JSHunter

Strumento Professionale di Analisi della Sicurezza JavaScript

Scoperta completa di endpoint, rilevamento di dati sensibili e analisi avanzata del codice per professionisti della sicurezza

Informazioni

JSHunter è uno strumento completo da riga di comando per l'analisi della sicurezza JavaScript e la scoperta di endpoint. Progettato per professionisti della sicurezza, penetration tester e sviluppatori, offre capacità di analisi di livello enterprise con algoritmi di rilevamento ad alta precisione e funzionalità di reporting professionali.

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

JSHunter in azione — una cattura reale del terminale della CLI (ogni segreto mostrato è dato di test fittizio)

Funzionalità

Capacità Principali

Scoperta Completa di Endpoint: Estrae automaticamente URL, endpoint API e parametri nascosti dai file JavaScript
Analisi Avanzata della Sicurezza: Identifica chiavi API, token JWT, credenziali e potenziali vulnerabilità con alta precisione
Metodi di Input Flessibili: Supporta URL, elenchi di file, file locali, piping da stdin e scoperta ricorsiva
Architettura ad Alte Prestazioni: Elaborazione concorrente multi-thread con limitazione intelligente della velocità
Funzionalità Stealth Professionali: Supporto proxy, header personalizzati, rotazione dello user-agent e rilevamento bypass

Motore di Rilevamento Intelligente

Precisione di livello enterprise con algoritmi di analisi avanzati

Rilevamento Smart Base64: Il filtraggio ad alta precisione elimina i falsi positivi da contenuti multimediali e dati codificati
Interfaccia Professionale: Terminologia, documentazione e formati di reporting completi di livello enterprise
Analisi Sensibile al Contesto: Algoritmi avanzati distinguono i token di sicurezza reali dai dati multimediali codificati
Analisi dell'Entropia: Algoritmi matematici identificano token di sicurezza e credenziali autentici con precisione

Suite Professionale HTTP e di Rete

Configurazione di Rete di Livello Enterprise

Autenticazione e Header:

Header Personalizzati (-H): Header di autenticazione ripetibili e header di richiesta personalizzati
Gestione Cookie (-c): Cookie di sessione per accedere a risorse protette
Controllo User-Agent (-U): Stringhe UA personalizzate o rotazione basata su file per la stealth

Prestazioni e Affidabilità:

Limitazione della Velocità (-R): Ritardi di richiesta configurabili (millisecondi) per evitare il rilevamento
Timeout Intelligenti (-T): Impostazioni di timeout personalizzate per diverse condizioni di rete
Retry Intelligente (-y): Meccanismo di retry automatico con backoff esponenziale per richieste fallite

Integrazione Professionale:

Supporto Proxy (-p): Integrazione completa con Burp Suite e proxy personalizzati (HTTP/HTTPS/SOCKS5)
Flessibilità TLS (-k): Bypass opzionale della verifica dei certificati per ambienti di test
Controllo Thread (-t): Gestione configurabile delle richieste concorrenti per prestazioni ottimali

Analisi Avanzata JavaScript

Suite Completa di Analisi del Codice e Deoffuscamento

Strumenti di Analisi Principali:

Motore di Deoffuscamento (-d): Decomprime JavaScript minificato e offuscato per un'analisi approfondita
Parser Source Map (-m): Estrae e analizza il codice sorgente originale dalle source map
Rilevamento Offuscamento (-z): Identifica e classifica tecniche e pattern di offuscamento

Analisi Dinamica:

Analisi Eval (-e): Analizza l'esecuzione dinamica del codice (eval(), Function(), generazione runtime)

Intelligenza del Codice:

Riconoscimento Pattern: Identifica framework e librerie JavaScript comuni
Analisi della Struttura del Codice: Mappa l'architettura dell'applicazione e i flussi di dati
Rilevamento Sensibile al Contesto: Comprende il contesto del codice per ridurre i falsi positivi

Utilizzo Professionale: Combina gli strumenti di analisi con il rilevamento della sicurezza per una copertura massima Esempio: jshunter -u target.js -d -m -e -s -g (deoffuscamento completo + analisi della sicurezza)

Suite di Analisi della Sicurezza

Toolkit Completo per la Valutazione della Sicurezza

Rilevamento Principale della Sicurezza:

Rilevamento Segreti (-s): Chiavi API, token di accesso, password e credenziali hardcoded
Analisi Token JWT (-x): Estrazione, validazione e ispezione del payload dei token di autenticazione
Sicurezza Firebase (-F): Analisi della configurazione, chiavi API e rilevamento URL del database

Analisi Avanzata:

Scoperta Parametri (-P): Parametri di modulo nascosti, variabili e chiavi di configurazione
Estrazione Parametri URL (-PU): Analisi avanzata dei parametri con contesto URL completo
Analisi GraphQL (-g): Rilevamento schema, estrazione query e scoperta endpoint
Rilevamento Bypass WAF (-B): Pattern di bypass della sicurezza e tecniche di evasione

Ambito e Contesto:

Filtraggio Endpoint Interni (-i): Identificazione e classificazione di risorse private/interne
Analisi Link (-L): Estrazione completa degli URL e mappatura delle relazioni

Ambito e Scoperta

Crawling Intelligente e Targeting

Scoperta Ricorsiva: Crawling di file JavaScript a più livelli di profondità
Ambito Dominio: Concentra l'analisi su domini specifici
Filtraggio Estensioni: Punta a tipi specifici di file JavaScript

Suite Professionale di Reporting ed Esportazione

Output e Integrazione di Livello Enterprise

Formati di Output Principali:

Visualizzazione Console: Output terminale color-coded con formattazione professionale e categorizzazione chiara
Esportazione File (-o): Salva risultati completi in posizioni file personalizzate
Esportazione JSON (-j): Formato dati strutturato per automazione ed elaborazione programmatica
Esportazione CSV (-C): Formato compatibile con fogli di calcolo per reporting esecutivo e analisi

Integrazione Professionale:

Esportazione Burp Suite (-n): Integrazione diretta con Burp Suite Professional per test immediati
Filtraggio Regex (-r): Corrispondenza pattern personalizzata per il filtraggio mirato dei risultati
Analisi Verbosa (-v): Output di analisi dettagliato con informazioni di debug e contesto

Gestione Risultati:

Modalità Pulita (--found-only): Nasconde i risultati vuoti per un reporting di sicurezza mirato
Modalità Silenziosa (-q): Sopprime il banner per scripting automatizzato e integrazione CI/CD

Installazione

Installazione con Go (Consigliata)```bash

Install JSHunter

go install -v github.com/cc1a2b/jshunter/cmd/jshunter@latest

Verify installation

jshunter --help

### Compilare dal sorgente```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go build -o jshunter ./cmd/jshunter

Requisiti di Sistema

Go 1.22.5+ (per la compilazione dal sorgente)
Linux, macOS o Windows (architettura a 64 bit)
Connettività di rete per l'analisi remota di JavaScript

Avvio Rapido

Analisi di Base```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

### Analisi di Sicurezza Completa```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

Esempi di Utilizzo```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

---

## Riferimento ai Comandi

Ottieni la guida completa in qualsiasi momento con `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)

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

Modello di confidenza

Ogni corrispondenza di classe segreta viene valutata in [0.0, 1.0]. Il punteggio parte da una priorità per regola e viene aggiustato da:

Il valore predefinito --min-confidence 0.50 filtra la lunga coda di corrispondenze basate solo sul pattern. Usa --min-confidence 0.80 per un triage ad alta precisione, --no-fp-filter per un output grezzo e non filtrato.

Validatori dei provider

Un validatore è un controllo di coerenza per regola che viene eseguito dopo la corrispondenza della regex. È la difesa più forte contro i falsi positivi: una stringa casuale che per caso si adatta alla forma deve comunque superare un checksum, una decodifica strutturale o una prova di lunghezza/charset prima di essere segnalata (e superarne uno aggiunge +0.10).

Copertura dei provider

Il registro curato include 85+ rilevatori che coprono cloud e gestori di segreti (AWS, Azure, GCP/PKCS#8, HashiCorp Vault, Terraform, Fly.io, Tailscale), controllo versione e CI/CD (GitHub, GitLab, Docker Hub, Atlassian, Sentry, CircleCI, Buildkite), pagamenti (Stripe, Square, Braintree, Plaid), provider AI/LLM (OpenAI, Anthropic, Groq, Perplexity, Replicate, OpenRouter, Fireworks, HuggingFace), messaggistica (Slack, Discord, Telegram, Twilio, Intercom, SendGrid, Mailgun), SaaS e database (Notion, Airtable, Figma, Postman, Databricks, PlanetScale, Grafana, New Relic, Dropbox, RubyGems, Supabase) e materiale PKI (chiavi private RSA/EC/DSA/OpenSSH/PGP/PKCS#8, .ppk PuTTY, URI di connessione a database). Esegui jshunter --list-rules per la tabella autorevole e jshunter --explain <rule_id> per il pattern, il validatore e le fixture di ogni singola regola. Le forme "hash nudo" senza prefisso vengono distribuite solo quando un validatore strutturale o un gate di contesto obbligatorio può mantenerle prive di falsi positivi.

Utilizzo Avanzato

Valutazione di Sicurezza Professionale```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

### Integrazione Enterprise & Automazione```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

Contributing

Accogliamo con piacere i contributi! Ecco come puoi aiutarci:

Segnala bug tramite GitHub Issues
Suggerisci funzionalità o miglioramenti
Migliora la documentazione
Invia pull request con migliorie

Configurazione di sviluppo```bash

git clone https://github.com/cc1a2b/jshunter.git cd jshunter go mod tidy go build -o jshunter ./cmd/jshunter

## Licenza

JSHunter è rilasciato sotto la **Licenza MIT**. Consulta [LICENSE](https://github.com/cc1a2b/jshunter/blob/master/LICENSE) per i dettagli.```
Copyright (c) 2024-2026 Hussain Alsharman
Licensed under MIT License - free for commercial and personal use

Supporto

Se JSHunter ti aiuta nella tua ricerca sulla sicurezza o nel lavoro professionale:

Metti una stella a questo repo • Segui @cc1a2b • Condividi con altri

JSHunter - Analisi Professionale della Sicurezza JavaScript

Creato da cc1a2b per la community della sicurezza

Il percorso sorgente sembra un bundle vendor/chunk	−0.15
Il contesto circostante contiene formulazioni da fixture	−0.30
Validatore specifico del provider superato	+0.10
Parola chiave di contesto richiesta presente (regola generica)	+0.05
Entropia di Shannon ≥ 4.5	+0.05
Diversità delle classi di caratteri ≥ 3	+0.05
Corrispondenza nella denylist del rumore vendor	scartata prima della valutazione
Lunghezza / entropia sotto la soglia della regola	scartata prima della valutazione
La riga è un marcatore `//# sourceMappingURL=`	scartata prima della valutazione

AWS	Famiglia di prefissi (`AKIA/ASIA/A3T…`) + corpo base32 di 16 caratteri
Stripe	Famiglia di chiavi (`sk/rk/pk_live/test_`) e corpo webhook `whsec_` in base62
GitHub	Checksum CRC32 in base62 verificato rispetto al corpo casuale
OpenAI	Prefisso di famiglia + finestra di lunghezza (`sk-/sk-proj-/sk-svcacct-`)
Slack	Forma a segmenti con trattini (segmenti interni numerici, coda alfanumerica)
JWT	Header JSON decodificato in base64url con campo `alg` + payload JSON
Twilio	Corpo di 32 esadecimali + soglia di entropia
Azure	Il corpo base64 `AccountKey=` si decodifica esattamente in 64 byte; AD `…<digit>Q~…`
Telegram	Divisione `<id di 8-10 cifre>:AA…`, segreto base64url + soglia di entropia
Intercom	Il base64 si decodifica in un payload con prefisso `tok:`
Sentry	Il payload del token org `sntrys_` si decodifica in base64 in JSON con una rivendicazione `url`
Terraform	Struttura a tre segmenti `<14>.atlasv1.<60-70>`
Square	Famiglia `sq0atp-/sq0csp-/sq0idp-` + lunghezza esatta del corpo + entropia
Braintree	Struttura a quattro segmenti `access_token$<env>$<16 base36>$<32 hex>`
Airtable	Divisione a due segmenti `pat<14>.<64 hex>`
Postman	Lunghezze dei segmenti `PMAK-<24 hex>-<34 hex>` + entropia
Database	password dell'URI di connessione rifiutata se templata/predefinita/a bassa entropia

JShunter

Più Popolari

Informazioni