A mitigação `maxLength` adicionada em ` 5.0.8 ` para GHSA- mh 99 - v 99 m- 4 gvg / CVE- 2026 - 14257 está incompleto. Ele limita o acumulador onde os resultados são * combinados*, mas não os arrays intermédios que o alimentam. A ~ 25 A entrada do KB ainda bloqueia o processo do Nó com um erro extra- memória ** incaptável**, então "tentar/ capturar" em torno de "expand()" não ajuda. Um segundo caminho relacionado na mesma função permite que um ~ 400 A entrada do KB bloqueia o loop do evento por mais de dois minutos sem exceder a memória ligada. `maxLength` foi forçado em `combine()`, a saída de um único lugar cresce. Dois arrays são construídos * antes de* ` combine()` executados, e nenhum foi limitado. ** 1. Alternativas de vírgula acumuladas sem um total em execução (exaustão da memória)**.

Cada alternativa em `{a,b,c,...}` é expandida por sua própria chamada recursiva `expand_()`, para que cada uma receba um subsídio completo e independente `maxLength`. Os resultados foram então concatenados em um único array de "valores" sem limite cumulativo: ````js valores = [] para (deixe j = 0; j < n. longh; j++) { valores.push.apply(valores, expand_(n[j], max, maxLongth, false)) } acc = combinar(acc, pre, valores, max, maxLongth,...) ```. Com alternativas `A`, `valores` podem alcançar caracteres `A * maxLength` antes que ` combine()` tenha a chance de troncar. No padrão `maxLongth` de 4,000,000 e 400 alternativas, que já passou de qualquer montão padrão.

** 2. Seqüências acolchadas ignoram `maxLength` enquanto geram (exaustão da CPU)**. "expandSequence()" foi delimitado por "max" (o resultado *count*) mas nunca consultou "maxLength". A largura de um elemento de uma sequência acolchoada segue a entrada, por isso ` { 0... 01.. 100000 }` com um amplo pad gera elementos `max`, cada um tão amplo quanto a entrada, apenas para ` combine()` descartar todos menos um punhado. A memória permanece plana aqui, porque V 8 representa as strings acolchoadas como strings de cons, o que é provável por isso que este caminho não foi capturado ao lado do problema original. O custo é tempo: trabalho proporcional a `max * largura '. Largura do pad Os resultados de entrada mantiveram o tempo ( 5.0.8 ). Tempo (padrão).----------------------------- 20,000 | 20 KBň 199 | ~ 7.3 sї ~ 20 Ms-. 100,000 | 100 KBň 39 | ~ 32 sї ~ 20 Ms-. 400,000 | 400 KBň 9 | ~ 124 sї ~ 18 msÌ.

A saída é byte- idêntica antes e depois da correção; somente o trabalho desperdiçado é removido. ### Prova de conceito. Exaustão da memória, contra ` 5.0.8 `: ````js import { expande } de 'brace- expansion'. const part = '{' + ' 0 '.repetir( 50 ) + ' 1.. 100000 }' const entrada = '{' + Array( 400.fill( parte).join(',') + '}' // ~ 25 KB.

tentar { expand( input) } captura (e) { // nunca alcançado - o processo já está morto } ``` ``` ERROR FATAL: Marcas ineficazes perto do limite do pilhado Alocação falhou - JavaScript mule fora de memória Interrompiu ``` Atrapalhamento do loop do evento, contra o ` 5.0.8 `. ````js import { expande } de 'brace- expansion'.

// ~ 400 Input de KB, retorna 9 resultados após aproximadamente dois minutos de bloqueio da CPU expand( '{' + ' 0 '.repetir( 400 _ 000 ) + ' 1.. 100000 }') ``` Negação de serviço. Qualquer aplicativo que passe a entrada controlada pelo atacante para `expand()`, diretamente ou transitivamente através de uma biblioteca globou ou padrão- pareamento, pode ser remotamente bloqueado ou parado. A variante fora da memória termina o processo e não pode ser manipulada com o `try/catcha'. Aplicações já no ` 5.0.8 ` são afetados: o ` 5.0.8 ` a mitigação não cobre estes caminhos.

Ambos os arrays intermédios estão agora limitados à medida que são construídos, usando os mesmos limites `max` e `maxLength` já aplicados em ` combine()`: - ` values` rastreia uma contagem de resultados em execução e comprimento de caracteres enquanto as alternativas são anexadas, e para quando ambos os limites são atingidos. - `expandSequence()` aceita `maxLength` e para de gerar uma vez que os próprios caracteres da sequência o atingem. Como com os limites existentes, a saída é truncada em vez de permitir que cresça sem limites, o que combina com o comportamento de `max`. Os padrões estão bem acima de qualquer expansão realista, por isso a entrada legítima não é afetada.

Se a atualização não for imediatamente possível, evite passar entrada não confiável para `expand()` ou para padrões de bretch glob, ou passar um `max` ** e** `maxLength' explicitamente pequeno. Note que um pequeno `maxLength` por si só não era suficiente nas versões afetadas: foi aplicado por alternativa em vez de cumulativamente, que é a raiz do primeiro número acima. O bypass de exaustão de memória foi relatado por Alessio Della Libera, CEO e Co- fundador em [Numyra](.

O problema de geração de sequência foi encontrado ao verificar o relatório. Registro de aconselhamento: GHSA-rgw 5 - rvv 9 - x 895. Identificadores relacionados: CVE- 2026 - 69152. Tempo: GitHub Advisory Database publicou este registro em 2026 - 08 - 03 T 16: 35: 32.000 Z e lista a sua última modificação como 2026 - 08 - 03 T 20: 17: 19.000 Z.

Severidade: ALTAMENTE. Dados de pontuação publicados: CVSS_V 3: CVSS: 3.1 /AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H. Software afetado e informações de versão: expansão de brace-package npm — ECOSISTEM: introduzido 0, corrigido 1.1.18. npm pacote de expansão de brace — ECOSISTEM: introduzido 2.0.0, corrigido 2.1.4. npm pacote de expansão de brace — ECOSISTEM: introduzido 3.0.0, corrigido 3.0.6. npm pacote de expansão de brace — ECOSISTEM: introduzido 4.0.0, corrigido 5.0.9. Classificação e evidência: identificadores de fraqueza CWE- 400, CWE- 770. O registro contém 7 suporte de referências nestes tipos: WEB, AVISO, EMBALAGAMENTO.