
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.
# JSHunter
<div align="center">
[](LICENSE)
[](https://golang.org)
[](https://github.com/cc1a2b/jshunter/releases)
[](https://github.com/cc1a2b/jshunter/stargazers)
[](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>