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

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