A single character — a forward slash, a question mark, or a hash — is all an attacker needs to silently bypass authentication in FastAPI, vLLM, LiteLLM, and thousands of AI agent servers deployed worldwide. CVE-2026-48710, dubbed BadHost, spent four months undetected in Starlette (the ASGI framework that powers FastAPI) before receiving a patch on May 21, 2026. With 325 million weekly Starlette downloads and 38% of professional Python developers now using FastAPI, the blast radius is difficult to overstate.

Un seul caractère — un slash, un point d'interrogation, ou un dièse — suffit à un attaquant pour contourner silencieusement l'authentification dans FastAPI, vLLM, LiteLLM et des milliers de serveurs d'agents IA déployés dans le monde. CVE-2026-48710, surnommé BadHost, a passé quatre mois non détecté dans Starlette (le framework ASGI qui propulse FastAPI) avant de recevoir un correctif le 21 mai 2026. Avec 325 millions de téléchargements Starlette par semaine et 38% des développeurs Python professionnels utilisant désormais FastAPI, l'étendue de l'impact est difficile à surestimer.

This guide covers every significant FastAPI security vulnerability disclosed in 2026: the BadHost authentication bypass, Pydantic AI SSRF chains, ormar validation bypass, the malicious fastar typosquat injected into FastAPI 0.136.3, and the async dependency injection pitfalls that silently leak credentials in production. Each section includes verified CVEs, real exploit patterns, and actionable mitigations.

Ce guide couvre toutes les vulnérabilités de sécurité FastAPI significatives divulguées en 2026 : le bypass d'authentification BadHost, les chaînes SSRF Pydantic AI, le bypass de validation ormar, le typosquat malveillant fastar injecté dans FastAPI 0.136.3, et les pièges d'injection de dépendances asynchrones qui fuient silencieusement des credentials en production. Chaque section inclut des CVE vérifiées, des patterns d'exploitation réels et des mitigations actionnables.

118M
FastAPI weekly downloads (PyPI)
Téléchargements FastAPI/semaine (PyPI)
Source: PyPI Stats, 2026
325M
Starlette weekly downloads — BadHost blast radius
Téléchargements Starlette/semaine — rayon d'impact BadHost
Source: OSTIF / InfoWorld, 2026
38%
Professional Python developers using FastAPI
Développeurs Python professionnels utilisant FastAPI
Source: programming-helper.com, 2026

CVE-2026-48710 BadHost: One Character That Bypasses Your Entire Auth Layer

CVE-2026-48710 BadHost : Un Caractère qui Contourne Toute Votre Couche d'Auth

BadHost is the most impactful FastAPI-related vulnerability of 2026. It was discovered on January 27, 2026 by X41 D-Sec researchers during an OSTIF-sponsored security audit of vLLM, and it does not affect FastAPI directly — it affects Starlette, the underlying ASGI framework on which FastAPI is built.

BadHost est la vulnérabilité la plus impactante liée à FastAPI en 2026. Elle a été découverte le 27 janvier 2026 par les chercheurs de X41 D-Sec lors d'un audit de sécurité sponsorisé par l'OSTIF sur vLLM, et n'affecte pas directement FastAPI — elle affecte Starlette, le framework ASGI sous-jacent sur lequel FastAPI est construit.

CVE-2026-48710 CVSS 6.5 Medium (Researchers: impact understated)
Starlette < 1.0.1 — Discovered Jan 27 2026 (X41 D-Sec / OSTIF) — Patched May 21 2026
In Starlette versions before 1.0.1, the HTTP Host request header was not validated before being used to reconstruct request.url. A Host header containing /, ?, or # shifts the URL parsing boundaries: request.url.path no longer matches the path the ASGI server actually received and routed against. Any middleware or route guard that compares against request.url.path can be bypassed by an unauthenticated attacker with a single injected character.
Dans les versions de Starlette antérieures à 1.0.1, l'en-tête HTTP Host n'était pas validé avant d'être utilisé pour reconstruire request.url. Un en-tête Host contenant /, ? ou # déplace les limites d'analyse d'URL : request.url.path ne correspond plus au chemin que le serveur ASGI a réellement reçu et utilisé pour router. Tout middleware ou garde de route comparant à request.url.path peut être contourné par un attaquant non authentifié avec un seul caractère injecté.

How the Attack Works

Comment fonctionne l'attaque

The vulnerability exploits how Starlette reconstructs request.url from the Host header. When an attacker sends a request like:

La vulnérabilité exploite la façon dont Starlette reconstruit request.url à partir de l'en-tête Host. Quand un attaquant envoie une requête comme :

# Attacker sends this request to /admin/users (a protected endpoint) GET /admin/users HTTP/1.1 Host: evil.com/api Authorization: (none) # Starlette reconstructs request.url as: # http://evil.com/api/admin/users # So request.url.path becomes: /api/admin/users # But the ASGI router routed to: /admin/users # # Any middleware checking request.url.path == "/admin/users" → MISS # Authentication bypass achieved.

The affected pattern — using request.url.path in security-relevant code — was common in middleware, route guards, and auth dependencies across FastAPI, vLLM, LiteLLM, MCP servers, and most OpenAI shim proxies. The official CVSS score of 6.5 is widely regarded as an underestimate given the concentration of high-value AI workloads running on Starlette in 2026.

Le pattern affecté — utiliser request.url.path dans du code critique pour la sécurité — était commun dans les middleware, les gardes de routes et les dépendances d'auth à travers FastAPI, vLLM, LiteLLM, les serveurs MCP et la plupart des proxies OpenAI shim. Le score CVSS officiel de 6,5 est largement considéré comme une sous-estimation étant donné la concentration de charges de travail IA à haute valeur fonctionnant sur Starlette en 2026.

BadHost Discovery Timeline
Chronologie de la découverte BadHost
Jan 27, 2026 X41 D-Sec discovers BadHost during OSTIF-sponsored vLLM security audit X41 D-Sec découvre BadHost lors de l'audit sécurité vLLM sponsorisé par l'OSTIF
Feb 4, 2026 Starlette maintainers notified Notification des mainteneurs Starlette
Mar 1, 2026 Patch proposed — does not ship Patch proposé — ne sort pas
May 21, 2026 Starlette 1.0.1 released with fix — 4-month exposure window closes Starlette 1.0.1 publié avec le correctif — fenêtre d'exposition de 4 mois fermée
May 2026 Public disclosure — InfoWorld, CSO Online, OSTIF, CCB Belgium advisories Divulgation publique — advisories InfoWorld, CSO Online, OSTIF, CCB Belgique

Remediation: Two Steps Required

Remédiation : Deux étapes requises

# Step 1: Upgrade Starlette pip install "starlette>=1.0.1" # Or via FastAPI: pip install "fastapi[standard]>=0.115.0" # Step 2: Fix every security-relevant path check in your code # VULNERABLE — do not use: if request.url.path.startswith("/admin"): raise HTTPException(401) # SAFE — use scope["path"] instead: if request.scope["path"].startswith("/admin"): raise HTTPException(401)

Even after upgrading Starlette, audit your codebase for any occurrence of request.url.path in middleware, auth guards, or decorators. The ASGI scope path (request.scope["path"]) reflects what the server actually routed — it cannot be shifted by a manipulated Host header.

Même après la mise à niveau de Starlette, auditez votre code pour toute occurrence de request.url.path dans les middleware, les gardes d'auth ou les décorateurs. Le chemin du scope ASGI (request.scope["path"]) reflète ce que le serveur a réellement routé — il ne peut pas être déplacé par un en-tête Host manipulé.

CVE-2026-25580 & CVE-2026-46678: Pydantic AI SSRF Chain

CVE-2026-25580 & CVE-2026-46678 : Chaîne SSRF Pydantic AI

Pydantic AI — the agentic framework built on top of Pydantic v2 and used by many FastAPI-based AI applications — suffered two related Server-Side Request Forgery vulnerabilities in 2026. These are distinct from Pydantic v2 core (which has no 2026 CVEs).

Pydantic AI — le framework agentique construit au-dessus de Pydantic v2 et utilisé par de nombreuses applications IA basées sur FastAPI — a subi deux vulnérabilités de type Server-Side Request Forgery liées en 2026. Celles-ci sont distinctes de Pydantic v2 core (qui n'a aucun CVE 2026).

CVE-2026-25580 SSRF
Pydantic AI 0.0.26 – < 1.56.0 — Cloud metadata blocklist bypass
Pydantic AI's cloud-metadata access protection relied on a blocklist that could be bypassed when force_download='allow-local' was enabled. An attacker-controlled URL could reach internal cloud metadata endpoints (AWS IMDS, GCP metadata server) to exfiltrate credentials.
La protection d'accès aux métadonnées cloud de Pydantic AI reposait sur une liste de blocage qui pouvait être contournée quand force_download='allow-local' était activé. Une URL contrôlée par un attaquant pouvait atteindre les endpoints de métadonnées cloud internes (AWS IMDS, serveur métadonnées GCP) pour exfiltrer des credentials.
CVE-2026-46678 SSRF
Pydantic AI — Incomplete fix of CVE-2026-25580
The fix for CVE-2026-25580 was incomplete: the cloud-metadata blocklist could still be bypassed by encoding the metadata server IP address in IPv4-mapped IPv6 notation (e.g., ::ffff:169.254.169.254 for AWS IMDS). Upgrade to Pydantic AI 1.57.0+ which validates both IPv4 and mapped IPv6 forms.
Le correctif pour CVE-2026-25580 était incomplet : la liste de blocage des métadonnées cloud pouvait toujours être contournée en encodant l'adresse IP du serveur de métadonnées en notation IPv6 mappée sur IPv4 (ex : ::ffff:169.254.169.254 pour AWS IMDS). Mettez à niveau vers Pydantic AI 1.57.0+ qui valide les formes IPv4 et IPv6 mappées.
Impact on FastAPI + Pydantic AI Stacks
Impact sur les stacks FastAPI + Pydantic AI

If your FastAPI application uses Pydantic AI agents that fetch external URLs (document loaders, tool calls, web browsing agents), and those agents run with force_download='allow-local', an attacker who can control agent inputs can reach your cloud metadata server and steal your instance credentials. This is particularly dangerous in multi-tenant AI applications where user input reaches agent tool parameters.

Si votre application FastAPI utilise des agents Pydantic AI qui récupèrent des URLs externes (chargeurs de documents, appels d'outils, agents de navigation web), et que ces agents s'exécutent avec force_download='allow-local', un attaquant qui peut contrôler les entrées des agents peut atteindre votre serveur de métadonnées cloud et voler vos credentials d'instance. C'est particulièrement dangereux dans les applications IA multi-locataires où l'entrée utilisateur atteint les paramètres des outils d'agent.

CVE-2026-27953: ormar Pydantic Validation Bypass

CVE-2026-27953 : Bypass de Validation Pydantic ormar

CVE-2026-27953 Validation Bypass
ormar ORM (FastAPI-native async ORM) — Pydantic model constructor injection
In ormar's model constructor, unauthenticated users can skip all Pydantic field validation by injecting "__pk_only__": true or "__excluded__": ["field_name"] into a JSON request body. FastAPI deserializes the JSON body and passes keyword arguments to the model constructor — ormar's constructor passes all kwargs through without filtering private Pydantic dunder fields. The unvalidated data is subsequently persisted to the database, bypassing type checks, validators, and constraint enforcement.
Dans le constructeur de modèle d'ormar, les utilisateurs non authentifiés peuvent contourner toute validation de champ Pydantic en injectant "__pk_only__": true ou "__excluded__": ["field_name"] dans un corps JSON. FastAPI désérialise le corps JSON et passe les arguments mot-clé au constructeur du modèle — le constructeur d'ormar transmet tous les kwargs sans filtrer les champs dunder Pydantic privés. Les données non validées sont ensuite persistées en base de données, contournant les vérifications de type, les validateurs et l'application des contraintes.
# Exploit example: POST /users with crafted body { "username": "attacker", "email": "attacker@evil.com", "__pk_only__": true, "__excluded__": ["is_admin", "email_verified"] } # Result: ormar skips validation on excluded fields. # is_admin and email_verified default to True (model defaults). # Attacker gets an admin account with a verified email.

The fix is to upgrade ormar and strictly validate request bodies using FastAPI's BaseModel schemas as input types (not ormar models directly), ensuring that only explicitly declared fields from your Pydantic schema are ever deserialized from user input.

Le correctif consiste à mettre à niveau ormar et à valider strictement les corps de requête en utilisant les schémas BaseModel de FastAPI comme types d'entrée (pas les modèles ormar directement), garantissant que seuls les champs explicitement déclarés de votre schéma Pydantic sont jamais désérialisés depuis l'entrée utilisateur.

FastAPI 0.136.3: The Malicious fastar Typosquat

FastAPI 0.136.3 : Le Typosquat Malveillant fastar

In 2026, FastAPI version 0.136.3 was found to include an undocumented dependency — fastar>=0.9.0 — designed as a typosquat against the legitimate faster-api package. When users installed FastAPI with the standard extras (pip install fastapi[standard]), the malicious package was pulled in automatically, enabling arbitrary code execution at install time via a setup.py postinstall hook.

En 2026, FastAPI version 0.136.3 a été trouvée avec une dépendance non documentée — fastar>=0.9.0 — conçue comme un typosquat contre le package légitime faster-api. Quand les utilisateurs installaient FastAPI avec les extras standard (pip install fastapi[standard]), le package malveillant était téléchargé automatiquement, permettant une exécution de code arbitraire à l'installation via un hook postinstall setup.py.

Check if You Were Affected
Vérifiez si vous êtes affecté
# Check your installed FastAPI version history pip show fastapi | grep Version # If you ever had 0.136.3 installed, check for fastar: pip show fastar 2>/dev/null && echo "COMPROMISED - remove immediately" || echo "OK" # Remediation: pip uninstall fastar -y pip install "fastapi[standard]>=0.136.4"

FastAPI Async Security Pitfalls: Dependency Injection Gone Wrong

Pièges Sécurité Async FastAPI : L'Injection de Dépendances qui Tourne Mal

FastAPI's dependency injection system is one of its greatest strengths — and one of its most common sources of subtle security bugs in production. These vulnerabilities are not CVEs, but they cause real credential leaks and authorization failures in deployed applications.

Le système d'injection de dépendances de FastAPI est l'un de ses plus grands atouts — et l'une des sources les plus communes de bugs de sécurité subtils en production. Ces vulnérabilités ne sont pas des CVE, mais elles causent de vraies fuites de credentials et des échecs d'autorisation dans les applications déployées.

Pitfall 1: Database Sessions Surviving Request Boundaries

Piège 1 : Les Sessions Base de Données Survivant aux Frontières de Requête

# VULNERABLE: Session not properly closed on exceptions async def get_db(): db = SessionLocal() yield db # If the route raises an exception, db.close() is never called # SAFE: Always close in finally block async def get_db(): db = SessionLocal() try: yield db finally: await db.close()

When database sessions are not properly closed on exceptions, they accumulate in the connection pool. At pool exhaustion, subsequent requests block — and in some ORM configurations, may inherit the session state (including uncommitted transactions) of a previous request. This is the FastAPI async pattern that most frequently causes connection pool leaks in production SQLAlchemy or asyncpg applications.

Quand les sessions de base de données ne sont pas correctement fermées lors des exceptions, elles s'accumulent dans le pool de connexions. À l'épuisement du pool, les requêtes suivantes se bloquent — et dans certaines configurations ORM, peuvent hériter de l'état de session (y compris les transactions non committées) d'une requête précédente. C'est le pattern async FastAPI qui cause le plus souvent des fuites de pool de connexions dans les applications SQLAlchemy ou asyncpg en production.

Pitfall 2: Returning Raw Database Models in Responses

Piège 2 : Retourner des Modèles Base de Données Bruts dans les Réponses

# VULNERABLE: Returning ORM model directly exposes internal fields @app.get("/user/{user_id}") async def get_user(user_id: int, db: Session = Depends(get_db)): user = await db.get(User, user_id) return user # Exposes: password_hash, internal_flags, db metadata # SAFE: Use a Pydantic response model to filter fields class UserResponse(BaseModel): id: int username: str email: str @app.get("/user/{user_id}", response_model=UserResponse) async def get_user(user_id: int, db: Session = Depends(get_db)): return await db.get(User, user_id)

Pitfall 3: Debug Mode and Stack Traces in Production

Piège 3 : Mode Debug et Stack Traces en Production

FastAPI's default exception handler returns the full exception detail in the HTTP response. When SQLAlchemy throws an error on a misconfigured query, the stack trace in the response body may include the database connection string (host, port, database name, credentials). Always configure a custom exception handler for production that returns generic error messages without internal details.

Le gestionnaire d'exceptions par défaut de FastAPI retourne le détail complet de l'exception dans la réponse HTTP. Quand SQLAlchemy lance une erreur sur une requête mal configurée, la stack trace dans le corps de la réponse peut inclure la chaîne de connexion à la base de données (hôte, port, nom de base, credentials). Configurez toujours un gestionnaire d'exceptions personnalisé en production qui retourne des messages d'erreur génériques sans détails internes.

from fastapi import FastAPI, Request from fastapi.responses import JSONResponse app = FastAPI() @app.exception_handler(Exception) async def generic_exception_handler(request: Request, exc: Exception): # Log the full exception internally (to your observability stack) logger.exception("Unhandled exception", exc_info=exc) # Return a generic response — no stack trace exposed return JSONResponse(status_code=500, content={"detail": "Internal server error"})

FastAPI Production Security Hardening Checklist 2026

Checklist Durcissement Sécurité FastAPI Production 2026

Beyond patching CVEs, hardening a FastAPI application for production requires addressing its deployment context. FastAPI itself is intentionally minimal — security is not enabled by default and must be actively configured.

Au-delà du patching des CVE, durcir une application FastAPI pour la production nécessite d'adresser son contexte de déploiement. FastAPI lui-même est intentionnellement minimal — la sécurité n'est pas activée par défaut et doit être configurée activement.

  • Upgrade to Starlette 1.0.1+ immediately — fixes CVE-2026-48710 BadHost
  • Mettre à niveau Starlette 1.0.1+ immédiatement — corrige CVE-2026-48710 BadHost
  • Replace all request.url.path with request.scope["path"] in security-sensitive code
  • Remplacer tout request.url.path par request.scope["path"] dans le code sensible à la sécurité
  • Deploy behind a reverse proxy (Nginx, Traefik, Caddy) — never expose uvicorn directly. Offload SSL, CORS, and rate limiting to the proxy layer
  • Déployer derrière un reverse proxy (Nginx, Traefik, Caddy) — ne jamais exposer uvicorn directement. Externaliser SSL, CORS et rate limiting vers la couche proxy
  • Enforce HTTPS everywhere — HTTP tokens transmitted in plaintext are a trivial intercept target
  • Forcer HTTPS partout — les tokens HTTP en clair sont une cible d'interception triviale
  • Pin your dependency versions — lockfile pinning catches typosquat injections like the fastar incident
  • Verrouiller les versions de dépendances — le pinning de lockfile détecte les injections de typosquats comme l'incident fastar
  • Always use response_model on every endpoint to filter internal ORM fields from responses
  • Toujours utiliser response_model sur chaque endpoint pour filtrer les champs ORM internes des réponses
  • Wrap yield dependencies in try/finally blocks to ensure database sessions always close
  • Encapsuler les dépendances yield dans des blocs try/finally pour garantir la fermeture des sessions de base de données
  • Configure a global exception handler that logs internally but returns generic responses — no stack traces in HTTP responses
  • Configurer un gestionnaire d'exceptions global qui journalise en interne mais retourne des réponses génériques — pas de stack traces dans les réponses HTTP
  • Use Pydantic BaseModel schemas (not ORM models) as endpoint input types — prevents ormar-style validation bypass patterns
  • Utiliser les schémas BaseModel Pydantic (pas les modèles ORM) comme types d'entrée des endpoints — prévient les patterns de bypass de validation de type ormar
  • If using Pydantic AI with force_download='allow-local', upgrade to Pydantic AI 1.57.0+ and add explicit IP range blocking for cloud metadata endpoints
  • Si vous utilisez Pydantic AI avec force_download='allow-local', mettez à niveau vers Pydantic AI 1.57.0+ et ajoutez un blocage explicite des plages IP pour les endpoints de métadonnées cloud
  • Audit your Pydantic AI agent tool parameters — user-controlled inputs that reach HTTP tool calls are SSRF vectors
  • Auditer les paramètres d'outils de vos agents Pydantic AI — les entrées contrôlées par l'utilisateur qui atteignent les appels d'outils HTTP sont des vecteurs SSRF
  • Scan your requirements.txt and pyproject.toml with pip-audit in CI/CD on every commit
  • Scanner votre requirements.txt et pyproject.toml avec pip-audit dans le CI/CD à chaque commit
4 mo.
BadHost exposure window before patch (Jan 27 – May 21, 2026)
Fenêtre d'exposition BadHost avant patch (27 jan. – 21 mai 2026)
Source: OSTIF / X41 D-Sec, 2026
50%+
Fortune 500 companies using FastAPI in production (mid-2025)
Entreprises Fortune 500 utilisant FastAPI en production (mi-2025)
Source: programming-helper.com, 2026

Frequently Asked Questions

Questions fréquentes

Is FastAPI itself vulnerable to CVE-2026-48710 BadHost?

FastAPI lui-même est-il vulnérable à CVE-2026-48710 BadHost ?

Not directly. BadHost is a vulnerability in Starlette, the ASGI framework that FastAPI is built on. However, since FastAPI inherits Starlette's request URL reconstruction, any FastAPI application that uses request.url.path in security-relevant middleware or route guards is effectively vulnerable. Upgrade Starlette to 1.0.1+ (bundled with FastAPI 0.115.0+) and replace request.url.path with request.scope["path"] in your code.

Pas directement. BadHost est une vulnérabilité dans Starlette, le framework ASGI sur lequel FastAPI est construit. Cependant, puisque FastAPI hérite de la reconstruction d'URL de Starlette, toute application FastAPI qui utilise request.url.path dans des middleware ou gardes de routes critiques pour la sécurité est effectivement vulnérable. Mettez à niveau Starlette vers 1.0.1+ (inclus dans FastAPI 0.115.0+) et remplacez request.url.path par request.scope["path"] dans votre code.

Does upgrading FastAPI automatically fix BadHost?

La mise à niveau de FastAPI corrige-t-elle automatiquement BadHost ?

Partially. FastAPI 0.115.0+ depends on Starlette 1.0.1+, so upgrading FastAPI upgrades Starlette and patches the URL reconstruction bug. However, you still need to audit your own code for any use of request.url.path in security-sensitive contexts. The Starlette library fix is necessary but not sufficient if your application contains the vulnerable pattern.

Partiellement. FastAPI 0.115.0+ dépend de Starlette 1.0.1+, donc mettre à niveau FastAPI met à niveau Starlette et patche le bug de reconstruction d'URL. Cependant, vous devez toujours auditer votre propre code pour toute utilisation de request.url.path dans des contextes sensibles à la sécurité. Le correctif de la bibliothèque Starlette est nécessaire mais pas suffisant si votre application contient le pattern vulnérable.

Is Pydantic v2 core safe to use in 2026?

Pydantic v2 core est-il sûr à utiliser en 2026 ?

Yes. Pydantic v2 core (the pydantic package) has zero CVEs in 2026. The SSRF vulnerabilities (CVE-2026-25580, CVE-2026-46678) affect the separate pydantic-ai package — the agentic AI framework — not Pydantic's data validation engine. If you only use Pydantic for input validation in FastAPI, you are not affected by these CVEs. If you use Pydantic AI agents with URL fetching capabilities, upgrade to Pydantic AI 1.57.0+.

Oui. Pydantic v2 core (le package pydantic) a zéro CVE en 2026. Les vulnérabilités SSRF (CVE-2026-25580, CVE-2026-46678) affectent le package séparé pydantic-ai — le framework d'IA agentique — pas le moteur de validation des données de Pydantic. Si vous utilisez uniquement Pydantic pour la validation des entrées dans FastAPI, vous n'êtes pas affecté par ces CVE. Si vous utilisez des agents Pydantic AI avec des capacités de récupération d'URL, mettez à niveau vers Pydantic AI 1.57.0+.

Should FastAPI applications use Pydantic models or ORM models as route input types?

Les applications FastAPI doivent-elles utiliser des modèles Pydantic ou des modèles ORM comme types d'entrée des routes ?

Always use dedicated Pydantic BaseModel schemas for route input and output — never expose ORM models directly to the HTTP layer. ORM models carry internal fields (database primary keys, relationship lazy-load flags, internal state markers) that can be exploited through injection patterns like CVE-2026-27953. Create separate CreateSchema, UpdateSchema, and ResponseSchema Pydantic models for each resource, and validate that only expected fields are accepted.

Utilisez toujours des schémas BaseModel Pydantic dédiés pour les entrées et sorties de routes — n'exposez jamais les modèles ORM directement à la couche HTTP. Les modèles ORM portent des champs internes (clés primaires de base de données, drapeaux de chargement paresseux de relations, marqueurs d'état interne) qui peuvent être exploités via des patterns d'injection comme CVE-2026-27953. Créez des modèles Pydantic CreateSchema, UpdateSchema et ResponseSchema séparés pour chaque ressource, et validez que seuls les champs attendus sont acceptés.

How do I continuously monitor my FastAPI dependencies for new CVEs?

Comment surveiller en continu mes dépendances FastAPI pour les nouvelles CVE ?

Run pip-audit in CI/CD on every commit — it queries the OSV database and covers PyPI vulnerabilities including Starlette, FastAPI, and Pydantic. For continuous monitoring (not just CI gates), tools like CVE OptiBot scan your lockfiles daily and alert you when new CVEs affect your exact pinned versions — catching vulnerabilities like BadHost before your next CI run.

Exécutez pip-audit dans le CI/CD à chaque commit — il interroge la base de données OSV et couvre les vulnérabilités PyPI incluant Starlette, FastAPI et Pydantic. Pour un monitoring continu (pas seulement les gates CI), des outils comme CVE OptiBot scannent vos lockfiles quotidiennement et vous alertent quand de nouvelles CVE affectent vos versions exactes pinned — détectant les vulnérabilités comme BadHost avant votre prochain run CI.

Monitor Your FastAPI Dependencies Automatically

Surveillez vos Dépendances FastAPI Automatiquement

CVE OptiBot scans your requirements.txt, Pipfile.lock, and pyproject.toml daily against the OSV database. Get alerted the moment a new CVE like BadHost affects your exact pinned versions — before attackers do.

CVE OptiBot scanne votre requirements.txt, Pipfile.lock et pyproject.toml quotidiennement contre la base de données OSV. Soyez alerté dès qu'une nouvelle CVE comme BadHost affecte vos versions exactement pinned — avant les attaquants.

Start free monitoring Démarrer le monitoring gratuit
Python Security Vulnerabilities 2026 → Vulnérabilités Sécurité Python 2026 → pip-audit & Safety CLI Guide → Guide pip-audit & Safety CLI → Django ORM Security 2026 → Sécurité Django ORM 2026 → CVE Monitoring → Monitoring CVE → Python Vulnerabilities → Vulnérabilités Python →