Path Traversal Remediation

import os
from pathlib import Path

UPLOAD_DIR = Path('/var/www/uploads').resolve()

def safe_file_access(user_filename):
    """Safely access a file within the upload directory."""
    # Construct the full path
    requested_path = (UPLOAD_DIR / user_filename).resolve()
    
    # Verify path is within allowed directory
    if not str(requested_path).startswith(str(UPLOAD_DIR)):
        raise ValueError("Access denied: path traversal attempt")
    
    # Additional check: file must exist
    if not requested_path.is_file():
        raise FileNotFoundError("File not found")
    
    return requested_path

# Alternative: Use indirect references
FILE_MAPPING = {
    'doc1': '/var/www/uploads/document1.pdf',
    'doc2': '/var/www/uploads/document2.pdf',
}

def get_file_by_id(file_id):
    if file_id not in FILE_MAPPING:
        raise ValueError("Invalid file ID")
    return FILE_MAPPING[file_id]

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.nio.file.Paths;

public class SafeFileAccess {
    private static final String BASE_DIR = "/var/www/uploads";
    
    public static File safeGetFile(String userInput) throws IOException {
        // Resolve and canonicalize the path
        Path basePath = Paths.get(BASE_DIR).toRealPath();
        Path requestedPath = basePath.resolve(userInput).normalize().toRealPath();
        
        // Verify path is within base directory
        if (!requestedPath.startsWith(basePath)) {
            throw new SecurityException("Path traversal attempt detected");
        }
        
        return requestedPath.toFile();
    }
    
    // Alternative: Sanitize filename (remove path components)
    public static String sanitizeFilename(String filename) {
        return new File(filename).getName();  // Returns only the filename
    }
}

const path = require('path');
const fs = require('fs');

const BASE_DIR = '/var/www/uploads';

function safeFileAccess(userFilename) {
    // Resolve to absolute path
    const requestedPath = path.resolve(BASE_DIR, userFilename);
    
    // Normalize and check if within base directory
    const normalizedBase = path.normalize(BASE_DIR);
    const normalizedPath = path.normalize(requestedPath);
    
    if (!normalizedPath.startsWith(normalizedBase + path.sep)) {
        throw new Error('Access denied: path traversal attempt');
    }
    
    // Additional validation
    if (!fs.existsSync(requestedPath)) {
        throw new Error('File not found');
    }
    
    return requestedPath;
}

// Alternative: Use basename to strip directory components
function sanitizeFilename(filename) {
    return path.basename(filename);
}

<?php
define('BASE_DIR', '/var/www/uploads');

function safeFileAccess($userFilename) {
    // Build full path and resolve it
    $requestedPath = realpath(BASE_DIR . DIRECTORY_SEPARATOR . $userFilename);
    $basePath = realpath(BASE_DIR);
    
    // realpath returns false if file doesn't exist
    if ($requestedPath === false) {
        throw new Exception('File not found');
    }
    
    // Verify path is within base directory
    if (strpos($requestedPath, $basePath) !== 0) {
        throw new Exception('Access denied: path traversal attempt');
    }
    
    return $requestedPath;
}

// Alternative: Strip directory from filename
function sanitizeFilename($filename) {
    return basename($filename);
}
?>