OWASP Top 10 explicado con ejemplos prácticos

Security2026-11-17TryQuickToolBox

Probablemente hayas oído hablar del OWASP Top 10, pero ¿sabes cómo se ve cada vulnerabilidad en el código real? Muchos desarrolladores lo tratan como una lista de verificación teórica, pero estas fallas están detrás de innumerables brechas de seguridad. Este artículo recorre cada categoría del OWASP Top 10 con ejemplos prácticos y soluciones concretas, para que puedas identificarlas y detenerlas en tus proyectos.

1. Control de acceso roto

El control de acceso determina qué pueden hacer los usuarios autenticados. Cuando está roto, los usuarios pueden acceder a datos o realizar acciones fuera de sus permisos.

Ejemplo: Referencia directa insegura a objetos (IDOR)

// Vulnerable: cualquier usuario autenticado puede ver cualquier pedido cambiando el ID
app.get('/orders/:id', (req, res) => {
  const order = db.getOrder(req.params.id);
  res.json(order);
});

// Corregido: verificar la propiedad
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);
});

Solución: Aplica el control de acceso en el servidor, deniega por defecto y registra los fallos.

2. Fallas criptográficas

Los datos sensibles deben cifrarse en tránsito y en reposo. Los errores comunes incluyen el uso de algoritmos débiles o claves codificadas directamente.

Ejemplo: Almacenar contraseñas con MD5

// Vulnerable
const hash = md5(password);

// Corregido: usar bcrypt o argon2
const hash = await bcrypt.hash(password, 12);

Solución: Usa hash fuerte con sal para contraseñas; cifra datos sensibles con AES-256; usa siempre HTTPS.

3. Inyección

La inyección ocurre cuando datos no confiables se envían a un intérprete como parte de un comando o consulta.

Ejemplo: Inyección SQL

// Vulnerable: concatenación de cadenas
const query = "SELECT * FROM users WHERE name = '" + name + "'";

// Corregido: consulta parametrizada
const query = 'SELECT * FROM users WHERE name = ?';
db.execute(query, [name]);

Solución: Usa consultas parametrizadas, ORMs y valida la entrada. Para comandos del sistema operativo, evita la ejecución de shell o usa APIs seguras.

4. Diseño inseguro

Esta categoría se centra en fallas en el diseño y la arquitectura, no solo en errores de implementación. El modelado de amenazas y los patrones de diseño seguro son esenciales.

Ejemplo: Sin límite de velocidad en restablecimiento de contraseña

Sin límite de velocidad, los atacantes pueden forzar tokens de restablecimiento. Solución: Implementa límites de velocidad, usa tokens fuertes y haz que expiren rápidamente.

5. Configuración de seguridad incorrecta

Las configuraciones predeterminadas, los errores detallados y las características innecesarias son culpables comunes.

Ejemplo: Exponer trazas de pila

// Vulnerable: error detallado al cliente
app.use((err, req, res, next) => {
  res.status(500).send(err.stack);
});

// Corregido: mensaje genérico, registrar detalles en el servidor
app.use((err, req, res, next) => {
  console.error(err.stack);
  res.status(500).send('Algo salió mal');
});

Solución: Refuerza las configuraciones, elimina características no utilizadas y usa encabezados de seguridad como CSP y HSTS.

6. Componentes vulnerables y desactualizados

Usar bibliotecas con vulnerabilidades conocidas es como dejar una puerta abierta.

Ejemplo: Versión antigua de lodash con contaminación de prototipo

Solución: Actualiza regularmente las dependencias, usa herramientas como npm audit o OWASP Dependency-Check y monitorea los avisos.

7. Fallas de identificación y autenticación

Una autenticación débil permite a los atacantes comprometer contraseñas o tokens de sesión.

Ejemplo: ID de sesión en la URL

// Vulnerable: ID de sesión en la cadena de consulta
const sessionId = req.query.sessionId;

// Corregido: usar cookies seguras y HttpOnly
res.cookie('session', sessionId, { httpOnly: true, secure: true });

Solución: Implementa autenticación multifactor, exige contraseñas fuertes y usa gestión de sesiones segura.

8. Fallas de integridad de software y datos

Esta categoría se relaciona con código e infraestructura que no protegen contra violaciones de integridad, como deserialización insegura o uso de CDNs no confiables.

Ejemplo: Deserialización insegura

// Vulnerable: deserializar datos no confiables
const obj = deserialize(userInput);

// Corregido: usar formatos seguros como JSON y validar el esquema
const obj = JSON.parse(userInput);
if (!isValidSchema(obj)) throw new Error('Inválido');

Solución: Verifica la integridad con firmas digitales, usa formatos de serialización seguros y revisa las canalizaciones de CI/CD.

9. Fallas de registro y monitoreo de seguridad

Sin un registro adecuado, las brechas pasan desapercibidas. Los registros deben generarse, almacenarse de forma segura y monitorearse.

Ejemplo: No registrar inicios de sesión fallidos

// Vulnerable: sin registro
if (!valid) return res.status(401).end();

// Corregido: registrar el evento
if (!valid) {
  logger.warn('Intento de inicio de sesión fallido', { ip: req.ip, username });
  return res.status(401).end();
}

Solución: Registra eventos de seguridad, configura alertas y asegura que los registros sean a prueba de manipulaciones.

10. Falsificación de solicitudes del lado del servidor (SSRF)

SSRF ocurre cuando un atacante puede hacer que el servidor envíe solicitudes a ubicaciones no previstas.

Ejemplo: Obtener una URL sin validación

// Vulnerable: obtiene cualquier URL
app.get('/fetch', async (req, res) => {
  const response = await fetch(req.query.url);
  res.send(await response.text());
});

// Corregido: validar URL contra lista de permitidos
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());
});

Solución: Usa listas de permitidos, valida URL y restringe el tráfico saliente.

Tabla comparativa: OWASP Top 10 de un vistazo

CategoríaEjemplo comúnSolución principal
Control de acceso rotoIDORVerificaciones en el servidor
Fallas criptográficasHash de contraseña débilUsar bcrypt/argon2
InyecciónInyección SQLConsultas parametrizadas
Diseño inseguroSin límite de velocidadModelado de amenazas
Configuración de seguridad incorrectaErrores detalladosReforzar configuraciones
Componentes vulnerablesBiblioteca desactualizadaActualizaciones regulares
Fallas de autenticaciónSesión en URLCookies seguras
Fallas de integridadDeserialización inseguraValidar y firmar
Fallas de registroSin registros de inicio de sesión fallidosRegistro centralizado
SSRFObtención de URL no validadaValidación con lista de permitidos

Preguntas frecuentes

¿Qué es el OWASP Top 10?

El OWASP Top 10 es un documento de concientización estándar para desarrolladores y seguridad de aplicaciones web. Representa un amplio consenso sobre los riesgos de seguridad más críticos para las aplicaciones web.

¿Con qué frecuencia se actualiza el OWASP Top 10?

OWASP actualiza la lista periódicamente para reflejar amenazas emergentes y cambios en la tecnología. La versión más reciente es de 2021, y se esperan actualizaciones en el futuro.

¿Es suficiente el OWASP Top 10 para proteger mi aplicación?

No, es un punto de partida. Un programa de seguridad integral incluye prácticas de codificación segura, pruebas regulares y monitoreo continuo más allá del Top 10.

¿Listo para verificar tus cargas útiles JSON en busca de fallas de inyección? Usa nuestro Formateador JSON para validar y formatear JSON de manera segura.