OWASP Top 10 Explicado com Exemplos Práticos

Security2026-11-17TryQuickToolBox

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

CategoriaExemplo ComumCorreção Primária
Controle de Acesso QuebradoIDORVerificações no servidor
Falhas CriptográficasHash de senha fracoUse bcrypt/argon2
InjeçãoInjeção SQLConsultas parametrizadas
Design InseguroSem limitação de taxaModelagem de ameaças
Configuração Incorreta de SegurançaErros detalhadosReforce configurações
Componentes VulneráveisBiblioteca desatualizadaAtualizações regulares
Falhas de AutenticaçãoSessão na URLCookies seguros
Falhas de IntegridadeDesserialização inseguraValide e assine
Falhas de RegistroSem logs de login falhoRegistro centralizado
SSRFBusca de URL não validadaValidaçã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.