Unsachgemäße Neutralisierung von CRLF-Sequenzen ('CRLF Injection')

Beschreibung

CRLF Injection ist eine Schwachstelle, die auftritt, wenn Software Ausgabedatensätze unter Verwendung von extern beeinflussten Eingaben konstruiert, aber Carriage Return (CR, \r, %0d) und Line Feed (LF, \n, %0a) Zeichen nicht oder nicht korrekt neutralisiert. In HTTP und vielen textbasierten Protokollen begrenzen CRLF-Sequenzen Header und trennen Header vom Body-Inhalt. Angreifer nutzen diese Schwachstelle aus, um beliebige Header einzuschleusen, HTTP-Antworten aufzuteilen, Log-Dateien zu manipulieren oder die Struktur von Protokollnachrichten zu ändern. HTTP Response Splitting ist eine besonders gefährliche Form der CRLF-Injection, die Cache-Poisoning, Cross-Site-Scripting und Session-Hijacking-Angriffe ermöglicht.

Risiko

CRLF-Injection ermöglicht je nach Kontext mächtige Angriffe. In HTTP-Antworten können Angreifer zusätzliche Header einschleusen, einschließlich Set-Cookie für Session-Fixation, Location für Redirect-Angriffe oder Sicherheits-Header, um Schutzmaßnahmen zu deaktivieren. HTTP Response Splitting ermöglicht das Einschleusen vollständiger gefälschter Antworten, die von Proxies gecacht werden können, was weitreichende Angriffe gegen andere Benutzer ermöglicht. In E-Mail-Headern ermöglicht CRLF-Injection E-Mail-Header-Injection für Spam-Relay oder Spoofing. Log-Injection kann Log-Dateien beschädigen, falsche Einträge einschleusen, um Spuren zu verwischen, oder Log-Viewer ausnutzen, die für Terminal-Escape-Sequenzen anfällig sind. Die Einfachheit der Ausnutzung kombiniert mit potenziell schwerwiegenden Auswirkungen macht dies zu einer hochprioritären Schwachstellenklasse.

Lösung

Entfernen oder codieren Sie alle CR- und LF-Zeichen aus Benutzereingaben, bevor Sie diese in HTTP-Header, Log-Nachrichten, E-Mail-Header oder andere zeilengetrennte Kontexte einbinden. Verwenden Sie framework-bereitgestellte Funktionen zum Setzen von HTTP-Headern, die die Codierung automatisch handhaben. Validieren Sie, dass Benutzereingaben keine unerwarteten Zeilenumbrüche enthalten. Für URLs und Redirect-Ziele validieren Sie gegen Allowlists erlaubter Domains und Pfade. Implementieren Sie ordnungsgemäße Ausgabecodierung für den spezifischen Kontext (URL-Codierung für URL-Parameter, Header-Codierung für HTTP-Header). Verwenden Sie moderne Web-Frameworks, die CRLF-Injection standardmäßig in Header-Setzfunktionen verhindern.

Häufige Auswirkungen

Auswirkung	Details
Integrität	Bereich: Integrität HTTP Response Splitting ermöglicht das Einschleusen beliebiger Inhalte einschließlich bösartigem JavaScript, gefälschten Login-Seiten oder irreführenden Informationen.
Zugriffskontrolle	Bereich: Zugriffskontrolle Session-Fixation durch eingeschleuste Set-Cookie-Header kann Kontoübernahme und unbefugten Zugriff ermöglichen.
Vertraulichkeit	Bereich: Vertraulichkeit Cache-Poisoning durch Response-Splitting kann Daten anderer Benutzer offenlegen oder diese auf bösartige Seiten umleiten.

Beispielcode + Lösungscode

Anfälliger Code

from flask import Flask, request, redirect, make_response

app = Flask(__name__)

@app.route('/redirect')
def vulnerable_redirect():
    # ANFÄLLIG: Benutzereingabe direkt im Location-Header
    # Angriff: url=http://example.com%0d%0aSet-Cookie:%20session=malicious
    url = request.args.get('url')
    response = make_response('Weiterleitung...')
    response.headers['Location'] = url  # CRLF-Injection möglich
    response.status_code = 302
    return response

@app.route('/setlang')
def set_language():
    # ANFÄLLIG: Benutzereingabe im Cookie ohne Bereinigung
    # Angriff: lang=en%0d%0aSet-Cookie:%20admin=true
    lang = request.args.get('lang')
    response = make_response('Sprache gesetzt')
    response.headers['Set-Cookie'] = f'language={lang}'
    return response

Korrigierter Code

from flask import Flask, request, redirect, make_response, abort
import re
from urllib.parse import urlparse

app = Flask(__name__)

def sanitize_header_value(value):
    """CRLF-Zeichen aus Header-Werten entfernen"""
    if value is None:
        return None
    # CR, LF und Null-Bytes entfernen
    return re.sub(r'[\r\n\x00]', '', value)

def validate_redirect_url(url):
    """Redirect-URL gegen Allowlist validieren"""
    allowed_domains = ['example.com', 'trusted.com']

    try:
        parsed = urlparse(url)
        if parsed.scheme not in ['http', 'https']:
            return None
        if parsed.netloc not in allowed_domains:
            return None
        return url
    except:
        return None

@app.route('/redirect')
def safe_redirect():
    url = request.args.get('url', '')

    # CRLF-Zeichen bereinigen
    url = sanitize_header_value(url)

    # Gegen Allowlist validieren
    safe_url = validate_redirect_url(url)
    if not safe_url:
        abort(400, 'Ungültige Redirect-URL')

    # Framework-Redirect-Funktion verwenden (fügt Schutz hinzu)
    return redirect(safe_url)

@app.route('/setlang')
def safe_set_language():
    lang = request.args.get('lang', 'en')

    # Gegen Allowlist validieren
    allowed_languages = ['en', 'de', 'fr', 'es', 'ja']
    if lang not in allowed_languages:
        lang = 'en'

    # response.set_cookie() anstelle von manuellem Header verwenden
    response = make_response('Sprache gesetzt')
    response.set_cookie('language', lang, httponly=True, secure=True)
    return response

Ausgenutzt in der Praxis

HTTP Response Splitting-Angriffe (Webanwendungen, historisch)

CRLF-Injection, die HTTP Response Splitting ermöglicht, wurde gegen verschiedene Webanwendungen ausgenutzt, um Cache-Poisoning-Angriffe durchzuführen, bei denen bösartige Antworten von Proxy-Servern gecacht und anderen Benutzern ausgeliefert werden.

https://owasp.org/www-community/attacks/HTTP_Response_Splitting

Tools zum Testen/Ausnutzen

Burp Suite — Web-Sicherheitstestplattform mit CRLF-Injection-Erkennung in Headern und Antworten.
CRLFuzz — Automatisierter CRLF-Injection-Schwachstellenscanner.

CVE-Beispiele

CVE-2023-27350 — PaperCut CRLF-Injection in der Druckauftragsverarbeitung.
CVE-2021-33026 — Flask-Caching CRLF-Injection in der Cache-Key-Verarbeitung.

Referenzen

MITRE. "CWE-93: Improper Neutralization of CRLF Sequences." https://cwe.mitre.org/data/definitions/93.html
OWASP. "HTTP Response Splitting." https://owasp.org/www-community/attacks/HTTP_Response_Splitting