CVE-2025-1094 Exploit Metadata

PoC files

7 files

File viewing is interactive and short-lived. Downloads are password-protected ZIP archives using password eip.

Analysisdeepseek-v4-pro:cloud · 2026-08-08

Technical assessment

The artifact is an exploit for CVE-2025-1094, a SQL injection vulnerability in PostgreSQL libpq and psql. It includes a Python script (exolit.py) that sends a crafted payload to a vulnerable Flask web application (app/app.py) to achieve remote code execution via psql meta-commands.

Backdoor review

No backdoor observed in reviewed code

The repository contains a proof-of-concept (PoC) for CVE-2025-1094, demonstrating SQL injection and remote code execution via psql meta-commands. All code and documentation directly support this stated purpose. No concealed, deceptive, or unrelated harmful behavior was observed.

ClassificationExploit

Model confidence95%

AuthenticationNot required

LanguagesPythonSQLDockerfileMarkdown

Target softwarePostgreSQL libpqPostgreSQL psqlFlask

Attack typesSQL InjectionRemote Code Execution

Evidence & reasoningClassification basis · observed behavior · safety review

Technical evidence

Classification basis and observed behavior

Classification basis

The artifact contains a functional exploit script (exolit.py) that actively sends a malicious payload to a vulnerable application to achieve remote code execution, which is the defining characteristic of an exploit.

exolit.py:1-37README.md:3

Requirements

A target running the vulnerable Flask application (app/app.py) with PostgreSQL and psql accessible.app/app.py:1-106
The target must be using a vulnerable version of PostgreSQL libpq (before 17.3, 16.7, 15.11, 14.16, 13.19).README.md:19

Observed behavior

Sends an HTTP POST request to the /search endpoint with a payload containing an invalid UTF-8 byte (0xC0) and psql meta-commands.exolit.py:8exolit.py:14
The payload bypasses PQescapeLiteral() escaping due to the invalid multibyte sequence, allowing a single quote to terminate the SQL string context.README.md:29-31app/app.py:32
The injected psql meta-command \! id executes the 'id' shell command on the server, and the script checks for 'uid=' in the response to confirm successful exploitation.exolit.py:8exolit.py:20-21

Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Exploit Payload: hax\xc0'; \\! id; \\! ls /tmp; #The PoC payload uses an invalid UTF-8 byte (0xC0) to bypass PQescapeLiteral and inject psql meta-commands for command execution, consistent with the described CVE.exolit.py:8README.md:70
Vulnerable Code Pattern: subprocess.Popen(['psql', db_url], stdin=subprocess.PIPE, ...)The Flask application passes user-controlled input to psql via a subprocess pipe, enabling the meta-command injection demonstrated by the PoC.app/app.py:86-92
Command Execution: \! id; \! ls /tmp;The exploit script sends psql meta-commands to execute 'id' and 'ls /tmp' on the target server, which is the intended demonstration of RCE.exolit.py:8

Review boundaries

What the analysis did not establish

The evidence includes only the text content of 4 out of 7 files; 3 files (likely Dockerfile, docker-compose.yml, and possibly another) are omitted, so the full build and deployment context is not available.
The analysis is based solely on static review of the provided source code; the exploit was not executed, and its effectiveness against a live target is not verified.
Three files (docker-compose.yml, app/Dockerfile, and one other) were omitted from the text evidence; their metadata was reported but content was not analyzed. These files are typical infrastructure files and are unlikely to contain backdoor behavior, but their absence is noted.

Model interpretation

This review is limited to the supplied PoC code and context. It does not assert that the code works or is safe to execute.

Docker lab environments

GitHub

docker-compose.yml

Created 2026-05-10Vuln labCVE-2025-1094Compose · mixed

1 Compose manifest · 1 Dockerfile · 2 services

Analysisdeepseek-v4-pro:cloud · 2026-08-06

Environment assessment

A Docker Compose environment simulating a vulnerable web application that uses PostgreSQL's libpq and psql, designed to demonstrate CVE-2025-1094 SQL injection and potential remote code execution.

README.md:1-3docker-compose.yml:1-34

Lab assessment

Vulnerability lab

The README explicitly states it is a Proof of Concept for CVE-2025-1094, and the provided code (app.py, exolit.py) implements the vulnerable pattern and exploit described.

README.md:1-3app/app.py:1-106

Lab shapeCompose · mixed

Services2

Compose manifests1

Dockerfiles1

Evidence & reasoningComponents · CVE assessment · exercise context · review boundaries

Components

Services and files described by the evidence

db

PostgreSQL database server

A PostgreSQL 16.6 container initialized with a company_db database and sample employee data. It exposes port 5432 and has a healthcheck.

docker-compose.yml:4-17app/init_db.sql:1-31

web

Vulnerable Flask web applicationSQL injection target

A Flask app built from app/Dockerfile, based on postgres:16.6. It accepts user input via POST /search, uses libpq's PQescapeLiteral for escaping, then pipes the resulting SQL to psql, creating a SQL injection and RCE path. It mounts the entire app directory for live code updates.

docker-compose.yml:19-33app/Dockerfile:1-17app/app.py:1-106

exolit.py

Exploit script

A Python script that sends a crafted POST request containing a multibyte bypass payload to the web application to trigger the SQL injection and execute shell commands.

exolit.py:1-37

CVE assessment

How the supplied evidence relates each vulnerability

CVE-2025-1094

Supported by supplied evidence

The environment directly implements the vulnerable pattern described for CVE-2025-1094: using PQescapeLiteral on user input and then executing the result via psql, which allows bypassing escaping with invalid multibyte bytes and executing meta-commands.

README.md:1-3app/app.py:68-90exolit.py:7

Exercise context

Requirements and sequence described by the evidence

Prerequisites

Docker and Docker Compose must be installed to build and run the environment.README.md:120-122
The target web application must be running and accessible on localhost:5000.exolit.py:4
The attacker must send a specially crafted payload containing an invalid UTF-8 byte (e.g., 0xC0) followed by a single quote and psql meta-commands.README.md:80-82exolit.py:7

Evidence-described exercise path

Start the lab environment using 'docker-compose up -d'.README.md:122
Wait for the db and web services to become healthy.README.md:126-128
Run the exploit script 'python exolit.py' to send the malicious payload.README.md:132
Observe the output, which should include the result of the 'id' command executed on the server, confirming successful exploitation.README.md:134exolit.py:17-20

Safety-review evidence

Behaviors behind the stored safety assessment

No harmful behavior observed

All visible behavior is directed at the lab's own target (the web container). The exploit executes shell commands within the container as part of the vulnerability demonstration. There is no evidence of host escape, external connections, persistence, credential theft, or destructive actions beyond the intended lab exercise.

exolit.py:7app/app.py:68-90docker-compose.yml:1-34

Review boundaries

What the analysis did not establish

The file doc.txt is listed in the file inventory but its content is not included in the evidence packet, so its role cannot be assessed.
The exploit script exolit.py targets localhost:5000, which is the lab's own web service; no external target is specified.

Model interpretation

This review is limited to the supplied lab evidence packet. It does not assert that the environment runs, reproduces a vulnerability, or is safe to execute. Contract: eip-docker-lab-analysis-v1.

Linked vulnerabilities

CVE-2025-1094