Una expresión regular de denegación de servicio compromete la seguridad de FastAPI

¡Hola, desarrolladores! En esta publicación, profundizaremos en la seguridad de las aplicaciones, centrándonos específicamente en una vulnerabilidad que puede comprometer la seguridad de FastAPI: la denegación de servicio (DoS) causada por expresiones regulares (regex) inseguras. Exploraremos cómo una regex mal construida puede provocar lo que se conoce como denegación de servicio por expresiones regulares (ReDoS), un tipo de ataque DoS, y cómo identificar y mitigar estas vulnerabilidades con una potente herramienta de seguridad para desarrolladores: Snyk.

Cómo afecta ReDoS a la seguridad de FastAPI en Python

Python, uno de los lenguajes de programación más populares, cuenta con un amplio ecosistema de paquetes y bibliotecas. Aunque estos paquetes nos facilitan la vida como desarrolladores, también representan un riesgo potencial si no se protegen correctamente. Con el rápido ritmo del desarrollo de software, los paquetes se actualizan con frecuencia y se lanzan nuevas versiones, que a veces introducen riesgos de seguridad sin que nos demos cuenta.

Uno de esos riesgos es la posibilidad de sufrir un ataque ReDoS, un tipo de ataque DoS en el que un atacante proporciona una entrada maliciosa a una expresión regular que tarda mucho tiempo en evaluarse. Esto hace que la aplicación deje de responder o se vuelva considerablemente más lenta, lo que puede tener consecuencias graves: desde una experiencia de usuario deficiente hasta la falla completa de la aplicación.

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

En el código anterior, la expresión regular ^(a+)+$ es vulnerable a un ataque ReDoS. Si un atacante proporciona una cadena de varias 'a' seguidas de un carácter distinto de 'a', la regex tarda mucho tiempo en evaluarse, lo que provoca efectivamente una DoS.

Cómo puede Snyk proteger tus aplicaciones de Python con FastAPI

Snyk es una herramienta de seguridad diseñada para desarrolladores que puede analizar tu código Python para detectar posibles vulnerabilidades ReDoS. Proporciona informes detallados de las vulnerabilidades detectadas y recomienda las soluciones más adecuadas.

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

Este comando analizará el manifiesto de dependencias de terceros, que suele estar en el archivo requirements.txt, y generará un informe de todas las vulnerabilidades detectadas, incluidas las posibles vulnerabilidades ReDoS. Crea una cuenta gratuita de Snyk para empezar hoy mismo a analizar tus proyectos de Python en busca de vulnerabilidades ReDoS y otras amenazas.

Comprender el impacto de estas vulnerabilidades y cómo mitigarlas es fundamental para mantener la seguridad de una aplicación Python. Aquí es donde resultan útiles herramientas como Snyk. Snyk Open Source puede ayudar a detectar y corregir vulnerabilidades de seguridad en paquetes de Python, incluidas las expresiones regulares inseguras que pueden provocar un ataque ReDoS.

Veamos más de cerca cómo identificar y mitigar este tipo de vulnerabilidades en aplicaciones web de Python con FastAPI mediante Snyk.

Vulnerabilidad de seguridad de FastAPI: CVE-2024-24762

FastAPI es un framework web moderno y de alto rendimiento para crear API con Python, basado en las sugerencias de tipos estándar de Python. Sus características principales son la velocidad y la capacidad de crear API robustas de forma rápida y sencilla, lo que lo convierte en una opción popular entre los desarrolladores de Python que necesitan crear API RESTful de alto rendimiento.

FastAPI simplifica la creación de API al ofrecer de forma integrada mecanismos de enrutamiento, serialización y deserialización, y validación. Se basa en los proyectos de Python Starlette, para la parte web, y Pydantic, para los datos. Esto permite a los desarrolladores aprovechar las funciones asíncronas disponibles en Python 3.6 y versiones posteriores.

Por ejemplo, puedes crear una API sencilla con una aplicación web de Python y FastAPI usando el siguiente fragmento de código:

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

Aunque FastAPI es una herramienta robusta y ágil para desarrollar API, no está libre de vulnerabilidades. Una de ellas es la vulnerabilidad CVE-2024-24762. Se trata de una vulnerabilidad de denegación de servicio que se origina en la regex del paquete de Python python-multipart.

La dependencia python-multipart es una biblioteca de Python para analizar datos multipart/form. Se usa comúnmente como dependencia de FastAPI para gestionar datos de formularios.

La vulnerabilidad se produce cuando un atacante envía una cadena maliciosa que hace que la expresión regular de python-multipart consuma una gran cantidad de CPU, lo que provoca una denegación de servicio (DoS). Esto también se conoce como denegación de servicio por expresiones regulares (ReDoS).

¿Cómo puede un desarrollador de Python mitigar esta vulnerabilidad? El primer paso es identificarla en el proyecto. Puedes hacerlo con la herramienta Snyk CLI.

$ snyk test

Para detectar vulnerabilidades como esta, es necesario analizar las dependencias del proyecto. El análisis generará un informe con todas las vulnerabilidades presentes en ellas.

El resultado del comando snyk test muestra la vulnerabilidad:

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

Para corregir la vulnerabilidad, puedes actualizar a versiones más recientes de los paquetes python-multipart y fastapi que ya la solucionan. Snyk recomienda estas versiones.

Cómo crear y poner a prueba la seguridad de FastAPI: guía paso a paso

El primer paso es configurar un nuevo proyecto de Python. Tendremos que instalar FastAPI y un servidor para alojarlo. Uvicorn es una buena opción porque es ligero y funciona bien con FastAPI.

Para empezar, instala FastAPI, python-multipart y Uvicorn con pip:

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

A continuación, crea un directorio para el proyecto y, dentro de él, un archivo nuevo para la aplicación FastAPI. Puedes llamarlo main.py.

Escribe el código Python de FastAPI

Ahora estamos listos para escribir el código de la aplicación FastAPI. Abre main.py y agrega el siguiente código de Python:

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}

Esta aplicación sencilla de FastAPI tiene varias rutas (/), incluida /submit, que usa un formulario multipart. Cuando recibe una solicitud POST, la ruta submit devuelve el nombre de usuario enviado.

Inicia el servidor y ejecuta la aplicación

Una vez escrito el código de la aplicación FastAPI, podemos iniciar el servidor Uvicorn y ejecutar la aplicación.

Usa el siguiente comando para iniciar el servidor:

uvicorn main:app --reload

Deberías ver un mensaje que indica que el servidor está en ejecución. Puedes probar la aplicación desde el navegador, visitando http://localhost:8000. En la página debería aparecer el mensaje "Test".

Cómo comprometer la seguridad de FastAPI con un ataque ReDoS

Ahora que nuestra aplicación FastAPI está en ejecución, podemos probar si tiene vulnerabilidades. Usaremos un payload de ataque ReDoS en la solicitud HTTP para explotar la vulnerabilidad del paquete python-multipart, que analiza el valor del encabezado content-type.

Si tienes instalado el programa curl, ejecuta el siguiente comando en la terminal:

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

Protege tu aplicación FastAPI con Snyk

Como ya viste, las dependencias de código abierto desempeñan un papel clave en la creación de aplicaciones de Python. Sin embargo, estas dependencias de terceros pueden convertirse en focos de vulnerabilidades y representar importantes amenazas de seguridad. En este contexto, Snyk Open Source es una herramienta robusta que ayuda a los desarrolladores a identificar y corregir problemas de seguridad de manera eficaz.

Imagina que pudieras encontrar rápidamente vulnerabilidades de seguridad de FastAPI en el panel del IDE mientras escribes código Python, en lugar de esperar a que las detecten los escáneres de seguridad en una etapa posterior.

La extensión de Snyk para IDE es gratuita. Si usas PyCharm, busca Snyk en la vista de complementos y descárgala directamente desde allí. Si usas VS Code, puedes encontrarla de forma similar en el marketplace de extensiones desde el IDE.

Introducción a Snyk Open Source y sus capacidades

Snyk Open Source es una potente herramienta para detectar y corregir vulnerabilidades en dependencias de código abierto e imágenes de contenedores. Está diseñada para integrarse fácilmente con el código base y los sistemas de CI/CD existentes, por lo que es muy útil para los desarrolladores. Ofrece una base de datos exhaustiva de vulnerabilidades conocidas que permite a los desarrolladores abordar de forma proactiva posibles brechas de seguridad.

Guía paso a paso para analizar dependencias de Python en busca de vulnerabilidades con Snyk

Para analizar dependencias de Python en busca de vulnerabilidades con Snyk, primero debes instalar Snyk CLI. Puedes seguir uno de los métodos de la guía o, si tienes un entorno de Node.js, instalar Snyk rápidamente con npm install -g snyk y luego ejecutar run snyk auth para autenticarte.

Una vez instalado, puedes usar el comando snyk test para comprobar si tu proyecto de Python tiene vulnerabilidades:

snyk test --all-projects

Snyk analizará todas tus dependencias y las comparará con su base de datos de vulnerabilidades. Si encuentra algún problema, te proporcionará un informe detallado con información sobre la vulnerabilidad, su gravedad y las posibles soluciones.

Supervisar tus proyectos con Snyk es fundamental para mantener la seguridad de tu aplicación. Con Snyk, no solo puedes detectar vulnerabilidades, sino también aplicar correcciones automatizadas, lo que puede ahorrarte tiempo y recursos.

Además, Snyk ofrece alertas de vulnerabilidades que te notifican sobre nuevas amenazas que podrían afectar tus proyectos. Así puedes anticiparte y corregir los problemas de seguridad antes de que alguien los explote.

Con el comando snyk monitor, puedes crear una instantánea de las dependencias actuales de tu proyecto y supervisarlas para detectar vulnerabilidades:

snyk monitor

Cómo integrar Snyk con repositorios de Git

Al integrar Snyk con tus repositorios de Git, puedes analizar automáticamente cada commit en busca de vulnerabilidades. Para hacerlo, agrega Snyk como webhook en la configuración del repositorio.

Una vez configurado, cada push al repositorio activará un análisis de Snyk que te ayudará a detectar y corregir vulnerabilidades lo antes posible.

En conclusión, Snyk Open Source es una herramienta valiosa para mantener la seguridad de tus proyectos de Python. Al analizar en busca de vulnerabilidades, supervisar tus proyectos e integrarse con tus repositorios de Git, Snyk te permite mantener un código base robusto y seguro. Si aún no tienes una, crea una cuenta gratuita de Snyk y empieza hoy mismo a proteger tus aplicaciones.