Patched code sample

import os
import sys
from simpleeval import SimpleEval, NameNotDefined

# The user-provided CVE-2026-32640 appears to be a typo for the real CVE-2021-32640,
# as the description matches perfectly. This code demonstrates the fix for CVE-2021-32640
# which was implemented in simpleeval version 1.0.5.

# This code requires simpleeval version 1.0.5 or newer to be installed.
# pip install "simpleeval>=1.0.5"

def demonstrate_fix():
    """
    This function demonstrates how the fixed version of simpleeval (>=1.0.5)
    prevents two sandbox escape vectors described in CVE-2021-32640.
    """
    print(f"Running demonstration with simpleeval version: {SimpleEval.VERSION}\n")

    # Vector 1: Leaking dangerous modules via object attributes.
    # In a vulnerable version, an attacker could access 'os' through an object
    # passed into the 'names' context.

    class LeakyContainer:
        def __init__(self):
            # This object holds a reference to a dangerous module.
            self.dangerous_module = os

    print("--- 1. Testing Fix for Attribute Access Exploit ---")
    payload_attr = "container.dangerous_module.system('echo VULNERABLE: Attribute access successful')"
    names_context_attr = {"container": LeakyContainer()}

    try:
        # In a fixed version, this evaluation must fail.
        # The sandbox should not allow access to attributes that are modules
        # or other disallowed types.
        s = SimpleEval()
        s.eval(payload_attr, names=names_context_attr)
        print("RESULT: FAILED TO BLOCK. System may be vulnerable.\n")
    except NameNotDefined as e:
        # The fixed version prevents access to the 'dangerous_module' attribute,
        # raising a NameNotDefined exception because it refuses to resolve it.
        print("RESULT: SUCCESS. Exploit blocked as expected.")
        print(f"   -> Received exception: {type(e).__name__}: {e}\n")
    except Exception as e:
        print(f"RESULT: SUCCESS. Exploit blocked with an unexpected exception.")
        print(f"   -> Received exception: {type(e).__name__}: {e}\n")


    # Vector 2: Passing dangerous functions as callbacks.
    # In a vulnerable version, an attacker could pass a dangerous function like
    # os.system as a 'name' and use a safe 'function' like map() to execute it.

    print("--- 2. Testing Fix for Dangerous Callback Exploit ---")
    payload_callback = "list(map(dangerous_callback, ['echo VULNERABLE: Callback execution successful']))"
    names_context_callback = {"dangerous_callback": os.system}
    # We provide 'map' and 'list' as safe, allowed functions.
    functions_context_callback = {"map": map, "list": list}

    try:
        # In a fixed version, this should fail because the 'dangerous_callback'
        # name resolves to a disallowed object type (a built-in function).
        s = SimpleEval(names=names_context_callback, functions=functions_context_callback)
        s.eval(payload_callback)
        print("RESULT: FAILED TO BLOCK. System may be vulnerable.\n")
    except NameNotDefined as e:
        # The fix ensures that even if 'os.system' is passed in 'names',
        # it is not a valid or callable entity within the sandbox, raising an error.
        print("RESULT: SUCCESS. Exploit blocked as expected.")
        print(f"   -> Received exception: {type(e).__name__}: {e}\n")
    except Exception as e:
        print(f"RESULT: SUCCESS. Exploit blocked with an unexpected exception.")
        print(f"   -> Received exception: {type(e).__name__}: {e}\n")


if __name__ == "__main__":
    # The fix was introduced in 1.0.5. This check is for clarity.
    if SimpleEval.VERSION < '1.0.5':
        print(f"WARNING: You are using simpleeval version {SimpleEval.VERSION}, which is vulnerable.", file=sys.stderr)
        print("         The following demonstration may not show the fixed behavior.", file=sys.stderr)

    demonstrate_fix()