
Pontuação de caminhos de ataque do BloodHound com reconhecimento de deteção - a rota mais silenciosa para o seu objetivo, calibrada em cinco níveis de deteção (audit/EDR/Elastic/MDI/WDAC) mais Azure.
<p align="center"><img src="https://assets.kitploit.com/production/public/readmes/50019/502beed5defd8b7d32991f173f6339e3214eb604968886518cd026cc2e4d3ee5.png" alt="NoiseHound" width="600"></p>
<h1 align="center">NoiseHound</h1>
<p align="center">
<a href="https://pypi.org/project/noisehound/"><img src="https://img.shields.io/pypi/v/noisehound" alt="PyPI"></a>
<a href="https://github.com/warpedatom/NoiseHound/releases"><img src="https://img.shields.io/github/v/release/warpedatom/NoiseHound" alt="Release"></a>
<a href="https://github.com/warpedatom/noisehound/blob/main/LICENSE"><img src="https://img.shields.io/github/license/warpedatom/NoiseHound" alt="License"></a>
<img src="https://img.shields.io/badge/python-3.10+-3776AB?logo=python&logoColor=white" alt="Python 3.10+">
<a href="https://github.com/warpedatom/NoiseHound/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/warpedatom/NoiseHound/ci.yml?branch=main&label=CI" alt="CI"></a>
<a href="https://github.com/warpedatom/noisehound/blob/main/SECURITY.md"><img src="https://img.shields.io/badge/Security-Policy-green" alt="Security policy"></a>
<a href="https://x.com/warped_atom"><img src="https://img.shields.io/badge/X-@warped__atom-000000?logo=x&logoColor=white" alt="X (Twitter): @warped_atom"></a>
</p>
**Pontuação de caminhos de ataque em Active Directory com reconhecimento de detecção.**
_DreadHost Research | complementar ao OffsetInspect (PowerShell) e ao OffsetScan (Rust)_
O BloodHound (e o PlumHound por cima dele) encontra *um* caminho até o objetivo.
O NoiseHound ingere os mesmos dados de grafo e reordena os caminhos pelo **custo
esperado de detecção** em vez do número de saltos, para que um operador possa perguntar
"qual é a forma mais silenciosa de chegar a Domain Admin" em vez de apenas "qual é uma forma".
> **Novo por aqui? O [Operator Walkthrough](https://github.com/warpedatom/noisehound/blob/main/docs/WALKTHROUGH.md) é a forma mais rápida de
> ver o que isto faz** - um tour prático, com capturas de ecrã, desde a instalação até uma prova
> de conceito ao vivo com o BloodHound CE (pontuações escritas de volta na UI), o motor DeadAir,
> e o relatório de lacunas de detecção para a equipa azul.
> **Estado do projeto (v1.2.0):** estável e testado com dados reais do BloodHound em
> múltiplos domínios. **37 das 77 arestas do corpus são medidas em laboratório** em cinco
> níveis de deteção on-prem (auditoria do Windows, Defender for Endpoint, Elastic SIEM,
> alertas em tempo de execução do Defender for Identity e auditoria WDAC) mais um nível
> Azure/Entra medido - disponibilizados como seis perfis prontos a usar em [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles),
> com prova de ciclo fechado de que alteram o ranking dos caminhos ([`docs/VALIDATION.md`](https://github.com/warpedatom/noisehound/blob/main/docs/VALIDATION.md)).
> O corpus inclui 13 arestas **Azure/Entra** ([`docs/AZURE.md`](https://github.com/warpedatom/noisehound/blob/main/docs/AZURE.md)),
> ingeríveis diretamente a partir da saída do AzureHound.
> As arestas on-prem não medidas e todas as arestas Azure têm **estimativas de especialistas**; o
> harness de calibração (`noisehound-calibrate`) é a forma de as medir, a elas e ao seu próprio
> ambiente. Trate os rankings não calibrados como orientação bem fundamentada, não como verdade absoluta.
> Apenas para engagements autorizados. Esta ferramenta pontua caminhos de ataque para
> planeamento OPSEC contra sistemas para os quais tem permissão escrita de teste.
> O NoiseHound é um projeto comunitário independente. Não está afiliado, aprovado
> ou associado à SpecterOps ou ao projeto BloodHound; consome o formato de dados
> aberto do BloodHound.
---
## Como funciona
1. **Ingerir** uma exportação do BloodHound CE (`.zip`), um ficheiro JSON em bruto ou um diretório
de exportações para um grafo interno. Um formato JSON normalizado `{nodes, edges}` também
é aceite para análise offline e testes. As arestas de escalada **ESC1-8** do AD CS
são sintetizadas no momento do carregamento a partir dos factos de modelos de certificado e CA
que o BloodHound recolhe (ver abaixo).
2. **Anotar** cada aresta a partir do corpus de telemetria de arestas, atribuindo uma
`effective_noise_score` (0-100). Quando vários direitos ligam o mesmo par
de nós, é escolhido o mais silencioso. Os tipos de aresta ausentes do corpus assumem
por defeito uma pontuação conservadora (60), para que as lacunas falhem em segurança em vez de subnotificarem.
Um **perfil de ambiente** opcional ajusta as pontuações à postura de deteção declarada
do alvo (ver abaixo).
3. **Resolver** os caminhos mais silenciosos. Como a pontuação do caminho é um gargalo mais
a média (não uma soma simples), não pode ser optimizada directamente por Dijkstra. O
solucionador combina uma *varredura de limiares* (para cada nível de ruído distinto, a
rota mais silenciosa que fica abaixo dele) com uma passagem limitada de k-caminhos-mais-curtos-por-peso,
e depois reordena a união pela pontuação real do caminho. A varredura de limiares é o
garante de correção: revela um caminho longo mas uniformemente silencioso que uma pesquisa
puramente baseada na soma de pesos classificaria abaixo de um curto mas ruidoso.
4. **Reportar** como texto, JSON (interoperável com o esquema de resultados do OffsetInspect),
ou um relatório HTML autónomo com o estilo do conjunto de ferramentas.
### Pontuação de caminhos
O ruído do caminho **não** é deliberadamente uma soma simples. Acionar a mesma deteção
duas vezes não é duas vezes mais ruidoso (triagem de SOC, não contagem bruta de eventos). O NoiseHound usa:
```
path_score = max(edge_scores) * 0.6 + mean(edge_scores) * 0.4
```
Isso pondera para o passo único mais ruidoso (um passo ruim frequentemente compromete toda a operação) enquanto ainda contabiliza a exposição cumulativa. Os pesos são configuráveis (`--max-weight` / `--mean-weight`) para que possam ser ajustados empiricamente assim que dados reais de detecção estiverem disponíveis a partir de um laboratório APT29/Caldera.
Cada caminho também reporta uma **probabilidade de detecção** - a chance de disparar um alerta correlacionado - combinando a aresta mais ruidosa com o OR ruidoso cumulativo de todas as arestas (ajustado por `--correlation`). Ela responde a uma pergunta diferente da pontuação de ruído: um caminho curto mas ruidoso pode ter uma probabilidade geral *menor* de ser detectado do que um longo mas silencioso. Ordene por ela com `--rank-by probability`.
### Motor de dois níveis (DeadAir)
Para grafos grandes, a resolução é despachada para o [DeadAir](https://github.com/warpedatom/DeadAir), um motor Rust companheiro (o nível OffsetScan-to-OffsetInspect). O NoiseHound permanece como o frontend rico em recursos - ingestão, corpus, ambiente/Sigma, restrições, relatórios - e entrega o grafo preparado para o motor que o resolver, de modo que os resultados são idênticos de qualquer forma.
- `--engine auto` (padrão): DeadAir quando seu binário é encontrado *e* o grafo é grande (>= 5000 nós); o solucionador Python integrado caso contrário.
- `--engine python`: força o solucionador integrado (nenhum binário necessário).
- `--engine rust`: força o DeadAir (gera erro se o binário estiver ausente).
O DeadAir é encontrado via `$NOISEHOUND_DEADAIR`, depois `PATH`, depois a compilação irmã `../deadair/target/{release,debug}/`. Ele é 10-100x mais rápido em grafos grandes (um grafo de 250k nós resolve em ~2s vs ~30s em Python) enquanto produz rankings byte-idênticos. A saída registra qual motor foi executado.
### Caminhamento multiobjetivo e restrito
Ruído, contagem de saltos e probabilidade de detecção puxam em direções diferentes, então `--pareto` retorna a **fronteira de Pareto** - todo caminho que nenhum outro supera nos três ao mesmo tempo - em vez de forçar um único vencedor. E operações reais têm restrições: `--avoid NODE` mantém um caminho longe de um host específico (um jump box monitorado por EDR, um honeypot), e `--avoid-edge TYPE` recusa uma técnica (por exemplo, `--avoid-edge DCSync`). Ambos são repetíveis e re-resolvem em tempo real.
```bash
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --pareto
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --avoid FILESERVER01 --avoid-edge HasSession
```
---
## Como o NoiseHound se compara
O pathfinding ponderado do BloodHound não é novidade, então aqui está o posicionamento honesto:
- **BloodHound / BloodHound CE** encontram *um* caminho por contagem de saltos não ponderada. Sem modelo de ruído.
- **GoodHound** atribui custos às arestas e encontra os caminhos mais baratos, mas seu modelo de custo é a dificuldade de exploração e o risco de negócio, não o ruído de detecção.
- **PlumHound / ImproHound** fazem relatórios e análise de violação de camadas; nenhum dos dois resolve novamente para um caminho mais silencioso até o objetivo.
- **Mapeamentos de detecção** (Sigma, DeTT&CT, referências de event-ID para ATT&CK) são ricos, mas orientados a humanos e não vinculados aos tipos de aresta do BloodHound.
A contribuição do NoiseHound é a combinação: um corpus legível por máquina de arestas do BloodHound para telemetria de detecção, uma re-resolução ponderada por ruído enquadrada como OPSEC do operador ("o caminho mais silencioso até o DA"), um modelo de ambiente que se adapta à postura declarada de um alvo, e um ciclo de calibração que transforma detecções de laboratório em pontuações medidas. A matemática de grafos é commodity; o corpus e o enquadramento são o ponto central. Seu valor é tão bom quanto o corpus, e é por isso que a calibração e a contribuição da comunidade são de primeira classe - veja abaixo.
## Instalação
```bash
cd NoiseHound
python -m pip install -r requirements.txt # networkx>=3.0
# optional editable install to get the `noisehound` command on PATH:
python -m pip install -e .
```
Requer Python 3.10+.
## Uso
```bash
# Text summary (default)
python -m noisehound --input export.zip --objective "Domain Admins" --source jdoe
# JSON, for downstream tooling / correlation across the DreadHost suite
python -m noisehound -i export.zip -o "Domain Admins" -s jdoe -f json --out paths.json
# Self-contained HTML report
python -m noisehound -i export.zip -o "Domain Admins" -s jdoe -f html --out report.html
```
Primeiro, faça uma verificação de sanidade do parser na sua exportação (histogramas + cobertura do corpus, sem pathing) - a forma mais rápida de validar o NoiseHound em dados do mundo real:
```bash
noisehound-inspect -i export.zip
```
### BloodHound CE / Neo4j em tempo real
Em vez de um zip, aponte `--input` para o banco de dados Neo4j que o BloodHound CE popula
e o NoiseHound lê o grafo (já analisado) diretamente via Bolt:
```bash
pip install 'noisehound[neo4j]'
export NEO4J_PASSWORD=bloodhoundcommunityedition # match your BHCE compose
noisehound-inspect -i bolt://localhost:7687
python -m noisehound -i bolt://localhost:7687 -s jdoe -o "Domain Admins"
```
Implante o BloodHound CE (que inclui o Neo4j na porta 7687) com seu compose oficial:
`curl -L https://ghst.ly/getbhce | docker compose -f - up`.
Experimente com as amostras incluídas:
```bash
python -m noisehound -i samples/sample_graph.json -s jdoe -o "Domain Admins" -d CONTOSO.LOCAL
python -m noisehound -i samples/sample_bloodhound_ce.zip -s jdoe -o "Domain Admins"
python -m noisehound -i samples/sample_adcs_ce.zip -s jdoe -o "Domain Admins" # ADCS ESC1
# Full-spectrum export exercising every edge family (sessions, delegation, DCSync, ADCS, trusts):
python -m noisehound -i samples/sample_fullspectrum_ce.zip -s ALICE -o "Domain Admins" -d CONTOSO.LOCAL -k 3
```
Esse último é a demonstração mais clara da tese: a rota mais silenciosa para
Domain Admins é o caminho de sessão de 4 saltos, classificado *acima* do caminho RDP de 3 saltos e do
ADCS ESC1 de 1 salto - mais saltos, menos ruído.
A amostra demonstra o valor central: a rota mais silenciosa é um caminho de sessão de 4 saltos
(pontuação 19,9), classificada *acima* de um atalho ForceChangePassword de 2 saltos (36,4).
Menos saltos não significa mais silencioso.
### Modo de lacuna de detecção para blue team
O caminho mais silencioso é onde a detecção é mais fraca, então adicione `--defensive` para inverter
a saída para os defensores: ele sinaliza as arestas que são silenciosas apenas porque sua
telemetria está desligada ou ausente, mapeia cada uma para o controle que a detectaria e
classifica esses controles por quanto eles elevam a pontuação do caminho mais silencioso.
```bash
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --defensive
```
No exemplo de espectro completo, descobre-se que o caminho mais silencioso para Domain Admins depende de acesso não detetado ao LSASS (`HasSession`, 20 -> 65 se instrumentado) e recomenda a implementação do Sysmon Event 10 — fechar essa única lacuna eleva o caminho mais silencioso de 19,9 para 48,4. Consulte [`docs/ROADMAP.md`](https://github.com/warpedatom/noisehound/blob/main/docs/ROADMAP.md) para saber para onde isto e o resto do modelo se dirigem.
### Opções principais
| Opção | Significado |
|--------|---------|
| `--input, -i` | BloodHound `.zip`, `.json`, ou diretório de exportações |
| `--source, -s` | Principal de partida (`jdoe` ou um id de objeto) |
| `--objective, -o` | Nó de destino (`Domain Admins` ou um id de objeto) |
| `--paths, -k` | Número de caminhos mais silenciosos a devolver (predefinição 5) |
| `--format, -f` | `text` (predefinição), `json`, ou `html` |
| `--defensive` | Vista de blue-team: lacunas de deteção nos caminhos mais silenciosos + correções |
| `--rank-by` | `noise` (predefinição) ou `probability` (P de um alerta correlacionado) |
| `--correlation` | Coeficiente de correlação do SOC para P(detetado), 0..1 (predefinição 0.5) |
| `--pareto` | Devolve a fronteira de Pareto sobre ruído/hops/P(detetado) |
| `--engine` | `auto` (predefinição), `python`, ou `rust` (o motor DeadAir) |
| `--avoid NODE` | Exclui um nó de todos os caminhos (repetível) |
| `--avoid-edge TYPE` | Exclui um tipo de aresta de todos os caminhos (repetível) |
| `--corpus` | Substitui o diretório do corpus de mapeamento de arestas |
| `--environment, -e` | JSON de postura do alvo declarada pelo operador (ajusta as pontuações) |
| `--max-weight` / `--mean-weight` | Pesos de pontuação (devem somar 1.0) |
| `--default-noise` | Pontuação para tipos de aresta ausentes do corpus (predefinição 60) |
---
## Perfis de ambiente
Uma pontuação estática do corpus não consegue saber se um determinado alvo tem a auditoria de objetos 4662 ativada, inclui Sysmon, ou executa um ITDR como o MDI — no entanto, esses fatores alteram enormemente o ruído real de uma aresta (o DCSync é quase silencioso sem auditoria 4662 e quase certo de ser detetado com ela). Em vez de fingir que um único número serve para todos os ambientes, declare a postura do alvo num pequeno ficheiro JSON e o NoiseHound ajusta as pontuações de forma transparente em relação às anotações de telemetria do próprio corpus:
```json
{
"name": "CONTOSO.LOCAL-prod",
"object_auditing_4662": true,
"ds_change_auditing_5136": false,
"edr": "MDI",
"sysmon": true,
"powershell_logging_4104": true,
"adjustments": { "HasSession": 65 }
}
```
Os ajustes apenas *elevam* uma pontuação em direção a um piso de detecção implícito pela postura declarada. `adjustments` são substituições rígidas por aresta - o local para registrar valores que você calibrou com base no seu próprio laboratório. Isso é fornecido pelo operador, não medido; não substitui a validação ao vivo da Fase 2, mas transforma o corpus estático de "um número para todos os ambientes" em "o número para o ambiente em que você realmente está". Na amostra incluída, declarar o perfil acima inverte a rota mais silenciosa do caminho de sessão de dump do LSASS para um caminho de escrita em diretório - o que é a decisão correta quando a telemetria do host está ativa.
```bash
python -m noisehound -i samples/sample_graph.json -s jdoe -o "Domain Admins" \
-e samples/env_profile.example.json
```
Precedência de pontuação: `static -> environment-adjusted -> live (Phase 2)`.
---
## Harness de calibração
Perfis de ambiente só são tão bons quanto os números que você coloca neles.
`noisehound-calibrate` fecha o ciclo: execute as técnicas em um laboratório de detecção,
registre o que disparou, e ele emite um perfil de ambiente calibrado.
**Isso já foi feito.** [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles) inclui seis perfis medidos de um
range real de Hyper-V Vulnerable-AD e de um tenant Azure de laboratório - audit, EDR (Defender for
Endpoint), Elastic SIEM, Defender for Identity, e camadas WDAC, além de uma camada medida
Azure/Entra, 37 arestas - produzidos pelo harness automatizado (`lab/`) e por esta
ferramenta. Use-os diretamente, ou meça os seus próprios:
```bash
# Use a shipped measured profile:
noisehound -i export.zip -s jdoe -o "Domain Admins" -e profiles/vulnad-hyperv-audit.json
# Or measure your own lab:
# 1. noisehound-calibrate --plan -o plan.json (per-edge detection events)
# 2. lab/Invoke-NoiseHoundCalibration.ps1 (run + auto-count -> lab_detections.json)
noisehound-calibrate -i lab_detections.json -o env.calibrated.json
noisehound -i export.zip -s jdoe -o "Domain Admins" -e env.calibrated.json
```
O modelo de pontuação é um estimador de encolhimento, honesto quanto ao tamanho da amostra:
```
p = detections / runs (detection probability)
lab_score = p * severity_loudness + (1 - p) * residual
w = runs / (runs + smoothing) (confidence in the lab)
calibrated = w * lab_score + (1 - w) * corpus_static
```
`lab_score` é o custo de detecção esperado — a severidade do SOC quando dispara, um pequeno resíduo quando não dispara. O peso `w` impede que uma única execução sobreponha-se ao corpus, ao mesmo tempo que permite que um resultado bem amostrado domine. No exemplo, HasSession sobe de um estático 20 para 52 (o laboratório detetou o dump do LSASS em 4 de 5 execuções), enquanto Kerberoast desce de 60 para 34 (nunca disparou). Use `--merge existing.json` para sobrepor a nova calibração a um perfil, mantendo as suas flags de postura, e `--smoothing` / `--residual` para ajustar o modelo.
---
## Pontuar contra deteções implementadas (Sigma)
Os perfis de ambiente e a calibração são autodeclarados. O `noisehound-sigma` pontua contra as deteções que um defensor *realmente escreveu*: aponte-o para um conjunto de regras Sigma e ele determina em que arestas do corpus cada regra dispararia (correspondendo aos event IDs de telemetria e à técnica ATT&CK da aresta), emitindo depois um perfil de ambiente que eleva as arestas cobertas — um substituto direto para `--environment`.
```bash
noisehound-sigma -r ./sigma-rules/ -o env.sigma.json
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" -e env.sigma.json --defensive
```
Para a camada de identidade, o **`noisehound-mdi`** faz o mesmo em relação às detecções integradas do Microsoft Defender for Identity - ele mapeia os alertas de runtime do MDI (e, com `--include-posture`, suas avaliações ISPM) para as arestas do corpus e emite um perfil de camada de identidade. O MDI é agnóstico em relação a ferramentas, portanto sua cobertura se mantém independentemente das ferramentas do atacante.
```bash
noisehound-mdi -o env.mdi.json # + coverage report (which edges MDI watches, and the gaps)
```
Para as arestas do **Azure/Entra**, o **`noisehound-entra`** mede a camada de nuvem da mesma forma que as camadas on-premises foram medidas: aciona os abusos `AZ*` em um tenant de laboratório, exporta o registro de `directoryAudits` do Entra e conta o que realmente foi registrado em um perfil calibrado (`docs/AZURE_CALIBRATION.md`).
```bash
noisehound-entra -a directoryAudits.json -m entra_runs.json --profile-out profiles/lab-tenant-azure.json
```
A correspondência é deliberadamente conservadora para nunca ocultar uma lacuna: uma regra só conta se referenciar um ID de evento que a aresta gera *e*, quando a regra tem tag ATT&CK, se a sua técnica concordar — assim, uma regra DCSync DS-Access (4662) não é creditada indevidamente por cobrir leituras LAPS que apenas compartilham o ID de evento. O relatório lista tanto o que as suas regras cobrem como, mais utilmente, as arestas de ataque que nenhuma regra cobre. Combinado com `--defensive`, isto responde a "dadas as deteções que tenho implementadas, onde está o meu caminho de ataque mais silencioso ainda invisível?"
### Inventário ao vivo do Elastic Security
`noisehound-elastic` responde à mesma pergunta em relação a deteções que estão **realmente ativas neste momento** numa stack Elastic Security em execução, em vez de regras em disco. Lê o motor de deteção através da API `_find` de apenas leitura do Kibana (ou de uma exportação offline), mapeia a técnica ATT&CK de cada regra ativa e quaisquer códigos de evento Windows na sua query, e emite o mesmo perfil de cobertura `--environment`.
```bash
export KIBANA_URL=https://kibana:5601 KIBANA_API_KEY=<base64 ApiKey>
noisehound-elastic -o env.elastic.json # live, read-only
noisehound-elastic --rules-json rules_find.json -o env.elastic.json # offline export
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" -e env.elastic.json --defensive
```
Ele reutiliza o matcher Sigma e adiciona um nível apenas de técnica (marcado como `[technique]`, com pontuação mais baixa) para as regras comportamentais KQL/EQL que nunca nomeiam um código de evento. Regras desativadas são ignoradas. O mesmo padrão de normalizar-e-pontuar para Splunk / Sentinel / MDI a seguir.
---
## AD CS ESC1-8
No momento do carregamento, o NoiseHound executa uma versão focada do pós-processamento ADCS do BloodHound, sintetizando arestas de escalação a partir dos fatos retidos de template/CA. Um direito `Enroll` num template vulnerável torna-se uma aresta direta `ADCSESCn` do principal para o grupo Domain Admins do domínio (RID 512), de modo que a escalação por certificado é navegável e pontuada como qualquer outra aresta:
| Aresta | Condição |
|------|-----------|
| `ADCSESC1` | Enrollee-supplies-subject + EKU de autenticação de cliente, sem aprovação/assinaturas RA |
| `ADCSESC2` | EKU Any-Purpose / SubCA, sem aprovação |
| `ADCSESC3` | Template de agente de inscrição + um template de autenticação na mesma CA |
| `ADCSESC4` | Controlo de escrita perigoso sobre um template publicado |
| `ADCSESC5` | Controlo do objeto CA ou do computador que o aloja |
| `ADCSESC6` | A CA tem `EDITF_ATTRIBUTESUBJECTALTNAME2` definido |
| `ADCSESC7` | `ManageCA` / `ManageCertificates` na CA |
| `ADCSESC8` | Endpoint de inscrição web HTTP vulnerável (coerce + NTLM relay) |
Experimente: `python -m noisehound -i samples/sample_adcs_ce.zip -s jdoe -o "Domain Admins"`.
Simplificações documentadas (falham de forma segura no sentido de mostrar mais caminhos): as restrições de inscrição ao nível da CA não são modeladas (a inscrição no template é considerada suficiente); o ESC5 abrange o objeto CA e o seu host, não todos os contentores PKI; ESC9/10/13 estão fora do âmbito. As arestas ESC sintéticas já presentes numa exportação pós-processada são preservadas.
---
## O corpus (`edge_mappings/`)
O corpus de telemetria de arestas é a verdadeira propriedade intelectual desta ferramenta; o código é matemática de grafos comparativamente simples por cima dele. Cada `edge_mappings/<Edge>.json` mapeia um tipo de aresta do BloodHound para a sua superfície de deteção:
- fontes de telemetria esperadas (Windows Security Event IDs, Sysmon Event IDs, rede, heurísticas EDR/ITDR) com fiabilidade por fonte e se a auditoria relevante está ativa por predefinição
- uma pontuação de ruído estática (0-100)
- técnica MITRE, privilégio de pré-requisito, a primitiva de abuso habitual e notas
```json
{
"edge_type": "DCSync",
"static_noise_score": 85,
"telemetry": [
{"source": "windows_security", "event_id": 4662,
"detail": "Directory Service Access - requires object auditing (default OFF)",
"reliability": "high_if_auditing_enabled", "default_enabled": false},
{"source": "edr_heuristic", "product_class": "MDI",
"detail": "Non-DC hosts issuing DRSGetNCChanges - high fidelity",
"reliability": "high"}
],
"mitre_technique": "T1003.006",
"notes": "Assumes default audit policy (mostly OFF) but high EDR/MDI coverage."
}
```
A ampliação do corpus é onde a maior parte do esforço contínuo deve ser investida. Adicione um novo arquivo JSON, mantenha o schema (validado no momento do carregamento), e ele é incorporado automaticamente. A v0.3 traz 43 tipos de aresta cobrindo as arestas de abuso de ACL, Kerberos, delegação, ADCS ESC1-8, LAPS/gMSA, GPO, confiança e direitos de acesso que importam para o path-finding.
As pontuações são semeadas a partir da matriz de ruído do DreadHost Red Team Operator Playbook (mapeamentos de eventos Windows/Sysmon, classificações de ruído de técnicas) e de fatos padrão de detecção de AD. Ajuste-as com base nos dados de detecção do seu próprio laboratório.
---
## Roadmap
- **Cobertura Azure / Entra ID (fundação entregue, em expansão).** 13 arestas de caminho de ataque `AZ*` agora são entregues com telemetria de detecção nativa do Entra - consulte [`docs/AZURE.md`](https://github.com/warpedatom/noisehound/blob/main/docs/AZURE.md). Dados do Azure coletados via AzureHound no BloodHound CE já são pontuados hoje (`noisehound -o "Global Administrator"`), e a ingestão nativa do AzureHound, além de um nível de calibração medido para Azure/Entra (`noisehound-entra`, `profiles/lab-tenant-azure.json`), também já são entregues. Próximo passo: perfis de postura do Entra (MDCA / ID Protection / Sentinel) e arestas híbridas (Entra Connect / PHS-PTA) para que o **MDI** contribua através da fronteira on-prem/cloud.
- **Concluir a calibração - 37/77 medidos, em andamento.** As ~40 arestas restantes (coerção/relay, ADCS ESC2-13, CanRDP em bare metal), calibração mais profunda em múltiplos ambientes e um corpus multi-EDR (CrowdStrike/S1 ao lado do MDE), além de calibração de ferramentas por aresta para ampliar o eixo `--tooling`.
- **Síntese de ADCS ESC10a/10b/13** (a síntese de ESC1-9 já é entregue).
Entregues: o motor em Rust ([DeadAir](https://github.com/warpedatom/DeadAir), despacho via `--engine`), ingestão ao vivo via Neo4j Bolt (`--input bolt://...`), o eixo selecionável **`--tooling`** (off-the-shelf-no-host vs remoto/nativo; `docs/TOOLING_AXIS.md`), o hook da Fase 2 **`--live-scores`** (pontuações medidas substituem o corpus/ambiente) e **`noisehound-mdi`** (cobertura do Defender for Identity -> perfil de nível de identidade). O trabalho restante do MDI é a *calibração de alertas em tempo de execução* condicionada ao laboratório (`docs/CALIBRATION.md`).
## Contribuindo
O corpus é extensível pela comunidade e é aí que as contribuições mais importam. Adicionar uma aresta é um único arquivo JSON validado no carregamento e na CI:
```bash
noisehound-validate # schema + consistency checks over the corpus
python -m pytest tests/ -q
```
Consulte [CONTRIBUTING.md](https://github.com/warpedatom/noisehound/blob/main/CONTRIBUTING.md) para o esquema, o guia de pontuação e as orientações para PR, e [`docs/edge_schema.json`](https://github.com/warpedatom/noisehound/blob/main/docs/edge_schema.json) para o esquema formal de arestas.
## Calibração com um laboratório
30 arestas são medidas (consulte [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles)); as restantes são estimativas até que as meça, e cada ambiente é diferente. [`docs/CALIBRATION.md`](https://github.com/warpedatom/noisehound/blob/main/docs/CALIBRATION.md) é um manual completo: topologia do laboratório, a política de auditoria do Windows e a configuração do Sysmon exatas para fazer disparar os IDs de evento do corpus, um runbook de exercício por aresta, uma camada de realismo APT29-via-Caldera, e como compilar os resultados num perfil calibrado. Comece com `noisehound-calibrate --template -o lab_detections.json`.
O kit [`lab/`](https://github.com/warpedatom/noisehound/blob/main/lab) automatiza a instrumentação de deteção: `Enable-Telemetry.ps1` ativa a política de auditoria, o registo de blocos de script, a SACL de DCSync e o Sysmon; `Collect-Detections.ps1` contabiliza o que disparou numa janela. Apoia-se no [GOAD](https://github.com/Orange-Cyberdefense/GOAD) ou no [Vulnerable-AD](https://github.com/WazeHell/vulnerable-AD) (ou em qualquer AD de laboratório de treino existente) para o próprio domínio vulnerável, em vez de os reimplementar.
## Utilização responsável
O NoiseHound destina-se a testes de segurança autorizados, exercícios de purple team, engenharia de deteção e investigação. Lê dados do BloodHound que já recolheu e calcula rankings; não executa nada contra um alvo. Utilize-o apenas onde tiver autorização escrita explícita. As contribuições não devem incluir dados específicos de alvos ou de compromissos reais.
## Testes
```bash
python -m pytest tests/ # with pytest
python tests/test_noisehound.py # dependency-light smoke run
```
## Layout
```
noisehound/ engine: schema, corpus, ingest, adcs, annotate, environment,
solver, report, cli, calibrate
edge_mappings/ the telemetry corpus (one JSON per edge type) - the IP
samples/ sample_graph.json, sample_bloodhound_ce.zip, sample_adcs_ce.zip,
sample_fullspectrum_ce.zip, env_profile.example.json,
lab_detections.example.json, sample_report.html
tests/ unit + end-to-end tests
```