A extensão nativa C do JSON do Ruby limpa o buffer de entrada 'JSON::ResumoParser' consumido, mas deixa 'state.start', `state.cursor' e `state.end' apontando para o armazenamento liberado. Quando `partial_ value` reconstrui um objeto incompleto contendo teclas duplicadas, o caminho de aviso de tecla duplicada chama ` cursor_ position`, o que desrefere aqueles ponteiros estáveis. Isto resulta em um uso em pilha- livre após- e pode terminar o processo Ruby. Um atacante que pode fornecer dados do stream JSON a um aplicativo usando `JSON::ResumableParser` pode causar a terminação do processo quando o aplicativo chamar `partial_value' em entrada incompleta controlada pelo atacante contendo chaves de objeto duplicado. O problema foi reproduzido na extensão C nativa das versões oficiais do RubyGems: * JSON 2.20.0 * JSON 2.21.0 * JSON 2.21.1. A evidência anexa demonstra: * um endereço sanitário-confirmado- uso em pilha-após-livre; * um nativo `SIGSEGV` usando o JSON oficial 2.21.1 RubyGem; * um ataque TCP de loop- to- end/ reprodução de vítimas; * quatro controles diferenciais; * execução bem sucedida após aplicação de um controle de patch testado.

Isto foi originalmente reportado em privado através do programa HackerOne do Ruby como relatório `# 3867755 `. Um mantenedor Ruby confirmou de forma independente a reprodução do falhado do ASan e solicitou que a coordenação continuasse através deste aconselhamento privado. Não é reclamada a execução de código ou divulgação de informações. ``` text ext/json/ ext/ parser/ parser.c ```. A sequência vulnerável no JSON 2.21.1 é: 1. `cResumableParser_parse` chega ao fim do buffer de entrada atual. 2. Chama `json_str_clear(parser->buffer)`. 3. Ele define `parser->buffer = Qfalse`. 4. Os ponteiros do estado de análise no buffer liberado não são reiniciados. 5. `partial_ value` faz uma cópia superficial do estado de análise. 6. Reconstruir um objeto incompleto contendo teclas duplicadas atinge o caminho de aviso de tecla duplicada. 7. ` cursor_ position` passa pelos ponteiros de entrada estáveis e lê a memória liberada. Localização da fonte relevante. * Release do buffer: 61 def 38 b 9 bb 859 taxa 7 eec 8 e 7 d 3143600 e 5 b 347 /ext/json/ext/parser/parser.c#L 2562 - L 2569 * Cópia do estado de Parser: 61 def 38 b 9 bb 859 taxa 7 eec 8 e 7 d 3143600 e 5 b 347 /ext/json/ext/parser/parser.c#L 2647 - L 2654.

* Ponto de estaleiro lido em ` cursor_position`: 61 def 38 b 9 bb 859 taxa 7 eec 8 e 7 d 3143600 e 5 b 347 /ext/json/ext/parser/parser.c#L 590 - L 628 * Caminho de manipulação de teclas duplicadas: 61 def 38 b 9 bb 859 taxa 7 eec 8 e 7 d 3143600 e 5 b 347 /ext/json/ext/parser/parser.c#L 1196 - L 1255 Quando a entrada é fornecida ao analisador resumible, o estado do analisador armazena ponteiros diretos para a cadeia Ruby de suporte: ```c RSTRING_GETMEM( parser->buffer, start, len); parser->state.start = start; parser->state.end = start + len; parser->state.cursor = parser->state.start + offset; ``` Depois que o buffer atual foi consumido, o `cResumableParser_parse` limpa a string e remove a referência do analisador a ele: ```c if (eos(&parser->estate)) { json_str_clear(parser->buffer); analisador->buffer = Qfalse; } ```. Este caminho não invalida nem substitui:.

``` text parser->state.start parser->state.cursor parser->state.end ```. "JSON::ResumoParser#partial_value` subsequentemente faz uma cópia superficial da estrutura do analisador: ```c JSON_ResumableParser *original_parser = cResumableParser_get(self); JSON_ResumableParser = *original_parser; ```. Quando o objeto parcial contém teclas duplicadas, a reconstrução segue este caminho de chamada: ```texto cResumoParser_partial_value_body -> json_decode_object -> json_on_duplicate_key -> emit_duplicate_key_warning -> emit_parse_warning -> cursor_position ``` ` cursor_ position` então lê através de ponteiros que podem se referir ao armazenamento liberado. Relatórios do Sanitizer de Endereço. ``` Texto ERROR: Endereço Sanitente: uso do pilha após a posição livre do cursor no analisador.c: 604 Liberado pelo cResumableParser_parse no parser.c: 2567 ``` O reprodutor segue a sequência API de resumo- parser normal. ``` Ruby parser << bloco parser.parse parser << next_chunk parser.parse parser.parcial_value ```.

O problema não requer. * uma chamada de volta definida pelo aplicativo; * coleta explícita de lixo; * reentrança do analisador; * opções personalizadas do analisador; * um objeto Ruby fornecido pelo atacante; * modificação manual do estado do analisador nativo. O crash de lançamento-construção reproduzido no JSON 2.20.0, 2.21.0, e 2.21.1. Este relatório cobre a implementação nativa da extensão C. A implementação separada da plataforma Java não foi testada e não é alegada como afetada. O pacote de evidências completo está anexado como. ``` texto ruby-json-resumible-partial- value- uaf- evidence-- 20260716.zip ``` ``` Texto 07 bf 8 d 47 b 115 e 45 d 6145 d 0447 ab 6 c 1 c 0255 e 4 a 7 e 9 b 2 fb 55 c 3 c 9 a 0 e 24406134 ac ``` * Linux * Ruby com cabeçalhos de desenvolvimento * compilador C * `make` * RubyGems.

#### Construção de lançamento, rede e reprodução diferencial. ```sh umzip ruby-json-resumible-partial-value- uaf- evidência- 20260716.zip cd ruby-json-resumible-partial- value- uaf- evidence-- 20260716 ``` Execute o JSON oficial 2.21.1 Release- build proof, loopback network proof e controles diferenciais: ```sh./run_exact_ 2211.sh ```. Resultados primários esperados: ``` texto release_ saída= 139 network_victim_exit= 139 network_result=PASS result=PASS ```. Os quatro controles diferenciais a seguir devem também relatar `result=PASS`: ```text unique_key duplicate_llowed no_partial complete_document ```. A pilha de falhas de lançamento-construção inclui: ```texto cursor_position emit_parse_warning emit_duplicate_key_warning json_decode_object cResumoParser_partial_value_body ```. Reprodução do Sanitizer de Endereço.

```sh./run_asan.sh ```. Resultado vulnerável esperado: ``` texto asan_vulnerável_exit= 134 ERROR: Endereço Sanitente: posição do cursor livre após o uso do pilha no analisador.c: 604 Liberado pelo cResumableParser_parse no parser.c: 2567 ``` Resultado de controle corregido esperado. ``` Texto asan_patched_exit= 0 asan_result=PASS ``` #### Matriz de Versão Afectada. O crash de lançamento- compilação foi reproduzido três vezes para cada uma das seguintes versões oficiais de RubyGems: ``` text json 2.20.0 json 2.21.0 json 2.21.1 ```. Evidências adicionais estão incluídas em: ````text artefatos/exato- 2211 - e 2 e.txt artefactes/asan-and-patched-control.txt artefactes/version-matrix.txt artefactes/source-and-release-verification.txt source-slices.txt prior-art.md patch-control.diff ```.

Este é um uso- depois- livre que pode resultar na terminação do processo Ruby nativo. Um atacante deve ser capaz de fornecer dados do stream JSON a um aplicativo que: 1. usa `JSON:: ResumoParser`; 2. processa entrada de transmissão controlada pelo atacante; 3. chama `partial_ value' após analisar um documento incompleto contendo chaves de objeto duplicadas. Em implantações orientadas para a rede que satisfaçam estas condições, um atacante pode causar a terminação do processo e a negação de serviço. O crash de lançamento- compilação foi reproduzido de forma consistente no ambiente Linux testado. O resultado do Endereço Sanitente confirma o uso- após- livre do pilha subjacente independentemente do comportamento normal do allocador.

O impacto demonstrado é. ``` Texto Negação de serviço através da terminação do processo nativo ``` Não é alegado impacto de confidencialidade, impacto de integridade, execução arbitrária de código ou divulgação de informações. ### Remediação sugerida. Antes de limpar ou liberar o buffer de entrada do analisador resumido, invalide ou substitua cada ponteiro do estado do analisador que se refere ao armazenamento de backup do buffer. Os caminhos de código atrasados, como a geração de avisos de teclas duplicadas, não devem calcular as posições do cursor usando ponteiros após o buffer correspondente ser liberado. O `Patch-control.diff` anexo demonstra um controle testado e é fornecido para validação em vez de como uma implementação final necessária.

Registro de aconselhamento: GHSA- 9 hj 4 - r 449 -HFVC. Identificadores relacionados: CVE- 2026 - 71847. Tempo: GitHub Advisory Database publicou este registro em 2026 - 08 - 07 T 18: 33: 12.000 Z e lista a sua última modificação como 2026 - 08 - 07 T 18: 33: 13.000 Z. Severidade: LOW. Nenhum vetor de pontuação está listado no registro. Software afetado e informações de versão: pacote RubyGems json — ECOSISTEM: introduzido 2.20.0, corrigido 2.21.2. Classificação e evidência: identificadores de fraqueza CWE- 416. O registro contém 2 suporte de referências nestes tipos: WEB, PACKAGE.