Segurança Web em 2025: 10 Práticas Essenciais que Todo Dev Deve Conhecer

A segurança web nunca foi tão crítica. Com o aumento exponencial de ataques cibernéticos em 2025, entender e implementar práticas de segurança deixou de ser opcional.

Por Que Segurança É Mais Importante Agora?

Em 2025, vemos:

• Aumento de 300% em ataques de ransomware
• Vazamento de dados custando média de R$ 4.5 milhões por incidente
• Regulamentações mais rígidas (LGPD, GDPR) com multas pesadas
• IA sendo usada por hackers para ataques mais sofisticados

As 10 Práticas Essenciais de Segurança

1. 🔐 Autenticação Multi-Fator (MFA)

Por quê? Senhas sozinhas não são mais suficientes.

// Implementação básica de MFA
import { authenticator } from 'otplib';

function generateMFASecret() {
  return authenticator.generateSecret();
}

function verifyMFAToken(token: string, secret: string) {
  return authenticator.verify({ token, secret });
}

Ferramentas recomendadas:

• Google Authenticator
• Authy
• Microsoft Authenticator

2. 🛡️ Proteção Contra SQL Injection

Problema: SQL Injection ainda é uma das vulnerabilidades mais exploradas.

// ❌ ERRADO - Vulnerável a SQL Injection
const query = `SELECT * FROM users WHERE email = '${email}'`;

// ✅ CORRETO - Usando prepared statements
const query = 'SELECT * FROM users WHERE email = ?';
db.execute(query, [email]);

3. 🔒 HTTPS Obrigatório

2025: Navegadores agora marcam sites HTTP como "Perigosos"

• Use Let's Encrypt (gratuito)
• Force HTTPS redirect
• Implemente HSTS (HTTP Strict Transport Security)

// Next.js - Force HTTPS
export default function middleware(req: NextRequest) {
  if (!req.url.startsWith('https://')) {
    return NextResponse.redirect(
      `https://${req.nextUrl.host}${req.nextUrl.pathname}`
    );
  }
}

4. 🚫 Proteção XSS (Cross-Site Scripting)

Sanitize todos os inputs de usuário!

import DOMPurify from 'isomorphic-dompurify';

// Sanitizar HTML antes de renderizar
const cleanHTML = DOMPurify.sanitize(userInput);

React já protege por padrão, mas cuidado com:

• dangerouslySetInnerHTML
• Injeção de URLs em href
• Event handlers dinâmicos

5. 🔑 Gestão Segura de Senhas

Nunca, JAMAIS armazene senhas em plain text!

import bcrypt from 'bcrypt';

// Hash de senha
async function hashPassword(password: string) {
  const saltRounds = 12; // Aumentado em 2025
  return await bcrypt.hash(password, saltRounds);
}

// Verificar senha
async function verifyPassword(password: string, hash: string) {
  return await bcrypt.compare(password, hash);
}

Use nosso Gerador de Senhas para criar senhas fortes!

6. 🎯 CORS Configurado Corretamente

// Next.js API Route com CORS seguro
export async function GET(req: Request) {
  const allowedOrigins = ['https://seu-site.com'];
  const origin = req.headers.get('origin');
  
  if (!origin || !allowedOrigins.includes(origin)) {
    return new Response('Forbidden', { status: 403 });
  }
  
  return new Response(JSON.stringify({ data: 'safe' }), {
    headers: {
      'Access-Control-Allow-Origin': origin,
      'Access-Control-Allow-Methods': 'GET, POST',
    }
  });
}

7. 🔐 JWT Tokens Seguros

import jwt from 'jsonwebtoken';

// Gerar token com expiração curta
function generateToken(userId: string) {
  return jwt.sign(
    { userId },
    process.env.JWT_SECRET!,
    { expiresIn: '15m' } // Token expira em 15 minutos
  );
}

// Usar refresh tokens para sessões longas
function generateRefreshToken(userId: string) {
  return jwt.sign(
    { userId, type: 'refresh' },
    process.env.JWT_REFRESH_SECRET!,
    { expiresIn: '7d' }
  );
}

8. 📊 Rate Limiting

Proteja suas APIs contra ataques de força bruta:

import rateLimit from 'express-rate-limit';

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutos
  max: 100, // limite de 100 requisições
  message: 'Muitas requisições, tente novamente mais tarde'
});

app.use('/api/', limiter);

9. 🔍 Validação de Dados

Nunca confie no frontend!

import { z } from 'zod';

// Validação robusta com Zod
const userSchema = z.object({
  email: z.string().email(),
  cpf: z.string().regex(/^d{3}.d{3}.d{3}-d{2}$/),
  age: z.number().min(18).max(120)
});

// Validar
const result = userSchema.safeParse(userData);
if (!result.success) {
  // Tratar erros
}

Use nossas ferramentas:

• Validador de CPF
• Validador de CNPJ
• Validador de Email

10. 🔒 Content Security Policy (CSP)

// Next.js headers configuration
const securityHeaders = [
  {
    key: 'Content-Security-Policy',
    value: "default-src 'self'; script-src 'self' 'unsafe-inline';"
  },
  {
    key: 'X-Frame-Options',
    value: 'DENY'
  },
  {
    key: 'X-Content-Type-Options',
    value: 'nosniff'
  },
  {
    key: 'Referrer-Policy',
    value: 'origin-when-cross-origin'
  }
];

Checklist de Segurança 2025

Use esta lista antes de lançar qualquer aplicação:

• [ ] HTTPS configurado e forçado
• [ ] MFA implementado
• [ ] Senhas hasheadas com bcrypt/argon2
• [ ] SQL Injection prevenido (prepared statements)
• [ ] XSS prevenido (sanitização de inputs)
• [ ] CORS configurado corretamente
• [ ] Rate limiting implementado
• [ ] JWT com expiração curta
• [ ] Validação de dados no backend
• [ ] CSP headers configurados
• [ ] Logs de segurança implementados
• [ ] Backup automatizado
• [ ] Plano de resposta a incidentes

Ferramentas de Teste de Segurança

Gratuitas

1. OWASP ZAP - Scanner de vulnerabilidades
2. Burp Suite Community - Análise de requisições
3. npm audit - Vulnerabilidades em dependências
4. Snyk - Scan de código

Pagas (Vale o Investimento)

1. Snyk Pro - Monitoramento contínuo
2. Checkmarx - SAST/DAST
3. Veracode - Análise profunda

Recursos Educacionais

Aprenda mais:

• OWASP Top 10 2024
• PortSwigger Web Security Academy
• HackTheBox - Prática hands-on

Teste seus conhecimentos:

• Quiz de Programação - Questões sobre segurança

Conclusão

Segurança não é um feature - é um requisito fundamental. Em 2025, com IA facilitando ataques e regulamentações mais rígidas, não há desculpas para aplicações inseguras.

Lembre-se: O custo de prevenir é sempre menor que o custo de remediar um vazamento de dados.

---

Implemente essas práticas hoje e durma tranquilo sabendo que sua aplicação está protegida!