JSHunter

Ferramenta Profissional de Análise de Segurança JavaScript

Descoberta completa de endpoints, detecção de dados sensíveis e análise avançada de código para profissionais de segurança

Sobre

JSHunter é uma ferramenta abrangente de linha de comando para análise de segurança JavaScript e descoberta de endpoints. Construída para profissionais de segurança, testadores de penetração e desenvolvedores, ela oferece capacidades de análise de nível empresarial com algoritmos de detecção de alta precisão e recursos profissionais de relatórios.

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

JSHunter em ação — uma captura real de terminal da CLI (todos os segredos exibidos são dados de teste falsos)

Recursos

Capacidades Principais

Descoberta Abrangente de Endpoints: Extrai automaticamente URLs, endpoints de API e parâmetros ocultos de arquivos JavaScript
Análise Avançada de Segurança: Identifica chaves de API, tokens JWT, credenciais e possíveis vulnerabilidades com alta precisão
Métodos Flexíveis de Entrada: Suporta URLs, listas de arquivos, arquivos locais, pipe de stdin e descoberta recursiva
Arquitetura de Alto Desempenho: Processamento concorrente multithread com limitação inteligente de taxa
Recursos Profissionais de Furtividade: Suporte a proxy, cabeçalhos personalizados, rotação de user-agent e detecção de bypass

Motor de Detecção Inteligente

Precisão de nível empresarial com algoritmos avançados de análise

Detecção Inteligente de Base64: Filtragem de alta precisão elimina falsos positivos de conteúdo de mídia e dados codificados
Interface Profissional: Terminologia de nível empresarial, documentação e formatos abrangentes de relatórios
Análise Sensível ao Contexto: Algoritmos avançados distinguem tokens de segurança reais de dados de mídia codificados
Análise de Entropia: Algoritmos matemáticos identificam tokens de segurança e credenciais genuínos com precisão

Suíte Profissional de HTTP e Rede

Configuração de Rede de Nível Empresarial

Autenticação e Cabeçalhos:

Cabeçalhos Personalizados (-H): Cabeçalhos de autenticação repetíveis e cabeçalhos de requisição personalizados
Gerenciamento de Cookies (-c): Cookies de sessão para acessar recursos protegidos
Controle de User-Agent (-U): Strings de UA personalizadas ou rotação baseada em arquivo para furtividade

Desempenho e Confiabilidade:

Limitação de Taxa (-R): Atrasos de requisição configuráveis (milissegundos) para evitar detecção
Timeouts Inteligentes (-T): Configurações de timeout personalizadas para diferentes condições de rede
Tentativas Inteligentes (-y): Mecanismo automático de tentativas com backoff exponencial para requisições com falha

Integração Profissional:

Suporte a Proxy (-p): Integração completa com Burp Suite e proxies personalizados (HTTP/HTTPS/SOCKS5)
Flexibilidade TLS (-k): Bypass opcional de verificação de certificado para ambientes de teste
Controle de Threads (-t): Gerenciamento configurável de requisições concorrentes para desempenho ideal

Análise Avançada de JavaScript

Suíte Completa de Análise de Código e Desofuscação

Ferramentas Principais de Análise:

Motor de Desofuscação (-d): Descompacta JavaScript minificado e ofuscado para análise profunda
Parser de Source Maps (-m): Extrai e analisa o código-fonte original de source maps
Detecção de Ofuscação (-z): Identifica e classifica técnicas e padrões de ofuscação

Análise Dinâmica:

Análise de Eval (-e): Analisa execução dinâmica de código (eval(), Function(), geração em tempo de execução)

Inteligência de Código:

Reconhecimento de Padrões: Identifica frameworks e bibliotecas JavaScript comuns
Análise de Estrutura de Código: Mapeia a arquitetura da aplicação e fluxos de dados
Detecção Sensível ao Contexto: Entende o contexto do código para reduzir falsos positivos

Uso Profissional: Combine ferramentas de análise com detecção de segurança para cobertura máxima Exemplo: jshunter -u target.js -d -m -e -s -g (desofuscação completa + análise de segurança)

Suíte de Análise de Segurança

Kit Completo de Avaliação de Segurança

Detecção Principal de Segurança:

Detecção de Segredos (-s): Chaves de API, tokens de acesso, senhas e credenciais codificadas
Análise de Tokens JWT (-x): Extração, validação e inspeção de payload de tokens de autenticação
Segurança Firebase (-F): Análise de configuração, chaves de API e detecção de URLs de banco de dados

Análise Avançada:

Descoberta de Parâmetros (-P): Parâmetros ocultos de formulários, variáveis e chaves de configuração
Extração de Parâmetros de URL (-PU): Análise avançada de parâmetros com contexto completo de URL
Análise GraphQL (-g): Detecção de schema, extração de consultas e descoberta de endpoints
Detecção de Bypass de WAF (-B): Padrões de bypass de segurança e técnicas de evasão

Escopo e Contexto:

Filtragem de Endpoints Internos (-i): Identificação e classificação de recursos privados/internos
Análise de Links (-L): Extração abrangente de URLs e mapeamento de relacionamentos

Escopo e Descoberta

Rastreamento e Segmentação Inteligentes

Descoberta Recursiva: Rastreamento de arquivos JavaScript em múltiplas profundidades
Escopo de Domínio: Foco da análise em domínios específicos
Filtragem por Extensão: Segmentação de tipos específicos de arquivos JavaScript

Suíte Profissional de Relatórios e Exportação

Saída e Integração de Nível Empresarial

Formatos Principais de Saída:

Exibição no Console: Saída de terminal codificada por cores com formatação profissional e categorização clara
Exportação de Arquivo (-o): Salva resultados abrangentes em locais de arquivo personalizados
Exportação JSON (-j): Formato de dados estruturado para automação e processamento programático
Exportação CSV (-C): Formato compatível com planilhas para relatórios executivos e análise

Integração Profissional:

Exportação Burp Suite (-n): Integração direta com Burp Suite Professional para testes imediatos
Filtragem por Regex (-r): Correspondência de padrões personalizados para filtragem direcionada de resultados
Análise Detalhada (-v): Saída de análise detalhada com informações de depuração e contexto

Gerenciamento de Resultados:

Modo Limpo (--found-only): Oculta resultados vazios para relatórios de segurança focados
Modo Silencioso (-q): Suprime banner para scripts automatizados e integração CI/CD

Instalação

Instalação via Go (Recomendada)```bash

Install JSHunter

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

Verify installation

jshunter --help

### Compilar a partir do código-fonte```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go build -o jshunter ./cmd/jshunter

Requisitos do Sistema

Go 1.22.5+ (para compilar a partir do código-fonte)
Linux, macOS ou Windows (arquitetura de 64 bits)
Conectividade de rede para análise remota de JavaScript

Início Rápido

Análise Básica```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

### Análise de Segurança 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

Exemplos de Uso```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

---

## Referência de Comandos

Obtenha a ajuda completa a qualquer momento com `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

Modelo de confiança

Cada correspondência classificada como segredo recebe uma pontuação em [0.0, 1.0]. A pontuação começa com uma prioridade por regra e é ajustada por:

O padrão --min-confidence 0.50 filtra a cauda longa de correspondências apenas por padrão. Use --min-confidence 0.80 para triagem de alta precisão, --no-fp-filter para saída bruta, sem filtros.

Validadores de provedor

Um validador é uma verificação de consistência por regra que é executada após a correspondência da regex. É a defesa mais forte contra falsos positivos: uma string aleatória que por acaso se encaixa no formato ainda precisa sobreviver a um checksum, uma decodificação estrutural ou uma prova de comprimento/charset antes de ser reportada (e passar em uma adiciona +0.10).

Cobertura de provedores

O registro curado inclui mais de 85 detectores abrangendo nuvem e gerenciadores de segredos (AWS, Azure, GCP/PKCS#8, HashiCorp Vault, Terraform, Fly.io, Tailscale), controle de versão e CI/CD (GitHub, GitLab, Docker Hub, Atlassian, Sentry, CircleCI, Buildkite), pagamentos (Stripe, Square, Braintree, Plaid), provedores de IA/LLM (OpenAI, Anthropic, Groq, Perplexity, Replicate, OpenRouter, Fireworks, HuggingFace), mensageria (Slack, Discord, Telegram, Twilio, Intercom, SendGrid, Mailgun), SaaS e bancos de dados (Notion, Airtable, Figma, Postman, Databricks, PlanetScale, Grafana, New Relic, Dropbox, RubyGems, Supabase) e material PKI (chaves privadas RSA/EC/DSA/OpenSSH/PGP/PKCS#8, .ppk do PuTTY, URIs de conexão de banco de dados). Execute jshunter --list-rules para a tabela autoritativa e jshunter --explain <rule_id> para o padrão, validador e fixtures de qualquer regra individual. Formatos "hash puro" sem prefixo só são incluídos quando um validador estrutural ou um portão de contexto obrigatório consegue mantê-los livres de falsos positivos.

Uso Avançado

Avaliação de Segurança Profissional```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

### Integração Empresarial & Automação```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

Aceitamos contribuições! Veja como você pode ajudar:

Reporte bugs através das GitHub Issues
Sugira funcionalidades ou melhorias
Melhore a documentação
Envie pull requests com aprimoramentos

Configuração de Desenvolvimento```bash

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

---

## Licença

O JSHunter é distribuído sob a **Licença MIT**. Consulte [LICENSE](https://github.com/cc1a2b/jshunter/blob/master/LICENSE) para obter detalhes.```
Copyright (c) 2024-2026 Hussain Alsharman
Licensed under MIT License - free for commercial and personal use

Suporte

Se o JSHunter ajudar na sua pesquisa de segurança ou no seu trabalho profissional:

Dê uma estrela neste repositório • Siga @cc1a2b • Compartilhe com outras pessoas

JSHunter - Análise Profissional de Segurança em JavaScript

Desenvolvido por cc1a2b para a comunidade de segurança

O caminho de origem parece um pacote vendor/chunk	−0.15
O contexto ao redor contém texto de fixture	−0.30
Validador específico do provedor passou	+0.10
Palavra-chave de contexto obrigatória presente (regra genérica)	+0.05
Entropia de Shannon ≥ 4.5	+0.05
Diversidade de classes de caracteres ≥ 3	+0.05
Correspondência na denylist de ruído de vendor	descartada antes da pontuação
Comprimento / entropia abaixo do piso da regra	descartada antes da pontuação
Linha é um marcador `//# sourceMappingURL=`	descartada antes da pontuação

AWS	Família de prefixo (`AKIA/ASIA/A3T…`) + corpo base32 de 16 caracteres
Stripe	Família de chave (`sk/rk/pk_live/test_`) e corpo base62 do webhook `whsec_`
GitHub	Checksum CRC32 base62 verificado contra corpo aleatório
OpenAI	Prefixo de família + janela de comprimento (`sk-/sk-proj-/sk-svcacct-`)
Slack	Formato de segmentos com hífen (segmentos internos numéricos, cauda alfanumérica)
JWT	Cabeçalho JSON decodificado em base64url com campo `alg` + payload JSON
Twilio	Corpo de 32 hex + limite de entropia
Azure	Corpo base64 `AccountKey=` decodifica para exatamente 64 bytes; AD `…<dígito>Q~…`
Telegram	Divisão `<id de 8-10 dígitos>:AA…`, segredo base64url + limite de entropia
Intercom	base64 decodifica para um payload prefixado com `tok:`
Sentry	Payload do token de org `sntrys_` decodifica em base64 para JSON carregando uma claim `url`
Terraform	Estrutura de três segmentos `<14>.atlasv1.<60-70>`
Square	Família `sq0atp-/sq0csp-/sq0idp-` + comprimento exato do corpo + entropia
Braintree	Estrutura de quatro segmentos `access_token$<env>$<16 base36>$<32 hex>`
Airtable	Divisão de dois segmentos `pat<14>.<64 hex>`
Postman	Comprimentos de segmento `PMAK-<24 hex>-<34 hex>` + entropia
Banco de dados	senha de URI de conexão rejeitada se modelada/padrão/baixa entropia

JShunter

Mais Populares

Sobre