From 17bf6e4198b3d6ab9ed80881f07161647bcc1255 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 17 Jul 2025 22:37:05 +0000 Subject: [PATCH] Translated ['src/network-services-pentesting/135-pentesting-msrpc.md'] t --- .../135-pentesting-msrpc.md | 84 +++++++++++++++---- 1 file changed, 68 insertions(+), 16 deletions(-) diff --git a/src/network-services-pentesting/135-pentesting-msrpc.md b/src/network-services-pentesting/135-pentesting-msrpc.md index b8ece047d..ae9357826 100644 --- a/src/network-services-pentesting/135-pentesting-msrpc.md +++ b/src/network-services-pentesting/135-pentesting-msrpc.md @@ -12,7 +12,7 @@ Die RPC eindpunt mapper kan toegang verkry word via TCP en UDP poort 135, SMB op ``` ## Hoe werk MSRPC? -Begin deur die kliënttoepassing, die MSRPC-proses behels die oproep van 'n plaaslike stub-prosedure wat dan met die kliënt runtime-biblioteek interaksie het om die versoek voor te berei en na die bediener te stuur. Dit sluit in om parameters in 'n standaard Netwerk Data Representasie-formaat om te skakel. Die keuse van die vervoersprotokol word deur die runtime-biblioteek bepaal as die bediener afgeleë is, wat verseker dat die RPC deur die netwerkstapel afgelewer word. +Begin deur die kliënttoepassing, die MSRPC-proses behels die oproep van 'n plaaslike stub-prosedure wat dan met die kliënt runtime-biblioteek interaksie het om die versoek voor te berei en na die bediener te stuur. Dit sluit in om parameters in 'n standaard Netwerkdata-representasieformaat om te skakel. Die keuse van die vervoersprotokol word deur die runtime-biblioteek bepaal as die bediener afgeleë is, wat verseker dat die RPC deur die netwerkstapel afgelewer word. ![https://0xffsec.com/handbook/images/msrpc.png](https://0xffsec.com/handbook/images/msrpc.png) @@ -46,7 +46,7 @@ Alle opsies behalwe `tcp_dcerpc_auditor` is spesifiek ontwerp om MSRPC op poort - **Beskrywing**: LSA Directory Services (DS) interface, gebruik om domeine en vertrouensverhoudings te enumerate. - **IFID**: 12345778-1234-abcd-ef00-0123456789ac - **Named Pipe**: `\pipe\samr` -- **Beskrywing**: LSA SAMR interface, gebruik om toegang te verkry tot openbare SAM-databasis elemente (bv. gebruikersname) en om gebruikerswagwoorde te brute-force, ongeag van rekening sluiting beleid. +- **Beskrywing**: LSA SAMR interface, gebruik om toegang te verkry tot openbare SAM-databasis elemente (bv. gebruikersname) en om gebruikerswagwoorde te brute-force ongeag van rekening sluiting beleid. - **IFID**: 1ff70682-0a51-30e8-076d-740be8cee98b - **Named Pipe**: `\pipe\atsvc` - **Beskrywing**: Taak skeduler, gebruik om opdragte op afstand uit te voer. @@ -81,11 +81,67 @@ Dit is moontlik om afstandkode op 'n masjien uit te voer, as die akrediteer van ## Poort 593 -Die **rpcdump.exe** van [rpctools](https://resources.oreilly.com/examples/9780596510305/tree/master/tools/rpctools) kan met hierdie poort kommunikeer. +Die **rpcdump.exe** van [rpctools](https://resources.oreilly.com/examples/9780596510305/tree/master/tools/rpctools) kan met hierdie poort interaksie hê. + +## Geoutomatiseerde Fuzzing van MSRPC Interfaces + +MS-RPC interfaces stel 'n groot en dikwels ongedokumenteerde aanvaloppervlak bloot. Die open-source [MS-RPC-Fuzzer](https://github.com/warpnet/MS-RPC-Fuzzer) PowerShell-module bou voort op James Forshaw se `NtObjectManager` om *dynamies* RPC-kliëntstubs te skep uit die interface metadata wat reeds in Windows-binaries teenwoordig is. Sodra 'n stub bestaan, kan die module elke prosedure met gemuteerde insette bombardeer en die uitkoms log, wat **herhaalbare, grootskaalse fuzzing van RPC eindpunte moontlik maak sonder om 'n enkele lyn van IDL te skryf**. + +### 1. Inventaris van die 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` sal die UUID, weergawe, binding stringe (genaamde-pyp / TCP / HTTP) en **volledige prosedure prototipes** vir elke interface wat dit teëkom, onttrek en in `rpcServerData.json` stoor. + +### 2. Voer die fuzzer uit +```powershell +'.\output\rpcServerData.json' | +Invoke-RpcFuzzer -OutPath .\output ` +-MinStrLen 100 -MaxStrLen 1000 ` +-MinIntSize 9999 -MaxIntSize 99999 +``` +Relevante opsies: + +* `-MinStrLen` / `-MaxStrLen` – grootte reeks vir gegenereerde strings +* `-MinIntSize` / `-MaxIntSize` – waarde reeks vir gemuteerde heelgetalle (nuttig vir oorgangstoetsing) +* `-Sorted` – voer prosedures uit in 'n volgorde wat **parameter afhanklikhede** respekteer sodat uitsette van een oproep as insette van die volgende kan dien (verhoog bereikbare paaie dramaties) + +Die fuzzer implementeer 2 strategieë: + +1. **Default fuzzer** – ewekansige primitiewe waardes + standaard voorbeelde vir komplekse tipes +2. **Sorted fuzzer** – afhanklikheid-bewuste ordening (sien `docs/Procedure dependency design.md`) + +Elke oproep word atomies na `log.txt` geskryf; na 'n ineenstorting vertel die **laaste lyn onmiddellik vir jou die oortredende prosedure**. Die resultaat van elke oproep word ook in drie JSON-lêers gekategoriseer: + +* `allowed.json` – oproep het geslaag en data teruggegee +* `denied.json` – bediener het geantwoord met *Access Denied* +* `error.json` – enige ander fout / ineenstorting + +### 3. Visualiseer met Neo4j +```powershell +'.\output\allowed.json' | +Import-DataToNeo4j -Neo4jHost 192.168.56.10:7474 -Neo4jUsername neo4j +``` +`Import-DataToNeo4j` omskakel die JSON artefakte in 'n grafstruktuur waar: + +* RPC bedieners, interfaces en prosedures is **nodes** +* Interaksies (`ALLOWED`, `DENIED`, `ERROR`) is **relationships** + +Cypher navrae kan dan gebruik word om vinnig gevaarlike prosedures op te spoor of om die presiese ketting van oproepe wat 'n kragonderbreking voorafgegaan het, te herhaal. + +⚠️ Die fuzzer is *destruktief*: verwag dienskragonderbrekings en selfs BSODs – hardloop dit altyd in 'n geïsoleerde VM-snapshot. + ### Geoutomatiseerde Interface Enumerasie & Dinamiese Kliënt Generasie (NtObjectManager) -PowerShell guru **James Forshaw** het die meeste van die Windows RPC interne binne die oop-bron *NtObjectManager* module blootgestel. Met dit kan jy enige RPC bediener DLL / EXE in 'n **volledig funksionele kliënt stub** in sekondes omskakel – geen IDL, MIDL of handmatige unmarshalling benodig. +PowerShell guru **James Forshaw** het die meeste van die Windows RPC interne binne die oop-bron *NtObjectManager* module blootgestel. Deur dit te gebruik kan jy enige RPC bediener DLL / EXE in 'n **volledig funksionele kliënt stub** in sekondes omskakel – geen IDL, MIDL of handmatige unmarshalling benodig. ```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 * ``` -Tipiese uitvoer stel parameter tipes bloot presies soos hulle verskyn in **MIDL** (bv. `FC_C_WSTRING`, `FC_LONG`, `FC_BIND_CONTEXT`). +Tipiese uitvoer stel parameter tipes bloot presies soos hulle in **MIDL** verskyn (bv. `FC_C_WSTRING`, `FC_LONG`, `FC_BIND_CONTEXT`). Sodra jy die koppelvlak ken, kan jy **'n gereed-om-te-kompiler C# kliënt genereer**: ```powershell @@ -121,43 +177,39 @@ Connect-RpcClient $client -stringbinding 'ncacn_np:127.0.0.1[\\pipe\\efsrpc]' ` $ctx = New-Object Marshal.NdrContextHandle $client.EfsRpcOpenFileRaw([ref]$ctx, "\\\127.0.0.1\test", 0) ``` -Authentication (Kerberos / NTLM) en versleuteling vlakke (`PacketIntegrity`, `PacketPrivacy`, …) kan direk verskaf word via die `Connect-RpcClient` cmdlet – ideaal vir **omseiling van Sekuriteitsbeskrywings** wat hoë-privilege naamgepipe beskerm. - ---- +Authentication (Kerberos / NTLM) en versleuteling vlakke (`PacketIntegrity`, `PacketPrivacy`, …) kan direk verskaf word via die `Connect-RpcClient` cmdlet – ideaal vir **omseiling van Veiligheidsbeskrywings** wat hoë-privilege naamgegewe pype beskerm. ### Konteksbewuste RPC Fuzzing (MS-RPC-Fuzzer) -Statische koppelvlak kennis is wonderlik, maar wat jy regtig wil hê is **dekking-geleide fuzzing** wat *kontekshandvatsels* en komplekse parameter kettings verstaan. Die open-source **MS-RPC-Fuzzer** projek outomatiseer presies daardie werkstroom: +Statische koppelvlak kennis is wonderlik, maar wat jy regtig wil hê is **dekking-geleide fuzzing** wat *kontekshandvatsels* en komplekse parameter kettings verstaan. Die open-source **MS-RPC-Fuzzer** projek outomatiseer presies daardie werksvloei: 1. Enumereer elke koppelvlak/prosedure wat deur die teiken binêre uitgevoer word (`Get-RpcServer`). 2. Genereer dinamiese kliënte vir elke koppelvlak (`Format-RpcClient`). 3. Randomiseer invoerparameters (wye string lengte, heelgetal reekse, enums) terwyl die oorspronklike **NDR tipe** gerespekteer word. 4. Volg *kontekshandvatsels* wat deur een oproep teruggegee word om opvolg prosedures outomaties te voed. -5. Vuur hoë-volume oproepe teen die gekose vervoer (ALPC, TCP, HTTP of naamgepipe). +5. Vuur hoë-volume oproepe teen die gekose vervoer (ALPC, TCP, HTTP of naamgegewe pyp). 6. Log uitgangstatusse / foute / tydsduur en voer 'n **Neo4j** invoer lêer uit om *koppelvlak → prosedure → parameter* verhoudings en crash klusters te visualiseer. -Voorbeeld uitvoering (naamgepipe teiken): +Voorbeeld uitvoering (naamgegewe pyp teiken): ```powershell Invoke-MSRPCFuzzer -Pipe "\\.\pipe\efsrpc" -Auth NTLM ` -MinLen 1 -MaxLen 0x400 ` -Iterations 100000 ` -OutDir .\results ``` -'n Enkele uit-bounds skrywe of onverwagte uitsondering sal onmiddellik na vore kom met die presiese opnum + gefuzzde payload wat dit geaktiveer het – 'n perfekte beginpunt vir 'n stabiele bewys-van-konsep ontploffing. +'n Enkele uit-bounds skrywe of onverwagte uitsondering sal onmiddellik verskyn met die presiese opnum + gefuzzed payload wat dit geaktiveer het – 'n perfekte beginpunt vir 'n stabiele bewys-van-konsep ontploffing. -> ⚠️ Baie RPC dienste werk in prosesse wat as **NT AUTHORITY\SYSTEM** loop. Enige geheue-veiligeheidsprobleem hier vertaal gewoonlik na plaaslike voorregverhoging of (wanneer oor SMB/135 blootgestel) *afgeleë kode-uitvoering*. +> ⚠️ Baie RPC dienste voer uit in prosesse wat as **NT AUTHORITY\SYSTEM** loop. Enige geheue-veiligeheidsprobleem hier vertaal gewoonlik na plaaslike voorregverhoging of (wanneer blootgestel oor SMB/135) *afgeleë kode-uitvoering*. ---- ## Verwysings - [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}}