CVE-2023-45612

HIGH
Search associated code STIX 2.1 vulnerability STIX 2.1 with PoCs

Record summary

CVE-2023-45612 has a selected CVSS score of 8.6 (high); EIP currently links 7 repository PoCs and 1 lab environment.

Description

In JetBrains Ktor before 2.3.5 default configuration of ContentNegotiation with XML format was vulnerable to XXE

Description source: CVE List

Exploitation context

Available material

Repository PoCs
7
Lab environments
1

CISA SSVC decision

ExploitationNone
AutomatableYes
Technical impactPartial

CISA Coordinator · SSVC 2.0.3 · Evaluated Sep 19, 2024 · Source: CVE List

Affected products and versions

1
ProductSourceVersion range

Ktor

Browse JetBrains / Ktor

Default status: unaffected, unknown

CVE ListBefore 2.3.5affected

Proofs of concept

7

Repository PoCs

GitHubinfernosalex/CVE-2023-45612-PoCRepository PoCby infernosalex1Exploit15 files

68.4 KiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

Python script that sends a crafted XML payload containing an external entity to a user-supplied Ktor endpoint, attempting to read a local file and display its contents in the response.

Backdoor review

No backdoor observed in reviewed code

The reviewed Python script (CVE-2023-45612.py) is a straightforward Proof of Concept for CVE-2023-45612 (XXE). It constructs an XML payload with an external entity pointing to a user-supplied file path and sends it to a user-supplied target URL. No backdoor, deceptive payload, or concealed operator-directed harm is present. The script's behavior is fully transparent and limited to the described exploit demonstration.

ClassificationExploit
Model confidence95%
AuthenticationNot required
Languagespython
Target softwareJetBrains Ktor
Attack typesxxe
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The script actively sends a malicious XML payload designed to trigger an XXE vulnerability and exfiltrate file contents, which constitutes exploitation rather than mere detection or scanning.

CVE-2023-45612.py:81-95CVE-2023-45612.py:115-119

Requirements

  • Target Ktor server with vulnerable ContentNegotiation XML configuration accepting POST requests at the specified endpoint.CVE-2023-45612.py:131-133
  • Network connectivity to the target server.CVE-2023-45612.py:97-104

Observed behavior

  • Constructs an XML payload with a DOCTYPE defining an external entity that references a local file path via file:// URI.CVE-2023-45612.py:75-95
  • Sends the XML payload via HTTP POST to the target endpoint and prints the server response, which may include the contents of the targeted file.CVE-2023-45612.py:115-125
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Exploit Mechanism
Payload withheldThe script builds an XML payload containing an external entity referencing a user-supplied file path and sends it via HTTP POST to a user-supplied endpoint.CVE-2023-45612.py:75-95CVE-2023-45612.py:115-119
Network Communication
Payload withheldThe script sends the crafted XML payload to a target URL and endpoint provided by the user via command-line arguments.CVE-2023-45612.py:131-133CVE-2023-45612.py:144-151
User Interaction
Payload withheldThe script requires the user to explicitly provide the target URL and the file path to read, making the attack fully user-directed.CVE-2023-45612.py:131-132
Review boundaries

What the analysis did not establish

  • Two binary files (gradle-wrapper.jar and gradlew) were not inspected; they are build/dependency files and do not affect the classification of the primary Python exploit script.
  • Only the two most relevant text files (CVE-2023-45612.py and README.md) were included; 12 other text files were omitted, but the included files are sufficient for classification.
  • Two binary files (gradle-wrapper.jar and gradlew) are present in the repository but are not analyzed. They are standard build tools and are not invoked by the reviewed PoC script.
  • The review is limited to the two text files provided; 12 other text files in the repository were not included in the evidence packet.
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.

GitHubaecelen/ktor-xxe-pocRepository PoCby aecelen1Exploit16 files

59.3 KiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

A proof-of-concept exploit for CVE-2023-45612, an XXE vulnerability in JetBrains Ktor. The artifact includes a vulnerable Ktor server application and a Python script that sends an XXE payload to read local files.

Backdoor review

No backdoor observed in reviewed code

The repository is a proof-of-concept for CVE-2023-45612 (XXE in Ktor). All reviewed source files implement a minimal Ktor server with a vulnerable XML endpoint and a Python test script that sends a benign request and an XXE payload. No backdoor, concealed executable behavior, or operator-directed harm is present in the supplied text evidence.

ClassificationExploit
Model confidence95%
AuthenticationNot required
LanguagesKotlinPython
Target softwareJetBrains Ktor
Attack typesXXE
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The artifact contains a Python script (test.py) that actively sends an XXE payload to a vulnerable server endpoint to exfiltrate local file contents, which constitutes exploitation code.

test.py:22-30

Requirements

  • A running instance of the vulnerable Ktor server on localhost:8080.README.md:15-25

Observed behavior

  • Sends a valid XML request to the /student endpoint.test.py:6-12
  • Sends an XML payload containing an external entity definition that attempts to read a local file (/etc/passwd or c:/windows/win.ini).test.py:22-30
  • The server deserializes the XML payload using a vulnerable ContentNegotiation configuration.src/main/kotlin/Serialization.kt:7-10src/main/kotlin/Routing.kt:18-20
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Vulnerability Demonstration
Payload withheldThe PoC demonstrates the CVE-2023-45612 vulnerability by sending an XML payload with a SYSTEM entity referencing a local file path.test.py:22-29
Vulnerable Configuration
Payload withheldThe server configuration in Serialization.kt enables XML content negotiation with default settings, which is the vulnerable configuration described in CVE-2023-45612.src/main/kotlin/Serialization.kt:7-10
Review boundaries

What the analysis did not establish

  • Two binary files (gradle-wrapper.jar, gradlew) were not inspected.
  • The analysis is based solely on the provided text evidence; the code was not executed.
  • Two binary files (gradle-wrapper.jar and gradlew) were flagged as BINARY and not analyzed; they are standard Gradle wrapper files but their contents were not inspected.
  • Seven additional text files in the repository were not included in the evidence packet and were not reviewed.
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.

GitHubclemfavre/cve-2023-45612_exploitRepository PoCby clemfavre0Writeup125 files

1.0 MiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

The artifact is a technical writeup describing CVE-2023-45612, an XXE vulnerability in JetBrains Ktor. It provides a detailed reproduction guide, including server setup, normal and malicious XML payloads, and curl commands, but contains no executable exploit or scanner code.

Backdoor review

No backdoor observed in reviewed code

The repository is a proof-of-concept (PoC) for CVE-2023-45612, an XXE vulnerability in JetBrains Ktor. All reviewed text files (README, build script, server source, Gradle wrapper, settings) describe or implement a legitimate demonstration of the vulnerability and its patch. No backdoor, deceptive payload, or concealed harmful behavior is present in the supplied evidence.

ClassificationWriteup
Model confidence95%
AuthenticationNot required
Languagesmarkdownkotlinxmlbash
Target softwareJetBrains Ktor
Attack typesxxe
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The artifact is a README.md file that explains the vulnerability, provides XML payload examples, and gives remediation advice. It does not contain any code that automatically exploits or scans for the vulnerability; the provided Kotlin server code is a demonstration target, not an exploit or scanner.

README.md:1-56server/src/main/kotlin/Main.kt:1-38

Requirements

  • A Ktor server running version 2.3.4 with XML content negotiation enabled.README.md:9server/build.gradle.kts:20-22

Observed behavior

  • The writeup describes sending a malicious XML payload containing an external entity referencing a local file, causing the server to return the file's contents in its response.README.md:31-46
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Vulnerability Demonstration
Payload withheldThe PoC shows how an attacker can read local files (sensitive_infos.txt) by sending a crafted XML payload to a Ktor server using the vulnerable ktor-serialization-kotlinx-xml library.README.md:30-46server/src/main/kotlin/Main.kt:21-37
Patch Indication
Payload withheldThe build file uses the patched version (2.3.5) of ktor-serialization-kotlinx-xml, consistent with the README's explanation that the vulnerability is fixed in this version.server/build.gradle.kts:22README.md:48
Review boundaries

What the analysis did not establish

  • 100 binary files were not inspected, but they are build artifacts and Gradle caches unlikely to contain exploit or scanner code.
  • Only 5 of 25 text files were included; the remaining 20 text files are omitted, but the included files (README, build script, server code) are the primary evidence-bearing files.
  • 100 binary files (e.g., compiled classes, Gradle caches) were not analyzed; their content could theoretically contain hidden behavior, but the text evidence shows no indication of such.
  • 20 additional text files were omitted from the evidence packet; their content is unknown.
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.

GitHubrazvanclaudiu/ktor-xxe-pocRepository PoCby razvanclaudiu0Exploit14 files

62.1 KiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

The artifact is a proof-of-concept exploit for CVE-2023-45612, an XXE vulnerability in JetBrains Ktor. It provides a complete vulnerable server application and a malicious XML payload designed to read arbitrary files from the server's filesystem and return their contents in an HTTP response.

Backdoor review

No backdoor observed in reviewed code

The repository is a proof-of-concept (PoC) for CVE-2023-45612, an XML External Entity (XXE) vulnerability in JetBrains Ktor. All supplied text files (README, build scripts, and Kotlin source code) describe or implement a deliberately vulnerable Ktor server for educational purposes. The code sets up a single POST endpoint that parses XML using a vulnerable default configuration, which is the expected behavior for demonstrating the CVE. No concealed executable behavior, persistence mechanisms, credential theft, or unrelated payloads were observed in the reviewed text evidence. One binary file (gradle-wrapper.jar) was not analyzed, which is a standard build tool component.

ClassificationExploit
Model confidence95%
AuthenticationNot required
LanguagesKotlinXML
Target softwareJetBrains Ktor
Attack typesXML External Entity (XXE)
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The artifact includes a complete, runnable vulnerable server and a specific malicious XML payload designed to trigger an XXE vulnerability and exfiltrate file contents. The README explicitly describes this as an exploit and provides step-by-step instructions to execute it, including the expected output of the exfiltrated file.

README.md:2README.md:90-109src/main/kotlin/Application.kt:13-16src/main/kotlin/Routing.kt:21-24

Requirements

  • A Ktor server running version < 2.3.5 with the ContentNegotiation plugin configured using the default xml() serializer.README.md:6src/main/kotlin/Application.kt:13-16
  • An attacker must be able to send an HTTP POST request with a crafted XML payload to the vulnerable /message endpoint.README.md:94-101src/main/kotlin/Routing.kt:21-23

Observed behavior

  • The server application is configured with a vulnerable XML parser that does not disable external entity processing.src/main/kotlin/Application.kt:13-16README.md:36
  • The exploit payload defines an external entity referencing a local file (secret_file.txt) and uses it within the XML message body.README.md:96-101
  • Upon receiving the malicious XML, the server parses the external entity, reads the contents of the specified file, and includes it in the HTTP response.README.md:107-109src/main/kotlin/Routing.kt:23-24
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Vulnerable Configuration
Payload withheldThe Application.kt file installs the ContentNegotiation plugin with the xml() serializer, which is the vulnerable default configuration described in CVE-2023-45612.src/main/kotlin/Application.kt:13-16
Vulnerable Endpoint
Payload withheldThe Routing.kt file defines a POST endpoint that receives and deserializes XML into a Message object, which is the attack vector for the XXE vulnerability.src/main/kotlin/Routing.kt:21-24
Exploit Instructions
Payload withheldThe README provides step-by-step instructions for exploiting the XXE vulnerability, including the exact XML payload and curl command, which is consistent with a legitimate PoC.README.md:90-110
Review boundaries

What the analysis did not establish

  • One binary file (gradle-wrapper.jar) was not analyzed, but it is a standard build tool wrapper and not part of the exploit logic.
  • The analysis is based solely on the provided source code and documentation; the code was not executed.
  • One binary file (gradle/wrapper/gradle-wrapper.jar, 43764 bytes) was not analyzed. It is a standard Gradle Wrapper JAR, but its exact contents are unverified.
  • Seven unclassified files (totaling 10075 bytes) were not included in the text evidence and were not analyzed.
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.

GitHubseraphimi/ktor-xxeRepository PoCby seraphimi0Scanner17 files

309.7 KiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

A Python script that sends crafted XML payloads to a Ktor server endpoint to test for XXE (CVE-2023-45612) by checking if file contents or SSRF responses are reflected in the HTTP response. It reports vulnerability status but does not perform post-exploitation actions.

Backdoor review

No backdoor observed in reviewed code

The supplied evidence consists of a README.md and a PoC script (poc.py) for CVE-2023-45612. The PoC script sends crafted XML payloads to a target server to test for XXE vulnerability. It performs no actions against the person running the PoC: it does not exfiltrate data, establish persistence, download or execute unrelated payloads, or conceal any operator-directed harm. The script's behavior is fully transparent and limited to the stated vulnerability testing.

ClassificationScanner
Model confidence95%
AuthenticationNot required
LanguagesPython
Target softwareJetBrains Ktor
Attack typesXXE
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The script is explicitly labeled as a scanner (line 3, line 20, line 74) and its primary operation is to send a test payload and report whether the server reflects entity content, without performing any further exploitation such as data exfiltration, command execution, or establishing persistence.

poc.py:3poc.py:20poc.py:74

Requirements

  • Target Ktor server with /xml endpoint accepting XML POST requestspoc.py:28poc.py:48-52

Observed behavior

  • Checks server availability via GET /xmlpoc.py:25-33
  • Sends XML payload with external entity referencing a local file or URLpoc.py:35-43
  • Evaluates response length and status to determine vulnerabilitypoc.py:55-66
  • Prints vulnerability status and exits with code 1 if vulnerablepoc.py:97-104
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Network Connection
Payload withheldThe script connects only to the user-supplied target server to send XXE test payloads. No connections to unrelated or attacker-controlled infrastructure are made.poc.py:28poc.py:48-53
Payload Generation
Payload withheldThe script constructs XML payloads containing external entities pointing to user-specified files or URLs. This is the expected behavior for an XXE PoC.poc.py:39-43
Review boundaries

What the analysis did not establish

  • Two binary files (gradle-wrapper.jar, gradlew) are present but not analyzed; they are build/dependency artifacts and unlikely to alter the classification of the provided Python scanner.
  • Only two of 17 repository files were provided as text; the remaining 12 text files and 3 non-text files were omitted, but the included files (README.md, poc.py) are sufficient for classification.
  • Two binary files (gradle-wrapper.jar and gradlew) are present in the repository but were not analyzed; they are standard Gradle wrapper files and not part of the PoC evidence.
  • Only the README.md and poc.py files were included as text evidence; 12 other text files in the repository were omitted from the packet.
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.

GitHubstefan-500/ktor-cve-2023-45612-pocRepository PoCby stefan-5001Scanner19 files

140.5 KiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

The artifact is a proof-of-concept repository for payload withheld, an XXE vulnerability in Ktor. The primary code provided is an XML payload (xxe-demo-file.xml) and a secret file (secret.txt) used to demonstrate the vulnerability. The README describes how to run a vulnerable Ktor server and send the payload using curl, which would read the secret file and display its contents. The artifact does not contain any exploit code that automatically exercises the vulnerability; it provides a payload and instructions for manual testing, functioning as a vulnerability scanner/demonstrator.

Backdoor review

No backdoor observed in reviewed code

The supplied evidence consists of a README, a sample secret file, and an XXE payload XML. The README documents a known payload withheld proof-of-concept, describes standard XXE exploitation steps, and provides prevention guidance. The XML payload and secret file are benign demonstration resources. No backdoor, trojan, or deceptive behavior is observed in the reviewed text.

ClassificationScanner
Model confidence95%
AuthenticationNot required
LanguagesXMLMarkdown
Target softwareJetBrains Ktor
Attack typesXXE
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The artifact provides an XML payload and instructions for manually sending it to a vulnerable server to observe the XXE behavior. It does not include any code that automatically sends the request or exploits the vulnerability; it only demonstrates how to check for the vulnerability. This matches the definition of a scanner: code that checks for a vulnerability without exploiting it.

README.md:1README.md:8README.md:40-41README.md:61-63

Requirements

  • A vulnerable Ktor server (version < 2.3.5) with XML ContentNegotiation enabled must be running.README.md:8README.md:14
  • The attacker must be able to send HTTP POST requests to the server's /xml endpoint.README.md:40

Observed behavior

  • The README instructs the user to send an XML payload containing an external entity reference to a local file (exploit/etc/secret.txt) via curl to the /xml endpoint.README.md:61-63
  • The XML payload defines an external entity 'xxe' pointing to 'exploit/etc/secret.txt' and references it in the document body.exploit/payloads/xxe-demo-file.xml:1-2
  • The expected vulnerable result is that the server console outputs the contents of the secret file.README.md:65-66
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Cve Reference
Payload withheldThe artifact is a proof-of-concept repository for a known XXE vulnerability in Ktor. The README explicitly states this and links to the CVE.README.md:1
Xxe Payload
Payload withheldThe XML payload is a standard XXE demonstration file that references a local file (exploit/etc/secret.txt) to illustrate the vulnerability. It does not contain any backdoor or malicious logic.exploit/payloads/xxe-demo-file.xml:1-2
Sample Secret File
Payload withheldThe secret.txt file contains placeholder credentials used as a target for the XXE demonstration. It is not a real secret and does not indicate any backdoor behavior.exploit/etc/secret.txt:1-2
Review boundaries

What the analysis did not establish

  • The repository contains a binary file (gradle-wrapper.jar) that was not analyzed.
  • Only 3 of 19 files were provided as text; the remaining 16 files (including potential source code for the Ktor server) were omitted.
  • The evidence does not include the actual Ktor server source code, so the vulnerable configuration cannot be verified.
  • One binary file (gradle-wrapper.jar, 45457 bytes) was flagged but not analyzed. It is a standard build tool component, but its contents were not inspected.
  • 13 unclassified files and 2 non-text media files were not included in the text analysis. Their contents are unknown.
  • The review is limited to the supplied evidence packets and does not verify the behavior of the application at runtime.
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.

GitHubksaweryr/CVE-2023-45612-PoCRepository PoCby ksaweryr0Exploit16 files

60.9 KiB

GitHub
PoC details
Analysisdeepseek-v4-pro:cloud ·

Technical assessment

A Python script that sends an XXE payload to a vulnerable Ktor server endpoint to achieve local file inclusion (LFI). The README describes it as a PoC for CVE-2023-45612.

Backdoor review

No backdoor observed in reviewed code

The reviewed text files (README.md and client/poc.py) describe and implement a standard XXE proof-of-concept for CVE-2023-45612. The Python client sends an XML payload with an external entity to a target server to demonstrate local file inclusion. No backdoor, deceptive payload, or concealed operator-directed harm is present in the supplied text evidence.

ClassificationExploit
Model confidence95%
AuthenticationNot required
Languagespython
Target softwareJetBrains Ktor
Attack typesxxelocal file inclusion
Evidence & reasoningClassification basis · observed behavior · safety review
Technical evidence

Classification basis and observed behavior

Classification basis

The Python script actively sends a crafted XML payload designed to trigger an XXE vulnerability and exfiltrate a local file, which constitutes exploitation, not just detection or scanning.

client/poc.py:7-21

Requirements

  • A running Ktor server instance with the vulnerable ContentNegotiation configuration and an endpoint susceptible to the attack.README.md:5

Observed behavior

  • Constructs an XML payload containing an XXE entity that references a local file ('file:///lfi_poc.txt').client/poc.py:7-17
  • Sends an HTTP POST request with the XML payload to a target server endpoint.client/poc.py:20
  • Prints the server's response, which is expected to contain the contents of the local file if the XXE is successful.client/poc.py:19-21
Safety-review evidence

Behaviors behind the backdoor verdict

Observables

Xml External Entity
Payload withheldThe PoC payload uses an XXE technique to read a local file, which is the expected behavior for demonstrating CVE-2023-45612.client/poc.py:8
Network Request
Payload withheldThe script sends the XXE payload to a configurable target host and port, which is normal for a PoC client.client/poc.py:20
Review boundaries

What the analysis did not establish

  • The server-side code (Ktor application) is not included in the selected text evidence, so the vulnerable endpoint's implementation cannot be verified.
  • Two binary files (gradle-wrapper.jar and gradlew) are present but not analyzed, which may contain additional build or server logic.
  • The evidence does not confirm whether the exploit was executed or is functional.
  • Two binary files (gradle-wrapper.jar and gradlew) were not inspected; their content could contain unrelated behavior not visible in the text evidence.
  • Only 2 of 16 total files were provided as text; the remaining 14 files (including server source code) were omitted, so the review cannot assess the server-side implementation.
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

1
GitHub

docker-compose.yaml

ksaweryr/CVE-2023-45612-PoCCreated Vuln labCVE-2023-45612Compose · builds

1 Compose manifest · 2 Dockerfiles · 2 services

View exploit
Analysisdeepseek-v4-pro:cloud ·

Environment assessment

A Docker Compose environment with a Ktor server (vulnerable to CVE-2023-45612 XXE) and a Python client that sends an XXE payload to demonstrate local file inclusion (LFI).

README.md:1-9docker-compose.yaml:1-15

Lab assessment

Vulnerability lab

The README explicitly states it is a proof of concept for CVE-2023-45612, and the included server code and client script are designed to demonstrate the XXE vulnerability leading to LFI.

README.md:1-9client/poc.py:1-21server/app/src/main/kotlin/org/example/App.kt:1-35
Lab shapeCompose · builds
Services2
Compose manifests1
Dockerfiles2
Evidence & reasoningComponents · CVE assessment · exercise context · review boundaries
Components

Services and files described by the evidence

server

vulnerable Ktor web serverXXE target

A Gradle-based Kotlin application using Ktor 2.3.4 with ContentNegotiation and XML serialization. It exposes a POST /foo endpoint that deserializes XML into a Foo data class, making it susceptible to XXE. The Dockerfile builds the project, creates a marker file /lfi_poc.txt, and runs the server on port 8080.

server/Dockerfile:1-14server/app/src/main/kotlin/org/example/App.kt:1-35server/app/build.gradle.kts:1-53

client

XXE exploit scriptLFI demonstration

A Python script using httpx to send an XXE payload to the server's /foo endpoint. The payload attempts to read /lfi_poc.txt from the server's filesystem. It prints the response, expecting the file content to appear if LFI succeeds.

client/Dockerfile:1-11client/poc.py:1-21
CVE assessment

How the supplied evidence relates each vulnerability

CVE-2023-45612

Supported by supplied evidence

The README, client PoC script, and server code all reference CVE-2023-45612. The server uses Ktor 2.3.4 with default XML ContentNegotiation, which is known to be vulnerable to XXE. The client sends an XXE payload targeting local file inclusion, consistent with the CVE description.

README.md:1-9client/poc.py:1-21server/app/build.gradle.kts:24-26
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:8
  • The server must be healthy (port 8080 accessible) before the client sends the exploit.docker-compose.yaml:4-9

Evidence-described exercise path

  1. Run `docker compose up` from the repository root to build and start both services.README.md:8
  2. The server builds, starts, and listens on port 8080. A healthcheck ensures it is ready.docker-compose.yaml:4-9server/Dockerfile:13
  3. Once the server is healthy, the client container starts and executes poc.py, which sends an XXE payload to http://server:8080/foo.docker-compose.yaml:10-14client/poc.py:1-21
  4. The server deserializes the XML, processes the external entity, and includes the content of /lfi_poc.txt in the response, demonstrating LFI.client/poc.py:7-20server/Dockerfile:6
Safety-review evidence

Behaviors behind the stored safety assessment

No harmful behavior observed

All visible behavior is confined to the lab's own containers. The client sends an XXE payload to the server container over the internal Docker network. The server reads a local file (/lfi_poc.txt) created during its own build. No host filesystem mounts, privilege escalation, external network connections, or destructive actions are present. The port mapping (8080:8080) is a standard lab requirement for accessing the vulnerable service.

docker-compose.yaml:1-15server/Dockerfile:1-14client/Dockerfile:1-11client/poc.py:1-21
Review boundaries

What the analysis did not establish

  • The server build context includes a binary gradle-wrapper.jar, which is uninspected.
  • The server Dockerfile copies the entire build context (COPY . .), including gradle scripts and configuration, but no evidence of malicious behavior is visible in the supplied text files.
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.

Packet coverage: 1 binary file not inspected

References

2