Patched code sample

import os

# --- The Fix for a vulnerability like CVE-2026-35002 ---
# The vulnerability stems from using eval() on user-controllable input.
# The fix is to replace the dangerous eval() call with a safe lookup
# mechanism, such as a dictionary acting as an allow-list (safelist).

# 1. Define a safelist of allowed, primitive types.
# This ensures that only expected and safe type names are processed.
ALLOWED_TYPES = {
    'str': str,
    'int': int,
    'float': float,
    'bool': bool,
}

def fixed_model_executor(function_call):
    """
    A corrected version of a model execution component that is not
    vulnerable to arbitrary code execution.
    """
    processed_args = {}
    arguments = function_call.get('arguments', [])

    for arg in arguments:
        field_type_str = arg.get('field_type')
        value = arg.get('value')
        arg_name = arg.get('name')

        # --- VULNERABILITY MITIGATION ---
        # Instead of using eval(field_type_str), we safely look up the
        # type in our predefined safelist.
        type_class = ALLOWED_TYPES.get(field_type_str)

        if type_class is None:
            # If the provided field_type is not in our safelist, we
            # reject it and raise an error, preventing the attack.
            raise TypeError(f"Unsupported or malicious field_type: '{field_type_str}'")

        try:
            # Safely cast the value to the allowed type.
            processed_args[arg_name] = type_class(value)
            print(f"Successfully processed argument '{arg_name}' with value '{value}' as type {type_class.__name__}")
        except (ValueError, TypeError):
            raise ValueError(f"Could not cast value '{value}' to type {field_type_str}")

    return processed_args

# --- Demonstration ---

if __name__ == '__main__':
    # A legitimate call that should be processed correctly.
    legitimate_function_call = {
        'name': 'update_user',
        'arguments': [
            {'name': 'user_id', 'value': '12345', 'field_type': 'int'},
            {'name': 'is_active', 'value': 'True', 'field_type': 'bool'}
        ]
    }

    print("--- Testing with legitimate input ---")
    try:
        result = fixed_model_executor(legitimate_function_call)
        print(f"Success. Processed arguments: {result}\n")
    except (TypeError, ValueError) as e:
        print(f"An unexpected error occurred: {e}\n")


    # A malicious call attempting to execute arbitrary code.
    # The 'field_type' contains a payload that would be executed by eval().
    malicious_function_call = {
        'name': 'exploit',
        'arguments': [{
            'name': 'payload',
            'value': 'ignored',
            'field_type': "__import__('os').system('echo VULNERABILITY EXPLOITED')"
        }]
    }

    print("--- Testing with malicious input ---")
    try:
        fixed_model_executor(malicious_function_call)
    except (TypeError, ValueError) as e:
        # The expected outcome: The fixed code catches the malicious 'field_type'
        # and raises a TypeError instead of executing the payload.
        print(f"Attack blocked. The code raised the following error as expected: {e}")