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

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

> एक प्रोडक्शन ऐप से निकाला गया और वास्तविक ट्रैफ़िक पर युद्ध-परीक्षित। 335 टेस्ट, 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 बनाम edge

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

| | **यह पैकेज** (app IDS) | **WAF** (mod_security, Cloudflare WAF) | **Edge / CDN** (Cloudflare) |
|---|:---:|:---:|:---:|
| दुर्भावनापूर्ण अनुरोधों को ब्लॉक करता है | ❌ केवल लॉग करता है | ✅ | ✅ |
| पूर्ण app संदर्भ (सटीक route, decoded payload, authenticated user) | ✅ | ⚠️ आंशिक | ❌ |
| आपके DB में built-in dashboard + threat log | ✅ | ⚠️ भिन्न होता है | ⚠️ केवल edge |
| App-विशिष्ट detections (जैसे Aadhaar / PAN / IFSC PII) | ✅ custom patterns | ❌ | ❌ |
| ऑफ़लाइन काम करता है / कोई बाहरी सेवा नहीं | ✅ | ⚠️ निर्भर करता है | ❌ |
| आपके app तक पहुँचने से पहले traffic रोकता है | ❌ | ✅ edge | ✅ |
| Setup | एक `composer require` | medium–high | low–medium |
| लागत | free, MIT | भिन्न | free tier + paid |

**संक्षिप्त संस्करण:** एक edge/WAF आपके दरवाज़े का ताला है; यह *अंदर* का security camera है,
जिसमें app संदर्भ होता है जो आपको बताता है कि किस route पर, किसके द्वारा, और कितनी बार
क्या प्रयास किया जा रहा है। इसका उपयोग वास्तविक निर्णय लेने के लिए करें — fail2ban bans, rate limits,
geo-blocking — उस डेटा के साथ जो आपकी edge परत कभी नहीं देखती।

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

- **WAF नहीं।** यह कभी किसी अनुरोध को ब्लॉक, फ़िल्टर या संशोधित नहीं करता। प्रवर्तन के लिए Cloudflare,
  mod_security, या एक वास्तविक WAF का उपयोग करें। (कोई edge परत नहीं है जिसे सौंपा जा सके?
  [operator-side helpers](#acting-on-the-data-operator-side-blocking) पैकेज के निर्णयों को
  उजागर करते हैं ताकि आप अपना खुद का पाँच-पंक्ति वाला blocking middleware लिख सकें —
  प्रवर्तन कोड आपका ही रहता है, पैकेज का नहीं।)
- **सुरक्षित कोडिंग का विकल्प नहीं।** Parameterized queries, input validation, और
  output escaping आपकी वास्तविक सुरक्षा हैं। यह पैकेज मानता है कि आपका कोड पहले से
  सुरक्षित है और आपको *दृश्यता* देता है, सुरक्षा नहीं।
- **Edge सेवा नहीं।** यदि आप Cloudflare को सामने रख सकते हैं, तो रखें — फिर application-level
  विवरण के लिए इसे जोड़ें जो edge सेवाएँ नहीं देख सकतीं।

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

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

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

पैकेज खुफिया जानकारी प्रदान करता है; आप अस्वीकृति प्रदान करते हैं। यह विभाजन
जानबूझकर है — आपके app में रहने वाला प्रवर्तन कोड वह कोड है जिसे आप पढ़,
परीक्षण और बंद कर सकते हैं, और इसका मतलब है कि एक detection bug कभी आपकी
साइट को नीचे नहीं ला सकता।

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

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

| पैकेज | यह क्या करता है | ब्लॉक करता है? | इसका उपयोग कब करें |
|---|---|:---:|---|
| **यह पैकेज** | 150+ patterns के विरुद्ध हर अनुरोध को स्कैन करता है, पूर्ण app संदर्भ के साथ लॉग करता है | ❌ | आप *देखना* चाहते हैं कि आपके app पर क्या प्रयास किया जा रहा है |
| `spatie/laravel-honeypot` | छिपा हुआ फ़ॉर्म फ़ील्ड जो spam bots को पकड़ता है | ✅ केवल फ़ॉर्म | आपके पास सार्वजनिक फ़ॉर्म हैं जिन पर spam हो रहा है |
| `graham-campbell/security` | इनपुट से XSS-जैसे markup हटाता है | ✅ mutate करता है | आप naive input sanitising चाहते हैं |
| `spatie/laravel-csp` | Content-Security-Policy headers भेजता है | ✅ browser | आप सीमित करना चाहते हैं कि browser क्या लोड करता है |
| `laravel/fortify` + rate limits | Auth throttling और lockout | ✅ | आपको login पर brute-force सुरक्षा चाहिए |
| Cloudflare / mod_security | Edge WAF, आपके app से पहले ब्लॉक करता है | ✅ | आप चाहते हैं कि traffic आने से पहले रोका जाए |

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

---

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

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

---

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

1. एक middleware हर आने वाले HTTP अनुरोध को स्कैन करता है
2. अनुरोध को 158 regex patterns के विरुद्ध जाँचा जाता है जिसमें SQL injection, XSS, RCE, file traversal, SSRF, LDAP, XPath, SSTI, और अधिक शामिल हैं
3. यदि कोई threat pattern मेल खाता है, तो IP, URL, threat type, severity level, और confidence score के साथ आपकी `threat_logs` database तालिका में एक रिकॉर्ड लिखा जाता है
4. वैकल्पिक रूप से, उच्च-गंभीरता वाले threats के लिए एक Slack alert भेजा जाता है
5. अनुरोध सामान्य रूप से आगे बढ़ता है - **कुछ भी ब्लॉक नहीं किया जाता**

Detection के लिए कोई इंटरनेट कनेक्शन आवश्यक नहीं है।

---

## त्वरित आरंभ

### 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')

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

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

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

**विकल्प A - आर्टिसन कमांड (सबसे तेज़):**```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" यूज़र-एजेंट पहचान (कम गंभीरता) भी लॉग होती है। यह अपेक्षित है - पैकेज स्वचालित टूल्स का पता लगाता है। |
| पैकेज कभी भी अनुरोधों को ब्लॉक नहीं करता | आपका ऐप सामान्य रूप से कार्य करता रहता है। पहचान निष्क्रिय है। |
| Slack सेटअप की आवश्यकता नहीं | सूचनाएं डिफ़ॉल्ट रूप से बंद हैं। |
| इंटरनेट कनेक्शन की आवश्यकता नहीं | मुख्य पहचान 100% स्थानीय है। केवल वैकल्पिक `threat-detection:enrich` कमांड भू-डेटा के लिए बाहरी API को कॉल करता है। |

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

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

इसमें क्या शामिल है: इस वातावरण के लिए सक्षम डिटेक्शन; लेखक (writer) को ज़रूरत का हर कॉलम (एक भी गायब कॉलम **हर** खतरे को खारिज कर देता है); डैशबोर्ड/API कॉलम; एक्सक्लूज़न-नियमों की तालिका; क्या मिडलवेयर वास्तव में किसी रूट या ग्रुप से जुड़ा है; इस संस्करण से पहले की प्रकाशित कॉन्फ़िग; बिल्ट-इन पैटर्न को ओवरराइड करने वाले कस्टम पैटर्न; एक कैश ड्राइवर जो DDoS गिनती नहीं कर सकता; और बिना प्रमाणीकरण के खुला छोड़ा गया डैशबोर्ड या API।

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

अगर डॉक्टर पास हो गया, तो इंस्टॉल ठीक है और समस्या टेस्ट रिक्वेस्ट में ही है। तीन चीज़ें जिन्हें यह आपके लिए जाँच नहीं सकता:

| जाँच | कैसे सत्यापित करें |
|-------|---------------|
| IP व्हाइटलिस्टेड नहीं है | अगर आपने `.env` में `THREAT_DETECTION_WHITELISTED_IPS` जोड़ा है, तो टेस्टिंग के दौरान उसे हटा दें |
| मौजूदा रूट का उपयोग किया | टेस्ट URL एक वास्तविक रूट से मेल खाना चाहिए (जैसे, `/`)। 404 का मतलब है कि मिडलवेयर कभी नहीं चला |
| डिडुप कैश | समान IP + समान अटैक प्रकार 5 मिनट के लिए कैश होता है - एक अलग अटैक प्रकार आज़माएँ |

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

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

नीचे [API प्रमाणीकरण](#api-authentication) देखें।

**"डैशबोर्ड 404 दिखाता है"**

डैशबोर्ड डिफ़ॉल्ट रूप से अक्षम है। `.env` में `THREAT_DETECTION_DASHBOARD=true` जोड़ें और रूट कैश साफ़ करें:```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 के शेड्यूलर को चलाना आवश्यक है (`php artisan schedule:run`)। यह `threat-detection:purge` के माध्यम से प्रतिदिन 02:00 बजे चलता है।

### ThreatDetected इवेंट

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

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

इवेंट `$ipAddress`, `$requestCount`, `$threshold`, और `$windowSeconds` लेकर आता है। इसे प्रति IP प्रति डीडुप विंडो में एक बार थ्रॉटल किया जाता है (लॉग रो के समान थ्रॉटल), ताकि फ्लड आपके लिसनर्स को डुबो न सके। इसका उपयोग अलर्टिंग के लिए या किसी बाहरी बैन स्टोर को फीड करने के लिए करें; थ्रेशोल्ड से अधिक क्लाइंट्स को *अस्वीकार* करने के लिए, अपने स्वयं के मिडलवेयर से `ThreatDetection::isDdosThresholdExceeded($ip)` का उपयोग करें — [डेटा पर कार्रवाई](#acting-on-the-data-operator-side-blocking) देखें।

---

## स्लैक नोटिफिकेशन

स्लैक अलर्ट डिफ़ॉल्ट रूप से अक्षम हैं। सक्षम करने के लिए:```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="Threat Detection Dashboard — stats, 7-day timeline, live threat log, top offending IPs, and threats by country" 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                                         |
+-------------------------------------------------------------------------+

`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);
    }
}

सहायक:

| सहायक | रिटर्न | आधार |
|---|---|---|
| `ThreatDetection::isBlocklisted($ip)` | `bool` | `blocklisted_ips` कॉन्फ़िग (CIDR `IpUtils` के माध्यम से; व्हाइटलिस्ट जीतती है) |
| `ThreatDetection::isWhitelisted($ip)` | `bool` | `whitelisted_ips` कॉन्फ़िग |
| `ThreatDetection::ddosRequestCount($ip)` | `int` | फ्लड काउंटर जिसे डिटेक्शन मिडलवेयर बनाए रखता है |
| `ThreatDetection::isDdosThresholdExceeded($ip)` | `bool` | वह काउंटर बनाम `ddos.threshold` |

नोट:

- **डेनीलिस्ट स्थिर और ऑपरेटर-अनुरक्षित है।** पैकेज में कुछ भी इसमें कभी नहीं जोड़ता —
  यह वही निर्णय निष्पादित करता है जो एक fail2ban जेल करेगा ("मैंने डैशबोर्ड पढ़ा; यह /24
  शत्रुतापूर्ण है"), बस इन-ऐप।
- DDoS काउंटर केवल उन अनुरोधों को गिनता है जो डिटेक्शन तक पहुँचे (`skip_paths`, व्हाइटलिस्टेड
  IPs, और अक्षम वातावरण कभी नहीं गिने जाते), और उन कैश ड्राइवरों पर 0 पर रहता है जहाँ
  DDoS डिटेक्शन अक्षम है (`file`, `database`, `null`)।
- जब कोई क्लाइंट थ्रेशोल्ड पार करता है, तो एक [`DdosThresholdExceeded` इवेंट](#ddosthresholdexceeded-event)
  भी डिस्पैच होता है — अलर्टिंग या बाहरी बैन सूची को फीड करने के लिए उपयोगी। लिसनर से `abort()`
  न करें, हालाँकि: लिसनर डिटेक्शन मिडलवेयर के fail-open
  `try/catch` के अंदर चलते हैं, इसलिए अस्वीकृति आपके अपने मिडलवेयर में ऊपर बताए अनुसार होनी चाहिए।

---

## 404 प्रोब ट्रैकिंग

पैकेज टोही प्रोब का पता लगाता है - बॉट जो आपकी गैर-WordPress, गैर-phpMyAdmin साइट पर `/wp-admin`, `/.env`, या `/phpmyadmin` जैसे ज्ञात कमजोर पथों को हिट करते हैं। इनमें कोई दुर्भावनापूर्ण पेलोड नहीं होता; पथ स्वयं ही संकेत है।

पेलोड-आधारित डिटेक्शन से अलग, `[probe]` प्रकार टैग के साथ लॉग किया जाता है। यदि कोई प्रोब अनुरोध में दुर्भावनापूर्ण पेलोड भी होता है, तो दोनों स्वतंत्र रूप से लॉग होते हैं।

50+ प्रोब पथों के साथ डिफ़ॉल्ट रूप से सक्षम। `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...
    ],
],

यहाँ सूचीबद्ध फ़ील्ड्स को क्वेरी पैराम्स और रिक्वेस्ट बॉडी से हटा दिया जाता है - दोनों फ़ॉर्म-एन्कोडेड और JSON (`application/json`) - डिटेक्शन चलने से पहले। उसी रिक्वेस्ट पर अन्य फ़ील्ड्स अभी भी पूरी तरह से स्कैन की जाती हैं।

### सुरक्षित पथ (path-aware, नेस्टेड JSON APIs के लिए)

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

उपलब्ध वैलिडेटर:

| Validator  | Checksum | Typical use |
|------------|----------|-------------|
| `verhoeff` | Verhoeff | आधार नंबर |
| `luhn`     | Luhn     | क्रेडिट/डेबिट कार्ड नंबर |

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

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

अलर्ट, एंडपॉइंट, फ़ील्ड नाम और हमला करने वाला IP सभी बचे रहते हैं - केवल मान (value) हटाया जाता है। रिडैक्शन *डिटेक्शन के बाद* चलता है, इसलिए कुछ भी छूटता नहीं है।```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` (डिफ़ॉल्ट) होता है, तो पैकेज दिन में एक बार एक चेतावनी लॉग करता है ताकि आपको प्रमाणीकरण कॉन्फ़िगर करने की याद दिला सके।

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

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

किसी खतरे को गलत सकारात्मक के रूप में चिह्नित करना और किसी बहिष्करण नियम को हटाना, दोनों ही सभी के लिए एक डिटेक्शन प्रकार को शांत कर देते हैं, जो लॉग पढ़ने से भिन्न विशेषाधिकार है। उन दो एंडपॉइंट्स की जाँच एक अलग गार्ड के विरुद्ध की जाती है:```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-checksum-aware-false-positive-reduction)); यह `pattern_validators` लेबल मैप पर प्राथमिकता लेता है।

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

> **नोट:** सामान्य प्रोब पथ जैसे `/wp-login.php`, `/.env`, `/phpmyadmin` अब [404 प्रोब ट्रैकिंग](#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 / कस्टम पैटर्न की समीक्षा करें।** डिफ़ॉल्ट भारत-केंद्रित हैं (आधार, PAN, IFSC) और व्यापक संख्यात्मक पैटर्न (जैसे बैंक-खाता) auth रूट्स के बाहर लंबे संख्यात्मक ID से मेल खा सकते हैं। अपने क्षेत्र और ऐप के लिए `custom_patterns` बदलें या ट्रिम करें, और भारी-कंटेंट रूट्स को `auth_paths` / `content_paths` में जोड़ें।
5. **यदि आप वॉल्यूम की उम्मीद करते हैं तो रिटेंशन चालू करें:** `THREAT_DETECTION_RETENTION=true` (शेड्यूलर के माध्यम से स्वतः-शुद्धि)। इसके लिए Laravel के शेड्यूलर (`schedule:run`) को क्रॉन-संचालित होना आवश्यक है।
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, बूलियन, टाइम-बेस्ड, CHAR एन्कोडिंग, DDL (DROP/ALTER/CREATE), DML (INSERT/UPDATE/DELETE), फ़ाइल ऑप्स (INTO OUTFILE, LOAD_FILE), ORDER BY एन्यूमरेशन, हेक्स स्ट्रिंग्स, UNHEX |
| **NoSQL इंजेक्शन** | MongoDB $ne, $gt, $regex, $where ऑपरेटर |
| **XSS** | स्क्रिप्ट टैग, SVG इवेंट हैंडलर (`<svg onload=`), HTML इवेंट हैंडलर (`<body onload=`, `<img onerror=`), CSS एक्सप्रेशन, JavaScript URI, DOM मैनिपुलेशन |
| **कोड एक्ज़ीक्यूशन** | RCE शेल फ़ंक्शन, PHP डीसीरियलाइज़ेशन, Java डीसीरियलाइज़ेशन (base64 + hex मैजिक बाइट्स), टेम्पलेट इंजेक्शन (Blade, JSP, ASP, Jinja2, Velocity), eval(), base64 डिकोड, PHP assert(), create_function(), preg_replace /e |
| **SSTI** | गणितीय प्रोब (`{{7*7}}`), Jinja2 import/config, Velocity टेम्पलेट, एक्सप्रेशन लैंग्वेज |
| **कमांड इंजेक्शन** | Linux (शेल फ़ंक्शन, कमांड चेन, curl, wget, nc), Windows (cmd.exe, PowerShell, wscript, cscript, net user) |
| **फ़ाइल एक्सेस** | डायरेक्टरी ट्रैवर्सल, LFI/RFI प्रोटोकॉल, संवेदनशील फ़ाइल प्रोब (.env, .git, composer.json) |
| **SSRF** | लोकलहोस्ट (127.0.0.1, 0.0.0.0, ::1), AWS/GCP मेटाडेटा, प्राइवेट IP, हेक्स/डेसिमल एन्कोडेड लोकलहोस्ट, DNS रीबाइंडिंग (xip.io, nip.io, sslip.io) |
| **LDAP इंजेक्शन** | LDAP फ़िल्टर मैनिपुलेशन, OR इंजेक्शन |
| **XPath इंजेक्शन** | एट्रिब्यूट सेलेक्टर, XPath फ़ंक्शन (contains, substring) |
| **CRLF / हेडर इंजेक्शन** | URL-एन्कोडेड CRLF (`%0d%0a`), LF इंजेक्शन, नल बाइट इंजेक्शन |
| **प्रोटोकॉल अटैक** | 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 एंटिटी एन्कोडिंग, यूनिकोड एस्केप, IIS यूनिकोड, हेक्स एस्केप |
| **अन्य** | GraphQL इंट्रोस्पेक्शन, प्रोटोटाइप पोल्यूशन, ओपन रीडायरेक्ट, XXE, वेब शेल, क्रिप्टो माइनिंग, PII डिटेक्शन |

---

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