Remote Code Execution in Apache Parquet parquet-avro Schema Parsing

This repository is a Java/Maven proof-of-concept project demonstrating unsafe class resolution and instantiation behaviors in Apache Parquet Java's parquet-avro reader when processing attacker-crafted Parquet files with malicious embedded Avro schema metadata. It is not tied to a common exploit framework. The project contains payload writers, reader-side demos, canary classes, and a markdown report explaining two vectors. Repository structure: pom.xml and dependency-reduced-pom.xml define a shaded Java 17 Maven build with parquet-avro/parquet-hadoop 1.15.1, Avro 1.12.0, and Hadoop 3.3.6. The main code lives under src/main/java/com/example/. Writer classes generate malicious Parquet files: WritePoC.java crafts a file whose record namespace/name maps to com.example.CanaryClass; WritePoC2.java crafts a STRING field with java-class=com.example.CanaryClass; WriteSsrfPayload.java crafts a file whose schema full name is com.example.SsrfCanary; WriteJEditorPanePayload.java crafts a STRING field with java-class=javax.swing.JEditorPane and embeds an HTTP callback URL. Reader/demo classes consume those files: ReadPoC.java exercises multiple parquet-avro configurations to observe class loading behavior; SsrfDemo.java demonstrates SSRF via class loading of SsrfCanary; JEditorPaneSsrfDemo.java demonstrates SSRF via javax.swing.JEditorPane(String url). CanaryClass.java and SsrfCanary.java are local gadget/canary classes used to prove static initializer and constructor execution. Main exploit capabilities: (1) generate malicious Parquet files that cause parquet-avro to resolve attacker-controlled class names during read; (2) trigger Class.forName() and no-arg constructor invocation via schema record name/namespace; (3) trigger String-constructor invocation via STRING field java-class metadata; (4) demonstrate SSRF by causing outbound HTTP GET requests to attacker-controlled URLs; and (5) test validator behavior introduced in parquet-avro 1.15.1. The markdown report states that the dangerous STRING java-class vector is fixed in 1.15.1 by ReflectClassValidator.PackageValidator, while the record name/namespace vector still bypasses that validator but appears limited to class loading and no-arg construction with lower practical impact. Operationally, this is a PoC rather than a weaponized exploit. It requires a victim application to read attacker-supplied Parquet files. For the JEditorPane SSRF path, the victim must use non-compat mode with SpecificData and either run a vulnerable parquet-avro version (<1.15.1) or allow the relevant package through SERIALIZABLE_PACKAGES. For the record-name vector, the victim must hit a code path that resolves schema full names through SpecificData.getClass(schema). The included demos use local loopback HTTP servers on port 8888 to verify outbound callbacks.

This repository is a proof-of-concept (PoC) exploit for CVE-2025-30065, a critical deserialization vulnerability in Apache Parquet's Java implementation (parquet-avro). The exploit demonstrates how a malicious Parquet file with a crafted Avro schema can trigger instantiation of arbitrary Java classes during deserialization, potentially leading to remote code execution. The repository contains: - A Bash script (CVE-2025-30065.sh) to automate building and running the PoC, including dependency resolution via Maven. - ParquetExploitGenerator.java: Generates a malicious Parquet file with an Avro schema that instantiates javax.swing.JEditorPane (a standard Java class with side effects) by default. - PayloadRecord.java: A legacy payload class with a static initializer that executes OS commands (launches calculator on Windows/Mac, or performs a curl to an attacker-controlled server on Linux/Unix). - ParquetVictim.java: Simulates a vulnerable application that reads the malicious Parquet file, triggering the exploit. - README.md: Provides detailed background, exploitation steps, mitigation advice, and a security checklist. The main attack vector is local: the victim must process a malicious Parquet file. However, the payload can perform network callbacks (e.g., exfiltrating the hostname to http://attacker.example.com). The exploit is a PoC and does not include weaponized, customizable payloads, but demonstrates the risk of arbitrary code execution via deserialization in vulnerable environments.

This repository provides a proof-of-concept (PoC) exploit for CVE-2025-30065, a critical deserialization vulnerability in Apache Parquet's 'parquet-avro' Java library. The exploit is implemented as a Java application (CanaryExploitGenerator.java) that generates a malicious Parquet file. The file is crafted so that, when processed by a vulnerable system, it causes the system to instantiate a javax.swing.JEditorPane object with a user-supplied URL. This results in the target system making an HTTP/S request to the attacker's canary URL, confirming the presence of the vulnerability. The repository includes build scripts (Gradle), usage instructions, and a single main code file. The exploit is non-destructive and intended for detection and validation purposes. No hardcoded endpoints are present; the canary URL is supplied by the user at runtime. The exploit targets systems using 'parquet-avro' 1.15.0 or earlier, or 1.15.1+ with permissive SERIALIZABLE_PACKAGES settings, and requires the ability to process attacker-supplied Parquet files.

This repository demonstrates exploitation of CVE-2025-30065, a vulnerability in Apache Parquet (with Avro integration) that allows remote class instantiation during deserialization of attacker-supplied Parquet files. The repository contains Java code to generate two types of malicious Parquet files: 1. RCE PoC: 'GenerateMaliciousParquet.java' creates a Parquet file ('exploit.parquet') that, when deserialized by a vulnerable application with the attacker's 'RCEPayload' class on the classpath, executes shell commands to create and open an HTML file. This is a proof-of-concept and not realistic in production, as the attacker's class would not typically be present. 2. SSRF PoC: 'GenerateMaliciousParquetSSRF.java' creates a Parquet file ('exploit-ssrf.parquet') that, when deserialized, instantiates 'javax.swing.JEditorPane' with a URL ('http://localhost:8000/ssrf'), causing the target JVM to make an HTTP request. This demonstrates a more feasible SSRF attack vector. The repository also includes 'Reader.java' and 'ReaderSSRF.java' to simulate a victim application deserializing the malicious files. The exploit requires the target to use vulnerable Parquet/Avro libraries and to deserialize untrusted Parquet files. The SSRF variant is more practical, as it leverages a standard Java class to trigger network requests. No hardcoded external IPs or domains are present, but the code is easily adaptable for real-world attacks.

This repository is a Proof-of-Concept (PoC) exploit for CVE-2025-30065, targeting Java applications that process Parquet files using Avro and Parquet libraries. The exploit demonstrates how a specially crafted Parquet file containing a serialized Java object (MaliciousObject) can trigger arbitrary command execution upon deserialization. The repository includes a Dockerfile for building a self-contained environment, a Bash entrypoint script to orchestrate payload generation and exploitation, and Java source files for generating the malicious payload and triggering the vulnerability. The workflow is: (1) generate a Parquet file with an embedded command, (2) process the file to trigger deserialization and command execution. The exploit is local in nature, requiring the attacker to supply a malicious file that is then processed by a vulnerable system. The main fingerprintable endpoints are the file paths used for payload generation and demonstration (e.g., /etc/passwd, ./out/malicious.parquet). The code is structured as a typical Java Maven project, with clear separation between payload generation and exploitation logic.

This repository is a proof-of-concept (PoC) exploit for CVE-2025-30065, a critical deserialization vulnerability in Apache Parquet (Java implementation, versions <1.15.0). The exploit demonstrates how a specially crafted Parquet file can embed a serialized Java object (MaliciousPayload) that executes arbitrary code when deserialized by a vulnerable application. The main components are: - MaliciousPayload.java: Defines a Serializable class whose static block executes the 'whoami' command upon deserialization, demonstrating code execution. - ParquetPayloadWriter.java: Serializes the MaliciousPayload object, embeds it in a Parquet file ('evil_payload.parquet'), and writes it to disk. - ParquetPayloadReader.java: Reads the malicious Parquet file, extracts the payload, and deserializes it, triggering the exploit. - SerializePayload.java: Utility to serialize the MaliciousPayload object. - docker-compose.yaml and pom.xml: Provide a containerized Maven environment for building and running the PoC. The exploit is local in nature, requiring the target to deserialize a malicious Parquet file. The only fingerprintable endpoint is the file 'evil_payload.parquet'. The repository is structured as a safe demonstration and does not include weaponized or remote exploitation features.

This repository is a proof-of-concept (PoC) exploit for CVE-2025-30065, a deserialization vulnerability in Apache Parquet's Avro schema handling. The exploit demonstrates how a malicious Parquet file can be crafted with a schema that references a standard Java class (javax.swing.JEditorPane) as a record with a default value. When a vulnerable application deserializes this file using AvroParquetReader, it instantiates the referenced class, which can have side effects such as network requests or code execution. The repository includes: - POC-CVE-2025-30065-ParquetExploitGenerator.java: Generates the malicious Parquet file. - ParquetVictim.java: Simulates a victim application that reads and deserializes the file, triggering the exploit. - PayloadRecord.java: Legacy payload class showing how a static initializer could execute OS commands (e.g., launching calculator or making HTTP requests to an attacker-controlled server). - run.sh: Automates compilation, dependency resolution, and execution of the exploit chain. - pom.xml: Maven configuration for dependencies. - README.md: Detailed documentation and background. The exploit targets Java environments that process attacker-supplied Parquet files without strict deserialization controls. The main attack vector is local file-based deserialization, but the payload demonstrates the potential for network-based callbacks. The PoC is accurate to the patched vulnerability and does not require custom classes to be present on the victim's classpath.