OWASP Webanwendung Top 10 (2025)

1️⃣ A01 - Defekte Zugangskontrolle

Übersicht

Die Zugriffskontrolle sorgt dafür, dass Benutzer nicht außerhalb der ihnen zugewiesenen Befugnisse handeln können. Fehler führen in der Regel zur unbefugten Offenlegung von Informationen, zur Änderung oder Zerstörung von Daten oder zur Ausführung einer Geschäftsfunktion außerhalb der vom Benutzer festgelegten Grenzen.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Zugriff standardmäßig verweigern, außer für öffentliche Ressourcen
• Implementierung von serverseitigen Zugriffskontrollen bei jeder Anfrage
• Erzwingen Sie die Eigentümerschaft von Datensätzen, anstatt vom Benutzer eingegebene IDs zu akzeptieren.
• Protokollierung von Fehlern bei der Zugangskontrolle und Alarmierung von Administratoren bei wiederholten Verstößen

2️⃣ A02 - Fehlkonfiguration der Sicherheit

Übersicht

Eine falsche Sicherheitskonfiguration liegt vor, wenn die Sicherheitseinstellungen nicht korrekt definiert, implementiert oder gepflegt werden. Dazu gehören fehlende Sicherheitshärtung, unnötig aktivierte Funktionen, Standardkonten mit unveränderten Passwörtern, übermäßig ausführliche Fehlermeldungen und falsch konfigurierte HTTP-Sicherheits-Header.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Implementierung eines wiederholbaren Härtungsprozesses für alle Umgebungen
• Entfernen oder Deaktivieren unnötiger Funktionen, Frameworks und Standardkonten
• Konfigurieren Sie die richtigen Sicherheits-Header (CSP, HSTS, X-Frame-Options)
• Verwendung automatisierter Tools zur Überprüfung der Wirksamkeit von Konfigurationen

3️⃣ A03 - Versagen der Software-Lieferkette

Übersicht

Neu im Jahr 2025. Konzentriert sich auf Risiken im Zusammenhang mit Komponenten Dritter, Abhängigkeiten und CI/CD-Pipelines. Angreifer greifen die Software-Lieferkette an, indem sie Pakete kompromittieren, bösartigen Code in Open-Source-Bibliotheken einschleusen oder Schwachstellen in der Build-Pipeline ausnutzen.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Pin-Versionen von Abhängigkeiten und Verwendung von Sperrdateien für reproduzierbare Builds
• Automatisches Scannen von Abhängigkeiten aktivieren (Dependabot, Snyk, Renovate)
• Erstellung und Pflege von Software-Stücklisten (SBOM)
• Überprüfung der Herkunft und der Signaturen von Paketen vor der Aufnahme

4️⃣ A04 - Kryptografische Fehlfunktionen

Übersicht

Fehler im Zusammenhang mit der Kryptographie, die häufig zur Preisgabe sensibler Daten führen. Dazu gehören die Verwendung veralteter Algorithmen, eine schwache Schlüsselgenerierung, fehlende Verschlüsselung von Daten bei der Übertragung oder im Ruhezustand sowie eine unsachgemäße Zertifikatsvalidierung.

Beispiel für anfälligen Code

import hashlib

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

Beispiel für sicheren Code

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)

Checkliste zur Schadensbegrenzung

• Verwendung starker, aktueller Algorithmen (AES-256, bcrypt/argon2, SHA-256+)
• Verschlüsselung aller sensiblen Daten bei der Übertragung (TLS 1.2+) und im Ruhezustand
• Verwenden Sie niemals veraltete Algorithmen (MD5, SHA-1, DES, RC4)
• Implementierung einer ordnungsgemäßen Schlüsselverwaltung mit Rotationsrichtlinien

5️⃣ A05 - Einspritzung

Übersicht

Injection-Fehler treten auf, wenn nicht vertrauenswürdige Daten als Teil eines Befehls oder einer Abfrage an einen Interpreter gesendet werden. SQL-Injektion, NoSQL-Injektion, OS-Befehlsinjektion und Cross-Site Scripting (XSS) sind die häufigsten Formen. Feindliche Daten können den Interpreter dazu verleiten, unbeabsichtigte Befehle auszuführen.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Verwenden Sie parametrisierte Abfragen oder vorbereitete Anweisungen für alle Datenbankoperationen
• Verwenden Sie eine kontextabhängige Ausgabekodierung, um XSS zu verhindern.
• Validierung und Bereinigung aller Benutzereingaben auf der Serverseite
• Verwendung von ORMs mit parametrisierten Abfragen anstelle der Erstellung roher SQL-Strings

6️⃣ A06 - Unsicheres Design

Übersicht

Unsicheres Design bezieht sich auf Risiken, die mit Design- und Architekturfehlern zusammenhängen. Sie erfordern die Verwendung von Bedrohungsmodellen, sicheren Entwurfsmustern und Referenzarchitekturen. Ein unsicherer Entwurf kann nicht durch eine perfekte Implementierung behoben werden; die erforderlichen Sicherheitskontrollen wurden nie zur Abwehr bestimmter Angriffe geschaffen.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Integration der Bedrohungsmodellierung in den Entwicklungslebenszyklus
• Anwendung von Ratenbegrenzungen und Anti-Automatisierungskontrollen bei sensiblen Vorgängen
• Verwendung sicherer Entwurfsmuster und Referenzarchitekturen
• Schreiben Sie Unit- und Integrationstests für Missbrauchsfälle, nicht nur für Anwendungsfälle

7️⃣ A07 - Fehler bei der Authentifizierung

Übersicht

Die Bestätigung der Identität eines Benutzers, die Authentifizierung und die Sitzungsverwaltung sind entscheidend. Authentifizierungsfehler treten auf, wenn Anwendungen Credential Stuffing, Brute-Force, schwache Passwörter oder eine mangelhafte Sitzungsverwaltung zulassen, z. B. durch nicht rotierende Sitzungs-IDs nach der Anmeldung.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Implementierung der Multi-Faktor-Authentifizierung (MFA) für alle kritischen Vorgänge
• Durchsetzung des Brute-Force-Schutzes mit Ratenbegrenzung und Kontosperrung
• Sitzungs-IDs nach der Authentifizierung rotieren lassen und sichere Sitzungskennzeichen verwenden
• Verwenden Sie allgemeine Fehlermeldungen, um die Aufzählung von Benutzern zu verhindern.

8️⃣ A08 - Fehler in der Software oder Datenintegrität

Übersicht

Software- und Datenintegritätsfehler beziehen sich auf Code und Infrastruktur, die nicht vor Integritätsverletzungen schützen. Dazu gehören unsichere Deserialisierung, die Verwendung von nicht vertrauenswürdigen CDNs oder Plugins ohne Integritätsprüfung und automatische Aktualisierungsmechanismen ohne signierte Updates.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Verwenden Sie Subresource Integrity (SRI) für alle externen Skripte und Stylesheets
• Niemals unsichere Deserialisierung (pickle, yaml.load) bei nicht vertrauenswürdiger Eingabe verwenden
• Überprüfung digitaler Signaturen von Software-Updates und CI/CD-Artefakten
• Integritätsprüfungen in CI/CD-Pipelines implementieren, um Manipulationen zu verhindern

9️⃣ A09 - Fehler bei der Sicherheitsprotokollierung und Alarmierung

Übersicht

Ohne ausreichende Protokollierung, Überwachung und Alarmierung können Sicherheitsverletzungen nicht rechtzeitig erkannt werden. Unzureichende Protokollierung, unzureichende Integration mit Systemen zur Reaktion auf Vorfälle und fehlende Echtzeit-Warnungen ermöglichen es Angreifern, weitere Angriffe auf Systeme zu verüben, diese aufrechtzuerhalten und Daten zu manipulieren oder zu extrahieren.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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

Checkliste zur Schadensbegrenzung

• Protokollierung aller Authentifizierungsversuche, Fehlschläge bei der Zugriffskontrolle und Eingabevalidierungsfehler
• Verwenden Sie ein zentrales Protokollverwaltungssystem mit Manipulationsschutz
• Implementierung von Echtzeitwarnungen für verdächtige Aktivitätsmuster
• Erstellung eines Reaktionsplans für Zwischenfälle mit festgelegten Eskalationsverfahren

🔟 A10 - Falsche Handhabung außergewöhnlicher Bedingungen

Übersicht

Neu im Jahr 2025. Anwendungen, die Fehler, Ausnahmen und Randfälle unsachgemäß behandeln, können vertrauliche Informationen preisgeben, in inkonsistente Zustände geraten oder ausnutzbare Bedingungen schaffen. Dazu gehören ausführliche Fehlermeldungen in der Produktion, nicht abgefangene Ausnahmen, die Sicherheitskontrollen umgehen, und Race Conditions.

Beispiel für anfälligen Code

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

Beispiel für sicheren Code

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)

Checkliste zur Schadensbegrenzung

• Niemals Stack Traces, Datenbankfehler oder interne Pfade in der Produktion offenlegen
• Implementierung eines globalen Fehlerhandlers, der allgemeine Meldungen mit Referenz-IDs zurückgibt
• Test auf Wettlaufbedingungen bei sicherheitskritischen Operationen
• Sicherstellen, dass alle Fehlerpfade Sicherheitsinvarianten beibehalten und Ressourcen bereinigt werden

📊 Übersichtstabelle