Skip to content
KitploitKITPLOIT
FerramentasExploitsBlog
Log in
Enviar
FerramentasExploitsBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
NoiseHound — 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. | Kitploit
Ferramentas/GitHubGitHub/warpedatom/noisehound
Ferramentas DefensivasEscalada de PrivilégiosMovimento LateralPós-ExploraçãoTestes de PenetraçãoRed TeamingAtaque Adversário
GitHubwarpedatom/noisehound

NoiseHound

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.

Ver Repositório
671071há 2 mesesRevisado pelo Kitploit
Compartilhar
Site
<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&amp;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&amp;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&amp;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
```
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 O kit definitivo de OSINT: grafo de investigação, pontuação de confiança, famílias de alias, mapa, linha do tempo e relatórios. 49 módulos, mais de 400 sites, sem necessidade de chaves de API.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicativo de Execução em Um Toque GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Plataforma autônoma de testes de penetração multiagente com LLM, com agentes planejador/executor, grafos de ativos e de exploração, registro de tráfego MITM e reteste de vulnerabilidades.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Kit de ferramentas de red team do lado do navegador com 102 ferramentas offline para reconhecimento, geração de payloads, ataques a credenciais, criptografia, codificação e relatórios de engajamento.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingere relatórios do Shadowserver no MongoDB e os reproduz como mapas interativos, análises, descobertas, avisos e painéis executivos.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    O sistema de ação para cibersegurança nativa em IA—onde a intenção se torna execução governada, a evidência se torna memória operacional, e cada operação melhora a próxima.

    282

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →