NLTK: omisión del sandbox de JAR, corregida en 3.10.4 (CVE-2026-128138)
En NLTK 3.10.3, java() confía en el primer token cmd: un -jar o @argfile forjado ejecuta un JAR externo. Corregido en 3.10.4.
Resumen
- NLTK 3.10.3 valida las opciones de la JVM pero después añade la secuencia
cmddel llamador sin comprobar su primer token. Uncmdque empieza por-jaro@argfileejecuta un JAR externo. - Solo NLTK 3.10.3 está afectado por esta CVE. La corrección está en 3.10.4, publicado el 21 de octubre de 2026.
- GitHub la califica CVSS v3.1 9.8 Crítica (CWE-77 y CWE-88). El aviso incluye una prueba de concepto pública, no se conoce explotación, CISA indica Exploitation: poc y la CVE no está en CISA KEV al 20 de noviembre de 2026.
- Actualice a 3.10.4. Si la aplicación pasa valores influidos por el usuario a
nltk.internals.java()o aStanfordSegmenter.java_class, trate esa ruta como ejecución de código hasta aplicar la actualización.
¿Estoy afectado?
Todas estas condiciones deben cumplirse:
- La aplicación ejecuta NLTK 3.10.3.
- La aplicación llama a
nltk.internals.java()con una secuenciacmd, directamente o mediante un wrapper de Stanford. - Un atacante puede influir en el primer elemento de esa secuencia
cmd, o en el argumentojava_classdeStanfordSegmenter.
NLTK está ampliamente desplegado. PyPI registró 48,827,217 descargas el mes pasado y 12,986,010 la semana pasada en la comprobación del 20 de noviembre de 2026.
NLTK es una biblioteca, no un servicio de red. La puntuación supone un llamador que coloca valores influidos por el atacante en la orden Java. Un script de línea de comandos que pasa nombres de clase fijos no está expuesto de la misma forma. Un servicio que construye java_class o cmd a partir de una petición sí lo está.
Piense en un servicio de procesamiento de documentos que permite a un inquilino elegir un modelo de Stanford, una clase de tokenizador o una ruta de JAR. El servicio es el llamador, y NLTK convierte esas elecciones en una línea de comandos. Si el servicio no valida la elección, la entrada del inquilino llega al lanzador de Java.
El mismo patrón aparece en canalizaciones por lotes que leen un nombre de clase de una definición de tarea y en complementos que aceptan un asistente Java desde un archivo de configuración.
| Rama | Versiones afectadas | Versión corregida |
|---|---|---|
| NLTK 3.10 | solo 3.10.3 | 3.10.4 |
| NLTK 3.9 y anteriores | no afectadas por esta CVE | no aplica |
Compruebe la versión instalada:
python -c "import nltk; print(nltk.__version__)"
pip show nltk | grep -E '^(Version|Location)'
Después busque los dos puntos de entrada en el código:
grep -R "nltk.internals.java\|from nltk.internals import java\|StanfordSegmenter" --include='*.py' .
grep -R "java_class\s*=" --include='*.py' .
Un resultado no es una vulnerabilidad por sí mismo. Compruebe si el valor viene de una petición, un archivo, un campo de base de datos u otra fuente que el atacante pueda cambiar. En un servicio multiinquilino, siga cada ruta que construye una orden Java. Confirme que el nombre de clase y la ruta del JAR vienen de una lista permitida fija, no de datos del inquilino.
¿Cómo lo corrijo?
Actualice a NLTK 3.10.4 o posterior:
pip install --upgrade "nltk>=3.10.4"
- Actualice todos los entornos que instalan NLTK, incluidos contenedores y trabajadores por lotes.
- Reconstruya cualquier imagen que fije 3.10.3.
- Vuelva a comprobar los dos puntos de entrada de "¿Estoy afectado?" después de la actualización.
- Si la aplicación no puede actualizarse de inmediato, deje de pasar valores influidos por el atacante a
cmdojava_class. Use una clase principal fija y una ruta de JAR fija.
Ningún conmutador de configuración cierra la falla en 3.10.3. La biblioteca no expone un ajuste de ejecución que valide el canal cmd. La única corrección es el código de 3.10.4.
La actualización también debe llegar a los entornos que ejecutan el código, no solo al equipo del desarrollador. Reconstruya las imágenes de contenedor que fijan nltk==3.10.3, actualice el archivo de bloqueo que usa el servicio y revise el entorno virtual de cada trabajador. Un paquete instalado en una imagen base puede sobrevivir al despliegue de la aplicación.
¿Cuál es la causa raíz?
nltk.internals.java() es un envoltorio fino alrededor del lanzador de Java. Construye una orden a partir de tres fuentes: una lista options validada, un classpath opcional y la secuencia cmd del llamador. El endurecimiento de 3.10.3 comprobaba las opciones y el sandbox de JAR, pero añadía cmd_list a la orden final sin validar su primer token.
El sandbox de JAR comprueba los archivos nombrados por path_to_jar y classpath. Confirma que están dentro de las raíces de datos de confianza y rechaza los modos unsafe-JAR y unsafe-classpath salvo que la aplicación lo permita. No inspecciona la secuencia cmd, porque esa secuencia debe nombrar la clase principal y sus argumentos de programa, no seleccionar un modo del lanzador.
El código relevante de NLTK 3.10.3 es:
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)
El lanzador de Java trata el primer token que no es una opción como la clase principal. Si cmd_list[0] es -jar, el lanzador cambia al modo JAR y ejecuta el JAR nombrado por el siguiente token. Si es @file, el lanzador expande el archivo de argumentos y toma su contenido como argumentos del lanzador. Ambas formas eluden el validador de opciones, que solo ve el canal options.
La forma @argfile es la más flexible. El lanzador de Java expande un archivo de argumentos allí donde aparezca, así que el token puede seguir a una clase principal legítima y añadir igualmente argumentos del lanzador. La corrección de 3.10.4 rechaza por eso @ en cualquier posición, no solo en el primer elemento.
StanfordSegmenter coloca su argumento público java_class al principio de cmd. En 3.10.3 el constructor guarda el valor sin comprobarlo, y segment_file() y segment_string() construyen una orden cuyo primer elemento es ese valor. Un atacante que controla java_class controla el primer token del lanzador.
Las correcciones anteriores explican la brecha. CVE-2026-12841 añadió la validación de las opciones globales de la JVM. CVE-2026-79675 corrigió el canal options no validado por llamada en 3.10.3. CVE-2026-128138 es el tercer canal: la secuencia cmd, que las correcciones anteriores no cubrían.
¿Cómo se explota?
El aviso publica una prueba de concepto funcional para el envoltorio directo:
nltk.internals.java(
["-jar", "/outside/trusted/roots/controlled.jar"],
classpath=None,
stdout="pipe",
stderr="pipe",
)
El proceso Java inicia el JAR externo. El classpath está vacío y los indicadores de sandbox de JAR de NLTK no están definidos. El JAR está fuera de las raíces de datos de confianza contra las que se comprueba path_to_jar. El mismo resultado se alcanza mediante el envoltorio de nivel superior:
StanfordSegmenter(
path_to_jar=trusted_segmenter_jar,
java_class="@/path/to/controlled-launcher.args",
path_to_model="dummy-model",
java_options=[],
)
El JAR de segmentación de confianza pasa las comprobaciones de suma y classpath. El archivo de argumentos proporcionado como java_class indica después al lanzador que ejecute otro JAR. El aviso indica que el marcador externo se escribió en las tres ejecuciones de prueba antes de que el envoltorio lanzara un error no relacionado.
El atacante debe controlar el primer elemento de cmd o java_class. Es una condición a nivel de aplicación, no un comportamiento predeterminado de NLTK. El aviso no nombra un servicio de red vulnerable ni una víctima. No se conoce explotación en la naturaleza.
La aplicación también debe alcanzar la llamada. Un servicio que expone un punto de conexión fijo con un nombre de clase fijo no da al atacante control sobre la orden. Un servicio que acepta una ruta de modelo, un nombre de clase o una lista de argumentos adicionales para una herramienta Java le da el canal que necesita esta falla.
¿Cómo se desarrolla el ataque?
Un token de clase principal controlado por el atacante se convierte en un conmutador del lanzador de Java, el lanzador ejecuta un JAR externo y el código se ejecuta con el usuario del proceso Python.
¿Qué puede hacer un atacante?
Un atacante que controla el primer token cmd puede ejecutar un JAR arbitrario en un nuevo proceso Java. Ese proceso se ejecuta con el mismo usuario del sistema que la aplicación Python. Hereda el entorno de la aplicación, incluidas las credenciales y el acceso a archivos. Se ejecuta fuera de las comprobaciones de JAR y classpath que NLTK aplica a path_to_jar y classpath.
La JVM hija es un proceso normal del sistema operativo. Puede leer las variables de entorno de la aplicación, abrir cualquier archivo al que el usuario tenga acceso y establecer conexiones de red salientes. Puede escribir un archivo de persistencia, iniciar un proceso en segundo plano o leer un secreto montado.
Los indicadores de sandbox de JAR de NLTK son comprobaciones de aplicación sobre los JAR que ejecuta el envoltorio. No son un sandbox de seguridad de Java y no limitan lo que puede hacer una JVM en ejecución.
El mismo acceso está disponible mediante StanfordSegmenter.java_class cuando una aplicación construye ese valor a partir de una entrada no confiable. El aviso demuestra el envoltorio directo y la ruta del wrapper.
Las condiciones son NLTK 3.10.3, una llamada a java() o a un envoltorio de Stanford y una influencia del atacante sobre el primer token de la orden. Sin esa influencia, el atacante no tiene ruta. El aviso no muestra una configuración predeterminada que exponga la falla en la red.
¿Por qué funciona la corrección?
NLTK 3.10.4 añade una protección antes de ensamblar la orden. El commit de corrección es 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 protección rechaza un primer token ausente o no textual, cualquier primer token que empiece por - o @, y cualquier @argfile en cualquier posición. Compara el token sin espacios, así que un prefijo de espacio no puede ocultar un conmutador del lanzador. Se ejecuta después de los validadores de opciones y classpath, así que una opción hostil sigue siendo notificada por su propia ruta de error.
El commit añade pruebas de regresión para conmutadores del lanzador, archivos de argumentos, tokens vacíos o no textuales, tokens con prefijo de espacio y una clase principal legítima con argumentos de programa. Una prueba de mutación demuestra que el validador de opciones es determinante. Esas pruebas cubren los casos del aviso y las variantes de espacio que una comprobación de cadena ingenua pasaría por alto.
La corrección conserva los argumentos de programa legítimos que empiezan por - después de una clase principal real, como la opción -loadClassifier de Stanford. Cierra el canal cmd que el validador de opciones de 3.10.3 no cubría. Las notas de la versión 3.10.4 describen el cambio más amplio como ejecutar Java solo desde ubicaciones absolutas de confianza, con opciones y entradas validadas.
¿Cómo compruebo si estuve comprometido?
El aviso no publica indicadores de compromiso. Una ejecución correcta deja las mismas huellas que cualquier proceso Java iniciado por la aplicación.
# 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'
Busque una ruta -jar inesperada o un @argfile que la aplicación no haya desplegado. Revise los registros de la aplicación en busca de peticiones que alcanzaron las rutas cmd o java_class. Si la aplicación no registra esos valores, un intento pasado puede no dejar rastro.
La ausencia de un proceso sospechoso no demuestra que no ocurriera nada. Un JAR de corta duración puede terminar antes de que se ejecute una comprobación de procesos. Correlacione con los registros de la aplicación, las conexiones de red salientes y las escrituras de archivos en el directorio de trabajo. Si la aplicación registra los argumentos pasados a java(), busque en esos registros -jar, @ y nombres de clase que no estén en el despliegue.
Cronología
- 2026-08-12: NLTK 3.10.3 publicó el endurecimiento para CVE-2026-79675.
- 2026-08-19: se escribió el commit de corrección del canal
cmd. - 2026-10-21: NLTK 3.10.4 se publicó en PyPI.
- 2026-11-19: GitHub publicó GHSA-x8q7-6c7m-52gw y el registro CVE-2026-128138.
Preguntas frecuentes
- ¿NLTK 3.10.4 es una versión de seguridad? Sí. Cierra el canal
cmddescrito aquí, y sus notas de versión describen un endurecimiento amplio del sandbox y de la validación de entradas. - ¿Afecta a todas las aplicaciones NLTK? No. La aplicación debe pasar valores influidos por el atacante a
java()o aStanfordSegmenter.java_class. Un script con nombres de clase fijos no está expuesto. - ¿Se explota en la naturaleza? No se conoce explotación, y la CVE no está en CISA KEV al 20 de noviembre de 2026. El aviso incluye una prueba de concepto pública.
- ¿Es 3.10.3 la única versión afectada? Sí para esta CVE. El rango afectado del aviso va de 3.10.3 hasta 3.10.4, sin incluirlo.
- ¿Puedo mantener 3.10.3 y validar la orden yo mismo? Puede rechazar un
cmdcuyo primer token empiece por-o@antes de llamar ajava(). Eso repite la protección de 3.10.4 en el código de la aplicación y es fácil pasarla por alto en una ruta de llamada, así que la actualización es más segura. - ¿La corrección bloquea opciones Java legítimas? No. Bloquea conmutadores del lanzador y archivos de argumentos en el canal
cmd. Una clase principal real seguida de-loadClassifiery otros argumentos de programa sigue funcionando.
Encuentre las versiones de NLTK en sus aplicaciones con Ostorlab
El análisis de composición de software y el SBOM de Ostorlab inventarían las bibliotecas que incluye una aplicación, incluidos los paquetes de Python y sus versiones. Encuentra NLTK 3.10.3 antes de que llegue a producción: https://www.ostorlab.co/product/sca_sbom
Referencias
- Aviso de NLTK GHSA-x8q7-6c7m-52gw: https://github.com/nltk/nltk/security/advisories/GHSA-x8q7-6c7m-52gw (comprobado el 20 de noviembre de 2026)
- Registro de CVE-2026-128138: https://www.cve.org/CVERecord?id=CVE-2026-128138 (comprobado el 20 de noviembre de 2026)
- Commit de corrección de NLTK b3621279: https://github.com/nltk/nltk/commit/b36212795a522d2b7b176cf0e0d9d8da489ba6e6 (comprobado el 20 de noviembre de 2026)
- Pull request de NLTK 3771: https://github.com/nltk/nltk/pull/3771 (comprobado el 20 de noviembre de 2026)
- Versión NLTK 3.10.4: https://github.com/nltk/nltk/releases/tag/v3.10.4 (comprobado el 20 de noviembre de 2026)
internals.pyen NLTK 3.10.3: https://github.com/nltk/nltk/blob/v3.10.3/nltk/internals.py (comprobado el 20 de noviembre de 2026)stanford_segmenter.pyen NLTK 3.10.3: https://github.com/nltk/nltk/blob/v3.10.3/nltk/tokenize/stanford_segmenter.py (comprobado el 20 de noviembre de 2026)- Aviso anterior GHSA-m4rf-3fr8-xwx3: https://github.com/nltk/nltk/security/advisories/GHSA-m4rf-3fr8-xwx3 (comprobado el 20 de noviembre de 2026)
- Estadísticas de descargas de PyPI para NLTK: https://pypistats.org/packages/nltk (comprobado el 20 de noviembre de 2026)
- Catálogo KEV de CISA: https://www.cisa.gov/known-exploited-vulnerabilities-catalog (comprobado el 20 de noviembre de 2026)