Patched code sample

import ast
import json
import os

# This code demonstrates a secure way to handle configuration data that
# might otherwise be processed by a dangerous function like eval().
# The vulnerability CVE-2025-14927 is hypothetical, but this pattern
# represents a real-world fix for the described flaw.

def convert_sew_d_config_fixed(malicious_checkpoint_config: str):
    """
    Safely converts a model configuration from a JSON string.

    This function represents the fix for a code injection vulnerability.
    Instead of using `eval()` on user-controlled strings from a config file,
    it uses `ast.literal_eval()`, which only evaluates static literals
    (strings, numbers, tuples, lists, dicts, booleans, None) and raises an
    error for any other content, such as function calls or expressions.

    Args:
        malicious_checkpoint_config: A JSON string representing the
                                     configuration from a malicious checkpoint.
    """
    print("--- Attempting to convert a potentially malicious config ---")
    try:
        config = json.loads(malicious_checkpoint_config)
        
        new_config = {}
        
        # Safely copy over expected values
        if "model_type" in config:
            new_config["model_type"] = config["model_type"]
        
        # --- THE FIX IS APPLIED HERE ---
        # The original vulnerable code would have used `eval()` on a user-controlled
        # string, like this:
        #
        # VULNERABLE: new_config["some_value"] = eval(config.get("dynamic_key"))
        #
        # The fix is to use a safe parser like `ast.literal_eval`.
        
        dynamic_value_str = config.get("some_dynamic_parameter")
        
        if dynamic_value_str:
            print(f"Processing dynamic parameter: '{dynamic_value_str}'")
            try:
                # ast.literal_eval will safely parse Python literals.
                # It will raise a ValueError if the string contains code,
                # function calls, or other non-literal expressions.
                new_config["some_value"] = ast.literal_eval(dynamic_value_str)
                print("SUCCESS: Parameter was a safe literal.")
            except (ValueError, TypeError, SyntaxError, MemoryError, RecursionError) as e:
                # This block is executed for the malicious payload, preventing RCE.
                print(f"SAFE ABORT: The parameter is not a valid literal. Error: {e}")
                print("Malicious code execution was prevented.")
                # Handle the error, e.g., by using a default value or raising an exception.
                raise ValueError("Invalid and potentially malicious configuration value detected.")
        
        return new_config

    except json.JSONDecodeError:
        print("Error: Invalid JSON in config.")
        return None
    except Exception as e:
        print(f"An error occurred during conversion: {e}")
        return None


if __name__ == '__main__':
    # This represents the content of a malicious 'config.json' file
    # provided by an attacker. The 'some_dynamic_parameter' field contains
    # a payload intended for remote code execution.
    malicious_config_payload = json.dumps({
        "model_type": "sew-d",
        "hidden_size": 768,
        "some_dynamic_parameter": "__import__('os').system('echo VULNERABILITY EXPLOITED')"
    })

    # A config with a safe, legitimate literal value for comparison.
    safe_config_payload = json.dumps({
        "model_type": "sew-d",
        "hidden_size": 768,
        "some_dynamic_parameter": "{'key': 'value', 'num': 123}"
    })
    
    # --- DEMONSTRATION OF THE FIX ---

    print("1. Processing a SAFE configuration payload...")
    # This will succeed because the string is a valid literal.
    try:
        converted_safe_config = convert_sew_d_config_fixed(safe_config_payload)
        if converted_safe_config:
            print("Safe config processed successfully.")
            print("Result:", converted_safe_config)
    except ValueError as e:
        print(f"Caught expected error: {e}")

    print("\n" + "="*50 + "\n")

    print("2. Processing the MALICIOUS configuration payload...")
    # This will fail safely because ast.literal_eval refuses to execute the code.
    # The `os.system` call will NOT be executed.
    try:
        converted_malicious_config = convert_sew_d_config_fixed(malicious_config_payload)
        if converted_malicious_config is None:
             print("Malicious config processing failed as expected.")
    except ValueError as e:
        print(f"Caught expected error, confirming the fix works: {e}")
    
    print("\nConclusion: The fix correctly identified and blocked the malicious payload.")