Unauthenticated terminal WebSocket RCE in Marimo

The repository contains one standalone Python exploit client, an MIT LICENSE, and a README documenting the claimed vulnerability and sample terminal session. CVE-2026-39987.py connects directly to a configurable Marimo terminal WebSocket endpoint without supplying credentials, cookies, or authentication tokens. Its default route is /terminal/ws over wss on port 443. It sets configurable Host and Origin handshake values and disables certificate verification and hostname checking for TLS connections. After a successful WebSocket upgrade, a daemon thread forwards standard input to the terminal, converting newline characters to carriage returns; callbacks print received text or decoded binary output and report connection errors or closure. The script does not verify the product version or prove shell access before announcing that the shell is opened, so a successful handshake alone is not evidence of command execution. The README attributes the issue to CVE-2026-39987 and Marimo versions below 0.23.0, but neither claim is independently established by the supplied files. The implementation is a plausible exploitation client for an exposed unauthenticated terminal, rather than a detection-only script, and contains no apparent destructive decoy or exfiltration destination. No hardcoded execution payload is supplied, so it is classified as POC. Repository URL, git reference, and archive size were not provided; empty strings and zero represent unavailable repository metadata. The listed file sizes total 6,027 bytes.

This two-file repository contains a README and a Python proof of concept targeting the claimed CVE-2026-39987 in Marimo. The sole executable, exploit.py, uses websocket-client to establish a TLS WebSocket connection to a user-supplied domain at wss://<domain>/terminal/ws. It explicitly disables TLS certificate verification, consumes one initial server message identified as the terminal prompt, then injects a shell command through the WebSocket. The injected command is an interactive sh reverse shell using /dev/tcp and attacker-controlled --reverse-shell IP and --port values. The script asks the operator to confirm that a netcat listener is already open, prints received WebSocket data, and closes after seeing a '$' character. The README describes the unauthenticated terminal exposure, dependency installation, and intended authorized-testing use. Although it mentions a simple test-command mode and test.py, neither is present; the supplied code exclusively sends the reverse-shell payload.

This five-file Python repository documents and implements an HTB Cohort attack chain. README.md describes SSRF against Flask /api/validate to discover an internal nginx vhost, unauthenticated Marimo terminal WebSocket access (CVE-2026-39987), and local PackageKit privilege escalation (CVE-2026-41651). scripts/marimo_shell.py connects to wss://<target>/terminal/ws while forcing the discovered internal Host header, yielding an interactive shell. scripts/cve-2026-41651_gio.py is the intended working local privilege-escalation exploit: it creates a PackageKit transaction on the system D-Bus, queues SIMULATE then non-simulated InstallFiles requests, flushes them as one batch, and polls for a SUID bash created by an externally prepared malicious DEB. scripts/cve-2026-41651_pydbus.py is retained as a failed first attempt because python-dbus serializes the asynchronous calls into separate writes and normally loses the race. No DEB payload-generation code is included, but the README specifies the post-install SUID-bash payload.

This two-file repository contains a Python proof-of-concept and supporting README for an alleged pre-authentication RCE affecting marimo's terminal WebSocket endpoint. `exploit.py` accepts a base WebSocket URL and optional command, appends `/terminal/ws`, and connects using the Python `websockets` library without a token, cookie, or Authorization header. After connection, it writes raw terminal input containing an execution marker, `id`, `uname -a`, and an operator-supplied shell command followed by carriage return. It collects PTY output and prints the section beginning at the marker. The exploit is operational rather than merely a detector because it directly executes arbitrary supplied commands on the target. The README states the issue is caused by missing authentication checks on the terminal WebSocket while marimo is in EDIT mode, and identifies versions through 0.20.4 as affected and 0.23.0 as patched. The repository has no external exploitation framework dependency beyond the standard asyncio runtime and the third-party `websockets` package.

This two-file repository contains a Python proof-of-concept exploit and supporting README for an alleged Marimo pre-authentication RCE tracked as CVE-2026-39987. The sole executable, exploit.py, uses websocket-client and optionally Rich for output. It parses a user-provided HTTP or HTTPS base URL, converts it to the corresponding WS/WSS target, and appends the terminal WebSocket path /terminal/ws. The script accepts listener host/port, timeout, retry, SSL-validation, and verbosity controls; its workflow is designed to create a local listener, establish a WebSocket terminal session, and leverage command execution via the exposed PTY to produce a reverse shell. README.md documents the claimed missing-authentication issue, expected patched behavior, operational examples, and remediation to Marimo 0.23.0 or later. No fixed victim URL, IP address, or hard-coded callback infrastructure is present; target and callback values are operator controlled.

This two-file proof-of-concept repository contains a Python 3 exploit client and supporting README documentation. CVE-2026-39987.py manually creates a TCP connection, wraps it in TLS for the default port 443 while disabling certificate validation, performs an HTTP WebSocket upgrade to /terminal/ws, then encodes and sends masked WebSocket text frames. It supports interactive mode by running a background frame reader and forwarding local input as CR-terminated commands, or a one-shot mode that submits command-line arguments and prints returned output. The README identifies the affected target as Marimo <= 0.20.4 and attributes the issue to a missing authentication check before the endpoint accepts a WebSocket connection and forks a PTY. The exploit is operational rather than framework-based: it has no hardcoded destructive command or callback infrastructure, but directly permits operator-selected arbitrary commands and interactive shell access.

This is a small standalone Python exploit repository containing one executable exploit (CVE-2026-39987.py), a detailed README, and requirements.txt. It uses the websocket-client library to connect to a target-derived terminal WebSocket endpoint. The URL normalizer strips any supplied scheme and path, retains the host and optional port, and constructs wss://<host>/terminal/ws by default; failed WSS connections are retried as ws://. After a configurable delay it drains the terminal banner, then either sends a selected command and collects output for a timeout period or leaves the connection open for an interactive PTY shell. It can read multiple targets from a local list file, disables TLS certificate validation unless --verify is given, and force-closes stalled sockets after output collection. The claimed vulnerability is a missing authentication validation on Marimo's /terminal/ws route that directly accepts a WebSocket and creates a PTY. The README identifies Marimo versions <= 0.20.4 as affected and 0.23.0 or later as fixed. The code is an active exploitation tool rather than a scanner or detection-only script; it contains no embedded destructive behavior, although its arbitrary-command interface can be used to run any command chosen by the operator.

This repository is a small standalone Go proof-of-concept exploit for CVE-2026-39987 affecting Marimo versions earlier than 0.23.0. The vulnerability is described as a pre-authentication remote code execution issue caused by missing authentication checks on the terminal WebSocket endpoint /terminal/ws. Repository structure is minimal: README.md documents the vulnerability and usage; cmd/cve-2026-39987/main.go is the CLI entry point; pkg/runner/runner.go contains the exploit logic; go.mod and go.sum define dependencies. There are only two code files, both in Go. The exploit flow is straightforward. main.go parses three operator-controlled options: target WebSocket URL, command string, and interactive mode. It then calls runner.NewConnect(). In runner.go, the exploit creates a Gorilla WebSocket client with TLS verification explicitly disabled via InsecureSkipVerify=true, allowing connections to HTTPS/WSS targets with invalid or self-signed certificates. It dials the operator-supplied target URL directly, with no authentication material added. Once connected, Run() starts a read loop that prints all terminal output received from the server. For input, it supports three modes: a single command mode using the -c argument, interactive stdin-driven mode using -i, and piped stdin mode. In all cases, commands are sent as WebSocket text messages with a trailing newline, and the tool automatically sends "exit\n" afterward to terminate the terminal session cleanly. This makes the exploit capable of one-shot command execution as well as interactive shell-like use over the vulnerable terminal channel. The exploit does not include post-exploitation automation, persistence, lateral movement, or a reverse shell payload. Its payload is simply arbitrary attacker-provided shell commands executed through the exposed terminal. Because it provides working command execution but relies on basic hardcoded operator input rather than a modular payload system, OPERATIONAL is the best maturity fit. Notable fingerprintable elements include the vulnerable endpoint path /terminal/ws, the expected target format ws(s)://host[:port]/terminal/ws, and the use of example commands such as uname -a, cat /etc/passwd, id, and whoami. No hardcoded victim IPs, domains, or C2 infrastructure are present; the target is entirely operator-supplied at runtime.

This repository is a small standalone Python PoC for CVE-2026-39987, described in the README as a Marimo pre-auth RCE issue. The repository contains one actual code file, one README, one license, and several PyCharm project metadata files under .idea/. The exploit logic is entirely in CVE-2026-39987-Poc.py. The script is not a scanner or detector; it is an interactive exploitation client. It uses the websocket Python library to connect directly to a target WebSocket terminal endpoint at wss://10.129.23.10/terminal/ws, optionally overriding the Host header with nb-1be3782a8afd3ad5.cohort.htb and setting the Origin header to https://nb-1be3782a8afd3ad5.cohort.htb. TLS certificate verification is explicitly disabled via ssl.CERT_NONE, which helps the PoC connect to targets using self-signed or otherwise invalid certificates. Operationally, the exploit establishes the WebSocket connection, starts a background receive loop in a daemon thread, prints all data returned by the server, and then accepts arbitrary operator input from stdin. Each entered command is sent to the remote endpoint with a trailing carriage return. This gives the user an interactive remote terminal session if the target is vulnerable and the endpoint is exposed without authentication. There is no embedded post-exploitation payload beyond operator-provided commands, no persistence, no lateral movement logic, and no automation for target discovery. As a result, this is best characterized as an operational PoC exploit client for manual exploitation rather than a weaponized framework module.

This repository is a small standalone Python proof-of-concept exploit for CVE-2026-39987 affecting Marimo. The repo contains one executable script (CVE-2026-39987.py), a README describing the vulnerability and usage, and a LICENSE file. The exploit is not part of a larger framework. The Python script uses the websocket client library to connect to a target-supplied WSS endpoint at /terminal/ws. Its core capability is unauthenticated remote command execution by sending newline-terminated commands over the WebSocket to a PTY-backed terminal exposed by the vulnerable application. It starts a receiver thread to continuously print server output, enabling either single-command execution or an interactive shell-like session. The script also supports disabling TLS certificate verification via --any-ssl, which is useful against self-signed or invalid certificates. Code structure is simple: recv_loop() continuously reads and prints messages from the socket; connect() builds the URL, establishes the WebSocket session, launches the receive thread, and either sends one command or enters an interactive input loop; main() parses CLI arguments and enforces that either command mode or interactive mode is selected. Although a --max-wait argument is defined, it is not actually used to control timing in the current implementation; non-interactive mode instead hardcodes a 5-second join timeout. Overall, this is a functional exploit rather than a detector. It directly targets an exposed unauthenticated terminal WebSocket in vulnerable Marimo deployments and provides practical post-exploitation capability in the form of arbitrary command execution and interactive remote shell access.

Small standalone Python PoC repository for CVE-2026-39987 targeting Marimo versions before 0.23.0. The repo contains one substantive code file, poc.py, plus README, requirements, license, and gitignore. The exploit is not part of a larger offensive framework. The main exploit logic in poc.py uses the Python websockets library to connect directly to a target WebSocket terminal endpoint, expected to be /terminal/ws. It disables TLS certificate validation for wss connections, then places the local terminal into raw mode to provide a low-latency interactive shell experience. This is a real exploitation tool rather than a scanner: once connected, it gives the operator direct command execution on the remote host through the exposed terminal service. Beyond shell access, the script implements practical post-exploitation helpers. perform_upload() reads a local file, base64-encodes it, splits it into chunks, and sends shell commands that reconstruct the file remotely using base64 -d and shell redirection. perform_download() sends a remote command that prints unique start/end markers and base64-encodes a requested remote file, then captures the output and decodes it locally. The README documents additional local control commands such as .upload, !upload, !download, and local exit commands. Fingerprintable targeting details are clearly documented in the README: vulnerable endpoint /terminal/ws, version/fingerprint endpoint /api/version, and favicon hash -1864630356 with corresponding Shodan and Censys queries. The exploit requires a reachable vulnerable Marimo deployment with no authentication protecting the terminal WebSocket. Successful exploitation yields unauthenticated interactive shell access and arbitrary file transfer capability, making this an operational PoC rather than a simple proof-of-concept or detection script.

This repository is a minimal proof-of-concept exploit for CVE-2026-39987, described as a marimo terminal WebSocket authentication bypass affecting versions before 0.23.0. The repository contains only two files: a README with vulnerability context and usage notes, and a single Python exploit script, exp.py. The script is the sole functional component and acts as a lightweight interactive WebSocket client aimed at the marimo terminal endpoint. The exploit flow is straightforward: it disables TLS certificate verification, opens a WebSocket connection to wss://<IP>/terminal/ws, sets custom Host and Origin headers, starts a background receiver thread to print server output, switches the local terminal into raw mode, and forwards local keystrokes one byte at a time to the remote endpoint. This effectively gives the operator an interactive remote terminal if the target accepts the unauthenticated connection. Notable operational details: the code contains placeholders (<REPLACE> and <IP>) and the README explicitly states it was used in a CTF and will not work out of the box without modification. There is no vulnerability detection logic, no post-exploitation automation, and no configurable payload beyond manual terminal interaction. Because it provides direct interactive access but remains hardcoded and incomplete, it is best classified as a POC rather than an operational or weaponized exploit.

This repository is a small standalone Python proof-of-concept for CVE-2026-39987, described as a pre-authentication RCE in Marimo affecting versions before 0.9.15. The repo contains only two files: a README with usage/advisory details and a single executable script, exploit.py. The script is the sole functional component and serves as the entry point. The exploit logic is straightforward: it accepts a target URL and optional command, normalizes the scheme, derives ws:// or wss:// based on the input scheme/port, appends the vulnerable /terminal/ws path if needed, and opens a WebSocket connection using websocket-client with TLS certificate verification disabled for HTTPS targets. After connecting, it drains any initial terminal output, sends the supplied command followed by a newline, waits briefly, then reads and prints all returned output. The default command is id && whoami && hostname, but the operator can provide any shell command, making this an arbitrary command execution POC. There is no scanning, brute forcing, persistence, lateral movement, or post-exploitation automation. It is not a detection-only script; it actively attempts exploitation and returns command output. Because it provides a real command-execution payload but remains simple and manually operated, the maturity is best classified as OPERATIONAL rather than WEAPONIZED.

This repository is a small standalone exploit PoC for CVE-2026-39987, a pre-authentication RCE in Marimo's terminal WebSocket. The repo contains 3 files: a GPL license, a detailed README describing the vulnerability and usage, and a single Python exploit script. Despite the README mentioning penelope.py, that file is not present in the provided repository snapshot, so reverse-shell helper integration is referenced but incomplete in this archive. The main exploit logic is in exploit.py. It normalizes a supplied target URL into ws:// or wss:// and appends /terminal/ws, then uses the websocket-client library to open a WebSocket connection directly to the vulnerable terminal endpoint. The script supports two primary modes: (1) one-shot command execution, where it sends an arbitrary command followed by a newline and prints returned PTY output after filtering prompts; and (2) reverse-shell mode, where it constructs a Python3 PTY reverse shell payload, base64-encodes it, and sends a detached nohup/setsid/bash wrapper so the shell persists after the WebSocket closes. Operationally, the exploit targets Marimo instances exposing the terminal WebSocket without authentication. The README states the vulnerable condition is edit mode plus PTY support, with affected versions listed as Marimo <= 0.20.4 and fixed in 0.23.0+. The exploit does not perform version detection or vulnerability checks; it assumes the endpoint is reachable and vulnerable. It also disables TLS certificate verification for wss:// targets, which is useful for lab or self-signed environments. Notable capabilities include unauthenticated command execution, interactive shell access through the PTY-backed WebSocket, and persistence of a reverse shell callback over raw TCP. In Penelope mode, the script forks a child to deliver the payload after a short delay while the parent replaces itself with a local listener process bound by default to 0.0.0.0:4444. Overall, this is a real exploit, not merely a detector, and its purpose is to weaponize the exposed /terminal/ws endpoint into immediate shell access on vulnerable Marimo servers.

This repository is a small standalone Python exploit PoC for CVE-2026-39987, described as a pre-authentication remote code execution issue affecting Marimo versions earlier than 0.23.0. The repository contains one substantive code file (CVE-2026-39987.py), plus a README, dependency list, license, and an auxiliary Dork.txt file with internet-search fingerprints. The main exploit flow is straightforward: it normalizes the supplied target URL, optionally probes /favicon.ico and /api/version to confirm the application and extract a version string, then builds a WebSocket URL to /terminal/ws using ws:// or wss:// depending on the original scheme. If the target appears vulnerable or the operator uses --no-check, the script connects to the terminal WebSocket and attempts to execute attacker-supplied commands. Based on the README and visible code structure, it supports three operator modes: single command execution, pseudo-interactive shell access, and generated reverse shell execution. Notable exploit capabilities include unauthenticated command execution, interactive terminal-style access, and reverse shell payload generation using operator-provided callback IP and port. SSL certificate validation is explicitly disabled for HTTPS/WSS targets, improving compatibility against self-signed deployments. The script also includes dependency checks and user-facing CLI argument parsing, indicating it is intended for direct operational use rather than just demonstrating a minimal bug trigger. Fingerprintable target endpoints are concentrated around /api/version, /favicon.ico, and especially /terminal/ws, which is the exploitation path. The Dork.txt file is auxiliary reconnaissance material and contains multiple Shodan/FOFA/Censys search fingerprints; however, most of those appear generic and not specific to Marimo. Overall, this is a real exploit PoC rather than a detector, and its maturity is best classified as OPERATIONAL because it includes practical exploitation logic and payload support, but not a broader framework or highly modular payload system.

This repository is a small standalone proof-of-concept exploit for CVE-2026-39987, described here as a pre-authentication remote code execution issue in Marimo versions prior to 0.23.0. The main exploit is CVE-2026-39987-poc.py, a Python script using the websocket-client library. It accepts a target URL and an arbitrary command, converts http/https targets into ws/wss, connects to the target WebSocket terminal endpoint at /terminal/ws, drains initial PTY output, sends the supplied command with a newline, and prints returned output until timeout or marker text. Its core capability is unauthenticated remote command execution through an exposed terminal WebSocket, effectively yielding shell-like access with the privileges of the Marimo process. Repository structure is minimal: one Python exploit, a README documenting the vulnerability and usage, and a docker-vulnerable lab containing a Dockerfile and docker-compose.yml. The Docker lab installs marimo==0.22.3, exposes port 2718, binds to 0.0.0.0, and disables authentication/token protections, creating a reproducible vulnerable environment. The exploit is not part of a larger framework and is operational rather than weaponized: it supports arbitrary operator-supplied commands but does not include advanced payload staging, persistence, or automation beyond command execution. Fingerprintable targets and observables include the /terminal/ws endpoint, TCP port 2718, host binding 0.0.0.0, and filesystem paths used in examples and the lab such as /app/notebooks, /etc/passwd, /etc/os-release, and /root/.bash_history. Overall, the repository’s purpose is to demonstrate and validate unauthenticated WebSocket terminal access leading to RCE against vulnerable Marimo deployments.

This repository is a local Docker lab and exploit demonstration for CVE-2026-39987, a pre-authentication RCE in marimo’s terminal WebSocket endpoint /terminal/ws. The repo contains two containerized environments: a vulnerable marimo 0.20.4 instance under vuln/ and a patched marimo 0.23.0 instance under patched/, both launched with marimo edit in headless mode on container port 2718 and exposed locally as 127.0.0.1:8081 and 127.0.0.1:8082. The notebook files are minimal and exist only to start the marimo edit server. The exploit logic is in poc/poc.py and poc/rce_poc.py. poc.py is a constrained proof-of-execution script: it validates that the supplied base URL is localhost-only, converts it to a WebSocket URL ending in /terminal/ws, connects without authentication, sends a benign shell command sequence (id; whoami; hostname) bracketed by markers, receives PTY output, strips ANSI/control noise, and reports vulnerability if uid= appears in the captured output. This is a real exploit path because it performs unauthenticated command execution, not just detection. poc/rce_poc.py is a less restricted interactive client that connects to the same endpoint and provides an operator-driven shell-like interface over the WebSocket, making it more capable than the benign PoC. Repository structure is straightforward: docker-compose.yml orchestrates both services with localhost-only bindings and container hardening; vuln/ and patched/ each contain a Dockerfile and notebook; poc/ contains the exploit scripts and Python dependencies; README.md documents the vulnerability, setup, and expected behavior; SAFETY.md defines local-only guardrails. Overall, the repository’s purpose is to compare vulnerable versus patched behavior and demonstrate that unauthenticated access to /terminal/ws can yield command execution as the marimo process user.

This repository is a small self-contained exploit lab for CVE-2026-39987 affecting marimo. It contains four files: a Python exploit (`exploit.py`), a vulnerable target container definition (`Dockerfile.target`), a Docker Compose lab environment (`docker-compose.yml`), and a detailed walkthrough (`README.md`). The overall purpose is to reproduce and study a pre-authentication remote code execution condition caused by an authentication bypass on marimo's terminal WebSocket endpoint. The main exploit capability is in `exploit.py`. It connects directly to a user-supplied WebSocket URL, intended to be `ws://<target>:2718/terminal/ws`, using the `websocket-client` library. After connecting, it drains any initial PTY/banner output, then either: (1) sends a single shell command and returns the output (`exec` mode), or (2) provides an interactive shell loop (`shell` mode). The exploit does not perform authentication, token handling, or session negotiation; it relies entirely on the vulnerable endpoint accepting the WebSocket connection unauthenticated. Output parsing is basic but functional: it reads until timeout or until a shell prompt ending in `#` or `$` is observed. The target environment is intentionally configured to demonstrate impact clearly. `Dockerfile.target` installs `marimo==0.20.4`, creates a notebook directory under `/app/notebooks`, exposes TCP port 2718, and launches `marimo edit --host 0.0.0.0 --port 2718 --token .`. `docker-compose.yml` publishes port 2718 to the host and explicitly runs the target container as root, so successful exploitation yields root-level command execution inside the container. The README explains the vulnerability model: normal endpoints such as `/` and `/ws` enforce authentication, but `/terminal/ws` allegedly accepts WebSocket connections without validating auth when marimo is in edit mode and terminal support is enabled. The exploit therefore targets a web/network attack surface, specifically an unauthenticated WebSocket endpoint. This is a real exploit PoC rather than a detector: it provides direct command execution and an interactive shell, making it operational but not heavily weaponized.

This repository is a standalone Python exploit tool for CVE-2026-39987, described as an unauthenticated WebSocket pre-auth RCE in Marimo versions prior to 0.23.0. The repository is small and simple: one main Python script (CVE-2026-39987.py), a README with usage and vulnerability details, and a license file. No external exploit framework is used. The main script is an operational mass scanner/exploitation utility rather than a minimal proof of concept. It imports websockets, requests, asyncio, threading, and rich, indicating concurrent network exploitation with formatted console output. The code defines output artifacts under nx_output/ and uses worker threads to process many targets concurrently. Based on the visible constants and README, the exploit connects to the vulnerable /terminal/ws endpoint over ws:// or wss:// to obtain a PTY shell without authentication. Beyond initial shell access, the script contains environment profiles for multiple deployment types including Marimo, cPanel, Plesk, Apache, Nginx, and Python app environments. These profiles enumerate likely web roots, config directories, log locations, and credential files. The exploit appears designed to run post-compromise discovery commands through the shell to identify privilege level, enumerate notebooks and users, inspect SSH/config/log files, harvest tokens and credentials, and probe for databases. It also attempts a proof-of-write/web verification step by dropping a marker file such as Nx.py or Nx.php into likely web roots and then checking HTTP-accessible paths like /Nx.php or /api/files/Nx.py for the string "Nxploited". Fingerprintable targets and paths are abundant in the code: the primary network target is /terminal/ws, while many filesystem paths are hardcoded for enumeration and credential access, including /root/.my.cnf, /etc/mysql/debian.cnf, /etc/psa/.psa.shadow, /etc/apache2, /etc/nginx, /var/log/nginx, /var/log/apache2, /var/www/html, and /etc/shadow. The README also documents example target formats and the common Marimo port 2718. Overall, this is a real exploit repository with offensive capability: it provides unauthenticated remote command execution against vulnerable Marimo instances and automates extensive host discovery and data collection after access is obtained.

Repository contains three Python utilities, one README, and one HTML helper page. The core purpose is exploitation of an alleged Marimo pre-auth remote code execution issue via unauthenticated WebSocket access to /terminal/ws on port 2718. CVE-2026-39987_exploit.py is a simple interactive exploit that opens a ws:// or wss:// connection and forwards stdin/stdout for shell-like interaction. CVE-2026-39987_scanner.py is a more aggressive probe script that connects to the same endpoint and sends hardcoded commands to confirm execution, including sensitive file reads. exploit_fast.py is the most feature-rich implementation: it optionally checks /api/version, compares versions against <0.23.0, supports single-command execution, interactive mode, and reverse-shell payload generation. The payload format in exploit_fast.py differs from the simpler exploit/scanner by sending JSON objects with type=exec and command fields, suggesting either multiple protocol assumptions or inconsistent understanding of the target protocol. website.html appears to be a local command-reference UI rather than exploit logic. Overall, this is a standalone Python exploit repository, not tied to a major framework. It is operational because it includes working exploit routines and payload generation, but payload customization is basic and mostly operator-supplied. The repository also shows internal inconsistency in claimed affected versions (README says <=0.20.4 while exploit_fast.py checks <0.23.0), which reduces confidence in targeting accuracy.

Repository contains a Python proof-of-concept exploit and a Nuclei template for CVE-2026-39987, targeting Marimo versions earlier than 0.23.0. The main exploit script, CVE-2026-39987_PoC.py, performs optional passive checks against /favicon.ico and /api/version, then converts the supplied base URL into a ws:// or wss:// connection to /terminal/ws and uses that unauthenticated terminal WebSocket to execute attacker-supplied commands. The script supports three main modes: one-shot command execution, interactive shell mode, and reverse shell generation using an operator-supplied callback IP and port. SSL verification is disabled for HTTPS targets, and the script includes basic operator prompts and dependency checks. The repository also includes CVE-2026-39987_nuclei.yaml, which is a detection template rather than an exploit; it fingerprints Marimo via favicon hash -1864630356, extracts the version from /api/version, and checks whether /terminal/ws responds as a WebSocket endpoint. Supporting files include README.md with usage examples, impact notes, remediation guidance, and example commands, plus requirements.txt and a short installation/usage note. Overall, this is a functional operational PoC for unauthenticated remote command execution against exposed vulnerable Marimo instances, accompanied by a scanner template for identification.