OWASP Top 10 Explicado com Exemplos Práticos
Você provavelmente já ouviu falar do OWASP Top 10, mas sabe como cada vulnerabilidade se parece em código real? Muitos desenvolvedores o tratam como uma lista de verificação teórica, mas essas falhas estão por trás de inúmeras violações de segurança. Este artigo percorre cada categoria do OWASP Top 10 com exemplos práticos e correções concretas, para que você possa identificá-las e detê-las em seus projetos.
1. Controle de Acesso Quebrado
O controle de acesso impõe o que usuários autenticados podem fazer. Quando está quebrado, os usuários podem acessar dados ou realizar ações fora de suas permissões.
Exemplo: Referência Direta Insegura a Objeto (IDOR)
// Vulnerável: qualquer usuário logado pode ver qualquer pedido alterando o ID
app.get('/orders/:id', (req, res) => {
const order = db.getOrder(req.params.id);
res.json(order);
});
// Corrigido: verificar propriedade
app.get('/orders/:id', (req, res) => {
const order = db.getOrder(req.params.id);
if (order.userId !== req.user.id) return res.status(403).end();
res.json(order);
});
Correção: Aplique controle de acesso no lado do servidor, negue por padrão e registre falhas.
2. Falhas Criptográficas
Dados sensíveis devem ser criptografados em trânsito e em repouso. Erros comuns incluem o uso de algoritmos fracos ou chaves codificadas.
Exemplo: Armazenar senhas com MD5
// Vulnerável
const hash = md5(password);
// Corrigido: use bcrypt ou argon2
const hash = await bcrypt.hash(password, 12);
Correção: Use hashing forte com salt para senhas; criptografe dados sensíveis com AES-256; sempre use HTTPS.
3. Injeção
Injeção ocorre quando dados não confiáveis são enviados a um interpretador como parte de um comando ou consulta.
Exemplo: Injeção SQL
// Vulnerável: concatenação de strings
const query = "SELECT * FROM users WHERE name = '" + name + "'";
// Corrigido: consulta parametrizada
const query = 'SELECT * FROM users WHERE name = ?';
db.execute(query, [name]);
Correção: Use consultas parametrizadas, ORMs e valide a entrada. Para comandos do sistema operacional, evite execução de shell ou use APIs seguras.
4. Design Inseguro
Esta categoria foca em falhas de design e arquitetura, não apenas em bugs de implementação. Modelagem de ameaças e padrões de design seguro são essenciais.
Exemplo: Sem limitação de taxa na redefinição de senha
Sem limitação de taxa, atacantes podem forçar tokens de redefinição. Correção: Implemente limitação de taxa, use tokens fortes e faça-os expirar rapidamente.
5. Configuração Incorreta de Segurança
Configurações padrão, erros detalhados e recursos desnecessários são culpados comuns.
Exemplo: Expor rastreamentos de pilha
// Vulnerável: erro detalhado para o cliente
app.use((err, req, res, next) => {
res.status(500).send(err.stack);
});
// Corrigido: mensagem genérica, registrar detalhes no servidor
app.use((err, req, res, next) => {
console.error(err.stack);
res.status(500).send('Algo deu errado');
});
Correção: Reforce configurações, remova recursos não utilizados e use cabeçalhos de segurança como CSP e HSTS.
6. Componentes Vulneráveis e Desatualizados
Usar bibliotecas com vulnerabilidades conhecidas é como deixar uma porta aberta.
Exemplo: Versão antiga do lodash com poluição de protótipo
Correção: Atualize dependências regularmente, use ferramentas como npm audit ou OWASP Dependency-Check e monitore avisos.
7. Falhas de Identificação e Autenticação
Autenticação fraca permite que atacantes comprometam senhas ou tokens de sessão.
Exemplo: ID de sessão na URL
// Vulnerável: ID de sessão na string de consulta
const sessionId = req.query.sessionId;
// Corrigido: use cookies seguros e HttpOnly
res.cookie('session', sessionId, { httpOnly: true, secure: true });
Correção: Implemente autenticação multifator, exija senhas fortes e use gerenciamento de sessão seguro.
8. Falhas de Integridade de Software e Dados
Esta categoria está relacionada a código e infraestrutura que não protegem contra violações de integridade, como desserialização insegura ou uso de CDNs não confiáveis.
Exemplo: Desserialização insegura
// Vulnerável: desserializar dados não confiáveis
const obj = deserialize(userInput);
// Corrigido: use formatos seguros como JSON e valide o esquema
const obj = JSON.parse(userInput);
if (!isValidSchema(obj)) throw new Error('Inválido');
Correção: Verifique a integridade com assinaturas digitais, use formatos de serialização seguros e revise os pipelines de CI/CD.
9. Falhas de Registro e Monitoramento de Segurança
Sem registro adequado, violações passam despercebidas. Os logs devem ser gerados, armazenados com segurança e monitorados.
Exemplo: Não registrar logins falhos
// Vulnerável: sem registro
if (!valid) return res.status(401).end();
// Corrigido: registrar o evento
if (!valid) {
logger.warn('Tentativa de login falhou', { ip: req.ip, username });
return res.status(401).end();
}
Correção: Registre eventos de segurança, configure alertas e garanta que os logs sejam à prova de adulteração.
10. Falsificação de Solicitação do Lado do Servidor (SSRF)
SSRF ocorre quando um atacante pode fazer o servidor enviar solicitações para locais não intencionais.
Exemplo: Buscar uma URL sem validação
// Vulnerável: busca qualquer URL
app.get('/fetch', async (req, res) => {
const response = await fetch(req.query.url);
res.send(await response.text());
});
// Corrigido: validar URL com lista de permissões
const allowedHosts = ['api.example.com'];
app.get('/fetch', async (req, res) => {
const url = new URL(req.query.url);
if (!allowedHosts.includes(url.hostname)) return res.status(400).end();
const response = await fetch(url);
res.send(await response.text());
});
Correção: Use listas de permissões, valide URLs e restrinja o tráfego de saída.
Tabela Comparativa: OWASP Top 10 em Resumo
| Categoria | Exemplo Comum | Correção Primária |
|---|---|---|
| Controle de Acesso Quebrado | IDOR | Verificações no servidor |
| Falhas Criptográficas | Hash de senha fraco | Use bcrypt/argon2 |
| Injeção | Injeção SQL | Consultas parametrizadas |
| Design Inseguro | Sem limitação de taxa | Modelagem de ameaças |
| Configuração Incorreta de Segurança | Erros detalhados | Reforce configurações |
| Componentes Vulneráveis | Biblioteca desatualizada | Atualizações regulares |
| Falhas de Autenticação | Sessão na URL | Cookies seguros |
| Falhas de Integridade | Desserialização insegura | Valide e assine |
| Falhas de Registro | Sem logs de login falho | Registro centralizado |
| SSRF | Busca de URL não validada | Validação com lista de permissões |
FAQ
O que é o OWASP Top 10?
O OWASP Top 10 é um documento de conscientização padrão para desenvolvedores e segurança de aplicações web. Representa um amplo consenso sobre os riscos de segurança mais críticos para aplicações web.
Com que frequência o OWASP Top 10 é atualizado?
O OWASP atualiza a lista periodicamente para refletir ameaças emergentes e mudanças na tecnologia. A versão mais recente é de 2021, com atualizações esperadas no futuro.
O OWASP Top 10 é suficiente para proteger minha aplicação?
Não, é um ponto de partida. Um programa de segurança abrangente inclui práticas de codificação segura, testes regulares e monitoramento contínuo além do Top 10.
Pronto para verificar suas cargas JSON em busca de falhas de injeção? Use nosso JSON Formatter para validar e formatar JSON com segurança.