Patched code sample

import os
import http.server
import socketserver
from urllib.parse import urlparse, parse_qs

# In a real application, this would be a configurable, secure directory.
# For this example, we create a temporary one.
LOG_ROOT = "/tmp/safe_log_root"

def create_safe_log_handler(user_provided_path):
    """
    Safely creates a log file handler, preventing path traversal.

    This function represents the fix for the path traversal vulnerability.
    The vulnerability was caused by directly using a user-provided path
    without validation. The fix involves the following steps:

    1.  Join the base log directory with the user-provided path.
    2.  Resolve the absolute, canonical path of the resulting target path.
        This collapses any directory traversal sequences (e.g., '../').
    3.  Verify that this resolved path is still located within the
        configured LOG_ROOT directory.
    4.  Only proceed with file operations if the path is confirmed to be safe.
    """
    # Ensure the base log directory exists
    os.makedirs(LOG_ROOT, exist_ok=True)

    # Resolve the absolute, canonical path of the safe base directory
    real_log_root = os.path.abspath(LOG_ROOT)

    # Combine the base directory with user input and resolve its absolute path
    # This step is crucial as os.path.abspath resolves '..' components.
    intended_path = os.path.join(real_log_root, user_provided_path)
    real_intended_path = os.path.abspath(intended_path)

    # --- THE FIX ---
    # Check if the resolved intended path is a sub-path of the resolved
    # safe base directory. `os.path.commonpath` is a robust way to verify
    # this. If the common path of the two is not the base directory itself,
    # it means the intended path has "escaped" the allowed directory.
    if os.path.commonpath([real_log_root, real_intended_path]) != real_log_root:
        # Path traversal detected, abort the operation.
        print(
            f"SECURITY ALERT: Path traversal attempt blocked.\n"
            f"  - Attacker input: '{user_provided_path}'\n"
            f"  - Attempted to write to: '{real_intended_path}'\n"
            f"  - Operation confined to: '{real_log_root}'"
        )
        return False

    # If the check passes, it is safe to proceed.
    try:
        os.makedirs(os.path.dirname(real_intended_path), exist_ok=True)
        with open(real_intended_path, "a") as f:
            f.write("Log data from a safe handler.\n")
        print(f"Success: Logged safely to '{real_intended_path}'")
        return True
    except OSError as e:
        print(f"Error: Could not write to file. {e}")
        return False

# --- Example Usage Demonstration ---
if __name__ == "__main__":
    print("--- Demonstrating Fix for Path Traversal ---")
    print(f"Configured log root: {LOG_ROOT}\n")

    # 1. Legitimate use case: creates a file within the allowed directory.
    print("Test 1: Legitimate filename")
    create_safe_log_handler("device1/telemetry.log")
    print("-" * 20)

    # 2. Malicious use case: attempts to write outside the log root.
    #    This attempt will be blocked by the security check.
    print("Test 2: Malicious path traversal input")
    # This path would resolve to /tmp/pwned.txt, which is outside /tmp/safe_log_root
    create_safe_log_handler("../../pwned.txt")
    print("-" * 20)
    
    # 3. Another legitimate but nested use case
    print("Test 3: Legitimate nested filename")
    create_safe_log_handler("mission_alpha/payload/stream.bin")
    print("-" * 20)