Ohler55

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Description** Oj é um parser JSON e marshaller de Objetos para Ruby. A função `Oj.load` está suscetível a corrupção de heap ao processar uma string JSON superior a 2 GB. Ocorre um estouro de inteiro (integer overflow) na função `buf append string()` (localizada em `buf.h:61`), onde o comprimento da string é convertido em um `size t` negativo de grande magnitude. Isso faz com que o `memcpy` copie uma quantidade excessiva de dados fora dos limites, resultando no travamento do processo e na corrupção da memória heap adjacente. O problema é desencadeado durante a manipulação de sequências de escape na função `read escaped str()`, onde o comprimento restante da string é computado incorretamente como um `int`. **Recommendations** Atualize o Oj para a versão 3.17.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Description** Ao operar no modo de objeto, a função `Oj.dump` está suscetível a um estouro de buffer de heap (heap buffer overflow) durante a serialização de objetos Exception se um valor de `:indent` elevado for utilizado. O problema ocorre porque o serializador aloca um buffer com base nos atributos do objeto, mas não contabiliza os bytes adicionais necessários para a indentação a cada gravação. Por exemplo, o uso de `indent: 5000` pode fazer com que o acúmulo de strings de indentação exceda a memória de heap alocada, resultando em corrupção de memória. Este processo envolve a função `fill indent()`, que é chamada repetidamente por `dump obj attrs()` ao processar atributos de um objeto Exception. **Recommendations** Atualize o Oj para a versão 3.17.2 ou posterior. Evite usar valores extremos para o parâmetro `:indent` e não permita que os usuários especifiquem tamanhos de indentação ilimitados ao realizar o dump de dados Ruby.

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Description** Os iteradores Oj::Doc (`each value`, `each child`, `each leaf`) estão sujeitos a um heap use-after-free. Isso ocorre quando um bloco Ruby executado durante a iteração chama `doc.close` ou `d.close`, fazendo com que a memória heap do documento seja liberada enquanto o iterador C ainda está ativo. Ao retornar o controle do bloco, o iterador tenta ler a região de memória liberada, tornando o use-after-free acessível a partir do Ruby puro. **Recommendations** Atualize o Oj para a versão 3.17.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** oj gem (versões afetadas não especificadas) **Description** Ocorre um use-after-free de heap em `Oj::Parser#parse` quando um callback SAJ/SAJ2 altera a string JSON de entrada durante o processo de parsing. O mecanismo em C mantém um ponteiro bruto para o buffer interno da string Ruby. Se um callback, como `hash start()`, redimensionar a string (por exemplo, via `String#replace`), o Ruby realoca o buffer e libera a memória original. Isso deixa o parser C com um ponteiro pendente, levando a um use-after-free quando o próximo caractere é lido. **Recommendations** No momento, não há informações sobre uma versão mais recente que contenha a correção para esta vulnerabilidade.

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Description** Ocorre um use-after-free de heap ao desativar `symbol keys` em uma instância reutilizada de `Oj::Parser`. Quando a configuração `symbol keys` é alterada de `true` para `false`, a função `opt symbol keys set` libera o cache de chaves interno usando `cache free`, mas não limpa o ponteiro. Consequentemente, a chamada subsequente à função `parse` tenta ler do cache liberado via `cache intern`, resultando em uma condição de use-after-free. **Recommendations** Atualize para a versão 3.17.2 ou posterior.

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Description** Ao operar no modo usual com `create id` habilitado, a função `Oj::Parser#parse` está suscetível à corrupção de heap. Isso ocorre quando uma chave de objeto JSON possui exatamente 65.535 bytes, levando a um truncamento de inteiro dentro da função `form attr()`. O truncamento converte o comprimento para -1 antes de ser passado para o `memcpy`, fazendo com que o sistema copie `SIZE MAX` bytes. Isso resulta na corrupção da memória heap e causa a falha do processo. **Recommendations** Atualize para a versão 3.17.2 ou posterior. Como medida paliativa temporária, evite usar a função `Oj::Parser#parse` no modo usual com `create id` habilitado ao processar entradas JSON não confiáveis.

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Descrição** O Oj::Parser no modo usual não marca as referências `array class` e `hash class` durante a coleta de lixo (GC), resultando em uma condição de Use-After-Free. Se o GC for executado após a classe ser atribuída, mas antes de uma operação de análise, o objeto da classe é recuperado, deixando o parser com um VALUE pendente. Uma chamada subsequente à função `parse()` desreferencia esse objeto liberado, levando a um erro de segmentação (segfault). Isso ocorre porque a função `parser mark()` em `ext/oj/parser.c` não passa o `array class` para `rb gc mark()`, fazendo com que o GC colete a classe referenciada. A falha ocorre especificamente quando `close array class()` chama `rb funcallv()` no VALUE da classe coletada. **Recomendações** Atualize para a versão 3.17.2.

**Nome do Software Vulnerável e Versões Afetadas** Oj versões anteriores a 3.17.2 **Description** O Oj é um parser JSON e marshaller de Objetos para Ruby. Um problema de Use-After-Free ocorre ao utilizar o `Oj::Parser` no modo SAJ. O parser não protege chaves de objetos em cache com 35 bytes ou mais contra a coleta de lixo (garbage collection). Se um callback Ruby disparar a coleta de lixo dentro da função `hash end`, a string da chave pode ser recuperada enquanto o parser C ainda mantém um ponteiro para ela. O acesso subsequente a esse valor de string liberado pode resultar em um erro de segmentação (segfault), potencialmente permitindo o controle sobre o conteúdo da memória liberada. **Recommendations** Atualize o Oj para a versão 3.17.2 ou posterior.

**Nome do software vulnerável e versões afetadas** Versões do Optica anteriores à 0.10.2 **Descrição** Uma vulnerabilidade de execução remota de código no Optica permite que invasores não autenticados executem código arbitrário por meio de cargas JSON especialmente criadas. Isso pode levar à execução remota de código no sistema atacado que execute o Optica. **Recomendações** Para versões anteriores à 0.10.2, atualize para a versão 0.10.2 ou posterior, na qual a chamada à função `oj.load` foi alterada para `oj.safe load` para resolver a vulnerabilidade.