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
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 :
Cela crée un risque de confidentialité important.
Le serveur d’actions expose des fonctionnalités associées à :```text tap swipe type_text launch_app press_key click_control
Ces opérations peuvent fournir à un appelant distant des capacités d’interaction avec l’interface utilisateur Android.
Selon l’état de l’appareil et les applications accessibles, cela peut potentiellement permettre :```text
Remote input
↓
UI navigation
↓
Application interaction
↓
Device-state modification
L'avis officiel décrit spécifiquement ces capacités comme des actions d'interface Android injectables à distance.
Un accès non autorisé aux informations de l'écran et de l'interface peut potentiellement exposer :
L'impact exact dépend de l'appareil Android et des applications accessibles via l'environnement ADB connecté.
Des actions mobiles non autorisées peuvent permettre à un attaquant de :```text Tap Swipe Type text Press keys Launch applications Click UI controls
Cela peut potentiellement modifier l’état de l’application ou interagir avec des flux de travail en cours d’exécution sur l’appareil.
---
# 💥 Impact sur la disponibilité
Des actions automatisées répétées pourraient :
* Interrompre l’automatisation
* Changer d’application
* Quitter les flux de travail
* Déclencher des actions d’interface inattendues
* Perturber les environnements de test
* Interrompre une session d’automatisation Android
L’évaluation CVSS attribue un **impact faible sur la disponibilité**, tandis que la confidentialité et l’intégrité sont évaluées comme **élevées**.
---
# 🧪 Détection sûre
Ce dépôt comprend :```text
cve-2026-73296.py
Le vérificateur est intentionnellement conçu comme un outil d'évaluation de sécurité non destructif.
Il vérifie :```text TCP reachability ↓ HTTP response ↓ Authentication boundary ↓ SAFE / VULNERABLE / UNKNOWN
Il **ne** fait **pas** appel aux outils Mobile MCP.
---
# 🟢 SÛR
Un résultat `SAFE` signifie que le point de terminaison HTTP testé a renvoyé une barrière d'authentification/autorisation telle que :```text
HTTP 401
HTTP 403
Exemple :```text [SAFE] Port 8020: authentication/authorization barrier detected
---
# 🔴 VULNÉRABLE
Un résultat `VULNERABLE` signifie que le point de terminaison HTTP testé a répondu avec succès sans présenter de défi d'authentification.
Exemple :```text
[VULNERABLE] Port 8021:
HTTP endpoint responded without an authentication challenge
This should be treated as a potential exposure requiring confirmation.
An UNKNOWN result means the checker could not reliably determine the authentication state.
Examples:```text TCP unreachable TLS error HTTP timeout Unexpected HTTP response Redirect
`UNKNOWN` ne doit pas être interprété comme sécurisé ou vulnérable.
---
# ⚠️ Limites de détection
Ce vérificateur ne prétend volontairement **pas** prouver une exploitation.
Un résultat vert signifie :
> Une protection par authentification a été observée sur la frontière HTTP testée.
Cela ne prouve pas mathématiquement que l'ensemble du déploiement UFO est sécurisé.
De même, un résultat rouge indique :
> Le point de terminaison testé a répondu sans défi d'authentification.
Il doit être corrélé avec :
* La version d'UFO
* La configuration du déploiement
* L'exposition réseau
* La configuration MCP
* Les proxys inverses
* La configuration TLS
* Les règles de pare-feu
* La connectivité ADB
---
# 🚀 Utilisation
Clonez le dépôt :```bash
git clone https://github.com/0xBlackash/CVE-2026-73296.git
cd CVE-2026-73296
Installer la dépendance :```bash python3 -m pip install requests
Syntax check:```bash
python3 -m py_compile cve-2026-73296.py
Exécutez-le contre un système de test autorisé :```bash python3 cve-2026-73296.py 127.0.0.1
Exemple de cible de laboratoire :```bash
python3 cve-2026-73296.py 192.168.56.10
Pour HTTPS avec un certificat de laboratoire/auto-signé :```bash python3 cve-2026-73296.py https://192.168.56.10 --no-verify-tls
---
# 🖥️ Exemple de sortie
### Point de terminaison protégé```py
════════════════════════════════════════════════════════
SECURITY ASSESSMENT
────────────────────────────────────────────────────────
SAFE : 2
VULNERABLE : 0
UNKNOWN : 0
✓ AUTHENTICATION CHECK PASSED
════════════════════════════════════════════════════════ SECURITY ASSESSMENT ────────────────────────────────────────────────────────
SAFE : 0 VULNERABLE : 2 UNKNOWN : 0
⚠ POTENTIAL CVE-2026-73296 EXPOSURE
→ TCP/8020 responded without an authentication challenge. → TCP/8021 responded without an authentication challenge.
<img width="1523" height="789" alt="CVE-2026-73296" src="https://assets.kitploit.com/production/public/readmes/54023/5754c6ba111148250c8f3067db1c7dfbb9cb85e4910f2afe13443f7906926573/def8f2a924188fdd01d3ef2b3880c3bc22bef0c251f9b13d24ac458f2143f3eb-display-v1.webp" />
---
# 🧬 Modèle Source-vers-Puits
La vulnérabilité peut être comprise comme une défaillance de sécurité de type source-vers-puits :```py
SOURCE
│
│ Unauthenticated network request
▼
MCP HTTP Server
│
│ Missing authentication/authorization
▼
MCP Tool
│
▼
ADB-backed operation
│
▼
ANDROID DEVICE
La frontière de sécurité prévue devrait plutôt être :```py Network Request │ ▼ Authentication │ ├──── INVALID ────► REJECT │ ▼ Authorization │ ├──── DENIED ─────► REJECT │ ▼ MCP Tool │ ▼ ADB
---
# 🔐 Remédiation recommandée
La remédiation principale consiste à imposer l'authentification à la limite du transport HTTP Mobile MCP.
Architecture de sécurité recommandée :```py
┌──────────────────┐
│ Authorized MCP │
│ Client │
└────────┬─────────┘
│
Bearer Token
│
▼
┌──────────────────┐
│ Authentication │
│ Middleware │
└────────┬─────────┘
│
Authorized?
/ \
NO YES
│ │
▼ ▼
REJECT MCP Tool
│
▼
ADB
L'avis officiel recommande une conception d'authentification basée sur :```py UFO_MCP_API_KEY
Le modèle de sécurité doit garantir :
1. Un secret à haute entropie est requis.
2. Le serveur échoue en mode fermé si l’identifiant est manquant.
3. Les identifiants bearer invalides sont rejetés.
4. L’authentification a lieu avant l’exécution de l’outil.
5. Les identifiants ne sont pas exposés comme paramètres d’outil visibles par le LLM.
6. La comparaison des identifiants doit utiliser une comparaison à temps constant.
7. Les déploiements distants doivent utiliser un transport chiffré.
8. Localhost doit rester la valeur par défaut lorsque c’est possible.
---
# 🌐 Exposition réseau
Évitez d’exposer :```py
0.0.0.0:8020
0.0.0.0:8021
directement à des réseaux non fiables.
Privilégiez :```py 127.0.0.1
pour les déploiements locaux uniquement.
Pour un accès à distance légitime, envisagez :```py
Client
│
▼
TLS / Private Tunnel
│
▼
Authenticated Reverse Proxy
│
▼
UFO MCP
│
▼
ADB
Contrôles de sécurité possibles :
Une suite de tests de régression de sécurité appropriée doit vérifier :
Request ↓ No Authorization header ↓ REJECT ↓ ADB not reached
## Features
- **Automated Reconnaissance**: Automates the initial reconnaissance phase, saving time and effort.
- **Comprehensive Scanning**: Performs thorough scans to identify open ports, services, and potential vulnerabilities.
- **Customizable Workflows**: Allows users to define custom scanning workflows tailored to their specific needs.
- **Detailed Reporting**: Generates comprehensive reports with actionable insights.
- **Integration Ready**: Seamlessly integrates with other security tools and frameworks.
- **User-Friendly Interface**: Provides an intuitive command-line interface that is easy to navigate.
- **Active Maintenance**: Regularly updated to incorporate the latest security research and techniques.```py
PASS
Bearer: invalid-token ↓ REJECT ↓ ADB not reached
## Installation
```bash
# Clone the repository
git clone https://github.com/example/repo.git
# Navigate to the directory
cd repo
# Install dependencies
pip install -r requirements.txt
Run the tool with the following command:
python main.py --target example.com
| Option | Description |
|---|---|
--target | Specify the target domain or IP address |
--verbose | Enable verbose output for detailed logging |
--output | Save results to a specified file |
Scan a single target:
python main.py --target example.com
Scan multiple targets from a file:
python main.py --target-list targets.txt
This project is licensed under the MIT License. See the LICENSE file for details.```py PASS
### Test 3 — Identifiants valides```py
Bearer: valid-token
↓
ACCEPT
↓
MCP Tool
↓
ADB
# Clone the repository
git clone https://github.com/example/repo.git
# Navigate to the directory
cd repo
# Install dependencies
pip install -r requirements.txt
To run the tool, use the following command:
python main.py --target example.com
This project is licensed under the MIT License. See the LICENSE file for details.```py PASS
### Test 4 — Secret serveur manquant```py
UFO_MCP_API_KEY = missing
- **`--no-verify`** : Ignore les erreurs de vérification (par exemple, les certificats SSL auto-signés).
- **`--proxy <proxy>`** : Définit un proxy pour la connexion (par exemple, `http://proxy.example.com:8080`).
- **`--timeout <seconds>`** : Définit le délai d'expiration de la connexion en secondes.
- **`--user-agent <ua>`** : Définit un User-Agent personnalisé pour les requêtes HTTP.
- **`--verbose`** : Active la sortie détaillée pour le débogage.
- **`--quiet`** : Supprime la sortie non essentielle, n'affiche que les résultats.
- **`--output <file>`** : Écrit les résultats dans le fichier spécifié au lieu de la sortie standard.
- **`--format <type>`** : Spécifie le format de sortie (`json`, `csv`, `txt`).
- **`--threads <n>`** : Définit le nombre de threads à utiliser pour le traitement parallèle.
- **`--retries <n>`** : Définit le nombre de tentatives pour les requêtes ayant échoué.
- **`--delay <seconds>`** : Définit le délai entre les requêtes pour éviter la détection.
- **`--random-agent`** : Utilise un User-Agent aléatoire pour chaque requête.
- **`--cookie <data>`** : Définit les cookies à envoyer avec les requêtes.
- **`--header <header>`** : Ajoute un en-tête HTTP personnalisé à chaque requête.
- **`--data <data>`** : Envoie des données dans le corps de la requête (pour les requêtes POST).
- **`--method <method>`** : Définit la méthode HTTP à utiliser (GET, POST, PUT, etc.).
- **`--follow-redirects`** : Suit les redirections HTTP automatiquement.
- **`--no-color`** : Désactive la coloration de la sortie.
- **`--help`** : Affiche le message d'aide et quitte.
- **`--version`** : Affiche la version de l'outil et quitte.
``````py
Server fails closed
Les variables d’environnement non résolues ne doivent pas devenir accidentellement des identifiants d’authentification.
Attendu :```py Client initialization fails
---
# 🛡️ Défense en profondeur
L'authentification seule ne doit pas être considérée comme suffisante.
Contrôles recommandés :
---```py
Internet
│
X
│
Firewall/VPN
│
▼
TLS / Proxy
│
▼
API Authentication
│
▼
Authorization
│
▼
MCP Server
│
▼
ADB
│
▼
Android Device
Les équipes de sécurité doivent surveiller les accès inattendus à :```text TCP/8020 TCP/8021
Recherchez :
* Des adresses IP sources inattendues
* Des requêtes sans en-têtes d’autorisation
* Des échecs d’authentification répétés
* Des sessions MCP inhabituelles
* Des demandes de captures d’écran inattendues
* Des appels d’interaction avec l’interface utilisateur répétés
* Des lancements d’applications inattendus
* Une activité ADB suspecte
Télémétrie réseau utile :```text
source_ip
destination_ip
destination_port
timestamp
HTTP_method
HTTP_status
user_agent
authorization_present
request_frequency
Si une instance vulnérable exposée est découverte :
Limitez immédiatement l'accès à :```text 8020 8021
### 2. Déconnecter les appareils Android inutiles
Si le service n'est pas requis, déconnectez l'appareil ADB associé.
### 3. Examiner les journaux
Recherchez :```text
Unknown source IPs
Unexpected MCP sessions
Unexpected device interactions
Unexpected application launches
Si des secrets d'authentification ont pu être exposés :```text Generate a new high-entropy API key
### 5. Examiner l'état de l'appareil
Vérifier :
* Les applications récemment lancées
* L'état modifié des applications
* Messages/saisies inattendus
* Activité d'interface utilisateur suspecte
### 6. Mettre à jour ou appliquer les recommandations de sécurité du fournisseur
Suivre les derniers avis de sécurité Microsoft UFO et les informations de publication.
### 7. Nouveau test
Exécuter à nouveau le vérificateur sécurisé après la remédiation.
---
# 🧰 Méthodologie de recherche
Ce projet suit une méthodologie défensive de validation des vulnérabilités :```py
1. Identify vulnerable component
↓
2. Determine network attack surface
↓
3. Identify missing security boundary
↓
4. Map exposed capabilities
↓
5. Build non-destructive detection
↓
6. Validate authentication behavior
↓
7. Document impact
↓
8. Apply remediation
↓
9. Regression test
Structure de projet recommandée :```py CVE-2026-73296/ │ ├── README.md │ ├── poc/ │ └── cve-2026-73296.py │ ├── docs/ │ ├── technical-analysis.md │ ├── remediation.md │ └── detection.md │ ├── screenshots/ │ ├── safe.png │ └── vulnerable.png │ ├── tests/ │ └── README.md │ ├── LICENSE └── .gitignore
---
# 🧠 Leçons clés en matière de sécurité
## 1. MCP est une frontière de sécurité
Les serveurs MCP ne doivent pas être traités comme des utilitaires locaux inoffensifs lorsqu'ils exposent des opérations puissantes sur un réseau.
---
## 2. ADB amplifie l'impact
Un point de terminaison MCP connecté à ADB peut devenir un pont entre :```text
Network
↓
Agent protocol
↓
ADB
↓
Android
Les exigences de sécurité doivent donc couvrir toute la chaîne.
Un service lié à :```text 127.0.0.1
a un profil d’exposition fondamentalement différent de :```text
0.0.0.0
La liaison réseau doit donc être traitée comme une configuration de sécurité.
L'invariant critique est le suivant :```text UNTRUSTED REQUEST ↓ AUTHENTICATION ↓ AUTHORIZATION ↓ MCP TOOL ↓ ADB
Jamais :```text
UNTRUSTED REQUEST
↓
MCP TOOL
↓
ADB
CVE-2026-73296 démontre le risque de sécurité créé lorsque de puissantes interfaces d'automatisation d'agents sont exposées sur un réseau sans une frontière appropriée d'authentification et d'autorisation.
L'architecture vulnérable de Mobile MCP crée un chemin depuis :```text Unauthenticated Network Client ↓ MCP Server ↓ MCP Tools ↓ ADB ↓ Android Device
L'impact résultant peut inclure à la fois une **perte de confidentialité**, via les informations d'écran/interface utilisateur/appareil, et un **impact sur l'intégrité**, via l'interaction à distance avec l'interface utilisateur Android.
Les contrôles défensifs les plus importants sont :```text
Authentication
Authorization
TLS
Network isolation
Least privilege
Secure defaults
Continuous monitoring
Regression testing
Dépôt officiel Microsoft UFO :
https://github.com/microsoft/UFO
Avis de sécurité officiel :
https://github.com/microsoft/UFO/security/advisories/GHSA-24fq-m9rr-g3mm
Ce projet est fourni pour :
Ne testez pas des systèmes ou des appareils sans autorisation explicite.
Le vérificateur sécurisé évite intentionnellement d'exécuter les capacités vulnérables de Mobile MCP sur de véritables appareils Android.
CVE-2026-73296 • Microsoft UFO • Recherche en sécurité Mobile MCP
| 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 |
| Propriété | Valeur |
|---|
| CVE | CVE-2026-73296 |
| Produit | Microsoft UFO |
| Composant | Mobile MCP |
| Sévérité | Critique |
| CVSS | 9.4 |
| Vecteur d'attaque | Réseau |
| Complexité | Faible |
| Privilèges | Aucun |
| Interaction utilisateur | Aucune |
| Confidentialité | Élevée |
| Intégrité | Élevée |
| Disponibilité | Faible |
| CWE-306 | Authentification manquante |
| CWE-862 | Autorisation manquante |
| Data MCP | TCP/8020 |
| Action MCP | TCP/8021 |
| Affecté | ≤ v3.0.7 |
| Version corrigée officielle | Aucune répertoriée |