Entenda como mapear serviços MS‑RPC para seus UUIDs no Windows, por que não existe um catálogo oficial “completo” e como correlacionar interfaces, versões e processos. Um guia prático para inventário, troubleshooting e segurança — sem depender de uma lista única.
Visão geral: MS‑RPC, interfaces e UUIDs
O Microsoft Remote Procedure Call (MS‑RPC) é a base de inúmeras funções do Windows (administração remota, impressão, compartilhamento de arquivos, Active Directory, DCOM, entre outras). A “unidade” lógica de um serviço RPC é a interface, definida em IDL (Interface Definition Language) e identificada de forma única por um UUID/GUID. Uma interface pode ser exposta por um ou mais processos, em diferentes endpoints (porta TCP, pipe nomeado, ALPC), usando “sequências de protocolo” como ncacniptcp, ncacnnp, ncalrpc e ncacnhttp.
Quando um cliente quer falar com um servidor, ele primeiro descobre onde a interface está disponível por meio do Endpoint Mapper (EPM), que roda na porta 135/TCP (ou via pipe \pipe\epmapper). Em seguida, ele negocia a versão (major/minor) da interface e estabelece o binding.
Perguntas do leitor — respostas objetivas
| Questão | Esclarecimento | Implicações práticas |
|---|---|---|
| Existe um catálogo oficial completo? | Não há uma tabela única e oficial que liste todos os serviços e respectivos UUIDs. A informação está espalhada em documentação de produtos, arquivos IDL/headers do Windows SDK, exemplos de código e ferramentas da comunidade. | Para descobrir mapeamentos, use utilitários de enumeração (por exemplo, rpcdump, rpcview, impacket-rpcdump) e análise de IDL/cabeçalhos do SDK. |
| Um serviço pode usar mais de um UUID? | Sim. É comum um mesmo produto/serviço expor múltiplas interfaces RPC, cada uma registrada com RpcServerRegisterIf e identificada por seu próprio UUID. | Trate cada interface de forma independente em inventários e auditorias; versões, ACLs e permissões de chamada podem diferir. |
| Dois serviços diferentes podem compartilhar o mesmo UUID ou um “UUID de combinação”? | Não. O UUID identifica uma interface específica e é globalmente único. Não existe “UUID de combinação”. Se você encontrar o mesmo UUID em locais diferentes, está vendo a mesma interface hospedada por processos distintos. | Evite “deduplicar” equivocadamente: o mesmo UUID em hosts/processos diferentes aponta para a mesma interface lógica. |
| Há UUIDs distintos quando muda a versão? | A mesma interface mantém o UUID e altera a versão (major/minor). O cliente só conecta se o major for igual e o minor do servidor for maior ou igual ao do cliente. Mudanças incompatíveis podem motivar criação de um novo UUID. | Em ambientes mistos, verifique versões antes de invocar chamadas para evitar falhas de compatibilidade. |
Conceitos que evitam confusões
Interface x serviço x processo x endpoint
| Termo | O que é | Exemplo |
|---|---|---|
| Interface | Contrato RPC (métodos, estruturas) com UUID e versão. | uuid(aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee), version(1.0) |
| Serviço | Conjunto funcional que pode expor uma ou várias interfaces. | “Serviço de Impressão” expondo interfaces de spooler e administração. |
| Processo | Binário que hospeda e registra a(s) interface(s) no EPM. | spoolsv.exe hospedando interfaces de impressão. |
| Endpoint | Coordenada de comunicação (porta TCP, pipe, ALPC) para a interface. | ncacnnp:[\\pipe\\spoolss], ncacnip_tcp:[49667] |
Endpoint Mapper (EPM)
O EPM cataloga quais endpoints implementam quais interfaces (UUID + versão). Ele não “sabe” tudo a priori; os servidores registram suas interfaces durante a inicialização ou sob demanda. Por isso não existe um catálogo universal pronto.
Versão major/minor e compatibilidade
- Major: precisa coincidir entre cliente e servidor; é a “quebra de contrato”.
- Minor: o servidor deve ser ≥ ao cliente; ampliações compatíveis normalmente incrementam o minor.
- Novo UUID: quando a evolução é incompatível, define-se uma interface totalmente nova.
Geração de UUIDs
Os UUIDs seguem RFC 4122 e são gerados por utilitários como uuidgen ou APIs equivalentes. Não há convenção de “codificar” serviço ou versão dentro do GUID.
Como descobrir o mapeamento na prática
A seguir, um fluxo comprovado para mapear interfaces, endpoints e processos sem depender de um “grande catálogo”. Ajuste conforme sua política de segurança e privacidade.
1) Enumere interfaces e endpoints via EPM
Use ferramentas de inventário/diagnóstico para listar as interfaces expostas por um host:
# Windows (exemplos)
rpcdump /s <HOST-OU-IP> # enumeração remota
rpcdump /s localhost # enumeração local
Suite Python (ex.: Impacket)
python3 rpcdump.py \ Saída típica (exemplo didático com valores fictícios):
Interface UUID: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee v1.0
prot seq: ncacniptcp endpoint: 49667
annotation: Example RPC Interface
Interface UUID: ffffffff-1111-2222-3333-444444444444 v2.2
prot seq: ncacn\_np endpoint: \pipe\example
annotation: Another Interface Guarde: UUID, versão, sequência de protocolo e endpoint.
2) Correlacione com o registro e o SDK
No Windows, chaves úteis:
HKCR\Interface\{UUID}— informações da interface e, às vezes, referência a TypeLib/Proxy‑Stub.HKLM\SOFTWARE\Microsoft\Rpc\Uuid— mapeamentos específicos de runtime (pode variar por versão do Windows).
Exemplo PowerShell para consultar rapidamente:
param([Parameter(Mandatory=$true)][string]$Uuid)
\$path = "Registry::HKEY\CLASSES\ROOT\Interface{\$Uuid}"
if (Test-Path \$path) {
Get-ChildItem \$path -Recurse | ForEach-Object {
New-Object psobject -Property @{
Path = \$*.PsPath
Name = \$*.GetValue("")
Keys = (Get-ItemProperty $\_.PsPath | Select-Object -ExcludeProperty PS\*)
}
} | Format-List \*
} else {
Write-Host "Interface {\$Uuid} não encontrada em HKCR:\Interface"
} 3) Descubra quem está hospedando (processo/serviço)
Se a ferramenta de enumeração não informar o processo, faça a correlação:
- Pipes nomeados: inspecione quais processos têm
\\pipe\\NOMEabertos. - TCP: identifique o PID que escuta a porta, depois descubra o serviço.
# Mapear porta → PID → serviço (Windows)
netstat -ano | findstr LISTENING | findstr 49667
tasklist /fi "PID eq <PID>"
sc queryex type= service | findstr /i "<NOME-DO-EXE>"
PowerShell, porta → processo
Get-NetTCPConnection -LocalPort 49667 | Select-Object LocalAddress,LocalPort,OwningProcess
Get-Process -Id \ | Select-Object Id,ProcessName,Path 4) Valide versão e comportamento
Se você precisa chamar métodos (teste funcional, automação), use stubs gerados a partir de IDL ou bibliotecas que já conhecem a interface. Confirme major/minor antes de invocar métodos que mudaram entre versões.
Exemplo didático: do UUID ao processo
Suponha que a enumeração retornou:
UUID: aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee v1.0
Sequência: ncacniptcp Endpoint: 49667
- Quem escuta 49667?
Get-NetTCPConnection -LocalPort 49667 | Select LocalAddress,OwningProcess Get-Process -Id <PID> - O que a interface representa?
reg query HKCR\Interface\{aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee} /s - Há outras interfaces no mesmo processo? Repita a enumeração por processo com ferramentas que cruzam interface⇄processo.
- Compatibilidade: se o cliente requer v1.1 e o servidor oferece v1.0, espere falhas ou métodos ausentes.
Construindo sua própria “tabela viva” de UUIDs
Como não existe um catálogo único, uma abordagem eficaz é gerar sua própria base por ambiente. A ideia é coletar, normalizar e armazenar periodicamente informações de UUID⇄Interface⇄Endpoint⇄Processo⇄Host.
Estrutura mínima sugerida
| Campo | Descrição |
|---|---|
| uuid | Identificador da interface (GUID). |
| version_major | Versão major suportada pelo servidor. |
| version_minor | Versão minor suportada pelo servidor. |
| protseq | Sequência de protocolo (ex.: ncacnip_tcp). |
| endpoint | Porta, pipe ou canal local. |
| pid | PID do processo hospedeiro. |
| process_name | Binário (ex.: svchost.exe). |
| service | Nome do serviço Windows (quando aplicável). |
| host | Hostname ou IP. |
| timestamp | Momento da coleta. |
Coleta com PowerShell (exemplo)
Exemplo simplificado para extrair interfaces do Registro e salvar um CSV local (útil para enriquecer a base com metadados):
$interfaces = Get-ChildItem 'Registry::HKEYCLASSESROOT\Interface' -ErrorAction SilentlyContinue
$result = foreach ($i in $interfaces) {
$guid = $i.PSChildName
$defaultName = (Get-ItemProperty $i.PSPath -ErrorAction SilentlyContinue).'(default)'
[pscustomobject]@{
uuid = $guid
name = $defaultName
path = $i.PSPath
}
}
$result | Export-Csv -NoTypeInformation -Encoding UTF8 -Path "$env:TEMP\interfaces-rpc.csv"
Write-Host "Arquivo gerado em $env:TEMP\interfaces-rpc.csv"
Combine esse CSV com a saída de enumeração de endpoints/processos para construir uma visão 360° do seu ambiente.
Canais de transporte (protocol sequences) — qual usar?
| Sequência | Descrição | Uso típico | Implicações de segurança |
|---|---|---|---|
ncacniptcp | TCP/IP | Admin remota, AD, serviços de infraestrutura. | Expõe porta; exigir firewall/ACL, autenticação e assinatura quando disponível. |
ncacn_np | SMB over pipe nomeado | Impressão, arquivos, serviços legados. | Depende de SMB; atenção a assinaturas SMB e endurecimento de permissões de pipe. |
ncalrpc | Canal local (ALPC) | Comunicação intra‑host | Não expõe rede; foco em isolamento de integridade e ACLs locais. |
ncacn_http | RPC sobre HTTP | Cenários atravessando proxies/firewalls | Permite transitar em 80/443; requer atenção a TLS e autenticação. |
Boas práticas para inventário, troubleshooting e segurança
- Escopo e autorização: enumere apenas sistemas sob sua responsabilidade. Ferramentas de varredura podem acionar alertas.
- Ambientes heterogêneos: documente quais versões de interface são esperadas em cada função (ex.: controladores de domínio, servidores de arquivos).
- Menos é mais: desabilite componentes e serviços RPC que não são necessários. Menos interfaces expostas = menor superfície de ataque.
- Firewall e segmentação: restrinja porta 135/TCP e portas dinâmicas RPC; avalie faixas dinâmicas com políticas de rede.
- Assinatura e criptografia: habilite quando suportado pelas interfaces críticas; preferir TLS em
ncacn_httpe assinatura SMB. - Registro de auditoria: monitore chamadas anômalas a interfaces sensíveis; correlacione UUIDs com eventos de segurança.
- Pipeline de “CMDB de UUIDs”: automatize a coleta e guarde histórico para detectar mudanças (novas interfaces, versões diferentes, endpoints inesperados).
- Teste de compatibilidade: em upgrades, valide major/minor com clientes críticos para evitar regressões.
Perguntas frequentes e armadilhas comuns
“Encontrei o mesmo UUID em dois processos diferentes. Bug?”
Não. É a mesma interface exposta por múltiplos hosts ou processos. O UUID é da interface, não do processo.
“Posso inferir a versão só pelo UUID?”
Não. UUID e versão são atributos distintos. Consulte o EPM ou a definição IDL para obter major.minor.
“Existe um ‘UUID de combinação’ para dois serviços cooperando?”
Não. Relações entre interfaces são expressas no design (métodos que chamam outros serviços), não via um GUID agregado.
“Por que não existe uma lista oficial única?”
Porque o ecossistema é vasto e dinâmico: o Windows e produtos dependentes introduzem/atualizam interfaces ao longo do tempo. O runtime RPC não mantém um índice global; ele registra o que está ativo naquele sistema.
Trecho IDL ilustrativo
Um simples exemplo em IDL que evidencia UUID e versão (valores fictícios):
[
uuid(aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee),
version(1.1),
pointer_default(unique)
]
interface ExampleIf
{
void Ping();
long GetStatus([out] long* code);
}
No servidor, essa interface seria registrada com RpcServerRegisterIf; no cliente, o binding incluirá o UUID e a versão para a negociação.
Checklist rápido (para colar no playbook)
- Enumerar EPM (porta 135/pipe) → capturar UUID, versão, prot_seq, endpoint.
- Resolver endpoint → PID → processo/serviço.
- Consultar
HKCR\Interface\{UUID}para metadados. - Cruzar com inventário/CMDB (host, função, compliance).
- Registrar baseline por função de servidor e monitorar desvios.
- Aplicar hardening (firewall, assinatura, desativação do que não é necessário).
Resumo para decisão
- Não há lista oficial abrangente de interface⇄UUID: mapeie no seu ambiente.
- Um serviço pode ter vários UUIDs (múltiplas interfaces).
- Dois serviços não partilham o mesmo UUID: se o GUID coincide, a interface é a mesma.
- Versões convivem por major/minor; mudanças incompatíveis podem introduzir novo UUID.
Apêndice: fontes comuns de informação (sem links)
| Fonte | Como ajuda | Observações |
|---|---|---|
| Windows SDK (IDL/headers) | Define interfaces, UUIDs, versões e estruturas. | Requer familiaridade com C/C++ e MIDL. |
| Ferramentas de enumeração | Listam UUIDs, endpoints e annotations em hosts. | Ex.: rpcdump, rpcview, impacket-rpcdump. |
| Registro do Windows | Metadados por interface e componentes Proxy‑Stub. | Nem sempre completo; depende do componente. |
| Projetos open‑source | Assinaturas e exemplos de mapeamento. | Úteis para análise de tráfego e testes. |
Conclusão
Mapear serviços MS‑RPC para UUIDs é menos sobre “decorar uma lista” e mais sobre entender a mecânica (interface, versão, endpoint) e instrumentar seu ambiente para observar o que realmente está exposto. Com um pipeline de enumeração + correlação + baseline, você conquista visibilidade operacional e reduz riscos — independentemente da ausência de um catálogo oficial único.