discover

Custom bash scripts used to automate various penetration testing tasks including recon, scanning, 
enumeration, and malicious payload creation using Metasploit. For use with Kali Linux or Ubuntu.

* **Update** (मुख्य मेनू विकल्प 16) चुनें ताकि ऑपरेटिंग सिस्टम अपडेट हो और निर्भरताएँ (`ffuf`, `feroxbuster`, `jq`, आदि) स्थापित हों।
* Dev स्कैनर्स `dev/` के अंतर्गत हैं और मुख्य मेनू विकल्प **15. Dev** से भी पहुँचा जा सकता है।
* कुछ विकल्पों को चलाने के लिए रूट क्रेडेंशियल्स की आवश्यकता होगी।

### मुख्य मेनू```
RECON
1.  Domain
2.  Person

SCANNING
3.  Generate target list
4.  CIDR
5.  List
6.  IP, range, or URL
7.  Rerun Nmap scripts and MSF aux

WEB
8.  Insecure direct object reference
9.  Open multiple tabs in Firefox
10. Nikto
11. SSL

MISC
12. Parse XML
13. Generate a malicious payload
14. Start a Metasploit listener
15. Dev
16. Update
17. Exit

INPUT:```
dev/
├── api-scanner.sh
├── cloud-scanner.sh
├── container-scanner.sh
├── oauth-jwt-scanner.sh
├── open-redirect.sh
├── sensitive-scanner.sh
├── waf-detect.sh
├── web-api-scanner.sh
├── data/
│   ├── api-paths.txt
│   ├── openredirect-payloads.txt
│   ├── sensitive-denylist.txt
│   ├── sensitive-patterns.tsv
│   ├── sensitive-skip-paths.txt
│   ├── sensitive-web-paths-quick.txt
│   ├── sensitive-web-paths-full.txt
│   ├── waf-aliases.tsv
│   ├── waf-labels.tsv
│   ├── waf-signatures.tsv
│   ├── web-api-phases.tsv
│   ├── web-api-tech-signatures.tsv
│   └── swagger-paths.txt
└── lib/
    ├── api-scanner/
    │   └── common.sh
    ├── cloud-scanner/
    │   ├── common.sh
    │   ├── aws.sh
    │   ├── azure.sh
    │   └── gcp.sh
    ├── container-scanner/
    │   ├── common.sh
    │   ├── docker.sh
    │   └── k8s.sh
    ├── oauth-jwt-scanner/
    │   ├── common.sh
    │   ├── oauth.sh
    │   └── jwt.sh
    ├── open-redirect-scanner/
    │   ├── common.sh
    │   └── engine.py
    ├── sensitive-scanner/
    │   ├── common.sh
    │   ├── files.sh
    │   ├── web.sh
    │   ├── filescan.py
    │   ├── engine.py
    │   ├── fixtures/
    │   └── run-tests.sh
    ├── waf-detect/
    │   ├── common.sh
    │   ├── probe.sh
    │   ├── fixtures/
    │   └── run-tests.sh
    └── web-api-scanner/
        ├── common.sh
        ├── phases.sh
        ├── waf.sh
        ├── targets.sh
        ├── msf.sh
        ├── msf_parse.py
        ├── probe.sh
        ├── fixtures/
        └── run-tests.sh

नोट: Passive और Active को root के रूप में नहीं चलाया जा सकता।

PASSIVE RECON

Amass, ARIN, DNSRecon, dnstwist, Metasploit, subfinder, sublist3r, theHarvester, Whois और कई वेबसाइटों का उपयोग करता है।

* theHarvester के साथ अधिकतम परिणामों के लिए सभी मुफ्त API कुंजियाँ प्राप्त करें।
* API कुंजियों को $HOME/.theHarvester/api-keys.yaml में जोड़ें।
* Passive $HOME/data/<domain>/ पर एक HTML रिपोर्ट बनाता है।
* मौजूदा रिपोर्ट में पंजीकृत डोमेन को pages/registered-domains.htm में अपडेट करें।
* Active httpx, whatweb और gowitness का उपयोग करता है; वैकल्पिक NVD API कुंजी Active रिपोर्ट पर CVSS संवर्धन को गति देती है (नीचे **NVD API key** देखें)।

#### नाम आयात करें (`import-names.sh`)

मैन्युअल शोध (LinkedIn, कंपनी साइट्स, फोन निर्देशिकाएं, आदि) से संपर्क जोड़ने या समृद्ध करने के लिए पैसिव स्कैन के बाद चलाएं।```
Enter the location of your previous passive scan:
/home/user/data/example.com

Enter manual contacts file (or press Enter for default):

समर्थित आयात:

* `firefox` — अपने Firefox प्रोफ़ाइल से `pinia/scans` खींचें (मुफ़्त Pentest-Tools स्कैन)
* Firefox `pinia/scans` निर्यात (`pinia-scans.json`)
* Pentest-Tools JSON (`pentest-tools-<domain>.json`)
* Pentest-Tools टेक्स्ट निर्यात (`pentest-tools.txt`)
* टैब-पृथक होस्ट/IP पंक्तियाँ

* मैन्युअल प्रविष्टियों के लिए `$HOME/data/<domain>/tools/subdomains-import.tsv` संपादित करें
* प्रारूप: सबडोमेन, IP (टैब-पृथक; IP वैकल्पिक)
* बिना IP वाले होस्ट आयात के दौरान `dig` से हल किए जाते हैं
* जब भी आप पंक्तियाँ जोड़ते हैं या कोई नया Pentest-Tools स्कैन चलाते हैं, तो Import subdomains को पुनः चलाएँ

Import subdomains मौजूदा `tools/subdomains` के साथ विलय करता है, `old/subdomain-categories.tsv` से श्रेणियाँ निर्दिष्ट करता है, निजी IP को `tools/private-subs` में विभाजित करता है, और केवल Subdomain, Category, और IP कॉलम के साथ `pages/subdomains.htm` को ताज़ा करता है। उसके बाद Photo, Status, Web Server, और Technologies को आबाद करने के लिए **Active** चलाएँ।

#### Active (`active.sh`)

सक्रिय रीकॉन

निष्क्रिय स्कैन (और वैकल्पिक रूप से Import subdomains) के बाद चलाएँ जब आप जाँचना चाहते हैं कि कौन से सार्वजनिक होस्ट HTTP/HTTPS पर प्रतिक्रिया देते हैं, तकनीकों की फ़िंगरप्रिंट लें, और स्क्रीनशॉट कैप्चर करें।```
Enter the location of your previous passive scan:
/home/user/data/example.com

**एक मुफ्त API कुंजी प्राप्त करें**

1. कुंजी का अनुरोध करें: https://nvd.nist.gov/developers/request-an-api-key
2. NIST द्वारा भेजे गए ईमेल की पुष्टि करें
3. Discover को कुंजी प्रदान करें (शेल एक्सपोर्ट और/या निजी `.env` — नीचे देखें)

**Discover कुंजी कैसे ढूंढता है**

प्राथमिकता क्रम (सूची में ऊपर के गैर-रिक्त मान हमेशा जीतते हैं):

1. शेल वातावरण — `export NVD_API_KEY=...`
2. Discover इंस्टॉल में निजी `.env` — `$DISCOVER/.env`
3. आपके होम कॉन्फ़िग में निजी `.env` — `~/.discover/.env`

उदाहरण `.env` पंक्ति (उद्धरण आवश्यक नहीं हैं):```
NVD_API_KEY=your-key-here

(उदाहरण के लिए `~/discover/resource/known_exploited_vulnerabilities.json`)

स्रोत: https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json  
कैटलॉग: https://www.cisa.gov/known-exploited-vulnerabilities-catalog

यदि डाउनलोड विफल होता है, तो कोई भी पिछला स्थानीय कैटलॉग यथावत रहता है। फ़ाइल gitignored है (अपडेट द्वारा ताज़ा की जाती है, कमिट नहीं की जाती)।

सक्रिय **Software versions** तालिका पर, **Top CVE** CISA KEV मिलान को प्राथमिकता देता है जब उत्पाद के कोई भी NVD CVE KEV कैटलॉग में दिखाई देते हैं (KEV में सबसे अधिक CVSS जीतता है)। अन्यथा Top CVE सबसे अधिक CVSS वाला NVD परिणाम होता है। KEV चयन लिंक किए गए CVE ID के आगे एक नारंगी **KEV** बैज दिखाते हैं।

#### SEC नेतृत्व (Names पृष्ठ)

अमेरिकी सार्वजनिक कंपनियों के लिए, Discover नाम विलय चरण से पहले SEC EDGAR से अधिकारियों और निदेशकों को खींचता है:

1. **DEF 14A** — पूर्ण शीर्षकों के लिए प्रॉक्सी स्टेटमेंट गद्य और बोर्ड तालिकाएँ
2. **Form 4** — अधिकारियों और निदेशकों को पूरक करने के लिए हालिया इनसाइडर फाइलिंग

* परिणाम zsec-people में लिखे जाते हैं और मौजूदा Name, Title, Phone कॉलम के साथ tools/names में मर्ज किए जाते हैं (phone खाली छोड़ा गया)।
* SEC फाइलिंग कार्य ईमेल या प्रति-व्यक्ति फ़ोन नंबर प्रदान नहीं करती हैं।
* Names पृष्ठ लेआउट अपरिवर्तित है — कोई ईमेल कॉलम नहीं जोड़ा गया।
* मैन्युअल ओवरराइड: tools/sec-people-manual.tsv (टैब-सेपरेटेड: Name, Title, Phone).

#### कंपनी मुख्यालय (Summary पृष्ठ)

पैसिव रिकॉन के दौरान, Discover कंपनी के नाम और डोमेन के बीच pages/summary.htm पर पता और फ़ोन ब्लॉक भरने का प्रयास करता है।

1. **SEC EDGAR 10-K** — अमेरिकी सार्वजनिक कंपनियों के लिए, नवीनतम 10-K से प्रमुख कार्यकारी कार्यालय फ़ील्ड पढ़ता है (इनलाइन XBRL `dei:` टैग)।
2. **Website footer** — यदि SEC से कोई मिलान नहीं, तो पतों/फ़ोन पैटर्न के लिए कैश्ड होमपेज फुटर (और संपर्क पृष्ठ) स्कैन करता है।
3. **मैन्युअल ओवरराइड** — जब डिस्कवरी गलत या अवरुद्ध हो, तो tools/company-manual.tsv में प्रविष्टियाँ जोड़ें।

परिणाम tools/company.json में लिखे जाते हैं और pages/summary.htm में इंजेक्ट किए जाते हैं।

#### सोशल मीडिया (Summary पृष्ठ)

पैसिव रिकॉन के दौरान, Discover कंपनी होमपेज प्राप्त करता है और आधिकारिक सोशल प्रोफ़ाइल लिंक (facebook, Instagram, LinkedIn, X, YouTube) निकालता है। फिर यह प्रत्येक प्रोफ़ाइल से फॉलोअर काउंट खींचने का प्रयास करता है।

* परिणाम tools/social.tsv में लिखे जाते हैं और pages/summary.htm में इंजेक्ट किए जाते हैं।
* यदि कोई प्लेटफ़ॉर्म स्क्रैपिंग को ब्लॉक करता है, तो फॉलोअर काउंट **Blocked** दिखाता है।
* यदि होमपेज बॉट-ब्लॉक है, तो स्कैन से पहले या बाद में tools/social-manual.tsv में URL जोड़ें (टैब-सेपरेटेड: Platform, URL).

### व्यक्ति```
RECON

First name:
Last name:

* लक्ष्य सूची बनाने के लिए विभिन्न उपकरणों का उपयोग करें, जिनमें शामिल हैं Angry IP Scanner, arp-scan, netdiscover, और Nmap pingsweep.

### CIDR, List, IP, Range, or URL```
Type of scan:

1.  External
2.  Internal
3.  Previous menu

### फ़ायरफ़ॉक्स में एकाधिक टैब खोलें```
Open multiple tabs in Firefox with:

1.  List
2.  Files in a directory
3.  Directories in robots.txt
4.  Previous menu
```
उदाहरण:
* एक सूची जिसमें कई IP और/या URL शामिल हों।
* आपने Nikto के साथ कई वेबसाइटों की स्कैनिंग पूरी कर ली है और एक निर्देशिका में स्थित प्रत्येक htm रिपोर्ट को खोलना चाहते हैं।
* किसी डोमेन की robot.txt फ़ाइल डाउनलोड करने के लिए wget का उपयोग करें, फिर सभी निर्देशिकाओं को खोलें।

### Nikto```
This option cannot be ran as root.

Run multiple instances of Nikto in parallel.

1.  List of IPs
2.  List of IP:port
3.  Previous menu
```
### SSL```
Check for SSL certificate issues.

List of IP:port.


Enter the location of your file:
```
* sslscan, sslyze और Nmap का उपयोग SSL/TLS प्रमाणपत्र समस्याओं की जांच के लिए करता है।

## विविध
### XML पार्स करें```
Parse XML to CSV.

1.  Burp (Base64)
2.  Nessus (.nessus)
3.  Nexpose (XML 2.0)
4.  Nmap
5.  Qualys
6.  Previous menu
```
### एक दुर्भावनापूर्ण पेलोड उत्पन्न करें```
Malicious Payloads

1.   android/meterpreter/reverse_tcp         (.apk)
2.   cmd/windows/reverse_powershell          (.bat)
3.   java/jsp_shell_reverse_tcp (Linux)      (.jsp)
4.   java/jsp_shell_reverse_tcp (Windows)    (.jsp)
5.   java/shell_reverse_tcp                  (.war)
6.   linux/x64/meterpreter_reverse_https     (.elf)
7.   linux/x64/meterpreter_reverse_tcp       (.elf)
8.   linux/x64/shell/reverse_tcp             (.elf)
9.   osx/x64/meterpreter_reverse_https       (.macho)
10.  osx/x64/meterpreter_reverse_tcp         (.macho)
11.  php/meterpreter_reverse_tcp             (.php)
12.  python/meterpreter_reverse_https        (.py)
13.  python/meterpreter_reverse_tcp          (.py)
14.  windows/x64/meterpreter_reverse_https   (multi)
15.  windows/x64/meterpreter_reverse_tcp     (multi)
16.  Previous menu
```
### मेटास्प्लॉइट लिसनर शुरू करें```
Metasploit Listeners

1.   android/meterpreter/reverse_tcp
2.   cmd/windows/reverse_powershell
3.   java/jsp_shell_reverse_tcp
4.   linux/x64/meterpreter_reverse_https
5.   linux/x64/meterpreter_reverse_tcp
6.   linux/x64/shell/reverse_tcp
7.   osx/x64/meterpreter_reverse_https
8.   osx/x64/meterpreter_reverse_tcp
9.   php/meterpreter/reverse_tcp
10.  python/meterpreter_reverse_https
11.  python/meterpreter_reverse_tcp
12.  windows/x64/meterpreter_reverse_https
13.  windows/x64/meterpreter_reverse_tcp
14.  Previous menu
```
### अपडेट (मुख्य मेनू विकल्प 16)

* ऑपरेटिंग सिस्टम को अपडेट करता है, विभिन्न रिपॉजिटरी से git pull करता है, और locate डेटाबेस को अपडेट करता है।
* डेव स्कैनर्स द्वारा उपयोग किए जाने वाले टूल्स इंस्टॉल करता है (उदाहरण के लिए `ffuf`, `feroxbuster`, `jq`, `trivy`)।

## DEV

स्कैन परिणाम `$HOME/data/` के अंतर्गत लिखे जाते हैं जब तक अन्यथा नोट न किया जाए। डेव स्कैनर्स अपने स्वयं के आउटपुट निर्देशिकाओं (`api-scan_*`, `cloud-scan_*`, आदि) में **स्वतंत्र रिपोर्ट** उत्पन्न करते हैं। वे जरूरत पड़ने पर मेनू हेल्पर्स और रंगों के लिए `discover.sh` को सोर्स करते हैं, लेकिन **नहीं** लिखते या अपडेट नहीं करते Discover के recon HTML रिपोर्ट (`report.sh`, `$NAME`, `pages/*.htm`) को।

### API सुरक्षा स्कैनर (`dev/api-scanner.sh`)

चरणबद्ध API खोज और सुरक्षा परीक्षण। साझा हेल्पर्स और वर्डलिस्ट `dev/lib/api-scanner/` और `dev/data/` में हैं।

**इंटरैक्टिव मेनू**```
1. API Discovery and Testing (full)
2. API Quick Scan (discovery + docs)
3. JWT Token Analysis
4. Full API Assessment (orchestrated)
5. Previous menu
```
**CLI** (जब `-u` सेट किया जाता है तो मेन्यू को छोड़ देता है):```
./dev/api-scanner.sh -u https://target.example --quick --authorized
./dev/api-scanner.sh -u https://target.example --full --token 'eyJ…' --authorized
./dev/api-scanner.sh --resume ~/data/api-scan_20260703-1200 -u https://target.example
./dev/api-scanner.sh -u https://target.example --orchestrate --authorized
./dev/api-scanner.sh --help
```
| ध्वज | उद्देश्य |
|------|---------|
| `--quick` | केवल खोज और दस्तावेज़ीकरण |
| `--full` | सभी चरण (डिफ़ॉल्ट) |
| `--orchestrate` | पूर्ण स्कैन, फिर संबंधित स्कैनर के लिए संकेत |
| `--token` | प्रमाणित अनुरोधों के लिए बेयरर टोकन |
| `--cookie-file` | नेटस्केप कुकी जार |
| `--max-parallel N` | समवर्ती कार्यकर्ता (डिफ़ॉल्ट: 3) |
| `--max-endpoints N` | मर्ज के बाद परीक्षण किए जाने वाले एंडपॉइंट की सीमा |
| `--skip PHASE` | एक चरण छोड़ें (दोहराने योग्य) |
| `--resume DIR` | मौजूदा आउटपुट निर्देशिका का उपयोग करके फिर से शुरू करें |
| `--authorized` | प्राधिकरण पुष्टिकरण संकेत को छोड़ें |
| `--aggressive-http` | TRACE/CONNECT विधि परीक्षण शामिल करें |

**चरण (पूर्ण स्कैन):** HTML/JS लिंक निष्कर्षण, ffuf/feroxbuster फ़ज़िंग, पथ जांच, OpenAPI/Swagger खोज, GraphQL परीक्षण (इंट्रोस्पेक्शन, डेप्थ, बैचिंग), CORS (GET + प्रीफ़्लाइट), HTTP विधि जाँच, रेट-लिमिट बर्स्ट, JWT विश्लेषण।

**आउटपुट:** `$HOME/data/api-scan_<timestamp>/api_scanner/`

* `report.txt` और `report.md` — स्कैनर-स्थानीय निष्कर्ष (Discover रेकॉन रिपोर्ट में विलय नहीं किए गए)
* `findings.json` — सभी निष्कर्षों का समेकित JSON निर्यात
* `findings_registry.tsv` — टैब-पृथक निष्कर्ष लॉग (JSON निर्यात का स्रोत)
* `scan.log` — अनुरोध ऑडिट ट्रेल
* `.checkpoint/` — प्रति चरण फिर से शुरू करने के मार्कर

`curl` और `jq` आवश्यक है। स्थापित होने पर `ffuf` या `feroxbuster` का उपयोग करता है (Discover **अपडेट** के माध्यम से स्थापित करें)। सीधे चलाने पर `f_banner`/मेनू सहायकों के लिए `discover.sh` को स्रोत करता है।

### क्लाउड सुरक्षा स्कैनर (`dev/cloud-scanner.sh`)

AWS, Azure और GCP के लिए चरणबद्ध क्लाउड गलत कॉन्फ़िगरेशन ऑडिट। साझा सहायक `dev/lib/cloud-scanner/` में रहते हैं।

**इंटरैक्टिव मेनू**```
1. AWS (Amazon Web Services)
2. Azure (Microsoft Azure)
3. GCP (Google Cloud Platform)
4. All providers
5. Previous menu
```
**CLI** (जब प्रदाता फ़्लैग सेट होते हैं तो मेनू को छोड़ देता है):```
./dev/cloud-scanner.sh --aws --quick
./dev/cloud-scanner.sh --azure --gcp --full
./dev/cloud-scanner.sh --aws --output-dir ~/data/cloud-scan_custom
./dev/cloud-scanner.sh --resume ~/data/cloud-scan_20260704-1200 --aws
./dev/cloud-scanner.sh --help
```
| झंडा | उद्देश्य |
|------|---------|
| `--aws` / `--azure` / `--gcp` | एक प्रदाता चलाएं (कई के लिए संयोजित करें) |
| `--quick` | एक्सपोज़र-केंद्रित जांच (सार्वजनिक पहुंच, MFA, खुला इनग्रेस) |
| `--full` | व्यापक ऑडिट जिसमें IAM गहराई, बहु-क्षेत्र EC2/SG, अतिरिक्त शामिल हैं |
| `--output-dir DIR` | कस्टम आउटपुट निर्देशिका |
| `--resume DIR` | मौजूदा स्कैन निर्देशिका का उपयोग करके जारी रखें (पूर्ण चरणों को छोड़ें) |
| `-h`, `--help` | उपयोग दिखाएं |

परिणाम `$HOME/data/cloud-scan_YYYYMMDD-HHMM/` (या `--output-dir`) के अंतर्गत लिखे जाते हैं:

* `findings_registry.tsv` — गंभीरता, प्रदाता, सेवा, संसाधन, जांच, विवरण, साक्ष्य
* `findings.json` — सभी निष्कर्षों का समेकित JSON निर्यात
* `report.txt` / `report.md` — स्कैनर-स्थानीय रोलअप (Discover recon रिपोर्ट में विलय नहीं)
* `scan.log` — API गतिविधि और निष्कर्ष लॉग
* `.checkpoint/` — `--resume` के लिए चरण मार्कर

आवश्यकता है `jq` और प्रासंगिक क्लाउड CLI (`aws`, `az`, `gcloud`/`gsutil`) की, स्कैनिंग से पहले क्रेडेंशियल कॉन्फ़िगर किए हों। स्कैनर CLI को स्वतः स्थापित नहीं करता है या इंटरएक्टिव `aws configure` / `gcloud init` नहीं चलाता है। सीधे चलने पर `f_banner` / मेनू सहायकों के लिए `discover.sh` को स्रोत करता है।

### कंटेनर सुरक्षा स्कैनर (`dev/container-scanner.sh`)

Trivy, Docker, और kubectl का उपयोग करके व्यापक Docker और Kubernetes सुरक्षा मूल्यांकन। `$HOME/data/container-scan_*` के अंतर्गत स्वतंत्र आउटपुट (Discover recon HTML रिपोर्ट को अपडेट नहीं करता)।

* **Docker images** — Trivy भेद्यता/गुप्त/कॉन्फ़िग स्कैन, SBOM (पूर्ण मोड), Dockerfile विश्लेषण
* **Docker containers** — विशेषाधिकार मोड, माउंट, क्षमताएं, रनटाइम जांच (पूर्ण मोड)
* **Kubernetes** — RBAC, NetworkPolicies, PSS लेबल, पदावनत APIs, पॉड सुरक्षा

**स्कैन प्रकार:** `docker-images`, `docker-containers`, `kubernetes`, या `all` (Discover मेनू से चलाए जाने पर डिफ़ॉल्ट)।

**CLI विकल्प:** `--quick`, `--full`, `--output-dir`, `--resume`, `--dockerfile-root`, `--include-ns`, `--exclude-ns`, `--trivy-jobs`, `--menu`, `-h`

**आउटपुट आर्टिफैक्ट:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `container_security_report.txt`

**निर्भरताएं:** `docker`, `kubectl` (kubernetes स्कैन), `trivy`, `jq`, `numfmt` — Discover अपडेट के माध्यम से स्थापित करें; स्वतः स्थापित नहीं।

**पर्यावरण:** `CONTAINER_OUTPUT_DIR`, `CONTAINER_DOCKERFILE_ROOT`, `CONTAINER_SCAN_MODE`, `CONTAINER_EXCLUDE_NS`

### OAuth और JWT सुरक्षा स्कैनर (`dev/oauth-jwt-scanner.sh`)

OAuth/OIDC खोज, लाइव अधिकृत प्रोब, ऑफ़लाइन JWT विश्लेषण, और वैकल्पिक लाइव टोकन सत्यापन। `api-scanner.sh` JWT जांच को पूरक करता है। `$HOME/data/oauth-jwt-scan_*` के अंतर्गत स्वतंत्र आउटपुट।

* **OAuth/OIDC** — खोज मेटाडेटा, JWKS, redirect_uri/state/PKCE/implicit प्रोब
* **JWT offline** — alg=none, RS256→HS256 भ्रम, jku/x5u/kid हमले, दावा स्वच्छता, विशेषाधिकार-वृद्धि पेलोड
* **JWT live** — `--jwt-endpoint` के विरुद्ध वैकल्पिक Bearer परीक्षण (खोजे जाने पर userinfo से स्वतः भरा जाता है)

**स्कैन प्रकार:** `oauth`, `jwt`, या `all` (संयुक्त)।

**मेनू:** OAuth परीक्षण, JWT परीक्षण, संयुक्त स्कैन, या पिछला मेनू।

**CLI उदाहरण:**```bash
./dev/oauth-jwt-scanner.sh --target https://app.example.com --full
./dev/oauth-jwt-scanner.sh --jwt 'eyJhbG...' --jwt-endpoint https://app.example.com/api/me
./dev/oauth-jwt-scanner.sh --target https://app.example.com --api-scan-dir ~/data/api-scan_20260101-1200 --all
```
**Options:** `--target`, `--jwt`, `--jwt-file`, `--api-scan-dir`, `--jwt-endpoint`, `--client-id`, `--redirect-uri`, `--quick`, `--full`, `--oauth`, `--jwt-only`, `--all`, `--output-dir`, `--resume`, `--menu`, `-h`

**Output:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`

**Dependencies:** `curl`, `jq`

### Open Redirect Scanner (`dev/open-redirect.sh`)

रिडायरेक्ट पैरामीटर को फ़ज़ करता है (मौजूदा क्वेरी पैरामीटर में इंजेक्ट और म्यूटेट करता है) कॉन्फ़िगरेबल कैनरी होस्ट के साथ। 3xx `Location` (एक-हॉप फॉलो के साथ), मेटा रिफ्रेश, और जावास्क्रिप्ट/बॉडी रिडायरेक्ट का पता लगाता है। पूर्ण मोड POST और हेडर प्रोब जोड़ता है। पुष्टिकरण पास गलत सकारात्मक को कम करने के लिए दूसरे कैनरी होस्ट का उपयोग करता है। पायथन इंजन: `dev/lib/open-redirect-scanner/engine.py`; पेलोड: `dev/data/openredirect-payloads.txt`। स्टैंडअलोन आउटपुट `$HOME/data/openredirect-scan_*` के अंतर्गत।

**Menu:** एकल URL, डोमेन, URL फ़ाइल, उन्नत विकल्प, पिछला स्कैन निर्देशिका, या पिछला मेनू।

**CLI examples:**```bash
./dev/open-redirect.sh --url https://app.example.com/login?next=/home --full
./dev/open-redirect.sh --domain example.com --quick
./dev/open-redirect.sh --scan-dir ~/data/api-scan_20260101-1200 --crawl --quick
./dev/open-redirect.sh --file ~/targets.txt --max-requests 500 --rps 5
```
**विकल्प:** `--url`, `--domain`, `--file`, `--scan-dir`, `--wordlist`, `--canary-host`, `--quick`, `--full`, `--crawl`, `--workers`, `--delay`, `--rps`, `--max-requests`, `--no-confirm`, `--quiet`, `--output-dir`, `--resume`, `--menu`, `-h`

**आउटपुट:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `openredirect_engine/results.json`, `openredirect_engine/checkpoint.json`

**निर्भरताएँ:** `python3`, `requests` (Discover Update `python3-requests` इंस्टॉल करता है), `jq`

### संवेदनशील जानकारी स्कैनर (`dev/sensitive-scanner.sh`)

स्थानीय फ़ाइलों/निर्देशिकाओं और उजागर वेब पथों में रहस्यों, क्रेडेंशियल्स और PII की खोज करता है। Bash ऑर्केस्ट्रेशन प्लस Python इंजन: `filescan.py` (सिंगल-पास फ़ाइल स्कैन) और `engine.py` (समानांतर वेब प्रोबिंग)। पैटर्न डेटा: `dev/data/sensitive-patterns.tsv`, `sensitive-denylist.txt`, `sensitive-skip-paths.txt`। `$HOME/data/sensitive-scan_*` के अंतर्गत स्टैंडअलोन आउटपुट।

* **फ़ाइल स्कैन** — `filescan.py` के माध्यम से प्रति फ़ाइल एक पास; डिनीलिस्ट, स्किप ग्लॉब्स, एन्ट्रॉपी फ़िल्टर, Luhn/SSN/TC सत्यापन; वैकल्पिक `gitleaks` / `trufflehog` (`--external auto`)
* **वेब स्कैन** — समानांतर वर्कर्स/RPS, प्रति-पथ चेकपॉइंट पुनरारंभ, robots डिसअलो + sitemap पथ, api-scanner एंडपॉइंट आयात, soft-404 गार्ड, डायरेक्ट्री लिस्टिंग डिटेक्शन, HTTP 200 बॉडी पर गहरा `filescan.py`
* **api-scanner हुक** — इनलाइन रिस्पांस जाँच में `filescan.py` का उपयोग; ऑर्केस्ट्रेटर बियरर टोकन के साथ `--all` को ऑटो-लॉन्च कर सकता है
* **रिपोर्ट्स** — डीडुप्लिकेटेड `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`; सुरक्षित आर्टिफैक्ट्स के लिए `--no-store-content` / `--shred-content`

**मेनू:** फ़ाइल या फ़ोल्डर, URL, फ़ाइल/फ़ोल्डर + पिछला स्कैन डायरेक्ट्री, URL + api-scan आउटपुट, या पिछला मेनू।

**उदाहरण:**```
./dev/sensitive-scanner.sh --path ./myapp --files --full
./dev/sensitive-scanner.sh --url https://app.example.com --web --quick --workers 8 --rps 5
./dev/sensitive-scanner.sh --url https://app.example.com --scan-dir ~/data/api-scan_20260101-1200 --all --quick --bearer-token "$TOKEN"
./dev/sensitive-scanner.sh --path /var/www/html/config.php --files --external gitleaks
./dev/lib/sensitive-scanner/run-tests.sh
```
**Options:** `--path`, `--url`, `--scan-dir`, `--wordlist`, `--quick`, `--full`, `--workers`, `--delay`, `--rps`, `--max-paths`, `--bearer-token`, `--insecure`, `--no-store-content`, `--shred-content`, `--redact-emails`, `--entropy-min`, `--external`, `--files`, `--web`, `--all`, `--output-dir`, `--resume`, `--quiet`, `--menu`, `-h`

**Output:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `sensitive_info/`, `web_sensitive/engine/{results,checkpoint}.json`

**Dependencies:** `python3`, `jq`, `find`; web scans need `python3-requests`; optional `gitleaks`, `trufflehog`, `rg`

### WAF पहचान (`dev/waf-detect.sh`)

लक्ष्यों के सामने वेब एप्लिकेशन फ़ायरवॉल और CDN एज लेयर्स की पहचान करता है। मॉड्यूलर लाइब्रेरी: `dev/lib/waf-detect/{common,probe}.sh`, `wafw00f_run.py`; डेटा: `dev/data/waf-signatures.tsv`, `waf-aliases.tsv`, `waf-labels.tsv`। स्टैंडअलोन आउटपुट `$HOME/data/waf-detection_*` के अंतर्गत।

* **सही निष्क्रिय (api-scanner हुक के लिए डिफ़ॉल्ट)** — `--passive` केवल एक सामान्य HTTP GET भेजता है; प्रतिक्रिया हेडर/बॉडी को `waf-signatures.tsv` से मिलाता है। कोई wafw00f नहीं, कोई SQLi ट्रिगर नहीं, कोई `X-Forwarded-For` इंजेक्शन नहीं।
* **सक्रिय मोड** — wafw00f `wafw00f_run.py` के माध्यम से (प्राथमिक, उच्च विश्वास) साथ ही पूरक सिग्नेचर/व्यवहारिक जांच। गैर-इंटरैक्टिव सक्रिय स्कैन के लिए `--i-understand` आवश्यक है।
* **पूरक** — `--supplemental auto` एक आत्मविश्वासपूर्ण wafw00f हिट के बाद बेमानी जांच को छोड़ देता है; व्यवहार संबंधी निष्कर्षों के लिए WAF हेडर की पुष्टि आवश्यक है
* **समेकित निष्कर्ष** — प्रति विक्रेता एक पंक्ति जिसमें आत्मविश्वास (`high`/`medium`/`low`), स्रोत और प्रकार (`waf`/`cdn`/`both`) होता है
* **संरचित हिट्स** — डाउनस्ट्रीम टूलिंग के लिए `waf_engine/hits.jsonl` और `findings.json` `hits[]`
* **फिर से शुरू** — `--resume DIR` `waf_engine/checkpoint.json` से जारी रहता है
* **रिपोर्ट** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`

**मेनू:** एकल लक्ष्य, लक्ष्य फ़ाइल, या पिछला मेनू (सक्रिय/निष्क्रिय विकल्प के साथ)।

**उदाहरण:**```
./dev/waf-detect.sh --url https://app.example.com --passive
./dev/waf-detect.sh --file ~/targets.txt --passive --delay 2
./dev/waf-detect.sh --url example.com --i-understand --output-dir ~/data/waf-test
./dev/waf-detect.sh --resume ~/data/waf-detection_20260704-1200 --workers 4
./dev/lib/waf-detect/run-tests.sh
```
**विकल्प:** `--url`, `--file`, `--output-dir`, `--resume`, `--passive`, `--i-understand`, `--waf-only`, `--insecure`, `--no-redirect`, `--proxy`, `--delay`, `--max-targets`, `--workers`, `--wafw00f`, `--supplemental`, `--input-format`, `--quiet`, `--menu`, `-h`

**आउटपुट:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`, `scan.log`, `waf_engine/{hits.jsonl,checkpoint.json,*.json}`

**निर्भरताएँ:** `curl`, `jq`, `grep`, `python3`; वैकल्पिक `wafw00f` (सक्रिय मोड, अनुशंसित)

**api-scanner एकीकरण:** `api-scanner.sh --orchestrate` मुख्य स्कैन के बाद waf-detect चलाने का संकेत देता है (डिफ़ॉल्ट रूप से निष्क्रिय)।

### वेब और API सुरक्षा (`dev/web-api-scanner.sh`)

Metasploit-आधारित वेब/API मूल्यांकन। मॉड्यूलर लाइब्रेरी: `dev/lib/web-api-scanner/{common,phases,msf,probe,waf,targets}.sh`, `msf_parse.py`; डेटा: `dev/data/web-api-{phases,tech-signatures}.tsv`। स्टैंडअलोन आउटपुट `$HOME/data/web-api-scan_*` के अंतर्गत।

* **स्तर** — `passive` (रिकॉन) | `standard`/`--quick` (रिकॉन + तकनीकी स्कैनर) | `intrusive` (+ SQLi/ब्रूट) | `exploit` (+ एक्सप्लॉइट जाँच)
* **चरण नियंत्रण** — `--phases`, `--skip-phases`; प्रति-चरण `msfconsole` `--phase-timeout` के साथ
* **प्रौद्योगिकी फिंगरप्रिंट** — भारित `web-api-tech-signatures.tsv` (Laravel, Spring, Swagger, nginx, …)
* **WAF-जागरूक** — जब WAF/CDN का पता चलता है तो ब्रूट चरणों को छोड़ देता है (`--scan-dir` या हेडर सिग्नेचर)
* **प्रमाणीकरण** — `--bearer-token`, `--cookie-file` curl + MSF के लिए
* **api-scanner एकीकरण** — `--scan-dir` `brute_dirs` पथों के लिए `api_scanner/all_endpoints.txt` लोड करता है
* **संरचित हिट** — `msf_parse.py` → `msf_engine/hits.jsonl` + `findings.json` `hits[]`
* **बहु-लक्ष्य** — `--file`, `--workers`, `--max-targets`
* **गुप्तचरी** — `--delay`, `--jitter`, `--proxy`, स्तर-आधारित `THREADS`
* **MSF DB** — डिफ़ॉल्ट रूप से केवल जाँच; `--msf-db-bootstrap` वैकल्पिक सेटअप के लिए

**मेनू:** URL स्कैन करें (निष्क्रिय डिफ़ॉल्ट) या पिछला मेनू।

**उदाहरण:**```
./dev/web-api-scanner.sh --url https://app.example.com --passive
./dev/web-api-scanner.sh --url example.com --quick --scan-dir ~/data/api-scan_*/ 
./dev/web-api-scanner.sh --url example.com --tier exploit --i-understand --bearer-token "$TOKEN"
./dev/web-api-scanner.sh --file ~/targets.txt --quick --workers 2 --max-targets 10
WEBAPI_RUN_LIVE_MSF=1 ./dev/lib/web-api-scanner/run-tests.sh
```
**विकल्प:** `--url`, `--file`, `--tier`, `--quick`, `--phases`, `--skip-phases`, `--scan-dir`, `--bearer-token`, `--cookie-file`, `--proxy`, `--phase-timeout`, `--workers`, `--threads`, `--jitter`, `--target-ip`, `--output-dir`, `--resume`, `--passive`, `--i-understand`, `--dry-run`, `--skip-msf-db`, `--msf-db-bootstrap`, `--keep-resources`, `--no-waf-aware`, `--insecure`, `--delay`, `--quiet`, `--menu`, `-h`

**आउटपुट:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `msf_engine/`

**निर्भरताएँ:** `curl`, `jq`, `grep`, `msfconsole`; MSF DB के लिए PostgreSQL अनुशंसित ( `--skip-msf-db` के साथ वैकल्पिक)

**api-scanner एकीकरण:** `api-scanner.sh --orchestrate` वेब-एपीआई-स्कैनर चलाने का संकेत देता है (डिफ़ॉल्ट रूप से निष्क्रिय)।

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

कुछ उपयोगकर्ताओं ने बताया है कि वे विकल्प 3, 4 और 5 को छोड़कर किसी भी अन्य विकल्प का उपयोग करने में असमर्थ हैं। 
अन्य विकल्प (1, 2, 6, आदि) चुनने पर कुछ नहीं होता।

## डाउनलोड हैश सत्यापित करें

हैश-आधारित सत्यापन यह सुनिश्चित करता है कि फ़ाइल दूषित नहीं हुई है, फ़ाइल के हैश मान की तुलना पहले से गणना किए गए मान से करके। 
यदि ये मान मेल खाते हैं, तो फ़ाइल अपरिवर्तित मानी जाती है।

### macOS

1. टर्मिनल खोलें
2. shasum -a 256 /path/to/file
3. मान की तुलना वेबसाइट पर दिए गए चेकसम से करें।

### Windows

1. PowerShell खोलें
2. Get-FileHash C:\path\to\file
3. मान की तुलना वेबसाइट पर दिए गए चेकसम से करें।

## VirtualBox या Windows Subsystem for Linux (WSL) पर Kali चलाना

कुछ उपयोगकर्ताओं ने बताया है कि समाधान WSL के बजाय VMware इमेज का उपयोग करना है। 

अन्य उपयोगकर्ताओं ने देखा है कि जब वे VirtualBox के माध्यम से बेयर मेटल Kali ISO चलाने के बजाय, 
पूर्व-निर्मित VirtualBox Kali इमेज चला रहे होते हैं तब समस्याएँ उत्पन्न होती हैं। 
(https://www.kali.org/get-kali/#kali-bare-metal)

यदि आप Kali चलाने के लिए VMware Workstation का उपयोग करने को तैयार नहीं हैं या असमर्थ हैं, 
तो हम आपको VirtualBox में अतिथि VM के रूप में Kali ISO चलाने का प्रयास करने के लिए प्रोत्साहित करते हैं।

1. Kali द्वारा प्रदान की गई बेयर मेटल ISO डाउनलोड करें।
2. ISO हैश सत्यापित करें (ऊपर देखें)।
3. VirtualBox में बेयर मेटल Kali ISO के साथ एक नया Kali VM प्रारंभ करें।

स्थापना के दौरान आपको कुछ [बुनियादी स्थापना निर्देश](https://www.kali.org/docs/installation/hard-disk-install/) भरने होंगे।

नोट: यदि आपको बेयर मेटल ISO सेट करने के बाद रूट तक पहुँचने में समस्या होती है, तो कृपया देखें: 
https://linuxconfig.org/how-to-reset-kali-linux-root-password