0xblackash/cve-2026-73296Outil d'évaluation de sécurité non destructif pour CVE-2026-73296, vérifiant les limites d'authentification sur les serveurs HTTP Mobile MCP exposés (ports 8020/8021) afin de détecter un éventuel accès non autorisé aux appareils Android.
UFO-Vuln 💥
Un accès MCP mobile non authentifié peut exposer les données de l'écran Android et offrir des capacités de contrôle d'interface à distance via ADB.
Ce dépôt est destiné uniquement à la recherche en sécurité autorisée, à la validation de vulnérabilités, aux tests défensifs et aux environnements de laboratoire contrôlés.
Le vérificateur inclus est conçu pour effectuer des contrôles de limites d'authentification non destructifs.
Il ne pas :
CVE : CVE-2026-73296
Produit : Microsoft UFO
Composant : Serveurs HTTP MCP mobiles
Gravité : Critique
CVSS v3.1 : 9.4
Versions affectées : <= v3.0.7
Versions officiellement corrigées : Aucune répertoriée par l'avis Microsoft UFO au moment de la rédaction de cette documentation.
CWE :
La vulnérabilité affecte les serveurs de collecte de données et d'action MCP mobiles d'UFO lorsqu'ils sont exposés sur un réseau sans authentification appropriée.
L'avis officiel identifie l'implémentation vulnérable comme suit :```text ufo/client/mcp/http_servers/mobile_mcp_server.py
Les services concernés exposent des interfaces MCP Streamable HTTP capables d’interagir avec un appareil Android connecté via ADB.
Si ces services sont accessibles à distance et que l’authentification n’est pas appliquée, un client réseau non authentifié peut être en mesure d’accéder à des informations sensibles de l’appareil et d’invoquer des fonctionnalités de contrôle de l’interface utilisateur Android.
---
# 🎯 Résumé exécutif
Microsoft UFO est un framework d’agents IA conçu pour l’automatisation intelligente et l’orchestration multi-appareils.
Sa fonctionnalité Mobile MCP fournit des serveurs MCP permettant d’interagir avec des appareils Android via ADB.
La configuration vulnérable expose deux services réseau importants :
| Service | Port | Fonction |
| -------------------------- | -----: | ----------------------------------- |
| Mobile Data Collection MCP | `8020` | Informations Android et données d’écran |
| Mobile Action MCP | `8021` | Interaction et contrôle Android |
Dans les versions concernées, les serveurs Mobile MCP pouvaient être créés sans fournisseur d’authentification ni contrôle d’autorisation au niveau de la requête.
Par conséquent :```text
Remote Client
│
│ HTTP / MCP
▼
┌──────────────────────┐
│ Mobile MCP Server │
│ │
│ Authentication: │
└──────────┬───────────┘
│
▼
ADB Interface
│
▼
Android Device
The security boundary between the remote network client and the ADB-backed functionality is therefore insufficiently protected.
9.4 CRITICAL
Vector :```py
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:L
| Métrique | Valeur |
|---|---|
| Vecteur d’attaque | Réseau |
| Complexité d’attaque | Faible |
| Privilèges requis | Aucun |
| Interaction utilisateur | Aucune |
| Portée | Inchangée |
| Confidentialité | Élevée |
| Intégrité | Élevée |
| Disponibilité | Faible |
La vulnérabilité est particulièrement significative car son exploitation ne nécessite pas intrinsèquement :
L’avis officiel indique qu’un client réseau capable d’atteindre le service exposé peut initialiser une session MCP et invoquer ses outils sans présenter d’identifiant.
Selon l’avis de sécurité officiel de Microsoft UFO :```py Affected: <= v3.0.7
Patched: None listed
The official repository currently lists `3.0.7` as a release.
> **Important:** Do not claim that `3.0.8` is an officially patched release unless Microsoft publishes that information. The official security advisory currently lists no patched version.
---
# 🏗️ Architecture vulnérable
La fonctionnalité vulnérable est implémentée dans :```py
ufo/client/mcp/http_servers/mobile_mcp_server.py
Fonctions importantes identifiées par l’avis officiel :
create_mobile_data_collection_server capture_screenshot get_ui_tree get_device_info get_mobile_app_target_info get_app_window_controls_target_info
### Actions mobiles```py
create_mobile_action_server
tap
swipe
type_text
launch_app
press_key
click_control
Les deux services HTTP sont associés à :```py TCP/8020 TCP/8021
L'avis identifie spécifiquement ces services comme les serveurs MCP de collecte de données mobiles et d'action.
---
# 🔬 Cause racine
Le problème de sécurité fondamental est le suivant :```py
Powerful functionality
+
Network exposure
+
Missing authentication
=
Unauthorized access
À l'implémentation concernée, les serveurs FastMCP du Mobile MCP ont été construits sans fournisseur d'authentification ni application équivalente d'autorisation au niveau des requêtes.
Conceptuellement :```python mcp = FastMCP( "Mobile MCP Server", host=host, port=port, )
Le problème ne réside pas simplement dans l’existence de MCP.
Le problème est qu’une interface accessible via le réseau expose des opérations sensibles pour la sécurité sans exiger que l’appelant établisse une identité authentifiée.
---
# 🔗 Flux d’attaque
Une chaîne d’attaque simplifiée se présente comme suit :```py
┌───────────────────┐
│ Unauthenticated │
│ Network Client │
└─────────┬─────────┘
│
│ HTTP
▼
┌─────────────────────────┐
│ Mobile MCP :8020/:8021 │
│ │
│ Authentication missing │
└───────────┬─────────────┘
│
│ MCP Tool
▼
┌─────────────────────────┐
│ Mobile MCP Tool │
└───────────┬─────────────┘
│
│ ADB operation
▼
┌─────────────────────────┐
│ Android Device / ADB │
└─────────────────────────┘
La transition de sécurité importante est :```py Unauthenticated network request ↓ MCP functionality ↓ ADB-backed action ↓ Android device
---
# 📡 Services exposés
## Port 8020 — Collecte de données
Le serveur de collecte de données peut exposer des fonctionnalités associées à :```py
capture_screenshot
get_ui_tree
get_device_info
get_mobile_app_target_info
get_app_window_controls_target_info
Les informations potentiellement exposées incluent :