Pular para o conteúdo
>_ITDITDPlataforma de Segurança Web

Por framework

Segurança do Ruby on Rails — uma referência de hardening de produção

Uma referência de hardening de produção para Ruby on Rails: um checklist por prioridade mais segredos/credentials, config, CVEs de gems, Strong Parameters, autorização, injeção e SSRF. Defensivo, sem passos de ataque.

Publicado 2026-07-02 Atualizado 2026-07-02 7 min de leitura

Para: qualquer pessoa que opere um app Ruby on Rails. Sem passos de ataque aqui — esta é uma referência de trabalho para hardening: um checklist ordenado por prioridade, orientação por área e autoverificação. Para o panorama entre frameworks, veja o hub de segurança por framework.

Checklist de hardening ordenado por prioridade

Faça esta tabela de cima para baixo. P0 é um pré-requisito, P1 é a fonte mais frequente de incidentes, P2 é higiene operacional contínua.

P0 ── Pré-requisito (faça primeiro)

Gestão de segredos e credentials / config de produção (sem exposição de exceções, force_ssl) / CVEs de gems corrigidos rápido

P1 ── Principal fonte de incidentes

Controle de Strong Parameters/Mass Assignment / autorização (escopo de proprietário)

P2 ── Higiene operacional

Injeção e métodos perigosos / sessões, CSRF / SSRF, uploads

Proteja da fundação para cima: P0 (pré-requisito) → P1 (principal fonte de incidentes) → P2 (higiene operacional).
PrioridadeControleEspecificidades (Rails)
P0Segredos e credentialsCredentials criptografadas + master key separado. Não faça commit do master key. Rotacione secret_key_base ao vazar
P0Config de produçãoNão exponha detalhes de exceção; config.force_ssl; filter_parameters para manter segredos fora dos logs
P0CVEs de gems (dependências)Monitore com bundler-audit / osv-scanner; julgue pela versão em execução, corrija rápido
P1Strong ParametersMantenha o permit mínimo. Não use permit!. Nunca atribua um campo de privilégio
P1Autorização explícitaPundit / CanCanCan + authorize + escopo por current_user para propriedade
P2Injeção/métodos perigososFaça bind em where. Não passe entrada a send/constantize. Não carregue YAML/Marshal não confiável
P2Sessões/CSRFprotect_from_forgery (padrão), cookie secure/httponly/samesite, regenere no login
P2SSRF/uploadsAllowlist para buscas server-side + bloqueie IPs internos. Valide uploads, armazene fora de public/

1. Segredos e credentials (P0)

  • Use as credentials criptografadas do Rails e não faça commit do master key (a chave de descriptografia) no repositório (injete via env, etc.).
  • secret_key_base é a base dos cookies assinados/criptografados e das sessões. Rotacione prontamente se vazar (note que isso invalida as assinaturas/criptografia existentes).
  • Não deixe .env, dumps ou backups em um diretório público (→ mantenha segredos fora dos diretórios públicos).

2. Config de produção (P0)

  • Em produção, não exponha detalhes de exceção (não habilite consider_all_requests_local, etc.) — reduza a divulgação da estrutura interna.
  • config.force_ssl para forçar HTTPS e marcar os cookies como secure. Não habilite ferramentas de dev como o web console em produção.
  • Use filter_parameters para manter senhas e afins fora dos logs.

3. CVEs de gems (dependências) (P0)

4. Strong Parameters e Mass Assignment (P1)

  • Mantenha os campos do permit no mínimo e evite o permit! (permitir tudo).
  • Nunca atribua um campo de privilégio como is_admin a partir da entrada do usuário. Abandone o "permitir de forma ampla porque é conveniente."

5. Autorização (P1 — a principal fonte)

Comum (perigoso)

  • sem autorização — "logado = pode ver/atualizar"
  • o binding rota-modelo busca o ID de outro usuário
  • confiar em rotas ocultas / IDs difíceis de adivinhar
  • esquecer o authorize em algumas ações

Correto

  • política explícita com Pundit / CanCanCan + authorize por ação
  • as leituras também têm escopo de proprietário por current_user
  • verificado em cada caminho de leitura/atualização/exclusão
  • autorização construída explicitamente, não deixada aos padrões

Veja o que é IDOR. Autenticação e autorização diferem; autorize perto dos dados.

6. Injeção e métodos dinâmicos perigosos (P2)

  • SQL: faça bind com placeholders em where; nunca construa queries por concatenação de string (evite where("... #{params}")) (→ o que é injeção de SQL).
  • Métodos dinâmicos perigosos: não passe entrada do usuário a send/public_send/constantize. Se precisar, restrinja rigorosamente com uma allowlist.
  • Desserialização: evite carregar YAML/Marshal não confiável (pode levar à execução de código sob as condições certas).

7. Sessões, cookies, CSRF (P2)

  • Não desabilite globalmente a proteção CSRF (protect_from_forgery); use o token do formulário (→ o que é CSRF).
  • Defina secure/httponly/samesite nos cookies/sessões e regenere a sessão no login.

8. SSRF, uploads, headers (P2)

  • A busca server-side de URLs fornecidas pelo usuário deve restringir os alvos a uma allowlist e bloquear o alcance a IPs internos/metadados (→ o que é SSRF).
  • Valide os uploads (tipo/tamanho), armazene fora de public/ e não conceda permissão de execução.
  • Adicione headers de segurança (verifique o seu próprio site com o verificador de headers de segurança).

Verifique: o seu Rails está realmente protegido?

Construir não é o fim — só está pronto quando você verificou. Estas são autoverificações defensivas contra o seu próprio ambiente.

1

Segredos não estão expostos/commitados

Confirme que o master.key não está no repositório e que .env/dumps não são buscáveis por URL.
2

Nenhum detalhe de exceção em produção

Provoque um erro e confirme que exceções detalhadas não são mostradas externamente e que o HTTPS é forçado.
3

A autorização se sustenta

Em um ambiente de teste, solicite o ID de recurso de outro usuário e confirme que é negado (leitura/atualização/exclusão).
4

Dependências e headers

Confirme que bundler-audit/osv está limpo e que HTTPS/HSTS estão presentes via o verificador de headers.

A visão deste site: mesmo protegido por convenções, a autorização e as dependências são sua responsabilidade

Os bons padrões do Rails apagam muito risco, mas a autorização — quem pode fazer o quê — e o frescor das dependências são específicos do app e da operação, então um framework não consegue protegê-los automaticamente. Os incidentes que continuamos vendo são menos ataques elaborados do que o tipo "autenticado, mas sem verificação de propriedade". Então o centro de gravidade é trabalhar a tabela acima de cima para baixo — aperte os Strong Parameters, torne a autorização explícita e monitore os gems por CVEs.

Leia a seguir

FAQ

QO que eu devo fazer primeiro para proteger o Rails?
A

Os três itens P0: (1) trate os segredos com segurança (mantenha as credentials criptografadas separadas do master key, não faça commit do master key; secret_key_base é a base dos cookies assinados/criptografados, então rotacione ao vazar); (2) firme a config de produção (não exponha detalhes de exceção; force_ssl); (3) monitore por máquina os CVEs de gems (dependências) e corrija rápido, julgando pela versão em execução. Em seguida, avance para os Strong Parameters e a autorização.

QCom o que devo me preocupar nos Strong Parameters?
A

Permita explicitamente (permit) quais campos você aceita para prevenir o Mass Assignment (atribuição em massa de campos não intencionais). O perigo é permitir de forma ampla por conveniência e usar permit! para permitir tudo. Mantenha os campos permitidos no mínimo e nunca deixe um campo de privilégio como is_admin ser atribuído a partir da entrada do usuário.

QComo implemento a autorização com segurança?
A

Além do login (autenticação), implemente uma verificação de propriedade de que o alvo realmente pertence ao usuário. Torne a política explícita com Pundit/CanCanCan, execute authorize em cada ação e dê escopo aos recursos por current_user. Não confie em rotas ocultas ou IDs difíceis de adivinhar — verifique explicitamente em cada caminho de leitura/atualização/exclusão.

QComo gerencio as vulnerabilidades de gems (dependências)?
A

Monitore por máquina os CVEs conhecidos com bundler-audit ou osv-scanner e corrija rápido, julgando pela versão em execução (decida pela versão real no Gemfile.lock). Mantenha o Rails e o Ruby em versões suportadas e não deixe versões EOL no lugar. O frescor das dependências é um fator mais realista nos incidentes do que ataques elaborados.

QQuais são os métodos dinâmicos perigosos?
A

Passar a entrada do usuário a send / public_send / constantize pode levar a chamadas de método ou resolução de classe não intencionais. Da mesma forma, carregar via Marshal ou YAML não confiável (restaurando objetos) pode, sob as condições certas, levar à execução de código. Não passe dados derivados do usuário a esses; se precisar, restrinja rigorosamente com uma allowlist.