Ein Denial-of-Service-Angriff mit Regex gefährdet die Sicherheit von FastAPI

Willkommen, liebe Entwicklerinnen und Entwickler! In diesem Blogbeitrag tauchen wir tief in die Anwendungssicherheit ein und konzentrieren uns insbesondere auf eine Schwachstelle, die die Sicherheit von FastAPI beeinträchtigen kann: Denial of Service (DoS) durch unsichere reguläre Ausdrücke (Regex). Wir zeigen, wie ein schlecht konstruierter Regex zu einem sogenannten Regular Expression Denial of Service (ReDoS), einer Form von DoS-Angriff, führen kann und wie sich diese Schwachstellen mit einem leistungsstarken Developer-Security-Tool – Snyk – erkennen und beheben lassen.

Die Auswirkungen von ReDoS auf die Sicherheit von FastAPI in Python verstehen

Python zählt zu den beliebtesten Programmiersprachen und verfügt über ein umfangreiches Ökosystem aus Paketen und Bibliotheken. Diese Pakete erleichtern uns Entwicklern zwar die Arbeit, bergen aber auch potenzielle Risiken, wenn sie nicht ausreichend abgesichert sind. Bei der rasanten Softwareentwicklung werden Pakete häufig aktualisiert und neue Versionen veröffentlicht – manchmal werden dadurch unbemerkt Sicherheitsrisiken eingeführt.

Ein solches Risiko ist ein möglicher ReDoS-Angriff. Dabei übermittelt ein Angreifer eine schädliche Eingabe an einen regulären Ausdruck, dessen Auswertung sehr lange dauert. Dadurch reagiert die Anwendung nicht mehr oder wird erheblich verlangsamt. Das kann schwerwiegende Folgen haben – von einer beeinträchtigten Nutzererfahrung bis hin zum vollständigen Ausfall der Anwendung.

1import re
2pattern = re.compile("^(a+)+$")
3def check(input):
4    return bool(pattern.match(input))
5check("a" * 3000 + "!")

Im obigen Code ist der reguläre Ausdruck ^(a+)+$ anfällig für einen ReDoS-Angriff. Wenn ein Angreifer eine Zeichenfolge aus mehreren „a“ gefolgt von einem Zeichen übermittelt, das kein „a“ ist, dauert die Auswertung des Regex sehr lange und führt dadurch effektiv zu einem DoS.

So schützt Snyk Ihre Python-Anwendungen mit FastAPI

Snyk ist ein Developer-first-Security-Tool, das Ihren Python-Code auf potenzielle ReDoS-Schwachstellen untersuchen kann. Es erstellt detaillierte Berichte zu den gefundenen Schwachstellen und empfiehlt die am besten geeigneten Korrekturen.

1# After installing Snyk and setting up the Snyk CLI
2# you can scan your project:
3$ snyk test 

Dieser Befehl untersucht Ihr Manifest für Drittanbieterabhängigkeiten, das sich üblicherweise in der Datei requirements.txt befindet, und erstellt einen Bericht über alle gefundenen Schwachstellen – einschließlich möglicher ReDoS-Schwachstellen. Registrieren Sie sich kostenlos für ein Snyk-Konto, um noch heute Ihre Python-Projekte auf ReDoS und andere Schwachstellen zu untersuchen.

Um eine sichere Python-Anwendung zu gewährleisten, ist es entscheidend, die Auswirkungen solcher Schwachstellen zu verstehen und zu wissen, wie sie sich beheben lassen. Hier kommen Tools wie Snyk ins Spiel. Snyk Open Source hilft Ihnen, Sicherheitslücken in Python-Paketen zu erkennen und zu beheben – darunter unsichere reguläre Ausdrücke, die zu einem ReDoS-Angriff führen können.

Sehen wir uns genauer an, wie Sie solche Schwachstellen in Python-Webanwendungen mit FastAPI mithilfe von Snyk erkennen und beheben können.

FastAPI-Sicherheitslücke CVE-2024-24762

FastAPI ist ein modernes, leistungsstarkes Web-Framework zum Erstellen von APIs mit Python auf Grundlage standardmäßiger Python-Typannotationen. Zu den wichtigsten Merkmalen zählen die hohe Geschwindigkeit und die Möglichkeit, robuste APIs schnell und mühelos zu erstellen. Deshalb ist FastAPI bei Python-Entwicklern beliebt, die leistungsstarke RESTful APIs entwickeln müssen.

FastAPI vereinfacht die API-Entwicklung, indem es Routing, Serialisierung/Deserialisierung und Validierung direkt mitbringt. Es baut auf den Python-Projekten Starlette für die Web-Funktionen und Pydantic für die Datenverarbeitung auf. So können Entwickler die asynchronen Funktionen nutzen, die ab Python 3.6 verfügbar sind.

Eine einfache API mit einer Python-Webanwendung auf Basis von FastAPI lässt sich beispielsweise mit folgendem Codeausschnitt erstellen:

1from fastapi import FastAPI
2app = FastAPI()
3@app.get("/")
4def read_root():
5    return {"Hello": "World"}

FastAPI ist zwar ein robustes und flexibles Tool für die API-Entwicklung, aber nicht frei von Schwachstellen. Dazu zählt die Anfälligkeit für CVE-2024-24762. Diese Denial-of-Service-Schwachstelle geht auf den Regex im Python-Paket python-multipart zurück.

Die Abhängigkeit python-multipart ist eine Python-Bibliothek zum Parsen von Multipart-/Form-Daten. In FastAPI wird sie häufig als Abhängigkeit zur Verarbeitung von Formulardaten verwendet.

Die Schwachstelle tritt auf, wenn ein Angreifer eine schädliche Zeichenfolge sendet, die dazu führt, dass der reguläre Ausdruck in python-multipart sehr viele CPU-Ressourcen beansprucht und dadurch einen Denial of Service (DoS) verursacht. Dies wird auch als Regular Expression Denial of Service (ReDoS) bezeichnet.

Wie kann ein Python-Entwickler diese Schwachstelle beheben? Zunächst müssen Sie die Schwachstelle in Ihrem Projekt erkennen. Dazu können Sie das Snyk-CLI-Tool verwenden.

$ snyk test

Um Schwachstellen wie diese zu erkennen, müssen Sie die Abhängigkeiten Ihres Projekts untersuchen. Dabei wird ein Bericht mit allen Schwachstellen in den Abhängigkeiten Ihres Projekts erstellt.

Die Ausgabe des Befehls „snyk test“ zeigt die Schwachstelle:

1snyk test
2
3Testing /Users/lirantal/projects/repos/fastapi-vulnerable-redos-app...
4
5Tested 13 dependencies for known issues, found 1 issue, 1 vulnerable path.
6
7Issues to fix by upgrading dependencies:
8
9  Upgrade fastapi@0.109.0 to fastapi@0.109.1 to fix
10  ✗ Regular Expression Denial of Service (ReDoS) (new) [High Severity][https://security.snyk.io/vuln/SNYK-PYTHON-FASTAPI-6228055] in fastapi@0.109.0
11    introduced by fastapi@0.109.0
12
13Organization:      liran.tal
14Package manager:   pip
15Target file:       requirements.txt
16Project name:      fastapi-vulnerable-redos-app

Um die Schwachstelle zu beheben, können Sie auf neuere Versionen des Pakets python-multipart und von fastapi aktualisieren, in denen die Schwachstelle behoben wurde. Snyk empfiehlt Ihnen passende Versionen.

FastAPI-Sicherheit aufbauen und angreifen: eine Schritt-für-Schritt-Anleitung

Zunächst richten wir ein neues Python-Projekt ein. Dafür müssen wir FastAPI und einen Server installieren, auf dem die Anwendung ausgeführt wird. Uvicorn eignet sich gut als Server, da es leichtgewichtig ist und gut mit FastAPI funktioniert.

Installieren Sie zunächst FastAPI, python-multipart und Uvicorn mit pip:

pip install fastapi==0.109.0 uvicorn python-multipart==0.0.6

Erstellen Sie als Nächstes ein neues Verzeichnis für Ihr Projekt und darin eine neue Datei für Ihre FastAPI-Anwendung. Sie können sie main.py nennen.

Python-Code für FastAPI schreiben

Jetzt können wir den Code für unsere FastAPI-Anwendung schreiben. Öffnen Sie main.py und fügen Sie den folgenden Python-Code ein:

1from typing import Annotated
2from fastapi.responses import HTMLResponse
3from fastapi import FastAPI,Form
4from pydantic import BaseModel
5
6class Item(BaseModel):
7    username: str
8
9app = FastAPI()
10
11@app.get("/", response_class=HTMLResponse)
12async def index():
13    return HTMLResponse("Test", status_code=200)
14
15@app.post("/submit/")
16async def submit(username: Annotated[str, Form()]):
17    return {"username": username}
18
19@app.post("/submit_json/")
20async def submit_json(item: Item):
21    return {"username": item.username}

Diese einfache FastAPI-Anwendung hat mehrere Routen (/), darunter /submit, die ein Multipart-Formular verwendet. Bei einer POST-Anfrage gibt die Route submit den übermittelten Benutzernamen zurück.

Server starten und Anwendung ausführen

Nachdem der Code für unsere FastAPI-Anwendung geschrieben ist, können wir jetzt den Uvicorn-Server starten und die Anwendung ausführen.

Starten Sie den Server mit folgendem Befehl:

uvicorn main:app --reload

Sie sollten eine Ausgabe sehen, die bestätigt, dass der Server läuft. Testen Sie Ihre Anwendung, indem Sie in Ihrem Webbrowser http://localhost:8000 aufrufen. Auf der Seite sollte die Meldung „Test“ angezeigt werden.

Die FastAPI-Sicherheit mit einem ReDoS-Angriff aushebeln

Nachdem unsere FastAPI-Anwendung nun läuft, können wir sie auf Schwachstellen testen. Dazu verwenden wir eine ReDoS-Angriffsnutzlast in der HTTP-Anfrage, um die Schwachstelle im Paket python-multipart auszunutzen, das den Wert des Content-Type-Headers verarbeitet.

Wenn das Programm curl bei Ihnen installiert ist, führen Sie den folgenden Befehl in Ihrem Terminal aus:

1curl -v -X 'POST' -H $'Content-Type: application/x-www-form-urlencoded; !=\"\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\' --data-binary 'input=1' 'http://localhost:8000/submit/'

Ihre FastAPI-Anwendung mit Snyk absichern

Wie Sie inzwischen gesehen haben, spielen Open-Source-Abhängigkeiten eine wichtige Rolle bei der Entwicklung von Python-Anwendungen. Diese Abhängigkeiten von Drittanbietern können jedoch mitunter ein Nährboden für Schwachstellen sein und erhebliche Sicherheitsrisiken mit sich bringen. Hier erweist sich Snyk Open Source als leistungsstarkes Tool, mit dem Entwickler Sicherheitsprobleme effektiv erkennen und beheben können.

Stellen Sie sich vor, Sie könnten Schwachstellen in FastAPI direkt im IDE-Bereich erkennen, während Sie Python-Code schreiben – statt darauf zu warten, dass Sicherheitsscanner sie erst später finden.

Die Snyk-IDE-Erweiterung ist kostenlos. Wenn Sie PyCharm verwenden, können Sie in der Plugin-Ansicht nach Snyk suchen und die Erweiterung direkt dort herunterladen. Bei VS Code finden Sie sie ebenfalls direkt in der IDE im Extensions-Marktplatz.

Snyk Open Source und seine Funktionen im Überblick

Snyk Open Source ist ein leistungsstarkes Tool, mit dem sich Schwachstellen in Open-Source-Abhängigkeiten und Container-Images aufdecken und beheben lassen. Es lässt sich problemlos in vorhandene Codebasen und CI/CD-Systeme integrieren und ist damit ein praktisches Tool für Entwickler. Eine umfassende Datenbank bekannter Schwachstellen ermöglicht es Entwicklern, potenziellen Sicherheitsverletzungen proaktiv entgegenzuwirken.

Schritt-für-Schritt-Anleitung: Python-Abhängigkeiten mit Snyk auf Schwachstellen untersuchen

Um Python-Abhängigkeiten mit Snyk auf Schwachstellen zu untersuchen, müssen Sie zunächst die Snyk-CLI installieren. Verwenden Sie dazu eine der in der Anleitung beschriebenen Methoden. Wenn Sie eine Node.js-Umgebung haben, können Sie Snyk auch schnell mit npm install -g snyk installieren und sich anschließend mit run snyk auth authentifizieren.

Nach der Installation können Sie Ihr Python-Projekt mit dem Befehl snyk test auf Schwachstellen überprüfen:

snyk test --all-projects

Snyk untersucht daraufhin alle Ihre Abhängigkeiten und gleicht sie mit der Snyk-Datenbank für Schwachstellen ab. Werden Probleme gefunden, erstellt Snyk einen detaillierten Bericht mit Informationen zur Schwachstelle, ihrem Schweregrad und möglichen Korrekturen.

Die Überwachung Ihrer Projekte mit Snyk ist entscheidend, um die Sicherheit Ihrer Anwendung zu gewährleisten. Mit Snyk können Sie nicht nur Schwachstellen erkennen, sondern auch automatische Korrekturen anwenden – das spart Ihnen Zeit und Ressourcen.

Darüber hinaus informiert Snyk Sie mit Warnmeldungen über neue Schwachstellen, die Ihre Projekte betreffen könnten. So können Sie einen Schritt voraus sein und Sicherheitsprobleme beheben, bevor sie ausgenutzt werden.

Mit dem Befehl snyk monitor können Sie eine Momentaufnahme der aktuellen Abhängigkeiten Ihres Projekts erstellen und sie auf Schwachstellen überwachen:

snyk monitor

Snyk in Git-Repositories integrieren

Wenn Sie Snyk in Ihre Git-Repositories integrieren, können Sie jeden Commit automatisch auf Schwachstellen untersuchen lassen. Fügen Sie dazu Snyk in den Repository-Einstellungen als Webhook hinzu.

Sobald die Einrichtung abgeschlossen ist, löst jeder Push in Ihr Repository einen Snyk-Scan aus. So können Sie Schwachstellen möglichst früh erkennen und beheben.

Zusammenfassend lässt sich sagen: Snyk Open Source ist ein wertvolles Tool, um die Sicherheit Ihrer Python-Projekte zu gewährleisten. Durch das Untersuchen auf Schwachstellen, die Überwachung Ihrer Projekte und die Integration in Ihre Git-Repositories hilft Snyk Ihnen, eine robuste und sichere Codebasis zu bewahren. Falls Sie es noch nicht getan haben: Registrieren Sie sich kostenlos für ein Snyk-Konto und sichern Sie Ihre Anwendungen noch heute ab.