Regex no Ruby: Vulnerabilidades do Case Folding Unicode
Sete vulnerabilidades de regex e conversão de caixa no Ruby mostram o case folding do Unicode como risco de memória. Veja como auditar seu código.

Uma aplicação Rails normaliza endereços de e-mail chamando upcase antes de salvá-los, como recomendam mil tutoriais. Um usuário se cadastra com mueller@straße.example num formulário que, em algum ponto do pipeline, decidiu que Windows-1252 era uma boa codificação. A chamada upcase transforma o ß final em SS — dois bytes onde antes havia um — e escreve um desses bytes além do fim de um buffer no heap. Isso não é hipotético. É uma reconstrução plausível de uma das sete vulnerabilidades de regex e conversão de caixa em strings que o time principal do Ruby acabou de corrigir, várias delas com provas de conceito de execução remota de código funcionando.
O aviso saiu junto com três releases emergenciais — Ruby 4.0.10, 3.4.13 e 3.3.14 — e serve como um bom estudo de caso de uma verdade mais profunda: conversão de caixa parece a operação mais simples de uma biblioteca de strings e, na prática, está entre as mais perigosas. É aí que a especificação gigantesca do Unicode encontra código C com décadas, e essa costura é exatamente onde os overflows de heap crescem.
Sete Bugs, Dois Subsistemas, Uma Causa Raiz
Os sete avisos (rastreados por identificadores GHSA enquanto os números CVE avançam por um processo de atribuição atrasado) se agrupam em duas famílias. Dois estão na conversão de caixa de String: um overflow de buffer no heap de um byte e um integer overflow que se propaga para um overflow de heap. Cinco estão no motor de expressões regulares do Ruby — um double free durante a compilação de padrões, um integer overflow na compilação, uma leitura fora dos limites na busca case-insensitive, uma leitura fora dos limites na busca case-insensitive de backreferences e um overflow de buffer no heap em Regexp#to_s.
Repare no que os une. Não é código descuidado no sentido usual — o core em C do Ruby é antigo, testado em batalha e muito submetido a fuzzing. O que os une é que os dois subsistemas implementam a semântica de caixa do Unicode, e essa semântica é uma armadilha. A busca de regex case-insensitive exige dobrar (fold) tanto o padrão quanto a entrada, o que significa que o motor usa as mesmas tabelas de mapeamento traiçoeiras de String#upcase, só que num caminho mais quente e com mais influência do atacante sobre as entradas. Backreferences em modo case-insensitive precisam comparar substrings dobradas. Regexp#to_s precisa reemitir o texto-fonte de um padrão com suas opções, dimensionando um buffer para uma reconstrução que também envolve lógica sensível à caixa. Todos esses caminhos de código precisam responder à mesma pergunta enganosamente difícil: quão grande fica esta string depois que eu mudo a caixa?
O Ruby 3.3 recebe a correção porque ainda está em manutenção de segurança. O Ruby 3.2 e versões anteriores estão no fim de vida e não recebem nada — se você está em alguma delas, este aviso é seu prazo de migração, não um alerta.
Uma Breve História de Conversões de Caixa Dando Errado
Em ASCII, mudar a caixa é inverter um bit. Vinte e seis pares de letras, um para um, preservando o tamanho, independentes de locale. A toupper() da era K&R em C resume a ideia inteira numa tabela de consulta. Este é o modelo mental que a maioria de nós carrega para a vida adulta, e é o modelo embutido na lógica de dimensionamento de buffers em código C do mundo inteiro. Também está errado para praticamente qualquer sistema de escrita além do latim básico.
O Unicode define milhares de mapeamentos de caixa, e uma fatia relevante deles não é um para um. O s alemão (ß) vira SS em maiúsculas. O ligature ff vira FF. Ligaturas armênias se expandem. O grego tem o sigma sensível ao contexto — σ versus ς no fim da palavra — então o dobramento correto depende dos caracteres ao redor. Turco e azeri têm o problema do I com e sem ponto, em que i vira İ e ı vira I, o que quebrou de tudo, de apps Java ao strtoupper do PHP em locales turcos. E o cherokee ganhou letras minúsculas retroativamente no Unicode 8.0, em 2015, transformando um script sem caixa num script com caixa e invalidando premissas em softwares do mundo inteiro.
As codificações legadas pioram tudo. O Windows-1252 tem um byte para o ß minúsculo (0xDF), mas nenhum byte para uma versão maiúscula hipotética — porque, historicamente, o alemão simplesmente nunca usou uma no texto corrido; escrevia-se SS. Então, quando uma rotina de conversão de caixa que opera sobre uma string Windows-1252 encontra ß e substitui corretamente por SS, a string cresce um byte. As análises mais afiadas que circulam após o aviso sugerem que é exatamente esse o overflow de um byte: o laço de conversão parece verificar a folga do buffer caractere por caractere, então um ß posicionado como último caractere de uma string dimensionada no limite produz um S perdido escrito além da alocação. Um overflow de um byte no heap com um S controlado pelo atacante é uma primitiva de exploração chata e delicada — mas o aviso confirma que existem PoCs que chegam a RCE, então alguém fez o trabalho de heap grooming.
Conversão de caixa não é bijetiva, não preserva o tamanho, não é independente de locale e nem sempre é representável em todas as codificações. Código que assume o contrário é uma vulnerabilidade esperando um fuzzer.
Por Que o Motor de Regex é a Preocupação Maior
O motor de regex do Ruby é o Onigmo, um fork do Oniguruma, e é uma peça de software genuinamente impressionante — lida com dezenas de codificações, case folding completo do Unicode, lookbehind, grupos nomeados e backreferences, tudo em C, com camadas que remontam ao fim dos anos 1990. Essas camadas são o problema. Em uma busca case-insensitive no Onigmo, todo ponto de comparação potencialmente executa lógica de dobramento, e dobrar muda tamanhos, então a contabilidade entre offsets do padrão, offsets da string e limites de match é genuinamente intrincada. Dois dos bugs corrigidos são leituras fora dos limites exatamente nessa maquinaria — um na busca case-insensitive em geral, outro especificamente na busca case-insensitive de backreferences, em que o motor compara uma substring capturada anteriormente (e dobrada) com a posição atual.
O modelo de exploração importa mais do que os detalhes internos, porém. Três dos cinco bugs de regex disparam durante a compilação de padrões, e o aviso é direto sobre quem está exposto: aplicações que compilam padrões controlados por atacantes. Você pode achar que isso é raro. Não é. Todo campo de busca envolvido em Regexp.new(query), toda regra de validação configurável carregada de um banco de dados, toda camada de parsing de logs ou de roteamento que monta padrões a partir de arquivos de configuração controlados por um operador (ou por um tenant comprometido) — isso é um caminho de compilação alcançável por entrada hostil. Antes deste aviso, o pior caso de compilar um padrão hostil era um ReDoS: um padrão de backtracking catastrófico que prende a CPU. Irritante, mas recuperável. Agora, o pior caso é corrupção de memória com PoCs de RCE. É um risco categoricamente diferente para a mesma linha de código que você tem em produção há anos.
Há um padrão aqui que vale nomear: a especificação diz uma coisa, o C diz outra, e a lacuna é explorável. Já falamos dessa dinâmica antes — a lacuna entre especificação e implementação é onde os bugs moram — e as tabelas de case folding do Unicode são uma das especificações mais ricas que um programador C pode ser convocado a implementar. As tabelas mudam entre versões do Unicode, as regras de special casing têm subcláusulas, e quem escreveu o código de dimensionamento de buffer em 2003 estava trabalhando com um Unicode menor e mais simples do que o que suas strings recebem hoje.
O Integer Overflow: Quatro Gigabytes Viram Seis Bytes
O segundo bug de string é uma bela ilustração de um modo de falha diferente: aritmética de tamanho de 32 bits em um mundo de 64 bits. Esta prova de conceito, que circulou publicamente após o aviso, usa Shift_JIS e uma string com mais de quatro gigabytes:
str = ("\x82\xA0" + ("A" * (2**32 + 4))).force_encoding(Encoding::Shift_JIS)
puts "str.bytesize: #{str.bytesize}" # 4294967302
new_str = str.downcase
puts new_str.bytesize # 6 on unpatched builds (!)
puts new_str.bytes # [130, 160, 97, 97, 97, 97]
Uma string de 4.294.967.302 bytes entra, e o resultado do downcase informa um tamanho de 6. Em algum ponto do caminho de conversão, um tamanho foi calculado ou truncado por um tipo de 32 bits: 2³² + 6 deu volta e resultou em 6, e a alocação ou cópia subsequente foi dimensionada de acordo — um clássico pipeline de integer overflow que vira overflow de heap. Quatro gigabytes parece uma entrada absurda, mas lembre que strings em um processo em execução não precisam chegar pela rede de uma vez: são montadas a partir de pedaços, de descompressão, de concatenações em jobs de importação e em parsers de arquivos. Um atacante que consegue influenciar quanto dado se acumula em uma string, e depois faz chamarem downcase nela, controla as duas metades desse bug.
Ambos os bugs de string compartilham uma lição de arquitetura com o bug do asterisco no Alpine, de uma década: o código perigoso fica num caminho que ninguém considera superfície de ataque. Ninguém faz threat modeling de upcase. É exatamente por isso que esses bugs sobrevivem por anos — eles ficaram em caminhos que humanos não auditam e que, até recentemente, fuzzers não alcançavam com inteligência suficiente para construir strings multibyte válidas.
Máquinas Encontraram Esses Bugs, e Isso Muda a Conta
Veja os créditos. Quatro dos sete avisos agradecem a Stephan Lipp, da Ada Logics — a empresa por trás de grande parte do desenvolvimento dos harnesses do OSS-Fuzz — e à Anthropic. É um especialista em infraestrutura de fuzzing em par com um modelo de IA, e não é a primeira vez que um aviso recente tem essa assinatura. A linhagem vale ser apreciada: o fuzzing começou com Barton Miller alimentando utilitários Unix com lixo aleatório em 1990, ficou mais esperto com a mutação guiada por cobertura do AFL em 2013, foi industrializado com o OSS-Fuzz martelando continuamente projetos de código aberto a partir de 2016, e agora ganhou uma camada capaz de raciocinar sobre o código — construir uma string Shift_JIS de 4 GiB ou um buffer Windows-1252 terminando em ß exige entender validade de codificação e aritmética de tamanho, não apenas mutar bytes.

A implicação estratégica corta para os dois lados. Defensores ganham auditoria contínua e incansável de bases de código que nenhuma equipe conseguiria revisar à mão. Mas a mesma capacidade está disponível para qualquer pessoa com um modelo e computação, e nem todo mundo abre avisos. A era confortável em que um bug de corrupção de memória num caminho de código obscuro podia contar com anos de vida tranquila está acabando; a economia de encontrá-los desmoronou. Já defendi antes que scanners de IA estão cobrando nossa dívida técnica, e isto é o recibo: um runtime de linguagem usado por milhões, reprovado não por um pesquisador entediado com um fim de semana livre, mas por um pipeline automatizado que simplesmente vai continuar rodando.
Minha posição: isso fortalece o argumento a favor de linguagens com segurança de memória, mas não do jeito simplista em que o debate costuma enquadrar. Reescrever o Onigmo em Rust não teria corrigido a lógica — case folding que muda o tamanho de uma string continua sendo um risco em nível de especificação, e a pergunta sobre o tamanho do buffer ainda precisa ser respondida corretamente. O que a segurança de memória remove é o gradiente de consequências. O bug de lógica vira um panic, um resultado errado, uma requisição falha — não um RCE. Isso não é pouca coisa; é a diferença entre um incidente e um comunicado de indisponibilidade.
Como Auditar Sua Própria Exposição
Comece pelo óbvio e vá se afastando. Atualize para 4.0.10, 3.4.13 ou 3.3.14 — o Onigmo está embutido no build do Ruby, então não há biblioteca separada para corrigir; o runtime é o próprio patch. Depois, audite o código da aplicação em busca das duas formas perigosas: strings influenciadas por atacantes fluindo para operações de caixa, e padrões influenciados por atacantes fluindo para Regexp.new ou Regexp.compile.
- Pare de compilar entrada do usuário em padrões. Se os usuários fornecem termos de busca, escape-os com
Regexp.escape. Se eles realmente precisam do poder de regex, coloque uma allowlist e um timeout rigoroso na frente — e saiba que o timeout ajuda contra ReDoS, não contra corrupção de memória. - Normalize codificações na fronteira de confiança. Os dois bugs de string dependem de codificações exóticas (Windows-1252, Shift_JIS). Se sua aplicação só fala UTF-8, deixe isso explícito nas bordas: force ou converta a codificação na entrada e rejeite o que não converter de forma limpa.
- Prefira comparação sem distinção de caixa a conversão de caixa.
a.casecmp?(b)faz uma pergunta;a.upcase == b.upcasealoca duas strings novas na codificação que a entrada declara. A API de comparação tem uma superfície semântica bem menor. - Faça grep por
upcase,downcase,swapcaseecapitalizeem dados não confiáveis. Cada ponto de chamada é um lugar onde mora uma premissa de tamanho. O mesmo vale para qualquer extensão C que você tenha escrito e que faça sua própria lógica de caixa — essas não ganham nenhum benefício das correções do time principal. - Faça fuzzing do que você mantém. O próprio Ruby é submetido a fuzzing pelo OSS-Fuzz, mas suas extensões C não são. AFL++ ou libFuzzer com ASan vão encontrar no seu código as mesmas classes de bug que as máquinas acabaram de encontrar no Ruby.
- Conheça o status de manutenção do seu runtime. O Ruby 3.2 está no fim de vida e não recebeu essas correções. 'Ainda funciona' não é uma postura de segurança quando o fluxo de patches parou.
Um antes e depois concreto para o padrão mais comum — normalizar nomes de usuário ou e-mails para checagens de unicidade:
# Before: allocates a new string, trusting the input's claimed encoding
def normalize(username)
username.upcase
end
# After: pin the encoding at the boundary, fold for comparison only
def normalize(username)
utf8 = username.encode(Encoding::UTF_8, invalid: :replace, undef: :replace)
utf8.downcase(:fold)
end
# And for comparisons, skip allocation entirely:
def same_user?(a, b)
a.encode(Encoding::UTF_8).casecmp?(b.encode(Encoding::UTF_8))
end
Nada disso deixa você seguro num runtime sem patch — para isso serve a atualização. Mas esses hábitos reduzem a classe de bugs que sua aplicação pode herdar da camada de baixo, e tornam seu próprio código honesto quanto ao fato de que texto não é bytes.

A Lição Mais Profunda para Runtimes de Linguagem
Há a tentação de arquivar isso sob 'C é perigoso, mais um episódio', e as respostas superficiais ao aviso fizeram exatamente isso. Mas eu iria mais fundo. Esses sete bugs não são realmente sobre C — são sobre o descompasso entre um padrão de internacionalização em evolução e premissas de implementação congeladas. O Unicode vai continuar adicionando scripts e refinando mapeamentos. Todo runtime de linguagem do planeta tem código de conversão de caixa escrito com base em alguma versão antiga dessas tabelas, dimensionado por alguma compreensão antiga de quanto uma string pode crescer. O Ruby foi pego neste mês; a próxima vez será o motor de regex, o case folder ou a rotina de normalização de outra pessoa.
A conclusão prática é tratar a transformação de texto como fronteira de segurança, não como função utilitária. Tudo que recodifica, muda a caixa, normaliza ou dobra é um parser, e parsers são onde os bugs de memória vivem. A conclusão histórica — a que eu acho genuinamente satisfatória como nerd de linguagens — é que o humilde ß alemão, uma letra com a qual gráficos lutam desde a era da Fraktur, ainda consegue atravessar seis séculos de história tipográfica e escrever um byte além do fim de um buffer no heap. A linguagem nunca foi simples. Apenas construímos nossas máquinas partindo do pressuposto de que era.


