NLTK : contournement du bac à sable JAR, corrigé en 3.10.4 (CVE-2026-128138)
Dans NLTK 3.10.3, java() fait confiance au premier jeton cmd : un -jar ou @argfile forgé exécute un JAR externe. Corrigé en 3.10.4.
En bref
- NLTK 3.10.3 valide les options de la JVM mais ajoute ensuite la séquence
cmdde l'appelant sans vérifier son premier jeton. Uncmdqui commence par-jarou@argfileexécute un JAR externe. - Seul NLTK 3.10.3 est concerné par cette CVE. Le correctif est dans 3.10.4, publié le 21 octobre 2026.
- GitHub la note CVSS v3.1 9,8 Critique (CWE-77 et CWE-88). L'avis contient une preuve de concept publique, aucune exploitation n'est connue, la CISA indique Exploitation : poc et la CVE n'est pas dans le KEV au 20 novembre 2026.
- Mettez à niveau vers 3.10.4. Si l'application transmet des valeurs influencées par l'utilisateur à
nltk.internals.java()ou àStanfordSegmenter.java_class, traitez ce chemin comme une exécution de code jusqu'à la mise à niveau.
Suis-je concerné ?
Toutes ces conditions doivent être réunies :
- L'application exécute NLTK 3.10.3.
- L'application appelle
nltk.internals.java()avec une séquencecmd, directement ou via un wrapper Stanford. - Un attaquant peut influencer le premier élément de cette séquence
cmd, ou l'argumentjava_classdeStanfordSegmenter.
NLTK est largement déployé. PyPI a enregistré 48 827 217 téléchargements le mois dernier et 12 986 010 la semaine dernière lors de la vérification du 20 novembre 2026.
NLTK est une bibliothèque, pas un service réseau. Le score suppose un appelant qui place des valeurs influencées par l'attaquant dans la commande Java. Un script en ligne de commande qui passe des noms de classe fixes n'est pas exposé de la même façon. Un service qui construit java_class ou cmd à partir d'une requête l'est.
Prenons un service de traitement de documents qui laisse un locataire choisir un modèle Stanford, une classe de tokenizer ou un chemin de JAR. Le service est l'appelant, et NLTK transforme ces choix en ligne de commande. Si le service ne valide pas le choix, l'entrée du locataire atteint le lanceur Java.
Le même schéma apparaît dans les pipelines par lots qui lisent un nom de classe dans une définition de tâche et dans les plugins qui acceptent un assistant Java depuis un fichier de configuration.
| Branche | Versions concernées | Version corrigée |
|---|---|---|
| NLTK 3.10 | 3.10.3 uniquement | 3.10.4 |
| NLTK 3.9 et antérieurs | non concernés par cette CVE | sans objet |
Vérifiez la version installée :
python -c "import nltk; print(nltk.__version__)"
pip show nltk | grep -E '^(Version|Location)'
Cherchez ensuite les deux points d'entrée dans le code :
grep -R "nltk.internals.java\|from nltk.internals import java\|StanfordSegmenter" --include='*.py' .
grep -R "java_class\s*=" --include='*.py' .
Un résultat n'est pas une vulnérabilité en soi. Vérifiez si la valeur vient d'une requête, d'un fichier, d'un champ de base de données ou d'une autre source que l'attaquant peut modifier. Dans un service multi-locataires, suivez chaque chemin qui construit une commande Java. Confirmez que le nom de classe et le chemin du JAR viennent d'une liste autorisée fixe, pas des données du locataire.
Comment corriger ?
Mettez à niveau vers NLTK 3.10.4 ou ultérieur :
pip install --upgrade "nltk>=3.10.4"
- Mettez à jour chaque environnement qui installe NLTK, y compris les conteneurs et les workers par lots.
- Reconstruisez toute image qui fige 3.10.3.
- Revérifiez les deux points d'entrée de « Suis-je concerné ? » après la mise à niveau.
- Si l'application ne peut pas être mise à niveau immédiatement, cessez de transmettre des valeurs influencées par l'attaquant à
cmdoujava_class. Utilisez une classe principale fixe et un chemin de JAR fixe.
Aucun commutateur de configuration ne ferme la faille dans 3.10.3. La bibliothèque n'expose pas de réglage d'exécution qui valide le canal cmd. Le seul correctif est le code de 3.10.4.
La mise à niveau doit aussi atteindre les environnements qui exécutent le code, pas seulement le poste du développeur. Reconstruisez les images de conteneur qui figent nltk==3.10.3, mettez à jour le fichier de verrouillage utilisé par le service et vérifiez l'environnement virtuel de chaque worker. Un paquet installé dans une image de base peut survivre au déploiement de l'application.
Quelle est la cause racine ?
nltk.internals.java() est une enveloppe mince autour du lanceur Java. Elle construit une commande à partir de trois sources : une liste options validée, un classpath optionnel et la séquence cmd de l'appelant. Le durcissement de 3.10.3 vérifiait les options et le bac à sable des JAR, mais il ajoutait cmd_list à la commande finale sans valider son premier jeton.
Le bac à sable JAR vérifie les fichiers nommés par path_to_jar et classpath. Il confirme qu'ils sont dans les racines de données de confiance et refuse les modes unsafe-JAR et unsafe-classpath sauf si l'application l'autorise. Il n'inspecte pas la séquence cmd, car cette séquence est censée nommer la classe principale et ses arguments de programme, pas sélectionner un mode du lanceur.
Le code pertinent de NLTK 3.10.3 est :
final_cmd = []
if isinstance(_java_bin, str):
final_cmd.append(_java_bin)
else:
final_cmd.extend(_java_bin if _java_bin else ["java"])
final_cmd.extend(opt_list)
if classpath_arg is not None:
final_cmd.extend(["-cp", classpath_arg])
final_cmd.extend(cmd_list)
Le lanceur Java traite le premier jeton non-option comme la classe principale. Si cmd_list[0] vaut -jar, le lanceur passe en mode JAR et exécute le JAR nommé par le jeton suivant. S'il vaut @file, le lanceur développe le fichier d'arguments et prend son contenu comme arguments du lanceur. Les deux formes contournent le validateur d'options, qui ne voit que le canal options.
La forme @argfile est la plus souple. Le lanceur Java développe un fichier d'arguments partout où il apparaît, donc le jeton peut suivre une classe principale légitime et ajouter quand même des arguments du lanceur. Le correctif 3.10.4 rejette donc @ à toute position, pas seulement au premier élément.
StanfordSegmenter place son argument public java_class en tête de cmd. Dans 3.10.3, le constructeur stocke la valeur sans la vérifier, et segment_file() et segment_string() construisent une commande dont le premier élément est cette valeur. Un attaquant qui contrôle java_class contrôle le premier jeton du lanceur.
Les correctifs précédents expliquent l'écart. CVE-2026-12841 a ajouté la validation des options JVM globales. CVE-2026-79675 a corrigé le canal options non validé par appel dans 3.10.3. CVE-2026-128138 est le troisième canal : la séquence cmd, que les correctifs précédents ne couvraient pas.
Comment la faille est-elle exploitée ?
L'avis publie une preuve de concept fonctionnelle pour l'enveloppe directe :
nltk.internals.java(
["-jar", "/outside/trusted/roots/controlled.jar"],
classpath=None,
stdout="pipe",
stderr="pipe",
)
Le processus Java démarre le JAR externe. Le classpath est vide et les indicateurs de bac à sable JAR de NLTK ne sont pas définis. Le JAR se trouve hors des racines de données de confiance par rapport auxquelles path_to_jar est vérifié. Le même résultat est atteignable avec l'enveloppe de plus haut niveau :
StanfordSegmenter(
path_to_jar=trusted_segmenter_jar,
java_class="@/path/to/controlled-launcher.args",
path_to_model="dummy-model",
java_options=[],
)
Le JAR de segmentation de confiance passe les contrôles de somme et de classpath. Le fichier d'arguments fourni comme java_class demande ensuite au lanceur d'exécuter un autre JAR. L'avis indique que le marqueur externe a été écrit lors des trois exécutions de test avant que l'enveloppe ne lève une erreur sans rapport.
L'attaquant doit contrôler le premier élément de cmd ou java_class. C'est une condition au niveau de l'application, pas un comportement par défaut de NLTK. L'avis ne nomme ni service réseau vulnérable ni victime. Aucune exploitation dans la nature n'est connue.
L'application doit aussi atteindre l'appel. Un service qui expose un point de terminaison fixe avec un nom de classe fixe ne lui donne aucun contrôle sur la commande. Un service qui accepte un chemin de modèle, un nom de classe ou une liste d'arguments supplémentaires pour un outil Java lui donne le canal nécessaire.
Comment se déroule l'attaque ?
Un jeton de classe principale contrôlé par l'attaquant devient un commutateur du lanceur Java, le lanceur exécute un JAR externe, et le code s'exécute avec l'utilisateur du processus Python.
Que peut faire un attaquant ?
Un attaquant qui contrôle le premier jeton cmd peut exécuter un JAR arbitraire dans un nouveau processus Java. Ce processus s'exécute avec le même utilisateur système que l'application Python. Il hérite de l'environnement de l'application, y compris les identifiants et l'accès aux fichiers. Il s'exécute hors des contrôles de JAR et de classpath que NLTK applique à path_to_jar et classpath.
La JVM enfant est un processus système normal. Elle peut lire les variables d'environnement de l'application, ouvrir tout fichier accessible à l'utilisateur et établir des connexions réseau sortantes. Elle peut écrire un fichier de persistance, lancer un processus en arrière-plan ou lire un secret monté.
Les indicateurs de bac à sable JAR de NLTK sont des contrôles applicatifs sur les JAR que l'enveloppe exécute. Ce ne sont pas un bac à sable de sécurité Java et ils ne limitent pas ce qu'une JVM en cours d'exécution peut faire.
Le même accès est disponible via StanfordSegmenter.java_class lorsqu'une application construit cette valeur à partir d'une entrée non fiable. L'avis démontre l'enveloppe directe et le chemin du wrapper.
Les conditions sont NLTK 3.10.3, un appel à java() ou à une enveloppe Stanford, et une influence de l'attaquant sur le premier jeton de la commande. Sans cette influence, l'attaquant n'a pas de chemin. L'avis ne montre pas de configuration par défaut qui exposerait la faille sur le réseau.
Pourquoi le correctif fonctionne-t-il ?
NLTK 3.10.4 ajoute une garde avant l'assemblage de la commande. Le commit de correction est b3621279 :
@@ -340,6 +340,37 @@ def _normalise(stream):
+ if not cmd_list:
+ raise ValueError("cmd must contain a Java main class")
+ first = cmd_list[0]
+ if (
+ not isinstance(first, str)
+ or not first.strip()
+ or first.strip().startswith(("-", "@"))
+ ):
+ raise ValueError(
+ f"cmd must begin with a Java main class, not a launcher switch or "
+ f"@argfile: {first!r} (CWE-88)"
+ )
+ for tok in cmd_list:
+ if isinstance(tok, str) and tok.strip().startswith("@"):
+ raise ValueError(
+ f"cmd may not contain an @argfile token: {tok!r}; the Java "
+ "launcher would expand it, injecting arguments (CWE-88)"
+ )
+
final_cmd = []
La garde rejette un premier jeton absent ou non textuel, tout premier jeton qui commence par - ou @, et tout @argfile à n'importe quelle position. Elle compare le jeton débarrassé des espaces, donc un préfixe d'espacement ne peut pas cacher un commutateur du lanceur. Elle s'exécute après les validateurs d'options et de classpath, donc une option hostile est toujours signalée par son propre chemin d'erreur.
Le commit ajoute des tests de régression pour les commutateurs du lanceur, les fichiers d'arguments, les jetons vides ou non textuels, les jetons préfixés par des espaces et une classe principale légitime avec des arguments de programme. Un test de mutation prouve que le validateur d'options est porteur. Ces tests couvrent les cas de l'avis et les variantes d'espacement qu'un contrôle de chaîne naïf manquerait.
Le correctif conserve les arguments de programme légitimes qui commencent par - après une vraie classe principale, comme l'option -loadClassifier de Stanford. Il ferme le canal cmd que le validateur d'options de 3.10.3 ne couvrait pas. Les notes de version de 3.10.4 décrivent le changement plus large comme l'exécution de Java uniquement depuis des emplacements absolus de confiance, avec des options et des entrées validées.
Comment vérifier si j'ai été compromis ?
L'avis ne publie aucun indicateur de compromission. Une exécution réussie laisse les mêmes traces que n'importe quel processus Java lancé par l'application.
# Processes and command lines that start with a launcher switch
ps -eo pid,user,args | grep -E '[j]ava .*(-jar|@)'
# Recent Java processes owned by the application user
ps -eo pid,user,lstart,args | grep '[j]ava'
Cherchez un chemin -jar inattendu ou un @argfile que l'application n'a pas déployé. Vérifiez les journaux de l'application pour les requêtes qui ont atteint les chemins cmd ou java_class. Si l'application ne journalise pas ces valeurs, une tentative passée peut ne laisser aucune trace.
L'absence de processus suspect ne prouve pas que rien ne s'est produit. Un JAR de courte durée peut se terminer avant qu'un contrôle de processus ne s'exécute. Corrélez avec les journaux applicatifs, les connexions réseau sortantes et les écritures de fichiers dans le répertoire de travail de l'application. Si l'application journalise les arguments passés à java(), cherchez dans ces journaux -jar, @ et les noms de classe absents du déploiement.
Chronologie
- 2026-08-12 : NLTK 3.10.3 a livré le durcissement pour CVE-2026-79675.
- 2026-08-19 : le commit de correction du canal
cmda été écrit. - 2026-10-21 : NLTK 3.10.4 a été publié sur PyPI.
- 2026-11-19 : GitHub a publié GHSA-x8q7-6c7m-52gw et l'enregistrement CVE-2026-128138.
FAQ
- NLTK 3.10.4 est-il une version de sécurité ? Oui. Elle ferme le canal
cmddécrit ici, et ses notes de version décrivent un durcissement large du bac à sable et de la validation des entrées. - Cela concerne-t-il toutes les applications NLTK ? Non. L'application doit transmettre des valeurs influencées par l'attaquant à
java()ou àStanfordSegmenter.java_class. Un script avec des noms de classe fixes n'est pas exposé. - Est-elle exploitée dans la nature ? Aucune exploitation n'est connue, et la CVE n'est pas dans le KEV de la CISA au 20 novembre 2026. L'avis contient une preuve de concept publique.
- La 3.10.3 est-elle la seule version concernée ? Oui pour cette CVE. La plage concernée de l'avis va de 3.10.3 à 3.10.4 exclu.
- Puis-je garder 3.10.3 et valider la commande moi-même ? Vous pouvez rejeter un
cmddont le premier jeton commence par-ou@avant d'appelerjava(). Cela répète la garde de 3.10.4 dans le code applicatif et est facile à manquer sur un chemin d'appel, donc la mise à niveau est plus sûre. - Le correctif bloque-t-il des options Java légitimes ? Non. Il bloque les commutateurs du lanceur et les fichiers d'arguments dans le canal
cmd. Une vraie classe principale suivie de-loadClassifieret d'autres arguments de programme fonctionne toujours.
Trouver les versions de NLTK dans vos applications avec Ostorlab
L'analyse de composition logicielle et le SBOM d'Ostorlab inventorient les bibliothèques qu'une application embarque, y compris les paquets Python et leurs versions. Ils trouvent NLTK 3.10.3 avant la production : https://www.ostorlab.co/product/sca_sbom
Références
- Avis NLTK GHSA-x8q7-6c7m-52gw : https://github.com/nltk/nltk/security/advisories/GHSA-x8q7-6c7m-52gw (vérifié le 20 novembre 2026)
- Enregistrement CVE-2026-128138 : https://www.cve.org/CVERecord?id=CVE-2026-128138 (vérifié le 20 novembre 2026)
- Commit de correction NLTK b3621279 : https://github.com/nltk/nltk/commit/b36212795a522d2b7b176cf0e0d9d8da489ba6e6 (vérifié le 20 novembre 2026)
- Pull request NLTK 3771 : https://github.com/nltk/nltk/pull/3771 (vérifié le 20 novembre 2026)
- Version NLTK 3.10.4 : https://github.com/nltk/nltk/releases/tag/v3.10.4 (vérifié le 20 novembre 2026)
internals.pydans NLTK 3.10.3 : https://github.com/nltk/nltk/blob/v3.10.3/nltk/internals.py (vérifié le 20 novembre 2026)stanford_segmenter.pydans NLTK 3.10.3 : https://github.com/nltk/nltk/blob/v3.10.3/nltk/tokenize/stanford_segmenter.py (vérifié le 20 novembre 2026)- Avis précédent GHSA-m4rf-3fr8-xwx3 : https://github.com/nltk/nltk/security/advisories/GHSA-m4rf-3fr8-xwx3 (vérifié le 20 novembre 2026)
- Statistiques de téléchargement PyPI pour NLTK : https://pypistats.org/packages/nltk (vérifié le 20 novembre 2026)
- Catalogue KEV de la CISA : https://www.cisa.gov/known-exploited-vulnerabilities-catalog (vérifié le 20 novembre 2026)