exploitintel

Classification basis

The primary artifact includes multiple Python scripts (poc.py, poc_vector2.py, poc_vector3.py) that are designed to actively exploit CVE-2026-28409 by sending crafted HTTP requests to a vulnerable WeGIA instance to achieve remote code execution. The code performs the full attack chain: authentication, malicious file upload, and triggering the vulnerable function, which constitutes an exploit.

Requirements

• Valid WeGIA administrative credentials (default admin/wegia) or a bypass for authentication.poc/poc.py:139-171
• Network access to the WeGIA web application's login, upload, and restore endpoints.poc/poc.py:155-157poc/poc.py:193-198poc/poc.py:239-245

Observed behavior

• Authenticates to the WeGIA application using provided credentials and extracts a PHP session ID.poc/poc.py:139-171
• Constructs a valid .tar.gz archive in memory and uploads it via a multipart/form-data POST request with a malicious filename containing shell metacharacters (e.g., $(echo MARKER > rce_out).dump.tar.gz).poc/poc.py:86-99poc/poc.py:174-214
• Triggers the database restore action by sending a POST request to gerenciar_backup.php with the malicious filename, causing the shell_exec() call to execute the injected OS command.poc/poc.py:217-252
• Verifies command execution by checking for a file written to the backup directory (file-write proof) or by measuring a delay in the HTTP response (timing-based proof).poc/poc.py:293-326poc/poc.py:356-371

Observables

Target Behavior

Payload withheldThis is the documented exploit behavior for CVE-2026-28409 and does not indicate a backdoor.poc/poc.py:139-252poc/poc_vector2.py:92-181poc/poc_vector3.py:86-177

Verification Method

Payload withheldThese are standard techniques for blind OS command injection verification and do not constitute backdoor behavior.poc/poc.py:78-81poc/poc.py:257-269

Network Communication

Payload withheldNo external or unrelated network connections are made by the PoC scripts.poc/poc.py:156-157poc/poc.py:194-195poc/poc.py:240-241

Classification basis

The primary artifact, poc.py, is an exploit. It is a Python script that automates the full attack chain to trigger and verify a stored XSS vulnerability. It creates a malicious project, commits a payload, sets up the required LSIF artifact, and uses a headless browser to confirm JavaScript execution (e.g., alert dialog detection). This goes beyond scanning or detection; it actively exercises the vulnerability to achieve code execution in the victim's browser context.

Requirements

• Authenticated GitLab user with Developer role (write access) to create a project and commit files.poc.py:19-20
• Target GitLab instance running a vulnerable version (14.2.0 through 18.0.5, 18.1.0 through 18.1.3, or 18.2.0 through 18.2.1).poc.py:20
• A victim user must view the attacker's crafted file in the GitLab blob viewer.poc.py:15

Observed behavior

• Creates a new GitLab project or uses an existing one via the API.poc.py:256-279
• Commits a Python source file containing XSS payloads (e.g., <img/src/onerror=...>) as string literals.poc.py:48-54
• Creates a .gitlab-ci.yml configuration to generate a legacy LSIF artifact (without an end_line property) that triggers the vulnerable code path.poc.py:57-78
• Verifies the LSIF data endpoint serves the vulnerable-format entries.poc.py:377-442
• Uses a headless browser (Playwright) to log in, navigate to the blob viewer, and detect XSS execution via alert dialogs and DOM inspection.poc.py:513-640

Observables

Url

Payload withheldAuthor attribution URL found in multiple script headers.poc.py:3

Url

Payload withheldTarget URL for the local Docker-based GitLab lab environment.CVE-LAB.md:37

Credential

Payload withheldDefault credentials for the local GitLab lab container.README.md:63-64

Command

Payload withheldCommand to create a personal access token on the local target GitLab instance.poc.py:237-245

Classification basis

The primary artifact consists of three Python scripts (poc.py, poc_vector2_git.py, poc_vector3_flaginjection.py) that actively exploit CVE-2026-0765 by building and serving malicious payloads, authenticating to the target, triggering the vulnerable pip install, and verifying remote code execution. The scripts are designed to exercise the vulnerability, not merely detect it.

Requirements

• Target Open WebUI instance reachable from hostpoc/poc.py:35
• Host reachable from target container for pip to fetch payloadpoc/poc.py:36
• Authenticated user with tool/function creation permissionsREADME.md:32

Observed behavior

• Builds a malicious Python sdist tar.gz with a weaponized setup.py that writes marker files to /tmppoc/poc.py:110-152
• Starts an HTTP server to host the malicious packagepoc/poc.py:176-182
• Authenticates to Open WebUI via signup or signinpoc/poc.py:236-281
• Creates a tool with crafted frontmatter containing a malicious pip requirements URLpoc/poc.py:286-320
• Verifies RCE by reading marker files written by the malicious setup.py via docker execpoc/poc.py:341-394
• Vector 2 creates a malicious git repository and serves it via a minimal git smart HTTP serverpoc/poc_vector2_git.py:119-178
• Vector 3 hosts a fake PEP 503 PyPI index and injects --extra-index-url and --trusted-host pip flags via comma-separated requirementspoc/poc_vector3_flaginjection.py:161-236

Observables

Marker File

Payload withheldWritten by the malicious setup.py on the target to confirm RCE.poc/poc.py:65

Marker File

Payload withheldWritten by the git+http vector payload on the target to confirm RCE.poc/poc_vector2_git.py:65

Marker File

Payload withheldWritten by the flag injection vector payload on the target to confirm RCE.poc/poc_vector3_flaginjection.py:66

Target Url

Payload withheldThe target Open WebUI instance, configured by the operator via command-line arguments.poc/poc.py:422-425

Attacker Url

Payload withheldThe attacker-controlled server hosting the malicious payload, configured by the operator.poc/poc.py:422-425

Classification basis

The file poc/poc.py is a complete exploit that exercises the vulnerability by registering a malicious plugin and executing an arbitrary OS command on the target, as described in its docstring and implemented in the exploit() function. The control_test.py file is a scanner that checks for exploitability without executing a payload, but the primary artifact includes an exploit script, making the overall classification 'exploit'.

Requirements

• Target must be running a vulnerable version of 9router (>= 0.4.30, < 0.4.37) with the unprotected /api/cli-tools/* and /api/mcp/* routes exposed.README.md:22-24
• Network access to the target's HTTP port.poc/poc.py:37

Observed behavior

• Sends an unauthenticated POST request to /api/cli-tools/cowork-settings with a JSON payload containing a customPlugins array that includes an attacker-controlled command and arguments.poc/poc.py:55-74
• Opens an SSE connection to /api/mcp/{plugin_name}/sse, which causes the server to spawn the registered command and stream its stdout back to the attacker.poc/poc.py:77-103
• Checks the SSE stream for a unique marker and the output of the 'id' command to confirm successful remote code execution.poc/poc.py:128-134

Observables

Command Execution

Payload withheldThe main PoC (poc.py) executes a command on the target to demonstrate RCE, which is the stated purpose of the exploit.poc/poc.py:52

Command Execution

Payload withheldThe control harness (control_test.py) uses a harmless echo command to test exploitability without executing a payload, as documented.poc/control_test.py:48

Network Connection

Payload withheldThe PoC sends a POST request to the vulnerable endpoint to register a malicious plugin, which is the first step of the documented attack chain.poc/poc.py:68

Classification basis

The artifact is a fully functional Python script that builds a malicious image, deploys a vulnerable containerd instance, and triggers host-level command execution via the binary:// logger. It is designed to exercise the vulnerability, not merely detect it, and includes a verification step that confirms code execution by checking for a marker file.

Requirements

• Docker daemon accessible to build and run privileged containerspoc/poc.py:90-93poc/poc.py:120-132
• Vulnerable containerd version (e.g., 2.3.1) running inside a privileged lab containerpoc/poc.py:111-116poc/poc.py:233-238
• Malicious Docker image with containerd.io/restart.status and containerd.io/restart.loguri labelspoc/poc.py:65-81

Observed behavior

• Builds a malicious Docker image containing reserved-namespace labels (containerd.io/restart.status, containerd.io/restart.loguri) with a binary:// payloadpoc/poc.py:65-108
• Starts a privileged Docker container running the target containerd version and mounts the malicious image tarpoc/poc.py:111-155
• Imports the malicious image into the nested containerd and creates a container, triggering label propagation to the containerpoc/poc.py:158-201
• Waits for the restart monitor to execute the binary:// logger, creating a marker file (payload withheld) as proof of host-level code executionpoc/poc.py:203-224
• Verifies success by checking for the marker file and reports [SUCCESS] or [FAILED]poc/poc.py:270-289

Observables

Marker File

Payload withheldUsed to verify successful host-level code execution as part of the exploit demonstration.poc/poc.py:47-48poc/poc.py:74poc/poc.py:207-220

Payload

Payload withheldThe exploit payload injected via a malicious Docker image label to achieve command execution on the host.poc/poc.py:74

Docker Image

Payload withheldThe malicious Docker image built by the PoC to carry the exploit labels.poc/poc.py:82

Classification basis

The primary artifact is poc.py, which is explicitly designed to send a malicious PROXY header to a target, trigger a crash, and confirm the vulnerability. The code includes an 'exploit' function that sends the crafted payload and checks for a 421 response or connection reset, which are indicators of a successful denial-of-service attack. This is active exploitation of the vulnerability, not merely detection or scanning.

Requirements

• Exim must be compiled with SUPPORT_PROXY=yes and configured with hosts_proxy matching the attacker's source IP.README.md:23

Observed behavior

• Sends a PROXY TCP4 header with a malformed source IP address containing leading '+' signs (e.g., '+0.+0.+0.+1') to the target Exim service.poc/poc.py:140-141
• The malformed IP passes Exim's string_is_ip_address() validation but is later rejected by inet_pton(), causing a LOG_PANIC_DIE and a child process crash, resulting in a 421 error response.poc/poc.py:164-167
• Additional scripts test other malformed IP vectors (leading zeros, malformed IPv6, whitespace) that also trigger the crash.poc/poc_vector2_leading_zeros.py:113-119poc/poc_vector3_ipv6.py:115-123poc/poc_vector4_whitespace.py:114-131

Observables

Network Connection

Payload withheldAll PoC scripts connect to a user-specified target to send PROXY protocol headers. This is expected behavior for a vulnerability PoC.poc/poc.py:58-68poc/poc_vector2_leading_zeros.py:54-62poc/poc_vector3_ipv6.py:56-64poc/poc_vector4_whitespace.py:54-62

Command Execution

Payload withheldThe primary PoC optionally reads the Exim panic log inside a Docker container to confirm crashes. This is a diagnostic check, not a backdoor.poc/poc.py:186-193

Classification basis

The artifact is a Python script that actively sends a malicious payload to trigger a heap-based buffer overflow in a vulnerable service and then verifies the crash, which constitutes exploitation code. The README and verification report confirm it is a PoC that exercises the vulnerability.

Requirements

• A running C++ Thrift endpoint using THeaderTransport (vulnerable versions 0.10.0 - 0.23.0) that accepts header-format connections.poc/poc.py:24-26
• Network access to the target service.poc/poc.py:35-36
• Docker CLI access to the lab container to verify process death (for the verdict mechanism).poc/poc.py:46-48

Observed behavior

• Constructs a Thrift header-format frame with ZLIB_TRANSFORM declared and a zlib-compressed payload that decompresses to 1000 bytes.poc/poc.py:87-103
• Sends the crafted frame to the target host and port via a TCP socket.poc/poc.py:106-120
• Polls the Docker container state to check if the target process exited due to a signal (e.g., SIGABRT, SIGSEGV), confirming the heap overflow.poc/poc.py:123-140
• Outputs [SUCCESS] if the target container died by signal, indicating successful exploitation.poc/poc.py:161-165

Observables

Network Connection

Payload withheldThis is the intended exploit trigger; no unrelated or covert connections are made.poc/poc.py:110-111

Process Execution

Payload withheldUsed to verify the exploit caused a crash; no other commands are executed.poc/poc.py:128-131

Classification basis

The primary artifact is poc/poc.py, a Python script that automates the full exploit chain: authentication, SSTI payload injection, and unauthenticated RCE trigger. The README and report describe it as a 'proof-of-concept' that 'demonstrates' and 'confirms' RCE. The code is intended to exercise the vulnerability, not merely detect it.

Requirements

• Valid credentials for the OneBlog admin interface with template:edit permission.poc/poc.py:60-61
• Network access to the blog-admin service for template injection.poc/poc.py:330-331
• Network access to the blog-web service to trigger the injected template.poc/poc.py:332-333

Observed behavior

• Authenticates to the blog-admin service using hardcoded credentials.poc/poc.py:88-142
• Injects a FreeMarker SSTI payload into the TM_ROBOTS template via an HTTP POST request.poc/poc.py:145-195
• Triggers the injected template by making an unauthenticated GET request to /robots.txt, causing the server to execute the injected OS command.poc/poc.py:198-232
• Restores the original template content after exploitation.poc/poc.py:235-266

Observables

Network Connection

Payload withheldThe PoC connects to operator-supplied admin_host and admin_port for authentication and template injection.poc/poc.py:98

Network Connection

Payload withheldThe PoC connects to operator-supplied web_host and web_port to trigger the RCE.poc/poc.py:212

Payload

Payload withheldThe SSTI payload is a standard FreeMarker RCE vector that executes the operator-supplied command on the target server.poc/poc.py:67

Classification basis

The artifact is classified as an exploit because it contains code (poc/poc.py) that actively crafts a malicious input and executes it against a target to trigger a vulnerability, resulting in a denial-of-service condition. The README and verification report confirm its purpose is to exercise the vulnerability, not just detect it.

Requirements

• A running Docker container of a vulnerable ClamAV version (<= 1.5.3) with a memory cap.poc/poc.py:99-105

Observed behavior

• Crafts a XAR file with a header declaring a decompressed TOC size just under 1 GiB and a compressed TOC of ~1 MB.poc/poc.py:68-84
• Stages the crafted XAR file and a minimal signature database into the target Docker container.poc/poc.py:122-129
• Executes clamscan on the crafted file inside the container and checks for exit code 137 (SIGKILL) and the container's OOMKilled flag to confirm successful exploitation.poc/poc.py:134-158

Observables

Docker Exec

Payload withheldThe PoC uses docker exec to run clamscan inside a lab container, which is the expected delivery mechanism for the DoS trigger.poc/poc.py:135-136

File Write

Payload withheldThe script writes a crafted XAR file to a temporary directory; this is the exploit payload generation, not a backdoor.poc/poc.py:68-84

Classification basis

The code's primary operation is to trigger a race condition and observe whether a crash occurs, which is a detection mechanism, not an exploitation primitive. The README explicitly states the PoC 'triggers the TOCTOU race condition' and expects a BSOD on unpatched builds, confirming it is a scanner. The code does not contain heap grooming, arbitrary write, or privilege escalation logic.

Requirements

• Local authenticated user with low privilegesREADME.md:25
• Unpatched Windows build prior to KB5079473README.md:17

Observed behavior

• Creates two IO Completion Ports and a named pipe pair with overlapped I/Opoc/exploit.c:122-160
• Launches an IO thread that issues overlapped NtReadFile and completes it via NtWriteFile to trigger IRP completionpoc/exploit.c:179-226
• Launches race threads that rapidly reassociate the pipe's file handle with different IOCPs and NULL using NtSetInformationFilepoc/exploit.c:230-271
• Monitors for system crash (BSOD) to determine if the vulnerability is present; reports completion without crash on patched systemspoc/exploit.c:351-355

Observables

Behavior

Payload withheldThe exploit.c code creates a named pipe pair, associates it with IOCPs, and races IOCP reassociation against IRP completion to trigger a use-after-free in ntoskrnl.exe. This matches the documented CVE-2026-24289 vulnerability.poc/exploit.c:190-223poc/exploit.c:240-268

Network

Payload withheldThe code uses only local named pipes and kernel objects; no socket, HTTP, or other network APIs are called.poc/exploit.c:1-365

Persistence

Payload withheldNo registry writes, scheduled tasks, service creation, or startup folder modifications are present.poc/exploit.c:1-365

Classification basis

The artifact is a Python script that actively sends a malicious request to exploit a path traversal vulnerability to read a file from the target server. This constitutes an exploit.

Requirements

• Target must be running a vulnerable version of the SEBLOD Joomla extension (e.g., 3.29.0).poc/poc.py:7
• The target's Joomla site must be reachable over HTTP.poc/poc.py:67-68

Observed behavior

• Sends an HTTP GET request to the target's index.php with a crafted 'file' parameter containing a path traversal payload (e.g., 'tmp/../../../..payload withheld').poc/poc.py:75-76
• Checks if the server responds with HTTP 200 and the response body contains content matching the payload withheld file format.poc/poc.py:83-84
• Prints '[SUCCESS]' and the first line of the retrieved file if exploitation is successful, or '[FAILED]' if it is not.poc/poc.py:85-100

Observables

Network Request

Payload withheldThe sole network request made by the PoC to exploit the path traversal vulnerability.poc/poc.py:75-76

File Read

Payload withheldThe target file read by the exploit; a standard Linux file used for non-destructive proof of concept.poc/poc.py:47

Classification basis

The primary artifact is poc.py, which is explicitly designed to perform an account takeover by exploiting a token type confusion vulnerability. It executes a multi-step attack chain: inserting a malicious token into the database and then exchanging it for a victim's session. This is the definition of exploit code, as it actively exercises the vulnerability to achieve an unauthorized outcome (session theft). The secondary script, poc_vector2_multitype.py, also performs the same exploitation steps for multiple token types to prove the lack of validation.

Requirements

• Direct access to the Mattermost PostgreSQL database to insert a crafted token.poc/poc.py:316-325
• Knowledge of the victim's user_id, which is discoverable via the Mattermost API.poc/poc.py:280-291
• The Mattermost instance must have the MobileSSOCodeExchange feature flag enabled (default in affected versions).README.md:156

Observed behavior

• Authenticates to the Mattermost API as a low-privileged user to discover the victim's user_id.poc/poc.py:262-275
• Generates attacker-controlled PKCE values (code_verifier, code_challenge) and a random token value.poc/poc.py:296-311
• Inserts a crafted token with an arbitrary type (e.g., 'saml') and the victim's user_id into the Tokens table via a direct PostgreSQL connection.poc/poc.py:316-332
• Sends a POST request to the unauthenticated /api/v4/users/login/sso/code-exchange endpoint with the crafted token and matching PKCE verifier.poc/poc.py:345-358
• Receives a valid session token for the victim user from the server's HTTP 200 response.poc/poc.py:362-372
• Uses the stolen session token to access the /api/v4/users/me endpoint, confirming the session belongs to the victim.poc/poc.py:382-398

Observables

Network Connection

Payload withheldThe PoC scripts connect to the local lab environment to demonstrate the exploit. No external or unrelated network connections are made.poc/poc.py:234-236poc/poc.py:328poc/poc_vector2_multitype.py:261-269

Database Operation

Payload withheldThe PoC inserts a crafted token into the local PostgreSQL database to simulate the prerequisite for the exploit. This is a required step in the documented attack chain.poc/poc.py:322-325poc/poc_vector2_multitype.py:226-229

Credential Usage

Payload withheldThe scripts use hardcoded credentials for the local lab environment described in the README. These are not exfiltrated; they are used only to authenticate to the local services.poc/poc.py:67-68poc/poc.py:72-73poc/poc_vector2_multitype.py:62-63poc/poc_vector2_multitype.py:66-67

Classification basis

The primary artifact (poc.py) creates connectors to test whether LdapLoginModule is blocked by the JAAS denylist. It does not deliver a malicious LDAP response, execute a deserialization gadget chain, or achieve code execution. Its stated purpose is a 'Differential Test' to confirm the denylist bypass, which is detection/validation behavior consistent with a scanner.

Requirements

• Access to the Kafka Connect REST API (default: no authentication, port 8083).README.md:23-24
• A running Kafka Connect worker with the vulnerable version (2.3.0–3.9.0).README.md:14

Observed behavior

• Sends HTTP POST requests to the Kafka Connect REST API to create connectors with specific SASL JAAS configurations containing JndiLoginModule or LdapLoginModule.poc/poc.py:102-122
• Checks the connector task status to determine if the LoginModule was blocked (denylist hit) or accepted (bypass confirmed).poc/poc.py:135-163
• Reports whether the target is vulnerable based on the differential result of the two LoginModule tests.poc/poc.py:296-316

Observables

Outbound Connection Target

Payload withheldHardcoded attacker LDAP server address used in PoC scripts to demonstrate the SSRF/deserialization path of the CVE.poc/poc.py:55poc/poc_vector2.py:65

Custom Login Module

Payload withheldCustom Java LoginModule that makes an outbound LDAP connection to an attacker-controlled server, used to prove the full exploitation path.poc/OutboundLdapModule.java:30-70

Network Service

Payload withheldTarget service for the exploit, used to create malicious connector configurations.CVE-LAB.md:23-24

Classification basis

The file poc/poc.py is explicitly described as a 'Full exploit' and 'PoC' that 'implements the full CVE-2026-28372 attack chain' to 'obtain root shell without password'. Its code actively connects to a service, injects a malicious payload to bypass authentication, and executes commands to verify privilege escalation, which is the definition of an exploit.

Requirements

• GNU inetutils telnetd <= 2.7 must be running on the target.poc/poc.py:39
• util-linux >= 2.40 must be installed as the system's login implementation.poc/poc.py:40
• An unprivileged local user must create a 'login.noauth' file containing 'yes' in a directory accessible to the target.poc/poc.py:41
• Network access to the telnetd service is required.poc/poc.py:42

Observed behavior

• Connects to a target telnetd service on a specified host and port.poc/poc.py:146-155
• Performs Telnet option negotiation, agreeing to handle options like NEW_ENVIRON.poc/poc.py:257-325
• When the server requests environment variables via SB NEW_ENVIRON SEND, injects CREDENTIALS_DIRECTORY and USER variables to trigger the authentication bypass.poc/poc.py:242-250
• After negotiation, sends verification commands ('id', 'whoami', 'head -1 /etc/shadow') to confirm root access.poc/poc.py:403-441
• Reports success if the output contains 'uid=0(root)' or 'whoami' returns 'root'.poc/poc.py:466-495

Observables

Network Connection

Payload withheldThe exploit connects only to the target host and port provided by the operator via command-line arguments.poc/poc.py:150-152

Exploit Mechanism

Payload withheldThe core exploit logic injects the CREDENTIALS_DIRECTORY and USER variables into the Telnet session to trigger the authentication bypass in login(1).poc/poc.py:186-213

Verification Command

Payload withheldThe exploit sends these commands to the target to verify root access, which is standard for privilege escalation PoCs.poc/poc.py:407-440

Classification basis

The primary artifact is classified as an exploit because the Python scripts actively exercise the vulnerability to achieve arbitrary code execution, OS command execution, and data exfiltration, rather than merely detecting or reporting the vulnerability. The code imports the vulnerable function, crafts malicious payloads, triggers eval(), and verifies the side effects of the injected code.

Requirements

• Access to a vulnerable OpenStack Vitrage instance (versions before 12.0.1, 13.0.0, 14.0.0, 15.0.0) with the eval() call present in create_predicate().poc/poc.py:108-136
• Ability to import and call the vitrage.graph.query.create_predicate function, either through authenticated API access or direct code execution on the host.poc/poc.py:34-37

Observed behavior

• Crafts a malicious query dictionary with a single-quote breakout in the value to inject Python code.poc/poc.py:152-165
• Calls create_predicate() which passes the crafted expression to eval(), creating a lambda containing the injected code.poc/poc.py:170-176
• Invokes the returned lambda predicate on a fake vertex object, triggering the injected code to write a marker file to /tmp/poc_evidence/.poc/poc.py:178-198
• Executes OS commands (id, whoami, hostname, uname -a) via __import__('os').popen() and writes the output to a file.poc/poc.py:204-248
• Reads sensitive files (/etc/hostname, /etc/passwd) and writes their contents to an exfiltration file.poc/poc.py:254-294
• Demonstrates exploitation through dictionary key injection by crafting a malicious key that breaks out of the string literal.poc/poc_vector2_key_injection.py:96-167
• Demonstrates exploitation through compound logical operator queries (and, or, nested) by injecting code into sub-expressions.poc/poc_vector3_logical_operator.py:112-224

Observables

Execution Context

Payload withheldEstablishes that the code execution targets the vulnerable Vitrage service host, not the operator's machine.README.md:90-98CVE-LAB.md:128-131

Exploit Behavior

Payload withheldThis is the disclosed exploit behavior for CVE-2026-28370 and is not a backdoor.poc/poc.py:112poc/poc.py:162-163poc/poc.py:216-224poc/poc.py:264-269

Classification basis

The Python script actively constructs and sends a malicious HTTP request to bypass authentication and gain unauthorized access to a protected resource, which constitutes exploitation.

Requirements

• Target must be running a vulnerable version of Eclipse Jetty with Digest authentication enabled and a user account whose password contains non-ISO-8859-1 characters.README.md:21-34
• Attacker must know the victim's username and the length of the victim's password.poc/poc.py:26-27

Observed behavior

• Sends an unauthenticated GET request to a protected resource and parses the 401 WWW-Authenticate Digest challenge.poc/poc.py:54-65
• Computes a Digest response using a colliding password where non-ISO-8859-1 characters are replaced with '?', mirroring the server's lossy encoding.poc/poc.py:84-95
• Sends the forged Authorization header and checks for a 200 OK response containing a known marker to confirm successful authentication bypass.poc/poc.py:105-110poc/poc.py:146-154

Observables

Network Connection

Payload withheldThe PoC connects only to the target specified by the user to demonstrate the authentication bypass. No other network connections are made.poc/poc.py:57poc/poc.py:105

Expected Marker

Payload withheldThe script checks for this marker in the HTTP response body to confirm successful exploitation. It is a benign string used for verification.poc/poc.py:51poc/poc.py:151

Classification basis

The primary artifact is a Python script (poc/poc.py) that actively exploits the vulnerability by sending a malicious payload to trigger deserialization and then verifies the side effect (file creation) to confirm code execution. This meets the definition of an exploit.

Requirements

• The target WordPress site must have the Ajax Search Lite plugin (version < 4.14.5) installed and the search statistics feature enabled.README.md:27-29
• A suitable POP gadget chain must be present on the target (provided by the lab's canary gadget for demonstration).poc/poc.py:25-27

Observed behavior

• Sends an unauthenticated POST request to /wp-json/ajax-search-lite/statistics/searches/add with a JSON body containing a serialized PHP object in the 'phrase' field.poc/poc.py:106
• The serialized object is crafted to instantiate a canary class whose __destruct method writes a unique marker file to /tmp/ on the target server.poc/poc.py:56-63
• Verifies successful exploitation by reading the marker file from the Docker container and comparing its contents to the expected token.poc/poc.py:113-126

Observables

Network Request

Payload withheldThe exploit sends a crafted serialized PHP object to the vulnerable endpoint to trigger deserialization.poc/poc.py:50poc/poc.py:106

Serialized Payload

Payload withheldThe payload is a hand-crafted serialized object of a lab-only canary class, used to prove object injection by writing a marker file.poc/poc.py:56-63

Docker Command

Payload withheldThe script reads the marker file from the target Docker container to verify the exploit's side effect.poc/poc.py:76-85

Classification basis

The primary artifact (poc.py) is classified as an exploit because it actively exercises the vulnerability by setting up a rogue TLS server, establishing a remote TLS connection, and demonstrating that the hostname verification is bypassed. The code is intended to prove the vulnerability can be exploited, not merely to detect its presence.

Requirements

• Requires a MITM network position between Apache Ranger and a NiFi/NiFi Registry server.README.md:217-218
• Requires a crafted certificate chain where an intermediate CA certificate contains a SAN matching the target hostname.README.md:219-220
• Requires Docker and Docker Compose to build and run the lab environment.README.md:66-67

Observed behavior

• Starts a rogue TLS server inside a Docker container that presents a crafted certificate chain (leaf SAN=attacker.com, intermediate CA SAN=nifi-registry.target.com).poc/poc.py:134-180poc/tls_rogue_server.py:27-56
• Connects to the rogue TLS server from the attacker's machine, retrieves the certificate chain, and demonstrates that a Python port of the vulnerable Java verifier accepts the connection (bypass) while a fixed verifier rejects it.poc/poc.py:263-307poc/poc.py:415-451
• Deploys and runs a Java test class inside the container that uses the actual vulnerable NiFiRegistryHostnameVerifier over a real TLS connection to the rogue server, confirming the bypass.poc/poc_vector2.py:81-231poc/poc_vector2.py:288-297
• Tests the second vulnerable code path (NiFiHostnameVerifier) and verifies it is an identical code clone to the first.poc/poc_vector3.py:61-246

Observables

Network Connection

Payload withheldExpected behavior for demonstrating a TLS hostname verification bypass MITM scenario.poc/poc.py:50poc/poc_vector2.py:30

Certificate Generation

Payload withheldNecessary to demonstrate the vulnerability where the verifier checks all certificates in the chain.poc/poc.py:13-16poc/tls_rogue_server.py:5-8

Docker Exec

Payload withheldUsed to set up the lab environment, start the rogue server, and run Java verification tests. All commands are directly related to demonstrating the CVE.poc/poc.py:105-108poc/poc_vector2.py:66-69

Classification basis

The artifact poc/poc.py is explicitly described as an exploit in the README and its own header. It actively sends crafted requests to a target to trigger a vulnerability and retrieve protected content, which is the definition of an exploit.

Requirements

• Target Tomcat instance with a vulnerable RewriteValve configuration that carries user-controlled segments into rewritten paths and a serving layer that aliases plus and space forms.README.md:22-38
• A lab environment with the vulnerable webapp deployed, as the exploit is designed to work against the provided Docker setup.README.md:69-86

Observed behavior

• Sends baseline HTTP GET requests to /pages/admin/flag and /app/admin/flag to verify that the admin subtree is protected (expects 401/403).poc/poc.py:70-77
• Sends an attack request to /pages/+admin/flag with a literal '+' in the path, which the vulnerable RewriteValve decodes to a space, bypassing security constraints.poc/poc.py:80-86
• Sends a second attack request to /pages/%2Badmin/flag, where %2B is decoded to '+' by the connector, then the valve applies the same incorrect decode.poc/poc.py:90-92
• Checks if the response body contains the secret marker 'payload withheld' and reports success or failure.poc/poc.py:86-107

Observables

Url

Payload withheldTarget URL for the PoC; user-supplied via command line.poc/poc.py:67

Url

Payload withheldTarget URL for the patched control environment.README.md:81

String

Payload withheldMarker string used to confirm successful bypass; expected in response body.poc/poc.py:48

Classification basis

The primary artifact is poc.py, which is explicitly designed to exploit CVE-2026-2749 by uploading a webshell and executing commands, achieving remote code execution. The README and verification report confirm successful exploitation. The code's stated purpose is to exercise the vulnerability, not merely detect it.

Requirements

• Target running Centreon Open Tickets < 25.10.3 / < 24.10.8 / < 24.04.7poc/poc.py:33-34
• Valid Centreon user credentials (any privilege level)poc/poc.py:34
• Python 3.6+ (stdlib only, no external dependencies)poc/poc.py:35

Observed behavior

• Authenticates to Centreon via POST to /centreon/login.php and extracts PHPSESSID cookiepoc/poc.py:153-186
• Uploads a PHP webshell via path traversal in the uniqId parameter of a multipart POST to call.php?action=upload-filepoc/poc.py:188-243
• Executes arbitrary commands (id, whoami, uname -a, cat /etc/hostname) via the uploaded webshell to prove RCEpoc/poc.py:245-280
• Cleans up by deleting the webshell via a path traversal in the remove-file actionpoc/poc.py:282-312
• Demonstrates arbitrary file deletion by creating a canary file via upload traversal and deleting it via remove-file traversalpoc/poc_vector2.py:133-180

Observables

Network Target

Payload withheldAll scripts connect exclusively to the target specified by the operator via command-line arguments or hardcoded defaults, which is the disclosed vulnerable Centreon instance.poc/poc.py:354-355poc/poc_vector2.py:231-232poc/poc_vector3.py:236-237

Webshell Payload

Payload withheldThe webshell is uploaded to the target Centreon server as part of the disclosed RCE exploit. It is executed on the target, not the operator's machine.poc/poc.py:69

Credential Usage

Payload withheldHardcoded default credentials used to authenticate to the target Centreon instance. These are standard lab credentials documented in the README and not used to access any external service.poc/poc.py:61-62README.md:118

Classification basis

The file poc/poc.py is a complete, executable script that actively resets a user's password and logs in to confirm account takeover, which is the definition of exploit code. The README and verification report confirm it was successfully run against a vulnerable lab instance.

Requirements

• Target WordPress site with vulnerable TrueBooker plugin (<=1.2.3) active and the [truebooker-myaccount] shortcode page accessible.poc/poc.py:58-67
• Target user account (default admin, user ID 1) must have an empty user_activation_key in the WordPress database.README.md:26-31

Observed behavior

• Scrapes ajax_object.nonce and truebooker_meta_box_noncename from the public /my-account/ page.poc/poc.py:58-67
• Sends a POST request to /wp-admin/admin-ajax.php with action=user_front_resetpass, a deliberately bogus activation key, and the attacker's chosen new password.poc/poc.py:116-128
• Logs in to WordPress as the target user with the new password and verifies the presence of a wordpress_logged_in cookie.poc/poc.py:70-84

Observables

Network Target

Payload withheldThe PoC sends HTTP requests to the target to scrape nonces, reset a password, and verify login. This is the expected exploit behavior.poc/poc.py:45poc/poc.py:62poc/poc.py:128

Binary Artifact

Payload withheldVulnerable plugin zip used in the Docker lab. Not analyzed; metadata only.README.md:65

Binary Artifact

Payload withheldFixed plugin zip used in the Docker lab. Not analyzed; metadata only.README.md:65

Classification basis

The primary artifact is poc/poc.py, which is explicitly described as a 'standalone RCE exploit' and 'PoC for CVE-2025-53833: LaRecipe SSTI to RCE'. Its code constructs and sends a malicious HTTP request to inject and execute arbitrary system commands on a vulnerable server, and it extracts the command output from the response. This is code intended to exercise a vulnerability, not merely detect it.

Requirements

• Target must be running a vulnerable version of LaRecipe (< 2.8.1) with the documentation endpoint accessible.poc/poc.py:7poc/poc.py:21-22
• The documentation page must contain anchor links (href="#...") to trigger the vulnerable replaceLinks() method.poc/poc.py:297-301

Observed behavior

• Sends a raw HTTP GET request to the target's documentation endpoint with a Blade SSTI payload in the query string.poc/poc.py:87-114poc/poc.py:150-180
• Extracts the output of the executed system command from the HTTP response body by parsing anchor href attributes.poc/poc.py:222-253
• Reports whether the target is vulnerable based on the presence of command output in the response.poc/poc.py:335-358

Observables

Network Connection

Payload withheldThe PoC connects to a user-specified target to deliver the exploit payload. This is the disclosed and expected behavior for a remote exploit.poc/poc.py:363-365

Command Execution

Payload withheldThe PoC injects a Blade directive containing the operator's command into the target's template engine, leading to RCE. This is the core of the disclosed exploit.poc/poc.py:68poc/poc.py:150-180

Classification basis

The artifact includes three complete, functional Python scripts (poc.py, poc_vector2.py, poc_vector3.py) that construct and send malicious HTTP requests to execute arbitrary OS commands on a remote target. The scripts are explicitly designed to exploit the vulnerability, not merely detect it. The README and verification reports confirm the scripts were tested and successfully achieved remote code execution.

Requirements

• Network access to the target Langflow instance on the HTTP port (default 7860).poc/poc.py:53
• The target must be running a vulnerable version of Langflow (<= 1.4.2) with the /api/v1/validate/code endpoint exposed without authentication.poc/poc.py:17-23

Observed behavior

• Sends an HTTP POST request to /api/v1/validate/code with a JSON body containing a 'code' field that holds a Python function definition with a malicious default argument, decorator, or generator expression.poc/poc.py:96-101poc/poc_vector2.py:71-77poc/poc_vector3.py:84-89
• The server's validate_code() function compiles and executes the user-supplied code with Python's exec(), causing the malicious expression to be evaluated immediately at function definition time.README.md:46-54
• The exploit exfiltrates command output by raising an exception containing the result of a subprocess call, which is returned in the HTTP response body under function.errors[0].poc/poc.py:145-165

Observables

Url

Payload withheldThe target endpoint for the exploit, as described in the CVE. All PoC scripts send crafted POST requests to this endpoint on a user-specified host and port.poc/poc.py:45poc/poc_vector2.py:41poc/poc_vector3.py:54

Command

Payload withheldExample usage command from the documentation, showing how an operator would run the PoC against a local test instance.README.md:133