Uma regex que causa negação de serviço compromete a segurança do FastAPI

Olá, desenvolvedores! Neste artigo, vamos explorar a segurança de aplicações, com foco em uma vulnerabilidade que pode comprometer a segurança do FastAPI: a negação de serviço (DoS) causada por expressões regulares (regex) inseguras. Vamos ver como uma regex mal construída pode levar ao que chamamos de negação de serviço por expressão regular (ReDoS), um tipo de ataque DoS, e como identificar e mitigar essas vulnerabilidades com uma poderosa ferramenta de segurança para desenvolvedores: o Snyk.

Entenda o impacto do ReDoS na segurança do FastAPI em Python

Python, uma das linguagens de programação mais populares, conta com um vasto ecossistema de pacotes e bibliotecas. Embora esses pacotes facilitem o nosso trabalho como desenvolvedores, eles também podem representar riscos se não forem protegidos adequadamente. Com o ritmo acelerado do desenvolvimento de software, os pacotes são atualizados com frequência e novas versões são lançadas, às vezes introduzindo riscos de segurança sem que ninguém perceba.

Um desses riscos é a possibilidade de um ataque ReDoS, um tipo de ataque DoS em que o invasor fornece uma entrada maliciosa para uma expressão regular que demora muito para ser avaliada. Isso faz com que a aplicação deixe de responder ou fique significativamente mais lenta, o que pode ter consequências sérias, desde uma experiência ruim para o usuário até a falha completa da aplicação.

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

No código acima, a expressão regular ^(a+)+$ é vulnerável a um ataque ReDoS. Se um invasor fornecer uma string com vários caracteres 'a' seguidos de um caractere diferente de 'a', a regex levará muito tempo para ser avaliada, causando efetivamente uma DoS.

Como o Snyk pode proteger suas aplicações Python com FastAPI

O Snyk é uma ferramenta de segurança voltada para desenvolvedores que verifica seu código Python em busca de possíveis vulnerabilidades ReDoS. A ferramenta apresenta relatórios detalhados das vulnerabilidades identificadas e recomenda as correções mais adequadas.

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

Este comando verifica o manifesto das dependências de terceiros, geralmente o arquivo requirements.txt, e apresenta um relatório com todas as vulnerabilidades identificadas, incluindo possíveis vulnerabilidades ReDoS. Crie uma conta gratuita no Snyk para começar hoje mesmo a verificar seus projetos Python em busca de ReDoS e outras vulnerabilidades.

Entender o impacto dessas vulnerabilidades e como mitigá-las é fundamental para manter uma aplicação Python segura. É aí que ferramentas como o Snyk ajudam. O Snyk Open Source pode ajudar a identificar e corrigir vulnerabilidades de segurança em pacotes Python, incluindo expressões regulares inseguras que podem levar a um ataque ReDoS.

Vamos ver mais de perto como identificar e mitigar essas vulnerabilidades em aplicações web Python com FastAPI usando o Snyk.

Vulnerabilidade de segurança no FastAPI: CVE-2024-24762

O FastAPI é um framework web moderno e de alto desempenho para criar APIs com Python, baseado em anotações de tipo padrão da linguagem. Seus principais diferenciais são a velocidade e a facilidade para criar APIs robustas, o que faz dele uma escolha popular entre desenvolvedores Python que precisam criar APIs RESTful de alto desempenho.

O FastAPI simplifica a criação de APIs ao oferecer, por padrão, mecanismos de roteamento, serialização e desserialização, além de validação. Ele é construído sobre os projetos Python Starlette, para os componentes web, e Pydantic, para os dados. Isso permite que os desenvolvedores aproveitem os recursos assíncronos disponíveis no Python 3.6 e em versões posteriores.

Veja um exemplo de como criar uma API simples com uma aplicação web Python usando FastAPI:

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

Embora o FastAPI seja uma ferramenta robusta e ágil para desenvolver APIs, ele não está livre de vulnerabilidades. Uma delas é a vulnerabilidade CVE-2024-24762. Trata-se de uma vulnerabilidade de negação de serviço causada pela regex usada pelo pacote Python python-multipart.

A dependência python-multipart é uma biblioteca Python para analisar dados multipart/form-data. Ela é comumente usada como dependência no FastAPI para gerenciar dados de formulários.

A vulnerabilidade ocorre quando um invasor envia uma string maliciosa que faz a expressão regular em python-multipart consumir muito processamento da CPU, levando a uma negação de serviço (DoS). Isso também é conhecido como negação de serviço por expressão regular (ReDoS).

Como um desenvolvedor Python pode mitigar essa vulnerabilidade? O primeiro passo é identificá-la no projeto. Para isso, você pode usar a CLI do Snyk.

$ snyk test

Para detectar vulnerabilidades como essa, é preciso verificar as dependências do projeto. A verificação gera um relatório com todas as vulnerabilidades encontradas nessas dependências.

O resultado do comando de teste do Snyk identifica a vulnerabilidade:

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 corrigir a vulnerabilidade, você pode atualizar os pacotes python-multipart e fastapi para versões mais recentes que já corrigem o problema. O Snyk recomenda essas versões.

Desenvolvendo e comprometendo a segurança do FastAPI: um guia passo a passo

O primeiro passo é configurar um novo projeto Python. Vamos precisar instalar o FastAPI e um servidor para hospedá-lo. O Uvicorn é uma boa opção porque é leve e funciona bem com o FastAPI.

Comece instalando o FastAPI, o python-multipart e o Uvicorn com pip:

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

Em seguida, crie um novo diretório para o projeto e, dentro dele, crie um arquivo para a aplicação FastAPI. Você pode chamá-lo de main.py.

Escrevendo o código Python do FastAPI

Agora podemos escrever o código da aplicação FastAPI. Abra main.py e adicione o seguinte código 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 aplicação simples do FastAPI tem várias rotas (/), incluindo /submit, que usa um formulário multipart. Ao receber uma solicitação POST, a rota submit retorna o nome de usuário enviado.

Iniciando o servidor e executando a aplicação

Com o código da aplicação FastAPI pronto, podemos iniciar o servidor Uvicorn e executar a aplicação.

Use o seguinte comando para iniciar o servidor:

uvicorn main:app --reload

Você verá uma mensagem indicando que o servidor está em execução. Para testar a aplicação, acesse http://localhost:8000 no navegador. A mensagem "Test" será exibida na página.

Comprometendo a segurança do FastAPI com um ataque ReDoS

Agora que nossa aplicação FastAPI está em execução, podemos testá-la em busca de vulnerabilidades. Vamos usar um payload de ataque ReDoS na solicitação HTTP para explorar a vulnerabilidade no pacote python-multipart, que analisa o valor do cabeçalho content-type.

Se você tiver o programa curl instalado, execute o seguinte comando no terminal:

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

Proteja sua aplicação FastAPI com o Snyk

Como você já viu, as dependências de código aberto têm um papel fundamental na criação de aplicações Python. No entanto, essas dependências de terceiros podem se tornar um terreno fértil para vulnerabilidades e representar sérias ameaças à segurança. Nesse contexto, o Snyk Open Source é uma ferramenta robusta que ajuda desenvolvedores a identificar e corrigir problemas de segurança com eficiência.

Imagine encontrar rapidamente vulnerabilidades de segurança do FastAPI no painel da sua IDE enquanto escreve código Python, em vez de esperar que os scanners de segurança as detectem em uma etapa posterior.

A extensão do Snyk para IDE é gratuita. Se você usa o PyCharm, procure o Snyk na visualização de plugins e faça o download diretamente por lá. Se usa o VS Code, você também pode encontrá-lo no marketplace de extensões, direto na IDE.

Conheça o Snyk Open Source e seus recursos

O Snyk Open Source é uma ferramenta poderosa para identificar e corrigir vulnerabilidades em dependências de código aberto e imagens de contêiner. Ele foi desenvolvido para se integrar facilmente à base de código e aos sistemas de CI/CD existentes, facilitando o trabalho dos desenvolvedores. A ferramenta oferece um banco de dados abrangente de vulnerabilidades conhecidas, permitindo que os desenvolvedores resolvam possíveis brechas de segurança de forma proativa.

Guia passo a passo para verificar vulnerabilidades nas dependências Python com o Snyk

Para verificar vulnerabilidades nas dependências Python com o Snyk, primeiro você precisa instalar a CLI do Snyk. Você pode usar um dos métodos descritos no guia ou, se tiver um ambiente Node.js, instalar o Snyk rapidamente com npm install -g snyk e depois executar run snyk auth para se autenticar.

Depois de instalar, você pode usar o comando snyk test para verificar se há vulnerabilidades no seu projeto Python:

snyk test --all-projects

Em seguida, o Snyk verificará todas as suas dependências e as comparará com seu banco de dados de vulnerabilidades. Se encontrar algum problema, apresentará um relatório detalhado com informações sobre a vulnerabilidade, sua gravidade e possíveis correções.

Monitorar seus projetos com o Snyk é fundamental para manter a segurança das suas aplicações. Com o Snyk, você não só detecta vulnerabilidades, como também pode aplicar correções automatizadas, economizando tempo e recursos.

Além disso, o Snyk envia alertas de vulnerabilidade para avisar você sobre novas vulnerabilidades que possam afetar seus projetos. Assim, você pode se antecipar e corrigir problemas de segurança antes que sejam explorados.

Com o comando snyk monitor, você pode criar um instantâneo das dependências atuais do projeto e monitorá-las em busca de vulnerabilidades:

snyk monitor

Como integrar o Snyk aos repositórios Git

Integrar o Snyk aos seus repositórios Git permite verificar automaticamente cada commit em busca de vulnerabilidades. Para isso, adicione o Snyk como webhook nas configurações do repositório.

Depois disso, cada push para o repositório acionará uma verificação do Snyk, ajudando você a identificar e corrigir vulnerabilidades o quanto antes.

Em resumo, o Snyk Open Source é uma ferramenta valiosa para manter a segurança dos seus projetos Python. Ao verificar vulnerabilidades, monitorar seus projetos e integrar-se aos repositórios Git, o Snyk ajuda você a manter uma base de código robusta e segura. Se ainda não tem uma conta, crie uma conta gratuita no Snyk e comece hoje mesmo a proteger suas aplicações.