Os 10 principais aplicativos da Web da OWASP (2025)

1️⃣ A01 - Controle de acesso quebrado

Visão geral

O controle de acesso aplica a política de modo que os usuários não possam agir fora das permissões pretendidas. As falhas geralmente levam à divulgação não autorizada de informações, à modificação ou destruição de dados ou à execução de uma função comercial fora dos limites do usuário.

Exemplo de código vulnerável

# 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())

Exemplo 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 verificação de mitigação

• Negar acesso por padrão, exceto para recursos públicos
• Implementar verificações de controle de acesso no lado do servidor em cada solicitação
• Impor a propriedade do registro em vez de aceitar IDs enviadas pelo usuário
• Registre as falhas de controle de acesso e alerte os administradores sobre violações repetidas

2️⃣ A02 - Configuração incorreta de segurança

Visão geral

A configuração incorreta da segurança ocorre quando as configurações de segurança são definidas, implementadas ou mantidas incorretamente. Isso inclui a falta de reforço de segurança, recursos desnecessários ativados, contas padrão com senhas inalteradas, mensagens de erro excessivamente detalhadas e cabeçalhos de segurança HTTP mal configurados.

Exemplo de código vulnerável

# 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!

Exemplo 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 verificação de mitigação

• Implementar um processo de proteção repetível para todos os ambientes
• Remover ou desativar recursos desnecessários, estruturas e contas padrão
• Configurar os cabeçalhos de segurança adequados (CSP, HSTS, X-Frame-Options)
• Usar ferramentas automatizadas para verificar a eficácia das configurações

3️⃣ A03 - Falhas na cadeia de suprimentos de software

Visão geral

Novo em 2025. Concentra-se nos riscos relacionados a componentes de terceiros, dependências e pipelines de CI/CD. Os invasores têm como alvo a cadeia de suprimentos de software comprometendo pacotes, injetando códigos mal-intencionados em bibliotecas de código aberto ou explorando vulnerabilidades de pipeline de compilação.

Exemplo de código vulnerável

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

Exemplo 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 verificação de mitigação

• Fixe as versões de dependência e use arquivos de bloqueio para obter compilações reproduzíveis
• Habilitar a verificação automatizada de dependências (Dependabot, Snyk, Renovate)
• Gerar e manter a lista de materiais de software (SBOM)
• Verificar a procedência e as assinaturas do pacote antes da inclusão

4️⃣ A04 - Falhas criptográficas

Visão geral

Falhas relacionadas à criptografia que geralmente levam à exposição de dados confidenciais. Isso inclui o uso de algoritmos obsoletos, geração de chaves fracas, falta de criptografia para dados em trânsito ou em repouso e validação inadequada de certificados.

Exemplo de código vulnerável

import hashlib

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

Exemplo 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 verificação de mitigação

• Use algoritmos fortes e atuais (AES-256, bcrypt/argon2, SHA-256+)
• Criptografar todos os dados confidenciais em trânsito (TLS 1.2+) e em repouso
• Nunca use algoritmos obsoletos (MD5, SHA-1, DES, RC4)
• Implementar o gerenciamento adequado de chaves com políticas de rotação

5️⃣ A05 - Injeção

Visão geral

As falhas de injeção ocorrem quando dados não confiáveis são enviados a um intérprete como parte de um comando ou consulta. Injeção de SQL, injeção de NoSQL, injeção de comando de sistema operacional e XSS (Cross-Site Scripting) são as formas mais comuns. Dados hostis podem induzir o intérprete a executar comandos não intencionais.

Exemplo de código vulnerável

# 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"

Exemplo 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 verificação de mitigação

• Use consultas parametrizadas ou instruções preparadas para todas as operações de banco de dados
• Use a codificação de saída com reconhecimento de contexto para evitar XSS
• Valide e higienize todas as entradas do usuário no lado do servidor
• Use ORMs com consultas parametrizadas em vez de criar strings SQL brutas

6️⃣ A06 - Design inseguro

Visão geral

O design inseguro refere-se aos riscos relacionados a falhas de design e arquitetura. Ele exige o uso de modelagem de ameaças, padrões de design seguro e arquiteturas de referência. Um projeto inseguro não pode ser corrigido por uma implementação perfeita; os controles de segurança necessários nunca foram criados para defender-se de ataques específicos.

Exemplo de código vulnerável

# 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)

Exemplo 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 verificação de mitigação

• Integrar a modelagem de ameaças ao ciclo de vida do desenvolvimento
• Aplique controles de limitação de taxa e antiautomação em operações confidenciais
• Use padrões de projeto seguros e arquiteturas de referência
• Escreva testes unitários e de integração para casos de abuso, não apenas para casos de uso

7️⃣ A07 - Falhas de autenticação

Visão geral

A confirmação da identidade, da autenticação e do gerenciamento de sessões de um usuário é fundamental. As falhas de autenticação ocorrem quando os aplicativos permitem o preenchimento de credenciais, força bruta, senhas fracas ou têm falhas no gerenciamento de sessões, como IDs de sessão não rotativos após o login.

Exemplo de código vulnerável

# 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')

Exemplo 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 verificação de mitigação

• Implementar autenticação multifator (MFA) para todas as operações críticas
• Aplique proteção contra força bruta com limitação de taxa e bloqueio de conta
• Gire os IDs de sessão após a autenticação e use sinalizadores de sessão seguros
• Use mensagens de erro genéricas para evitar a enumeração de usuários

8️⃣ A08 - Falhas de integridade de software ou dados

Visão geral

As falhas de integridade de software e dados estão relacionadas ao código e à infraestrutura que não protegem contra violações de integridade. Isso inclui desserialização insegura, uso de CDNs ou plug-ins não confiáveis sem verificação de integridade e mecanismos de atualização automática sem atualizações assinadas.

Exemplo de código vulnerável

<!-- 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!

Exemplo 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 verificação de mitigação

• Use o SRI (Subresource Integrity) para todos os scripts e folhas de estilo externos
• Nunca use desserialização insegura (pickle, yaml.load) em entradas não confiáveis
• Verificar assinaturas digitais em atualizações de software e artefatos de CI/CD
• Implemente verificações de integridade nos pipelines de CI/CD para evitar adulterações

9️⃣ A09 - Falhas no registro de segurança e alertas

Visão geral

Sem registros, monitoramento e alertas suficientes, as violações não podem ser detectadas em tempo hábil. O registro insuficiente, a integração ineficaz com sistemas de resposta a incidentes e a falta de alertas em tempo real permitem que os invasores ataquem ainda mais os sistemas, mantenham a persistência e adulterem ou extraiam dados.

Exemplo de código vulnerável

# 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')

Exemplo 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 verificação de mitigação

• Registre todas as tentativas de autenticação, falhas de controle de acesso e erros de validação de entrada
• Use um sistema centralizado de gerenciamento de registros com proteção contra violações
• Implementar alertas em tempo real para padrões de atividades suspeitas
• Estabelecer um plano de resposta a incidentes com procedimentos de escalonamento definidos

🔟 A10 - Manuseio incorreto de condições excepcionais

Visão geral

Novo em 2025. Os aplicativos que tratam erros, exceções e casos extremos de forma inadequada podem expor informações confidenciais, entrar em estados inconsistentes ou criar condições exploráveis. Isso inclui mensagens de erro detalhadas na produção, exceções não capturadas que ignoram os controles de segurança e condições de corrida.

Exemplo de código vulnerável

# 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!

Exemplo 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 verificação de mitigação

• Nunca exponha rastreamentos de pilha, erros de banco de dados ou caminhos internos na produção
• Implemente um manipulador de erros global que retorne mensagens genéricas com IDs de referência
• Teste de condições de corrida em operações críticas para a segurança
• Garantir que todos os caminhos de erro mantenham invariantes de segurança e limpem os recursos

📊 Tabela de resumo