Segurança essencial para aplicativos web em 2026
Práticas mínimas para garantir integridade frente a eventos imprevisíveis.
Para começar, esse artigo exige que você já saiba o mínimo de desenvolvimento seguro, itens como armazenar senha como hash seguro, ter MFA implementado e Rate Limit. Listei alguns itens um pouco além do óbvio, pensando mais próximo de como um bom atacante hoje pensa. Mas como ele pensa? Não existe uma fórmula mágica, mas há algumas características que acompanham a maioria deles pela essência da atividade, como:
Reconhecimento:
É a fase explorátoria, identificando
- Endpoints esquecidos (/metrics, /debug)
- Comentários de chaves expostas no frontend
- Enumeração de ambientes legados de testes ou homologação
- Análise de cabeçalhos, identificando versões de frameworks, servidores web ou bibliotecas.
- Mapeamento de buckets ou pastas de midia estática.
Questionar premissas:
Questionar as premissas envolvem ir contra o esperado pelo backend, no objetivo de descobrir pontos de falhas.
- Enviar campos com tipos diferententes do esperado (String em campo de número);
- Número negativo em campos que deveriam receber somente positivos;
- Números gigantes;
- Enviar com extensões inesperadas;
- Enviar scripts maliciosos com os magic bytes e extensões alteradas para burlar a checagem.
Business Logic Flaws:
É procurado brechas nas regras de négocio e fluxos, pegando o mesmo caminho de burlar premissas, tentando pular passos da escada que foi idealizada. Por exemplo:
- Enviar requisição para endpoint de finalização sem passar pelo área de pagamento
- Abusar do programa de indicação com criação de contas infinitas
- Concorrência simultanêa, mandando diversas requisições no mesmo milisegundo para um endpoint de uso de CUPOM limitado.
Agora sabendo desses vetores, vamos tomar medidas de defesa e prevenção
Defendendo o reconhecimento: reduza a superfície exposta
Você não consegue impedir que alguém olhe, mas pode garantir que não tenha nada de útil para ver.
- Endpoints de observabilidade (/metrics, /debug, /actuator, /swagger) atrás de VPN, rede privada ou autenticação, nunca na internet pública;
- Rodar scanner de segredos (gitleaks, trufflehog) no CI e no histórico do repositório. Chave que já foi commitada deve ser considerada vazia e rotacionada;
- Ambientes de homologação e testes com autenticação, sem dados reais de produção e desligados quando não estiverem em uso;
- Remover cabeçalhos que entregam versões (
Server,X-Powered-By) e desabilitar páginas de erro detalhadas e stack traces em produção; - Buckets privados por padrão, com URLs assinadas e expiração curta para acesso a arquivos;
- Manter inventário de domínios, subdomínios e serviços. Ninguém protege o que não sabe que existe.
Defendendo as premissas: nunca confie na entrada
Toda premissa do backend precisa virar uma validação explícita, no servidor. Validação no frontend é só UX.
- Validar tipo, formato, tamanho e faixa de valores com um schema (Zod, Joi, Pydantic, Bean Validation), rejeitando tudo que não estiver na especificação (allowlist, não blocklist);
- Limitar tamanho de payload, quantidade de itens em listas e profundidade de JSON;
- Usar tipos adequados para dinheiro (inteiro em centavos ou decimal) e checar overflow e valores negativos;
- Em uploads: não confiar na extensão nem no
Content-Typeenviado pelo cliente. Verificar o conteúdo real (magic bytes), limitar o tamanho, renomear o arquivo com um identificador gerado por você e armazenar fora do diretório executável, de preferência em um bucket sem permissão de execução; - Consultas parametrizadas e escape de saída conforme o contexto (HTML, SQL, shell), porque validar a entrada não substitui tratar a saída.
Defendendo a lógica de negócio: o servidor é dono do fluxo
Aqui nenhum scanner automático ajuda, porque o código está “correto”, só não previu o uso malicioso.
- Modelar o fluxo como máquina de estados: o pedido só vai para
finalizadose estiver empago, e essa checagem acontece no backend a cada transição; - Nunca aceitar do cliente valores que o servidor pode calcular, como preço, desconto ou total;
- Verificar autorização por objeto (o recurso pertence a este usuário?) em todo endpoint, evitando IDOR;
- Contra concorrência (race condition): usar transações com lock (
SELECT ... FOR UPDATE), constraints únicas no banco ou operações atômicas, comoUPDATE cupons SET usos = usos + 1 WHERE id = ? AND usos < limite. Chaves de idempotência também ajudam em pagamentos; - Contra abuso de indicação e criação de contas em massa: verificação de e-mail e telefone, limites por dispositivo e IP, análise de padrões e recompensa só liberada após uma ação real, como a primeira compra confirmada;
- Pensar como atacante já no desenho da funcionalidade: para cada fluxo, perguntar “e se eu pular este passo? e se eu repetir? e se eu fizer isso mil vezes ao mesmo tempo?”.
Defendendo a cadeia de suprimentos: você também roda o código dos outros
Uma aplicação moderna tem centenas de dependências diretas e transitivas, e o atacante sabe que é mais fácil comprometer um pacote popular do que o seu servidor.
- Rodar análise de dependências (
npm audit,pip-audit, OSV-Scanner, Dependabot, Renovate) no CI, falhando o build para vulnerabilidades altas e críticas; - Versionar o lockfile e instalar com
npm ci, que respeita exatamente as versões travadas, em vez denpm install; - Cuidado com typosquatting (
reqeustsem vez derequests) e com pacotes novos, com poucos downloads ou recém-transferidos para outro mantenedor. Conferir antes de adicionar; - Desabilitar scripts de instalação (
--ignore-scripts) quando não forem necessários, já quepostinstallexecuta código arbitrário na sua máquina e no CI; - Atualizar com frequência, em passos pequenos. Uma atualização por semana é mais fácil de revisar e reverter do que uma por ano;
- Remover dependências sem uso. Menos pacotes significa menos superfície;
- Gerar um SBOM (lista de componentes) a cada release, para responder rápido à pergunta “estamos usando a biblioteca afetada?” quando sair a próxima vulnerabilidade crítica;
- Proteger o próprio pipeline: segredos do CI com escopo mínimo, actions fixadas por hash do commit e revisão obrigatória em mudanças de workflow.
Sessão com logout automático e teto de renovação
Token que nunca expira é uma credencial roubada que vale para sempre. A solução é combinar uma sessão curta, que se renova enquanto o usuário está ativo, com um limite absoluto que obriga um novo login.
- Como entregar a credencial: não precisa ser um token devolvido no corpo da resposta HTTP e guardado pelo frontend (
localStorage, memória). O servidor pode enviar tudo viaSet-CookiecomHttpOnly,SecureeSameSite, de modo que o JavaScript nunca toca na credencial e um XSS não consegue lê-la. Isso vale tanto para tokens (JWT) quanto para um ID de sessão opaco guardado no servidor. Se usar cookie, lembre da proteção contra CSRF (SameSite=LaxouStrict, e token anti-CSRF em requisições que alteram estado); - Credencial de acesso de vida curta (5 a 15 minutos), seja um access token ou o cookie de sessão. Se vazar, a janela de abuso é pequena;
- Refresh token para emitir uma nova credencial de acesso sem pedir a senha. Também em cookie
HttpOnly, comPathrestrito à rota de refresh para que não seja enviado em todas as requisições; - Rotação do refresh token: a cada uso, o antigo é invalidado e um novo é emitido. Se um token já usado aparecer de novo, é sinal de roubo, então toda a família de sessões é revogada;
- Timeout por inatividade (por exemplo, 30 minutos sem requisições): a sessão expira e o refresh deixa de funcionar;
- Teto absoluto de sessão (por exemplo, 8 ou 12 horas desde o login): mesmo com atividade constante, o refresh para de renovar e o usuário precisa se autenticar de novo. O teto é gravado no momento do login (
session_started_at) e nunca é estendido por um refresh; - Logout automático no cliente: ao receber
401do refresh, limpar o estado local da interface e redirecionar para o login. Com cookiesHttpOnlyo cliente não consegue apagá-los, então o logout precisa de uma chamada ao servidor que responda comSet-Cookieexpirado. Um aviso “sua sessão vai expirar” alguns minutos antes melhora a experiência; - Revogação no servidor: logout, troca de senha e suspeita de comprometimento invalidam os refresh tokens no banco. Sem isso o logout é só cosmético;
- Para ações sensíveis (trocar e-mail, senha, dados de pagamento), exigir reautenticação recente mesmo com a sessão válida.
A regra de renovação, no servidor, fica assim:
const INACTIVITY_LIMIT = 30 * 60 * 1000; // 30 min sem uso
const ABSOLUTE_LIMIT = 8 * 60 * 60 * 1000; // teto de 8h desde o login
async function refresh(oldToken: string, res: Response) {
const session = await sessions.findByToken(hash(oldToken));
const now = Date.now();
if (!session || session.revokedAt) throw new Unauthorized();
// token já rotacionado sendo reutilizado: possível roubo
if (session.rotatedAt) {
await sessions.revokeFamily(session.familyId);
throw new Unauthorized();
}
if (now - session.lastActivityAt > INACTIVITY_LIMIT) throw new Unauthorized();
if (now - session.startedAt > ABSOLUTE_LIMIT) throw new Unauthorized(); // teto
await sessions.markRotated(session.id);
const next = await sessions.create({
familyId: session.familyId,
startedAt: session.startedAt, // herdado, o teto não se renova
lastActivityAt: now,
});
// credenciais enviadas em cookies HttpOnly, nada no corpo da resposta
res.cookie("access", signAccessToken(session.userId), {
httpOnly: true, secure: true, sameSite: "lax", maxAge: 15 * 60 * 1000,
});
res.cookie("refresh", next.token, {
httpOnly: true, secure: true, sameSite: "lax",
path: "/auth/refresh", // só viaja nesta rota
maxAge: ABSOLUTE_LIMIT - (now - session.startedAt),
});
}
O ponto central é startedAt: session.startedAt: o refresh renova a atividade, mas não o relógio do teto. Note também que o maxAge do cookie de refresh diminui a cada renovação, para acompanhar o teto.
Detecção e resposta
Prevenção falha em algum momento, então é preciso perceber quando isso acontecer.
- Logs estruturados de eventos sensíveis (login, troca de senha, falhas de autorização, uso de cupom) sem registrar senhas, tokens ou dados pessoais;
- Alertas para picos de erros 4xx/5xx, tentativas repetidas em endpoints inexistentes e uso anormal de um mesmo recurso;
- Ter um plano de resposta a incidentes simples e ensaiado: quem é acionado, como rotacionar segredos, como revogar sessões e como comunicar os afetados;
- Backups testados e isolados. Um backup que nunca foi restaurado é só uma esperança.
Conclusão
Segurança mínima não é uma lista de ferramentas, é uma mudança de perspectiva: assumir que cada entrada pode ser hostil, que cada passo do fluxo pode ser pulado e que algo vai escapar. Se você aplicar só o que está aqui, já terá dificultado a vida de boa parte dos atacantes, e é justamente isso que muda o jogo: tornar o ataque caro o suficiente para que ele procure outro alvo.