Skip to content
KitploitKITPLOIT
StrumentiExploitsBlog
Log in
Invia
StrumentiExploitsBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

FeedContattoPrivacy© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Strumenti/GitHubGitHub/cc1a2b/jshunter
RicognizioneAnalisi Statica del Codice (SAST)Analisi delle VulnerabilitàAnalisi Dinamica del Codice (DAST)Bypass WAFSicurezza WebPenetration TestingRilevamento SegretiSicurezza delle API
GitHubcc1a2b/jshunter

JShunter

52959691 mese faRevisionato da Kitploit

Informazioni

Vedi Repository

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.

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

**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>
Scarica lo strumento

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 Il toolkit OSINT definitivo: grafo di indagine, punteggio di affidabilità, famiglie di alias, mappa, timeline e report. 49 moduli, oltre 400 siti, nessuna chiave API richiesta.

    786
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # App di esecuzione con un tocco GhostLock (CVE-2026-43499)

    506
  • 3

    ARTEX

    baarai/artex

    Piattaforma di penetration testing autonoma multi-agente basata su LLM con agenti planner/worker, grafi di asset e di esplorazione, registrazione del traffico MITM e retesting delle vulnerabilità.

    429
  • 4

    redforge

    cybersecurity91/redforge

    Toolkit red team lato browser con 102 strumenti offline per ricognizione, generazione di payload, attacchi alle credenziali, crittografia, codifica e reportistica dell'engagement.

    345
  • 5

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Il sistema d'azione per la cybersecurity nativa AI—dove l'intento diventa esecuzione governata, le evidenze diventano memoria operativa, e ogni operazione migliora la successiva.

    262
  • 6

    looking-glass

    anonghosty/looking-glass

    Piattaforma CSIRT che importa i report di Shadowserver in MongoDB e li riproduce come mappe interattive, analisi, risultati, avvisi e dashboard executive.

    256

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →