Penafian perkhidmatan Regex memecahkan keselamatan FastAPI

Selamat datang, rakan pembangun! Dalam catatan blog ini, kami akan mendalami dunia keselamatan aplikasi, khususnya menumpukan pada kerentanan yang boleh merosot keselamatan FastAPI: Penafian perkhidmatan (DoS) yang disebabkan oleh ungkapan biasa (regex) yang tidak selamat. Kami akan meneroka cara regex yang dibina dengan buruk boleh membawa kepada apa yang dikenali sebagai penafian perkhidmatan ekspresi biasa (ReDoS), satu bentuk serangan DoS dan cara kelemahan ini boleh dikenal pasti dan dikurangkan menggunakan alat keselamatan pembangun yang berkuasa — Snyk.

Memahami kesan ReDoS pada keselamatan FastAPI dalam Python

Python, salah satu bahasa pengaturcaraan yang paling popular, mempunyai ekosistem pakej dan perpustakaan yang luas. Walaupun pakej ini menjadikan kehidupan kita lebih mudah sebagai pembangun, pakej ini juga menimbulkan potensi risiko jika tidak dilindungi dengan betul. Dengan kepesatan pembangunan perisian, pakej sering dikemas kini dan versi baharu dikeluarkan, kadangkala tanpa disedari memperkenalkan risiko keselamatan.

Salah satu risiko sedemikian ialah potensi untuk serangan ReDoS, satu bentuk serangan DoS di mana penyerang memberikan input berniat jahat kepada ungkapan biasa yang mengambil masa yang sangat lama untuk dinilai. Ini menyebabkan aplikasi menjadi tidak bertindak balas atau perlahan dengan ketara, yang boleh membawa implikasi yang serius, daripada pengalaman pengguna yang merosot hingga menyelesaikan kegagalan aplikasi.

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

Dalam kod di atas, ungkapan biasa ^(a+)+$ terdedah kepada serangan ReDoS. Jika penyerang memberikan rentetan 'a' diikuti oleh bukan 'a', regex mengambil masa yang sangat lama untuk menilai, dengan berkesan menyebabkan DoS.

Bagaimana Snyk boleh melindungi aplikasi Python FastAPI anda

Snyk ialah alat keselamatan yang mengutamakan pembangun yang boleh mengimbas kod Python anda untuk kemungkinan kelemahan ReDoS. Ia menyediakan laporan terperinci tentang kelemahan yang dikenal pasti dan mengesyorkan pembaikan yang paling sesuai.

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

Arahan ini akan mengimbas manifes pergantungan pihak ketiga anda, biasanya pada fail requirements.txt dan menyediakan laporan semua kelemahan yang dikenal pasti, termasuk kemungkinan kelemahan ReDoS. Daftar untuk mendapatkan akaun Snyk percuma untuk mula mengimbas projek Python anda untuk ReDoS dan kelemahan lain hari ini.

Memahami kesan kelemahan tersebut dan cara mengurangkannya adalah penting untuk mengekalkan aplikasi Python yang selamat. Di sinilah alat seperti Snyk berguna. Sumber Terbuka Snyk boleh membantu mengenal pasti dan membetulkan kelemahan keselamatan dalam pakej Python, termasuk ungkapan biasa yang tidak selamat yang boleh membawa kepada serangan ReDoS.

Mari kita lihat dengan lebih dekat cara mengenal pasti dan mengurangkan kelemahan sedemikian dalam aplikasi web FastAPI Python menggunakan Snyk.

Kerentanan keselamatan FastAPI dengan CVE-2024-24762

FastAPI ialah rangka kerja web moden berprestasi tinggi untuk membina API dengan Python berdasarkan pembayang jenis Python standard. Ciri utamanya ialah kelajuan dan keupayaannya untuk membina API yang mantap dengan cepat dan mudah, menjadikannya pilihan popular untuk pembangun Python yang perlu membina API RESTful berprestasi tinggi.

FastAPI memudahkan proses membina API dengan menyediakan mekanisme penghalaan, pensirilan/penyahserikatan dan pengesahan di luar kotak. Ia dibina di atas projek Python Starlette untuk bahagian web dan Pydantic untuk bahagian data. Ini membolehkan pembangun memanfaatkan ciri tak segerak yang tersedia dalam Python 3.6 dan ke atas.

Sebagai contoh, mencipta API mudah dengan aplikasi web FastAPI Python boleh dicapai dengan coretan kod berikut:

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

Walaupun FastAPI ialah alat yang teguh dan tangkas untuk membangunkan API, ia tidak mempunyai kelemahan. Salah satunya ialah kerentanan terhadap CVE-2024-24762. Ini ialah kelemahan penafian perkhidmatan yang berasal dari regex yang digunakan oleh pakej Python python-multipart.

Kebergantungan python-multipart ialah perpustakaan Python untuk menghuraikan data berbilang bahagian/bentuk. Ia biasanya digunakan sebagai kebergantungan dalam FastAPI untuk mengurus data borang.

Kerentanan berlaku apabila penyerang menghantar rentetan hasad yang menyebabkan ungkapan biasa dalam python-multipart menggunakan jumlah CPU yang tinggi, yang membawa kepada penafian perkhidmatan (DoS). Ini juga dikenali sebagai penafian perkhidmatan ungkapan biasa (ReDoS).

Bagaimanakah pembangun Python mengurangkan kelemahan ini? Langkah pertama ialah mengenal pasti kelemahan dalam projek anda. Ini boleh dilakukan menggunakan alat Snyk CLI.

$ snyk test

Mengesan kelemahan seperti ini memerlukan pengimbasan kebergantungan projek anda, yang akan memberikan laporan tentang semua kelemahan dalam kebergantungan projek anda.

Output arahan ujian Snyk menemui kelemahan:

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

Untuk membetulkan kerentanan, anda boleh menaik taraf kepada versi pakej berbilang bahagian python dan fastapi yang lebih baharu yang telah membetulkan kerentanan dan versi ini dicadangkan oleh Snyk.

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.

Setelah ini selesai, setiap tolakan ke repositori anda akan mencetuskan imbasan Snyk, membantu anda menangkap dan membetulkan kelemahan seawal mungkin.

Untuk membuat kesimpulan, Sumber Terbuka Snyk ialah alat yang berharga untuk mengekalkan keselamatan projek Python anda. Dengan mengimbas kelemahan, memantau projek anda dan menyepadukan dengan repositori Git anda, Snyk membolehkan anda mengekalkan pangkalan kod yang teguh dan selamat. Jika anda belum berbuat demikian, daftar untuk mendapatkan akaun Snyk percuma dan mula melindungi permohonan anda hari ini.

Atas ialah kandungan terperinci Penafian perkhidmatan Regex memecahkan keselamatan FastAPI. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!