diff --git a/src/network-services-pentesting/135-pentesting-msrpc.md b/src/network-services-pentesting/135-pentesting-msrpc.md index fcab8b21d..274c90dcb 100644 --- a/src/network-services-pentesting/135-pentesting-msrpc.md +++ b/src/network-services-pentesting/135-pentesting-msrpc.md @@ -6,13 +6,13 @@ O protocolo Microsoft Remote Procedure Call (MSRPC), um modelo cliente-servidor que permite que um programa solicite um serviço de um programa localizado em outro computador sem entender os detalhes da rede, foi inicialmente derivado de software de código aberto e posteriormente desenvolvido e protegido por direitos autorais pela Microsoft. -O mapeador de endpoint RPC pode ser acessado via porta TCP e UDP 135, SMB na TCP 139 e 445 (com uma sessão nula ou autenticada), e como um serviço web na porta TCP 593. +O mapeador de ponto de extremidade RPC pode ser acessado via porta TCP e UDP 135, SMB na 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 a chamada de um procedimento stub local que interage com a biblioteca de tempo de execução do cliente para preparar e transmitir a solicitação ao servidor. Isso inclui a conversão de parâmetros em um formato padrão de Representação de Dados de Rede. A escolha do protocolo de transporte é determinada pela biblioteca de tempo de execução se o servidor for remoto, garantindo que o RPC seja entregue através da pilha de rede. +Iniciado pela aplicação cliente, o processo MSRPC envolve chamar um procedimento stub local que interage com a biblioteca de tempo de execução do cliente para preparar e transmitir a solicitação ao servidor. Isso inclui converter parâmetros em um formato padrão de Representação de Dados de Rede. A escolha do protocolo de transporte é determinada pela biblioteca de tempo de execução se o servidor for remoto, garantindo que o RPC seja entregue através da pilha de rede. ![https://0xffsec.com/handbook/images/msrpc.png](https://0xffsec.com/handbook/images/msrpc.png) @@ -43,7 +43,7 @@ Todas as opções, exceto `tcp_dcerpc_auditor`, são especificamente projetadas - **Descrição**: Interface LSA, usada para enumerar usuários. - **IFID**: 3919286a-b10c-11d0-9ba8-00c04fd92ef5 - **Named Pipe**: `\pipe\lsarpc` -- **Descrição**: Interface de Serviços de Diretório LSA (DS), usada para enumerar domínios e relações de confiança. +- **Descrição**: Interface de Serviços de Diretório (DS) LSA, usada para enumerar domínios e relações de confiança. - **IFID**: 12345778-1234-abcd-ef00-0123456789ac - **Named Pipe**: `\pipe\samr` - **Descrição**: Interface LSA SAMR, usada para acessar elementos públicos do banco de dados SAM (por exemplo, nomes de usuários) e realizar força bruta em senhas de usuários, independentemente da política de bloqueio de conta. @@ -83,8 +83,78 @@ Este método tem sido usado para obter informações da interface como endereço O **rpcdump.exe** do [rpctools](https://resources.oreilly.com/examples/9780596510305/tree/master/tools/rpctools) pode interagir com esta porta. +### Enumeração de Interface Automatizada & Geração de Cliente Dinâmico (NtObjectManager) + +O guru do PowerShell **James Forshaw** expôs a maior parte dos internos do Windows RPC dentro do módulo de código aberto *NtObjectManager*. Usando-o, você pode transformar qualquer DLL / EXE de servidor RPC em um **stub de cliente totalmente funcional** em segundos – sem IDL, MIDL ou desmarshalling manual necessário. +```powershell +# 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 os tipos de parâmetro exatamente como aparecem no **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**: +```powershell +# 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: +```csharp +public int EfsRpcOpenFileRaw(out Marshal.NdrContextHandle ctx, string FileName, int Flags) { +// marshals parameters & calls opnum 0 +} +``` +O helper PowerShell `Get-RpcClient` pode criar um **objeto cliente interativo** para que você possa chamar o procedimento imediatamente: +```powershell +$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 **contornar Descritores de Segurança** que protegem pipes nomeados de alto privilégio. + +--- + +### Fuzzing RPC Consciente do Contexto (MS-RPC-Fuzzer) + +O conhecimento estático da interface é ótimo, mas o que você realmente deseja é **fuzzing guiado por cobertura** que entenda *handles de contexto* e cadeias de parâmetros complexas. O projeto de código aberto **MS-RPC-Fuzzer** automatiza exatamente esse fluxo de trabalho: + +1. Enumerar cada interface/procedimento exportado pelo binário alvo (`Get-RpcServer`). +2. Gerar clientes dinâmicos para cada interface (`Format-RpcClient`). +3. Randomizar parâmetros de entrada (comprimento de strings largas, intervalos de inteiros, enums) enquanto respeita o **tipo NDR** original. +4. Rastrear *handles de contexto* retornados por uma chamada para alimentar procedimentos subsequentes automaticamente. +5. Disparar chamadas de alto volume contra o transporte escolhido (ALPC, TCP, HTTP ou pipe nomeado). +6. Registrar status de saída / falhas / timeouts e exportar um arquivo de importação **Neo4j** para visualizar relacionamentos *interface → procedimento → parâmetro* e clusters de falhas. + +Exemplo de execução (alvo de pipe nomeado): +```powershell +Invoke-MSRPCFuzzer -Pipe "\\.\pipe\efsrpc" -Auth NTLM ` +-MinLen 1 -MaxLen 0x400 ` +-Iterations 100000 ` +-OutDir .\results +``` +Uma única gravação fora dos limites ou exceção inesperada será exibida imediatamente com o opnum exato + payload fuzzed que a acionou – ponto de partida perfeito para um exploit de prova de conceito estável. + +> ⚠️ Muitos serviços RPC são executados em processos que rodam como **NT AUTHORITY\SYSTEM**. Qualquer problema de segurança de memória aqui geralmente se traduz em escalonamento de privilégios local ou (quando exposto via SMB/135) *execução remota de código*. + +--- + ## Referências +- [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/)