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.
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
| Prioridade | Controle | Especificidades (Rails) |
|---|---|---|
| P0 | Segredos e credentials | Credentials criptografadas + master key separado. Não faça commit do master key. Rotacione secret_key_base ao vazar |
| P0 | Config de produção | Não exponha detalhes de exceção; config.force_ssl; filter_parameters para manter segredos fora dos logs |
| P0 | CVEs de gems (dependências) | Monitore com bundler-audit / osv-scanner; julgue pela versão em execução, corrija rápido |
| P1 | Strong Parameters | Mantenha o permit mínimo. Não use permit!. Nunca atribua um campo de privilégio |
| P1 | Autorização explícita | Pundit / CanCanCan + authorize + escopo por current_user para propriedade |
| P2 | Injeção/métodos perigosos | Faça bind em where. Não passe entrada a send/constantize. Não carregue YAML/Marshal não confiável |
| P2 | Sessões/CSRF | protect_from_forgery (padrão), cookie secure/httponly/samesite, regenere no login |
| P2 | SSRF/uploads | Allowlist 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_sslpara forçar HTTPS e marcar os cookies como secure. Não habilite ferramentas de dev como o web console em produção.- Use
filter_parameterspara manter senhas e afins fora dos logs.
3. CVEs de gems (dependências) (P0)
- Monitore por máquina os CVEs de gems com bundler-audit ou osv-scanner, julgue pela versão em execução (Gemfile.lock) e corrija rápido (→ monitorar CVEs de dependências · o manual de resposta a vulnerabilidades).
- Mantenha o Rails e o Ruby em versões suportadas e não deixe versões EOL no lugar.
4. Strong Parameters e Mass Assignment (P1)
- Mantenha os campos do
permitno mínimo e evite opermit!(permitir tudo). - Nunca atribua um campo de privilégio como
is_admina 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
authorizeem algumas ações
Correto
- política explícita com Pundit / CanCanCan +
authorizepor 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 (evitewhere("... #{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/Marshalnã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.
Segredos não estão expostos/commitados
master.key não está no repositório e que .env/dumps não são buscáveis por URL.Nenhum detalhe de exceção em produção
A autorização se sustenta
Dependências e headers
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
- Hub: segurança por framework · segurança do Laravel (mesmo MVC, forma de autorização parecida)
- Prática: o manual de resposta a vulnerabilidades · monitorar CVEs de dependências · mantenha segredos fora dos diretórios públicos
- Glossário: o que é IDOR · injeção de SQL · CSRF · SSRF
- Ferramentas: verificador de headers de segurança
FAQ
QO que eu devo fazer primeiro para proteger o Rails?
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?
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?
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)?
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?
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.