OWASP Top 10 2025: Riesgos Críticos para Aplicaciones Web

// Ejemplo: vulnerabilidad IDOR
// MAL - usuario puede consultar cualquier orden
app.get('/api/orders/:id', auth, async (req, res) => {
  const order = await Order.findById(req.params.id);
  res.json(order); // ¡Sin verificación!
});

// BIEN - agregar verificación de autorización
app.get('/api/orders/:id', auth, async (req, res) => {
  const order = await Order.findOne({
    _id: req.params.id,
    userId: req.user.id
  });
  if (!order) return res.status(404).json({ error: 'No encontrado' });
  res.json(order);
});

// MAL - almacenar contraseña con MD5
const hash = crypto.createHash('md5').update(password).digest('hex');

// BIEN - usar bcrypt con salt rounds
const bcrypt = require('bcrypt');
const saltRounds = 12;
const hash = await bcrypt.hash(password, saltRounds);

// Verificación
const isValid = await bcrypt.compare(inputPassword, storedHash);

// MAL - vulnerabilidad de inyección SQL
const query = `SELECT * FROM users WHERE id = ${req.params.id}`;
db.query(query);

// BIEN - consulta parametrizada
const query = 'SELECT * FROM users WHERE id = ?';
db.query(query, [req.params.id]);

// Ejemplo ORM (Sequelize)
const user = await User.findOne({
  where: { id: req.params.id }
});

// MAL - sin rate limiting en reset de contraseña
app.post('/api/reset-password', async (req, res) => {
  const user = await User.findByEmail(req.body.email);
  if (user) sendResetEmail(user); // ¡Sin límite!
  res.json({ message: 'Revisa tu email' });
});

// BIEN - rate limiting + bloqueo de cuenta
const rateLimit = require('express-rate-limit');
const resetLimiter = rateLimit({
  windowMs: 15 * 60 * 1000,
  max: 3,
  message: 'Demasiadas solicitudes, intente más tarde'
});
app.post('/api/reset-password', resetLimiter, async (req, res) => {
  // ... implementación segura
});

# Configuración de headers de seguridad Nginx
server {
  # Strict Transport Security
  add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;

  # Content Security Policy
  add_header Content-Security-Policy "default-src 'self'; script-src 'self'" always;

  # Prevenir clickjacking
  add_header X-Frame-Options "SAMEORIGIN" always;

  # Prevenir MIME type sniffing
  add_header X-Content-Type-Options "nosniff" always;

  # Ocultar versión del servidor
  server_tokens off;
}

# Verificar vulnerabilidades en tu proyecto
npm audit

# Corregir automáticamente paquetes vulnerables
npm audit fix

# Escaneo Snyk para análisis más profundo
npx snyk test

# Mostrar paquetes desactualizados
npm outdated

# Config Dependabot (.github/dependabot.yml)
version: 2
updates:
  - package-ecosystem: "npm"
    directory: "/"
    schedule:
      interval: "weekly"

// Login con protección contra fuerza bruta
const loginAttempts = new Map();

app.post('/api/login', async (req, res) => {
  const { email, password } = req.body;
  const attempts = loginAttempts.get(email) || { count: 0, lockUntil: 0 };

  if (attempts.lockUntil > Date.now()) {
    return res.status(429).json({ error: 'Cuenta bloqueada temporalmente' });
  }

  const user = await User.findByEmail(email);
  const valid = user && await bcrypt.compare(password, user.password);

  if (!valid) {
    attempts.count++;
    if (attempts.count >= 5) {
      attempts.lockUntil = Date.now() + 15 * 60 * 1000;
    }
    loginAttempts.set(email, attempts);
    return res.status(401).json({ error: 'Credenciales inválidas' });
  }

  loginAttempts.delete(email);
  const token = generateJWT(user);
  res.json({ token });
});

// Subresource Integrity (SRI) para scripts externos
<script
  src="https://cdn.example.com/lib.min.js"
  integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K/uxAh6VgnSY"
  crossorigin="anonymous">
</script>

// Verificación de lock file en pipeline CI
// Siempre commitear package-lock.json o yarn.lock
// Usar npm ci en vez de npm install en CI
npm ci --ignore-scripts

// Verificar integridad de paquetes
npm audit signatures

// Logging de seguridad estructurado con Winston
const winston = require('winston');

const securityLogger = winston.createLogger({
  level: 'info',
  format: winston.format.json(),
  defaultMeta: { service: 'auth-service' },
  transports: [
    new winston.transports.File({ filename: 'security.log' })
  ]
});

// Registrar intentos de login fallidos
app.post('/api/login', async (req, res) => {
  const { email } = req.body;
  const success = await authenticate(email, req.body.password);

  securityLogger.info({
    event: success ? 'LOGIN_SUCCESS' : 'LOGIN_FAILURE',
    email,
    ip: req.ip,
    userAgent: req.headers['user-agent'],
    timestamp: new Date().toISOString()
  });
});

// MAL - URL del usuario sin validación
app.post('/api/fetch-url', async (req, res) => {
  const response = await fetch(req.body.url); // ¡SSRF!
  res.json(await response.json());
});

// BIEN - validación de URL con allowlist
const allowedDomains = ['api.example.com', 'cdn.example.com'];

function isAllowedUrl(urlString) {
  try {
    const url = new URL(urlString);
    if (!['http:', 'https:'].includes(url.protocol)) return false;
    if (!allowedDomains.includes(url.hostname)) return false;
    const ip = url.hostname;
    if (ip.startsWith('10.') || ip.startsWith('192.168.') ||
        ip.startsWith('169.254.') || ip === 'localhost') return false;
    return true;
  } catch { return false; }
}

app.post('/api/fetch-url', async (req, res) => {
  if (!isAllowedUrl(req.body.url)) {
    return res.status(400).json({ error: 'URL no permitida' });
  }
  const response = await fetch(req.body.url);
  res.json(await response.json());
});