Une faille critique du SDK Python MCP expose les identifiants OAuth à des serveurs malveillants

Une vulnérabilité de sécurité critique dans le SDK Python officiel du Model Context Protocol (MCP) permet à des serveurs MCP malveillants de voler des identifiants OAuth aux clients connectés. La faille, révélée le 28 septembre 2026, affecte les versions 1.9.1 à 1.29.1 et 2.0.0 à 2.1.1, permettant aux attaquants d'intercepter les secrets clients, les codes d'autorisation et les clés de preuve PKCE.

Ce qui s'est passé

Les mainteneurs du SDK Python MCP ont publié un avis de sécurité après que des chercheurs de Cycode ont démontré comment un serveur malveillant pouvait tromper une application pour qu'elle transmette des données d'authentification sensibles. Lorsqu'un client MCP tente de se connecter, il demande au serveur connecté l'emplacement de son serveur d'autorisation. Dans les versions affectées, le SDK ne validait pas strictement cette réponse.

Un serveur malveillant pouvait diriger le client vers un point de terminaison contrôlé par l'attaquant ou fournir des détails de connexion semblant légitimes mais routant les identifiants ailleurs. Par conséquent, le client envoyait son secret client de longue durée, son code d'autorisation à usage unique et sa clé de preuve PKCE à l'attaquant. Avec ces identifiants, l'attaquant pouvait demander un jeton d'accès valide auprès du véritable service de connexion, obtenant ainsi toutes les permissions détenues par l'application originale.

La gravité de la faille dépend du fournisseur OAuth utilisé. Pour les fournisseurs machine-à-machine fonctionnant sans intervention humaine, le risque est évalué comme élevé avec un score de 7,5. Pour les fournisseurs interactifs nécessitant une connexion utilisateur, le score est de 6,5, bien que l'utilisateur approuve toujours la connexion sur une page d'apparence authentique. Aucun CVE n'avait été attribué au 29 septembre 2026, et aucune exploitation active n'a été signalée dans la nature.

Comment cela fonctionne

Le problème central réside dans la manière dont le SDK gère la découverte du serveur d'autorisation. Lors du flux OAuth, le client compte sur le serveur MCP pour spécifier où envoyer les demandes d'authentification. Les versions vulnérables du SDK ne vérifiaient pas si le serveur d'autorisation spécifié correspondait à l'émetteur attendu avant d'envoyer les identifiants.

Ce manque de validation a permis à un serveur malveillant de rediriger l'échange d'identifiants. Même avec PKCE (Proof Key for Code Exchange), conçu pour empêcher la réutilisation des codes d'autorisation, la protection était neutralisée car le client remettait volontairement la clé de preuve à l'attaquant. Cela permettait à l'attaquant de compléter le processus d'échange de jetons comme s'il était le client légitime.

Détails clés

• Versions affectées : SDK Python MCP 1.9.1–1.29.1 et 2.0.0–2.1.1.
• Versions corrigées : Passez à la version 1.30.0 pour la ligne 1.x ou à la version 2.2.0 pour la ligne 2.x.
• Fournisseurs vulnérables : OAuthClientProvider, ClientCredentialsOAuthProvider, PrivateKeyJWTOAuthProvider et le RFC7523OAuthClientProvider déprécié.
• Configurations non affectées : Les serveurs MCP construits avec le SDK, les clients stdio locaux et les clients attachant leurs propres jetons ne sont pas vulnérables.
• Exigence de configuration : Pour ClientCredentialsOAuthProvider et PrivateKeyJWTOAuthProvider, la mise à niveau seule est insuffisante ; les développeurs doivent également passer le paramètre issuer= pour verrouiller le client sur un service de connexion spécifique.
• Action post-mise à niveau : Effacez les enregistrements clients OAuth stockés après la mise à niveau, car les anciens enregistrements ne sont pas liés à un service de connexion spécifique.

Pourquoi c'est important

Pour les ingénieurs développant des agents IA ou intégrant des outils externes via MCP, cette vulnérabilité représente une défaillance significative de la frontière de confiance. Le standard MCP est conçu pour connecter des applications IA à diverses sources de données et outils, impliquant souvent des serveurs tiers. Si votre application agit comme un client MCP se connectant à des serveurs non fiables ou semi-fiables, elle risque d'exposer des identifiants de longue durée pouvant accorder un accès persistant à vos services.

La subtilité de la correction ajoute une complexité opérationnelle. Une simple mise à niveau du SDK ne sécurise pas entièrement les applications utilisant certains fournisseurs OAuth, sauf si le paramètre issuer est explicitement configuré. Comme Python masque les avertissements de dépréciation par défaut, de nombreux développeurs pourraient manquer l'instruction critique consistant à ajouter ce paramètre, laissant leurs applications vulnérables même après la mise à jour. Cela souligne la nécessité d'une revue minutieuse des configurations d'authentification lors de l'adoption de nouveaux standards comme MCP.

Ce que vous pouvez faire

• Mettez immédiatement à niveau vers la version 1.30.0 ou 2.2.0 du SDK Python MCP.
• Si vous utilisez ClientCredentialsOAuthProvider ou PrivateKeyJWTOAuthProvider, assurez-vous que le paramètre issuer= est défini sur votre service de connexion attendu.
• Migrez loin du RFC7523OAuthClientProvider déprécié, car il ne dispose pas de l'option issuer=.
• Effacez tous les enregistrements clients OAuth stockés une fois après la mise à niveau pour supprimer les entrées non liées.
• Faites pivoter les secrets clients et révoquez les jetons existants auprès de votre service de connexion s'il existe une chance que votre client ait été connecté à un serveur non fiable.
• Activez les avertissements de dépréciation Python dans vos environnements de développement et de préproduction pour détecter les problèmes de configuration tôt.