Skip to content
KitploitKITPLOIT
ToolsBlog
Log in
Einreichen
ToolsBlog
Einreichen

Hacking-, PenTest- und Cybersicherheits-Tools für Ihr Sicherheitsarsenal!

Kitploit ist ein Verzeichnis von Hacking-, Cybersicherheits- und Pentesting-Tools. Entdecken Sie die neuesten Projekt-Updates, um Schwachstellen zu finden, Systeme zu analysieren, Tests zu automatisieren und Ihre Sicherheit zu stärken.

FeedsKontaktDatenschutz© 2026 Kitploit

Tool-Verzeichnis

Kategorien

Alle Kategorien anzeigen
Loading categories
JShunter — jshunter ist ein Befehlszeilen-Tool zur Analyse von JavaScript-Dateien und zum Extrahieren von Endpunkten. Dieses Tool ist auf die Identifizierung sensibler Daten wie API-Endpunkte und potenzieller Sicherheitslücken spezialisiert und ist damit eine unverzichtbare Ressource für Bug-Bounty-Jäger und Sicherheitsforscher. | Kitploit
Tools/GitHubGitHub/cc1a2b/jshunter
AufklärungStatische Code-Analyse (SAST)SchwachstellenanalyseDynamische Code-Analyse (DAST)WAF-UmgehungWebsicherheitPenetrationstestsSecret-ErkennungAPI-Sicherheit
GitHubcc1a2b/jshunter

JShunter

5295969vor 1 MonatVon Kitploit geprüft

Über

Repository anzeigen

jshunter ist ein Befehlszeilen-Tool zur Analyse von JavaScript-Dateien und zum Extrahieren von Endpunkten. Dieses Tool ist auf die Identifizierung sensibler Daten wie API-Endpunkte und potenzieller Sicherheitslücken spezialisiert und ist damit eine unverzichtbare Ressource für Bug-Bounty-Jäger und Sicherheitsforscher.

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

**Professionelles Tool zur JavaScript-Sicherheitsanalyse**

*Vollständige Endpunkt-Erkennung, Erkennung sensibler Daten und erweiterte Code-Analyse für Sicherheitsexperten*

</div>

## Über

**JSHunter** ist ein umfassendes Kommandozeilen-Tool für JavaScript-Sicherheitsanalyse und Endpunkt-Erkennung. Es wurde für Sicherheitsexperten, Penetrationstester und Entwickler entwickelt und bietet Analysefunktionen auf Unternehmensniveau mit hochpräzisen Erkennungsalgorithmen und professionellen Berichtsfunktionen.

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

*JSHunter in Aktion — eine echte Terminalaufnahme der CLI (alle gezeigten Secrets sind gefälschte Testdaten)*

---

## Inhaltsverzeichnis

- [Über](#about)
- [Funktionen](#features)
- [Installation](#installation)  
- [Schnellstart](#quick-start)
- [Anwendungsbeispiele](#usage-examples)
- [Befehlsreferenz](#command-reference)
- [Erweiterte Nutzung](#advanced-usage)
- [Mitwirken](#contributing)
- [Lizenz](#license)
- [Support](#support)

---

## Funktionen

### Kernfunktionen
- **Umfassende Endpunkt-Erkennung**: Extrahiert automatisch URLs, API-Endpunkte und versteckte Parameter aus JavaScript-Dateien
- **Erweiterte Sicherheitsanalyse**: Identifiziert API-Schlüssel, JWT-Token, Anmeldedaten und potenzielle Schwachstellen mit hoher Genauigkeit
- **Flexible Eingabemethoden**: Unterstützt URLs, Dateilisten, lokale Dateien, stdin-Piping und rekursive Erkennung
- **Hochleistungsarchitektur**: Multithreaded-Parallelverarbeitung mit intelligenter Ratenbegrenzung
- **Professionelle Stealth-Funktionen**: Proxy-Unterstützung, benutzerdefinierte Header, User-Agent-Rotation und Bypass-Erkennung

### Intelligente Erkennungs-Engine
> **Genauigkeit auf Unternehmensniveau mit fortschrittlichen Analysalgorithmen**

- **Intelligente Base64-Erkennung**: Hochpräzise Filterung eliminiert Fehlalarme durch Medieninhalte und kodierte Daten
- **Professionelle Schnittstelle**: Unternehmensgerechte Terminologie, Dokumentation und umfassende Berichtsformate
- **Kontextbewusste Analyse**: Fortschrittliche Algorithmen unterscheiden echte Sicherheitstoken von kodierten Mediendaten
- **Entropie-Analyse**: Mathematische Algorithmen identifizieren echte Sicherheitstoken und Anmeldedaten mit Präzision

### Strukturelle Erkennungs-Engine

JSHunter parst das JavaScript, das es scannt, anstatt es nur per Musterabgleich zu prüfen. Ein
Single-Pass-ECMAScript-Scanner klassifiziert jedes Byte der Antwort als String-
Literal, Template-Literal, Kommentar, Regular-Expression-Literal oder Code, und die
Erkennungsregeln werden gegen diese Klassifizierung ausgewertet.

Das ist wichtig, weil eine Regex keine Ahnung hat, was sie gematcht hat. Dieselben vierzig Base64-
Zeichen bedeuten „Credential" innerhalb eines String-Literals, „Chunk-Hash" innerhalb
eines minifizierten Bezeichners und gar nichts, wenn sie die Naht zwischen zwei
benachbarten Token überspannen. Zu wissen, welcher Fall vorliegt, ersetzt einen Haufen Näherungs-
Heuristiken durch eine strukturelle Antwort:

- **Region-Gating**: Ein Treffer innerhalb eines Regex-Literals ist ein Muster, kein Wert.
  Ein Treffer, der eine Token-Grenze überschreitet, ist kein einzelnes Literal. Ein Treffer im Code
  ist ein Bezeichnerfragment. Alle drei werden kategorisch verworfen.
- **Bindungskontext**: Statt ein festes Zeichenfenster nach dem
  Wort `key` zu durchsuchen, rekonstruiert die Engine den Bezeichner oder Property-Key, an den der Wert
  tatsächlich gebunden ist — `const stripeSecret = "..."` liest sich ganz anders als
  `{contentHash: "..."}`, und eine rein formbasierte Regel erfordert nun diese Bindung.
- **Geschwister-Schlüsselmengen**: Die Mitglieder einer Firebase-Web-Konfiguration, einer Algolia-Such-
  konfiguration, einer Segment-Analytics-Konfiguration und eines Supabase-Browser-Clients werden
  anhand der Form des Objekts erkannt, in dem sie sich befinden.
- **Wertform**: Digests, UUIDs, Fließtext, Pfade, Platzhalter und Base64, das
  zu einem PNG, einer Schriftart, einem JSON-Dokument oder einem englischen Satz dekodiert, werden jeweils
  als das identifiziert, was sie sind.
- **Exposure-Klassifizierung**: Werte, die der Aussteller absichtlich veröffentlicht — Stripe-
  Publishable-Keys, Mapbox-Public-Tokens, Supabase-Anon-JWTs, die aus ihrem eigenen
  `role`-Claim gelesen werden, Twilio-SIDs — werden klassifiziert statt als Leaks gemeldet.
  `--include-public` meldet sie trotzdem.
- **Dateirelative Surprisal**: Ein Zeichenübergangsmodell, das aus der gescannten
  Datei erstellt wird, bewertet, wie unähnlich der Rest dieser Datei einem Kandidaten liest.

Jede Verwerfung ist daran gebunden, dass der Body mit Sicherheit JavaScript oder JSON ist.
Bei allem anderen — einer `.env`-Datei, Fließtext, rohem HTML — liefert die Engine
Hinweise, unterdrückt aber nie, sodass eine falsch klassifizierte Eingabe niemals ein Secret verbergen kann.
`--no-structural` schaltet die gesamte Schicht ab und stellt das Verhalten von v0.7 wieder her.

Funde tragen die Begründung als `evidence`-Objekt in `--json`, `--ndjson` und
der SARIF-Property-Bag mit sich:```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` meldet, was jede Stufe verworfen hat, sodass die Pipeline auditierbar bleibt.

### Chunk-Graph und Routen-Erkennung

Eine moderne Anwendung liefert ein Einstiegs-Bundle und mehrere hundert lazy
geladene Chunks aus, deren URLs zur Laufzeit aus einem Manifest zusammengesetzt
werden, das der Bundler inline einbettet. Nichts verlinkt auf sie, sodass ein
Crawler sie nie sieht. `-G` rekonstruiert dieses Manifest
und gibt die vollständige Asset-Liste und die Client-Routentabelle aus:```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
```
Unterstützte Runtimes: webpack 4 und 5 (`__webpack_require__.u`, `miniCssF`,
`jsonpScriptSrc`), Next.js-Build-Manifeste, Vite und Rollup (`__vite__mapDeps`,
`__vitePreload`), einfache dynamische `import()`, sowie Routentabellen von React Router,
Vue Router und Angular. Die Ausgabe ist tabulatorgetrennt und dedupliziert, sodass sie
direkt als Eingabeliste für einen Folge-Scan weiterverwendet werden kann:```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
```
### Professionelle HTTP- & Netzwerk-Suite
<details>
<summary><strong>Netzwerkkonfiguration auf Unternehmensniveau</strong></summary>

**Authentifizierung & Header:**
- **Benutzerdefinierte Header** (`-H`): Wiederholbare Authentifizierungs-Header und benutzerdefinierte Anfrage-Header
- **Cookie-Verwaltung** (`-c`): Sitzungs-Cookies für den Zugriff auf geschützte Ressourcen
- **User-Agent-Steuerung** (`-U`): Benutzerdefinierte UA-Strings oder dateibasierte Rotation für Stealth

**Leistung & Zuverlässigkeit:**
- **Ratenbegrenzung** (`-R`): Konfigurierbare Anfrageverzögerungen (Millisekunden) zur Vermeidung von Erkennung
- **Intelligente Timeouts** (`-T`): Benutzerdefinierte Timeout-Einstellungen für verschiedene Netzwerkbedingungen
- **Intelligenter Retry** (`-y`): Automatischer Wiederholungsmechanismus mit exponentiellem Backoff für fehlgeschlagene Anfragen

**Professionelle Integration:**
- **Proxy-Unterstützung** (`-p`): Vollständige Burp Suite- und benutzerdefinierte Proxy-Integration (HTTP/HTTPS/SOCKS5)
- **TLS-Flexibilität** (`-k`): Optionale Umgehung der Zertifikatsüberprüfung für Testumgebungen
- **Thread-Steuerung** (`-t`): Konfigurierbare gleichzeitige Anfrageverarbeitung für optimale Leistung

> **Funktionen für Sicherheitsexperten**: Entwickelt für Penetrationstests und Sicherheitsbewertungen
> **Beispiel**: `jshunter -l targets.txt -p 127.0.0.1:8080 -H "Authorization: Bearer token" -R 1000`

</details>

### Erweiterte JavaScript-Analyse
<details>
<summary><strong>Komplette Code-Analyse- & Deobfuskierungs-Suite</strong></summary>

**Kernanalysewerkzeuge:**
- **Deobfuskierungs-Engine** (`-d`): Entpackt minifiziertes und obfuskiertes JavaScript für tiefgehende Analysen
- **Source-Map-Parser** (`-m`): Extrahiert und analysiert Originalquellcode aus Source Maps
- **Obfuskierungserkennung** (`-z`): Identifiziert und klassifiziert Obfuskierungstechniken und -muster

**Dynamische Analyse:**
- **Eval-Analyse** (`-e`): Analysiert dynamische Codeausführung (`eval()`, `Function()`, Laufzeitgenerierung)

**Code-Intelligenz:**
- **Mustererkennung**: Identifiziert gängige JavaScript-Frameworks und -Bibliotheken
- **Codestrukturanalyse**: Kartiert Anwendungsarchitektur und Datenflüsse
- **Kontextbewusste Erkennung**: Versteht den Codekontext zur Reduzierung von Fehlalarmen

> **Professionelle Nutzung**: Kombinieren Sie Analysewerkzeuge mit Sicherheitserkennung für maximale Abdeckung
> **Beispiel**: `jshunter -u target.js -d -m -e -s -g` (vollständige Deobfuskierung + Sicherheitsanalyse)

</details>

### Sicherheitsanalyse-Suite
<details>
<summary><strong>Komplettes Toolkit zur Sicherheitsbewertung</strong></summary>

**Kern-Sicherheitserkennung:**
- **Secrets-Erkennung** (`-s`): API-Schlüssel, Zugriffstoken, Passwörter und hartcodierte Anmeldedaten
- **JWT-Token-Analyse** (`-x`): Extraktion, Validierung und Payload-Inspektion von Authentifizierungstoken
- **Firebase-Sicherheit** (`-F`): Konfigurationsanalyse, API-Schlüssel und Datenbank-URL-Erkennung

**Erweiterte Analyse:**
- **Parameter-Entdeckung** (`-P`): Versteckte Formularparameter, Variablen und Konfigurationsschlüssel
- **URL-Parameter-Extraktion** (`-PU`): Erweiterte Parameteranalyse mit vollständigem URL-Kontext
- **GraphQL-Analyse** (`-g`): Schema-Erkennung, Query-Extraktion und Endpunkt-Entdeckung
- **WAF-Bypass-Erkennung** (`-B`): Sicherheitsumgehungsmuster und Evasion-Techniken

**Umfang & Kontext:**
- **Interne Endpunkt-Filterung** (`-i`): Identifizierung und Klassifizierung privater/interner Ressourcen
- **Link-Analyse** (`-L`): Umfassende URL-Extraktion und Beziehungszuordnung

> **Professioneller Tipp**: Kombinieren Sie Flags für umfassende Analysen (z. B. `jshunter -u target.js -s -x -F -g`)

</details>

### Umfang & Entdeckung
<details>
<summary><strong>Intelligentes Crawling & Targeting</strong></summary>

- **Rekursive Entdeckung**: Mehrstufiges Crawling von JavaScript-Dateien
- **Domain-Eingrenzung**: Fokussierung der Analyse auf bestimmte Domains
- **Erweiterungsfilterung**: Gezielte Auswahl bestimmter JavaScript-Dateitypen

</details>

### Professionelle Reporting- & Export-Suite
<details>
<summary><strong>Ausgabe & Integration auf Unternehmensniveau</strong></summary>

**Kern-Ausgabeformate:**
- **Konsolenanzeige**: Farbcodierte Terminalausgabe mit professioneller Formatierung und klarer Kategorisierung
- **Dateiexport** (`-o`): Speichern umfassender Ergebnisse an benutzerdefinierten Dateispeicherorten
- **JSON-Export** (`-j`): Strukturiertes Datenformat für Automatisierung und programmatische Verarbeitung
- **CSV-Export** (`-C`): Tabellenkalkulationskompatibles Format für Management-Reporting und Analyse

**Professionelle Integration:**
- **Burp Suite-Export** (`-n`): Direkte Integration mit Burp Suite Professional für sofortige Tests
- **Regex-Filterung** (`-r`): Benutzerdefinierter Musterabgleich für gezielte ErgebnisFilterung
- **Ausführliche Analyse** (`-v`): Detaillierte Analyseausgabe mit Debugging-Informationen und Kontext

**Ergebnisverwaltung:**
- **Clean-Modus** (`--found-only`): Ausblenden leerer Ergebnisse für fokussiertes Sicherheits-Reporting
- **Quiet-Modus** (`-q`): Unterdrückung des Banners für automatisierte Skripterstellung und CI/CD-Integration

> **Reporting-Workflow**: Verwenden Sie JSON für Automatisierung, CSV für Management-Berichte, Burp-Export für sofortige Tests
> **Beispiel**: `jshunter -l targets.txt -s -j -o security-findings.json` (strukturierter Sicherheitsbericht)

</details>

---

## Installation

### Go Install (Empfohlen)```bash
# Install JSHunter
go install -v github.com/cc1a2b/jshunter/cmd/jshunter@latest

# Verify installation
jshunter --help
```
### Aus dem Quellcode erstellen```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go build -o jshunter ./cmd/jshunter
```
### Systemanforderungen
- **Go 1.22.5+** (zum Erstellen aus dem Quellcode)
- **Linux, macOS oder Windows** (64-Bit-Architektur)
- **Netzwerkkonnektivität** für die Remote-JavaScript-Analyse

---

## Schnellstart

### Grundlegende Analyse```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
```
### Vollständige Sicherheitsanalyse```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
```
---

## Anwendungsbeispiele```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
```
---

## Befehlsreferenz

Erhalte jederzeit die vollständige Hilfe mit `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
```
### Konfidenzmodell

Jeder Treffer einer Secret-Klasse wird in `[0.0, 1.0]` bewertet. Die Bewertung beginnt bei einem regelbasierten Prior und wird angepasst durch:

| Signal                                         | Auswirkung                   |
|------------------------------------------------|------------------------------|
| Quellpfad sieht wie ein Vendor-/Chunk-Bundle aus | −0.15                      |
| Umgebender Kontext enthält Fixture-Formulierung | −0.30                       |
| Providerspezifischer Validator bestanden       | +0.10                        |
| Erforderliches Kontext-Schlüsselwort vorhanden (generische Regel) | +0.05       |
| Shannon-Entropie ≥ 4.5                         | +0.05                        |
| Zeichenklassen-Diversität ≥ 3                  | +0.05                        |
| Treffer in der Vendor-Noise-Denylist           | vor der Bewertung verworfen  |
| Länge / Entropie unterhalb der Regel-Untergrenze | vor der Bewertung verworfen |
| Zeile ist ein `//# sourceMappingURL=`-Marker   | vor der Bewertung verworfen  |

Der Standardwert `--min-confidence 0.50` filtert den langen Schwanz reiner Muster-Treffer heraus. Verwenden Sie `--min-confidence 0.80` für hochpräzise Triage, `--no-fp-filter` für rohe, ungefilterte Ausgabe.

### Provider-Validatoren

Ein Validator ist eine regelbasierte Konsistenzprüfung, die *nach* dem Regex-Match ausgeführt wird.
Er ist die stärkste Verteidigung gegen False Positives: Ein zufälliger String, der
zufällig der Form entspricht, muss trotzdem eine Prüfsumme, eine strukturelle Dekodierung oder
einen Längen-/Zeichensatz-Nachweis überstehen, bevor er gemeldet wird (und das Bestehen fügt `+0.10` hinzu).

| Provider | Validator                                                                |
|----------|--------------------------------------------------------------------------|
| AWS      | Präfix-Familie (`AKIA/ASIA/A3T…`) + 16-Zeichen-base32-Body                |
| Stripe   | Schlüssel-Familie (`sk/rk/pk_live/test_`) und `whsec_`-Webhook-base62-Body |
| GitHub   | CRC32-base62-Prüfsumme verifiziert gegen zufälligen Body                  |
| OpenAI   | Familien-Präfix + Längenfenster (`sk-/sk-proj-/sk-svcacct-`)              |
| Slack    | Bindestrich-Segment-Form (numerische innere Segmente, alphanumerischer Tail) |
| JWT      | base64url-dekodierter JSON-Header mit `alg`-Feld + JSON-Payload           |
| Twilio   | 32-Hex-Body + Entropie-Gate                                               |
| Azure    | `AccountKey=`-base64-Body dekodiert zu exakt 64 Bytes; AD `…<digit>Q~…`   |
| Telegram | `<8-10 digit id>:AA…`-Split, base64url-Secret + Entropie-Gate             |
| Intercom | base64 dekodiert zu einer `tok:`-präfixierten Payload                     |
| Sentry   | `sntrys_`-Org-Token-Payload base64-dekodiert zu JSON mit `url`-Claim      |
| Terraform| `<14>.atlasv1.<60-70>`-Dreisegmentstruktur                                |
| Square   | `sq0atp-/sq0csp-/sq0idp-`-Familie + exakte Body-Länge + Entropie          |
| Braintree| `access_token$<env>$<16 base36>$<32 hex>`-Viersegmentstruktur            |
| Airtable | `pat<14>.<64 hex>`-Zweisegment-Split                                      |
| Postman  | `PMAK-<24 hex>-<34 hex>`-Segmentlängen + Entropie                         |
| Database | Connection-URI-Passwort abgelehnt, wenn templated/default/niedrig-entropisch |

### Provider-Abdeckung

Die kuratierte Registry enthält **85+ Detektoren**, die Cloud- & Secret-Manager
(AWS, Azure, GCP/PKCS#8, HashiCorp Vault, Terraform, Fly.io, Tailscale), Versionskontrolle
& CI/CD (GitHub, GitLab, Docker Hub, Atlassian, Sentry, CircleCI,
Buildkite), Zahlungen (Stripe, Square, Braintree, Plaid), KI/LLM-Provider
(OpenAI, Anthropic, Groq, Perplexity, Replicate, OpenRouter, Fireworks,
HuggingFace), Messaging (Slack, Discord, Telegram, Twilio, Intercom, SendGrid,
Mailgun), SaaS & Datenbanken (Notion, Airtable, Figma, Postman, Databricks,
PlanetScale, Grafana, New Relic, Dropbox, RubyGems, Supabase) und PKI-Material
(RSA/EC/DSA/OpenSSH/PGP/PKCS#8-Private-Keys, PuTTY `.ppk`, Datenbank-Connection-
URIs) abdecken. Führen Sie `jshunter --list-rules` für die maßgebliche Tabelle und
`jshunter --explain <rule_id>` für Muster, Validator und Fixtures einer einzelnen Regel aus.
Präfixlose „Bare-Hash"-Formen werden nur ausgeliefert, wenn ein struktureller
Validator oder ein obligatorisches Kontext-Gate sie frei von False Positives halten kann.

---

## Erweiterte Nutzung

### Professionelle Sicherheitsbewertung```bash
# Complete security analysis with all tools
jshunter -l targets.txt -d -m -e -z -s -x -P -PU -g -F -B -L -j -v -o complete_assessment.json

# Advanced deobfuscation and analysis pipeline
jshunter -l targets.txt -d -m -z -e -s -g -F --found-only -o deobfuscated_findings.json

# Stealth reconnaissance with rate limiting and custom headers
jshunter -l targets.txt -R 2000 -U "Mozilla/5.0..." -H "X-Forwarded-For: 1.1.1.1" -s -x -F -q

# Professional penetration testing through proxy
jshunter -l targets.txt -p 127.0.0.1:8080 -s -x -g -F -B -n -o burp_comprehensive.txt

# Deep parameter and endpoint discovery
jshunter -l targets.txt -ep -P -PU -L -w 3 -i -j -o endpoint_discovery.json
```
### Integration in Unternehmen und Automatisierung```bash
# CI/CD Security Pipeline Integration
jshunter -f dist/bundle.js -d -s -x -F -j --found-only > security-scan.json

# Comprehensive automated security reporting
jshunter -l production-js.txt -d -s -x -P -g -F -B -C -o enterprise-security-report.csv

# Source map analysis for development security
jshunter -f app.js -m -s -x -F -v -o sourcemap-analysis.json

# Firebase and GraphQL focused assessment
jshunter -l targets.txt -g -F -L -j -o api_security_findings.json
```
---

## Mitwirken

Wir freuen uns über Beiträge! So kannst du helfen:

- **Fehler melden** über [GitHub Issues](https://github.com/cc1a2b/jshunter/issues)
- **Funktionen vorschlagen** oder Verbesserungen
- **Dokumentation verbessern**
- **Pull Requests einreichen** mit Erweiterungen

### Entwicklungsumgebung einrichten```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go mod tidy
go build -o jshunter ./cmd/jshunter
```
---

## Lizenz

JSHunter wird unter der **MIT-Lizenz** veröffentlicht. Siehe [LICENSE](https://github.com/cc1a2b/jshunter/blob/master/LICENSE) für Details.```
Copyright (c) 2024-2026 Hussain Alsharman
Licensed under MIT License - free for commercial and personal use
```
---

##  Support

Wenn JSHunter bei deiner Sicherheitsforschung oder professionellen Arbeit hilft:

<div align="center">

**Star dieses Repo** • **Folge [@cc1a2b](https://twitter.com/cc1a2b)** • **Teile es mit anderen**

</div>

---

<div align="center">

**JSHunter - Professionelle JavaScript-Sicherheitsanalyse**

*Entwickelt von [cc1a2b](https://github.com/cc1a2b) für die Sicherheits-Community*

</div>
Tool herunterladen

Beliebteste

Alle anzeigen →

Entdecken Sie die meistgenutzten Tools unserer Community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Das ultimative OSINT-Toolkit: Untersuchungsgraph, Konfidenzbewertung, Alias-Familien, Karte, Zeitleiste und Berichte. 49 Module, 400+ Websites, keine API-Schlüssel erforderlich.

    806
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    GhostLock One-Tap Execution App (CVE-2026-43499)

    523
  • 3

    ARTEX

    baarai/artex

    LLM-basierte Multi-Agenten-Plattform für autonome Penetrationstests mit Planer-/Worker-Agenten, Asset- und Explorationsgraphen, MITM-Verkehrsaufzeichnung und Schwachstellen-Retesting.

    441
  • 4

    redforge

    cybersecurity91/redforge

    Browser-seitiges Red-Team-Toolkit mit 102 Offline-Tools für Recon, Payload-Generierung, Credential-Angriffe, Krypto, Encoding und Engagement-Reporting.

    346
  • 5

    looking-glass

    anonghosty/looking-glass

    CSIRT-Plattform, die Shadowserver-Berichte in MongoDB einliest und sie als interaktive Karten, Analysen, Findings, Advisories und Executive-Dashboards wiedergibt.

    270
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Das System der Handlung für KI-native Cybersicherheit – wo Absicht zu gesteuerter Ausführung wird, Beweise zu operativem Gedächtnis werden und jeder Einsatz den nächsten verbessert.

    264

Alle Tools erkunden

Durchsuchen Sie unsere Tool-Sammlung

Alle Tools anzeigen →