Bienvenue, amis développeurs ! Dans cet article de blog, nous allons approfondir le monde de la sécurité des applications, en nous concentrant spécifiquement sur une vulnérabilité qui peut détériorer la sécurité de FastAPI : le déni de service (DoS) provoqué par des expressions régulières non sécurisées (regex). Nous explorerons comment une expression régulière mal construite peut conduire à ce que l'on appelle un déni de service d'expression régulière (ReDoS), une forme d'attaque DoS, et comment ces vulnérabilités peuvent être identifiées et atténuées à l'aide d'un puissant outil de sécurité pour les développeurs : Snyk.
Python, l'un des langages de programmation les plus populaires, possède un vaste écosystème de packages et de bibliothèques. Bien que ces packages nous facilitent la vie en tant que développeurs, ils présentent également un risque potentiel s'ils ne sont pas correctement sécurisés. Avec le rythme rapide du développement des logiciels, les packages sont souvent mis à jour et de nouvelles versions sont publiées, introduisant parfois sans le savoir des risques de sécurité.
L'un de ces risques est le potentiel d'une attaque ReDoS, une forme d'attaque DoS dans laquelle un attaquant fournit une entrée malveillante à une expression régulière dont l'évaluation prend très longtemps. Cela empêche l'application de répondre ou la ralentit considérablement, ce qui peut avoir de graves conséquences, allant d'une expérience utilisateur dégradée à l'échec complet de l'application.
import re
pattern = re.compile("^(a+)+$")
def check(input):
return bool(pattern.match(input))
check("a" * 3000 + "!")
Dans le code ci-dessus, l'expression régulière ^(a+)+$ est vulnérable à une attaque ReDoS. Si un attaquant fournit une chaîne de « a » suivie d'un caractère autre que « a », l'évaluation de l'expression régulière prend très longtemps, provoquant effectivement un DoS.
Snyk est un outil de sécurité destiné aux développeurs qui peut analyser votre code Python à la recherche de vulnérabilités ReDoS potentielles. Il fournit des rapports détaillés sur les vulnérabilités identifiées et recommande les correctifs les plus adaptés.
# After installing Snyk and setting up the Snyk CLI # you can scan your project: $ snyk test
Cette commande analysera votre manifeste de dépendance tiers, généralement dans le fichier exigences.txt, et fournira un rapport de toutes les vulnérabilités identifiées, y compris les vulnérabilités ReDoS potentielles. Inscrivez-vous pour un compte Snyk gratuit pour commencer dès aujourd'hui à analyser vos projets Python à la recherche de ReDoS et d'autres vulnérabilités.
Comprendre l'impact de ces vulnérabilités et comment les atténuer est essentiel pour maintenir une application Python sécurisée. C'est là que des outils comme Snyk s'avèrent utiles. Snyk Open Source peut aider à identifier et à corriger les vulnérabilités de sécurité dans les packages Python, y compris les expressions régulières non sécurisées pouvant conduire à une attaque ReDoS.
Examinons de plus près comment identifier et atténuer ces vulnérabilités dans les applications Web FastAPI Python à l'aide de Snyk.
FastAPI est un framework Web moderne et performant permettant de créer des API avec Python basées sur des astuces standard de type Python. Ses principales caractéristiques sont sa rapidité et sa capacité à créer rapidement et sans effort des API robustes, ce qui en fait un choix populaire pour les développeurs Python qui ont besoin de créer des API RESTful hautes performances.
FastAPI simplifie le processus de création d'API en fournissant un mécanisme de routage, de sérialisation/désérialisation et de validation prêts à l'emploi. Il est construit sur les projets Python Starlette pour les composants WebPart et Pydantic pour les composants de données. Cela permet aux développeurs de profiter des fonctionnalités asynchrones disponibles dans Python 3.6 et versions ultérieures.
À titre d'exemple, la création d'une API simple avec une application Web FastAPI Python peut être réalisée avec l'extrait de code suivant :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Si FastAPI est un outil robuste et agile pour développer des API, il n’est pas dénué de vulnérabilités. L'une d'entre elles est la vulnérabilité CVE-2024-24762. Il s'agit d'une vulnérabilité de déni de service qui provient de l'expression régulière utilisée par le package Python python-multipart.
La dépendance python-multipart est une bibliothèque Python pour analyser les données multipart/form. Il est couramment utilisé comme dépendance dans FastAPI pour gérer les données de formulaire.
La vulnérabilité se produit lorsqu'un attaquant envoie une chaîne malveillante qui fait que l'expression régulière dans python-multipart consomme de grandes quantités de CPU, conduisant à un déni de service (DoS). Ceci est également connu sous le nom de déni de service d'expression régulière (ReDoS).
Comment un développeur Python pourrait-il atténuer cette vulnérabilité ? La première étape consiste à identifier la vulnérabilité de votre projet. Cela peut être fait à l'aide de l'outil Snyk CLI.
$ snyk test
La détection de vulnérabilités telles que celle-ci nécessite d'analyser les dépendances de votre projet, ce qui fournira un rapport de toutes les vulnérabilités dans les dépendances de votre projet.
Le résultat de la commande de test Snyk trouve la vulnérabilité :
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
Pour corriger la vulnérabilité, vous pouvez mettre à niveau vers des versions plus récentes du package python-multipart et de fastapi qui ont corrigé la vulnérabilité, et ces versions sont suggérées par Snyk.
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.
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.
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.
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/'
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.
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.
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
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.
Une fois cela fait, chaque poussée vers votre référentiel déclenchera une analyse Snyk, vous aidant à détecter et corriger les vulnérabilités le plus tôt possible.
En conclusion, Snyk Open Source est un outil précieux pour maintenir la sécurité de vos projets Python. En recherchant les vulnérabilités, en surveillant vos projets et en s'intégrant à vos référentiels Git, Snyk vous permet de maintenir une base de code robuste et sécurisée. Si vous ne l'avez pas déjà fait, créez un compte Snyk gratuit et commencez à sécuriser vos applications dès aujourd'hui.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
