Translated ['src/network-services-pentesting/135-pentesting-msrpc.md'] t

src/network-services-pentesting/135-pentesting-msrpc.md

@@ -12,7 +12,7 @@ Le mappage des points de terminaison RPC peut être accédé via le port TCP et
 ```
 ## Comment fonctionne MSRPC ?
 
-Initie par l'application cliente, le processus MSRPC implique l'appel d'une procédure stub locale qui interagit ensuite avec la bibliothèque d'exécution cliente pour préparer et transmettre la demande au serveur. Cela inclut la conversion des paramètres en un format standard de représentation de données réseau. Le choix du protocole de transport est déterminé par la bibliothèque d'exécution si le serveur est distant, garantissant que le RPC est livré à travers la pile réseau.
+Initie par l'application cliente, le processus MSRPC implique l'appel d'une procédure stub locale qui interagit ensuite avec la bibliothèque d'exécution cliente pour préparer et transmettre la demande au serveur. Cela inclut la conversion des paramètres en un format standard de représentation de données réseau. Le choix du protocole de transport est déterminé par la bibliothèque d'exécution si le serveur est distant, garantissant que l'RPC est livré à travers la pile réseau.
 
 ![https://0xffsec.com/handbook/images/msrpc.png](https://0xffsec.com/handbook/images/msrpc.png)
 
@@ -83,9 +83,65 @@ Il est possible d'exécuter du code à distance sur une machine, si les identifi
 
 Le **rpcdump.exe** de [rpctools](https://resources.oreilly.com/examples/9780596510305/tree/master/tools/rpctools) peut interagir avec ce port.
 
-### Énumération d'interface automatisée et génération dynamique de client (NtObjectManager)
+## Fuzzing automatisé des interfaces MSRPC
 
-Le gourou PowerShell **James Forshaw** a exposé la plupart des internals RPC de Windows à l'intérieur du module open-source *NtObjectManager*. En l'utilisant, vous pouvez transformer n'importe quel serveur RPC DLL / EXE en un **stub client complet** en quelques secondes – sans IDL, MIDL ou désérialisation manuelle requise.
+Les interfaces MS-RPC exposent une surface d'attaque large et souvent non documentée. Le module PowerShell open-source [MS-RPC-Fuzzer](https://github.com/warpnet/MS-RPC-Fuzzer) s'appuie sur `NtObjectManager` de James Forshaw pour *créer dynamiquement* des stubs de client RPC à partir des métadonnées d'interface déjà présentes dans les binaires Windows. Une fois qu'un stub existe, le module peut bombarder chaque procédure avec des entrées mutées et enregistrer le résultat, rendant **le fuzzing reproductible à grande échelle des points de terminaison RPC possible sans écrire une seule ligne d'IDL**.
+
+### 1. Inventaire des interfaces
+```powershell
+# Import the module (download / git clone first)
+Import-Module .\MS-RPC-Fuzzer.psm1
+
+# Parse a single binary
+Get-RpcServerData -Target "C:\Windows\System32\efssvc.dll" -OutPath .\output
+
+# Or crawl the whole %SystemRoot%\System32 directory
+Get-RpcServerData -OutPath .\output
+```
+`Get-RpcServerData` extraira le UUID, la version, les chaînes de liaison (named-pipe / TCP / HTTP) et **les prototypes de procédure complets** pour chaque interface qu'il rencontre et les stockera dans `rpcServerData.json`.
+
+### 2. Exécutez le fuzzer
+```powershell
+'.\output\rpcServerData.json' |
+Invoke-RpcFuzzer -OutPath .\output `
+-MinStrLen 100  -MaxStrLen 1000 `
+-MinIntSize 9999 -MaxIntSize 99999
+```
+Options pertinentes :
+
+* `-MinStrLen` / `-MaxStrLen` – plage de taille pour les chaînes générées
+* `-MinIntSize` / `-MaxIntSize` – plage de valeur pour les entiers mutés (utile pour les tests de débordement)
+* `-Sorted` – exécute les procédures dans un ordre qui respecte les **dépendances des paramètres** afin que les sorties d'un appel puissent servir d'entrées pour le suivant (augmente considérablement les chemins accessibles)
+
+Le fuzzer implémente 2 stratégies :
+
+1. **Fuzzer par défaut** – valeurs primitives aléatoires + instances par défaut pour les types complexes
+2. **Fuzzer trié** – ordonnancement conscient des dépendances (voir `docs/Procedure dependency design.md`)
+
+Chaque appel est écrit de manière atomique dans `log.txt` ; après un crash, **la dernière ligne vous indique immédiatement la procédure fautive**. Le résultat de chaque appel est également catégorisé en trois fichiers JSON :
+
+* `allowed.json` – l'appel a réussi et a renvoyé des données
+* `denied.json`  – le serveur a répondu avec *Accès refusé*
+* `error.json`   – toute autre erreur / crash
+
+### 3. Visualiser avec Neo4j
+```powershell
+'.\output\allowed.json' |
+Import-DataToNeo4j -Neo4jHost 192.168.56.10:7474 -Neo4jUsername neo4j
+```
+`Import-DataToNeo4j` convertit les artefacts JSON en une structure de graphe où :
+
+* Les serveurs RPC, interfaces et procédures sont des **nœuds**
+* Les interactions (`ALLOWED`, `DENIED`, `ERROR`) sont des **relations**
+
+Des requêtes Cypher peuvent ensuite être utilisées pour repérer rapidement des procédures dangereuses ou pour rejouer la chaîne exacte d'appels qui a précédé un crash.
+
+⚠️  Le fuzzer est *destructeur* : attendez-vous à des plantages de service et même des BSOD – exécutez-le toujours dans un instantané de VM isolé.
+
+
+### Énumération d'Interface Automatisée & Génération Dynamique de Client (NtObjectManager)
+
+Le gourou de PowerShell **James Forshaw** a exposé la plupart des internals de Windows RPC à l'intérieur du module open-source *NtObjectManager*. En l'utilisant, vous pouvez transformer n'importe quel DLL / EXE de serveur RPC en un **stub de client complet** en quelques secondes – sans IDL, MIDL ou désérialisation manuelle requise.
 ```powershell
 # Install the module once
 Install-Module NtObjectManager -Force
@@ -97,7 +153,7 @@ $rpcinterfaces | Format-Table Name,Uuid,Version,Procedures
 # Inspect a single procedure (opnum 0)
 $rpcinterfaces[0].Procedures[0] | Format-List *
 ```
-La sortie typique expose les types de paramètres exactement comme ils apparaissent dans **MIDL** (par exemple, `FC_C_WSTRING`, `FC_LONG`, `FC_BIND_CONTEXT`).
+La sortie typique expose les types de paramètres exactement tels qu'ils apparaissent dans **MIDL** (par exemple, `FC_C_WSTRING`, `FC_LONG`, `FC_BIND_CONTEXT`).
 
 Une fois que vous connaissez l'interface, vous pouvez **générer un client C# prêt à être compilé** :
 ```powershell
@@ -123,8 +179,6 @@ $client.EfsRpcOpenFileRaw([ref]$ctx, "\\\127.0.0.1\test", 0)
 ```
 L'authentification (Kerberos / NTLM) et les niveaux de cryptage (`PacketIntegrity`, `PacketPrivacy`, …) peuvent être fournis directement via le cmdlet `Connect-RpcClient` – idéal pour **contourner les descripteurs de sécurité** qui protègent les pipes nommés à privilèges élevés.
 
----
-
 ### Fuzzing RPC Sensible au Contexte (MS-RPC-Fuzzer)
 
 La connaissance statique de l'interface est excellente, mais ce que vous voulez vraiment, c'est un **fuzzing guidé par la couverture** qui comprend les *handles de contexte* et les chaînes de paramètres complexes. Le projet open-source **MS-RPC-Fuzzer** automatise exactement ce flux de travail :
@@ -134,7 +188,7 @@ La connaissance statique de l'interface est excellente, mais ce que vous voulez
 3. Randomiser les paramètres d'entrée (longueur des chaînes larges, plages d'entiers, énumérations) tout en respectant le **type NDR** original.
 4. Suivre les *handles de contexte* retournés par un appel pour alimenter automatiquement les procédures de suivi.
 5. Effectuer des appels à fort volume contre le transport choisi (ALPC, TCP, HTTP ou pipe nommé).
-6. Enregistrer les statuts de sortie / défauts / délais d'attente et exporter un fichier d'importation **Neo4j** pour visualiser les relations *interface → procédure → paramètre* et les clusters de crash.
+6. Enregistrer les statuts de sortie / défauts / délais d'attente et exporter un fichier d'importation **Neo4j** pour visualiser les relations *interface → procédure → paramètre* et les clusters de plantage.
 
 Exécution d'exemple (cible de pipe nommé) :
 ```powershell
@@ -147,16 +201,15 @@ Une seule écriture hors limites ou une exception inattendue sera immédiatement
 
 > ⚠️  De nombreux services RPC s'exécutent dans des processus fonctionnant en tant que **NT AUTHORITY\SYSTEM**. Tout problème de sécurité mémoire ici se traduit généralement par une élévation de privilèges locale ou (lorsqu'il est exposé via SMB/135) *exécution de code à distance*.
 
----
 
 ## Références
 
 - [Automating MS-RPC vulnerability research (2025, Incendium.rocks)](https://www.incendium.rocks/posts/Automating-MS-RPC-Vulnerability-Research/)
 - [MS-RPC-Fuzzer – context-aware RPC fuzzer](https://github.com/warpnet/MS-RPC-Fuzzer)
 - [NtObjectManager PowerShell module](https://github.com/googleprojectzero/sandbox-attacksurface-analysis-tools/tree/master/NtObjectManager)
-
 - [https://www.cyber.airbus.com/the-oxid-resolver-part-1-remote-enumeration-of-network-interfaces-without-any-authentication/](https://www.cyber.airbus.com/the-oxid-resolver-part-1-remote-enumeration-of-network-interfaces-without-any-authentication/)
 - [https://www.cyber.airbus.com/the-oxid-resolver-part-2-accessing-a-remote-object-inside-dcom/](https://www.cyber.airbus.com/the-oxid-resolver-part-2-accessing-a-remote-object-inside-dcom/)
 - [https://0xffsec.com/handbook/services/msrpc/](https://0xffsec.com/handbook/services/msrpc/)
+- [MS-RPC-Fuzzer (GitHub)](https://github.com/warpnet/MS-RPC-Fuzzer)
 
 {{#include ../banners/hacktricks-training.md}}