DLLHijackHunter

Por ProjectMerai

Descoberta, Validação e Confirmação Automatizada de DLL Hijacking
Transformando configurações incorretas locais em caminhos de ataque confirmados e armados.

Visão Geral

O DLLHijackHunter é uma ferramenta automatizada de detecção de DLL hijacking para Windows que vai além da análise estática. Ele descobre, valida e confirma oportunidades de DLL hijacking usando um pipeline de múltiplas fases:

1. Descoberta — Enumera binários em serviços, tarefas agendadas, itens de inicialização, objetos COM e vetores de bypass de UAC AutoElevate
2. Filtragem — Elimina falsos positivos por meio de portões rígidos e flexíveis inteligentes
3. Confirmação Canary — Implanta um DLL canary inofensivo e aciona o binário para provar que o hijack funciona
4. Pontuação e Relatórios — Classifica os achados por explorabilidade com um sistema de confiança em níveis

A maioria das ferramentas de DLL hijacking para em "este DLL pode ser sequestrável". O DLLHijackHunter tenta validá-lo, cruzá-lo com inteligência de exploração conhecida e confirmar caminhos de execução reais quando possível.

Arquitetura

flowchart TB
    subgraph Phase1["Fase 1: Descoberta"]
        SE["Mecanismo Estático<br/>Serviços, Tarefas, Inicialização,<br/>COM, Chaves Run"]
        AE["Mecanismo AutoElevate<br/>Manifesto + Bypass UAC COM"]
        PE["Analisador PE<br/>Tabelas de Importação, Cargas Atrasadas,<br/>Manifestos, Exportações"]
        ETW["Mecanismo ETW<br/>Monitoramento de Carga de DLL<br/>em Tempo Real"]
        SO["Calculadora de<br/>Ordem de Busca"]
    end

    subgraph Phase2["Fase 2: Pipeline de Filtragem"]
        direction LR
        HG["Portões Rígidos<br/>(Eliminação Binária)"]
        SG["Portões Flexíveis<br/>(Ajuste de Confiança)"]
    end

    subgraph Phase3["Fase 3: Verificação de Carga (--verify-load)"]
        LP["LoadProbe<br/>Teste de carregador em processo filho<br/>DLL de sonda colocada e removida"]
    end

    subgraph Phase4["Fase 4: Canary"]
        CB["Construtor de DLL Canary"]
        TE["Executor de Gatilho"]
        VF["Verificação"]
    end

    subgraph Phase5["Fase 5: Saída"]
        SC["Pontuador em Níveis"]
        RC["Relatório de Console"]
        RJ["Relatório JSON"]
        RH["Relatório HTML"]
    end

    SE --> PE --> SO
    AE --> PE
    ETW --> SO
    SO --> Phase2
    HG --> SG
    Phase2 --> Phase3
    Phase3 --> Phase4
    CB --> TE --> VF
    Phase4 --> Phase5

Principais Recursos

Cobertura de Tipos de Hijack

Entradas IFEO Debugger são enumeradas e o binário referenciado é analisado quanto a importações de DLL, mas não há um tipo de hijack IFEO/bypass de KnownDLL dedicado — esses não são anunciados como detecções independentes.

Descoberta de Bypass de UAC

O DLLHijackHunter inclui descoberta dedicada de bypass de UAC:

• AutoElevate de Manifesto — Verifica System32 e SysWOW64 em busca de EXEs com <autoElevate>true</autoElevate> em manifestos incorporados
• AutoElevação COM — Verifica HKLM\SOFTWARE\Classes\CLSID em busca de objetos COM com Elevation\Enabled=1
• Simulação de Side-Load — Para binários AutoElevate que não chamam SetDllDirectory ou SetDefaultDllDirectories, simula o caminho de ataque "copiar EXE para pasta gravável + soltar DLL"

Base de Conhecimento de Vulnerabilidades Direcionadas

• Mapeamento de vulnerabilidades direcionadas — Cruza importações descobertas com um instantâneo integrado do conjunto de dados HijackLibs (≈590 entradas de DLL documentadas abrangendo ≈700 executáveis vulneráveis), incorporado como Resources/hijacklibs.json. Uma correspondência aumenta a confiança e vincula o achado à página de referência do HijackLibs; a ausência de correspondência não significa nada. O conjunto de dados é orientado por dados — atualize-o baixando novamente https://hijacklibs.net/api/hijacklibs.json sobre esse recurso (sem necessidade de alterações de código). Conjunto de dados © o projeto HijackLibs e colaboradores.
• Exploração automatizada de PATH — Avalia pastas graváveis do PATH e gera candidatos a hijack para um mapa curado de serviços nativos do Windows conhecidos por buscar DLLs ausentes no PATH
• Caça expandida a DLLs fantasmas — Busca uma biblioteca de oportunidades de DLL fantasma de alto valor em várias categorias

Pipeline de Filtragem

O pipeline reduz falsos positivos por meio de dois estágios:

Portões Rígidos

• Filtragem de esquema de conjuntos de API (api-ms-*, ext-ms-*)
• Filtragem de KnownDLL
• Validação de gravabilidade ACL relativa ao atacante — um caminho conta como gravável somente se um principal não privilegiado (Users / Authenticated Users / Everyone, além de contas de serviço subadministrador à prova de vazamento como LOCAL SERVICE/NETWORK SERVICE) tiver direitos de escrita efetivos. Crucialmente, isso é calculado independentemente do token sob o qual a ferramenta é executada, então executar elevado não faz System32/Program Files parecerem graváveis. É isso que torna execuções elevadas significativas para triagem de LPE.

Portões Flexíveis

• Penalidade de manifesto WinSxS
• Análise de delta de privilégios
• Verificações de mitigação de LoadLibraryEx
• Verificações de validação de assinatura
• Penalidades de tratamento gracioso de erros

Confirmação Canary

Em vez de adivinhar, o DLLHijackHunter tenta provar que os hijacks funcionam:

sequenceDiagram
    participant H as DLLHijackHunter
    participant B as Construtor de DLL Canary
    participant T as Executor de Gatilho
    participant V as Binário Vítima

    H->>B: Construir DLL canary
    B->>B: Extrair canary pré-compilado<br/>(ou compilar um proxy com MSVC)
    B-->>H: canary.dll + caminho do arquivo de confirmação
    H->>H: Colocar DLL no caminho de hijack
    H->>T: Acionar execução do binário
    T->>V: Iniciar serviço / executar tarefa / ativar COM
    V->>V: Carrega DLL canary
    V-->>H: Grava arquivo de confirmação<br/>PID, privilégio, nível de integridade
    H->>H: Registrar: CONFIRMADO
    H->>H: Limpeza do DLL canary

O DLL canary:

• É fornecido pré-compilado para x64 e x86, incorporado no scanner, então nenhum compilador é necessário no momento da varredura. A arquitetura correta é selecionada para corresponder à bitness da vítima e extraída sob demanda.
• É autolocalizável: deriva o caminho do arquivo de confirmação em tempo de execução do próprio caminho do módulo carregado (%ProgramData%\DLLHijackHunter\canary_<hash>.confirm), então um único binário atende a todos os candidatos. O scanner calcula o mesmo hash a partir do caminho de implantação e verifica a existência desse arquivo.
• Usa um mecanismo de confirmação baseado em arquivo
• Captura metadados de execução como usuário, nível de integridade e indicadores de privilégio
• Não contém payload malicioso; é estritamente um mecanismo de detecção e validação
• Vincula estaticamente o CRT, então não tem dependência de tempo de execução (ucrtbase/vcruntime) no host vítima.

Os binários integrados são construídos a partir do código-fonte auditável em src/DLLHijackHunter/Resources/canary_src.c e podem ser regenerados com Resources/build_canary.bat (requer o toolchain C++ do MSVC; o scanner não requer).

Exceção de proxy funcional: Quando um hijack de ordem de busca visa um DLL que existe e expõe exportações, manter o host vivo após a confirmação requer um proxy de encaminhamento de exportações, que é compilado por DLL com MSVC (cl.exe, localizado via vswhere/vcvarsall). Se nenhum toolchain estiver presente, o canary pré-compilado é usado em vez disso — ele ainda confirma a carga (DllMain dispara), mas não encaminha exportações, então o processo host pode falhar após a confirmação ser registrada. Candidatos de DLL fantasma e outros sem exportações não precisam de compilador algum.

Assinatura: Os canaries incorporados não são assinados. Assiná-los digitalmente (para que carreguem sob políticas mais rígidas e sejam atribuíveis) requer um certificado de assinatura e fica como uma etapa de tempo de lançamento para o mantenedor.

Nota importante sobre o modo proxy/encaminhamento de exportações

Canaries de proxy/encaminhamento de exportações são experimentais e de melhor esforço. Alguns alvos podem falhar ao carregar corretamente ou se comportar inesperadamente dependendo de:

• exportações somente por ordinal
• nomes de exportação decorados
• incompatibilidades de convenção de chamada
• suposições do carregador/tempo de execução no processo alvo

Isso significa que um canary proxy com falha nem sempre indica que o caminho de hijack subjacente é impossível.

Verificação de Ordem de Carga (--verify-load)

Uma verificação opt-in, de usuário padrão, que fica entre o pipeline de filtragem e a fase canary. Para cada candidato aplicável, ela grava brevemente um DLL de sonda benigno na posição de hijack gravável e então pergunta ao carregador real do Windows — em um processo filho de curta duração — para resolver o DLL pelo nome. Onde o carregador resolve determina o veredito:

• Vitória verificada — o carregador escolhe a posição gravável. A alegação de ordem de busca é provada (essa corroboração permite que o achado alcance o nível Alto; a execução canary permanece o único caminho para Confirmado).
• Perde para protegido — o carregador escolhe um KnownDLL, a cópia do System32 ou uma cópia redirecionada por SxS. A posição quase certamente não é sequestrável, então o candidato é fortemente rebaixado. Isso captura os falsos positivos clássicos que um calculador estático de ordem de busca perde (por exemplo, um "achado" de .local/ordem de busca para ntdll.dll que os KnownDLLs tornam inexplorável).

Notas de design e segurança:

• Executa em um processo filho para que um nome já carregado no scanner não possa contornar o resultado, e para que qualquer efeito colateral de carga ou falha seja isolado. Nenhuma elevação é necessária.
• Cada sonda é colocada, resolvida e então removida; qualquer arquivo pré-existente é copiado e restaurado.
• Modela a ordenação moderna LOAD_LIBRARY_SEARCH, então é aplicada apenas a candidatos Fantasma / Ordem de Busca / Side-Load. Candidatos .local, PATH e AppInit/AppCert usam mecânicas diferentes e são relatados como Ignorados.
• Grava arquivos transitoriamente em posições candidatas (impacto médio); deixe desativado para triagem totalmente passiva e somente leitura.

# Triagem de usuário padrão com ordem de busca verificada pelo carregador (sem canary, sem ETW)
.\DLLHijackHunter.exe --lpe-only --no-canary --no-etw --verify-load

Comparação

Uso

Pré-requisitos

• Windows 10/11 ou Windows Server 2016+
• Runtime .NET 8.0 ou 10.0 (ou use uma compilação autocontida)
• Privilégios de administrador recomendados (necessários para ETW, implantação canary e alguns gatilhos de serviço)

Compilação

git clone https://github.com/ghostvectoracademy/DLLHijackHunter.git
cd DLLHijackHunter

# Compilar (arquivo único autocontido)
dotnet publish src/DLLHijackHunter/DLLHijackHunter.csproj `
    -c Release -r win-x64 --self-contained `
    -p:PublishSingleFile=true -o ./publish

# Ou use o script de compilação
.\build.ps1

Início Rápido

# Varredura agressiva completa (recomendada, requer admin)
.\DLLHijackHunter.exe --profile aggressive

# Varredura segura (sem gravação de arquivos, sem gatilhos)
.\DLLHijackHunter.exe --profile safe

# Varredura focada em bypass de UAC
.\DLLHijackHunter.exe --profile uac-bypass

# Visar um binário específico
.\DLLHijackHunter.exe --target "C:\Program Files\MyApp\app.exe"

# Visar por nome de arquivo (correspondência parcial)
.\DLLHijackHunter.exe --target notepad.exe

# Apenas achados confirmados
.\DLLHijackHunter.exe --profile redteam --format json -o report.json

Opções de CLI

DLLHijackHunter — Detecção Automatizada de DLL Hijacking

Opções:
  -p, --profile <profile>        Perfil de varredura [padrão: aggressive]
                                   aggressive | strict | safe | redteam | uac-bypass
  -o, --output <caminho>         Caminho do arquivo de saída (detecta formato automaticamente)
  -f, --format <formato>         Formato de saída [padrão: console]
                                   console | json | html
  -t, --target <alvo>            Visar binário, diretório ou nome de arquivo específico
      --min-confidence <valor>   Limiar mínimo de confiança 0-100. Quando omitido, o limiar
                                   de cada perfil se aplica; passá-lo o substitui.
      --no-canary                Desativar confirmação canary
      --no-etw                   Desativar descoberta em tempo de execução ETW
      --verify-load              Verificar ordem de busca com o carregador real (veja abaixo).
                                   Usuário padrão; grava transitoriamente uma sonda benigna.
      --confirmed-only           Mostrar apenas achados confirmados por canary
      --lpe-only                 Caça estrita a LPE: ignorar System32/Program Files, mostrar
                                   apenas vulnerabilidades graváveis por usuário padrão
      --log-file <caminho>       Gravar log de varredura de diagnóstico em arquivo
  -v, --verbose                  Saída detalhada

Nota: --min-confidence só é tratado como substituição quando você o passa explicitamente. Caso contrário, o limiar do perfil selecionado é usado (por exemplo, safe = 50%, strict = 80%).

Perfis de Varredura

Pontuação

Cada achado recebe sinais de confiança e impacto que são combinados em um nível final de priorização.

Considerações típicas de impacto incluem:

• privilégio obtido
• confiabilidade do gatilho
• furtividade
• persistência após reinicialização

A execução canary confirmada deve ser tratada como o sinal de validação mais forte.

Limitação de níveis: os níveis Alto e Confirmado são reservados para achados respaldados por um sinal de prova — um canary disparado, uma observação de carga em tempo de execução ETW ou uma correspondência documentada de base de conhecimento. Uma correspondência puramente estática de ordem de busca, por mais limpa que seja, é limitada ao topo do nível Médio e anotada como Somente estático para que heurísticas não verificadas nunca se apresentem como alta confiança.

Configuração recomendada de triagem

Como a gravabilidade é avaliada relativa ao atacante, execuções elevadas e de usuário padrão são significativas:

• Para triagem de LPE, a configuração mais confiável é uma execução de usuário padrão com --lpe-only (e --no-canary se um compilador não estiver disponível) — todo achado sobrevivente é genuinamente gravável por um principal não privilegiado.
• Execuções elevadas são necessárias para ETW e confirmação canary, e agora estão seguras da inversão histórica de "tudo em System32 parece gravável".

Segurança

O DLLHijackHunter é projetado para pesquisa de segurança defensiva, validação em laboratório, auditoria e simulação de red team em ambientes autorizados.

Use-o apenas em sistemas e redes que você possui ou para os quais está explicitamente autorizado a avaliar.

Notas operacionais

• O modo canary grava DLLs de teste em locais candidatos
• Alguns gatilhos podem iniciar ou parar brevemente serviços/tarefas durante a validação
• Canaries de proxy/encaminhamento de exportações podem desestabilizar alvos frágeis
• O perfil seguro é o modo preferido para triagem em produção quando gravação de arquivos e gatilhos não são aceitáveis

Saída

O DLLHijackHunter suporta:

• relatório de console
• exportação JSON
• exportação HTML

Fluxo de trabalho recomendado:

1. executar uma varredura ampla
2. revisar achados de alta confiança
3. usar confirmação canary seletivamente em caminhos de alto valor
4. preservar a saída JSON/HTML para relatórios e triagem

Licença

MIT

Créditos

Construído por ProjectMerai.