Skip to content
KitploitKITPLOIT
उपकरणएक्सप्लॉइटब्लॉग
Log in
जमा करें
उपकरणएक्सप्लॉइटब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

फ़ीडसंपर्कगोपनीयता© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
JShunter — jshunter एक कमांड-लाइन टूल है जो JavaScript फ़ाइलों का विश्लेषण करने और endpoints निकालने के लिए डिज़ाइन किया गया है। यह टूल संवेदनशील डेटा, जैसे कि API endpoints और संभावित सुरक्षा कमजोरियों की पहचान करने में विशेषज्ञता रखता है, जिससे यह बग बाउंटी शिकारियों और सुरक्षा शोधकर्ताओं के लिए एक आवश्यक संसाधन बन जाता है। | Kitploit
उपकरण/GitHubGitHub/cc1a2b/jshunter
टोहीस्थैतिक कोड विश्लेषण (SAST)भेद्यता विश्लेषणगतिशील कोड विश्लेषण (DAST)WAF बाईपासवेब सुरक्षापेनिट्रेशन टेस्टिंगसीक्रेट डिटेक्शनAPI सुरक्षा
GitHubcc1a2b/jshunter

JShunter

52959692 महीने पहलेKitploit द्वारा समीक्षित

विवरण

jshunter एक कमांड-लाइन टूल है जो JavaScript फ़ाइलों का विश्लेषण करने और endpoints निकालने के लिए डिज़ाइन किया गया है। यह टूल संवेदनशील डेटा, जैसे कि API endpoints और संभावित सुरक्षा कमजोरियों की पहचान करने में विशेषज्ञता रखता है, जिससे यह बग बाउंटी शिकारियों और सुरक्षा शोधकर्ताओं के लिए एक आवश्यक संसाधन बन जाता है।

रिपॉजिटरी देखें
साझा करें
# JSHunter

<div align="center">

[![License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
[![Go Version](https://img.shields.io/badge/Go-1.25+-00ADD8?style=flat&logo=go)](https://golang.org)
[![Release](https://img.shields.io/github/release/cc1a2b/jshunter.svg)](https://github.com/cc1a2b/jshunter/releases)
[![GitHub stars](https://img.shields.io/github/stars/cc1a2b/jshunter)](https://github.com/cc1a2b/jshunter/stargazers)
[![Platform](https://img.shields.io/badge/platform-Linux%20%7C%20macOS%20%7C%20Windows-lightgrey)](https://github.com/cc1a2b/jshunter/releases)

**प्रोफेशनल JavaScript सुरक्षा विश्लेषण उपकरण**

*सुरक्षा पेशेवरों के लिए पूर्ण एंडपॉइंट खोज, संवेदनशील डेटा पहचान, और उन्नत कोड विश्लेषण*

</div>

## परिचय

**JSHunter** JavaScript सुरक्षा विश्लेषण और एंडपॉइंट खोज के लिए एक व्यापक कमांड-लाइन उपकरण है। सुरक्षा पेशेवरों, पेनिट्रेशन टेस्टरों, और डेवलपर्स के लिए बनाया गया, यह उच्च-सटीकता पहचान एल्गोरिदम और प्रोफेशनल रिपोर्टिंग सुविधाओं के साथ एंटरप्राइज़-ग्रेड विश्लेषण क्षमताएं प्रदान करता है।

https://github.com/user-attachments/assets/5a5f60fa-f8dc-4aac-bd06-2e93779f9af4

*JSHunter कार्यरत — CLI का वास्तविक टर्मिनल कैप्चर (दिखाया गया प्रत्येक सीक्रेट नकली परीक्षण डेटा है)*

---

## विषय-सूची

- [परिचय](#about)
- [विशेषताएं](#features)
- [इंस्टॉलेशन](#installation)  
- [क्विक स्टार्ट](#quick-start)
- [उपयोग के उदाहरण](#usage-examples)
- [कमांड संदर्भ](#command-reference)
- [उन्नत उपयोग](#advanced-usage)
- [योगदान](#contributing)
- [लाइसेंस](#license)
- [सहायता](#support)

---

## विशेषताएं

### मुख्य क्षमताएं
- **व्यापक एंडपॉइंट खोज**: JavaScript फ़ाइलों से स्वचालित रूप से URL, API एंडपॉइंट, और छिपे हुए पैरामीटर निकालता है
- **उन्नत सुरक्षा विश्लेषण**: उच्च सटीकता के साथ API कुंजियों, JWT टोकन, क्रेडेंशियल्स, और संभावित कमजोरियों की पहचान करता है
- **लचीली इनपुट विधियां**: URL, फ़ाइल सूचियों, स्थानीय फ़ाइलों, stdin पाइपिंग, और पुनरावर्ती खोज का समर्थन करता है
- **उच्च-प्रदर्शन आर्किटेक्चर**: बुद्धिमान दर सीमित करने के साथ मल्टी-थ्रेडेड समवर्ती प्रसंस्करण
- **प्रोफेशनल स्टेल्थ सुविधाएं**: प्रॉक्सी समर्थन, कस्टम हेडर, यूजर-एजेंट रोटेशन, और बायपास डिटेक्शन

### बुद्धिमान डिटेक्शन इंजन
> **उन्नत विश्लेषण एल्गोरिदम के साथ एंटरप्राइज़-ग्रेड सटीकता**

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

### संरचनात्मक डिटेक्शन इंजन

JSHunter जिस JavaScript को स्कैन करता है उसे केवल पैटर्न-मैचिंग के बजाय पार्स करता है। एक
सिंगल-पास ECMAScript स्कैनर प्रतिक्रिया के प्रत्येक बाइट को स्ट्रिंग
लिटरल, टेम्पलेट लिटरल, कमेंट, रेगुलर-एक्सप्रेशन लिटरल, या कोड के रूप में वर्गीकृत करता है, और
डिटेक्शन नियमों का मूल्यांकन उस वर्गीकरण के विरुद्ध किया जाता है।

यह मायने रखता है क्योंकि एक regex को पता नहीं होता कि उसने क्या मैच किया। वही चालीस base64
अक्षर स्ट्रिंग लिटरल के अंदर "क्रेडेंशियल" का अर्थ रखते हैं, मिनिफाइड आइडेंटिफायर के अंदर "चंक हैश" का,
और कुछ भी नहीं जब वे दो आसन्न टोकन के बीच की सीमा पर हों। यह जानना कि कौन सा है,
निकटता ह्यूरिस्टिक्स के ढेर को एक संरचनात्मक उत्तर से बदल देता है:

- **क्षेत्र गेटिंग**: एक regex लिटरल के अंदर का मैच एक पैटर्न है, मान नहीं।
  एक मैच जो टोकन सीमा को पार करता है वह एकल लिटरल नहीं है। कोड में एक मैच
  एक आइडेंटिफायर फ्रैगमेंट है। तीनों को सीधे अस्वीकार कर दिया जाता है।
- **बाइंडिंग संदर्भ**: `key` शब्द के लिए अक्षरों की एक निश्चित विंडो स्कैन करने के बजाय,
  इंजन उस आइडेंटिफायर या प्रॉपर्टी कुंजी को पुनर्प्राप्त करता है जिससे मान वास्तव में बंधा है —
  `const stripeSecret = "..."` बहुत अलग पढ़ा जाता है `{contentHash: "..."}` से, और एक
  केवल-आकार नियम अब उस बाइंडिंग की आवश्यकता रखता है।
- **सहोदर कुंजी-सेट**: एक Firebase वेब कॉन्फ़िग, एक Algolia सर्च
  कॉन्फ़िग, एक Segment एनालिटिक्स कॉन्फ़िग और एक Supabase ब्राउज़र क्लाइंट के सदस्यों को
  उस ऑब्जेक्ट के आकार से पहचाना जाता है जिसमें वे स्थित हैं।
- **मान आकार**: डाइजेस्ट, UUID, गद्य, पथ, प्लेसहोल्डर, और base64 जो
  PNG, फ़ॉन्ट, JSON दस्तावेज़ या अंग्रेजी वाक्य में डिकोड होता है, प्रत्येक को
  उनके वास्तविक स्वरूप के लिए पहचाना जाता है।
- **एक्सपोज़र वर्गीकरण**: जारीकर्ता द्वारा जानबूझकर प्रकाशित मान — Stripe
  publishable keys, Mapbox public tokens, Supabase anon JWTs जो उनके स्वयं के
  `role` claim से पढ़े जाते हैं, Twilio SIDs — को लीक के रूप में रिपोर्ट करने के बजाय वर्गीकृत किया जाता है।
  `--include-public` उन्हें फिर भी रिपोर्ट करता है।
- **फ़ाइल-सापेक्ष आश्चर्य**: स्कैन की जा रही फ़ाइल से बनाया गया एक कैरेक्टर-ट्रांज़िशन मॉडल
  स्कोर करता है कि एक उम्मीदवार उस फ़ाइल के बाकी हिस्से से कितना अलग पढ़ा जाता है।

प्रत्येक अस्वीकृति इस शर्त पर निर्भर है कि बॉडी विश्वास के साथ JavaScript या JSON है।
किसी और चीज़ पर — एक `.env` फ़ाइल, गद्य, कच्चा HTML — इंजन साक्ष्य योगदान देता है लेकिन कभी दबाता नहीं, इसलिए एक गलत वर्गीकृत इनपुट कभी सीक्रेट छिपा नहीं सकता।
`--no-structural` पूरी परत को बंद कर देता है और v0.7 व्यवहार बहाल करता है।

निष्कर्ष `--json`, `--ndjson` और
SARIF प्रॉपर्टी बैग में एक `evidence` ऑब्जेक्ट के रूप में तर्क साथ रखते हैं:```json
"exposure": "secret",
"evidence": {
  "region": "string-literal",
  "role": "assignment",
  "bound_to": "awsAccessKeyId",
  "shape": "opaque-token",
  "charset": "alphanumeric",
  "signals": [
    {"name": "in-literal", "delta": 0.04, "detail": "value is a complete string-literal"},
    {"name": "credential-binding", "delta": 0.12, "detail": "bound to 'awsAccessKeyId'"}
  ]
}
```
`--stats` रिपोर्ट करता है कि प्रत्येक चरण ने क्या छोड़ा, इसलिए पाइपलाइन ऑडिट करने योग्य बनी रहती है।

### Chunk Graph और Route Discovery

एक आधुनिक एप्लिकेशन एक entry bundle और कई सौ lazily loaded
chunks भेजता है जिनके URLs रनटाइम पर bundler द्वारा inline किए गए manifest से
असेंबल किए जाते हैं। उनसे कोई लिंक नहीं जुड़ता, इसलिए crawler उन्हें कभी नहीं देखता। `-G` उस manifest को
पुनर्प्राप्त करता है और पूरी asset सूची तथा client route तालिका प्रिंट करता है:```console
$ jshunter -u https://target.example/_next/static/chunks/main-a1b2c3.js -G
[CHUNKS] https://target.example/...: next runtime, 214 chunks, 37 routes
[CHUNK]  https://target.example/...  https://target.example/_next/static/chunks/settings.11aa22bb33cc.js
[ROUTE]  https://target.example/...  /admin/users/:id
```
समर्थित रनटाइम: webpack 4 और 5 (`__webpack_require__.u`, `miniCssF`,
`jsonpScriptSrc`), Next.js बिल्ड मैनिफ़ेस्ट, Vite और Rollup (`__vite__mapDeps`,
`__vitePreload`), सादा डायनामिक `import()`, और React Router,
Vue Router तथा Angular से रूट टेबल। आउटपुट टैब-पृथक और डुप्लिकेट-रहित होता है, इसलिए यह सीधे
अगले स्कैन की इनपुट सूची के रूप में पाइप हो जाता है:```bash
jshunter -u https://target.example/main.js -G -q | awk -F'\t' '/^\[CHUNK\]/{print $3}' > chunks.txt
jshunter -l chunks.txt -s -j > findings.json
```
### व्यावसायिक HTTP और नेटवर्किंग सूट
<details>
<summary><strong>एंटरप्राइज़-ग्रेड नेटवर्क कॉन्फ़िगरेशन</strong></summary>

**प्रमाणीकरण और हेडर:**
- **कस्टम हेडर** (`-H`): दोहराने योग्य प्रमाणीकरण हेडर और कस्टम अनुरोध हेडर
- **कुकी प्रबंधन** (`-c`): संरक्षित संसाधनों तक पहुँचने के लिए सत्र कुकीज़
- **User-Agent नियंत्रण** (`-U`): स्टील्थ के लिए कस्टम UA स्ट्रिंग्स या फ़ाइल-आधारित रोटेशन

**प्रदर्शन और विश्वसनीयता:**
- **दर सीमित करना** (`-R`): पता लगने से बचने के लिए कॉन्फ़िगर करने योग्य अनुरोध विलंब (मिलीसेकंड)
- **स्मार्ट टाइमआउट** (`-T`): विभिन्न नेटवर्क स्थितियों के लिए कस्टम टाइमआउट सेटिंग्स
- **इंटेलिजेंट रीट्राई** (`-y`): विफल अनुरोधों के लिए एक्सपोनेंशियल बैकऑफ़ के साथ स्वचालित रीट्राई तंत्र

**व्यावसायिक एकीकरण:**
- **प्रॉक्सी समर्थन** (`-p`): पूर्ण Burp Suite और कस्टम प्रॉक्सी एकीकरण (HTTP/HTTPS/SOCKS5)
- **TLS लचीलापन** (`-k`): परीक्षण वातावरण के लिए वैकल्पिक प्रमाणपत्र सत्यापन बायपास
- **थ्रेड नियंत्रण** (`-t`): इष्टतम प्रदर्शन के लिए कॉन्फ़िगर करने योग्य समवर्ती अनुरोध प्रबंधन

> **सुरक्षा पेशेवर सुविधाएँ**: पेनेट्रेशन परीक्षण और सुरक्षा आकलन के लिए डिज़ाइन किया गया
> **उदाहरण**: `jshunter -l targets.txt -p 127.0.0.1:8080 -H "Authorization: Bearer token" -R 1000`

</details>

### उन्नत JavaScript विश्लेषण
<details>
<summary><strong>पूर्ण कोड विश्लेषण और डीऑब्फस्केशन सूट</strong></summary>

**मुख्य विश्लेषण उपकरण:**
- **डीऑब्फस्केशन इंजन** (`-d`): गहन विश्लेषण के लिए मिनिफाइड और ऑब्फस्केटेड JavaScript को अनपैक करता है
- **सोर्स मैप पार्सर** (`-m`): सोर्स मैप्स से मूल स्रोत कोड निकालता और विश्लेषण करता है
- **ऑब्फस्केशन डिटेक्शन** (`-z`): ऑब्फस्केशन तकनीकों और पैटर्न की पहचान और वर्गीकरण करता है

**गतिशील विश्लेषण:**
- **Eval विश्लेषण** (`-e`): गतिशील कोड निष्पादन (`eval()`, `Function()`, रनटाइम जनरेशन) का विश्लेषण करता है

**कोड इंटेलिजेंस:**
- **पैटर्न पहचान**: सामान्य JavaScript फ्रेमवर्क और लाइब्रेरी की पहचान करता है
- **कोड संरचना विश्लेषण**: एप्लिकेशन आर्किटेक्चर और डेटा फ़्लो को मैप करता है
- **संदर्भ-जागरूक डिटेक्शन**: गलत सकारात्मकता कम करने के लिए कोड संदर्भ को समझता है

> **व्यावसायिक उपयोग**: अधिकतम कवरेज के लिए विश्लेषण उपकरणों को सुरक्षा डिटेक्शन के साथ संयोजित करें
> **उदाहरण**: `jshunter -u target.js -d -m -e -s -g` (पूर्ण डीऑब्फस्केशन + सुरक्षा विश्लेषण)

</details>

### सुरक्षा विश्लेषण सूट
<details>
<summary><strong>पूर्ण सुरक्षा आकलन टूलकिट</strong></summary>

**मुख्य सुरक्षा डिटेक्शन:**
- **सीक्रेट्स डिटेक्शन** (`-s`): API कुंजियाँ, एक्सेस टोकन, पासवर्ड, और हार्डकोडेड क्रेडेंशियल
- **JWT टोकन विश्लेषण** (`-x`): प्रमाणीकरण टोकन निष्कर्षण, सत्यापन, और पेलोड निरीक्षण
- **Firebase सुरक्षा** (`-F`): कॉन्फ़िगरेशन विश्लेषण, API कुंजियाँ, और डेटाबेस URL डिटेक्शन

**उन्नत विश्लेषण:**
- **पैरामीटर डिस्कवरी** (`-P`): छिपे हुए फ़ॉर्म पैरामीटर, वेरिएबल, और कॉन्फ़िगरेशन कुंजियाँ
- **URL पैरामीटर निष्कर्षण** (`-PU`): पूर्ण URL संदर्भ के साथ उन्नत पैरामीटर विश्लेषण
- **GraphQL विश्लेषण** (`-g`): स्कीमा डिटेक्शन, क्वेरी निष्कर्षण, और एंडपॉइंट डिस्कवरी
- **WAF बायपास डिटेक्शन** (`-B`): सुरक्षा बायपास पैटर्न और एवेज़न तकनीकें

**स्कोप और संदर्भ:**
- **आंतरिक एंडपॉइंट फ़िल्टरिंग** (`-i`): निजी/आंतरिक संसाधन की पहचान और वर्गीकरण
- **लिंक विश्लेषण** (`-L`): व्यापक URL निष्कर्षण और संबंध मैपिंग

> **व्यावसायिक सुझाव**: व्यापक विश्लेषण के लिए फ़्लैग संयोजित करें (जैसे, `jshunter -u target.js -s -x -F -g`)

</details>

### स्कोप और डिस्कवरी
<details>
<summary><strong>इंटेलिजेंट क्रॉलिंग और टार्गेटिंग</strong></summary>

- **पुनरावर्ती डिस्कवरी**: बहु-गहराई JavaScript फ़ाइल क्रॉलिंग
- **डोमेन स्कोपिंग**: विशिष्ट डोमेन पर विश्लेषण केंद्रित करें
- **एक्सटेंशन फ़िल्टरिंग**: विशिष्ट JavaScript फ़ाइल प्रकारों को लक्षित करें

</details>

### व्यावसायिक रिपोर्टिंग और निर्यात सूट
<details>
<summary><strong>एंटरप्राइज़-ग्रेड आउटपुट और एकीकरण</strong></summary>

**मुख्य आउटपुट प्रारूप:**
- **कंसोल डिस्प्ले**: पेशेवर फ़ॉर्मेटिंग और स्पष्ट वर्गीकरण के साथ रंग-कोडित टर्मिनल आउटपुट
- **फ़ाइल निर्यात** (`-o`): व्यापक परिणामों को कस्टम फ़ाइल स्थानों पर सहेजें
- **JSON निर्यात** (`-j`): ऑटोमेशन और प्रोग्रामेटिक प्रोसेसिंग के लिए संरचित डेटा प्रारूप
- **CSV निर्यात** (`-C`): कार्यकारी रिपोर्टिंग और विश्लेषण के लिए स्प्रेडशीट-संगत प्रारूप

**व्यावसायिक एकीकरण:**
- **Burp Suite निर्यात** (`-n`): तत्काल परीक्षण के लिए Burp Suite Professional के साथ सीधा एकीकरण
- **Regex फ़िल्टरिंग** (`-r`): लक्षित परिणाम फ़िल्टरिंग के लिए कस्टम पैटर्न मिलान
- **वर्बोज़ विश्लेषण** (`-v`): डिबगिंग जानकारी और संदर्भ के साथ विस्तृत विश्लेषण आउटपुट

**परिणाम प्रबंधन:**
- **क्लीन मोड** (`--found-only`): केंद्रित सुरक्षा रिपोर्टिंग के लिए खाली परिणाम छिपाएँ
- **क्वाइट मोड** (`-q`): स्वचालित स्क्रिप्टिंग और CI/CD एकीकरण के लिए बैनर दबाएँ

> **रिपोर्टिंग वर्कफ़्लो**: ऑटोमेशन के लिए JSON, प्रबंधन रिपोर्ट के लिए CSV, तत्काल परीक्षण के लिए Burp निर्यात का उपयोग करें
> **उदाहरण**: `jshunter -l targets.txt -s -j -o security-findings.json` (संरचित सुरक्षा रिपोर्ट)

</details>

---

## इंस्टॉलेशन

### Go इंस्टॉल (अनुशंसित)```bash
# Install JSHunter
go install -v github.com/cc1a2b/jshunter/cmd/jshunter@latest

# Verify installation
jshunter --help
```
### स्रोत से बिल्ड करें```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go build -o jshunter ./cmd/jshunter
```
### सिस्टम आवश्यकताएँ
- **Go 1.22.5+** (स्रोत से बिल्ड करने के लिए)
- **Linux, macOS, या Windows** (64-बिट आर्किटेक्चर)
- **नेटवर्क कनेक्टिविटी** रिमोट JavaScript विश्लेषण के लिए

---

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

### बुनियादी विश्लेषण```bash
# Analyze a single JavaScript file
jshunter -u "https://example.com/app.js"

# Scan multiple URLs from file
jshunter -l urls.txt

# Analyze local JavaScript file
jshunter -f app.js
```
### पूर्ण सुरक्षा विश्लेषण```bash
# Find API keys, secrets, and credentials
jshunter -u "https://target.com/app.js" -s

# Full analysis with deobfuscation, GraphQL, and Firebase detection
jshunter -u "https://target.com/app.js" -d -s -g -F -x -L

# Professional security assessment with all tools
jshunter -u "https://target.com/app.js" -d -m -e -s -x -P -g -F -B -L

# Export comprehensive results for reporting
jshunter -l targets.txt -s -g -F -j -o security_findings.json
```
---

## उपयोग के उदाहरण```bash
# Analyze single URL
jshunter -u "https://example.com/app.js"

# Analyze multiple URLs from file
jshunter -l urls.txt

# Pipe URLs from stdin
cat urls.txt | grep "\.js" | jshunter

# Complete security analysis - find secrets, API keys, and credentials
jshunter -u "https://example.com/app.js" -s -x -F

# Full analysis suite with deobfuscation and all security tools
jshunter -u "https://target.com/app.js" -d -m -e -s -x -P -g -F -B -L

# Professional assessment with source map analysis
jshunter -u "https://target.com/bundle.js" -d -m -s -g -F

# Export comprehensive results to structured formats
jshunter -l targets.txt -s -x -F -g -j -o security_findings.json

# Stealth scanning with Burp Suite integration
jshunter -l targets.txt -p 127.0.0.1:8080 -s -g -F -n -o burp_findings.txt

# Scanning through SOCKS5 proxy (Tor, SSH tunnel, etc.)
jshunter -l targets.txt -p socks5://127.0.0.1:9050 -s -x -F

# Rate-limited professional scanning with authentication
jshunter -l urls.txt -R 2000 -H "Authorization: Bearer token" -s -x -F -g -q

# Complete endpoint and parameter discovery
jshunter -l urls.txt -ep -P -PU -L -w 2

# Advanced obfuscation analysis with context detection
jshunter -f obfuscated.js -d -z -e -s -v
```
---

## कमांड संदर्भ

`jshunter --help` के साथ कभी भी पूरी सहायता प्राप्त करें```
Usage:
  -u,  --url URL                Input a URL
  -l,  --list FILE.txt          Input a file with URLs (.txt)
  -f,  --file FILE.js           Path to JavaScript file
       --har FILE               Ingest a Chrome DevTools HAR archive

Basic Options:
  -t,  --threads INT            Number of concurrent threads (default: 5)
  -c,  --cookies <cookies>      Authentication cookies for protected resources
  -p,  --proxy host:port        HTTP/SOCKS5 proxy (e.g., 127.0.0.1:8080 for Burp Suite)
  -q,  --quiet                  Suppress ASCII art output
       --no-color               Disable ANSI color (auto-off when not a TTY)
  -o,  --output FILENAME        Output file path
  -r,  --regex <pattern>        RegEx for filtering results
       --update, --up           Update the tool to latest version
  -ep, --end-point              Extract endpoints from JavaScript files
  -k,  --skip-tls               Skip TLS certificate verification
  -fo, --found-only             Only show results when sensitive data is found

HTTP Configuration:
  -H,  --header "Key: Value"    Custom HTTP headers (repeatable, including Auth)
  -U,  --user-agent UA          Custom User-Agent string or file path
  -R,  --rate-limit MS          Request rate limiting delay (milliseconds)
  -T,  --timeout SEC            HTTP request timeout (seconds)
  -y,  --retry INT              Retry attempts for failed requests (default: 2)
       --per-host INT           Per-host outbound concurrency cap (default: 4)
       --max-bytes N            Cap response body read in bytes (default: 32MiB)
       --allow-internal         Permit localhost / RFC1918 / link-local targets
       --cache-dir DIR          Persist responses on disk; revalidate via ETag

JavaScript Analysis:
  -d,  --deobfuscate            Deobfuscate minified and obfuscated JavaScript
  -m,  --sourcemap              Fetch and parse source maps + sourcesContent[]
  -e,  --eval                   Analyze dynamic code execution (eval, Function)
  -z,  --obfs-detect            Detect code obfuscation patterns and techniques
       --inline-html            Scan inline <script> tags + SRI/CSP in HTML responses
       --csp-origins            Emit CSP-allowed origins as candidate endpoints

Security Analysis:
  -s,  --secrets                Detect API keys, tokens, and credentials
  -x,  --tokens                 Extract JWT and authentication tokens
  -P,  --params                 Discover hidden parameters and variables
  -PU, --param-urls             Advanced parameter extraction with URL context
  -i,  --internal               Filter for internal/private endpoints
  -g,  --graphql                Analyze GraphQL endpoints and queries
  -B,  --bypass                 Detect WAF bypass patterns and techniques
  -F,  --firebase               Analyze Firebase configurations and keys
  -L,  --links                  Extract and analyze all embedded links

Detection Tuning:
  -mc, --min-confidence FLOAT   Minimum confidence (0.0-1.0) for a finding (default: 0.50)
  -sc, --show-confidence        Print [conf=X.XX] alongside each finding
       --no-fp-filter           Disable the false-positive filter (debug)
       --ignore-file FILE       Permanent suppressions (.jshunterignore)
       --diff PREVIOUS.json     Report only NEW findings vs previous JSON envelope
       --rules-file FILE.json   Load an external JSON rule pack
       --only-rules id,glob     Run only matching rules (supports * glob)
       --disable-rule id,glob   Disable matching rules (supports * glob)

Structural Engine:
       --no-structural          Disable byte-level classification (regex-only, v0.7 behaviour)
       --include-public         Report values published by design and non-granting identifiers
       --min-severity LEVEL     Report floor: info|low|medium|high|critical
  -G,  --chunk-graph            Enumerate lazily loaded chunks and client routes

Verification:
       --verify                 Probe findings against provider read-only endpoints
       --verify-timeout SEC     Timeout per verification probe (default: 10)
       --verify-workers INT     Concurrent verifier worker pool (default: 8)

Scope & Discovery:
  -w,  --crawl DEPTH            Recursive JavaScript discovery depth (default: 1)
  -D,  --domain DOMAIN          Limit analysis to specific domain
  -E,  --ext                    Filter by JavaScript file extensions
       --robots                 Fetch /robots.txt for each input host and exit

Output Formats:
  -j,  --json                   Structured JSON output (schema_version 2)
       --ndjson                 Newline-delimited JSON (jq / SIEM streaming)
       --sarif                  SARIF 2.1.0 (GitHub code-scanning compatible)
  -C,  --csv                    CSV format for spreadsheet analysis
  -v,  --verbose                Detailed analysis and debug output
  -n,  --burp                   Burp Suite compatible export format
       --stats                  Per-stage counters on stderr at end of run

Registry:
       --list-rules             Print the rule registry as a table and exit
       --explain RULE_ID        Print full rule details and exit
       --self-test              Run rule registry against built-in TP/FP fixtures

  -h,  --help                   Display this help message
```
### विश्वास मॉडल
```

---

[Read more](https://github.com/cc1a2b/jshunter)
टूल डाउनलोड करें

सबसे लोकप्रिय

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 अंतिम OSINT टूलकिट: जाँच ग्राफ़, विश्वास स्कोरिंग, उपनाम परिवार, मानचित्र, टाइमलाइन और रिपोर्ट। 49 मॉड्यूल, 400+ साइटें, किसी API कुंजी की आवश्यकता नहीं।

    911
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # घोस्टलॉक वन-टैप निष्पादन ऐप (CVE-2026-43499)

    548
  • 3

    redforge

    cybersecurity91/redforge

    ब्राउज़र-साइड रेड टीम टूलकिट, जिसमें रेकॉन, पेलोड जनरेशन, क्रेडेंशियल हमलों, क्रिप्टो, एन्कोडिंग और एंगेजमेंट रिपोर्टिंग के लिए 102 ऑफ़लाइन टूल्स हैं।

    366
  • 4

    ARTEX

    baarai/artex

    प्लानर/वर्कर एजेंट, एसेट और एक्सप्लोरेशन ग्राफ़, MITM ट्रैफ़िक रिकॉर्डिंग, और भेद्यता पुनःपरीक्षण के साथ LLM मल्टी-एजेंट स्वायत्त पेनेट्रेशन टेस्टिंग प्लेटफ़ॉर्म।

    362
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT प्लेटफ़ॉर्म जो Shadowserver रिपोर्ट्स को MongoDB में इनजेस्ट करता है और उन्हें इंटरैक्टिव मैप्स, विश्लेषण, निष्कर्षों, सलाहों और कार्यकारी डैशबोर्ड के रूप में पुनः प्रस्तुत करता है।

    311
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    AI-मूल साइबरसुरक्षा के लिए कार्रवाई की प्रणाली—जहाँ इरादा नियंत्रित निष्पादन बन जाता है, साक्ष्य परिचालन स्मृति बन जाता है, और हर ऑपरेशन अगले को बेहतर बनाता है।

    287

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →