वे अनुरोध पहले से ही आपके Laravel ऐप तक पहुँच रहे हैं। आपका एक्सेस लॉग URL और स्टेटस कोड दिखाता है, और कुछ नहीं — न डिकोड किया गया पेलोड, न यह कि आपके कौन से रूट को लक्षित किया गया, न यह कि क्या उसी IP ने इस घंटे में चालीस अन्य चीज़ें आज़माई हैं।

यह पैकेज उन सवालों का जवाब देता है। इसे किसी भी Laravel 10–13 ऐप में डालें और यह हर HTTP अनुरोध को 150+ हमला पैटर्न के विरुद्ध स्कैन करना शुरू कर देता है, प्रत्येक मिलान को विश्वास के आधार पर स्कोर करता है और इसे आपके डेटाबेस में लिखता है — एक अंतर्निहित डैशबोर्ड, Slack अलर्ट, geo-enrichment, और fail2ban/blocklist एक्सपोर्ट के साथ। कोई भी अनुरोध कभी ब्लॉक नहीं किया जाता। सिक्योरिटी कैमरा सोचें, ताला नहीं: यह आपको ठीक-ठीक दिखाता है कि कौन आपके रूट को प्रोब कर रहा है, कितनी बार, और किन तकनीकों के साथ।

> एक प्रोडक्शन ऐप से निकाला गया और वास्तविक ट्रैफ़िक पर परखा गया। 1,857 टेस्ट, Laravel के अलावा कोई रनटाइम निर्भरता नहीं, और डिटेक्शन के लिए किसी इंटरनेट कनेक्शन की आवश्यकता नहीं।
>
> अपग्रेड कर रहे हैं? देखें [UPGRADING.md](https://github.com/jay123anta/laravel-threat-detection/blob/main/UPGRADING.md)। योगदान कर रहे हैं? देखें [CONTRIBUTING.md](https://github.com/jay123anta/laravel-threat-detection/blob/main/CONTRIBUTING.md)।

## एक मिनट से कम में शुरू करें```bash
composer require jayanta/laravel-threat-detection
php artisan vendor:publish --tag=threat-detection-migrations
php artisan migrate

---

## यह कहाँ फिट बैठता है: IDS बनाम WAF बनाम एज

यह पैकेज एक **निष्क्रिय, एप्लिकेशन-स्तरीय IDS** है — यह देखता और रिकॉर्ड करता है, यह
ब्लॉक नहीं करता। यह किसी WAF या एज सेवा के *साथ-साथ* रहने के लिए बनाया गया है, न कि उसे बदलने के लिए। प्रत्येक परत कुछ ऐसा देखती है जो अन्य नहीं देख सकतीं:

| | **यह पैकेज** (ऐप IDS) | **WAF** (mod_security, Cloudflare WAF) | **एज / CDN** (Cloudflare) |
|---|:---:|:---:|:---:|
| दुर्भावनापूर्ण अनुरोधों को ब्लॉक करता है | ❌ केवल लॉग करता है | ✅ | ✅ |
| पूर्ण ऐप संदर्भ (सटीक रूट, डिकोड किया गया पेलोड, प्रमाणित उपयोगकर्ता) | ✅ | ⚠️ आंशिक | ❌ |
| आपके DB में अंतर्निहित डैशबोर्ड + खतरा लॉग | ✅ | ⚠️ भिन्न होता है | ⚠️ केवल एज |
| ऐप-विशिष्ट डिटेक्शन (जैसे आधार / PAN / IFSC PII) | ✅ कस्टम पैटर्न | ❌ | ❌ |
| ऑफ़लाइन काम करता है / कोई बाहरी सेवा नहीं | ✅ | ⚠️ निर्भर करता है | ❌ |
| आपके ऐप तक पहुँचने से पहले ट्रैफ़िक रोकता है | ❌ | ✅ एज | ✅ |
| सेटअप | एक `composer require` | मध्यम–उच्च | निम्न–मध्यम |
| लागत | मुफ़्त, MIT | भिन्न होती है | मुफ़्त टियर + सशुल्क |

**संक्षेप में:** एक एज/WAF आपके दरवाज़े का ताला है; यह *अंदर* का सुरक्षा कैमरा है,
जिसमें ऐप संदर्भ होता है ताकि आपको ठीक-ठीक पता चले कि किस रूट पर, किसके द्वारा, और कितनी बार क्या आज़माया जा रहा है। इसका उपयोग वास्तविक निर्णयों को सूचित करने के लिए करें — fail2ban प्रतिबंध, रेट लिमिट, जियो-ब्लॉकिंग — उन डेटा के साथ जो आपकी एज परत कभी नहीं देखती।

### यह जानबूझकर क्या नहीं है

- **WAF नहीं है।** यह कभी किसी अनुरोध को ब्लॉक, फ़िल्टर या संशोधित नहीं करता। प्रवर्तन के लिए Cloudflare, mod_security, या किसी वास्तविक WAF का उपयोग करें। (हैंड ऑफ़ करने के लिए कोई एज परत नहीं? [ऑपरेटर-साइड हेल्पर्स](#acting-on-the-data-operator-side-blocking) पैकेज के निर्णयों को उजागर करते हैं ताकि आप अपना खुद का पाँच-पंक्ति का ब्लॉकिंग मिडलवेयर लिख सकें — प्रवर्तन कोड आपका रहता है, पैकेज का नहीं।)
- **सुरक्षित कोडिंग का विकल्प नहीं है।** पैरामीटरयुक्त क्वेरी, इनपुट वैलिडेशन, और आउटपुट एस्केपिंग आपके वास्तविक बचाव हैं। यह पैकेज मानता है कि आपका कोड पहले से सुरक्षित है और आपको *दृश्यता* देता है, सुरक्षा नहीं।
- **एज सेवा नहीं है।** यदि आप Cloudflare को आगे लगा सकते हैं, तो लगाएँ — फिर एप्लिकेशन-स्तरीय विवरण के लिए इसे जोड़ें जो एज सेवाएँ नहीं देख सकतीं।
- **पूर्ण डिटेक्टर नहीं है, और हो भी नहीं सकता।** पैटर्न मिलान उन हमलों को पकड़ता है जो *ज्ञात हमलों जैसे दिखते हैं*। कोई नई तकनीक, या कोई परिचित तकनीक जिसे काफ़ी बदल दिया गया हो, बिना लॉग हुए निकल जाएगी — और आपको बताया नहीं जाएगा कि ऐसा हुआ। यहाँ मौन का अर्थ है "कुछ मेल नहीं खाया", कभी नहीं "कुछ हुआ ही नहीं"। जहाँ यह अपनी जगह बनाता है वह है उच्च-मात्रा, कम-प्रयास वाला ट्रैफ़िक जो वास्तव में एक सार्वजनिक Laravel ऐप पर पहुँचने वाले अधिकांश हिस्से का निर्माण करता है: स्कैनर, रेकॉन प्रोब, ऑफ़-द-शेल्फ इंजेक्शन स्ट्रिंग्स, क्रेडेंशियल स्प्रे। एक शांत लॉग को साक्ष्य की अनुपस्थिति मानें, न कि अनुपस्थिति का साक्ष्य।

### अपेक्षा करें कि यह पहले ही दिन आपकी खुद की सामग्री को फ़्लैग करेगा

एक बिना ट्यून किया गया इंस्टॉल वैध सामग्री पर फ़ायर करता है, और आपको यह इंस्टॉल करने के बाद नहीं बल्कि पहले जानना चाहिए। ये मापे गए हैं, काल्पनिक नहीं — सूट इस सटीक सूची को पिन करता है ताकि यह बदल न सके ([`LegitimateTrafficCorpusTest`](https://github.com/jay123anta/laravel-threat-detection/blob/main/tests/Feature/LegitimateTrafficCorpusTest.php)):

<!-- noise-floor:start -->
| पूरी तरह से वैध अनुरोध | बिना ट्यून किया गया इंस्टॉल क्या लॉग करता है |
|---|---|
| सर्च बॉक्स में टाइप किया गया `how to write a UNION SELECT in postgres` | `SQL Injection UNION` / high |
| `<script>window.dataLayer=[];</script>` वाला एक ब्लॉग पोस्ट | `XSS Script Tag` / high |
| पेस्ट किए गए `SELECT * FROM users WHERE id = 1` त्रुटि वाला एक सपोर्ट टिकट | `SQLi Variant` / high |
| यह समझाने वाला दस्तावेज़ कि `../../etc/passwd` क्लासिक ट्रैवर्सल पेलोड है | `Directory Traversal` / medium |
| एक वास्तविक भारतीय मोबाइल नंबर और PAN एकत्र करने वाला प्रोफ़ाइल फ़ॉर्म | `PAN Number Detected` / high |
<!-- noise-floor:end -->

**इनमें से कोई भी बग नहीं है।** `<script>` वाला एक ब्लॉग पोस्ट, बाइट-दर-बाइट, एक स्टोर्ड-XSS पेलोड है; `UNION SELECT` की खोज उसके प्रयास से अप्रभेद्य है। इन्हें ऐप्लिकेशन संदर्भ के अलावा कुछ भी अलग नहीं करता, और कोई भी पैटर्न इंजन आपके लिए वह संदर्भ प्रदान नहीं कर सकता।

इसे प्रदान करना एक-पंक्ति का कॉन्फ़िग परिवर्तन है — `safe_fields`, `safe_paths`, `content_paths`, या `relaxed` मोड। देखें [Reducing False Positives](#reducing-false-positives)।
**यदि आपका ऐप रिच टेक्स्ट, कोड सैंपल, या सर्च क्वेरी स्वीकार करता है, तो आउटपुट का मूल्यांकन करने से पहले ऐसा करें।** डिफ़ॉल्ट जानबूझकर शोर-भरा-पर-ईमानदार है, न कि शांत-और-अपूर्ण: एक ज्ञात मैच को चुप कराना उस मैच की खोज करने से आसान है जो कभी फ़ायर ही नहीं हुआ।

### तो आप वास्तव में इसका उपयोग क्या करते हैं?

एक ऐसे डिटेक्टर के बारे में सबसे आम सवाल जो कभी ब्लॉक नहीं करता। चार उत्तर, बढ़ते प्रयास के क्रम में:

| आप चाहते हैं | उपयोग करें | प्रयास |
|---|---|---|
| देखें कि आप पर क्या हमला हो रहा है | [डैशबोर्ड](#dashboard) या `threat-detection:stats` | कोई नहीं, यह पहले से चल रहा है |
| फ़ायरवॉल पर बार-बार अपराध करने वालों को प्रतिबंधित करें | [`threat-detection:export-fail2ban`](#artisan-commands) — cron को पाइप करें | एक पंक्ति |
| वेब सर्वर पर अस्वीकार करें | [`threat-detection:export-blocklist`](#artisan-commands) → nginx/apache निर्देश | एक पंक्ति |
| ऐप में अनुरोधों को अस्वीकार करें | [ऑपरेटर-साइड हेल्पर्स](#acting-on-the-data-operator-side-blocking) — `isBlocklisted()`, `isDdosThresholdExceeded()` | आपके अपने मिडलवेयर की ~10 पंक्तियाँ |
| वास्तविक समय में प्रतिक्रिया दें | [`ThreatDetected` इवेंट](#threatdetected-event) — Telegram, SIEM, PagerDuty | एक लिसनर |

पैकेज इंटेलिजेंस प्रदान करता है; आप इनकार प्रदान करते हैं। यह विभाजन जानबूझकर है — आपके ऐप में रहने वाला प्रवर्तन कोड वह कोड है जिसे आप पढ़, परीक्षण और बंद कर सकते हैं, और इसका मतलब है कि एक डिटेक्शन बग कभी आपकी साइट को नीचे नहीं गिरा सकता।


### यह अन्य Laravel सुरक्षा पैकेजों से कैसे तुलना करता है

ये अलग-अलग समस्याओं को हल करते हैं और अच्छी तरह से मिलते हैं — तालिका सही टूल चुनने के बारे में है, जीतने के बारे में नहीं।

| पैकेज | यह क्या करता है | ब्लॉक करता है? | इसका उपयोग कब करें |
|---|---|:---:|---|
| **यह पैकेज** | हर अनुरोध को 150+ पैटर्न के विरुद्ध स्कैन करता है, पूर्ण ऐप संदर्भ के साथ लॉग करता है | ❌ | आप *देखना* चाहते हैं कि आपके ऐप पर क्या आज़माया जा रहा है |
| `spatie/laravel-honeypot` | छिपा हुआ फ़ॉर्म फ़ील्ड जो स्पैम बॉट्स को पकड़ता है | ✅ केवल फ़ॉर्म | आपके पास सार्वजनिक फ़ॉर्म हैं जिन पर स्पैम हो रहा है |
| `graham-campbell/security` | इनपुट से XSS-जैसा मार्कअप हटाता है | ✅ बदलता है | आप सरल इनपुट सैनिटाइज़िंग चाहते हैं |
| `spatie/laravel-csp` | Content-Security-Policy हेडर भेजता है | ✅ ब्राउज़र | आप ब्राउज़र जो लोड करता है उसे सीमित करना चाहते हैं |
| `laravel/fortify` + रेट लिमिट | ऑथ थ्रॉटलिंग और लॉकआउट | ✅ | आपको लॉगिन पर ब्रूट-फ़ोर्स सुरक्षा चाहिए |
| Cloudflare / mod_security | एज WAF, आपके ऐप से पहले ब्लॉक करता है | ✅ | आप चाहते हैं कि ट्रैफ़िक आने से पहले रोक दिया जाए |

ईमानदार सारांश: एक हनीपॉट फ़ॉर्म स्पैम पकड़ता है, एक WAF एज पर ज्ञात-खराब ट्रैफ़िक को ब्लॉक करता है, और CSP ब्राउज़र को सीमित करता है। **इनमें से कोई भी आपको नहीं बताता कि किसी हमलावर ने आपके विशिष्ट रूट्स के विरुद्ध क्या आज़माया, पेलोड डिकोड किए गए और प्रमाणित उपयोगकर्ता संलग्न।** यही अंतराल यह भरता है — और यही कारण है कि पैकेज जानबूझकर ब्लॉक नहीं करता: आप इसे उपरोक्त सभी के साथ चला सकते हैं बिना किसी के एक-दूसरे से टकराए।

---

## आवश्यकताएँ

- PHP 8.2+ (Laravel 13 के लिए PHP 8.3+ आवश्यक है)
- Laravel 10.x, 11.x, 12.x, या 13.x
- Laravel द्वारा समर्थित कोई भी डेटाबेस (MySQL, PostgreSQL, SQLite, SQL Server)
- कोई भी कैश ड्राइवर - **किसी Redis या क्यू वर्कर की आवश्यकता नहीं**। Redis/Memcached केवल वैकल्पिक DDoS जाँच को सक्षम करने के लिए *अनुशंसित* है (जो गैर-परमाणु ड्राइवरों पर स्वतः अक्षम हो जाती है)। क्यू किए गए राइट ऑप्ट-इन हैं और डिफ़ॉल्ट रूप से बंद हैं।

---

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

1. एक मिडलवेयर हर आने वाले HTTP अनुरोध को स्कैन करता है
2. अनुरोध को 158 रेगेक्स पैटर्न के विरुद्ध जाँचा जाता है जो SQL इंजेक्शन, XSS, RCE, फ़ाइल ट्रैवर्सल, SSRF, LDAP, XPath, SSTI, और अधिक को कवर करते हैं
3. यदि कोई खतरा पैटर्न मेल खाता है, तो आपकी `threat_logs` डेटाबेस तालिका में IP, URL, खतरा प्रकार, गंभीरता स्तर, और एक विश्वास स्कोर के साथ एक रिकॉर्ड लिखा जाता है
4. वैकल्पिक रूप से, उच्च-गंभीरता वाले खतरों के लिए एक Slack अलर्ट भेजा जाता है
5. अनुरोध सामान्य रूप से आगे बढ़ता है - **कुछ भी ब्लॉक नहीं होता**

डिटेक्शन के लिए किसी इंटरनेट कनेक्शन की आवश्यकता नहीं है।

---

## त्वरित शुरुआत

### 1. पैकेज इंस्टॉल करें```bash
composer require jayanta/laravel-threat-detection

यह दो तालिकाएँ बनाता है: `threat_logs` (पता लगाए गए खतरों को संग्रहीत करता है) और `threat_exclusion_rules` (गलत सकारात्मक नियमों को संग्रहीत करता है)।

**सत्यापित करें कि तालिकाएँ बनाई गई हैं:**```bash
php artisan migrate:status

> **अपना Laravel संस्करण कैसे जाँचें:** अपने टर्मिनल में `php artisan --version` चलाएँ।

**यदि आप Laravel 10 का उपयोग करते हैं** - `app/Http/Kernel.php` खोलें:```php
protected $middlewareGroups = [
    'web' => [
        // ... existing middleware
        \JayAnta\ThreatDetection\Http\Middleware\ThreatDetectionMiddleware::class,
    ],
];

यह पैकेज समझदार डिफ़ॉल्ट्स के साथ काम करता है। कॉन्फ़िग प्रकाशित करने से आप डिटेक्शन पैटर्न, संवेदनशीलता मोड, Slack सूचनाएँ, और बहुत कुछ अनुकूलित कर सकते हैं। यदि आप इस चरण को छोड़ देते हैं, तो भी सब कुछ काम करता है।

**बस इतना ही।** आपका ऐप अब खतरों का पता लगा रहा है।

---

## सत्यापित करें कि यह काम करता है

इंस्टॉलेशन के बाद, एक परीक्षण खतरा ट्रिगर करें और पुष्टि करें कि यह लॉग किया गया था।

### चरण 1: अपना ऐप शुरू करें```bash
php artisan serve

**XSS (क्रॉस-साइट स्क्रिप्टिंग):**```
http://localhost:8000/?q=<script>alert(1)</script>

**RCE (रिमोट कोड एक्ज़ीक्यूशन):**```
http://localhost:8000/?cmd=system('ls -la')

**Windows कमांड इंजेक्शन:**```
http://localhost:8000/?cmd=powershell -c whoami

> अपने ऐप में वास्तव में मौजूद रूट का उपयोग करें (जैसे `/`)। यदि URL 404 लौटाता है, तो हो सकता है कि मिडलवेयर चला ही न हो।

### चरण 3: जाँचें कि खतरों को लॉग किया गया था

**विकल्प A - Artisan कमांड (सबसे तेज़):**```bash
php artisan threat-detection:stats

```php
DB::table('threat_logs')->latest()->take(5)->get(['ip_address', 'type', 'threat_level', 'confidence_score']);

### परीक्षण करते समय जानने योग्य बातें

| व्यवहार | स्पष्टीकरण |
|----------|-------------|
| समान खतरा केवल प्रति 5 मिनट में एक बार लॉग होता है | डुप्लीकेशन हटाना: समान IP + समान खतरा प्रकार 5 मिनट के लिए कैश किया जाता है। प्रत्येक परीक्षण के लिए **भिन्न आक्रमण प्रकार** का उपयोग करें, या परीक्षणों के बीच प्रतीक्षा करें। |
| `curl` अनुरोध अतिरिक्त पहचान ट्रिगर करते हैं | `curl` का उपयोग करने पर "cURL Command" user-agent पहचान (कम गंभीरता) भी लॉग होती है। यह अपेक्षित है - पैकेज स्वचालित उपकरणों का पता लगाता है। |
| पैकेज कभी भी अनुरोधों को ब्लॉक नहीं करता | आपका ऐप सामान्य रूप से कार्य करता रहता है। पहचान निष्क्रिय है। |
| Slack सेटअप की आवश्यकता नहीं | सूचनाएं डिफ़ॉल्ट रूप से बंद हैं। |
| इंटरनेट कनेक्शन की आवश्यकता नहीं | मुख्य पहचान 100% स्थानीय है। केवल वैकल्पिक `threat-detection:enrich` कमांड जियो-डेटा के लिए बाहरी API को कॉल करता है। |

### समस्या निवारण

**यहाँ से शुरू करें — एक कमांड इसका अधिकांश उत्तर देता है:**```bash
php artisan threat-detection:doctor

कवर क्या करता है: इस वातावरण के लिए सक्षम डिटेक्शन; लेखक को जिन सभी कॉलमों की आवश्यकता होती है (एक गुम कॉलम **हर** खतरे को खारिज कर देता है); डैशबोर्ड/API कॉलम; exclusion-rules तालिका; क्या middleware वास्तव में किसी route या group से जुड़ा है; इस संस्करण से पहले का प्रकाशित config; अंतर्निहित पैटर्न को ढकने वाले कस्टम पैटर्न; एक cache driver जो DDoS गिनती नहीं कर सकता; और बिना authentication के खुला छोड़ा गया डैशबोर्ड या API।

**"मैंने परीक्षण किया लेकिन `threat-detection:stats` शून्य खतरे दिखाता है" / "खतरे डेटाबेस में संग्रहीत नहीं होते"**

यदि doctor पास हो गया, तो इंस्टॉल ठीक है और समस्या परीक्षण अनुरोध में ही है। तीन चीजें जो यह आपके लिए जाँच नहीं सकता:

| जाँच | सत्यापन कैसे करें |
|-------|---------------|
| IP whitelisted नहीं है | यदि आपने `.env` में `THREAT_DETECTION_WHITELISTED_IPS` जोड़ा है, तो परीक्षण के दौरान इसे हटा दें |
| मौजूदा route का उपयोग किया | परीक्षण URL को वास्तविक route से मेल खाना चाहिए (जैसे, `/`)। 404 का अर्थ है कि middleware कभी चला ही नहीं |
| Dedup cache | समान IP + समान attack type 5 मिनट के लिए cached रहता है - भिन्न attack type आज़माएँ |

> केवल `php artisan migrate` चलाना कभी पर्याप्त नहीं होता: migration फ़ाइलें
> package के अंदर रहती हैं और पहले आपके ऐप के `database/migrations/`
> में publish की जानी चाहिए। जब यही समस्या हो, तो doctor सटीक कमांड प्रिंट करता है।

**"API 401 Unauthorized लौटाता है"**

नीचे [API Authentication](#api-authentication) देखें।

**"Dashboard 404 दिखाता है"**

Dashboard डिफ़ॉल्ट रूप से अक्षम है। `.env` में `THREAT_DETECTION_DASHBOARD=true` जोड़ें और route cache साफ़ करें:```bash
php artisan route:clear

### डिटेक्शन मोड्स

| मोड | कॉन्फिडेंस थ्रेशोल्ड | व्यवहार |
|------|---------------------|----------|
| `strict` | 0 (सब कुछ लॉग करता है) | सभी पैटर्न सक्रिय, सबसे कम थ्रेशोल्ड। सब कुछ पकड़ता है लेकिन वैध ट्रैफ़िक को भी फ़्लैग कर सकता है। |
| `balanced` | 10 | डिफ़ॉल्ट। कॉन्फिडेंस स्कोरिंग सक्रिय, मानक थ्रेशोल्ड। अधिकांश ऐप्स के लिए उपयुक्त। |
| `relaxed` | 40 | केवल उच्च-गंभीरता वाले पैटर्न ट्रिगर होते हैं। बार-बार फ़ॉल्स पॉज़िटिव वाली कंटेंट-भारी साइटों के लिए सर्वोत्तम। |

### सक्षम एनवायरनमेंट्स

डिफ़ॉल्ट रूप से, डिटेक्शन `production`, `staging`, और `local` में चलता है। बदलने के लिए, कॉन्फ़िग प्रकाशित करें और संपादित करें:```php
'enabled_environments' => ['production', 'staging', 'local'],

### कॉन्फ़िग संदर्भ

सभी उपलब्ध विकल्पों को देखने के लिए कॉन्फ़िग फ़ाइल प्रकाशित करें:```bash
php artisan vendor:publish --tag=threat-detection-config

सभी रूट स्कैन करने के लिए खाली (डिफ़ॉल्ट) छोड़ें (`skip_paths` के अधीन)। जब दोनों कॉन्फ़िगर किए जाते हैं, तो पहले `only_paths` जाँचा जाता है, फिर मेल खाने वाले सेट के भीतर `skip_paths` लागू होता है।

### क्यू समर्थन

डिफ़ॉल्ट रूप से, थ्रेट लॉगिंग अनुरोध चक्र में समकालिक रूप से होती है। उच्च-ट्रैफ़िक ऐप्स के लिए, आप DB राइट्स और Slack सूचनाओं को क्यू पर ऑफ़लोड कर सकते हैं:```env
THREAT_DETECTION_QUEUE=true
THREAT_DETECTION_QUEUE_CONNECTION=redis
THREAT_DETECTION_QUEUE_NAME=threat-logs

यह Laravel के scheduler के चलने की आवश्यकता है (`php artisan schedule:run`)। `threat-detection:purge` के माध्यम से प्रतिदिन 02:00 बजे चलता है।

### ThreatDetected Event

प्रत्येक पुष्ट किए गए खतरे एक `ThreatDetected` event dispatch करता है जिसे आप सुन सकते हैं:```php
// app/Providers/EventServiceProvider.php
use JayAnta\ThreatDetection\Events\ThreatDetected;

protected $listen = [
    ThreatDetected::class => [
        YourCustomListener::class,
    ],
];

The event carries `$ipAddress`, `$requestCount`, `$threshold`, and `$windowSeconds`. It is
throttled to once per IP per dedup window (same throttle as the log row), so a flood can't
drown your listeners. Use it for alerting or to feed an external ban store; to *refuse*
over-threshold clients, use `ThreatDetection::isDdosThresholdExceeded($ip)` from your own
middleware instead — see [Acting on the Data](#acting-on-the-data-operator-side-blocking).

---

## Slack Notifications

Slack alerts are disabled by default. To enable:```env
THREAT_DETECTION_NOTIFICATIONS=true
THREAT_DETECTION_SLACK_WEBHOOK=https://hooks.slack.com/services/YOUR/WEBHOOK/URL
THREAT_DETECTION_SLACK_CHANNEL=#threat-alerts

---

## डैशबोर्ड

<p align="center">
  <img src="https://assets.kitploit.com/production/public/readmes/12500/fc7950bd0cc6323bcc2d62b03e31c99edc7450b0ef76f9cbfa5133b527b25269.png" alt="खतरा पहचान डैशबोर्ड — आंकड़े, 7-दिन की टाइमलाइन, लाइव खतरा लॉग, शीर्ष अपराधी IPs, और देश के अनुसार खतरे" width="100%">
</p>

पैकेज एक अंतर्निहित डार्क-मोड डैशबोर्ड के साथ आता है (Alpine.js + Tailwind CDN - किसी बिल्ड चरण की आवश्यकता नहीं)।```
+-------------------------------------------------------------------------+
|  Threat Detection Dashboard                                              |
+-------------------------------------------------------------------------+
|  Total: 847  |  High: 23  |  Med: 156  |  Low: 668  |  IPs: 94         |
+-------------------------------------------------------------------------+
|  [Timeline Chart - 7 Day Stacked Bar]                                   |
+-------------------------------------------------------------------------+
|  Search: [___________]  Level: [All]                                    |
|  Time         IP             Type            Level  Confidence  Actions  |
|  Mar 2 14:02  185.220.101.4  SQL Injection   HIGH   80%         [FP]    |
|  Mar 2 13:58  45.33.32.156   XSS Script Tag  HIGH   65%         [FP]    |
|  Mar 2 13:45  192.168.1.10   Scanner: Nikto  MED    35%         [FP]    |
+-------------------------------------------------------------------------+
|  Top IPs              |  Threats by Country                              |
|  185.220.101.4  [23]  |  US  234                                        |
|  45.33.32.156   [18]  |  CN  156                                        |
|  103.152.220.1  [12]  |  RU  98                                         |
+-------------------------------------------------------------------------+

Visit: `http://your-app.test/threat-detection`

### स्थानीय विकास के दौरान प्रवेश करना

डैशबोर्ड डिफ़ॉल्ट रूप से `['web', 'auth']` मिडलवेयर का उपयोग करता है, इसलिए उपयोगकर्ताओं को लॉग इन होना आवश्यक है। यदि आपके ऐप में अभी तक प्रमाणीकरण नहीं है, तो इसके बजाय इसे केवल अपनी मशीन तक सीमित करें:```env
THREAT_DETECTION_DASHBOARD_GUARD=ip
THREAT_DETECTION_DASHBOARD_IPS=127.0.0.1

**विकल्प 2 - मिडलवेयर को सीधे बदलें:**```php
// config/threat-detection.php
'api' => [
    'enabled' => true,
    'prefix' => 'api/threat-detection',
    'middleware' => ['api', 'auth'],  // or 'auth:your-guard'
],

> उत्पादन में तैनात करने से पहले प्रमाणीकरण बहाल करें।

### एंडपॉइंट संदर्भ

| Method | Endpoint | Description |
|--------|----------|-------------|
| GET | `/api/threat-detection/threats` | खतरों की सूची (पेजिनेटेड, फ़िल्टर करने योग्य) |
| GET | `/api/threat-detection/threats/{id}` | एकल खतरे का विवरण |
| POST | `/api/threat-detection/threats/{id}/false-positive` | खतरे को गलत सकारात्मक के रूप में चिह्नित करें |
| GET | `/api/threat-detection/stats` | समग्र आंकड़े |
| GET | `/api/threat-detection/summary` | प्रकार, स्तर, IP के अनुसार विस्तृत विवरण |
| GET | `/api/threat-detection/live-count` | पिछले घंटे में खतरे |
| GET | `/api/threat-detection/by-country` | देश के अनुसार समूहीकृत |
| GET | `/api/threat-detection/by-cloud-provider` | क्लाउड प्रदाता के अनुसार समूहीकृत |
| GET | `/api/threat-detection/top-ips` | शीर्ष अपराधी IP |
| GET | `/api/threat-detection/timeline` | खतरा टाइमलाइन (चार्ट के लिए) |
| GET | `/api/threat-detection/ip-stats?ip=x.x.x.x` | विशिष्ट IP के लिए आंकड़े |
| GET | `/api/threat-detection/correlation` | सहसंबंध विश्लेषण |
| GET | `/api/threat-detection/export` | CSV में निर्यात करें |
| GET | `/api/threat-detection/exclusion-rules` | बहिष्करण नियमों की सूची |
| DELETE | `/api/threat-detection/exclusion-rules/{id}` | एक बहिष्करण नियम हटाएं |

### `/threats` के लिए क्वेरी पैरामीटर

| Parameter | Description |
|-----------|-------------|
| `keyword` | IP, URL, प्रकार में खोजें |
| `ip` | IP पते के अनुसार फ़िल्टर करें |
| `level` | खतरे के स्तर के अनुसार फ़िल्टर करें (`high`, `medium`, `low`) |
| `type` | खतरे के प्रकार के अनुसार फ़िल्टर करें |
| `country` | देश कोड के अनुसार फ़िल्टर करें |
| `is_foreign` | विदेशी IP फ़िल्टर करें (`true`/`false`) |
| `cloud_provider` | क्लाउड प्रदाता के अनुसार फ़िल्टर करें |
| `is_false_positive` | गलत सकारात्मक स्थिति के अनुसार फ़िल्टर करें (`true`/`false`) |
| `date_from` / `date_to` | दिनांक सीमा फ़िल्टर |
| `per_page` | प्रति पृष्ठ आइटम (डिफ़ॉल्ट: 20, अधिकतम: 100) |

### उदाहरण API प्रतिक्रिया

**GET `/api/threat-detection/stats`:**```json
{
  "success": true,
  "data": {
    "total_threats": 847,
    "high_severity": 23,
    "medium_severity": 156,
    "low_severity": 668,
    "unique_ips": 94,
    "foreign_ips": 67,
    "cloud_attacks": 12,
    "today": 34,
    "last_hour": 5
  }
}

const threats = await fetch('/api/threat-detection/threats?per_page=20');
this.threats = await threats.json();

**React:**```jsx
useEffect(() => {
    fetch('/api/threat-detection/stats')
        .then(res => res.json())
        .then(data => setStats(data));
}, []);

---

## डेटा पर कार्रवाई करना (ऑपरेटर-साइड ब्लॉकिंग)

यह पैकेज कभी भी किसी अनुरोध को ब्लॉक नहीं करता — यही इसकी पहचान है, कोई डिफ़ॉल्ट नहीं। ऊपर दिए गए एक्सपोर्ट्स उन एनफोर्समेंट लेयर्स को फ़ीड करते हैं जो आप पहले से चला रहे हैं (fail2ban, nginx, एक एज WAF)। लेकिन कुछ डिप्लॉयमेंट्स में फ़ीड करने के लिए ऐसी कोई लेयर नहीं होती — शेयर्ड होस्टिंग, PaaS, उन लोड बैलेंसर के पीछे कंटेनर जिन्हें आप नियंत्रित नहीं करते। उनके लिए, यह पैकेज अपने *निर्णयों* को हेल्पर्स के रूप में उजागर करता है, और एनफोर्समेंट मिडलवेयर आप स्वयं लिखते हैं। एक्सपोर्ट्स के समान ही आर्किटेक्चर: **इंटेलिजेंस हम देते हैं, इनकार आप करते हैं।**```php
// app/Http/Middleware/EnforceThreatDecisions.php
namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use JayAnta\ThreatDetection\Facades\ThreatDetection;

class EnforceThreatDecisions
{
    public function handle(Request $request, Closure $next)
    {
        $ip = (string) $request->ip();

        // Static operator denylist (config: blocklisted_ips).
        // CIDR supported; whitelisted_ips wins on overlap.
        if (ThreatDetection::isBlocklisted($ip)) {
            abort(403);
        }

        // Volumetric flood: refuse over-threshold clients until the window resets.
        if (ThreatDetection::isDdosThresholdExceeded($ip)) {
            return response('Too Many Requests', 429, [
                'Retry-After' => (string) config('threat-detection.ddos.window', 60),
            ]);
        }

        return $next($request);
    }
}

The helpers:

| Helper | Returns | Backed by |
|---|---|---|
| `ThreatDetection::isBlocklisted($ip)` | `bool` | `blocklisted_ips` config (CIDR via `IpUtils`; whitelist wins) |
| `ThreatDetection::isWhitelisted($ip)` | `bool` | `whitelisted_ips` config |
| `ThreatDetection::ddosRequestCount($ip)` | `int` | the flood counter the detection middleware maintains |
| `ThreatDetection::isDdosThresholdExceeded($ip)` | `bool` | that counter vs `ddos.threshold` |

Notes:

- **The denylist is static and operator-maintained.** Nothing in the package ever adds to
  it — it executes the same decision a fail2ban jail would ("I read the dashboard; this /24
  is hostile"), just in-app.
- The DDoS counter counts only requests that reached detection (`skip_paths`, whitelisted
  IPs, and disabled environments are never counted), and stays at 0 on cache drivers where
  DDoS detection is disabled (`file`, `database`, `null`).
- When a client crosses the threshold, a [`DdosThresholdExceeded` event](#ddosthresholdexceeded-event)
  is also dispatched — useful for alerting or feeding an external ban list. Don't `abort()`
  from the listener, though: listeners run inside the detection middleware's fail-open
  `try/catch`, so refusal belongs in your own middleware as above.

---

## 404 Probe Tracking

The package detects reconnaissance probes -  bots that hit known vulnerable paths like `/wp-admin`, `/.env`, or `/phpmyadmin` on your non-WordPress, non-phpMyAdmin site. These have no malicious payload; the path itself is the signal.

Logged with a `[probe]` type tag, separate from payload-based detection. If a probe request also contains a malicious payload, both are logged independently.

Enabled by default with 50+ probe paths. Customize in `config/threat-detection.php`:```php
'probe_tracking' => [
    'enabled' => true,
    'default_level' => 'medium',
    'paths' => [
        '/wp-admin' => 'WordPress Admin',
        '/wp-admin/*' => 'WordPress Admin',
        '/.env' => 'Environment File',
        '/phpmyadmin' => 'phpMyAdmin',
        '/actuator/*' => 'Spring Actuator',
        // Add your own probe paths...
    ],
],

यहाँ सूचीबद्ध फ़ील्ड्स को query params और request body - दोनों form-encoded और JSON (`application/json`) - से हटा दिया जाता है, इससे पहले कि detection चले। उसी request पर मौजूद अन्य फ़ील्ड्स अभी भी पूरी तरह से scan किए जाते हैं।

### Safe Paths (path-aware, nested JSON APIs के लिए)

`safe_fields` किसी key name से **कहीं भी** मेल खाता है जहाँ वह दिखाई दे। nested JSON APIs के लिए यह अक्सर बहुत व्यापक होता है — आप किसी एक विशिष्ट फ़ील्ड की value को छूट देना चाह सकते हैं, बिना उस key को हर जगह छूट दिए। `safe_paths` का उपयोग करें, जो dot-notation **path** से मेल खाता है और `fnmatch` wildcards का समर्थन करता है:```php
// config/threat-detection.php
'safe_paths' => ['search.query', 'filters.*.value'],

उपलब्ध सत्यापनकर्ता:

| सत्यापनकर्ता | चेकसम | सामान्य उपयोग |
|------------|----------|-------------|
| `verhoeff` | Verhoeff | आधार संख्याएँ |
| `luhn`     | Luhn     | क्रेडिट/डेबिट कार्ड संख्याएँ |

शिप किए गए मैपिंग के साथ, टाइमस्टैम्प, ऑर्डर आईडी और बारकोड जो संयोगवश 12 अंकों के होते हैं, अब PII के रूप में लॉग नहीं होते — जबकि वास्तविक आधार संख्याएँ अभी भी होती हैं। यदि कई मान मेल खाते हैं और केवल एक चेकसम पास करता है, तो डिटेक्शन अभी भी सक्रिय होता है: शोर के बीच एक वास्तविक संख्या अभी भी एक लीक है।

चेकसम-गेटेड कार्ड डिटेक्शन के लिए अपने स्वयं के पैटर्न के साथ एक सत्यापनकर्ता को जोड़ें:```php
'custom_patterns'    => ['/\b(?:\d[ -]?){13,19}\b/' => 'Card Number Detected'],
'pattern_validators' => ['Card Number Detected' => 'luhn'],

अलर्ट, एंडपॉइंट, फ़ील्ड नाम और हमलावर IP सभी बने रहते हैं - केवल मान हट जाता है। रिडैक्शन डिटेक्शन के *बाद* चलता है, इसलिए कुछ भी छूटता नहीं है।```php
// config/threat-detection.php
'redact' => [
    'enabled' => env('THREAT_DETECTION_REDACT', true),
    'mask'    => '[REDACTED]',
    'labels'  => ['Aadhaar Number Detected', 'PAN Number Detected', /* ... */],
],

API रूट के लिए भी वही विकल्प `THREAT_DETECTION_API_GUARD` के साथ उपलब्ध हैं।

जब `guard=none` (डिफ़ॉल्ट) होता है, तो पैकेज आपको प्रमाणीकरण कॉन्फ़िगर करने की याद दिलाने के लिए दिन में एक बार चेतावनी लॉग करता है।

गार्ड **fail closed** होता है: एक अपरिचित गार्ड मान (जैसे कि टाइपो) को 403 के साथ अस्वीकार कर दिया जाता है और एक चेतावनी लॉग की जाती है, बजाय चुपचाप पहुँच प्रदान करने के, और `guard=role` तब अस्वीकार करता है (चेतावनी के साथ) जब प्रमाणित उपयोगकर्ता मॉडल में `hasRole()` विधि नहीं होती।

### किसी डिटेक्शन को अक्षम करने के लिए केवल पढ़ने की पहुँच से अधिक की आवश्यकता होती है

किसी खतरे को false positive के रूप में चिह्नित करना और एक exclusion नियम को हटाना दोनों ही सभी के लिए एक डिटेक्शन प्रकार को शांत कर देते हैं, जो लॉग पढ़ने से भिन्न विशेषाधिकार है। उन दो endpoints की जाँच एक अलग गार्ड के विरुद्ध की जाती है:```env
# Options: none, auth, role, ip. Default: role
THREAT_DETECTION_API_WRITE_GUARD=role

**उदाहरण - एक कस्टम एडमिन एंडपॉइंट प्रोब का पता लगाएं:**```php
'/\/my-admin-panel/i' => 'Custom Admin Panel Probe',

- **`level`** थ्रेट स्तर को सीधे सेट करता है, बजाय इसे लेबल में `threat_levels` कीवर्ड्स से प्राप्त करने के।
- **`contexts`** स्कैनिंग को विशिष्ट रिक्वेस्ट सेगमेंट्स तक सीमित करता है — उदाहरण के लिए, एक कार्ड पैटर्न जो केवल बॉडी में ही अर्थ रखता है, हेडर्स में डिजिट रन्स से मैच करना बंद कर देता है।
- **`validator`** एक इनलाइन पोस्ट-मैच चेक का नाम देता है (देखें [Post-Match Validators](#post-match-validators-checksum-aware-false-positive-reduction)); यह `pattern_validators` लेबल मैप पर प्राथमिकता लेता है।

स्ट्रिंग और ऐरे एंट्रीज़ एक ही कॉन्फ़िग में स्वतंत्र रूप से मिलती हैं। विकृत विकल्प **fail open** होते हैं — पैटर्न अभी भी स्कैन करता है, बिना किसी प्रतिबंध के, और एक चेतावनी लॉग की जाती है — इसलिए एक कॉन्फ़िग गलती कभी भी चुपचाप किसी डिटेक्शन को अक्षम या संकीर्ण नहीं कर सकती।

> **नोट:** `/wp-login.php`, `/.env`, `/phpmyadmin` जैसे सामान्य प्रोब पाथ अब [404 Probe Tracking](#404-probe-tracking) फ़ीचर द्वारा स्वचालित रूप से संभाले जाते हैं। आपको उनके लिए कस्टम पैटर्न की आवश्यकता नहीं है।

प्रत्येक पैटर्न के लिए थ्रेट स्तर स्वचालित रूप से लेबल में कीवर्ड्स को `threat_levels` कॉन्फ़िग से मिलाकर निर्धारित किया जाता है:```php
'threat_levels' => [
    'high' => ['XSS', 'SQL Injection', 'SQL DDL', 'SQL DML', 'SQL File', 'SQL Hex', 'RCE', ..., 'Shellshock', 'Spring4Shell', 'PowerShell', 'CRLF', 'Null Byte', 'SSTI', 'Java', 'LDAP', 'XPath', 'PHP assert', ...],
    'medium' => ['Directory Traversal', 'LFI', 'SSRF', 'Sensitive', 'Config', ..., 'Open Redirect', 'LF Injection', 'GraphQL', 'Spring Boot Actuator', ...],
    'low' => ['User-Agent', 'JS Redirect', 'SEO Bot', 'Empty', 'Rate', 'Command-line Downloader', 'DNS Rebinding'],
],

---

## प्रोडक्शन में जाना

यह पैकेज डिज़ाइन से ही निष्क्रिय है - यह कभी भी किसी अनुरोध को ब्लॉक, अस्वीकार या परिवर्तित नहीं करता, और डिटेक्शन मिडलवेयर अपने पूरे बॉडी को `try/catch` में लपेटता है, इसलिए डिटेक्शन विफलता कभी भी आपके ऐप को तोड़ नहीं सकती। यह समझदार डिफ़ॉल्ट्स के साथ आता है और इसे चलाने के लिए किसी बाहरी सेवा की आवश्यकता नहीं है। लाइव जाने से पहले, यह छोटी चेकलिस्ट देखने लायक है:

1. **डैशबोर्ड और API की सुरक्षा करें।** दोनों ज़ीरो-कॉन्फ़िग पहले रन के लिए डिफ़ॉल्ट रूप से `guard = none` पर सेट होते हैं, और असुरक्षित रहने तक दैनिक चेतावनी लॉग करते हैं। प्रोडक्शन से पहले, एक गार्ड सेट करें - `THREAT_DETECTION_DASHBOARD_GUARD` और `THREAT_DETECTION_API_GUARD` (`auth`, `role`, या `ip`)। एक अपरिचित मान या `hasRole()` के बिना यूज़र मॉडल पर `role` गार्ड अब **फेल क्लोज़्ड** (403) होता है, इसलिए एक टाइपो चुपचाप डेटा को उजागर नहीं करेगा। डिटेक्शन को अक्षम करना अलग से `THREAT_DETECTION_API_WRITE_GUARD` द्वारा नियंत्रित होता है, जो डिफ़ॉल्ट रूप से `role` पर सेट है। देखें [डैशबोर्ड और API प्रमाणीकरण](#dashboard-and-api-authentication)।
2. **माइग्रेशन चलाएँ** (`vendor:publish --tag=threat-detection-migrations && migrate`)। दोबारा पब्लिश करना सुरक्षित है - पहले से पब्लिश किए गए माइग्रेशन छोड़ दिए जाते हैं।
3. **एक डिटेक्शन मोड चुनें।** `balanced` (डिफ़ॉल्ट) अधिकांश ऐप्स के लिए उपयुक्त है; कंटेंट-भारी साइटों के लिए `relaxed`, उच्च-सुरक्षा सतहों के लिए `strict` का उपयोग करें। `content_paths`, `safe_fields`, और `min_confidence` के साथ ट्यून करें - देखें [फ़ॉल्स पॉज़िटिव कम करना](#reducing-false-positives)।
4. **क्षेत्रीय PII / कस्टम पैटर्न की समीक्षा करें।** डिफ़ॉल्ट भारत-केंद्रित हैं (Aadhaar, PAN, IFSC) और व्यापक संख्यात्मक पैटर्न (जैसे bank-account) auth रूट्स के बाहर लंबे संख्यात्मक ID से मेल खा सकते हैं। अपने क्षेत्र और ऐप के लिए `custom_patterns` को बदलें या ट्रिम करें, और भारी-कंटेंट रूट्स को `auth_paths` / `content_paths` में जोड़ें।
5. **रिटेंशन चालू करें** यदि आप वॉल्यूम की अपेक्षा करते हैं: `THREAT_DETECTION_RETENTION=true` (शेड्यूलर के माध्यम से ऑटो-पर्ज)। इसके लिए Laravel के शेड्यूलर (`schedule:run`) का cron-चालित होना आवश्यक है।
6. **वैकल्पिक अतिरिक्त सुविधाएँ, सभी डिफ़ॉल्ट रूप से बंद:** Slack अलर्ट (`THREAT_DETECTION_NOTIFICATIONS`), जियो-एनरिचमेंट (`php artisan threat-detection:enrich` - एकमात्र सुविधा जो आउटबाउंड कॉल करती है, मुफ़्त ip-api.com पर), और क्यूड राइट्स (`THREAT_DETECTION_QUEUE` - केवल तभी सक्षम करें जब आप पहले से क्यू वर्कर चलाते हों; अन्यथा राइट्स सिंक्रोनस होते हैं और Redis की आवश्यकता नहीं होती)।

कोर डिटेक्शन और लॉगिंग के लिए किसी Redis, क्यू वर्कर, या आउटबाउंड नेटवर्क कॉल की आवश्यकता नहीं है।

---

## फ़ॉल्स पॉज़िटिव कम करना

यह पैकेज फ़ॉल्स पॉज़िटिव कम करने के लिए कई उपकरण प्रदान करता है। जो आपकी स्थिति के अनुकूल हो उसका उपयोग करें:

### सेफ़ फ़ील्ड्स और सेफ़ पाथ्स

किसी फ़ील्ड को स्कैनिंग से पूरी तरह बाहर करें, या तो हर जगह नाम से (`safe_fields`) या नेस्टेड JSON के लिए डॉट-नोटेशन पाथ से (`safe_paths`)। सबसे सरल दृष्टिकोण, और सबसे कठोर - फ़ील्ड छोड़ दिया जाता है, इसलिए उस पर कोई डिटेक्शन नहीं चलता।

पूर्ण विवरण और उदाहरण: [सेफ़ फ़ील्ड्स](#safe-fields-false-positive-reduction)।

### कंटेंट पाथ सप्रेशन

यदि आपके पास CMS एडिटर, ब्लॉग पोस्ट फ़ॉर्म, या कमेंट सेक्शन हैं जहाँ उपयोगकर्ता रिच कंटेंट सबमिट करते हैं, तो वे पाथ अक्सर फ़ॉल्स पॉज़िटिव ट्रिगर करते हैं (जैसे, `<script>` कोड सैंपल वाला ब्लॉग पोस्ट)। निम्न/मध्यम अलर्ट को दबाने के लिए उन पाथ्स को जोड़ें:```php
// config/threat-detection.php
'content_paths' => [
    'admin/posts/*',
    'admin/pages/*',
    'blog/*/edit',
    'comments',
],

### कॉन्फिडेंस स्कोरिंग

प्रत्येक खतरे को निम्नलिखित के आधार पर कॉन्फिडेंस स्कोर (0-100) प्राप्त होता है:
- एक ही अनुरोध में पैटर्न मिलानों की संख्या
- मिलान किए गए पैटर्न की गंभीरता
- पैटर्न कहाँ पाया गया (क्वेरी स्ट्रिंग > हेडर > बॉडी)
- क्या यूज़र-एजेंट किसी ज्ञात हमला टूल से मेल खाता है
- वर्तमान डिटेक्शन मोड

आपके डिटेक्शन मोड के लिए कॉन्फिडेंस थ्रेशोल्ड से नीचे के खतरे लॉग नहीं किए जाते (देखें [डिटेक्शन मोड](#detection-modes))।

---

## पता लगाए गए हमले के प्रकार

| श्रेणी | उदाहरण |
|----------|---------|
| **SQL इंजेक्शन** | UNION, boolean, time-based, CHAR encoding, DDL (DROP/ALTER/CREATE), DML (INSERT/UPDATE/DELETE), file ops (INTO OUTFILE, LOAD_FILE), ORDER BY enumeration, hex strings, UNHEX |
| **NoSQL इंजेक्शन** | MongoDB $ne, $gt, $regex, $where ऑपरेटर |
| **XSS** | Script टैग, SVG इवेंट हैंडलर (`<svg onload=`), HTML इवेंट हैंडलर (`<body onload=`, `<img onerror=`), CSS एक्सप्रेशन, JavaScript URI, DOM मैनिपुलेशन |
| **कोड एक्ज़ीक्यूशन** | RCE शेल फंक्शन, PHP डीसेरियलाइज़ेशन, Java डीसेरियलाइज़ेशन (base64 + hex magic bytes), टेम्पलेट इंजेक्शन (Blade, JSP, ASP, Jinja2, Velocity), eval(), base64 decode, PHP assert(), create_function(), preg_replace /e |
| **SSTI** | गणितीय प्रोब (`{{7*7}}`), Jinja2 import/config, Velocity टेम्पलेट, Expression Language |
| **कमांड इंजेक्शन** | Linux (शेल फंक्शन, कमांड चेन, curl, wget, nc), Windows (cmd.exe, PowerShell, wscript, cscript, net user) |
| **फ़ाइल एक्सेस** | डायरेक्टरी ट्रैवर्सल, LFI/RFI प्रोटोकॉल, संवेदनशील फ़ाइल प्रोब (.env, .git, composer.json) |
| **SSRF** | Localhost (127.0.0.1, 0.0.0.0, ::1), AWS/GCP मेटाडेटा, प्राइवेट IP, hex/decimal एन्कोडेड localhost, DNS रीबाइंडिंग (xip.io, nip.io, sslip.io) |
| **LDAP इंजेक्शन** | LDAP फ़िल्टर मैनिपुलेशन, OR इंजेक्शन |
| **XPath इंजेक्शन** | एट्रिब्यूट सेलेक्टर, XPath फंक्शन (contains, substring) |
| **CRLF / हेडर इंजेक्शन** | URL-एन्कोडेड CRLF (`%0d%0a`), LF इंजेक्शन, null byte इंजेक्शन |
| **प्रोटोकॉल हमले** | HTTP रिक्वेस्ट स्मगलिंग (CL+TE), SSI इंजेक्शन |
| **CVE एक्सप्लॉइट** | Shellshock (CVE-2014-6271), Spring4Shell (CVE-2022-22965), PHPUnit RCE (CVE-2017-9841), Drupalgeddon, Log4Shell |
| **प्रोब ट्रैकिंग** | WordPress (`/wp-admin`, `/wp-login.php`), कॉन्फ़िग फ़ाइलें (`/.env`, `/.git`), डेटाबेस टूल (`/phpmyadmin`), टेक्नोलॉजी प्रोब (`.asp`, `.jsp`), Spring actuator, Swagger/API डॉक्स - 50+ पाथ |
| **स्कैनर** | SQLMap, Nikto, Nmap, Burp Suite, FeroxBuster, FFUF, XSStrike, Dalfox, Netsparker, Qualys, Nuclei, और 20+ अन्य (कुल 53) |
| **AI स्क्रैपर** | GPTBot, ClaudeBot, ChatGPT, ByteSpider, Cohere, Common Crawl |
| **हेडलेस ब्राउज़र** | HeadlessChrome, PhantomJS, Selenium, Puppeteer, Playwright |
| **बॉट** | Python स्क्रिप्ट, Go HTTP क्लाइंट, cURL, wget, AhrefsBot, SEMRushBot, खाली यूज़र एजेंट |
| **प्रमाणीकरण** | ब्रूट फोर्स डिटेक्शन, टोकन लीक, पासवर्ड एक्सपोज़र, सेशन ID एक्सपोज़र |
| **DDoS** | रेट-आधारित अत्यधिक अनुरोध डिटेक्शन |
| **एवेज़न** | SQL कमेंट इंसर्शन, डबल URL एन्कोडिंग, HTML एंटिटी एन्कोडिंग, Unicode एस्केप, IIS Unicode, hex एस्केप |
| **अन्य** | GraphQL इंट्रोस्पेक्शन, प्रोटोटाइप पॉल्यूशन, ओपन रीडायरेक्ट, XXE, वेब शेल, क्रिप्टो माइनिंग, PII डिटेक्शन |

---

## टेस्ट सूट चलाना```bash
composer test