Vulnerable code sample

import os
import sys

# This class is a simplified representation of the vulnerable PySyft server
# environment before the fix for CVE-2026-31220.
class VulnerableSyftServer:

    def __init__(self):
        # In a real scenario, this would be a database of user-submitted functions
        # that have been approved by an administrator.
        self.approved_user_functions = {}

    # This simulates an API endpoint where a low-privileged user submits Python code.
    # The 'code_string' would be part of the request body.
    def api_submit_code_for_approval(self, function_id, code_string):
        print(f"[Server] Received code for '{function_id}'. Assuming it passed a flawed human approval process.")
        # The core of the issue is that the approval process does not perform
        # any automated security scanning for dangerous code.
        self.approved_user_functions[function_id] = code_string

    # This simulates a request to execute a previously approved function.
    # This is where the remote code execution vulnerability is triggered.
    def api_execute_function(self, function_id):
        if function_id not in self.approved_user_functions:
            print(f"[Server] Error: Function '{function_id}' not found.")
            return

        code_to_run = self.approved_user_functions[function_id]
        print(f"[Server] EXECUTING user-submitted code for '{function_id}'...")

        try:
            # THE VULNERABILITY: The server uses 'exec()' to run the user's
            # code string. There is no sandboxing or isolation, so the code
            # runs with the same permissions as the server process itself.
            execution_scope = {}
            exec(code_to_run, globals(), execution_scope)
            print("[Server] Execution finished.")

        except Exception as e:
            print(f"[Server] An error occurred during execution: {e}")


# --- Attacker's Interaction Simulation ---

# 1. The attacker crafts a malicious Python code string. This payload, when
#    executed, will import the 'os' module and create a file on the server's
#    filesystem, demonstrating a successful remote code execution.
attacker_code_payload = """
import os

print(">>> [ATTACKER's CODE] Hello from the server's process!")
print(">>> [ATTACKER's CODE] I can access the filesystem and run commands.")
os.system('echo "Server has been compromised" > pwned.txt')
print(">>> [ATTACKER's CODE] 'pwned.txt' has been created on the server.")
"""

# 2. The simulation starts. We instantiate the vulnerable server.
vulnerable_server = VulnerableSyftServer()

# 3. The attacker submits their malicious code via the API. The server's
#    flawed approval mechanism accepts it.
function_name = "user_data_processor_v1"
vulnerable_server.api_submit_code_for_approval(
    function_id=function_name,
    code_string=attacker_code_payload
)

print("-" * 30)

# 4. At a later time, a legitimate-looking request is made to execute the
#    function, which now contains the attacker's payload.
vulnerable_server.api_execute_function(function_id=function_name)

print("-" * 30)

# 5. We verify that the attack was successful by checking for the file.
if os.path.exists("pwned.txt"):
    print("[VERIFICATION] SUCCESS: The file 'pwned.txt' was created by the payload.")
    with open("pwned.txt", "r") as f:
        print(f"[VERIFICATION] File content: '{f.read().strip()}'")
    os.remove("pwned.txt") # Clean up the created file
else:
    print("[VERIFICATION] FAILED: The payload did not execute as expected.")