Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
NoiseHound — Scoring des chemins d'attaque BloodHound tenant compte de la détection - la route la plus discrète vers votre objectif, calibrée sur cinq niveaux de détection (audit/EDR/Elastic/MDI/WDAC) ainsi qu'Azure. | Kitploit
Outils/GitHubGitHub/warpedatom/noisehound
Outils DéfensifsEscalade de PrivilègesMouvement LatéralPost-ExploitationTests d'IntrusionRed TeamingAttaque Adversariale
GitHubwarpedatom/noisehound

NoiseHound

Scoring des chemins d'attaque BloodHound tenant compte de la détection - la route la plus discrète vers votre objectif, calibrée sur cinq niveaux de détection (audit/EDR/Elastic/MDI/WDAC) ainsi qu'Azure.

Voir le dépôt
671071il y a 2 moisVérifié par Kitploit
Partager
Site web
<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>

**Notation des chemins d'attaque Active Directory tenant compte de la détection.**
_DreadHost Research | compagnon d'OffsetInspect (PowerShell) et OffsetScan (Rust)_

BloodHound (et PlumHound par-dessus) trouve *un* chemin vers l'objectif.
NoiseHound ingère les mêmes données de graphe et reclasse les chemins selon le **coût de détection attendu** plutôt que selon le nombre de sauts, afin qu'un opérateur puisse se demander « quel est le moyen le plus discret d'atteindre Domain Admin » plutôt que simplement « quel est un moyen d'y parvenir ».

> **Nouveau ici ? Le [Operator Walkthrough](https://github.com/warpedatom/noisehound/blob/main/docs/WALKTHROUGH.md) est le moyen le plus rapide de
> voir ce que fait cet outil** - une visite pratique, guidée par captures d'écran, de l'installation à une preuve de concept BloodHound CE en conditions réelles (scores réécrits dans l'interface), le moteur DeadAir, et le rapport de lacunes de détection pour la blue team.

> **État du projet (v1.2.0) :** stable et testé sur des données BloodHound réelles sur
> plusieurs domaines. **37 des 77 arêtes du corpus sont mesurées en laboratoire** sur cinq
> niveaux de détection on-prem (audit Windows, Defender for Endpoint, Elastic SIEM,
> alertes d'exécution Defender for Identity, et audit WDAC) plus un niveau Azure/Entra
> mesuré - livrés sous forme de six profils prêts à l'emploi dans [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles), avec
> une preuve en boucle fermée qu'ils modifient le classement des chemins ([`docs/VALIDATION.md`](https://github.com/warpedatom/noisehound/blob/main/docs/VALIDATION.md)).
> Le corpus inclut 13 arêtes **Azure/Entra** ([`docs/AZURE.md`](https://github.com/warpedatom/noisehound/blob/main/docs/AZURE.md)),
> ingérables directement depuis la sortie d'AzureHound.
> Les arêtes on-prem non mesurées et toutes les arêtes Azure portent des **estimations
> d'experts** ; le harnais de calibration (`noisehound-calibrate`) est le moyen de les mesurer, ainsi que votre propre environnement. Considérez les classements non calibrés comme des indications bien raisonnées, et non comme une vérité terrain.

> Pour les engagements autorisés uniquement. Cet outil note les chemins d'attaque pour la planification OPSEC
> contre des systèmes pour lesquels vous disposez d'une autorisation écrite de test.

> NoiseHound est un projet communautaire indépendant. Il n'est ni affilié à,
> ni approuvé par, ni associé à SpecterOps ou au projet BloodHound ; il
> consomme le format de données ouvert de BloodHound.

---

## Fonctionnement

1. **Ingérer** un export BloodHound CE (`.zip`), un fichier JSON brut ou un répertoire
   d'exports dans un graphe interne. Un format JSON normalisé `{nodes, edges}` est
   également accepté pour l'analyse hors ligne et les tests. Les arêtes d'escalade
   AD CS **ESC1-8** sont synthétisées au chargement à partir des faits sur les
   modèles de certificats et les CA collectés par BloodHound (voir ci-dessous).
2. **Annoter** chaque arête à partir du corpus de télémétrie d'arêtes, en attachant un
   `effective_noise_score` (0-100). Lorsque plusieurs droits relient la même paire
   de nœuds, le plus discret est choisi. Les types d'arêtes absents du corpus
   reçoivent par défaut un score conservateur (60) afin que les lacunes échouent en
   sécurité plutôt que de sous-estimer. Un **profil d'environnement** optionnel
   ajuste les scores selon la posture de détection déclarée de la cible (voir ci-dessous).
3. **Résoudre** les chemins les plus discrets. Comme le score de chemin est un
   goulot d'étranglement plus une moyenne (et non une simple somme), il ne peut pas
   être optimisé directement par Dijkstra. Le solveur combine un *balayage de seuils*
   (pour chaque niveau de bruit distinct, la route la plus discrète qui reste en
   dessous) avec une passe bornée des k-plus-courts-par-poids, puis reclasse
   l'union selon le score de chemin réel. Le balayage de seuils est le filet de
   sécurité de correction : il fait émerger un chemin long mais uniformément
   discret qu'une recherche pure sur le poids cumulé classerait en dessous d'un
   chemin court mais bruyant.
4. **Rapporter** en texte, JSON (interopérable avec le schéma de résultat
   OffsetInspect) ou un rapport HTML autonome stylisé pour correspondre à la boîte à outils.

### Notation des chemins

Le bruit d'un chemin n'est délibérément **pas** une simple somme. Déclencher la même
détection deux fois n'est pas deux fois plus bruyant (triage SOC, pas un comptage brut
d'événements). NoiseHound utilise :

```
path_score = max(edge_scores) * 0.6 + mean(edge_scores) * 0.4
```

Ceci pondère vers l'étape unique la plus bruyante (une mauvaise étape consume souvent toute l'opération) tout en tenant compte de l'exposition cumulée. Les poids sont configurables
(`--max-weight` / `--mean-weight`) afin de pouvoir être ajustés empiriquement une fois de vraies
données de détection disponibles à partir d'un labo APT29/Caldera.

Chaque chemin rapporte également une **probabilité de détection** - la chance qu'il déclenche une
alerte corrélée - en combinant l'arête la plus bruyante avec le noisy-OR cumulé de toutes
les arêtes (ajusté par `--correlation`). Elle répond à une question différente du score de bruit :
un chemin court mais bruyant peut avoir une probabilité globale d'être
détecté *plus faible* qu'un chemin long mais discret. Classez selon celle-ci avec `--rank-by probability`.

### Moteur à deux niveaux (DeadAir)

Pour les grands graphes, la résolution est déléguée à [DeadAir](https://github.com/warpedatom/DeadAir), un moteur
Rust compagnon (le niveau OffsetScan-to-OffsetInspect). NoiseHound reste le
frontend riche en fonctionnalités - ingestion, corpus, environnement/Sigma, contraintes,
rapports - et transmet le graphe préparé au moteur qui le résout, de sorte que
les résultats sont identiques dans les deux cas.

- `--engine auto` (par défaut) : DeadAir lorsque son binaire est trouvé *et* que le graphe est
  grand (>= 5000 nœuds) ; sinon le solveur Python intégré.
- `--engine python` : force le solveur intégré (aucun binaire nécessaire).
- `--engine rust` : force DeadAir (erreur si le binaire est absent).

DeadAir est trouvé via `$NOISEHOUND_DEADAIR`, puis `PATH`, puis le build voisin
`../deadair/target/{release,debug}/`. Il est 10 à 100 fois plus rapide sur les grands graphes
(un graphe de 250k nœuds se résout en ~2s contre ~30s en Python) tout en produisant des
classements identiques octet pour octet. La sortie enregistre quel moteur a été exécuté.

### Cheminement multi-objectif et contraint

Le bruit, le nombre de sauts et la probabilité de détection tirent dans des directions différentes, donc
`--pareto` renvoie la **frontière de Pareto** - chaque chemin qu'aucun autre ne bat sur
les trois à la fois - au lieu de forcer un seul gagnant. Et les opérations réelles
ont des contraintes : `--avoid NODE` garde un chemin à l'écart d'un hôte spécifique (un
jump box surveillé par EDR, un honeypot), et `--avoid-edge TYPE` refuse une technique
(par ex. `--avoid-edge DCSync`). Les deux sont répétables et se re-résolvent à la volée.

```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
```

---

## Comment NoiseHound se compare

Le pathfinding BloodHound pondéré n'est pas nouveau, voici donc le positionnement honnête :

- **BloodHound / BloodHound CE** trouvent *un* chemin par nombre de sauts non pondéré. Aucun modèle de bruit.
- **GoodHound** attribue des coûts aux arêtes et trouve les chemins les moins coûteux, mais son modèle de coût repose sur la difficulté d'exploitation et le risque métier, pas sur le bruit de détection.
- **PlumHound / ImproHound** font du reporting et de l'analyse de violation de tiers ; aucun des deux ne résout à nouveau pour un chemin le plus discret vers l'objectif.
- **Les mappings de détection** (Sigma, DeTT&CT, références event-ID-vers-ATT&CK) sont riches mais orientés humain et non indexés sur les types d'arêtes BloodHound.

La contribution de NoiseHound est la combinaison : un corpus lisible par machine d'arêtes BloodHound vers télémétrie de détection, une re-résolution pondérée par le bruit formulée comme OPSEC d'opérateur (« le chemin le plus discret vers DA »), un modèle d'environnement qui s'adapte à la posture déclarée d'une cible, et une boucle de calibration qui transforme les détections de laboratoire en scores mesurés. Les mathématiques de graphe sont du tout-venant ; le corpus et le cadrage sont l'essentiel. Sa valeur ne vaut que ce que vaut le corpus, c'est pourquoi la calibration et la contribution communautaire sont de premier ordre - voir ci-dessous.

## Installation

```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 .
```

Nécessite Python 3.10+.

## Utilisation

```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
```

Tout d'abord, vérifiez le bon fonctionnement de l'analyseur sur votre export (histogrammes + couverture du corpus, sans pathing) - le moyen le plus rapide de valider NoiseHound sur des données réelles :

```bash
noisehound-inspect -i export.zip
```

### BloodHound CE / Neo4j en direct

Au lieu d'un zip, pointez `--input` vers la base de données Neo4j que BloodHound CE alimente
et NoiseHound lit le graphe (déjà analysé) directement 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"
```

Déployez BloodHound CE (qui inclut Neo4j sur le port 7687) avec son compose officiel :
`curl -L https://ghst.ly/getbhce | docker compose -f - up`.

Testez-le avec les échantillons fournis :

```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
```

Celle-ci est la démonstration la plus claire de la thèse : la route la plus silencieuse vers les Domain Admins est le chemin de session à 4 sauts, classé *au-dessus* du chemin RDP à 3 sauts et de l'ADCS ESC1 à 1 saut — le plus de sauts, le moins de bruit.

L'échantillon illustre la valeur centrale : la route la plus silencieuse est un chemin de session à 4 sauts (score 19,9), classé *au-dessus* d'un raccourci ForceChangePassword à 2 sauts (36,4). Moins de sauts ne signifie pas plus silencieux.

### Mode d'écart de détection pour l'équipe bleue

Le chemin le plus silencieux est là où la détection est la plus faible, donc ajoutez `--defensive` pour inverser la sortie à destination des défenseurs : il signale les arêtes qui ne sont silencieuses que parce que leur télémétrie est désactivée ou absente, associe chacune au contrôle qui la détecterait, et classe ces contrôles selon l'ampleur avec laquelle ils augmentent le score du chemin le plus silencieux.

```bash
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --defensive
```

Sur l'échantillon complet, il constate que le chemin le plus silencieux vers Domain Admins repose sur un accès LSASS non détecté (`HasSession`, 20 -> 65 si instrumenté) et recommande de déployer Sysmon Event 10 - combler cette seule lacune fait passer le chemin le plus silencieux de 19,9 à 48,4. Voir [`docs/ROADMAP.md`](https://github.com/warpedatom/noisehound/blob/main/docs/ROADMAP.md) pour savoir où cela mène, ainsi que le reste du modèle.

### Options clés

| Option | Signification |
|--------|---------|
| `--input, -i` | BloodHound `.zip`, `.json`, ou répertoire d'exports |
| `--source, -s` | Principal de départ (`jdoe` ou un id d'objet) |
| `--objective, -o` | Nœud cible (`Domain Admins` ou un id d'objet) |
| `--paths, -k` | Nombre de chemins les plus silencieux à retourner (par défaut 5) |
| `--format, -f` | `text` (par défaut), `json`, ou `html` |
| `--defensive` | Vue blue-team : lacunes de détection sur les chemins les plus silencieux + correctifs |
| `--rank-by` | `noise` (par défaut) ou `probability` (P d'une alerte corrélée) |
| `--correlation` | Coefficient de corrélation SOC pour P(détecté), 0..1 (par défaut 0.5) |
| `--pareto` | Retourne la frontière de Pareto sur noise/hops/P(detect) |
| `--engine` | `auto` (par défaut), `python`, ou `rust` (le moteur DeadAir) |
| `--avoid NODE` | Exclut un nœud de tous les chemins (répétable) |
| `--avoid-edge TYPE` | Exclut un type d'arête de tous les chemins (répétable) |
| `--corpus` | Remplace le répertoire du corpus de mapping d'arêtes |
| `--environment, -e` | JSON de posture cible déclarée par l'opérateur (ajuste les scores) |
| `--max-weight` / `--mean-weight` | Poids de scoring (doivent sommer à 1.0) |
| `--default-noise` | Score pour les types d'arêtes absents du corpus (par défaut 60) |

---

## Profils d'environnement

Un score de corpus statique ne peut pas savoir si une cible donnée a l'audit d'objets 4662 activé, déploie Sysmon, ou exécute un ITDR comme MDI - pourtant ces éléments modifient énormément le bruit réel d'une arête (DCSync est quasi silencieux sans audit 4662 et quasi certain d'être détecté avec). Plutôt que de prétendre qu'un seul chiffre convient à tous les environnements, déclarez la posture de la cible dans un petit fichier JSON et NoiseHound ajuste les scores de manière transparente par rapport aux annotations de télémétrie du 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 }
}
```

Les ajustements ne font que *relever* un score vers un plancher de détection impliqué par la posture déclarée. Les `adjustments` sont des surcharges dures par arête - l'endroit où consigner les valeurs que vous avez calibrées sur votre propre laboratoire. Elles sont fournies par l'opérateur, non mesurées ; elles ne remplacent pas la validation en direct de la Phase 2, mais elles transforment le corpus statique de « un chiffre pour tous les environnements » en « le chiffre pour l'environnement dans lequel vous vous trouvez réellement ». Sur l'échantillon fourni, déclarer le profil ci-dessus fait basculer la route la plus discrète du chemin de session de dump LSASS vers un chemin d'écriture de répertoire - ce qui est le bon choix une fois la télémétrie de l'hôte active.

```bash
python -m noisehound -i samples/sample_graph.json -s jdoe -o "Domain Admins" \
    -e samples/env_profile.example.json
```

Précédence des scores : `static -> environment-adjusted -> live (Phase 2)`.

---

## Harnais de calibration

Les profils d'environnement ne valent que ce que valent les chiffres qu'on y met.
`noisehound-calibrate` boucle la boucle : exécutez les techniques dans un lab de détection,
enregistrez ce qui a déclenché, et il émet un profil d'environnement calibré.

**Cela a été fait.** [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles) fournit six profils mesurés issus d'un
véritable range Hyper-V Vulnerable-AD et d'un tenant Azure de lab - audit, EDR (Defender for
Endpoint), Elastic SIEM, Defender for Identity, et les niveaux WDAC plus un niveau Azure/Entra mesuré, 37 arêtes - produits par le harnais automatisé (`lab/`) et cet
outil. Utilisez-les directement, ou mesurez les vôtres :

```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
```

Le modèle de score est un estimateur de rétrécissement, honnête quant à la taille de l'échantillon :

```
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` est le coût de détection attendu - la sévérité SOC lorsqu'il se déclenche, un faible résidu lorsqu'il ne se déclenche pas. Le poids `w` empêche une seule exécution de prendre le pas sur le corpus tout en laissant un résultat bien échantillonné dominer. Sur l'exemple, HasSession passe d'un 20 statique à 52 (le lab a détecté le dump LSASS 4 fois sur 5) tandis que Kerberoast chute de 60 à 34 (il ne s'est jamais déclenché). Utilisez `--merge existing.json` pour superposer une nouvelle calibration sur un profil tout en conservant ses indicateurs de posture, et `--smoothing` / `--residual` pour ajuster le modèle.

---

## Évaluer par rapport aux détections déployées (Sigma)

Les profils d'environnement et la calibration sont auto-déclarés. `noisehound-sigma` évalue par rapport aux détections qu'un défenseur a *réellement écrites* : pointez-le vers un ensemble de règles Sigma et il détermine sur quelles arêtes du corpus chaque règle se déclencherait (en faisant correspondre les identifiants d'événements de télémétrie et la technique ATT&CK de l'arête), puis émet un profil d'environnement qui élève les arêtes couvertes - un remplacement direct pour `--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
```

Pour le niveau identité, **`noisehound-mdi`** fait de même face aux détections intégrées de Microsoft Defender for Identity - il mappe les alertes d'exécution de MDI (et, avec `--include-posture`, ses évaluations ISPM) sur les arêtes du corpus et émet un profil de niveau identité. MDI est agnostique vis-à-vis des outils, sa couverture reste donc valable quel que soit l'outillage de l'attaquant.

```bash
noisehound-mdi -o env.mdi.json          # + coverage report (which edges MDI watches, and the gaps)
```

Pour les arêtes **Azure/Entra**, **`noisehound-entra`** mesure le niveau cloud de la même manière que les niveaux on-prem ont été mesurés : déclencher les abus `AZ*` dans un tenant de laboratoire, exporter la piste `directoryAudits` d'Entra, et il compte ce qui s'est réellement connecté dans un profil calibré (`docs/AZURE_CALIBRATION.md`).

```bash
noisehound-entra -a directoryAudits.json -m entra_runs.json --profile-out profiles/lab-tenant-azure.json
```

La correspondance est volontairement conservatrice afin de ne jamais masquer une lacune : une règle n'est prise en compte que si elle référence un ID d'événement que l'arête génère *et*, lorsque la règle est étiquetée ATT&CK, que sa technique concorde — ainsi, une règle DCSync DS-Access (4662) n'est pas créditée à tort comme couvrant des lectures LAPS qui partagent simplement l'ID d'événement. Le rapport liste à la fois ce que vos règles couvrent et, plus utilement, les arêtes d'attaque qu'aucune règle ne couvre. Combiné avec `--defensive`, cela répond à la question : « compte tenu des détections que j'ai déployées, où se trouve mon chemin d'attaque le plus discret encore invisible ? »

### Inventaire Elastic Security en direct

`noisehound-elastic` répond à la même question face aux détections qui sont **réellement activées en ce moment** dans une pile Elastic Security en fonctionnement, plutôt que face aux règles présentes sur le disque. Il lit le moteur de détection via l'API `_find` en lecture seule de Kibana (ou un export hors ligne), associe la technique ATT&CK de chaque règle activée et tout code d'événement Windows présent dans sa requête, et produit le même profil de couverture `--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
```

Il réutilise le matcher Sigma et ajoute un niveau réservé aux techniques (marqué `[technique]`, avec un score plus faible) pour les règles comportementales KQL/EQL qui ne nomment jamais un code d'événement. Les règles désactivées sont ignorées. Même schéma normaliser-puis-scorer pour Splunk / Sentinel / MDI ensuite.

---

## AD CS ESC1-8

Au chargement, NoiseHound effectue une version ciblée du post-traitement ADCS de BloodHound, en synthétisant des arêtes d'escalade à partir des faits de modèles/CA conservés. Un droit `Enroll` sur un modèle vulnérable devient une arête `ADCSESCn` directe du principal vers le groupe Domain Admins du domaine (RID 512), de sorte que l'escalade par certificat est pathable et scorée comme n'importe quelle autre arête :

| Arête | Condition |
|------|-----------|
| `ADCSESC1` | Enrollee-supplies-subject + EKU client-auth, sans approbation/signatures RA |
| `ADCSESC2` | EKU Any-Purpose / SubCA, sans approbation |
| `ADCSESC3` | Modèle d'agent d'enrôlement + un modèle d'authentification sur la même CA |
| `ADCSESC4` | Contrôle d'écriture dangereux sur un modèle publié |
| `ADCSESC5` | Contrôle de l'objet CA ou de son ordinateur hôte |
| `ADCSESC6` | La CA a `EDITF_ATTRIBUTESUBJECTALTNAME2` défini |
| `ADCSESC7` | `ManageCA` / `ManageCertificates` sur la CA |
| `ADCSESC8` | Point de terminaison d'enrôlement web HTTP vulnérable (coerce + relais NTLM) |

Essayez : `python -m noisehound -i samples/sample_adcs_ce.zip -s jdoe -o "Domain Admins"`.

Simplifications documentées (elles échouent de manière sûre en affichant davantage de chemins) : les restrictions d'enrôlement au niveau de la CA ne sont pas modélisées (l'enrôlement par modèle est considéré comme suffisant) ; ESC5 couvre l'objet CA et son hôte, pas tous les conteneurs PKI ; ESC9/10/13 sont hors périmètre. Les arêtes ESC synthétiques déjà présentes dans un export post-traité sont préservées.

---

## Le corpus (`edge_mappings/`)

Le corpus de télémétrie d'arêtes constitue la véritable propriété intellectuelle de cet outil ; le code n'est qu'un calcul de graphe comparativement simple par-dessus. Chaque `edge_mappings/<Edge>.json` associe un type d'arête BloodHound à sa surface de détection :

- les sources de télémétrie attendues (Windows Security Event IDs, Sysmon Event IDs, réseau, heuristiques EDR/ITDR) avec la fiabilité par source et si l'audit concerné est activé par défaut
- un score de bruit statique (0-100)
- la technique MITRE, le privilège prérequis, la primitive d'abus habituelle et des notes

```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."
}
```

L'extension du corpus est là où la majeure partie de l'effort continu devrait être investie. Ajoutez un nouveau fichier JSON, conservez le schéma (validé au chargement), et il est pris en compte automatiquement. La v0.3 livre 43 types d'arêtes couvrant les arêtes d'abus d'ACL, Kerberos, de délégation, ADCS ESC1-8, LAPS/gMSA, GPO, d'approbation et de droits d'accès qui importent pour la recherche de chemins.

Les scores sont initialisés à partir de la matrice de bruit du DreadHost Red Team Operator Playbook (mappages d'événements Windows/Sysmon, évaluations de bruit des techniques) et des faits de détection AD standard. Ajustez-les en fonction de vos propres données de détection de laboratoire.

---

## Feuille de route

- **Couverture Azure / Entra ID (fondation livrée, en expansion).** 13 arêtes de chemin d'attaque `AZ*` sont désormais livrées avec la télémétrie de détection native d'Entra - voir [`docs/AZURE.md`](https://github.com/warpedatom/noisehound/blob/main/docs/AZURE.md). Les données Azure collectées via AzureHound dans BloodHound CE sont évaluées dès aujourd'hui (`noisehound -o "Global Administrator"`), et l'ingestion native d'AzureHound ainsi qu'un niveau de calibration Azure/Entra mesuré (`noisehound-entra`, `profiles/lab-tenant-azure.json`) sont désormais également livrés. Prochaine étape : les profils de posture Entra (MDCA / ID Protection / Sentinel) et les arêtes hybrides (Entra Connect / PHS-PTA) afin que **MDI** contribue à travers la frontière on-prem/cloud.
- **Terminer la calibration - 37/77 mesurées, en cours.** Les ~40 arêtes restantes (coercition/relais, ADCS ESC2-13, CanRDP sur bare metal), une calibration multi-environnements plus poussée, et un corpus multi-EDR (CrowdStrike/S1 aux côtés de MDE), plus une calibration d'outillage par arête pour élargir l'axe `--tooling`.
- **Synthèse ADCS ESC10a/10b/13** (la synthèse ESC1-9 est livrée dès maintenant).

Livré : le moteur Rust ([DeadAir](https://github.com/warpedatom/DeadAir), répartition `--engine`), l'ingestion Neo4j Bolt en direct (`--input bolt://...`), l'axe sélectionnable **`--tooling`** (outils standards sur l'hôte vs distant/natif ; `docs/TOOLING_AXIS.md`), le hook **`--live-scores`** de la Phase 2 (les scores mesurés remplacent le corpus/environnement), et **`noisehound-mdi`** (couverture Defender for Identity -> profil de niveau identité). Le travail MDI restant est la *calibration des alertes d'exécution* conditionnée par le laboratoire (`docs/CALIBRATION.md`).

## Contribution

Le corpus est extensible par la communauté et c'est là que les contributions comptent le plus. L'ajout d'une arête se fait via un seul fichier JSON validé au chargement et en CI :

```bash
noisehound-validate              # schema + consistency checks over the corpus
python -m pytest tests/ -q
```

Voir [CONTRIBUTING.md](https://github.com/warpedatom/noisehound/blob/main/CONTRIBUTING.md) pour le schéma, le guide de notation et les
consignes de PR, et [`docs/edge_schema.json`](https://github.com/warpedatom/noisehound/blob/main/docs/edge_schema.json) pour le schéma
formel des arêtes.

## Calibrage par rapport à un lab

30 arêtes sont mesurées (voir [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles)) ; les autres sont des estimations tant
que vous ne les mesurez pas, et chaque environnement diffère. [`docs/CALIBRATION.md`](https://github.com/warpedatom/noisehound/blob/main/docs/CALIBRATION.md)
est un playbook complet : topologie du lab, la politique d'audit Windows exacte et la
configuration Sysmon pour faire déclencher les event IDs du corpus, un runbook d'exercice par arête, une
couche de réalisme APT29-via-Caldera, et comment compiler les résultats en un profil calibré.
Commencez par `noisehound-calibrate --template -o lab_detections.json`.

Le kit [`lab/`](https://github.com/warpedatom/noisehound/blob/main/lab) automatise l'instrumentation de détection :
`Enable-Telemetry.ps1` active la politique d'audit, la journalisation des blocs de script, la SACL DCSync,
et Sysmon ; `Collect-Detections.ps1` comptabilise ce qui s'est déclenché dans une fenêtre. Il
s'appuie sur [GOAD](https://github.com/Orange-Cyberdefense/GOAD) ou
[Vulnerable-AD](https://github.com/WazeHell/vulnerable-AD) (ou tout AD de lab d'entraînement
existant) pour le domaine vulnérable lui-même plutôt que de les réimplémenter.

## Utilisation responsable

NoiseHound est destiné aux tests de sécurité autorisés, aux exercices purple-team, à l'ingénierie
de détection et à la recherche. Il lit les données BloodHound que vous avez déjà collectées et
calcule des classements ; il n'exécute rien contre une cible. Utilisez-le uniquement là où vous
disposez d'une autorisation écrite explicite. Les contributions ne doivent pas inclure
de données spécifiques à une cible ou issues d'un engagement réel.

## Tests

```bash
python -m pytest tests/          # with pytest
python tests/test_noisehound.py  # dependency-light smoke run
```

## Disposition

```
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
```
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    911
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    548
  • 3

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    366
  • 4

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    362
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    311
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    287

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →