NoiseHound

डिटेक्शन-जागरूक Active Directory आक्रमण-पथ स्कोरिंग। DreadHost Research | OffsetInspect (PowerShell) और OffsetScan (Rust) का साथी उपकरण

BloodHound (और उसके ऊपर PlumHound) लक्ष्य तक एक रास्ता खोजता है। NoiseHound उसी ग्राफ डेटा को ग्रहण करता है और पथों को हॉप-गणना के बजाय अपेक्षित डिटेक्शन लागत के आधार पर पुनः-क्रमबद्ध करता है, ताकि एक ऑपरेटर पूछ सके "Domain Admin बनने का सबसे शांत तरीका क्या है" सिर्फ "एक तरीका क्या है" के बजाय।

यहाँ नए हैं? Operator Walkthrough से शुरू करें — एक व्यावहारिक, स्क्रीनशॉट-आधारित ट्यूटोरियल जो आपको इंस्टॉल से लाइव BloodHound CE प्रूफ-ऑफ-कॉन्सेप्ट तक ले जाता है (स्कोर BloodHound UI में वापस लिखे जाते हैं), DeadAir इंजन, और ब्लू-टीम डिटेक्शन-गैप रिपोर्ट।

परियोजना स्थिति (v1.0): स्थिर और कई डोमेन में वास्तविक BloodHound डेटा पर परीक्षित। 57 में से 30 कॉर्पस किनारे अब प्रयोगशाला-मापित हैं चार डिटेक्शन स्तरों (audit, Defender for Endpoint, Elastic SIEM, और MDI मुद्रा) में — profiles/ में ड्रॉप-इन प्रोफाइल के रूप में भेजे गए हैं, इस बात के क्लोज्ड-लूप प्रमाण के साथ कि वे पथ रैंकिंग बदलते हैं (docs/VALIDATION.md)। शेष ~28 किनारे अभी भी विशेषज्ञ अनुमान रखते हैं; अंशांकन हार्नेस (noisehound-calibrate, docs/CALIBRATION.md) वह तरीका है जिससे वे, और आपका अपना वातावरण, मापे जाते हैं। अंशांकित रैंकिंग को सुविचारित मार्गदर्शन मानें, न कि अंतिम सत्य।

केवल अधिकृत अभियानों के लिए। यह उपकरण उन प्रणालियों के विरुद्ध OPSEC नियोजन के लिए आक्रमण पथों को स्कोर करता है जिन पर आपके पास लिखित परीक्षण अनुमति है।

NoiseHound एक स्वतंत्र सामुदायिक परियोजना है। इसका SpecterOps या BloodHound परियोजना से कोई संबद्धता, समर्थन या जुड़ाव नहीं है; यह BloodHound के खुले डेटा प्रारूप का उपभोग करता है।

यह कैसे काम करता है

1. इन्जेस्ट एक BloodHound CE निर्यात (.zip), एक कच्ची JSON फ़ाइल, या निर्यातों की एक निर्देशिका को आंतरिक ग्राफ में लें। एक सामान्यीकृत {nodes, edges} JSON प्रारूप भी ऑफ़लाइन विश्लेषण और परीक्षणों के लिए स्वीकार किया जाता है। AD CS ESC1-8 एस्केलेशन किनारे लोड समय पर BloodHound द्वारा एकत्रित प्रमाणपत्र-टेम्पलेट और CA तथ्यों से संश्लेषित किए जाते हैं (नीचे देखें)।
2. एनोटेट किनारे-टेलीमेट्री कॉर्पस से हर किनारे को, एक effective_noise_score (0-100) जोड़ते हुए। जहाँ कई अधिकार समान नोड जोड़ी को जोड़ते हैं, वहाँ सबसे शांत चुना जाता है। कॉर्पस में अनुपस्थित किनारे प्रकार डिफ़ॉल्ट रूप से एक रूढ़िवादी स्कोर (60) लेते हैं ताकि अंतराल कम-रिपोर्टिंग के बजाय सुरक्षित रूप से विफल हों। एक वैकल्पिक पर्यावरण प्रोफ़ाइल लक्ष्य की घोषित डिटेक्शन मुद्रा के लिए स्कोर समायोजित करती है (नीचे देखें)।
3. हल करें सबसे शांत पथों के लिए। चूँकि पथ स्कोर एक अड़चन प्लस माध्य है (साधारण योग नहीं), इसे Dijkstra द्वारा सीधे अनुकूलित नहीं किया जा सकता। सॉल्वर एक थ्रेशोल्ड स्वीप (प्रत्येक विशिष्ट शोर स्तर के लिए, सबसे शांत मार्ग जो उसके नीचे रहता है) को एक बाउंडेड k-शॉर्टेस्ट-बाय-वेट पास के साथ जोड़ता है, फिर वास्तविक पथ स्कोर द्वारा संघ को पुनः-क्रमबद्ध करता है। थ्रेशोल्ड स्वीप शुद्धता का बैकस्टॉप है: यह एक लंबे-लेकिन-समान रूप से शांत पथ को सतह पर लाता है जिसे एक शुद्ध योग-भार खोज एक छोटे-लेकिन-तेज़ पथ से नीचे रैंक करेगी।
4. रिपोर्ट टेक्स्ट, JSON (OffsetInspect परिणाम स्कीमा के साथ अंतर-संचालनीय), या एक स्व-निहित HTML रिपोर्ट के रूप में जो टूलसेट से मेल खाती है।

पथ स्कोरिंग

पथ शोर जानबूझकर नहीं है एक साधारण योग। उसी डिटेक्शन को दो बार ट्रिगर करना दोगुना तेज़ नहीं है (SOC ट्राइएज, कच्ची घटना गणना नहीं)। 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 सुविधाओं से भरपूर
फ्रंटएंड बना रहता है - इंजेशन, कॉर्पस, एनवायरनमेंट/सिग्मा, बाधाएं,
रिपोर्टिंग - और तैयार ग्राफ़ को किसी भी इंजन को सौंप देता है जो उसे हल करता है, इसलिए
परिणाम दोनों तरह से समान होते हैं।

- `--engine auto` (default): DeadAir जब इसका बाइनरी मिलता है *और* ग्राफ़
  बड़ा होता है (>= 5000 नोड्स); अन्यथा अंतर्निहित Python सॉल्वर।
- `--engine python`: अंतर्निहित सॉल्वर को बाध्य करें (कोई बाइनरी आवश्यक नहीं)।
- `--engine rust`: DeadAir को बाध्य करें (यदि बाइनरी गायब है तो त्रुटि)।

DeadAir `$NOISEHOUND_DEADAIR`, फिर `PATH`, और फिर सहोदर
`../deadair/target/{release,debug}/` बिल्ड के माध्यम से पाया जाता है। यह बड़े ग्राफ़ों पर 10-100x तेज़ है
(एक 250k-नोड ग्राफ़ ~2s में हल होता है बनाम Python में ~30s) जबकि बाइट-समान
रैंकिंग उत्पन्न करता है। आउटपुट रिकॉर्ड करता है कि कौन सा इंजन चला।

### बहु-उद्देश्यीय और प्रतिबंधित पाथिंग

शोर, हॉप संख्या, और पहचान संभावना अलग-अलग दिशाओं में खींचते हैं, इसलिए
`--pareto` **Pareto frontier** लौटाता है - हर वह पथ जिसे कोई अन्य एक साथ तीनों
मापदंडों पर नहीं हरा सकता - एक ही विजेता को बाध्य करने के बजाय। और वास्तविक अभियानों में
बाधाएं होती हैं: `--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

पहले, अपने निर्यात पर पार्सर की सैनिटी-जाँच करें (हिस्टोग्राम + कॉर्पस कवरेज, कोई पाथिंग नहीं) - वास्तविक-विश्व डेटा पर NoiseHound को सत्यापित करने का सबसे तेज़ तरीका:```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 को उसके आधिकारिक compose के साथ चालू करें (Neo4j को 7687 पर बंडल करता है): 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-hop session पथ है, जो 3-hop RDP पथ और  
1-hop ADCS ESC1 से *ऊपर* रैंक किया गया है - सबसे अधिक hops, सबसे कम शोर।

यह नमूना मुख्य मूल्य दर्शाता है: सबसे शांत मार्ग एक 4-hop session  
path (score 19.9) है, जो 2-hop ForceChangePassword shortcut (36.4) से *ऊपर* रैंक किया गया है।  
कम hops का मतलब अधिक शांत नहीं है।

### ब्लू-टीम डिटेक्शन-गैप मोड

सबसे शांत पथ वहीं है जहाँ डिटेक्शन सबसे कमज़ोर है, इसलिए `--defensive` जोड़ें फ्लिप करने के लिए  
आउटपुट को डिफेंडरों के लिए: यह उन edges को फ़्लैग करता है जो केवल इसलिए शांत हैं क्योंकि उनकी  
telemetry बंद या अनुपस्थित है, प्रत्येक को उस control से मैप करता है जो उसे पकड़ सकता है, और  
उन controls को रैंक करता है कि वे सबसे शांत पथ के स्कोर को कितना बढ़ाते हैं।```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 कि यह और मॉडल का बाकी हिस्सा किस ओर बढ़ रहा है।

Key options

Environment profiles

एक स्थिर corpus स्कोर यह नहीं जान सकता कि किसी दिए गए लक्ष्य में 4662 ऑब्जेक्ट ऑडिटिंग चालू है, Sysmon शामिल है, या MDI जैसा ITDR चल रहा है - फिर भी ये एक edge के वास्तविक शोर को बहुत अधिक बदल देते हैं (DCSync 4662 ऑडिटिंग के बिना लगभग मौन है और इसके साथ लगभग निश्चित-पहचान वाला है)। यह दिखावा करने के बजाय कि एक संख्या हर पर्यावरण में फिट बैठती है, लक्ष्य की स्थिति को एक छोटी JSON फ़ाइल में घोषित करें और NoiseHound स्कोर को 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 } }

समायोजन केवल स्कोर को घोषित मुद्रा द्वारा निहित डिटेक्शन फ्लोर की ओर *बढ़ाते* हैं।
`adjustments` कठोर प्रति-एज ओवरराइड हैं - वह स्थान जहाँ
आप अपनी लैब के विरुद्ध कैलिब्रेट किए गए मान दर्ज करते हैं। यह ऑपरेटर-प्रदत्त है,
मापा नहीं गया; यह Phase 2 लाइव सत्यापन को प्रतिस्थापित नहीं करता, बल्कि यह
स्थैतिक कॉर्पस को "सभी वातावरणों के लिए एक संख्या" से "जिस वातावरण में आप
वास्तव में हैं उसके लिए संख्या" में बदल देता है। बंडल किए गए नमूने पर, उपरोक्त प्रोफ़ाइल घोषित करने से
सबसे शांत मार्ग LSASS-डंप सत्र पथ से बदलकर एक निर्देशिका-लेखन पथ हो जाता है -
जो होस्ट टेलीमेट्री लाइव होने पर सही निर्णय है।```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/ तीन मापी गई प्रोफ़ाइलें प्रदान करता है एक वास्तविक Hyper-V Vulnerable-AD रेंज से - audit, EDR (Defender for Endpoint), और Elastic SIEM स्तर, 30 edges - जो स्वचालित हार्नेस (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

स्कोर मॉडल एक shrinkage estimator है, जो नमूना आकार के बारे में ईमानदार है:```
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 तक चढ़ता है (लैब ने LSASS डंप को 5 में से 4 रन में पकड़ा) जबकि Kerberoast 60 से 34 तक गिरता है (यह कभी फायर नहीं हुआ)। --merge existing.json का उपयोग करके किसी प्रोफ़ाइल पर नया कैलिब्रेशन ओवरले करें जबकि उसके पोस्चर फ्लैग बनाए रखें, और मॉडल को ट्यून करने के लिए --smoothing / --residual का उपयोग करें।

तैनात डिटेक्शनों के विरुद्ध स्कोर (Sigma)

पर्यावरण प्रोफ़ाइल और कैलिब्रेशन स्व-घोषित हैं। noisehound-sigma उन डिटेक्शनों के विरुद्ध स्कोर करता है जिन्हें एक डिफ़ेंडर ने वास्तव में लिखा है: इसे एक Sigma नियम सेट पर इंगित करें और यह पता लगाता है कि प्रत्येक नियम किस कॉर्पस एज पर फायर होगा (एज के टेलीमेट्री ईवेंट IDs और 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

मिलान जानबूझकर रूढ़िवादी है ताकि यह कभी भी कोई अंतराल न छिपाए: एक नियम केवल तभी गिना जाता है जब वह किसी ईवेंट ID को संदर्भित करता है जिसे एज उत्पन्न करता है *और*, जब नियम ATT&CK-टैग किया गया हो, उसकी तकनीक सहमत हो - इसलिए एक DS-Access (4662) DCSync नियम को LAPS रीड्स को कवर करने का श्रेय नहीं दिया जाता जो केवल ईवेंट ID साझा करते हैं। रिपोर्ट सूचीबद्ध करती है कि आपके नियम क्या कवर करते हैं और, अधिक उपयोगी रूप से, उन हमले वाले एजों को जिन्हें कोई नियम कवर नहीं करता। `--defensive` के साथ मिलाकर, यह उत्तर देता है "मेरी तैनात डिटेक्शनों के आधार पर, मेरा सबसे शांत हमला पथ अभी भी कहाँ अदृश्य है?"

---

## AD CS ESC1-8

लोड समय पर NoiseHound, BloodHound के ADCS पोस्ट-प्रोसेसिंग का एक केंद्रित संस्करण निष्पादित करता है, जो बनाए रखे गए टेम्पलेट/CA तथ्यों से एस्केलेशन एजों को संश्लेषित करता है। एक कमजोर टेम्पलेट पर `Enroll` अधिकार, प्रिंसिपल से डोमेन के Domain Admins समूह (RID 512) तक एक सीधा `ADCSESCn` एज बन जाता है, इसलिए प्रमाणपत्र एस्केलेशन किसी भी अन्य एज की तरह पाथ करने योग्य और स्कोर किया जाने वाला होता है:

| एज | शर्त |
|------|-----------|
| `ADCSESC1` | Enrollee-supplies-subject + client-auth EKU, कोई अनुमोदन/RA हस्ताक्षर नहीं |
| `ADCSESC2` | Any-Purpose / SubCA EKU, कोई अनुमोदन नहीं |
| `ADCSESC3` | Enrollment-agent टेम्पलेट + उसी CA पर एक auth टेम्पलेट |
| `ADCSESC4` | प्रकाशित टेम्पलेट पर खतरनाक लेखन नियंत्रण |
| `ADCSESC5` | CA ऑब्जेक्ट या उसके होस्टिंग कंप्यूटर का नियंत्रण |
| `ADCSESC6` | CA पर `EDITF_ATTRIBUTESUBJECTALTNAME2` सेट है |
| `ADCSESC7` | CA पर `ManageCA` / `ManageCertificates` |
| `ADCSESC8` | कमजोर HTTP वेब-एनरोलमेंट एंडपॉइंट (coerce + NTLM रिले) |

इसे आज़माएँ: `python -m noisehound -i samples/sample_adcs_ce.zip -s jdoe -o "Domain Admins"`.

प्रलेखित सरलीकरण (वे सुरक्षित पक्ष पर रहते हुए अधिक पथ दिखाते हैं): CA-स्तरीय एनरोलमेंट प्रतिबंध मॉडल नहीं किए जाते (टेम्पलेट एनरोलमेंट को पर्याप्त मान लिया जाता है); ESC5 CA ऑब्जेक्ट और उसके होस्ट को कवर करता है, हर PKI कंटेनर को नहीं; ESC9/10/13 दायरे से बाहर हैं। पोस्ट-प्रोसेस्ड एक्सपोर्ट में पहले से मौजूद सिंथेटिक ESC एजों को संरक्षित किया जाता है।

---

## कॉर्पस (`edge_mappings/`)

एज-टेलीमेट्री कॉर्पस इस टूल की वास्तविक बौद्धिक संपदा (IP) है; कोड इसके ऊपर तुलनात्मक रूप से सरल ग्राफ गणित है। प्रत्येक `edge_mappings/<Edge>.json` एक BloodHound एज प्रकार को उसकी डिटेक्शन सतह से मैप करता है:

- अपेक्षित टेलीमेट्री स्रोत (Windows Security ईवेंट IDs, Sysmon ईवेंट IDs,
  नेटवर्क, EDR/ITDR ह्यूरिस्टिक्स) प्रति-स्रोत विश्वसनीयता के साथ और यह कि
  प्रासंगिक ऑडिटिंग डिफ़ॉल्ट रूप से चालू है या नहीं
- एक स्थिर noise स्कोर (0-100)
- MITRE तकनीक, आवश्यक विशेषाधिकार, सामान्य abuse primitive, और नोट्स```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."
}

कोरपस का विस्तार वह क्षेत्र है जहाँ सबसे अधिक निरंतर प्रयास किए जाने चाहिए। एक नई JSON फ़ाइल जोड़ें, स्कीमा बनाए रखें (लोड समय पर मान्य किया जाता है), और यह स्वचालित रूप से शामिल कर ली जाती है। v0.3 में 43 एज प्रकार शामिल हैं जो ACL-दुरुपयोग, Kerberos, प्रत्यायोजन, ADCS ESC1-8, LAPS/gMSA, GPO, ट्रस्ट और एक्सेस-अधिकार एज को कवर करते हैं जो पथ-खोज के लिए महत्वपूर्ण हैं।

स्कोर DreadHost Red Team Operator Playbook नॉइज़ मैट्रिक्स से सीड किए जाते हैं (Windows/Sysmon इवेंट मैपिंग, तकनीक नॉइज़ रेटिंग) और मानक AD डिटेक्शन तथ्य। उन्हें अपने स्वयं के लैब डिटेक्शन डेटा के अनुसार समायोजित करें।

रोडमैप

• कैलिब्रेशन - 30/57 एज के लिए पूर्ण, जारी। तीन मापी गई प्रोफ़ाइल शामिल हैं profiles/ में (audit / EDR / Elastic स्तर) क्लोज़्ड-लूप के साथ सत्यापन। शेष: अन्य ~28 एज (coercion/relay, ADCS ESC2-13, CanRDP), MDI रनटाइम-अलर्ट स्तर (पोस्चर काम करता है; अलर्ट पथ के लिए बेयर-मेटल/ Ludus DC की आवश्यकता है - docs/CALIBRATION.md देखें), और एक चयन योग्य टूलिंग-प्रोफ़ाइल अक्ष (docs/TOOLING_AXIS.md) ताकि स्कोर ऑफ-द-शेल्फ बनाम नेटिव ट्रेडक्राफ्ट को दर्शाएं।
• चरण 2 - लाइव डिटेक्शन सत्यापन। स्थिर स्कोर को इससे बदलें वास्तविक लक्ष्य के Defender/Sysmon/audit कॉन्फ़िग से प्राप्त live_noise_score, OffsetInspect की डिटेक्शन-सीमा लॉजिक का पुन: उपयोग करते हुए। annotate() पहले से ही एक live_scores ओवरराइड स्वीकार करता है; CLI हुक चरण 2 में आएगा।
• लाइव Neo4j इंजेशन Bolt के माध्यम से उसी DB पर जिसे SharpHound पॉप्युलेट करता है (ऑफ़लाइन zip इंजेशन अभी शामिल है)।
• ADCS ESC9/10/13 संश्लेषण (ESC1-8 अभी शामिल हैं)।
• स्कोरिंग इंजन का Rust पोर्ट (petgraph), OffsetInspect -> OffsetScan पैटर्न का अनुसरण करते हुए, एक बार डेटा मॉडल सिद्ध हो जाने पर।

योगदान

कोरपस सामुदायिक-विस्तार योग्य है और यही वह स्थान है जहाँ योगदान सबसे अधिक मायने रखते हैं। एक एज जोड़ना एक JSON फ़ाइल है जिसे लोड समय पर और CI में मान्य किया जाता है:```bash noisehound-validate # schema + consistency checks over the corpus python -m pytest tests/ -q

स्कीमा, स्कोरिंग गाइड और PR मार्गदर्शन के लिए [CONTRIBUTING.md](https://github.com/warpedatom/noisehound/blob/HEAD/CONTRIBUTING.md) देखें, और
औपचारिक एज स्कीमा के लिए [`docs/edge_schema.json`](https://github.com/warpedatom/noisehound/blob/HEAD/docs/edge_schema.json)
देखें।

## लैब के साथ अंशांकन

30 किनारे मापे जाते हैं (देखें [`profiles/`](https://github.com/warpedatom/noisehound/blob/HEAD/profiles/)); बाकी अनुमानित हैं जब तक
आप उन्हें मापते नहीं, और हर वातावरण अलग होता है। [`docs/CALIBRATION.md`](https://github.com/warpedatom/noisehound/blob/HEAD/docs/CALIBRATION.md)
एक संपूर्ण प्लेबुक है: लैब टोपोलॉजी, सटीक Windows ऑडिट नीति और Sysmon
कॉन्फ़िग ताकि कॉर्पस के इवेंट आईडी ट्रिगर हों, एक प्रति-किनारा अभ्यास रनबुक, एक
APT29-via-Caldera यथार्थवाद परत, और परिणामों को कैलिब्रेटेड प्रोफ़ाइल में
संकलित करने का तरीका। `noisehound-calibrate --template -o lab_detections.json` से शुरू करें।

[`lab/`](https://github.com/warpedatom/noisehound/blob/HEAD/lab/) किट डिटेक्शन इंस्ट्रूमेंटेशन को स्वचालित करती है:
`Enable-Telemetry.ps1` ऑडिट नीति, स्क्रिप्ट-ब्लॉक लॉगिंग, DCSync
SACL और Sysmon चालू करता है; `Collect-Detections.ps1` एक विंडो में जो फायर हुआ उसे गिनता है। यह
[GOAD](https://github.com/Orange-Cyberdefense/GOAD) या
[Vulnerable-AD](https://github.com/WazeHell/vulnerable-AD) (या आपकी CRTP/CRTO
लैब) पर निर्भर करता है, असुरक्षित डोमेन के लिए उन्हें दोबारा लागू करने के बजाय।

## उत्तरदायी उपयोग

NoiseHound अधिकृत सुरक्षा परीक्षण, पर्पल-टीम अभ्यास, डिटेक्शन
इंजीनियरिंग और शोध के लिए है। यह उस BloodHound डेटा को पढ़ता है जिसे आप पहले ही एकत्र कर चुके हैं और
रैंकिंग की गणना करता है; यह लक्ष्य के विरुद्ध कुछ भी निष्पादित नहीं करता। इसका उपयोग केवल वहीं करें जहाँ आपके पास
स्पष्ट लिखित प्राधिकरण हो। योगदान में
लक्ष्य-विशिष्ट या वास्तविक-एंगेजमेंट डेटा शामिल नहीं होना चाहिए।

## परीक्षण```bash
python -m pytest tests/          # with pytest
python tests/test_noisehound.py  # dependency-light smoke run

लेआउट```

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 docs/ WALKTHROUGH.md (start here), CYPHER.md, VALIDATION.md, CALIBRATION.md, ROADMAP.md, seed_demo_graph.cypher, seed_showcase_graph.cypher, images/ tests/ unit + end-to-end tests