Secure Coding: Best Practices zum Einsatz von Java NIO gegen Path Traversal

 Path basePath = Paths.get("/var/www/uploads").normalize();

String userInput = request.getParameter("file");
Path resolvedPath = basePath.resolve(userInput);

Path normalizedPath = resolvedPath.normalize();

if (!normalizedPath.startsWith(basePath)) {
  throw new SecurityException("Invalid file path: path traversal attempt detected.");
   }

import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;
import java.io.IOException;

public class SecureFileHandler {

    /**
     * Creates a directory with secure permissions.
     *
     * @param dirPath The path of the directory to create.
     * @throws IOException if an I/O error occurs.
     */
    public static void createSecureDirectory(Path dirPath) throws IOException {
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxr-x---");
        FileAttribute<Set<PosixFilePermission>> attr 
                = PosixFilePermissions.asFileAttribute(perms);
        Files.createDirectories(dirPath, attr);
    }

    /**
     * Example usage of creating a secure directory.
     *
     * @param args Command line arguments.
     */
    public static void main(String[] args) {
        Path dirPath = Paths.get("/var/www/uploads");
        try {
            createSecureDirectory(dirPath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.io.IOException;
import java.util.Set;

public class SecureFileHandler {

    /**
     * Sets secure permissions for a file.
     *
     * @param filePath The path of the file.
     * @throws IOException if an I/O error occurs.
     */
    public static void setSecureFilePermissions(Path filePath) throws IOException {
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-r-----");
        Files.setPosixFilePermissions(filePath, perms);
    }

    /**
     * Example usage of setting secure file permissions.
     *
     * @param args Command line arguments.
     */
    public static void main(String[] args) {
        Path filePath = Paths.get("/var/www/uploads/example.txt");
        try {
            setSecureFilePermissions(filePath);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.nio.file.*;
import java.nio.file.attribute.PosixFilePermissions;
import java.nio.file.attribute.PosixFilePermission;
import java.io.IOException;
import java.util.Set;

public class SecureFileHandler {

    /**
     * Checks if a file has the required permissions.
     *
     * @param filePath The path of the file.
     * @param requiredPerms The required permissions.
     * @return True if the file has the required permissions, false otherwise.
     * @throws IOException if an I/O error occurs.
     */
    public static boolean hasRequiredPermissions(Path filePath, 
                                                                                     Set<PosixFilePermission> requiredPerms) 
                throws IOException {
        Set<PosixFilePermission> perms = Files.getPosixFilePermissions(filePath);
        return perms.containsAll(requiredPerms);
    }

    /**
     * Example usage of checking file permissions.
     *
     * @param args Command line arguments.
     */
    public static void main(String[] args) {
        Path filePath = Paths.get("/var/www/uploads/example.txt");
        Set<PosixFilePermission> requiredPerms = PosixFilePermissions.fromString("rw-r-----");
        try {
            if (hasRequiredPermissions(filePath, requiredPerms)) {
                System.out.println("File has the required permissions.");
            } else {
                System.out.println("File does not have the required permissions.");
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;

public class SecureSymlinkHandler {

    /**
     * Checks if the given path is a symbolic link.
     *
     * @param path The path to check.
     * @return True if the path is a symbolic link, false otherwise.
     * @throws IOException if an I/O error occurs.
     */
    public static boolean isSymlink(Path path) throws IOException {
        return Files.isSymbolicLink(path);
    }

    /**
     * Safely deletes a file without following symbolic links.
     *
     * @param path The path to the file to delete.
     * @throws IOException if an I/O error occurs.
     */
    public static void safeDelete(Path path) throws IOException {
        if (isSymlink(path)) {
            throw new SecurityException("Refusing to delete symbolic link: " + path);
        }
        Files.delete(path);
    }

    /**
     * Safely reads a file's attributes without following symbolic links.
     *
     * @param path The path to the file.
     * @return The file's attributes.
     * @throws IOException if an I/O error occurs.
     */
    public static BasicFileAttributes safeReadAttributes(Path path) throws IOException {
        return Files.readAttributes(path, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS);
    }

    public static void main(String[] args) {
        Path path = Paths.get("/var/www/uploads/example.txt");
        try {
            if (isSymlink(path)) {
                System.out.println("Path is a symbolic link.");
            } else {
                System.out.println("Path is not a symbolic link.");
                BasicFileAttributes attrs = safeReadAttributes(path);
                System.out.println("File size: " + attrs.size());
                safeDelete(path);
                System.out.println("File deleted safely.");
            }
        } catch (IOException | SecurityException e) {
            e.printStackTrace();
        }
    }
}

import java.nio.file.*;
import java.io.IOException;

public class SecureSymlinkHandler {

    /**
     * Validates that the symlink's target is within the allowed base directory.
     *
     * @param symlink The symbolic link to validate.
     * @param baseDir The allowed base directory.
     * @throws IOException if an I/O error occurs or if validation fails.
     */
    public static void validateSymlinkTarget(Path symlink, Path baseDir) throws IOException {
        if (!Files.isSymbolicLink(symlink)) {
            throw new IllegalArgumentException("Path is not a symbolic link: " + symlink);
        }
        Path target = Files.readSymbolicLink(symlink).normalize();
        Path resolvedTarget = baseDir.resolve(target).normalize();

        if (!resolvedTarget.startsWith(baseDir)) {
            throw new SecurityException("Invalid symlink target: " + resolvedTarget);
        }
    }

    public static void main(String[] args) {
        Path symlink = Paths.get("/var/www/uploads/symlink");
        Path baseDir = Paths.get("/var/www/uploads").normalize();
        try {
            validateSymlinkTarget(symlink, baseDir);
            System.out.println("Symlink target is valid and within the allowed base directory.");
        } catch (IOException | SecurityException e) {
            e.printStackTrace();
        }
    }
}

import java.nio.file.*;
import java.util.Set;
import java.util.HashSet;
import java.util.logging.Logger;
import java.io.IOException;
import java.util.regex.Pattern;

public class SecureInputValidator {

    private static final Logger logger = Logger.getLogger(SecureInputValidator.class.getName());
    private static final Set<String> ALLOWED_EXTENSIONS = new HashSet<>();

    static {
        ALLOWED_EXTENSIONS.add(".txt");
        ALLOWED_EXTENSIONS.add(".jpg");
        ALLOWED_EXTENSIONS.add(".png");
        ALLOWED_EXTENSIONS.add(".pdf");
    }

    /**
     * Validates the user-provided file name against a whitelist of allowed characters and extensions.
     *
     * @param fileName The user-provided file name.
     * @throws IllegalArgumentException if the file name is invalid.
     */
    public static void validateFileName(String fileName) throws IllegalArgumentException {
        if (fileName == null || fileName.isEmpty()) {
            throw new IllegalArgumentException("File name cannot be null or empty.");
        }

        // Check for invalid characters
        Pattern pattern = Pattern.compile("[^a-zA-Z0-9._-]");
        if (pattern.matcher(fileName).find()) {
            throw new IllegalArgumentException("File name contains invalid characters.");
        }

        // Check for allowed file extensions
        boolean validExtension = ALLOWED_EXTENSIONS.stream().anyMatch(fileName::endsWith);
        if (!validExtension) {
            throw new IllegalArgumentException("File extension is not allowed.");
        }
    }

    /**
     * Validates the user-provided path to ensure it stays within the base directory.
     *
     * @param baseDir The base directory.
     * @param userInput The user-provided input.
     * @return The validated and normalized path.
     * @throws SecurityException if a path traversal attempt is detected.
     * @throws IllegalArgumentException if the file name is invalid.
     * @throws IOException if an I/O error occurs.
     */
    public static Path getSecureFilePath(String baseDir, String userInput) throws SecurityException, IllegalArgumentException, IOException {
        validateFileName(userInput);

        // Normalize the base directory
        Path basePath = Paths.get(baseDir).normalize();

        // Resolve the user input against the base directory and normalize the result
        Path resolvedPath = basePath.resolve(userInput).normalize();

        // Validate that the resolved path starts with the base directory
        if (!resolvedPath.startsWith(basePath)) {
            logSuspiciousActivity(userInput);
            throw new SecurityException("Invalid file path: path traversal attempt detected.");
        }

        return resolvedPath;
    }

    /**
     * Logs suspicious activity for further analysis.
     *
     * @param userInput The suspicious user input.
     */
    private static void logSuspiciousActivity(String userInput) {
        logger.warning("Suspicious file access attempt: " + userInput);
    }

    /**
     * Example usage of the secure file path validation.
     *
     * @param args Command line arguments.
     */
    public static void main(String[] args) {
        String baseDir = "/var/www/uploads";
        String userInput = "example.txt";
        try {
            Path filePath = getSecureFilePath(baseDir, userInput);
            System.out.println("Validated file path: " + filePath);
        } catch (SecurityException | IllegalArgumentException | IOException e) {
            e.printStackTrace();
        }
    }
}