
पहचान-जागरूक BloodHound आक्रमण-पथ स्कोरिंग - आपके उद्देश्य तक सबसे शांत मार्ग, पाँच पहचान स्तरों (audit/EDR/Elastic/MDI/WDAC) और 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>
**डिटेक्शन-अवेयर Active Directory हमला-पथ स्कोरिंग।**
_DreadHost Research | OffsetInspect (PowerShell) और OffsetScan (Rust) का साथी_
BloodHound (और उसके ऊपर PlumHound) लक्ष्य तक *एक* पथ खोजता है।
NoiseHound वही ग्राफ़ डेटा ग्रहण करता है और पथों को हॉप-काउंट के बजाय
**अपेक्षित डिटेक्शन लागत** के आधार पर पुनः रैंक करता है, ताकि एक ऑपरेटर
"डोमेन एडमिन तक पहुँचने का सबसे शांत तरीका क्या है" पूछ सके, न कि केवल
"कोई एक तरीका क्या है"।
> **यहाँ नए हैं? [Operator Walkthrough](https://github.com/warpedatom/noisehound/blob/main/docs/WALKTHROUGH.md) यह देखने का सबसे तेज़ तरीका है
> कि यह क्या करता है** - इंस्टॉल से लेकर एक लाइव
> BloodHound CE प्रूफ़ ऑफ़ कॉन्सेप्ट (स्कोर UI में वापस लिखे गए), DeadAir
> इंजन, और ब्लू-टीम डिटेक्शन-गैप रिपोर्ट तक एक व्यावहारिक, स्क्रीनशॉट-आधारित यात्रा।
> **प्रोजेक्ट स्थिति (v1.2.0):** स्थिर और कई डोमेन पर वास्तविक BloodHound डेटा पर परीक्षित।
> **77 कॉर्पस एजों में से 37 लैब-मापित हैं** पाँच ऑन-प्रेम डिटेक्शन टियर (Windows audit, Defender for Endpoint, Elastic SIEM,
> Defender for Identity रनटाइम अलर्ट, और WDAC audit) के साथ-साथ एक मापित Azure/Entra
> टियर में - [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles) में छह ड्रॉप-इन प्रोफ़ाइल के रूप में शिप किए गए, साथ में
> क्लोज़्ड-लूप प्रमाण कि वे पथ रैंकिंग बदलते हैं ([`docs/VALIDATION.md`](https://github.com/warpedatom/noisehound/blob/main/docs/VALIDATION.md))।
> कॉर्पस में 13 **Azure/Entra** एजें हैं ([`docs/AZURE.md`](https://github.com/warpedatom/noisehound/blob/main/docs/AZURE.md)),
> जिन्हें सीधे AzureHound आउटपुट से ग्रहण किया जा सकता है।
> अमापित ऑन-प्रेम और सभी Azure एजों में **विशेषज्ञ अनुमान** हैं; कैलिब्रेशन
> हार्नेस (`noisehound-calibrate`) ही वह माध्यम है जिससे वे, और आपका अपना वातावरण,
> मापे जाते हैं। अकैलिब्रेटेड रैंकिंग को सुविचारित मार्गदर्शन मानें, न कि ग्राउंड ट्रुथ।
> केवल अधिकृत एंगेजमेंट के लिए। यह टूल उन सिस्टमों के विरुद्ध OPSEC
> योजना के लिए हमला-पथों को स्कोर करता है जिन्हें परीक्षण करने की आपके पास लिखित अनुमति है।
> NoiseHound एक स्वतंत्र सामुदायिक प्रोजेक्ट है। यह SpecterOps या BloodHound प्रोजेक्ट से
> संबद्ध, समर्थित या जुड़ा नहीं है; यह
> BloodHound के खुले डेटा फ़ॉर्मेट का उपभोग करता है।
---
## यह कैसे काम करता है
1. **Ingest** करें BloodHound CE export (`.zip`), एक raw JSON फ़ाइल, या exports की एक directory को internal graph में। एक normalised `{nodes, edges}` JSON format भी offline analysis और tests के लिए स्वीकार किया जाता है। AD CS **ESC1-8** escalation edges load time पर certificate-template और CA facts से synthesised होते हैं जो BloodHound collect करता है (नीचे देखें)।
2. edge-telemetry corpus से हर edge को **Annotate** करें, एक `effective_noise_score` (0-100) संलग्न करते हुए। जहाँ कई rights एक ही pair of nodes को जोड़ते हैं, वहाँ सबसे quietest चुना जाता है। corpus में अनुपस्थित edge types एक conservative score (60) पर default होते हैं ताकि gaps fail safe हों, under-reporting के बजाय। एक optional **environment profile** target के declared detection posture के लिए scores को adjust करता है (नीचे देखें)।
3. quietest paths के लिए **Solve** करें। चूँकि path score एक bottleneck plus mean है (साधारण sum नहीं), इसे Dijkstra द्वारा सीधे optimise नहीं किया जा सकता। solver एक *threshold sweep* (प्रत्येक distinct noise level के लिए, सबसे quietest route जो उसके नीचे रहता है) को bounded k-shortest-by-weight pass के साथ जोड़ता है, फिर union को real path score द्वारा re-rank करता है। threshold sweep correctness backstop है: यह एक long-but-uniformly-quiet path को सामने लाता है जिसे pure summed-weight search एक short-but-loud path से नीचे rank करेगा।
4. text, JSON (OffsetInspect result schema के साथ interoperable), या toolset से मेल खाने के लिए styled एक self-contained HTML report के रूप में **Report** करें।
### Path scoring
Path noise जानबूझकर एक साधारण sum **नहीं** है। एक ही detection को दो बार trigger करना दोगुना loud नहीं होता (SOC triage, raw event count नहीं)। NoiseHound उपयोग करता है:
```
path_score = max(edge_scores) * 0.6 + mean(edge_scores) * 0.4
```
यह सबसे तेज़ एकल चरण की ओर झुकता है (एक खराब चरण अक्सर पूरे ऑपरेशन को बर्बाद कर देता है) जबकि संचयी जोखिम को भी ध्यान में रखता है। भार कॉन्फ़िगर करने योग्य हैं (`--max-weight` / `--mean-weight`) ताकि APT29/Caldera लैब से वास्तविक डिटेक्शन डेटा उपलब्ध होने पर उन्हें अनुभवजन्य रूप से ट्यून किया जा सके।
प्रत्येक पथ एक **डिटेक्शन प्रायिकता** भी रिपोर्ट करता है - किसी सहसंबद्ध अलर्ट को ट्रिगर करने की संभावना - जो सबसे तेज़ किनारे को सभी किनारों के संचयी noisy-OR के साथ मिलाती है (`--correlation` द्वारा ट्यून की गई)। यह शोर स्कोर से एक अलग प्रश्न का उत्तर देती है: एक छोटा लेकिन तेज़ पथ, एक लंबे लेकिन शांत पथ की तुलना में पकड़े जाने की *कम* समग्र प्रायिकता रख सकता है। इसे `--rank-by probability` के साथ रैंक करें।
### दो-स्तरीय इंजन (DeadAir)
बड़े ग्राफ़ के लिए, समाधान [DeadAir](https://github.com/warpedatom/DeadAir) को सौंपा जाता है, जो एक साथी Rust इंजन है (OffsetScan-to-OffsetInspect स्तर)। NoiseHound सुविधा-संपन्न फ्रंटएंड बना रहता है - अंतर्ग्रहण, कॉर्पस, पर्यावरण/Sigma, बाधाएँ, रिपोर्टिंग - और तैयार ग्राफ़ को उस इंजन को सौंप देता है जो इसे हल करता है, इसलिए परिणाम दोनों तरह से समान होते हैं।
- `--engine auto` (डिफ़ॉल्ट): DeadAir जब इसकी बाइनरी मिलती है *और* ग्राफ़ बड़ा है (>= 5000 नोड्स); अन्यथा अंतर्निहित Python सॉल्वर।
- `--engine python`: अंतर्निहित सॉल्वर को बाध्य करें (किसी बाइनरी की आवश्यकता नहीं)।
- `--engine rust`: DeadAir को बाध्य करें (यदि बाइनरी अनुपस्थित है तो त्रुटि देता है)।
DeadAir `$NOISEHOUND_DEADAIR`, फिर `PATH`, फिर सहोदर `../deadair/target/{release,debug}/` बिल्ड के माध्यम से खोजा जाता है। यह बड़े ग्राफ़ पर 10-100x तेज़ है (250k-नोड ग्राफ़ ~2s में हल होता है बनाम Python में ~30s) जबकि बाइट-समान रैंकिंग उत्पन्न करता है। आउटपुट रिकॉर्ड करता है कि कौन सा इंजन चला।
### बहु-उद्देश्यीय और बाधित पाथिंग
शोर, हॉप गणना, और डिटेक्शन प्रायिकता अलग-अलग दिशाओं में खींचते हैं, इसलिए `--pareto` **Pareto फ्रंटियर** लौटाता है - प्रत्येक वह पथ जिसे कोई अन्य तीनों पर एक साथ नहीं हराता - एकल विजेता को बाध्य करने के बजाय। और वास्तविक ऑपरेशनों में बाधाएँ होती हैं: `--avoid NODE` किसी पथ को एक विशिष्ट होस्ट (EDR-निगरानी वाला जंप बॉक्स, एक हनीपॉट) से दूर रखता है, और `--avoid-edge TYPE` किसी तकनीक को अस्वीकार करता है (जैसे `--avoid-edge DCSync`)। दोनों पुनरावर्तनीय हैं और तुरंत पुनः-हल करते हैं।
```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
```
## NoiseHound की तुलना
भारित BloodHound पाथफाइंडिंग नई नहीं है, इसलिए यहाँ ईमानदार स्थिति प्रस्तुत है:
- **BloodHound / BloodHound CE** बिना भार वाले हॉप काउंट द्वारा *एक* पथ खोजते हैं। कोई शोर
मॉडल नहीं।
- **GoodHound** किनारों को लागत सौंपता है और सबसे सस्ते पथ खोजता है, लेकिन इसका लागत मॉडल
शोषण कठिनाई और व्यावसायिक जोखिम है, पहचान शोर नहीं।
- **PlumHound / ImproHound** रिपोर्टिंग और टियर-उल्लंघन विश्लेषण करते हैं; इनमें से कोई भी
लक्ष्य तक सबसे शांत पथ के लिए पुनः-समाधान नहीं करता।
- **डिटेक्शन मैपिंग** (Sigma, DeTT&CT, event-ID-to-ATT&CK संदर्भ) समृद्ध हैं लेकिन
मानव-उन्मुख हैं और BloodHound किनारे के प्रकारों से जुड़े नहीं हैं।
NoiseHound का योगदान संयोजन है: एक मशीन-पठनीय
BloodHound-किनारे-से-डिटेक्शन-टेलीमेट्री कॉर्पस, ऑपरेटर OPSEC ("DA तक सबसे शांत रास्ता") के रूप में
तैयार किया गया शोर-भारित पुनः-समाधान, एक पर्यावरण मॉडल जो लक्ष्य की घोषित मुद्रा के अनुकूल होता है, और एक
कैलिब्रेशन लूप जो लैब डिटेक्शन को मापे गए स्कोर में बदलता है। ग्राफ गणित सामान्य वस्तु है; कॉर्पस और
प्रस्तुतीकरण ही मुख्य बात है। इसका मूल्य केवल कॉर्पस जितना ही अच्छा है, यही कारण है कि कैलिब्रेशन और
सामुदायिक योगदान प्राथमिक हैं - नीचे देखें।
## इंस्टॉल
```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 .
```
Python 3.10+ आवश्यक है।
## उपयोग
```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
```
सबसे पहले, अपने export पर parser का sanity-check करें (histograms + corpus coverage, कोई pathing नहीं) - real-world data पर NoiseHound को validate करने का सबसे तेज़ तरीका:
```bash
noisehound-inspect -i export.zip
```
### लाइव BloodHound CE / Neo4j
zip के बजाय, `--input` को उस Neo4j डेटाबेस की ओर इंगित करें जिसे BloodHound CE भरता है
और NoiseHound 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"
```
BloodHound CE (7687 पर Neo4j को बंडल करता है) को उसके आधिकारिक compose के साथ खड़ा करें:
`curl -L https://ghst.ly/getbhce | docker compose -f - up`।
इसे बंडल किए गए नमूनों के विरुद्ध आज़माएँ:
```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
```
वह अंतिम उदाहरण थीसिस का सबसे स्पष्ट प्रदर्शन है: Domain Admins तक का सबसे शांत मार्ग 4-हॉप सत्र पथ है, जो 3-हॉप RDP पथ और 1-हॉप ADCS ESC1 से *ऊपर* स्थानित है - सबसे अधिक हॉप्स, सबसे कम शोर।
नमूना मूल मूल्य प्रदर्शित करता है: सबसे शांत मार्ग एक 4-हॉप सत्र पथ है (स्कोर 19.9), जो 2-हॉप ForceChangePassword शॉर्टकट (36.4) से *ऊपर* स्थानित है। कम हॉप्स का अर्थ शांत नहीं होता।
### ब्लू-टीम डिटेक्शन-गैप मोड
सबसे शांत पथ वह है जहाँ डिटेक्शन सबसे कमजोर है, इसलिए रक्षकों के लिए आउटपुट बदलने हेतु `--defensive` जोड़ें: यह उन एजों को चिह्नित करता है जो केवल इसलिए शांत हैं क्योंकि उनकी टेलीमेट्री बंद या अनुपस्थित है, प्रत्येक को उस नियंत्रण से मैप करता है जो उसे पकड़ेगा, और उन नियंत्रणों को इस आधार पर रैंक करता है कि वे सबसे शांत-पथ स्कोर को कितना बढ़ाते हैं।
```bash
python -m noisehound -i export.zip -s jdoe -o "Domain Admins" --defensive
```
पूर्ण-स्पेक्ट्रम नमूने पर यह पाता है कि Domain Admins तक का सबसे शांत पथ अनडिटेक्टेड LSASS एक्सेस (`HasSession`, 20 -> 65 यदि इंस्ट्रूमेंटेड) पर निर्भर करता है और Sysmon Event 10 तैनात करने की सलाह देता है - उस एक अंतराल को बंद करने से सबसे शांत पथ 19.9 से 48.4 तक बढ़ जाता है। यह और बाकी मॉडल किस दिशा में जा रहे हैं, इसके लिए [`docs/ROADMAP.md`](https://github.com/warpedatom/noisehound/blob/main/docs/ROADMAP.md) देखें।
### मुख्य विकल्प
| विकल्प | अर्थ |
|--------|---------|
| `--input, -i` | BloodHound `.zip`, `.json`, या एक्सपोर्ट की डायरेक्टरी |
| `--source, -s` | प्रारंभिक प्रिंसिपल (`jdoe` या एक ऑब्जेक्ट आईडी) |
| `--objective, -o` | लक्ष्य नोड (`Domain Admins` या एक ऑब्जेक्ट आईडी) |
| `--paths, -k` | लौटाए जाने वाले सबसे शांत पथों की संख्या (डिफ़ॉल्ट 5) |
| `--format, -f` | `text` (डिफ़ॉल्ट), `json`, या `html` |
| `--defensive` | ब्लू-टीम दृश्य: सबसे शांत पथों पर डिटेक्शन अंतराल + समाधान |
| `--rank-by` | `noise` (डिफ़ॉल्ट) या `probability` (सहसंबद्ध अलर्ट की P) |
| `--correlation` | P(detected) के लिए SOC सहसंबंध गुणांक, 0..1 (डिफ़ॉल्ट 0.5) |
| `--pareto` | noise/hops/P(detect) पर Pareto फ्रंटियर लौटाएँ |
| `--engine` | `auto` (डिफ़ॉल्ट), `python`, या `rust` (DeadAir इंजन) |
| `--avoid NODE` | सभी पथों से एक नोड को बाहर रखें (दोहराने योग्य) |
| `--avoid-edge TYPE` | सभी पथों से एक एज प्रकार को बाहर रखें (दोहराने योग्य) |
| `--corpus` | एज-मैपिंग कॉर्पस डायरेक्टरी को ओवरराइड करें |
| `--environment, -e` | ऑपरेटर-घोषित लक्ष्य पोस्चर JSON (स्कोर समायोजित करता है) |
| `--max-weight` / `--mean-weight` | स्कोरिंग भार (योग 1.0 होना चाहिए) |
| `--default-noise` | कॉर्पस में अनुपस्थित एज प्रकारों के लिए स्कोर (डिफ़ॉल्ट 60) |
---
## एनवायरनमेंट प्रोफ़ाइल
एक स्थिर कॉर्पस स्कोर यह नहीं जान सकता कि किसी दिए गए लक्ष्य पर 4662 ऑब्जेक्ट ऑडिटिंग चालू है, Sysmon तैनात है, या MDI जैसा ITDR चल रहा है - फिर भी ये चीज़ें किसी एज के वास्तविक noise को बहुत अधिक बदल देती हैं (4662 ऑडिटिंग के बिना DCSync लगभग-मौन है और इसके साथ लगभग-निश्चित-डिटेक्शन)। हर एनवायरनमेंट के लिए एक ही संख्या को उपयुक्त मानने का दिखावा करने के बजाय, लक्ष्य के पोस्चर को एक छोटी JSON फ़ाइल में घोषित करें और NoiseHound कॉर्पस के अपने टेलीमेट्री एनोटेशन के आधार पर स्कोर को पारदर्शी रूप से समायोजित करता है:
```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 }
}
```
Adjustments केवल स्कोर को घोषित posture द्वारा निहित detection floor की ओर *बढ़ाते* हैं। `adjustments` प्रति-edge hard overrides हैं - वह स्थान जहाँ आप अपनी स्वयं की lab के विरुद्ध calibrated किए गए मान रिकॉर्ड करते हैं। यह operator-supplied है, मापा गया नहीं; यह Phase 2 live validation का स्थान नहीं लेता, लेकिन यह static corpus को "सभी environments के लिए एक संख्या" से "उस environment के लिए संख्या जिसमें आप वास्तव में हैं" में बदल देता है। bundled sample पर, ऊपर दिया गया profile घोषित करने से सबसे शांत route LSASS-dump session path से directory-write path में बदल जाता है - जो कि host telemetry live होने पर सही निर्णय है।
```bash
python -m noisehound -i samples/sample_graph.json -s jdoe -o "Domain Admins" \
-e samples/env_profile.example.json
```
स्कोर प्राथमिकता: `static -> environment-adjusted -> live (Phase 2)`।
---
## कैलिब्रेशन हार्नेस
एनवायरनमेंट प्रोफ़ाइलें उतनी ही अच्छी होती हैं जितने अच्छे आप उनमें डाले गए नंबर होते हैं।
`noisehound-calibrate` इस लूप को पूरा करता है: किसी डिटेक्शन लैब में तकनीकें चलाएँ,
रिकॉर्ड करें कि क्या फायर हुआ, और यह एक कैलिब्रेटेड एनवायरनमेंट प्रोफ़ाइल उत्पन्न करता है।
**यह किया जा चुका है।** [`profiles/`](https://github.com/warpedatom/noisehound/blob/main/profiles) में एक वास्तविक Hyper-V Vulnerable-AD रेंज और एक लैब Azure टेनेंट से छह मापी गई प्रोफ़ाइलें शामिल हैं - audit, EDR (Defender for Endpoint), Elastic SIEM, Defender for Identity, और WDAC टियर के साथ-साथ एक मापा गया Azure/Entra टियर, 37 एज - जो स्वचालित हार्नेस (`lab/`) और इस टूल द्वारा उत्पन्न की गई हैं। इन्हें सीधे उपयोग करें, या अपनी स्वयं की मापें:
```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
```
स्कोर मॉडल एक संकुचन अनुमानक है, जो नमूना आकार के बारे में ईमानदार है:
```
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` अपेक्षित डिटेक्शन लागत है - जब यह फायर होता है तो SOC गंभीरता, और जब नहीं होता तो एक छोटा अवशेष। भार `w` एकल रन को कॉर्पस को ओवरराइड करने से रोकता है जबकि एक अच्छी तरह से नमूना परिणाम को प्रभावी होने देता है। उदाहरण पर, HasSession स्थिर 20 से 52 तक चढ़ता है (लैब ने 5 में से 4 रन में LSASS डंप पकड़ा) जबकि Kerberoast 60 से 34 तक गिरता है (यह कभी फायर नहीं हुआ)। किसी प्रोफ़ाइल पर नई कैलिब्रेशन को ओवरले करने के लिए `--merge existing.json` का उपयोग करें जबकि इसके पोस्चर फ़्लैग्स को बनाए रखें, और मॉडल को ट्यून करने के लिए `--smoothing` / `--residual` का उपयोग करें।
---
## तैनात डिटेक्शन के विरुद्ध स्कोर करें (Sigma)
पर्यावरण प्रोफ़ाइल और कैलिब्रेशन स्व-घोषित हैं। `noisehound-sigma` उन डिटेक्शन के विरुद्ध स्कोर करता है जो एक डिफेंडर ने *वास्तव में लिखे* हैं: इसे एक Sigma नियम सेट पर इंगित करें और यह पता लगाता है कि प्रत्येक नियम किन कॉर्पस किनारों पर फायर होगा (किनारे के टेलीमेट्री इवेंट ID और ATT&CK तकनीक से मिलान करते हुए), फिर एक पर्यावरण प्रोफ़ाइल उत्सर्जित करता है जो कवर किए गए किनारों को बढ़ाता है - `--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
```
पहचान टियर के लिए, **`noisehound-mdi`** Microsoft Defender for Identity की अंतर्निहित डिटेक्शन्स के विरुद्ध वही कार्य करता है - यह MDI के रनटाइम अलर्ट्स (और, `--include-posture` के साथ, इसके ISPM आकलनों) को कॉर्पस एजों पर मैप करता है और एक पहचान-टियर प्रोफ़ाइल उत्सर्जित करता है। MDI टूल-अज्ञेय है, इसलिए इसकी कवरेज हमलावर की टूलिंग की परवाह किए बिना बनी रहती है।
```bash
noisehound-mdi -o env.mdi.json # + coverage report (which edges MDI watches, and the gaps)
```
---
[Read more](https://github.com/warpedatom/noisehound)