Patched code sample

import ast
import os

# This file demonstrates a safe way to validate Python code, representing
# the fix for CVE-2026-33873. The vulnerability stemmed from executing
# LLM-generated code during a validation step. The fix is to validate
# the code's syntax without executing it.

def validate_code_safely(code_string: str) -> bool:
    """
    Validates Python code by parsing it into an Abstract Syntax Tree (AST).
    This method is safe as it only checks for syntactic validity and does
    not execute any part of the code, thus preventing remote code execution.

    This represents the fixed approach.

    Args:
        code_string: A string containing Python code to validate.

    Returns:
        True if the code is syntactically valid Python, False otherwise.
    """
    try:
        ast.parse(code_string)
        return True
    except SyntaxError as e:
        print(f"Code validation failed with a syntax error: {e}")
        return False


def validate_code_vulnerable(code_string: str) -> bool:
    """
    -- VULNERABLE IMPLEMENTATION (FOR DEMONSTRATION ONLY) --
    This function "validates" code by executing it, which is the root cause
    of the vulnerability. An attacker can provide malicious code that will
    be run on the server.
    """
    print("Executing code in a vulnerable manner...")
    try:
        # DANGER: exec() runs the untrusted code from the LLM.
        # The CVE describes a scenario where generated classes were instantiated,
        # leading to the execution of code within their __init__ methods.
        exec(code_string, {})
        return True
    except Exception as e:
        print(f"Code execution failed: {e}")
        return False

if __name__ == '__main__':
    # This malicious payload would be generated by an attacker-influenced LLM.
    # It creates a file named 'pwned.txt' on the server.
    malicious_code = """
import os

print("--- Malicious code is executing ---")

class MaliciousAgent:
    def __init__(self):
        # This code runs when the class is instantiated,
        # which happened during the vulnerable validation phase.
        print("--- Exploiting vulnerability: writing to a file. ---")
        with open("pwned.txt", "w") as f:
            f.write("This server has been compromised by CVE-2026-33873 exploit.")

# Instantiating the class triggers the malicious __init__ method.
MaliciousAgent()
"""

    print("--- 1. Demonstrating the VULNERABLE validation method ---")
    if os.path.exists("pwned.txt"):
        os.remove("pwned.txt")

    result_vulnerable = validate_code_vulnerable(malicious_code)
    print(f"Vulnerable validation result: {result_vulnerable}")

    if os.path.exists("pwned.txt"):
        print("VULNERABILITY CONFIRMED: 'pwned.txt' was created by the validation function.\n")
        os.remove("pwned.txt")
    else:
        print("Vulnerability could not be confirmed (this should not happen with the vulnerable function).\n")

    print("-" * 50)

    print("\n--- 2. Demonstrating the FIXED validation method ---")
    if os.path.exists("pwned.txt"):
        os.remove("pwned.txt")

    # The safe function is called. It will parse the code but not execute it.
    result_fixed = validate_code_safely(malicious_code)
    print(f"Safe validation result: {result_fixed}")

    if os.path.exists("pwned.txt"):
        print("FIX FAILED: 'pwned.txt' was created. The fix is not working.")
        os.remove("pwned.txt")
    else:
        print("FIX CONFIRMED: 'pwned.txt' was NOT created. The code was validated without being executed.")

    print("\n--- 3. Demonstrating the FIXED method with invalid syntax ---")
    invalid_code = "class MyAgent: def __init__(self) print('invalid')"
    result_invalid = validate_code_safely(invalid_code)
    print(f"Safe validation result for invalid code: {result_invalid}")