Ein Denial-of-Service-Regex unterbricht die FastAPI-Sicherheit

Willkommen, liebe Entwicklerkollegen! In diesem Blogbeitrag werden wir tief in die Welt der Anwendungssicherheit eintauchen und uns dabei insbesondere auf eine Schwachstelle konzentrieren, die die Sicherheit von FastAPI beeinträchtigen kann: Denial of Service (DoS), verursacht durch unsichere reguläre Ausdrücke (Regex). Wir werden untersuchen, wie ein schlecht konstruierter regulärer Ausdruck zu einem sogenannten „Regular Expression Denial of Service“ (ReDoS) führen kann, einer Form des DoS-Angriffs, und wie diese Schwachstellen mithilfe eines leistungsstarken Entwickler-Sicherheitstools – Snyk.

Verständnis der Auswirkungen von ReDoS auf die FastAPI-Sicherheit in Python

Python, eine der beliebtesten Programmiersprachen, verfügt über ein riesiges Ökosystem an Paketen und Bibliotheken. Während diese Pakete uns das Leben als Entwickler erleichtern, stellen sie auch ein potenzielles Risiko dar, wenn sie nicht ordnungsgemäß gesichert werden. Aufgrund der rasanten Geschwindigkeit der Softwareentwicklung werden Pakete häufig aktualisiert und neue Versionen veröffentlicht, was manchmal unwissentlich Sicherheitsrisiken mit sich bringt.

Ein solches Risiko ist die Möglichkeit eines ReDoS-Angriffs, einer Form des DoS-Angriffs, bei dem ein Angreifer böswillige Eingaben in einen regulären Ausdruck eingibt, dessen Auswertung sehr lange dauert. Dies führt dazu, dass die Anwendung nicht mehr reagiert oder erheblich langsamer wird, was schwerwiegende Folgen haben kann, von einer beeinträchtigten Benutzererfahrung bis hin zum vollständigen Ausfall der Anwendung.

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

Im obigen Code ist der reguläre Ausdruck ^(a+)+$ anfällig für einen ReDoS-Angriff. Wenn ein Angreifer eine Zeichenfolge mit „a“ gefolgt von einem Nicht-„a“-Zeichen bereitstellt, dauert die Auswertung des regulären Ausdrucks sehr lange, was effektiv zu einem DoS führt.

Wie Snyk Ihre FastAPI-Python-Anwendungen schützen kann

Snyk ist ein entwicklerorientiertes Sicherheitstool, das Ihren Python-Code auf potenzielle ReDoS-Schwachstellen scannen kann. Es liefert detaillierte Berichte über die identifizierten Schwachstellen und empfiehlt die am besten geeigneten Korrekturen.

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

Dieser Befehl scannt Ihr Drittanbieter-Abhängigkeitsmanifest, normalerweise in der Datei „requirements.txt“, und stellt einen Bericht über alle identifizierten Schwachstellen bereit, einschließlich potenzieller ReDoS-Schwachstellen. Registrieren Sie sich für ein kostenloses Snyk-Konto, um noch heute mit dem Scannen Ihrer Python-Projekte auf ReDoS und andere Schwachstellen zu beginnen.

Für die Aufrechterhaltung einer sicheren Python-Anwendung ist es von entscheidender Bedeutung, die Auswirkungen solcher Schwachstellen zu verstehen und zu wissen, wie sie gemindert werden können. Hier kommen Tools wie Snyk zum Einsatz. Snyk Open Source kann dabei helfen, Sicherheitslücken in Python-Paketen zu identifizieren und zu beheben, einschließlich unsicherer regulärer Ausdrücke, die zu einem ReDoS-Angriff führen können.

Sehen wir uns genauer an, wie man solche Schwachstellen in FastAPI-Python-Webanwendungen mithilfe von Snyk identifizieren und entschärfen kann.

FastAPI-Sicherheitslücke mit CVE-2024-24762

FastAPI ist ein modernes, leistungsstarkes Web-Framework zum Erstellen von APIs mit Python basierend auf standardmäßigen Python-Hinweisen. Seine Hauptmerkmale sind seine Geschwindigkeit und seine Fähigkeit, schnell und mühelos robuste APIs zu erstellen, was es zu einer beliebten Wahl für Python-Entwickler macht, die leistungsstarke RESTful-APIs erstellen müssen.

FastAPI vereinfacht den Prozess der API-Erstellung, indem es sofort einen Routing-Mechanismus, Serialisierung/Deserialisierung und Validierung bereitstellt. Es basiert auf den Python-Projekten Starlette für die Webparts und Pydantic für die Datenteile. Dadurch können Entwickler die asynchronen Funktionen nutzen, die in Python 3.6 und höher verfügbar sind.

Die Erstellung einer einfachen API mit einer FastAPI-Python-Webanwendung kann beispielsweise mit dem folgenden Codeausschnitt erfolgen:

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

Obwohl FastAPI ein robustes und agiles Tool für die Entwicklung von APIs ist, ist es nicht frei von Schwachstellen. Eine davon ist die Schwachstelle CVE-2024-24762. Hierbei handelt es sich um eine Denial-of-Service-Schwachstelle, die ihren Ursprung im regulären Ausdruck hat, der vom Python-Paket python-multipart verwendet wird.

Die Python-Multipart-Abhängigkeit ist eine Python-Bibliothek zum Parsen von Multipart-/Formulardaten. Es wird häufig als Abhängigkeit in FastAPI zum Verwalten von Formulardaten verwendet.

Die Sicherheitslücke tritt auf, wenn ein Angreifer eine schädliche Zeichenfolge sendet, die dazu führt, dass der reguläre Ausdruck in Python-Multipart viel CPU verbraucht, was zu einem Denial-of-Service (DoS) führt. Dies wird auch als ReDoS (Regular Expression Denial of Service) bezeichnet.

Wie würde ein Python-Entwickler diese Sicherheitslücke schließen? Der erste Schritt besteht darin, die Schwachstelle in Ihrem Projekt zu identifizieren. Dies kann mit dem Snyk CLI-Tool erfolgen.

$ snyk test

Um solche Schwachstellen zu erkennen, müssen Sie die Abhängigkeiten Ihres Projekts scannen, wodurch ein Bericht über alle Schwachstellen in den Abhängigkeiten Ihres Projekts erstellt wird.

Die Ausgabe des Snyk-Testbefehls findet die Schwachstelle:

snyk test

Testing /Users/lirantal/projects/repos/fastapi-vulnerable-redos-app...

Tested 13 dependencies for known issues, found 1 issue, 1 vulnerable path.

Issues to fix by upgrading dependencies:

  Upgrade fastapi@0.109.0 to fastapi@0.109.1 to fix
  ✗ Regular Expression Denial of Service (ReDoS) (new) [High Severity][https://security.snyk.io/vuln/SNYK-PYTHON-FASTAPI-6228055] in fastapi@0.109.0
    introduced by fastapi@0.109.0

Organization:      liran.tal
Package manager:   pip
Target file:       requirements.txt
Project name:      fastapi-vulnerable-redos-app

Um die Schwachstelle zu beheben, können Sie auf neuere Versionen des Pakets „python-multipart“ und von Fastapi aktualisieren, die die Schwachstelle behoben haben. Diese Versionen werden von Snyk empfohlen.

Building and breaking FastAPI security: A step-by-step guide

Our first step is to set up a new Python project. We'll need to install FastAPI, along with a server to host it on. Uvicorn is a good choice for a server because it is lightweight and works well with FastAPI.

Start by installing FastAPI, python-multipart, and Uvicorn with pip:

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

Next, create a new directory for your project, and inside that directory, create a new file for your FastAPI application. You can call it main.py.

Writing the FastAPI Python code

Now we're ready to write our FastAPI application code. Open main.py and add the following Python code:

from typing import Annotated
from fastapi.responses import HTMLResponse
from fastapi import FastAPI,Form
from pydantic import BaseModel

class Item(BaseModel):
    username: str

app = FastAPI()

@app.get("/", response_class=HTMLResponse)
async def index():
    return HTMLResponse("Test", status_code=200)

@app.post("/submit/")
async def submit(username: Annotated[str, Form()]):
    return {"username": username}

@app.post("/submit_json/")
async def submit_json(item: Item):
    return {"username": item.username}

This simple FastAPI application has several routes (/), including /submit, which uses a multipart form. When a POST request is received, the submit route returns the username that was submitted.

Starting the server and running the application

With our FastAPI application code written, we can now start the Uvicorn server and run our application.

Use the following command to start the server:

uvicorn main:app --reload

You should see an output indicating that the server is running. You can test your application by navigating to http://localhost:8000 in your web browser. The message "Test" should be displayed on the page.

Breaking FastAPI security with a ReDoS attack

Now that our FastAPI application is running, we can test it for vulnerabilities. We'll use a ReDoS attack payload in the HTTP request to exploit the vulnerability in the python-multipart package that parses the content-type header value.

If you have the curl program installed, run the following command in your terminal:

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

Securing your FastAPI application with Snyk

As you saw by now, open source dependencies play a key role in building Python applications. However, these third-party dependencies can sometimes be a breeding ground for vulnerabilities, thus posing significant security threats. In this context, Snyk Open Source emerges as a robust tool that helps developers identify and fix security issues effectively.

Imagine you could quickly find FastAPI security vulnerabilities already in the IDE panel when you write Python code instead of waiting until security scanners pick this up at a later stage.

The Snyk IDE extension is free, and if you’re using PyCharm, you can search for Snyk in the Plugins view and download it directly from there. If you’re using VS Code you can similarly find it in the Extensions marketplace right from the IDE.

Introduction to Snyk Open Source and its capabilities

Snyk Open Source is a powerful tool used for uncovering and addressing vulnerabilities in open source dependencies and container images. It is designed to integrate easily with the existing codebase and CI/CD systems, making it a handy tool for developers. It provides a comprehensive database of known vulnerabilities, enabling developers to proactively address potential breaches in security.

Step-by-step guide on how to scan Python dependencies for vulnerabilities with Snyk

To scan Python dependencies for vulnerabilities with Snyk, you first need to install the Snyk CLI. You can do this using one of the methods in the guide, or if you have a Node.js environment, you can quickly install Snyk with npm install -g snyk and then run snyk auth to authenticate.

Once installed, you can use the snyk test command to check your Python project for vulnerabilities:

snyk test --all-projects

Snyk will then scan all your dependencies and compare them against its vulnerability database. If any issues are found, Snyk will provide a detailed report with information about the vulnerability, its severity, and possible fixes.

Monitoring your projects with Snyk is crucial to maintain the security of your application. With Snyk, not only can you detect vulnerabilities, but you can also apply automated fixes, which can save you time and resources.

In addition, Snyk offers vulnerability alerts that notify you about new vulnerabilities that may affect your projects. This allows you to stay one step ahead and fix security issues before they can be exploited.

With the snyk monitor command, you can take a snapshot of your current project dependencies and monitor them for vulnerabilities:

snyk monitor

How to integrate Snyk with Git repositories

Integrating Snyk with your Git repositories allows you to automatically scan every commit for vulnerabilities. This can be done by adding Snyk as a webhook in your repository settings.

Sobald dies erledigt ist, löst jeder Push in Ihr Repository einen Snyk-Scan aus, der Ihnen hilft, Schwachstellen so früh wie möglich zu erkennen und zu beheben.

Zusammenfassend lässt sich sagen, dass Snyk Open Source ein wertvolles Tool zur Aufrechterhaltung der Sicherheit Ihrer Python-Projekte ist. Durch die Suche nach Schwachstellen, die Überwachung Ihrer Projekte und die Integration in Ihre Git-Repositorys ermöglicht Ihnen Snyk die Aufrechterhaltung einer robusten, sicheren Codebasis. Wenn Sie es noch nicht getan haben, registrieren Sie sich für ein kostenloses Snyk-Konto und beginnen Sie noch heute mit der Sicherung Ihrer Bewerbungen.

Das obige ist der detaillierte Inhalt vonEin Denial-of-Service-Regex unterbricht die FastAPI-Sicherheit. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!