
jshunter è uno strumento da riga di comando progettato per analizzare file JavaScript ed estrarre endpoint. Questo strumento è specializzato nell'identificazione di dati sensibili, come endpoint API e potenziali vulnerabilità di sicurezza, rendendolo una risorsa essenziale per cacciatori di bug e ricercatori di sicurezza.
# 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)
**Strumento professionale per l'analisi della sicurezza JavaScript**
*Scoperta completa degli endpoint, rilevamento di dati sensibili e analisi avanzata del codice per professionisti della sicurezza*
</div>
## Informazioni
**JSHunter** è uno strumento completo da riga di comando per l'analisi della sicurezza JavaScript e la scoperta degli 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 professionale.
https://github.com/user-attachments/assets/5a5f60fa-f8dc-4aac-bd06-2e93779f9af4
*JSHunter in azione — una cattura reale del terminale della CLI (ogni segreto mostrato è un dato di test fittizio)*
---
## Indice
- [Informazioni](#about)
- [Funzionalità](#features)
- [Installazione](#installation)
- [Avvio rapido](#quick-start)
- [Esempi di utilizzo](#usage-examples)
- [Riferimento dei comandi](#command-reference)
- [Utilizzo avanzato](#advanced-usage)
- [Contribuire](#contributing)
- [Licenza](#license)
- [Supporto](#support)
---
## Funzionalità
### Capacità principali
- **Scoperta completa degli endpoint**: estrae automaticamente URL, endpoint API e parametri nascosti dai file JavaScript
- **Analisi di sicurezza avanzata**: identifica chiavi API, token JWT, credenziali e potenziali vulnerabilità con elevata 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 rate limiting intelligente
- **Funzionalità professionali di stealth**: supporto proxy, header personalizzati, rotazione dello user-agent e rilevamento dei bypass
### Motore di rilevamento intelligente
> **Precisione di livello enterprise con algoritmi di analisi avanzati**
- **Rilevamento intelligente Base64**: filtraggio ad alta precisione che elimina i falsi positivi da contenuti multimediali e dati codificati
- **Interfaccia professionale**: terminologia, documentazione e formati di reporting completi pronti per l'enterprise
- **Analisi context-aware**: algoritmi avanzati distinguono i token di sicurezza reali dai dati multimediali codificati
- **Analisi dell'entropia**: algoritmi matematici identificano con precisione token di sicurezza e credenziali autentici
### Motore di rilevamento strutturale
JSHunter analizza il JavaScript che scansiona invece di limitarsi a confrontarlo con pattern. Uno
scanner ECMAScript a passata singola classifica ogni byte della risposta come stringa
letterale, template literal, commento, letterale di espressione regolare o codice, e le
regole di rilevamento vengono valutate in base a tale classificazione.
Questo è importante perché una regex non ha idea di cosa abbia trovato. Gli stessi quaranta caratteri
base64 significano "credenziale" all'interno di una stringa letterale, "hash di chunk" all'interno
di un identificatore minificato, e nulla quando si trovano a cavallo della giunzione tra due
token adiacenti. Sapere quale dei tre casi sia sostituisce una serie di euristiche
di prossimità con una risposta strutturale:
- **Region gating**: una corrispondenza all'interno di un letterale di espressione regolare è un pattern, non un valore.
Una corrispondenza che attraversa un confine di token non è un singolo letterale. Una corrispondenza nel codice
è un frammento di identificatore. Tutti e tre i casi vengono respinti a priori.
- **Contesto di binding**: invece di scansionare una finestra fissa di caratteri per la
parola `key`, il motore recupera l'identificatore o la chiave di proprietà a cui il valore è
effettivamente associato — `const stripeSecret = "..."` si legge in modo molto diverso da
`{contentHash: "..."}`, e una regola basata solo sulla forma ora richiede quel binding.
- **Insiemi di chiavi affini**: i membri di una configurazione web Firebase, di una configurazione di ricerca
Algolia, di una configurazione di analytics Segment e di un client browser Supabase vengono
riconosciuti dalla forma dell'oggetto in cui si trovano.
- **Forma del valore**: digest, UUID, prosa, percorsi, placeholder e base64 che
decodifica in un PNG, un font, un documento JSON o una frase in inglese vengono ciascuno
identificati per quello che sono.
- **Classificazione dell'esposizione**: i valori che l'emittente pubblica di proposito — chiavi pubblicabili
Stripe, token pubblici Mapbox, JWT anon di Supabase letti dal loro stesso
claim `role`, SID Twilio — vengono classificati anziché segnalati come leak.
`--include-public` li segnala comunque.
- **Surprisal relativo al file**: un modello di transizione tra caratteri costruito dal file
scansionato assegna un punteggio a quanto un candidato risulti diverso dal resto di quel file.
Ogni rifiuto è condizionato al fatto che il corpo sia con certezza JavaScript o JSON.
Su qualsiasi altra cosa — un file `.env`, prosa, HTML grezzo — il motore fornisce
evidenza ma non sopprime mai, così un input classificato erroneamente non può mai nascondere un segreto.
`--no-structural` disattiva l'intero livello e ripristina il comportamento della v0.7.
I risultati riportano il ragionamento come oggetto `evidence` in `--json`, `--ndjson` e
nel property bag SARIF:```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` riporta cosa ha scartato ogni fase, così la pipeline resta verificabile.
### Grafo dei Chunk e Scoperta delle Rotte
Un'applicazione moderna distribuisce un bundle di ingresso e diverse centinaia di
chunk caricati in modo lazy i cui URL vengono assemblati a runtime a partire da un manifest che il bundler incorpora inline.
Nulla punta ad essi, quindi un crawler non li vede mai. `-G` recupera quel manifest
e stampa la lista completa degli asset e la tabella delle rotte client:```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
```
Runtime supportati: webpack 4 e 5 (`__webpack_require__.u`, `miniCssF`,
`jsonpScriptSrc`), manifest di build di Next.js, Vite e Rollup (`__vite__mapDeps`,
`__vitePreload`), `import()` dinamico semplice, e tabelle di route di React Router,
Vue Router e Angular. L'output è separato da tabulazioni e deduplicato, quindi può essere
reindirizzato direttamente come lista di input di una scansione successiva:```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
```
### Suite Professionale per HTTP e Networking
<details>
<summary><strong>Configurazione di Rete di Livello Enterprise</strong></summary>
**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 stealthness
**Prestazioni e Affidabilità:**
- **Rate Limiting** (`-R`): Ritardi configurabili tra le richieste (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 le 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 testing
- **Controllo Thread** (`-t`): Gestione configurabile delle richieste concorrenti per prestazioni ottimali
> **Funzionalità per Professionisti della Sicurezza**: Progettato per penetration testing e valutazioni di sicurezza
> **Esempio**: `jshunter -l targets.txt -p 127.0.0.1:8080 -H "Authorization: Bearer token" -R 1000`
</details>
### Analisi Avanzata di JavaScript
<details>
<summary><strong>Suite Completa per l'Analisi del Codice e la Deoffuscazione</strong></summary>
**Strumenti di Analisi Principali:**
- **Motore di Deoffuscazione** (`-d`): Decomprime JavaScript minificato e offuscato per un'analisi approfondita
- **Parser di Source Map** (`-m`): Estrae e analizza il codice sorgente originale dalle source map
- **Rilevamento di Offuscamento** (`-z`): Identifica e classifica tecniche e pattern di offuscamento
**Analisi Dinamica:**
- **Analisi Eval** (`-e`): Analizza l'esecuzione dinamica di codice (`eval()`, `Function()`, generazione a runtime)
**Intelligence sul Codice:**
- **Riconoscimento di Pattern**: Identifica framework e librerie JavaScript comuni
- **Analisi della Struttura del Codice**: Mappa l'architettura dell'applicazione e i flussi di dati
- **Rilevamento Context-Aware**: Comprende il contesto del codice per ridurre i falsi positivi
> **Utilizzo Professionale**: Combina gli strumenti di analisi con il rilevamento di sicurezza per la massima copertura
> **Esempio**: `jshunter -u target.js -d -m -e -s -g` (deoffuscazione completa + analisi di sicurezza)
</details>
### Suite di Analisi di Sicurezza
<details>
<summary><strong>Toolkit Completo per la Valutazione di Sicurezza</strong></summary>
**Rilevamento di Sicurezza Principale:**
- **Rilevamento di Segreti** (`-s`): Chiavi API, token di accesso, password e credenziali hardcoded
- **Analisi di Token JWT** (`-x`): Estrazione, validazione e ispezione del payload dei token di autenticazione
- **Sicurezza Firebase** (`-F`): Analisi della configurazione, chiavi API e rilevamento di URL di database
**Analisi Avanzata:**
- **Scoperta di Parametri** (`-P`): Parametri di form nascosti, variabili e chiavi di configurazione
- **Estrazione di Parametri URL** (`-PU`): Analisi avanzata dei parametri con contesto URL completo
- **Analisi GraphQL** (`-g`): Rilevamento dello schema, estrazione di query e scoperta di endpoint
- **Rilevamento di Bypass WAF** (`-B`): Pattern di bypass di sicurezza e tecniche di evasione
**Scope e Contesto:**
- **Filtraggio di Endpoint Interni** (`-i`): Identificazione e classificazione di risorse private/interne
- **Analisi dei Link** (`-L`): Estrazione completa di URL e mappatura delle relazioni
> **Suggerimento Professionale**: Combina i flag per un'analisi completa (es. `jshunter -u target.js -s -x -F -g`)
</details>
### Scope e Scoperta
<details>
<summary><strong>Crawling e Targeting Intelligenti</strong></summary>
- **Scoperta Ricorsiva**: Crawling di file JavaScript multi-livello
- **Scoping di Dominio**: Concentra l'analisi su domini specifici
- **Filtraggio per Estensione**: Prendi di mira tipi specifici di file JavaScript
</details>
### Suite Professionale di Reporting ed Export
<details>
<summary><strong>Output e Integrazione di Livello Enterprise</strong></summary>
**Formati di Output Principali:**
- **Visualizzazione su Console**: Output terminale con colori, formattazione professionale e categorizzazione chiara
- **Export su File** (`-o`): Salva i risultati completi in posizioni di file personalizzate
- **Export JSON** (`-j`): Formato dati strutturato per automazione ed elaborazione programmatica
- **Export CSV** (`-C`): Formato compatibile con fogli di calcolo per reportistica e analisi direzionale
**Integrazione Professionale:**
- **Export per Burp Suite** (`-n`): Integrazione diretta con Burp Suite Professional per test immediati
- **Filtraggio Regex** (`-r`): Pattern matching personalizzato per filtrare i risultati in modo mirato
- **Analisi Verbose** (`-v`): Output di analisi dettagliato con informazioni di debug e contesto
**Gestione dei Risultati:**
- **Modalità Clean** (`--found-only`): Nasconde i risultati vuoti per una reportistica di sicurezza mirata
- **Modalità Quiet** (`-q`): Sopprime il banner per scripting automatizzato e integrazione CI/CD
> **Workflow di Reporting**: Usa JSON per l'automazione, CSV per i report di management, l'export Burp per i test immediati
> **Esempio**: `jshunter -l targets.txt -s -j -o security-findings.json` (report di sicurezza strutturato)
</details>
---
## Installazione
### Go Install (Consigliato)```bash
# Install JSHunter
go install -v github.com/cc1a2b/jshunter/cmd/jshunter@latest
# Verify installation
jshunter --help
```
### Compilazione dal codice 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)
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
```
### Modello di confidenza
Ogni corrispondenza di classe secret viene valutata in `[0.0, 1.0]`. Il punteggio parte da un prior per regola e viene adattato da:
| Segnale | Effetto |
|------------------------------------------------|------------------------------|
| Il percorso sorgente sembra un bundle vendor/chunk | −0.15 |
| Il contesto circostante contiene diciture da fixture | −0.30 |
| Validator specifico del provider superato | +0.10 |
| Parola chiave di contesto richiesta presente (regola generica) | +0.05 |
| Entropia di Shannon ≥ 4.5 | +0.05 |
| Diversità di 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 marker `//# sourceMappingURL=` | scartata prima della valutazione |
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 output grezzo e non filtrato.
### Validator dei provider
Un validator è un controllo di coerenza per regola che viene eseguito *dopo* che la regex ha trovato una corrispondenza.
È la difesa più forte contro i falsi positivi: una stringa casuale che
si adatta alla forma deve comunque superare un checksum, una decodifica strutturale o una
prova di lunghezza/charset prima di essere segnalata (e superarne una aggiunge `+0.10`).
| Provider | Validator |
|----------|--------------------------------------------------------------------------|
| AWS | Famiglia di prefissi (`AKIA/ASIA/A3T…`) + corpo base32 di 16 caratteri |
| Stripe | Famiglia di chiavi (`sk/rk/pk_live/test_`) e corpo base62 del webhook `whsec_` |
| GitHub | Checksum CRC32 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 caratteri hex + gate di entropia |
| Azure | Il corpo base64 di `AccountKey=` si decodifica in esattamente 64 byte; AD `…<digit>Q~…` |
| Telegram | Split `<8-10 digit id>:AA…`, secret base64url + gate di entropia |
| Intercom | base64 si decodifica in un payload con prefisso `tok:` |
| Sentry | Il payload del token org `sntrys_` si decodifica da base64 in JSON contenente una claim `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 | Split 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 templated/default/a bassa entropia |
### Copertura dei provider
Il registry curato include **oltre 85 detector** che coprono cloud e secret manager
(AWS, Azure, GCP/PKCS#8, HashiCorp Vault, Terraform, Fly.io, Tailscale), controllo
di 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, PuTTY `.ppk`, URI di connessione
a database). Esegui `jshunter --list-rules` per la tabella autorevole e
`jshunter --explain <rule_id>` per il pattern, il validator e le fixture di una
singola regola. Le forme "bare hash" senza prefisso vengono fornite solo quando
un validator 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 e 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
```
---
## Contribuire
Accogliamo con piacere i contributi! Ecco come puoi aiutare:
- **Segnala bug** tramite [GitHub Issues](https://github.com/cc1a2b/jshunter/issues)
- **Suggerisci funzionalità** o miglioramenti
- **Migliora la documentazione**
- **Invia pull request** con miglioramenti
### Configurazione per lo 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**. Vedi [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 aiuta la tua ricerca sulla sicurezza o il tuo lavoro professionale:
<div align="center">
**Metti una stella a questa repo** • **Segui [@cc1a2b](https://twitter.com/cc1a2b)** • **Condividi con altri**
</div>
---
<div align="center">
**JSHunter - Analisi di Sicurezza JavaScript Professionale**
*Creato da [cc1a2b](https://github.com/cc1a2b) per la community della sicurezza*
</div>