No universo do desenvolvimento de sistemas, e-commerces, aplicativos financeiros e plataformas SaaS, três falhas de arquitetura concentram a esmagadora maioria dos vazamentos milionários de dados e das maiores recompensas pagas em programas globais de Bug Bounty: IDOR (Insecure Direct Object Reference), SQL Injection (SQLi) e Broken Access Control (Controle de Acesso Quebrado).
Na auditoria de segurança de aplicações web — cujo objetivo é encontrar e corrigir vulnerabilidades críticas antes que criminosos as explorem —, fica evidente que a simples presença de um cadeado HTTPS no navegador não protege um site mal programado. O HTTPS apenas criptografa o canal de transporte entre o usuário e o servidor; se a lógica interna da aplicação não validar quem tem permissão para ler cada registro ou se concatenar comandos diretamente no banco de dados, o invasor entra pela porta da frente.
Neste guia técnico, dissecamos o funcionamento real do IDOR, do Broken Access Control, do SQL Injection, do SSRF e do Blind XSS, entregando exemplos práticos de código vulnerável versus código blindado para proteger sua empresa.
---
1. IDOR (Insecure Direct Object Reference) — A Falha do "Número Sequencial"
O IDOR (Referência Direta Insegura a Objetos) é uma das vulnerabilidades mais simples de explorar e, paradoxalmente, uma das mais frequentes em sistemas de emissão de boletos, clínicas médicas, portais de notas fiscais e plataformas de ensino.
Como Acontece um Ataque de IDOR na Prática?
Imagine que um cliente faz login legítimo no portal da sua empresa e clica em "Baixar Meu Contrato em PDF". O navegador faz uma requisição para a seguinte URL ou rota de API:
`GET https://sistema.empresa.com.br/api/v1/faturas/download?id=10428`
O servidor recebe o parâmetro `id=10428`, busca o documento `10428` no banco de dados e devolve o PDF com o nome completo, CPF, endereço e valor da compra. Porém, o programador esqueceu de incluir uma verificação fundamental no código do servidor: "O documento `10428` realmente pertence ao usuário que está logado nesta sessão?".
- Um golpista percebe o número sequencial na barra de endereços, altera manualmente para `id=10427`, `id=10429`, `id=10430` (ou cria um script automatizado no Burp Suite Intruder) e baixa em poucos minutos todos os contratos, exames médicos ou boletos de milhares de clientes da empresa.
+-------------------------------------------------------------------------+
| FLUXO VULNERÁVEL A IDOR vs. ARQUITETURA BLINDADA |
+-------------------------------------------------------------------------+
| |
| [ X ] FLUXO VULNERÁVEL (Sem Validação de Propriedade / Ownership): |
| Usuário Logado (ID: 55) ---> GET /api/pedidos/9001 |
| Backend executa: SELECT * FROM pedidos WHERE id = 9001; |
| Resultado: Devolve os dados do pedido 9001 (que pertencia ao ID 88!). |
| |
| [ V ] FLUXO BLINDADO NO SERVIDOR (SEGURO): |
| Usuário Logado (ID: 55, extraído do Token JWT/Sessão no Servidor) |
| ---> GET /api/pedidos/a8f9d2c1-4b3e-411a-9c00-1f2e3d4c5b6a (UUIDv4) |
| Backend executa: |
| SELECT * FROM pedidos WHERE uuid = $1 AND cliente_id = $2; |
| Resultado: Se o pedido não pertencer ao usuário 55 -> HTTP 403/404! |
+-------------------------------------------------------------------------+
Como Corrigir Definitivamente o IDOR
1. Validação Obrigatória de Propriedade (Ownership Check) no Backend: Toda consulta ao banco de dados deve filtrar simultaneamente pelo ID do recurso solicitado e pelo `user_id` ou `tenant_id` extraído da sessão autenticada no servidor (nunca confie em um `user_id` enviado no corpo do JSON pelo navegador).
2. Substituição de IDs Sequenciais por UUIDv4 ou ULID: Embora o UUID sozinho não substitua a validação de permissão no backend, trocar `id=10428` por um identificador randômico de 128 bits (`550e8400-e29b-41d4-a716-446655440000`) impede que atacantes enumerem quantos clientes ou pedidos sua empresa possui.
---
2. Broken Access Control (Controle de Acesso Quebrado — OWASP #1)
Enquanto o IDOR foca no acesso indevido a registros de mesmo nível (escalonamento horizontal), o Broken Access Control abrange também o escalonamento vertical de privilégios — quando um usuário comum consegue executar funções exclusivas de um Administrador.
O Erro Clássico de Confiar Apenas no Frontend (React/Vue/Angular)
Muitos desenvolvedores iniciantes escondem o botão "Excluir Usuário" ou "Exportar Relatório Financeiro" na tela do navegador usando uma condição visual (`if (user.role === 'admin')`), mas deixam a rota da API (`DELETE /api/admin/usuarios/12` ou `GET /api/relatorio-geral`) aberta no backend, verificando apenas se o usuário está logado, sem checar seu cargo (Role).
- Qualquer atacante que inspecione o arquivo JavaScript compilado do site descobre as rotas administrativas ocultas e dispara a requisição diretamente via `curl` ou Postman.
- Outro erro crítico (Mass Assignment / Atribuição em Massa): Permitir que o endpoint de edição de perfil (`PUT /api/perfil`) salve diretamente no banco qualquer campo enviado no JSON. Se o atacante enviar `{"nome": "João", "role": "admin", "saldo_creditos": 99999}`, um backend sem DTO Whitelisting atualizará o cargo do usuário para administrador.
---
3. SQL Injection (SQLi) — Como Funciona e Como Blindar 100% do Código
A Injeção de SQL (SQL Injection) ocorre quando dados digitados pelo usuário (em um campo de login, barra de pesquisa ou filtro de URL) são concatenados diretamente dentro do texto do comando SQL enviado ao banco de dados (PostgreSQL, MySQL, SQL Server, Oracle).
Anatomia da Invasão por Concatenação de String
Observe a diferença entre um código vulnerável e um código imune a SQL Injection:
// [ X ] CÓDIGO VULNERÁVEL (JAMAIS FAÇA ISSO!)
// Se o atacante digitar no campo email: [email protected]' OR '1'='1
const queryVulneravel = `SELECT * FROM usuarios WHERE email = '${req.body.email}' AND senha = '${hash}'`;
// O banco executará: SELECT * FROM usuarios WHERE email = '[email protected]' OR '1'='1' ...
// Como '1'='1' é sempre verdadeiro, o atacante entra como Administrador sem saber a senha!
// [ V ] CÓDIGO BLINDADO (Prepared Statements / Queries Parametrizadas)
const querySegura = 'SELECT id, nome, email, role FROM usuarios WHERE email = $1';
const resultado = await db.query(querySegura, [req.body.email]);
Por que as Consultas Parametrizadas (Prepared Statements) neutralizam 100% do SQL Injection? Porque o banco de dados compila a estrutura do comando SQL antes de receber o parâmetro `$1`. Mesmo que o golpista envie aspas simples (`'`), ponto e vírgula (`;`), `UNION SELECT` ou `DROP TABLE`, o banco tratará toda aquela sequência exclusivamente como texto literal de busca, e jamais como comando executável.
---
4. SSRF (Server-Side Request Forgery) e Blind XSS em Auditorias Web
Em auditorias avançadas de aplicações e programas de Bug Bounty, outras duas vulnerabilidades críticas para empresas modernas são detalhadas:
A) SSRF (*Server-Side Request Forgery*)
Muitos sistemas modernos possuem funcionalidades como "Importar foto de perfil a partir de uma URL", "Testar Webhook" ou "Gerar PDF a partir de um link". Na falha de SSRF, em vez de informar um link público da internet (`https://site.com/foto.jpg`), o atacante informa um endereço da rede interna do próprio servidor:
- `http://localhost:6379` ou `http://127.0.0.1:8080/admin` (acessando painéis internos que estavam bloqueados no firewall externo, usando o próprio servidor web como ponte);
- `http://169.254.169.254/latest/meta-data/iam/security-credentials/` (o endereço de metadados internos de instâncias em nuvem AWS/GCP/Azure, permitindo roubar as chaves temporárias de nuvem do servidor!).
- Defesa contra SSRF: Nunca permita que o backend faça requisições HTTP para faixas de IP privadas (`127.0.0.0/8`, `10.0.0.0/8`, `172.16.0.0/12`, `192.168.0.0/16`, `169.254.0.0/16`), desative redirecionamentos HTTP automáticos e exija IMDSv2 (com token obrigatório por sessão) nos servidores em nuvem.
B) Blind XSS (Cross-Site Scripting às Cegas)
Diferente do XSS Refletido (que executa imediatamente na tela de quem clicou em um link), no Blind XSS o atacante preenche um formulário de "Fale Conosco", "Suporte" ou "Currículo" injetando uma carga JavaScript maliciosa. Nada acontece na tela pública do site. Porém, horas depois, quando um funcionário do atendimento ou o administrador abre o Painel Interno de Administração para ler as mensagens recebidas, se aquele painel interno não escapar as tags HTML, o script malicioso é executado dentro do navegador do administrador, roubando seu token de sessão e enviando-o para o servidor do atacante.
---
5. Matriz Comparativa e Checklist de Blindagem de Aplicações Web
| Vulnerabilidade Web | Impacto Médio em Incidentes Reais | Causa Raiz no Código | Solução Técnica Definitiva (Padrão de Segurança Defensiva) |
| :--- | :--- | :--- | :--- |
| IDOR | Vazamento em massa de documentos, faturas e dados pessoais de terceiros | Busca por `id` sem validar se o registro pertence ao usuário da sessão | Filtrar todas as queries por `AND user_id = session.userId` + usar `UUIDv4` |
| Broken Access Control | Usuário comum executando ações administrativas ou alterando próprio cargo | Confiar na ocultação visual no frontend ou aceitar todos os campos no body JSON | Middleware de autorização RBAC/ABAC no backend + validação estrita de DTO |
| SQL Injection (SQLi) | Roubo total do banco de dados, bypass de login e destruição de tabelas | Concatenação direta de variáveis de entrada na string SQL (`'${input}'`) | Uso estrito de Prepared Statements (`$1`, `?`) ou ORMs sem raw queries concatenadas |
| SSRF | Invasão da rede interna e roubo de credenciais da nuvem (`169.254.169.254`) | Servidor buscando URLs fornecidas pelo usuário sem filtrar IPs privados | Bloquear faixas de IP locais/privadas após resolução DNS + exigir IMDSv2 na nuvem |
| Blind XSS | Sequestro da conta do Administrador quando ele visualiza chamados/logs internos | Renderizar dados enviados por clientes usando `innerHTML` sem sanitização no painel admin | Escapar toda saída HTML (nativo do React/Vue, proibir `dangerouslySetInnerHTML` sem DOMPurify) + cabeçalho `Content-Security-Policy (CSP)` |
---
Perguntas Frequentes (FAQ) sobre IDOR, SQL Injection e Segurança de APIs
1. Trocar números sequenciais (`1, 2, 3`) por códigos UUID resolve sozinho a falha de IDOR?
Não completamente. Usar UUIDs impede que um invasor adivinhe ou faça uma varredura sequencial fácil dos identificadores, mas se o UUID de um pedido ou documento acabar vazando em um log, histórico compartilhado ou e-mail, qualquer outra pessoa logada ainda conseguirá acessá-lo caso o backend não verifique explicitamente se aquele recurso pertence ao usuário autenticado na sessão.
2. Usar um ORM moderno (como Prisma, TypeORM, Hibernate ou Django ORM) garante 100% de imunidade contra SQL Injection?
Os métodos padrões dos ORMs (como `findUnique`, `filter` ou `where` parametrizado) utilizam Prepared Statements por baixo dos panos e são seguros contra SQL Injection. Entretanto, se o programador utilizar funções de consulta bruta (raw queries, como `$queryRawUnsafe` ou `.raw`) concatenando variáveis de texto diretamente, a aplicação voltará a ficar vulnerável a SQL Injection.
3. Como posso testar se o site da minha empresa possui essas falhas sem correr riscos?
Realize testes em um ambiente de homologação (staging) idêntico ao de produção utilizando dois usuários de teste (`Usuario A` e `Usuario B`). Tente acessar um documento criado pelo `Usuario A` usando o token de sessão do `Usuario B` (teste de IDOR) e tente chamar uma rota administrativa usando o token de um usuário comum (teste de Broken Access Control).
---
Fonte: Curso Hacker do Bem — TI Academy.