Ruby corrige 7 falhas em regex e strings; 5 têm PoC para execução remota de código (RCE)
19 de Novembro de 2026

O Ruby contém sete falhas de segurança de memória em seu mecanismo de expressões regulares e no código responsável pela conversão entre maiúsculas e minúsculas. Segundo os mantenedores, códigos de prova de conceito demonstraram que cinco delas podem permitir a execução de código na máquina.

“Temos conhecimento de códigos de prova de conceito que demonstram que algumas dessas falhas podem ser usadas para provocar a execução remota de código”, disseram os mantenedores.

O projeto lançou ontem as versões corrigidas: Ruby 4.0.10, 3.4.13 e 3.3.14. O risco para cada aplicação depende de um invasor conseguir fornecer padrões ou textos especialmente elaborados ao código vulnerável. Até o momento, os avisos não relatam ataques.

As outras duas falhas são menos graves. Uma delas tem um código de prova de conceito que provoca corrupção de memória controlada pelo invasor, mas ainda não há demonstração de execução de código. A outra permite apenas ler áreas indevidas da memória ou fazer o programa travar.

O projeto detalhou as sete falhas em um comunicado de segurança e em avisos individuais. Os avisos classificam três como críticas, três como altas e uma como moderada, além de indicar quais têm códigos de prova de conceito para execução remota de código. A lista, em ordem de gravidade, é a seguinte:

- **Crítica.** GHSA-34m4-m9fh-gqp5: estouro de um byte na memória dinâmica quando o Ruby converte textos entre maiúsculas e minúsculas em determinadas codificações de byte único, como ISO-8859-1 ou Windows-1252. Há um código de prova de conceito para execução remota de código. (Aviso do GitHub)
- **Crítica.** GHSA-7x2q-68qv-6p8x: liberação dupla de memória quando o Ruby compila uma expressão regular especialmente elaborada que usa a interseção de classes de caracteres (`&&`). Há um código de prova de conceito para execução remota de código. (Aviso do GitHub)
- **Crítica.** GHSA-3p8q-wmhx-vm2w: estouro de memória dinâmica quando o tamanho de uma expressão regular compilada excede o limite durante a compilação. Há um código de prova de conceito para execução remota de código. (Aviso do GitHub)
- **Alta.** GHSA-87fm-7w84-j2px: estouro de memória dinâmica quando a conversão entre maiúsculas e minúsculas produz um resultado maior que 4 GiB. Há um código de prova de conceito para execução remota de código, embora o tamanho necessário torne o ataque inviável na maioria das solicitações. (Aviso do GitHub)
- **Alta.** GHSA-7whj-cfh7-xgm4: estouro de memória dinâmica quando o Ruby converte em texto uma expressão regular compilada especialmente elaborada com `Regexp#to_s`. Há um código de prova de conceito para execução remota de código. (Aviso do GitHub)
- **Alta.** GHSA-wpqw-5qxg-m68r: leitura fora dos limites durante uma comparação sem distinção entre maiúsculas e minúsculas. O código de prova de conceito demonstra corrupção de memória controlada pelo invasor. Segundo os mantenedores, a execução remota de código é possível, mas ainda não foi demonstrada. (Aviso do GitHub)
- **Moderada.** GHSA-pvgc-g7gj-pv6h: leitura fora dos limites quando o Ruby compara uma referência retroativa sem distinção entre maiúsculas e minúsculas com um texto de entrada especialmente elaborado. O aviso afirma que a falha “pode revelar conteúdo da memória ou fazer o processo travar”. (Aviso do GitHub)

O projeto atribuiu quatro das descobertas a Stephan Lipp, da Ada Logics e da Anthropic. As outras três foram reportadas por baba__yaga, aphantom, Hiroya Fujinami e Hiroshi SHIBATA.

Quais aplicações estão expostas

As falhas estão no próprio código do Ruby, portanto todas as aplicações que usam uma versão afetada estão vulneráveis. A possibilidade de um invasor alcançar o código depende de como a aplicação processa dados externos.

As falhas nas expressões regulares exigem que a aplicação crie uma expressão regular a partir de dados controlados pelo invasor e depois a compile ou execute. Comparar textos não confiáveis com um padrão escrito pelos desenvolvedores não representa o mesmo risco, com uma exceção descrita abaixo.

As duas falhas relacionadas à conversão entre maiúsculas e minúsculas não envolvem expressões regulares. Elas são acionadas quando a aplicação converte um texto especialmente elaborado. Por isso, vale revisar os trechos de código que fazem essa conversão em textos importados ou recebidos de fontes externas.

A exceção é a falha moderada de leitura. Ela ocorre quando a aplicação compara um texto de entrada especialmente elaborado com um padrão fixo que usa uma referência retroativa sem distinção entre maiúsculas e minúsculas. O comunicado e os avisos não incluem o código de prova de conceito.

As correções estão nas versões Ruby 4.0.10, 3.4.13 e 3.3.14. As versões afetadas são:

- Ruby 4.0.0 a 4.0.9, corrigidas na versão 4.0.10.
- Ruby 3.4.0 a 3.4.12, corrigidas na versão 3.4.13.
- Ruby 3.3.13 e anteriores, corrigidas na versão 3.3.14.
- Ruby 3.2 e anteriores, fora de suporte e sem correção.

Essas versões mais antigas não receberão uma correção, e o projeto recomenda migrar para uma linha ainda mantida. Com a versão 3.3.14, os mantenedores mudaram a classificação da fase do Ruby 3.3, de manutenção de segurança para manutenção legada. O suporte ainda termina no fim de março de 2027.

Como as correções fazem parte do Ruby, atualizar as bibliotecas ou o framework de uma aplicação não substitui um interpretador vulnerável. É preciso atualizar a versão do Ruby em execução nos servidores de aplicações, nos processos em segundo plano e nas imagens de container. Depois, esses componentes devem ser reiniciados ou recriados.

As sete falhas ainda não têm números CVE. O projeto informou que solicitou a atribuição desses identificadores. Até que sejam definidos, os códigos dos avisos do GitHub são a única forma de rastrear as falhas em ferramentas de varredura e inventários de software.

Esta é a segunda vez em um mês que o projeto corrige o mecanismo de expressões regulares. Nas correções lançadas em 23 de outubro, foram publicadas as versões Ruby 4.0.9, 3.4.12 e 3.3.13 para corrigir erros de compilação identificados pelo GitLab. Essas falhas estavam na origem de quatro vulnerabilidades críticas do GitLab.

Uma dessas vulnerabilidades levou a uma tentativa de ataque contra o servidor GitLab da própria Alpine Linux. Mais tarde, a CISA incluiu a falha no catálogo KEV, sua lista de vulnerabilidades conhecidas como exploradas, classificando-a como explorada ativamente.

Essas falhas são diferentes das sete divulgadas nesta semana. Os novos avisos não afirmam que o GitLab ou qualquer outro produto citado possa ser atacado por meio delas. O caso de outubro mostrou, porém, que uma expressão regular criada a partir de dados fornecidos por usuários pode se tornar uma via real de acesso a um servidor, e não apenas um risco teórico.

Publicidade

Um novo caminho a ser seguido

Vibecoding cria 10x mais sistemas, 20x mais vulneráveis. E quem ganha com isso é a galera do hacking ético e pentest. Quer ser pago para invadir sistemas? Então você tem que aprender com a Solyd que são os melhores do Brasil. Saiba mais...