Vulnerabilidade de RCE no Rails (Ruby2Shell): como verificar se sua API está afetada

Ruby2Shell (CVE-2026-132825) é um heap overflow de pré-autenticação em Ruby que afeta até versões padrão do Rails. Verifique qual versão do Ruby sua API realmente executa, encontre todas as versões fixadas (pinned), faça upgrade para 3.3.14, 3.4.13 ou 4.0.10 e valide a build corrigida.

Ashley Innocent

Ashley Innocent

20 novembro 2026

Vulnerabilidade de RCE no Rails (Ruby2Shell): como verificar se sua API está afetada

Apidog para empresas

Implantação local

SSO & RBAC

Conforme SOC 2

Explorar Apidog Enterprise

A vulnerabilidade de RCE no Rails que está circulando nesta semana é a Ruby2Shell (escrita “Ruby2ßhell” por seus descobridores), rastreada como CVE-2026-132825 e GHSA-34m4-m9fh-gqp5. Trata-se de um heap overflow de um byte na conversão de maiúsculas/minúsculas de strings do Ruby que, segundo os pesquisadores, pode ser explorada sem autenticação em um app Rails padrão. Sua API é afetada se ela roda Ruby 2.4.0 a 3.3.13, 3.4.0 a 3.4.12 ou 4.0.0 a 4.0.9. A correção é um upgrade do Ruby para 3.3.14, 3.4.13 ou 4.0.10, não uma atualização de gem.

Resposta rápida: estou afetado?

  1. Execute ruby -v dentro do ambiente que realmente atende sua API (container, VM ou dyno), não no seu notebook.
  2. Se a versão estiver em um dos três intervalos acima, você está exposto.
  3. Atualize o Ruby, reconstrua todas as imagens, reinicie todos os servidores de aplicação e, em seguida, execute novamente os testes da sua API.

O que é a vulnerabilidade de RCE Ruby2Shell no Rails?

A Ruby2Shell é um heap buffer overflow de um byte no código que o Ruby usa para alterar a capitalização de strings em codificações legadas de byte único, como ISO-8859-x e Windows-125x. A Veria Labs a classifica como Crítica, explorável pela rede sem autenticação, e afirma que o Rails e o Sinatra no estilo clássico alcançam o código vulnerável em sua configuração padrão.

A causa raiz é pequena. A maioria das codificações de byte único não tem forma maiúscula do eszett alemão, “ß”, então convertê-lo para maiúsculas escreve dois bytes, “SS”. O loop que faz isso verifica apenas se há espaço para um byte. O Ruby aloca o buffer de saída com o comprimento da entrada mais 20 bytes, então, de acordo com o relatório da Veria, uma entrada com 21 caracteres “ß” excede esse buffer em um byte.

Diagrama do bug Ruby2Shell: uma string de entrada com caracteres eszett se expande para dois caracteres S cada, e o último S fica um byte após o fim do buffer de saída

O overflow é alcançado por meio de upcase, swapcase, downcase(:fold) e casecmp?. Strings UTF-8 seguem um caminho de código diferente e não são afetadas. O bug existe no Ruby desde a versão 2.4.0.

O Ruby publicou seu aviso de segurança em 18 de novembro de 2026, junto com outras seis falhas no motor de expressões regulares e na conversão de capitalização de strings. O Ruby afirma estar ciente de provas de conceito que usam essa falha para execução remota de código “em alguns cenários”. A Veria Labs diz que foi a primeira a demonstrar RCE em um Rails padrão e planeja publicar seu exploit em 25 de novembro de 2026, ou depois, caso os grandes fornecedores ainda não tenham lançado correções até então.

Essa data é o seu prazo real: uma vez que um exploit se torne público, escanear APIs Rails sem correção fica barato.

Quais versões do Ruby e do Rails são afetadas?

Esta tabela combina o aviso do Ruby com a tabela de software afetado da Veria Labs, até 20 de novembro de 2026.

Série do Ruby Afetada Corrigida em
4.0 4.0.0 a 4.0.9 4.0.10
3.4 3.4.0 a 3.4.12 3.4.13
3.3 3.3.0 a 3.3.13 3.3.14
3.2 e anteriores Todas as versões desde a 2.4.0 Sem correção (fim de vida)

A versão do Rails não importa aqui. O bug está no interpretador, então bundle update rails não muda nada. Um app Rails 8 no Ruby 3.4.12 é vulnerável; um app Rails 6.1 no Ruby 3.3.14 não é.

A Veria Labs lista o Rails e o Sinatra no estilo clássico como afetados em sua configuração padrão. Outros frameworks e apps Rack puros não ficam expostos por padrão, mas qualquer código que converta strings não confiáveis para maiúsculas em uma codificação legada ainda pode atingir o bug.

O Ruby 3.2 e versões anteriores não recebem correção. Se um serviço ainda está na 3.1 ou 3.2, a Ruby2Shell transforma o “vamos atualizar no próximo trimestre” na tarefa desta semana.

Como verificar se sua API Rails é afetada

A armadilha é verificar no lugar errado: o Ruby no seu notebook, ou no .ruby-version, pode ser diferente do que a produção executa.

Fluxograma para verificar uma API Rails contra a Ruby2Shell: executar ruby -v em produção, comparar com os intervalos afetados e, então, atualizar ou rodar testes de regressão

Etapa 1: Leia a versão do ambiente em execução

Pergunte ao processo que atende o tráfego. Escolha a linha que corresponde ao seu hosting:

# Docker / Kubernetes
docker exec <container> ruby -v
kubectl exec deploy/<api-deployment> -- ruby -v

# Heroku-style platforms
heroku run ruby -v -a <app-name>

# A VM or bare-metal host, as the app user
sudo -u deploy bash -lc 'cd /srv/api/current && bundle exec ruby -v'

Etapa 2: Compare com as versões corrigidas

Para vários serviços, cole este one-liner em cada ambiente. Ele usa apenas Gem::Version, que já vem com o Ruby:

ruby -e '
fixed = { "3.3" => "3.3.14", "3.4" => "3.4.13", "4.0" => "4.0.10" }
v = Gem::Version.new(RUBY_VERSION)
series = RUBY_VERSION.split(".").first(2).join(".")
if v < Gem::Version.new("2.4.0")
  puts "#{RUBY_VERSION}: outside the Ruby2Shell range, but end of life"
elsif fixed[series] && v >= Gem::Version.new(fixed[series])
  puts "#{RUBY_VERSION}: patched"
else
  puts "#{RUBY_VERSION}: VULNERABLE, upgrade Ruby"
end'

Ele imprime uma linha, por exemplo 3.4.12: VULNERABLE, upgrade Ruby. Qualquer versão 3.2 ou mais antiga também será reportada como vulnerável, o que está correto: não há versão corrigida nessas séries.

Etapa 3: Encontre todos os lugares onde o Ruby está fixado

A produção mostra o estado de hoje. Seu repositório mostra o que o próximo deploy vai entregar. Procure em todos estes lugares:

grep -rnE "ruby[-_]version|^ruby |FROM ruby:|RUBY VERSION" \
  --include="*.yml" --include="*.yaml" --include="Dockerfile*" \
  --include="Gemfile*" --include=".ruby-version" --include=".tool-versions" .

Etapa 4: Não esqueça o Ruby que você não instalou

Ferramentas self-hosted trazem seu próprio Ruby, então atualizar o Ruby do sistema não vai ajudá-las. A tabela da Veria Labs, atualizada em 20 de novembro de 2026 às 01:59 UTC, diz o seguinte:

Software Status Corrigido em
GitLab 19.6.0 e anteriores vulneráveis Sem versão corrigida ainda
GitHub Enterprise Server 3.22.5 e anteriores vulneráveis Sem versão corrigida ainda
Chatwoot 4.20.0 e anteriores vulneráveis Sem versão corrigida ainda
Mastodon 4.7.5 e anteriores 4.7.6, 4.6.12, 4.5.22, 4.4.29
OpenProject 17.9.7 e anteriores 17.9.8, 17.8.3
Discourse imagem base anterior a 2.0.20261119-0203 2.0.20261119-0203

Para os produtos sem correção, a orientação da Aikido é tirar o servidor da internet pública, colocá-lo atrás de uma VPN ou de uma allowlist de IPs, até que o fornecedor lance a correção.

Como corrigir a Ruby2Shell sem quebrar sua API

O Ruby não lista workaround algum, então o patch é a correção. Esta é a ordem que evita surpresas:

  1. Atualize a fixação de versão. Defina .ruby-version, a linha ruby do Gemfile e qualquer ruby-version de CI para 3.3.14, 3.4.13 ou 4.0.10, permanecendo na sua série atual.
  2. Atualize o lockfile. Execute bundle install para que a seção RUBY VERSION do Gemfile.lock fique consistente.
  3. Reconstrua as imagens a partir de uma base corrigida. Aponte FROM ruby: para uma tag que inclua a versão de patch corrigida (verifique a lista de tags no Docker Hub antes de fixar), e reconstrua com --pull para que uma camada antiga em cache não volte disfarçada.
  4. Reinicie todos os processos. Puma, Sidekiq, runners de cron e consoles one-off mantêm o interpretador antigo em memória até serem reiniciados.
  5. Reexecute a Etapa 1 em produção. Confie no ruby -v do container em execução, não no pull request mesclado.

A mesma versão corrige outros seis bugs de regexp e de strings, que afetam código do qual uma API depende: parsing de parâmetros, validações e buscas case-insensitive. Rode seus testes de API contra o staging antes de promover o build.

Deixe seu agente de código verificar a API corrigida com o Apidog CLI

Você já tem um agente de código aberto para atualizar a fixação do Ruby. Deixe o mesmo agente provar que o build corrigido retorna o que seus clientes esperam, em vez de clicar nos endpoints você mesmo. O Apidog CLI dá ao Claude Code, Codex, Cursor ou OpenCode uma forma programável de importar sua spec de API, escrever casos de teste e executá-los contra qualquer ambiente.

A configuração leva três comandos:

npm install -g apidog-cli@latest
apidog login --with-token <YOUR_TOKEN>
npx -y skills add https://apidog.com   # pick your agent when prompted

Se seu app Rails exporta um arquivo OpenAPI (rswag, por exemplo), dê um único prompt ao seu agente:

Import openapi.yaml into Apidog project <id>. Create test cases for our five
most-used endpoints, including GET /api/v1/users/:id and POST /api/v1/orders,
that assert status codes, response schemas and that names containing non-ASCII
characters (like "Straße") round-trip unchanged. Run them against staging after
the Ruby 3.4.13 deploy and summarize any failures.

O agente lê o schema do payload, valida e executa a suíte. Estes são os comandos que ele usa:

apidog import --project <id> --format openapi --file ./openapi.yaml
apidog cli-schema get test-case-create
apidog cli-schema validate test-case-create --file case.json
apidog test-case create --project <id> --file case.json
apidog run --test-case <caseId> --project <id> -e <stagingEnvId> -r cli,json

A verificação de caracteres não ASCII não é um teste de exploit, e não deve ser: não dispare payloads de overflow criados contra produção. É uma checagem de regressão no caminho de código que o patch tocou. Depois que ela passar no staging, coloque a mesma etapa apidog run ... -r junit no CI para que o próximo bump do Ruby receba a mesma checagem automaticamente. O guia de CI/CD do Apidog CLI mostra a configuração do pipeline, e o Apidog CLI no Claude Code cobre o lado do agente. O Apidog Free cobre até 4 usuários, o suficiente para uma equipe de backend pequena fazer isso hoje.

Como a Ruby2Shell se compara a outros RCEs recentes de runtime

A Ruby2Shell segue dois outros RCEs de nível de runtime abordados aqui desde outubro. Nos três casos, o bug está no runtime, então atualizações de framework e de pacotes não resolvem nada.

Bug Camada O que você atualiza
Ruby2Shell (CVE-2026-132825) Conversão de capitalização de strings do Ruby Ruby para 3.3.14, 3.4.13 ou 4.0.10
PHP2Shell (CVE-2026-109618, CVE-2026-109619) Interpretador PHP PHP para 8.5.12, 8.4.27, 8.3.36 ou 8.2.35
RCE do Brotli no Node.js (CVE-2026-111497) Decodificador Brotli do Node.js O próprio Node.js

Se sua equipe mantém uma stack poliglota, construa um inventário único de versões de runtime por serviço. Cada um desses bugs começa com a mesma pergunta: qual versão a produção realmente executa? Para uma abordagem mais ampla, veja detecção automatizada de vulnerabilidades em APIs.

FAQ

Atualizar a gem do Rails corrige a Ruby2Shell? Não. O bug está no interpretador Ruby, então bundle update rails não o afeta. Você precisa do Ruby 3.3.14, 3.4.13 ou 4.0.10, além de imagens reconstruídas e processos reiniciados.

Meu app está seguro se usa apenas UTF-8? A Veria Labs diz que strings UTF-8 seguem um caminho de código diferente e não são afetadas. Mas também diz que o Rails e o Sinatra clássico alcançam o código vulnerável em sua configuração padrão, então a suposição de “só usamos UTF-8” não é motivo para pular o upgrade.

Existe exploit público para a Ruby2Shell? Ainda não, até 20 de novembro de 2026. O Ruby afirma conhecer provas de conceito de RCE em alguns cenários, e a Veria Labs planeja publicar seu exploit contra Rails padrão em 25 de novembro de 2026, ou depois, caso os fornecedores não tenham lançado correções até lá.

E se eu estiver no Ruby 3.2 ou anterior? O Ruby 3.2 e anteriores estão em fim de vida e não receberão a correção. Migre para 3.3.14 ou posterior, idealmente 3.4.13 ou 4.0.10, e trate o upgrade como urgente.

Como verificar a exposição à Ruby2Shell no GitLab ou Mastodon? Esses produtos incluem seu próprio Ruby. Consulte as notas de versão do fornecedor em busca de uma versão corrigida. Onde ainda não existir, restrinja o acesso com uma VPN ou allowlist de IPs até que a correção seja lançada.

O upgrade do Ruby corrige mais alguma coisa? Sim. O Ruby 3.3.14, 3.4.13 e 4.0.10 também corrigem outras seis falhas de regexp e de conversão de capitalização de strings listadas no mesmo aviso do Ruby, então um único upgrade cobre todas as sete.

Pratique o design de API no Apidog

Descubra uma forma mais fácil de construir e usar APIs