Top 10 de aplicaciones web de OWASP (2025)

1️⃣ A01 - Control de acceso roto

Visión general

El control de acceso aplica la política de forma que los usuarios no puedan actuar fuera de los permisos previstos. Los fallos suelen provocar la divulgación no autorizada de información, la modificación o destrucción de datos, o la realización de una función empresarial fuera de los límites del usuario.

Ejemplo de código vulnerable

# User ID taken directly from request without authorization check
@app.route('/api/user/<user_id>/profile')
def get_profile(user_id):
    user = db.get_user(user_id)  # No ownership check!
    return jsonify(user.to_dict())

Ejemplo de código seguro

@app.route('/api/user/<user_id>/profile')
@login_required
def get_profile(user_id):
    # Verify the requesting user owns this resource
    if current_user.id != user_id and not current_user.is_admin:
        abort(403)

    user = db.get_user(user_id)
    if not user:
        abort(404)
    return jsonify(user.to_dict())

Lista de control de las medidas paliativas

• Denegar el acceso por defecto excepto a los recursos públicos
• Implantar comprobaciones de control de acceso en el servidor para cada solicitud
• Imponer la propiedad de los registros en lugar de aceptar los identificadores enviados por los usuarios
• Registre los fallos del control de acceso y avise a los administradores en caso de infracciones reiteradas

2️⃣ A02 - Error de configuración de seguridad

Visión general

La mala configuración de la seguridad se produce cuando los ajustes de seguridad se definen, implementan o mantienen de forma incorrecta. Esto incluye la falta de refuerzo de la seguridad, la activación de funciones innecesarias, cuentas predeterminadas con contraseñas sin modificar, mensajes de error demasiado detallados y cabeceras de seguridad HTTP mal configuradas.

Ejemplo de código vulnerable

# Debug mode enabled in production, verbose errors exposed
app = Flask(__name__)
app.config['DEBUG'] = True  # Exposes stack traces!
app.config['SECRET_KEY'] = 'default-secret'  # Default key!

Ejemplo de código seguro

import os

app = Flask(__name__)
app.config['DEBUG'] = False
app.config['SECRET_KEY'] = os.environ['SECRET_KEY']

@app.after_request
def set_security_headers(response):
    response.headers['X-Content-Type-Options'] = 'nosniff'
    response.headers['X-Frame-Options'] = 'DENY'
    response.headers['Strict-Transport-Security'] = 'max-age=31536000; includeSubDomains'
    response.headers['Content-Security-Policy'] = "default-src 'self'"
    return response

Lista de control de las medidas paliativas

• Implantar un proceso de refuerzo repetible para todos los entornos
• Elimine o desactive funciones, marcos y cuentas predeterminadas innecesarios.
• Configurar cabeceras de seguridad adecuadas (CSP, HSTS, X-Frame-Options)
• Utilizar herramientas automatizadas para verificar la eficacia de las configuraciones.

3️⃣ A03 - Fallos en la cadena de suministro de software

Visión general

Nuevo en 2025. Se centra en los riesgos relacionados con los componentes de terceros, las dependencias y las canalizaciones CI/CD. Los atacantes atacan la cadena de suministro de software comprometiendo paquetes, inyectando código malicioso en bibliotecas de código abierto o explotando vulnerabilidades de las canalizaciones de compilación.

Ejemplo de código vulnerable

// package.json with unpinned dependencies
{
  "dependencies": {
    "express": "*",           // Any version!
    "lodash": "^4.0.0",       // Wide range
    "unknown-pkg": "^1.0.0"   // Unvetted package
  }
}

Ejemplo de código seguro

// package.json with pinned versions + lockfile + audit
{
  "dependencies": {
    "express": "4.21.2",
    "lodash": "4.17.21"
  },
  "scripts": {
    "preinstall": "npx npm-audit-resolver",
    "integrity-check": "npm audit signatures"
  }
}
// Also: use package-lock.json, enable Dependabot/Renovate,
// generate SBOM, verify package provenance

Lista de control de las medidas paliativas

• Fija las versiones de las dependencias y utiliza archivos de bloqueo para realizar compilaciones reproducibles.
• Activar el análisis automático de dependencias (Dependabot, Snyk, Renovate)
• Generación y mantenimiento de la lista de materiales de software (SBOM)
• Verificar la procedencia y las firmas de los paquetes antes de su inclusión

4️⃣ A04 - Fallos criptográficos

Visión general

Fallos relacionados con la criptografía que a menudo conducen a la exposición de datos sensibles. Esto incluye el uso de algoritmos obsoletos, la generación de claves débiles, la falta de cifrado de datos en tránsito o en reposo y la validación incorrecta de certificados.

Ejemplo de código vulnerable

import hashlib

# Storing passwords with weak hashing
def store_password(password: str) -> str:
    return hashlib.md5(password.encode()).hexdigest()  # MD5 is broken!

Ejemplo de código seguro

import bcrypt

def store_password(password: str) -> bytes:
    # Use bcrypt with automatic salting
    salt = bcrypt.gensalt(rounds=12)
    return bcrypt.hashpw(password.encode(), salt)

def verify_password(password: str, hashed: bytes) -> bool:
    return bcrypt.checkpw(password.encode(), hashed)

Lista de control de las medidas paliativas

• Utilice algoritmos sólidos y actuales (AES-256, bcrypt/argon2, SHA-256+).
• Cifrar todos los datos confidenciales en tránsito (TLS 1.2+) y en reposo
• Nunca utilice algoritmos obsoletos (MD5, SHA-1, DES, RC4)
• Aplicar una gestión de claves adecuada con políticas de rotación

5️⃣ A05 - Inyección

Visión general

Los fallos de inyección se producen cuando se envían datos no fiables a un intérprete como parte de un comando o consulta. Las formas más comunes son la inyección SQL, la inyección NoSQL, la inyección de comandos OS y el Cross-Site Scripting (XSS). Los datos hostiles pueden engañar al intérprete para que ejecute comandos no deseados.

Ejemplo de código vulnerable

# SQL injection via string concatenation
def get_user(username: str):
    query = f"SELECT * FROM users WHERE name = '{username}'"
    return db.execute(query)  # username = "' OR '1'='1"

Ejemplo de código seguro

# Parameterized queries prevent SQL injection
def get_user(username: str):
    query = "SELECT * FROM users WHERE name = %s"
    return db.execute(query, (username,))

# For XSS prevention, escape output
from markupsafe import escape

def render_comment(comment: str) -> str:
    return f"<p>{escape(comment)}</p>"

Lista de control de las medidas paliativas

• Utilice consultas parametrizadas o sentencias preparadas para todas las operaciones de la base de datos.
• Utilice una codificación de salida sensible al contexto para evitar XSS
• Validar y desinfectar todas las entradas del usuario en el servidor
• Utilizar ORM con consultas parametrizadas en lugar de construir cadenas SQL sin procesar

6️⃣ A06 - Diseño inseguro

Visión general

El diseño inseguro se refiere a los riesgos relacionados con defectos de diseño y arquitectura. Exige el uso de modelos de amenazas, patrones de diseño seguros y arquitecturas de referencia. Un diseño inseguro no puede solucionarse con una implementación perfecta; los controles de seguridad necesarios nunca se crearon para defenderse de ataques específicos.

Ejemplo de código vulnerable

# Password reset with no rate limit or verification
@app.route('/reset-password', methods=['POST'])
def reset_password():
    email = request.form['email']
    new_pass = request.form['new_password']
    user = db.find_by_email(email)
    user.password = hash_password(new_pass)  # No token verification!
    db.save(user)

Ejemplo de código seguro

from datetime import datetime, timedelta

@app.route('/reset-password', methods=['POST'])
@rate_limit("3/hour")
def reset_password():
    token = request.form['token']
    new_pass = request.form['new_password']

    # Verify time-limited, single-use token
    reset_req = db.find_reset_token(token)
    if not reset_req or reset_req.used or reset_req.expires < datetime.utcnow():
        abort(400, "Invalid or expired token")

    # Enforce password complexity
    if not meets_password_policy(new_pass):
        abort(400, "Password does not meet requirements")

    reset_req.user.password = hash_password(new_pass)
    reset_req.used = True
    db.save_all([reset_req.user, reset_req])

Lista de control de las medidas paliativas

• Integrar el modelado de amenazas en el ciclo de vida del desarrollo
• Aplicar controles de limitación de velocidad y antiautomatización en operaciones sensibles
• Utilizar patrones de diseño seguros y arquitecturas de referencia
• Escribir pruebas unitarias y de integración para casos de abuso, no sólo casos de uso.

7️⃣ A07 - Fallos de autenticación

Visión general

La confirmación de la identidad de un usuario, la autenticación y la gestión de sesiones son fundamentales. Los fallos de autenticación se producen cuando las aplicaciones permiten el relleno de credenciales, la fuerza bruta, las contraseñas débiles o tienen una gestión de sesión defectuosa, como la no rotación de los ID de sesión tras el inicio de sesión.

Ejemplo de código vulnerable

# No brute force protection, weak session handling
@app.route('/login', methods=['POST'])
def login():
    user = db.find_by_email(request.form['email'])
    if user and user.password == request.form['password']:  # Plain comparison!
        session['user'] = user.id  # Session ID not rotated
        return redirect('/dashboard')

Ejemplo de código seguro

from flask_limiter import Limiter

limiter = Limiter(app, default_limits=["100/hour"])

@app.route('/login', methods=['POST'])
@limiter.limit("5/minute")
def login():
    user = db.find_by_email(request.form['email'])
    if not user or not bcrypt.checkpw(
        request.form['password'].encode(), user.password_hash
    ):
        # Generic error to prevent user enumeration
        return "Invalid credentials", 401

    # Rotate session ID after authentication
    session.regenerate()
    session['user'] = user.id

    # Check for MFA requirement
    if user.mfa_enabled:
        return redirect('/mfa-verify')
    return redirect('/dashboard')

Lista de control de las medidas paliativas

• Implantar la autenticación multifactor (MFA) en todas las operaciones críticas.
• Protección por fuerza bruta con limitación de velocidad y bloqueo de cuentas
• Rotar los identificadores de sesión después de la autenticación y utilizar indicadores de sesión segura.
• Utilizar mensajes de error genéricos para evitar la enumeración de usuarios

8️⃣ A08 - Fallos en el software o en la integridad de los datos

Visión general

Los fallos de integridad del software y los datos están relacionados con el código y la infraestructura que no protegen contra las violaciones de la integridad. Esto incluye la deserialización insegura, el uso de CDN o plugins no fiables sin verificación de integridad y mecanismos de actualización automática sin actualizaciones firmadas.

Ejemplo de código vulnerable

<!-- Loading external scripts without integrity checks -->
<script src="https://cdn.example.com/lib.js"></script>

<!-- Insecure deserialization in Python -->
import pickle
data = pickle.loads(user_input)  # Arbitrary code execution!

Ejemplo de código seguro

<!-- Use Subresource Integrity (SRI) for external scripts -->
<script src="https://cdn.example.com/lib.js"
  integrity="sha384-oqVuAfXRKap7fdgcCY5uykM6+R9GqQ8K..."
  crossorigin="anonymous"></script>

# Use safe deserialization in Python
import json
data = json.loads(user_input)  # Safe: only parses JSON data

Lista de control de las medidas paliativas

• Utilice la Integridad de Subrecursos (SRI) para todas las secuencias de comandos y hojas de estilo externas.
• Nunca use deserialización insegura (pickle, yaml.load) en entradas no confiables.
• Verificación de firmas digitales en actualizaciones de software y artefactos CI/CD
• Implantar comprobaciones de integridad en los procesos CI/CD para evitar manipulaciones.

9️⃣ A09 - Fallos en el registro y las alertas de seguridad

Visión general

Sin un registro, supervisión y alerta suficientes, las brechas no pueden detectarse a tiempo. Un registro insuficiente, una integración ineficaz con los sistemas de respuesta a incidentes y la falta de alertas en tiempo real permiten a los agresores seguir atacando los sistemas, mantener la persistencia y manipular o extraer datos.

Ejemplo de código vulnerable

# No logging of security-relevant events
@app.route('/login', methods=['POST'])
def login():
    user = authenticate(request.form)
    if not user:
        return "Login failed", 401  # No record of failure
    return redirect('/dashboard')

Ejemplo de código seguro

import logging
from datetime import datetime

security_log = logging.getLogger('security')

@app.route('/login', methods=['POST'])
def login():
    user = authenticate(request.form)
    if not user:
        security_log.warning(
            "LOGIN_FAILED | ip=%s | email=%s | time=%s",
            request.remote_addr,
            request.form.get('email', 'unknown'),
            datetime.utcnow().isoformat(),
        )
        check_brute_force(request.remote_addr)
        return "Invalid credentials", 401

    security_log.info(
        "LOGIN_SUCCESS | user_id=%s | ip=%s",
        user.id, request.remote_addr,
    )
    return redirect('/dashboard')

Lista de control de las medidas paliativas

• Registre todos los intentos de autenticación, fallos de control de acceso y errores de validación de entradas.
• Utilice un sistema centralizado de gestión de registros con protección contra manipulaciones
• Implementar alertas en tiempo real para detectar patrones de actividad sospechosos
• Establecer un plan de respuesta a incidentes con procedimientos de escalada definidos.

🔟 A10 - Mala gestión de las condiciones excepcionales

Visión general

Nuevo en 2025. Las aplicaciones que manejan incorrectamente errores, excepciones y casos extremos pueden exponer información sensible, entrar en estados inconsistentes o crear condiciones explotables. Esto incluye mensajes de error detallados en producción, excepciones no capturadas que eluden los controles de seguridad y condiciones de carrera.

Ejemplo de código vulnerable

# Exposing internal details in error messages
@app.route('/api/data')
def get_data():
    try:
        result = db.query(request.args['q'])
        return jsonify(result)
    except Exception as e:
        return jsonify({"error": str(e)}), 500  # Leaks DB details!

Ejemplo de código seguro

import uuid, logging

logger = logging.getLogger(__name__)

@app.errorhandler(Exception)
def handle_exception(e):
    error_id = str(uuid.uuid4())
    logger.error("Unhandled exception [%s]: %s", error_id, e, exc_info=True)

    # Return generic error with reference ID for support
    return jsonify({
        "error": "An internal error occurred",
        "reference": error_id,
    }), 500

@app.route('/api/data')
def get_data():
    q = request.args.get('q')
    if not q or not is_valid_query(q):
        return jsonify({"error": "Invalid query parameter"}), 400

    result = db.query(q)
    return jsonify(result)

Lista de control de las medidas paliativas

• Nunca exponga trazas de pila, errores de base de datos o rutas internas en producción.
• Implementar un gestor de errores global que devuelva mensajes genéricos con ID de referencia
• Pruebas de condiciones de carrera en operaciones críticas para la seguridad
• Garantizar que todas las rutas de error mantienen invariantes de seguridad y limpian los recursos.

📊 Cuadro recapitulativo