Test d'intrusion FastAPI : Sécurité des API Python, DoS et Dépendances
FastAPI est devenu le framework Python pour APIs le plus populaire, plébiscité pour sa rapidité, ses types Pydantic et sa génération automatique de documentation OpenAPI. Sa montée en puissance dans les architectures microservices et les backends d'intelligence artificielle en fait une cible de plus en plus présente dans les audits de sécurité. CVE-2024-24762 dans python-multipart (dépendance directe de FastAPI pour le traitement des formulaires) a démontré qu'un attaquant pouvait provoquer un déni de service en envoyant des données de formulaire malformées. CVE-2023-30798 dans Starlette (le framework ASGI sous-jacent de FastAPI) a exposé des vulnérabilités dans la gestion des requêtes. Matproof examine vos APIs FastAPI de manière exhaustive, des endpoints aux dépendances en passant par la configuration de sécurité.
Pourquoi les APIs FastAPI nécessitent des tests de sécurité spécialisés
FastAPI offre des avantages de développement significatifs — validation automatique via Pydantic, génération OpenAPI, performances async — mais ces mêmes fonctionnalités introduisent des risques spécifiques. La validation Pydantic, bien que robuste, ne remplace pas les contrôles d'autorisation que FastAPI ne fournit pas nativement. Le système de dépendances (Depends) de FastAPI est puissant pour injecter l'authentification, mais son implémentation incorrecte crée des failles d'autorisation subtiles. La documentation Swagger UI exposée en production révèle l'intégralité de la structure de l'API aux attaquants. La stack de dépendances (Starlette, Uvicorn, python-multipart, idna) introduit des surfaces d'attaque supplémentaires au-delà du code applicatif lui-même.
- CVE-2024-24762 (DoS via python-multipart dans FastAPI) : python-multipart est utilisé par FastAPI pour traiter les corps de requête multipart/form-data (File, Form). Cette CVE permettait à un attaquant non authentifié d'envoyer des données de formulaire spécialement construites provoquant une consommation excessive de CPU et une condition de déni de service. Toutes les APIs FastAPI utilisant File() ou Form() dans leurs paramètres de route étaient potentiellement affectées.
- CVE-2024-3651 (vulnérabilité dans la bibliothèque idna) : idna est une dépendance transitive courante dans les environnements Python incluant FastAPI. Cette CVE permettait des attaques de déni de service via la traitement de labels de domaine internationalisés (IDN) malformés. Les applications FastAPI effectuant des résolutions DNS ou des appels HTTP vers des URLs fournies par l'utilisateur étaient exposées.
- CVE-2023-30798 (vulnérabilité dans Starlette, base de FastAPI) : Starlette est le framework ASGI sur lequel FastAPI est construit. CVE-2023-30798 concernait la gestion des requêtes HTTP dans certaines versions de Starlette, affectant par extension toutes les applications FastAPI utilisant ces versions. La mise à jour de FastAPI met automatiquement à jour Starlette, mais beaucoup d'applications restent bloquées sur des versions non patchées.
- Absence de contrôles d'autorisation natifs dans FastAPI : contrairement à des frameworks comme Django REST Framework, FastAPI ne fournit pas de système d'autorisation intégré. Chaque endpoint doit implémenter explicitement ses propres vérifications via Depends(). L'oubli d'un Depends d'authentification sur un endpoint critique est une erreur fréquente conduisant à un accès non authentifié.
- Exposition de la documentation OpenAPI / Swagger en production : par défaut, FastAPI expose /docs (Swagger UI) et /redoc avec la documentation complète de l'API, incluant tous les schémas de requête/réponse et les exemples. Cette exposition en production fournit à un attaquant une cartographie précise et interactive de tous les endpoints disponibles.
- Injection via les modèles Pydantic et mass-assignment : Pydantic valide les types mais ne contrôle pas les autorisations d'accès aux champs. Si un schéma de requête accepte plus de champs que prévu (schéma trop permissif), des données non autorisées peuvent être persistées en base. L'utilisation de modèles Pydantic partagés entre l'entrée utilisateur et la base de données est particulièrement risquée.
- Sécurité des tokens JWT et authentification OAuth2 : FastAPI inclut des utilitaires OAuth2 mais délègue l'implémentation au développeur. Les vulnérabilités courantes incluent : validation insuffisante du token JWT (algorithme 'none', clés faibles), absence de liste noire des tokens révoqués, et scopes OAuth2 non vérifiés dans les endpoints protégés.
Ce qui est examiné lors d'un test d'intrusion FastAPI
- Audit des dépendances Python et de la stack ASGI : scan de toutes les dépendances (requirements.txt, pyproject.toml, Poetry.lock) contre NVD et PyPI Advisory Database ; vérification des versions de FastAPI, Starlette, Uvicorn, python-multipart, pydantic, idna et cryptography contre les CVE connus.
- Test de déni de service sur les endpoints multipart : envoi de corps de requête multipart/form-data malformés ou démesurément larges vers tous les endpoints acceptant File() ou Form() ; test de limites de taille, de types MIME et de profondeur de traitement.
- Vérification de l'exposition de la documentation OpenAPI : test de l'accessibilité de /docs, /redoc et /openapi.json en production ; si accessible, analyse du schéma pour identifier les endpoints non documentés ou les informations sensibles dans les descriptions.
- Audit des dépendances Depends() d'authentification : examen de tous les paramètres de route pour la présence de Depends() d'authentification/autorisation ; test des endpoints en envoyant des requêtes non authentifiées ou avec des tokens expirés/invalides vers chaque endpoint.
- Test d'injection et de validation Pydantic : test de dépassement de limites de type (très grand int, string Unicode de longueur extrême), de schémas récursifs ou imbriqués pouvant causer un stack overflow dans la validation, et d'injection de types non attendus.
- Sécurité des tokens JWT et OAuth2 : test de l'algorithme JWT accepté (rejet de 'none', HMAC vs RSA), force de la clé secrète, validation de la signature, vérification des claims exp/iat/iss, test de scopes OAuth2 insuffisamment vérifiés dans les handlers.
- Test IDOR et contrôles d'accès aux ressources : test d'accès aux ressources d'autres utilisateurs via manipulation des IDs dans les paramètres de chemin (/users/{user_id}/data) et de requête ; vérification que les requêtes sont scopées à l'utilisateur authentifié.
- Tests d'injection via les paramètres de requête et body : tests SQLi sur les paramètres filtrés transmis à SQLAlchemy ou requêtes brutes, SSRF via les paramètres URL, injection de commandes si des paramètres sont passés à subprocess ou os.system.
- Sécurité des CORS et des en-têtes HTTP : vérification de la configuration CORS (origines autorisées, allow_credentials), des en-têtes de sécurité (HSTS, X-Content-Type-Options, X-Frame-Options, CSP), et des en-têtes exposant des informations de version serveur.
- Test de rate-limiting et de protection contre la force brute : vérification de l'implémentation de rate-limiting sur les endpoints d'authentification, d'inscription et de reset de mot de passe ; test de contournement via rotation d'IP, manipulation d'en-têtes X-Forwarded-For.
Exemple de finding
Déni de service via python-multipart sur l'endpoint d'upload (CVE-2024-24762)
L'endpoint POST /api/v1/files/upload utilise le paramètre FastAPI File(). La version python-multipart installée (0.0.6) est affectée par CVE-2024-24762. Lors du test, l'envoi d'une requête multipart/form-data avec un en-tête Content-Disposition contenant un nom de champ de 50 000 caractères construits spécifiquement a provoqué une consommation CPU de 100 % pendant 45 secondes, rendant l'application non responsive pour tous les utilisateurs. L'endpoint est accessible sans authentification (utilisé pour les uploads publics), amplifiant le risque d'exploitation.
Correction : Mettre à jour python-multipart vers la version 0.0.7+ (corrige CVE-2024-24762). Mettre à jour FastAPI vers la dernière version stable pour obtenir les dépendances patchées automatiquement. Implémenter des limites de taille sur tous les endpoints d'upload (max_size parameter ou middleware de limitation de taille de corps). Ajouter un rate-limiting sur les endpoints d'upload même publics (ex. 10 requêtes/minute par IP via slowapi). Référence : CVE-2024-24762, python-multipart GitHub Security Advisory.
Référence : CVE-2024-24762 (python-multipart DoS) · CVE-2023-30798 (Starlette) · OWASP A05:2021 Security Misconfiguration · CWE-400 Uncontrolled Resource Consumption
Pentest FastAPI : comparaison des options
| — | Scan gratuit | Matproof Sentinel | Consultance classique |
|---|---|---|---|
| Moteur de scan automatisé | ✓ (aperçu 3 min) | ✓ Scan complet | ✗ Manuel uniquement |
| Couverture OWASP Top 10 | Partielle | ✓ Complète | ✓ Complète |
| Preuve d'exploitation | ✗ | ✓ Par finding | ✓ Par finding |
| Mapping réglementaire (DORA/NIS2/ISO 27001) | ✗ | ✓ Automatisé | ✓ Manuel |
| Rapport PDF prêt pour l'audit | ✗ | ✓ Instantané | ✓ Livraison 2–4 semaines |
| Scans continus / récurrents | ✗ | ✓ Par déploiement | ✗ Engagement annuel |
| Délai avant premier résultat | ~3 min | ~30 min scan complet | 2–4 semaines |
| Prix | €0 | À partir de €149 | €8 000–€25 000 |
| Revue de code source (SAST) | ✗ | ✓ Plan Growth | ✓ Périmètre défini |
| Tests API (REST/GraphQL) | ✗ | ✓ Automatisé | ✓ Manuel |
Offres de pentest FastAPI
- 1 scan pentest complet
- Résultats priorisés par IA avec CVSS 3.1
- Proof-of-exploit pour chaque finding
- Rapport PDF (prêt pour l'audit)
- Mapping réglementaire (DORA, NIS2, ISO 27001)
- Scans illimités (jusqu'à 3 domaines)
- Surveillance continue
- Intégration CI/CD (GitHub, GitLab)
- Tous les mappings réglementaires
- Support prioritaire
- Scans + domaines illimités
- Tests authentifiés / White-Box
- Tests d'API et d'infrastructure cloud
- Account manager sécurité dédié
- SLA réponse 24h
Questions fréquentes sur le test d'intrusion FastAPI
FastAPI est-il sécurisé par défaut ou nécessite-t-il une configuration de sécurité manuelle ?
FastAPI fournit d'excellents outils de sécurité (utilitaires OAuth2, HTTPBearer, APIKey) mais n'impose aucune sécurité par défaut : chaque endpoint est accessible sans authentification à moins qu'un Depends() de sécurité ne soit explicitement ajouté. La documentation Swagger UI (/docs) est activée par défaut. La validation Pydantic protège contre les types incorrects mais pas contre les accès non autorisés. En résumé : FastAPI facilite l'implémentation de la sécurité mais ne la fournit pas automatiquement — la responsabilité incombe entièrement au développeur.
Comment CVE-2024-24762 affecte-t-il concrètement une application FastAPI et comment s'en protéger ?
CVE-2024-24762 affecte les applications FastAPI utilisant les paramètres File() ou Form() dans leurs endpoints, qui utilisent python-multipart pour parser les corps multipart/form-data. Un attaquant envoie une requête avec un champ form malformé contenant un nom très long ou une structure récursive spécialement conçue, provoquant un traitement CPU excessif. Protection : (1) mettre à jour python-multipart vers 0.0.7+ ; (2) limiter la taille maximale des corps de requête via un middleware ; (3) implémenter un rate-limiting sur les endpoints acceptant des données multipart.
Faut-il désactiver la documentation OpenAPI (/docs) en production ?
C'est fortement recommandé pour les APIs non publiques. La documentation Swagger UI expose l'intégralité de la structure de votre API à quiconque y accède, facilitant considérablement le travail d'un attaquant en phase de reconnaissance. Pour désactiver : définir docs_url=None et redoc_url=None dans le constructeur FastAPI(). Si la documentation est nécessaire pour des équipes internes, la protéger avec une authentification Basic ou la restreindre aux IPs internes via un reverse proxy (Nginx). Pour les APIs publiques avec documentation intentionnellement exposée, s'assurer que les exemples dans la documentation ne contiennent pas de données réelles ou de tokens valides.
Comment implémenter correctement l'authentification JWT dans FastAPI ?
Implémentation sécurisée JWT dans FastAPI : (1) utiliser l'algorithme RS256 (asymétrique) plutôt qu'HS256 en production — la clé privée signe, la clé publique vérifie, réduisant le risque de compromission ; (2) valider systématiquement les claims exp, iat, iss et sub dans chaque requête ; (3) implémenter une liste noire des tokens révoqués (Redis ou base de données) pour la déconnexion effective ; (4) utiliser des durées de vie courtes (15-60 minutes pour l'access token, 7-30 jours pour le refresh token avec rotation) ; (5) stocker les clés JWT dans des variables d'environnement chiffrées, jamais en dur dans le code.
Comment prévenir les injections SQL dans FastAPI avec SQLAlchemy ?
Avec SQLAlchemy ORM : utilisez toujours les requêtes paramétrées via l'ORM (session.query(User).filter(User.id == user_id)) — l'ORM paramètre automatiquement. Pour les requêtes brutes : utilisez text() avec des paramètres nommés (session.execute(text('SELECT * FROM users WHERE id = :id'), {'id': user_id})) — jamais de concaténation de chaînes. Évitez db.execute(f'SELECT * FROM users WHERE id = {user_id}'). Les filtres dynamiques (ORDER BY, table names) nécessitent une validation par liste blanche car les paramètres SQLAlchemy ne couvrent pas les identifiants SQL. Matproof teste spécifiquement les constructions de requêtes brutes dans le code FastAPI.
Quelle est la différence entre un pentest FastAPI et un pentest d'API REST générique ?
Un pentest d'API REST générique couvre les classes OWASP API Top 10 indépendamment du framework. Un pentest FastAPI spécialisé adresse en plus : la validation des dépendances Python avec CVE spécifiques à l'écosystème (FastAPI, Starlette, Uvicorn, Pydantic), la vérification exhaustive des Depends() manquants sur tous les endpoints (via introspection du graphe de routes OpenAPI), les risques de validation Pydantic (ReDoS, stack overflow sur schémas complexes), et les configurations ASGI/Uvicorn spécifiques (nombre de workers, timeout, limites de taille).
Comment sécuriser les CORS dans FastAPI pour une API consommée par un frontend ?
Configuration CORS sécurisée dans FastAPI : (1) n'utiliser jamais allow_origins=['*'] avec allow_credentials=True — cela est invalide selon le standard CORS et certaines implémentations peuvent se comporter de manière inattendue ; (2) spécifier explicitement les origines autorisées (ex. ['https://app.example.com', 'https://admin.example.com']) ; (3) lister uniquement les méthodes HTTP nécessaires (allow_methods=['GET', 'POST', 'PUT', 'DELETE']) ; (4) en développement, utiliser allow_origins=['http://localhost:3000'] et ne pas commiter cette configuration en production ; (5) les APIs purement backend (consommées uniquement par d'autres services, pas par des navigateurs) n'ont généralement pas besoin de CORS.
Quelle fréquence de pentest est recommandée pour une API FastAPI en production ?
Pour les APIs FastAPI en production exposant des données sensibles ou traitant des paiements : pentest complet au lancement et après chaque changement architectural majeur, plus un test ciblé trimestriel pour les APIs à fort trafic. La surveillance continue via Matproof Sentinel est particulièrement pertinente pour les APIs Python car le rythme des CVE dans l'écosystème Python (Pydantic, Starlette, Uvicorn, cryptography) est élevé. Une nouvelle vulnérabilité dans une dépendance transitive peut introduire un risque sans qu'aucun changement de code applicatif n'ait été effectué.
Approfondir — articles de blog associés
Démarrez votre test d'intrusion FastAPI maintenant
Vérifiez en quelques minutes si votre API FastAPI est exposée à des vulnérabilités de déni de service, des dépendances Python vulnérables ou des failles d'authentification. Rapport audit-ready en français, aucune installation requise.
Démarrer le pentest FastAPI