EQSTLab

Classification basis

The script actively exploits the vulnerability by sending a malicious payload to the target server to achieve remote code execution, as opposed to merely detecting or reporting the vulnerability.

Requirements

• Target Gitea instance must be vulnerable (versions 1.17 through 1.27.0).README.md:21-22
• Attacker must have write access to a repository on the target Gitea instance (e.g., via open registration).README.md:13README.md:50
• Attacker must provide valid credentials (username and password) for the target Gitea instance.poc.py:8-9
• A listener (e.g., netcat) must be running on a host reachable from the Gitea server to receive the reverse shell.README.md:70-72

Observed behavior

• Constructs a reverse shell command and embeds it in a Git hook script (payload withheld).poc.py:17-19
• Generates a Git patch that creates the hook file with executable permissions.poc.py:23-31
• Sends the same patch twice via HTTP POST to the Gitea diffpatch API endpoint to trigger the vulnerability.poc.py:41-44
• The second request may time out while the reverse shell is active, which the script treats as a possible success.poc.py:50-53

Observables

Reverse Shell

Payload withheldThe PoC script generates a reverse shell command to the attacker-controlled host and port, which is the stated purpose of the exploit.poc.py:17

Base64 Encoding

Payload withheldThe reverse shell command is base64-encoded before embedding in the hook, a common technique to avoid shell metacharacter issues, not an attempt at concealment.poc.py:18

Git Hook Installation

Payload withheldThe patch creates an executable post-index-change hook in the bare repository's working tree, which is the documented RCE mechanism.poc.py:24

Classification basis

The artifact contains a complete, self-contained Python script (`attacker/exploit.py`) that builds a malicious JAR, serves it, generates an exploit payload, and listens for a reverse shell. The README explicitly describes it as a PoC and provides step-by-step instructions for achieving remote code execution. This is code intended to exercise a vulnerability, not merely detect or report it.

Requirements

• Target application uses Fastjson 1.2.68–1.2.83 with default configuration (AutoType disabled) and parses attacker-controlled JSON.README.md:8-11README.md:31-33
• Target application is packaged as a Spring Boot executable fat-JAR.README.md:9README.md:33
• Attacker can reach the target over the network and the target can make outbound HTTP connections to the attacker's machine.README.md:50-51

Observed behavior

• Builds a JAR file containing a seed class and multiple payload classes. Each payload class has a static initializer (`<clinit>`) that executes a reverse shell command via `Runtime.getRuntime().exec`.attacker/exploit.py:76-128attacker/exploit.py:199-210
• Starts an HTTP server to serve the malicious JAR to the target.attacker/exploit.py:151-155attacker/exploit.py:221
• Constructs a JSON payload containing crafted `@type` values that cause Fastjson to fetch the attacker's JAR via `jar:http://` and then load classes via `jar:file:/proc/self/fd/` to achieve code execution.attacker/exploit.py:213-218
• Starts a TCP listener to accept the reverse shell connection from the compromised target.attacker/exploit.py:158-184attacker/exploit.py:239

Observables

Reverse Shell

Payload withheldThe exploit establishes a reverse shell to the attacker's machine, which is the intended outcome of the RCE PoC.attacker/exploit.py:199-201

Payload Generation

Payload withheldThe script builds a JAR with a class whose <clinit> method runs Runtime.exec() with the reverse shell command, triggered by Fastjson deserialization.attacker/exploit.py:76-128attacker/exploit.py:206-210

Http Server

Payload withheldThe script starts an HTTP server to deliver the JAR to the target, a necessary step in the exploit chain.attacker/exploit.py:151-155attacker/exploit.py:221

Ctf Flag

Payload withheldA CTF flag is placed in the Docker container, indicating the lab environment is a capture-the-flag exercise.Dockerfile:19

Classification basis

The artifact contains code that actively exploits the vulnerability by sending a crafted request to bypass authentication and access a protected resource. The Python script (poc.py) is designed to exercise the vulnerability, not merely detect it, and the README describes it as a 'PoC' that demonstrates the bypass.

Requirements

• A running Gitea instance with reverse-proxy authentication enabled and REVERSE_PROXY_TRUSTED_PROXIES set to '*'.README.md:10
• The attacker must be able to reach the Gitea backend directly or through a proxy that preserves the payload withheld header.README.md:22

Observed behavior

• The Dockerfile builds a Gitea 1.26.2 image with reverse-proxy authentication enabled and creates an admin user and a private repository containing a proof file.Dockerfile:3-9Dockerfile:26-32
• The Python script sends an HTTP GET request to the private proof file with the header 'payload withheld: gitea-admin' and checks if the response status is 200 and the body matches the expected proof string.poc.py:29-32poc.py:72-74poc.py:84-89
• If the bypass is successful, the script prints 'VULNERABLE' and the proof string, demonstrating unauthorized access to the private repository.poc.py:91-94

Observables

Url

Payload withheldTarget URL used by the PoC to interact with the local Gitea instance.poc.py:56

Http Header

Payload withheldThe header used to demonstrate the authentication bypass.poc.py:32

String

Payload withheldExpected proof string stored in the private repository to confirm successful exploitation.poc.py:20

Classification basis

The primary artifact poc.py contains code that actively exercises the vulnerability by sending malicious HTTP/2 requests to cause memory exhaustion and denial of service. It is not merely detecting or reporting the vulnerability; it is exploiting it.

Requirements

• Target must be running a vulnerable version of Apache HTTP Server (2.4.17 through 2.4.67) with mod_http2 enabled and h2c direct mode configured.README.md:24-25Dockerfile:1-14
• Network access to the target HTTP/2 service.poc.py:204-205

Observed behavior

• Establishes multiple HTTP/2 connections using h2c direct mode.poc.py:204-221
• Sends HPACK-encoded header blocks that expand into many cookie header fields on the server, causing repeated memory allocation during cookie merging.poc.py:76-90poc.py:257-258
• Uses HTTP/2 flow control (initial window size of 0 and periodic small window updates) to delay response transmission, keeping streams open and preventing memory release.poc.py:92-94poc.py:229-240poc.py:286-303
• Maintains connections for a configurable hold duration to sustain memory pressure.poc.py:286-303

Observables

Vulnerability Exploit

Payload withheldThe PoC targets a known Apache HTTP Server DoS vulnerability via HTTP/2 HPACK cookie header amplification.README.md:12-15poc.py:75-90

Network Behavior

Payload withheldThe PoC connects to a user-supplied target to send the DoS payload. This is expected exploit behavior, not a backdoor.poc.py:204-221poc.py:244-249

Command Line Interface

Payload withheldThe README instructs the user to run the PoC against a target server. No hidden or deceptive commands are present.README.md:61-70

Classification basis

The Python script `poc.py` actively constructs and sends SQL injection payloads to a vulnerable Ghost CMS instance to extract sensitive data (admin credentials, API secrets) and enumerate database contents. This constitutes exploitation, not mere detection or scanning. The README describes it as a 'PoC' that 'demonstrates how a public Content API request can be turned into a boolean-based database read primitive' and the code performs the actual data extraction.

Requirements

• A target Ghost CMS instance vulnerable to CVE-2026-26980 (versions >= 3.24.0, < 6.19.1) with a known public Content API key.README.md:14README.md:22-24poc.py:7
• The target must have two oracle tags named 'bacon' and 'chorizo' seeded in the database for the boolean-based extraction to function.README.md:155-158poc.py:30poc.py:176

Observed behavior

• Sends HTTP GET requests to the Ghost Content API endpoint `/ghost/api/content/tags/` with a crafted `filter` parameter containing a SQL injection payload in the `slug:[...]` filter.poc.py:15-18poc.py:21-30
• Uses a boolean-based blind SQL injection technique: the order of the returned tags ('bacon' first vs 'chorizo' first) reveals whether an injected SQL condition is true or false.poc.py:33-42README.md:155-158
• Extracts database values character by character using a prefix-based GLOB search, recovering admin email, admin name, admin API key ID, and admin API secret.poc.py:45-80poc.py:210-213
• Enumerates row counts for multiple database tables (settings, users, api_keys, posts, tags, posts_tags) using the same boolean oracle.poc.py:101-118poc.py:202-206

Observables

Exploit Behavior

Payload withheldThis is the normal, advertised exploit behavior for CVE-2026-26980 and does not constitute a backdoor.poc.py:1-237

Network Target

Payload withheldThe target is explicitly provided by the user; the script does not contain hardcoded exfiltration to an attacker-controlled server.poc.py:170

Hardcoded Credential

Payload withheldThis is a lab-specific Content API key used for the demonstration; it is not a backdoor credential and is documented in the README.poc.py:7README.md:55-56

Classification basis

The primary artifact is poc.py, which is explicitly designed to send a malicious request to the vulnerable endpoint to delete an arbitrary directory. This constitutes exploit code because it exercises the vulnerability to cause the intended harmful effect (directory deletion), not merely detect or report exposure.

Requirements

• The target must be running a vulnerable Langflow version (< 1.9.0).README.md:23
• The attacker must be authenticated or able to make authenticated API requests (low privileges).README.md:30
• The attacker must be able to reach the DELETE /api/v1/knowledge_bases endpoint.README.md:24-28
• The Langflow process must have filesystem permissions to delete the target directory.README.md:32

Observed behavior

• The poc.py script constructs a JSON payload with a user-supplied path in the kb_names array and sends it as a DELETE request to /api/v1/knowledge_bases.poc.py:33-39
• The script prints the HTTP status and response body after sending the request.poc.py:60-69
• The README provides a curl command that performs the same DELETE request to delete the payload withheld directory.README.md:80-84

Observables

Exploit Behavior

Payload withheldThe PoC sends a DELETE request to the vulnerable endpoint to delete a directory outside the intended Knowledge Base storage. This matches the described CVE-2026-42048 vulnerability.poc.py:32-42README.md:80-84

Target Directory

Payload withheldThe lab setup creates a disposable target directory for the PoC to delete. The Dockerfile sets CHALLENGE_TARGET_DIR and the PoC defaults to this path.Dockerfile:18poc.py:9

Authentication Requirement

Payload withheldThe README states that exploitation requires an authenticated attacker. The PoC does not include credential theft or authentication bypass; it assumes the user is already authenticated.README.md:30

Classification basis

The artifact contains a complete, executable exploit chain: a vulnerable server (server.js) that evaluates user input, a Dockerfile to reproduce the vulnerable environment, and a README with a specific payload and instructions to achieve a reverse shell. The payload is designed to exercise the vulnerability by overwriting internal object properties to execute arbitrary code, which is the definition of an exploit.

Requirements

• A vulnerable Math.js version (13.1.1 to 15.1.1) must be installed and used to evaluate user-controlled expressions.Dockerfile:3README.md:23
• The application must pass untrusted user input directly to math.evaluate without additional sanitization.server.js:19-21README.md:70
• The attacker must have network access to the vulnerable server and a listener for the reverse shell.README.md:47-50

Observed behavior

• The server.js file creates an HTTP server that accepts POST requests to /calculate, parses a JSON body containing an 'expr' field, splits it by newline, and passes the resulting array directly to math.evaluate.server.js:13-21
• The README.md provides a multi-line JavaScript payload that uses reviver to obtain an ArrayNode, overwrites its .map property with a function that returns Function.constructor, and then uses a FunctionAssignmentNode to trigger internal code that calls the overwritten .map, ultimately executing a reverse shell command.README.md:54-61
• The Dockerfile builds a container with Math.js version 15.1.0 (vulnerable), copies the server.js, and creates a flag file to demonstrate file system access after exploitation.Dockerfile:1-6

Observables

Vulnerable Dependency

Payload withheldThe Dockerfile installs a version of Math.js known to be vulnerable to CVE-2026-40897, which is the subject of the PoC.Dockerfile:3

Exploit Payload

Payload withheldThe README.md provides a multi-line expression that exploits the Math.js parser to achieve arbitrary code execution, consistent with the described CVE.README.md:55-60

Network Service

Payload withheldThe server.js file implements the vulnerable endpoint that evaluates user-supplied expressions, which is the attack surface for the PoC.server.js:13-21

Classification basis

The artifact includes a complete, runnable vulnerable application and explicit instructions (curl command) to trigger the SQL injection vulnerability, resulting in unauthorized data exfiltration. This is code intended to exercise a vulnerability, meeting the definition of an exploit.

Requirements

• A running instance of the vulnerable application, which can be built and started using the provided Dockerfile and instructions.README.md:30-33Dockerfile:1-12

Observed behavior

• The application defines a custom MikroORM type `JsonOrRawType` that passes objects with a `__raw` property directly to the database without sanitization.app.js:11-17
• The `/api/posts` endpoint accepts user-supplied JSON and creates a database entity with the `content` field, which is of the vulnerable custom type.app.js:300-316
• The README provides a curl command that sends a JSON payload with `"content": { "__raw": true, "sql": "(SELECT group_concat(name || ': ' || salary, ' / ') FROM salaries)" }`, causing the SQL subquery to be executed and its result stored in the post content.README.md:43-53
• The application seeds a `salaries` table with sensitive data, including a flag string, which the exploit exfiltrates.app.js:54-71

Observables

Vulnerability Demonstration

Payload withheldThis is the core of the demonstrated CVE-2026-34220 SQL injection vulnerability, not a backdoor.app.js:11-17

Sensitive Data Seed

Payload withheldA flag string is seeded into the database as part of the PoC scenario to demonstrate data exfiltration via SQL injection.app.js:70

Poc Instruction

Payload withheldThis is the documented PoC trigger, not a backdoor command.README.md:43-53

Classification basis

The artifact includes a complete, runnable application and explicit instructions to perform actions that result in unauthorized mass data modification or deletion. This constitutes exploit code because it is designed to exercise the vulnerability and cause a harmful outcome (mass deletion/modification) beyond mere detection.

Requirements

• A running instance of the vulnerable application, which can be started via the provided Docker commands.README.md:31-34
• The application must be configured to use InlineIdsOrClauseBulkIdStrategy, as indicated in the mitigation section.README.md:58-59

Observed behavior

• The README instructs the user to register with the malicious username "' or '1' = '1".README.md:42-44
• The frontend JavaScript code sends the username to the backend via a POST request to /users without any client-side sanitization of SQL metacharacters.app/src/main/resources/static/index.html:324-333
• The User entity maps the username field as the primary key (Id) and stores it directly from user input.app/src/main/java/com/example/lab/domain/User.java:15-17
• The README states that triggering an update or delete on the malicious account will cause the SQL payload to be injected into the WHERE clause, affecting all rows.README.md:46-53
• The frontend provides '정보 변경' (update) and '탈퇴' (delete) buttons for the currently logged-in user, which send PATCH and DELETE requests respectively.app/src/main/resources/static/index.html:310-312app/src/main/resources/static/index.html:364-378

Observables

Vulnerability Demonstration

Payload withheldThe artifact is a legitimate proof-of-concept for a known CVE, demonstrating the vulnerability through a user registration and bulk update/delete flow.README.md:1-65

Application Behavior

Payload withheldThe Java and HTML files implement standard create, read, update, and delete operations on user records, consistent with the described PoC.app/src/main/resources/static/index.html:225-400app/src/main/java/com/example/lab/domain/User.java:1-40

Startup Script

Payload withheldThe script sets up a local database and starts the vulnerable application; no external connections or hidden commands are present.start.sh:1-16

Classification basis

The artifact includes a fully functional Python script (exploit.py) that actively exploits CVE-2026-33937 by sending a crafted AST payload to a target server to execute arbitrary commands. This is the primary artifact and its purpose is to exercise the vulnerability, not merely detect it. The README describes it as a 'PoC' and provides instructions for using the exploit.

Requirements

• A vulnerable Handlebars.js server (versions 4.0.0 through 4.7.8) must be running and accessible, with an endpoint that passes user-controlled input directly to Handlebars.compile().README.md:76-81

Observed behavior

• The Python script (exploit.py) establishes an interactive shell that repeatedly prompts the user for a command, constructs a malicious Handlebars AST object with the command injected into a NumberLiteral node's value field, and sends it via HTTP POST to a target server endpoint.exploit.py:12-68
• The injected payload uses process.mainModule.require('child_process').execSync() to execute the supplied command on the server.exploit.py:50-52
• The script prints the server's response, which is expected to contain the output of the executed command.exploit.py:70-72
• The poc.json file provides a static example of the AST injection technique using a BooleanLiteral node to execute 'cat /etc/passwd'.poc.json:1-23

Observables

Exploit Payload

Payload withheldThe Python exploit script constructs an AST payload that injects a call to execSync with user-supplied commands, consistent with the documented RCE vulnerability.exploit.py:52

Exploit Payload

Payload withheldThe poc.json file contains a static AST payload that executes 'cat /etc/passwd', demonstrating the same RCE primitive.poc.json:13

Target Endpoint

Payload withheldThe exploit script targets a local server endpoint, which is the intended vulnerable application described in the README.exploit.py:4

Classification basis

The artifact includes a complete, runnable application (app.js) with a vulnerable endpoint and explicit instructions (README.md) to send a malicious payload that triggers a SQL injection, causing the application to return all database rows. This constitutes code intended to exercise a vulnerability.

Requirements

• The vulnerable application must be running and accessible over the network.README.md:35-57

Observed behavior

• Sends a crafted JSON POST request with a malicious key 'name::text) or 1=1--' to the /api/users/search endpoint.README.md:80-89
• The application returns all user rows from the database, confirming the SQL injection altered the query logic.README.md:91-95
• The vulnerable endpoint passes user-controlled JSON object keys directly into a Sequelize where clause on a JSON column.app.js:460-462

Observables

Vulnerability Demonstration

Payload withheldThe README and app.js code demonstrate the CVE-2026-30951 SQL injection by passing a crafted JSON key to Sequelize's where clause, which is the expected behavior of a PoC for this vulnerability.README.md:80-89app.js:460-466

Flag Definition

Payload withheldA flag is defined for a CTF-style challenge, but it is only stored in the database and never exfiltrated or sent to an external server. The application does not expose the flag through any endpoint.app.js:6app.js:71-73

Classification basis

The primary artifact is a Python script that actively exploits CVE-2026-5027 by performing path traversal to write arbitrary files and establish a reverse shell, which is the definition of exploit code.

Requirements

• Target running Langflow <= 1.8.4 with auto-login enabled (default configuration) or valid credentials.CVE-2026-5027.py:10-13CVE-2026-5027.py:79-89
• Network access to the target's /api/v2/files endpoint.CVE-2026-5027.py:113-114

Observed behavior

• Obtains an access token via auto-login (unauthenticated) or supplied credentials.CVE-2026-5027.py:79-103
• Constructs a multipart filename with path traversal sequences ('../' * 9) to escape the intended upload directory.CVE-2026-5027.py:109-110
• Writes attacker-controlled content to an arbitrary filesystem path via the /api/v2/files endpoint.CVE-2026-5027.py:106-115
• Deploys a cron job to /etc/cron.d/ that executes a bash reverse shell to the attacker's listener every minute.CVE-2026-5027.py:144-158
• Writes a proof-of-concept file to /tmp/CVE-2026-5027-proof.txt when no listener is specified.CVE-2026-5027.py:163-175

Observables

Reverse Shell Payload

Payload withheldThe exploit optionally deploys a cron job that executes a reverse shell to attacker-controlled host/port. This is the advertised RCE payload for the target vulnerability, not a backdoor against the PoC operator.CVE-2026-5027.py:147-150

Path Traversal Technique

Payload withheldThe script prepends nine '../' sequences to the user-supplied remote path to escape the upload directory. This is the core exploit mechanism for CVE-2026-5027.CVE-2026-5027.py:109-110

Auto Login Abuse

Payload withheldThe script attempts unauthenticated token retrieval via the auto-login endpoint, matching the vulnerability description for default configurations.CVE-2026-5027.py:82

Classification basis

The artifact includes a complete, functional Python script (exploit.py) that actively exploits CVE-2026-33017 by sending a crafted request to execute arbitrary code and establish a reverse shell on the target server. This is code intended to exercise a vulnerability, not merely detect or report it.

Requirements

• A running, vulnerable Langflow instance (prior to 1.9.0) with a public flow ID.README.md:11-16README.md:22
• An attacker-controlled listener (netcat or the script's built-in listener) to receive the reverse shell.README.md:27-31

Observed behavior

• The exploit script constructs a JSON payload containing a custom component with embedded Python code that imports socket and subprocess, connects to a specified IP and port, and spawns an interactive bash shell.exploit.py:9-24
• The script sends an unauthenticated POST request to the target endpoint with the malicious payload.exploit.py:108-117
• The script optionally starts a built-in TCP listener to catch the reverse shell and provides an interactive command interface.exploit.py:56-87

Observables

Reverse Shell

Payload withheldThis is the core exploit payload for the documented RCE vulnerability. It is not a hidden backdoor; it is the intended demonstration of the CVE.exploit.py:18-22README.md:141

Listener

Payload withheldThis is a convenience feature for the PoC user, not a backdoor. It simply receives the reverse shell connection initiated by the exploit payload.exploit.py:56-87

Classification basis

The artifact contains a complete, functional exploit script (poc.py) that actively exercises the vulnerability to achieve remote code execution, not merely detect or report it. The README explicitly describes it as a 'PoC script' and 'exploit script' that provides an interactive shell.

Requirements

• A vulnerable n8n instance (version 1.120.4) with a Form Trigger workflow activated and its URL known.README.md:3README.md:29-34
• Python 3.x with dependencies (requests, PyJWT) installed on the attacker's machine.README.md:7README.md:39-41

Observed behavior

• Reads arbitrary files from the n8n server by sending a crafted POST request to the Form Trigger URL with a 'files' payload containing a target filepath.poc.py:34-66
• Extracts the encryption key from /home/n8n/.n8n/config and derives the FINAL_SECRET_KEY.poc.py:75-80
• Extracts admin credentials (email, bcrypt hash, UUID) from /home/n8n/.n8n/database.sqlite.poc.py:82-98
• Generates a forged JWT authentication token using the extracted secret and admin credentials, then sets session headers and cookies.poc.py:112-124
• Creates a new n8n workflow containing an 'Execute Command' node with an attacker-supplied command, runs it, and retrieves the command output, achieving remote code execution.poc.py:127-170
• Provides an interactive shell prompt ('n8n-shell>') for repeated command execution.poc.py:178-183

Observables

Credential Extraction

Payload withheldThe PoC reads sensitive n8n configuration files to derive a JWT secret and admin credentials, which are then used to authenticate to the n8n API for command execution. This is the core of the CVE-2026-21858 exploit.poc.py:75-110

Command Execution

Payload withheldAfter extracting credentials, the script creates a new workflow containing an Execute Command node and runs it, retrieving the output. This demonstrates the RCE impact of the vulnerability.poc.py:127-170

Classification basis

The script actively sends a payload designed to execute arbitrary commands on the target system and retrieves the output, which constitutes exploitation rather than mere detection or scanning.

Requirements

• Target must be a Langflow instance version < 1.3.0 with the /api/v1/validate/code endpoint exposed.CVE-2025-3248.py:69README.md:15
• Attacker must be able to reach the target over HTTP(S).CVE-2025-3248.py:84-85

Observed behavior

• Constructs a JSON payload containing a Python function definition with a default argument that executes a shell command via subprocess.check_output.CVE-2025-3248.py:72-80
• Sends an HTTP POST request with the payload to the target's /api/v1/validate/code endpoint.CVE-2025-3248.py:84-85
• Parses the JSON response to extract command output from error messages.CVE-2025-3248.py:95-102
• Prints the extracted command output to stdout.CVE-2025-3248.py:119-121

Observables

Exploit Mechanism

Payload withheldThe payload constructs a Python function definition where the default argument value calls exec() with a subprocess command, exploiting the code validation endpoint to achieve RCE.CVE-2025-3248.py:74

Network Target

Payload withheldThe script sends a POST request to the vulnerable endpoint with the malicious payload.CVE-2025-3248.py:69CVE-2025-3248.py:84-85

Command Execution

Payload withheldThe script takes a command from the command line and injects it into the payload, which is then executed on the target server.CVE-2025-3248.py:74CVE-2025-3248.py:111-116

Output Handling

Payload withheldThe script parses the JSON error response from the server to retrieve the output of the executed command.CVE-2025-3248.py:95-102

Classification basis

The repository contains only a Dockerfile and a shell script that installs the vulnerable software version. There is no code that exercises, detects, or analyzes the CVE-2025-26788 vulnerability. The artifact is a placeholder setup environment, not a PoC.

Observed behavior

• Builds a Rocky Linux 9.3 container with systemd.dockerfile:1-21
• Downloads and installs StrongKey FIDO Server v4.15.0 and a sample application.setup-skfs.sh:1-73

Observables

Download Source

Payload withheldThe setup script downloads the official StrongKey FIDO Server distribution from SourceForge.setup-skfs.sh:36

Download Source

Payload withheldThe setup script downloads a sample application WAR from the official StrongKey project on SourceForge.setup-skfs.sh:61