A Ruby2Shell (GHSA-34m4-m9fh-gqp5) é um heap buffer overflow de um byte nas rotinas nativas de conversão de case do Ruby. Parece pouco? Um byte é tudo que um atacante precisa para corromper a heap e ganhar controle do processo.
O problema mora na forma como Ruby aloca buffers para operações de upcase(), swapcase(), downcase(:fold) e casecmp?(). O código reserva o tamanho da string de entrada mais 20 bytes de margem. Na maioria dos casos, isso basta. Mas existe um caractere específico que quebra essa conta: o eszett alemão, o famoso ß.
Quando você chama upcase() em uma string que contém ß, o Ruby converte para SS, ou seja, dois bytes. Cada ß na entrada produz um byte a mais na saída. Se a string tiver 21 ou mais caracteres ß, o buffer de 20 bytes extras estoura. Um byte escapa. E esse byte é S (0x53) ou s (0x73), dependendo da operação.
# Isso é seguro - 20 ß cabem na margem
"ß" * 20 # upcase → "SS" * 20 (40 bytes, margem ok)
# Isso estoura o buffer - 21 ß precisam de 21 bytes extras
"ß" * 21 # upcase → "SS" * 21 (42 bytes, margem de 20 estourou)
Sim, é absurdamente simples. E é exatamente por isso que ninguém percebeu por anos.
Por que isso é pré-autenticação
Aqui vem a parte que arrepia: em Rails e Sinatra (modo clássico), o framework processa parâmetros de request antes de qualquer lógica de autenticação da aplicação. Isso significa que um atacante pode enviar uma string maliciosa em um header, parâmetro de query ou corpo de request, e o Ruby vai processar a conversão de case antes do seu código decidir se o usuário tem permissão de estar ali.
Não precisa de cookie. Não precisa de token. Não precisa de nada. Basta mandar um request HTTP para qualquer endpoint que, em algum ponto da stack, faça uma operação de case conversion em dados do usuário.
E sejamos honestos: qual app Rails não normaliza input em algum momento?
A anatomia do exploit
Vamos destrinchar a cadeia de exploração:
Passo 1: Trigger o overflow
O atacante envia uma request com uma string contendo 21+ caracteres ß em uma encoding single-byte (ISO-8859-1, Windows-1252, etc.). Strings UTF-8 usam um code path diferente e não são afetadas.
Passo 2: Corrupção de heap
O byte que escapa (S ou s) sobrescreve metadados de heap adjacentes. Dependendo do layout da heap naquele momento, isso pode corromper o tamanho de um chunk livre, um ponteiro de linked list, ou dados de outra alocação.
Passo 3: Primitiva de escrita
Com controle sobre metadados de heap, o atacante pode transformar o overflow de um byte em uma primitiva de escrita arbitrária. Existem técnicas bem documentadas para isso em alocadores glibc.
Passo 4: RCE
A partir da escrita arbitrária, o caminho clássico é sobrescrever ponteiros de função ou hooks do alocador para redirecionar execução para shellcode ou uma cadeia de ROP.
| Etapa | O que acontece | Dificuldade |
|---|---|---|
| Trigger | String com 21+ ß em encoding single-byte | Trivial |
| Heap corruption | 1 byte sobrescreve metadado adjacente | Depende do layout |
| Write primitive | Corrupção vira escrita controlada | Avançado |
| RCE | Shellcode ou ROP chain | Avançado |
A Veria Labs (que descobriu a falha) confirmou que tem proof-of-concept funcional, mas atrasou a publicação em uma semana para dar tempo de upgrade.
Versões afetadas (e como corrigir)
A falha existe desde o Ruby 2.4.0, lançado em 2016. Dez anos de código vulnerável.
| Branch Ruby | Versões afetadas | Correção |
|---|---|---|
| 4.0 | 4.0.0 a 4.0.9 | Atualizar para 4.0.10 |
| 3.4 | 3.4.0 a 3.4.12 | Atualizar para 3.4.13 |
| 3.3 | 3.3.0 a 3.3.13 | Atualizar para 3.3.14 |
| 3.2 e anterior | Todas desde 2.4.0 | Sem correção (EOL) |
Se você está rodando Ruby 3.2 ou anterior em produção, não tem patch. A solução é migrar para uma versão suportada. Ontem.
# Verificar sua versão
ruby --version
# Atualizar via rbenv
rbenv install 3.4.13
rbenv global 3.4.13
# Ou via RVM
rvm install 3.4.13
rvm use 3.4.13 --default
# Verificar se atualizou
ruby --version
KindaRails2Shell: a segunda bomba
Como se a Ruby2Shell não bastasse, o ecossistema Rails também recebeu a CVE-2026-66066, batizada de KindaRails2Shell. Essa é diferente: em vez de explorar Ruby em si, ela ataca o Active Storage do Rails.
O CVSS? 9.5 de 10. Crítico.
Como funciona
O Active Storage usa libvips para processar variantes de imagem (redimensionar, converter formato, etc.). A CVE-2026-66066 explora uma interação insegura entre o Active Storage e a libvips para ler arquivos arbitrários do servidor.
A cadeia de ataque:
- O atacante obtém uma
variation_keyassinada de qualquer página que renderize uma representação do Active Storage - Usando a rota de direct-upload (que não exige autenticação), cria um blob malicioso
- O arquivo é crafted para ser interpretado como MATLAB Level 5 pela libvips, mas como container HDF5 pela libmatio
- A feature de External File List do HDF5 permite ler bytes de qualquer path no servidor
- Esses bytes são renderizados como pixels da imagem resultante
Request malicioso → Active Storage → libvips → libmatio → lê /config/master.key
→ lê /config/credentials.yml.enc
→ lê /config/database.yml
Com a master key do Rails em mãos, o atacante pode forjar variações do ImageProcessing 1.x e escalar para execução remota de código. Sem desserialização Marshal, sem truques exóticos. Apenas chaves legítimas usadas de forma ilegítima.
Versões afetadas do Rails
| Branch Rails | Versões afetadas | Correção |
|---|---|---|
| 7.x | 7.0.0 a 7.2.3.1 | 7.2.3.2 |
| 8.0.x | 8.0.0 a 8.0.5 | 8.0.5.1 |
| 8.1.x | 8.1.0 a 8.1.3 | 8.1.3.1 |
| 6.x | Vulnerável se usar Vips | Sem patch oficial |
Mitigação imediata
Se não pode atualizar agora:
# Se libvips >= 8.13, bloquear operações untrusted
export VIPS_BLOCK_UNTRUSTED=1
# Ou no initializer do Rails (ruby-vips >= 2.2.1)
# config/initializers/vips.rb
Vips.block_untrusted(true)
E o mais importante: rotacione todos os secrets. Se a falha foi explorada, o atacante já tem sua secret_key_base, credenciais de banco e tokens de serviços externos.
# Regenerar master key
rails credentials:edit
# Rotacionar secret_key_base
rails secret
# Atualize config/credentials.yml.enc com o novo valor
A tempestade perfeita
O que torna essa semana particularmente perigosa é a combinação das duas falhas. Imagine o cenário:
- Atacante usa Ruby2Shell para corromper a heap do processo Ruby
- Mesmo que a app não use Active Storage, o overflow pode ser explorado independentemente
- Se a app usa Active Storage, o atacante tem duas portas de entrada separadas
- Ambas funcionam sem autenticação
- Ambas têm proof-of-concept público (ou prestes a ser publicado)
Para quem administra infraestrutura Rails, isso significa que atualizar só o Ruby ou só o Rails não basta. Você precisa dos dois.
UTF-8 salva (dessa vez)
Um detalhe técnico interessante: a Ruby2Shell só afeta strings em encodings single-byte como ISO-8859-1, Windows-1252 e similares. Strings UTF-8 usam um code path completamente diferente nas rotinas de case conversion e não são vulneráveis.
Na prática, a maioria das aplicações modernas trabalha com UTF-8 por padrão. Isso limita a superfície de ataque, mas não elimina. Muitas apps ainda precisam lidar com encodings legadas, especialmente em:
- Integração com sistemas antigos
- Processamento de emails (headers podem usar ISO-8859-1)
- APIs que recebem dados de clientes variados
- Importação de arquivos CSV/Excel com encoding não-UTF-8
Se a sua app aceita input de fontes externas e faz qualquer tipo de normalização de case, a superfície existe.
Checklist de emergência
Aqui vai o passo a passo para proteger seus apps hoje:
Para Ruby2Shell:
- [ ] Verificar versão do Ruby (
ruby --version) - [ ] Atualizar para 3.3.14, 3.4.13 ou 4.0.10
- [ ] Se usar Ruby <= 3.2, planejar migração urgente
- [ ] Auditar código que faz
upcase/downcase/swapcaseem input externo com encoding não-UTF-8
Para KindaRails2Shell (CVE-2026-66066):
- [ ] Verificar versão do Rails (
rails --version) - [ ] Atualizar para 7.2.3.2, 8.0.5.1 ou 8.1.3.1
- [ ] Atualizar ruby-vips para >= 2.2.1
- [ ] Atualizar libvips para >= 8.13
- [ ] Setar
VIPS_BLOCK_UNTRUSTED=1como mitigação temporária - [ ] Rotacionar TODOS os secrets (master key, credentials, tokens)
- [ ] Auditar logs do Active Storage em busca de uploads suspeitos
- [ ] Rodar as ferramentas forenses que a equipe do Rails disponibilizou
# Script rápido de verificação
echo "=== Ruby Version ==="
ruby --version
echo "=== Rails Version ==="
bundle exec rails --version 2>/dev/null || echo "Não é um projeto Rails"
echo "=== libvips Version ==="
vips --version 2>/dev/null || echo "libvips não instalado"
echo "=== ruby-vips Version ==="
bundle show ruby-vips 2>/dev/null || echo "ruby-vips não instalado"
echo "=== Encoding padrão ==="
ruby -e 'puts Encoding.default_external'
O elefante na sala: memory safety
Toda vez que aparece um bug de heap overflow em 2026, a discussão sobre memory safety ressurge. E com razão.
A Ruby2Shell é um bug clássico de C. O core do Ruby (MRI/CRuby) é escrito em C, e as rotinas de case conversion são código nativo que opera diretamente na memória. Não importa que você escreve Ruby, uma linguagem de alto nível com garbage collector: por baixo, C está alocando buffers e fazendo aritmética de ponteiros.
JRuby e TruffleRuby, que rodam na JVM e GraalVM respectivamente, não são afetados por essa falha específica porque usam implementações diferentes das rotinas de string.
A ironia é que o Ruby 4.0 foi lançado com grande fanfarra sobre melhorias de performance e novas features, mas carregou consigo um bug que existe desde o Ruby 2.4. Dez anos. Bilhões de requests processados. E ninguém notou que a margem de 20 bytes era insuficiente para 21 caracteres ß.
Como a comunidade respondeu
A equipe de segurança do Ruby coordenou a divulgação com os mantenedores do Rails, Sinatra e os principais provedores de hosting (Heroku, Render, Fly.io). Patches foram lançados simultaneamente para Ruby 3.3, 3.4 e 4.0.
A Veria Labs, responsável pela descoberta, está segurando o proof-of-concept completo por uma semana. É uma prática comum em responsible disclosure, mas com a quantidade de informação técnica já disponível, é questão de dias até exploits aparecerem no wild.
Heroku já forçou atualizações automáticas para apps no plano Eco e Basic. Render e Fly.io publicaram advisories pedindo atualização manual.
Se você usa Docker para deploy, lembre-se de rebuildar suas imagens:
# Atualize a imagem base
FROM ruby:3.4.13-slim
# Ou se usa multi-stage
FROM ruby:3.4.13 AS builder
# ... build steps ...
FROM ruby:3.4.13-slim AS runtime
# ... runtime steps ...
Lições para devs que não usam Ruby
Mesmo que você nunca tenha escrito uma linha de Ruby, essa história tem lições universais:
1. Margens fixas em buffers são bombas-relógio. A margem de 20 bytes era “suficiente” para todos os casos conhecidos até que alguém pensou em 21 caracteres ß. Sempre aloque baseado no pior caso calculado, não em uma constante mágica.
2. Unicode é um campo minado. Conversões de case podem mudar o tamanho da string. ß → SS, fi → FI, İ → I + combining dot. Se seu código assume que len(upcase(s)) == len(s), você tem um bug.
3. Pré-autenticação é mais comum do que parece. Frameworks web processam muita coisa antes do seu middleware de auth rodar. Headers, cookies, parâmetros de URL, tudo isso já foi parseado e potencialmente transformado antes de você decidir se o request é legítimo.
4. Duas falhas pequenas viram uma catástrofe. Ruby2Shell sozinha é difícil de explorar de forma confiável. KindaRails2Shell sozinha precisa de condições específicas. Juntas, cobrem praticamente qualquer app Rails em produção.
Enquanto isso, o HN debate se “Ruby está morto” pela milésima vez. Ruby não está morto. Está, como qualquer runtime maduro, pagando o preço de decisões de design tomadas quando “21 caracteres ß em uma string single-byte” parecia um caso de teste que ninguém jamais precisaria escrever.
Atualize seus servidores. Rotacione seus secrets. E da próxima vez que alguém disser que bugs de memória “só acontecem em C/C++”, mande o link da Ruby2Shell.
Fontes: Veria Labs: Ruby2Shell | Rapid7: KindaRails2Shell CVE-2026-66066 | Ruby Security Advisory













