jshunter é uma ferramenta de linha de comando projetada para analisar arquivos JavaScript e extrair endpoints. Esta ferramenta é especializada em identificar dados sensíveis, como endpoints de API e potenciais vulnerabilidades de segurança, tornando-a um recurso essencial para caçadores de bug bounty e pesquisadores de segurança.
# 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)
**Ferramenta Profissional de Análise de Segurança em JavaScript**
*Descoberta completa de endpoints, detecção de dados sensíveis e análise avançada de código para profissionais de segurança*
</div>
## Sobre
**JSHunter** é uma ferramenta de linha de comando abrangente para análise de segurança em JavaScript e descoberta de endpoints. Desenvolvida para profissionais de segurança, testadores de penetração e desenvolvedores, oferece capacidades de análise de nível empresarial com algoritmos de detecção de alta precisão e recursos de relatórios profissionais.
https://github.com/user-attachments/assets/5a5f60fa-f8dc-4aac-bd06-2e93779f9af4
*JSHunter em ação — uma captura real do terminal da CLI (todo segredo exibido é dado de teste fictício)*
---
## Índice
- [Sobre](#sobre)
- [Recursos](#recursos)
- [Instalação](#instalação)
- [Início Rápido](#início-rápido)
- [Exemplos de Uso](#exemplos-de-uso)
- [Referência de Comandos](#referência-de-comandos)
- [Uso Avançado](#uso-avançado)
- [Contribuindo](#contribuindo)
- [Licença](#licença)
- [Suporte](#suporte)
---
## Recursos
### Capacidades Principais
- **Descoberta Abrangente de Endpoints**: Extrai automaticamente URLs, endpoints de API e parâmetros ocultos de arquivos JavaScript
- **Análise de Segurança Avançada**: Identifica chaves de API, tokens JWT, credenciais e potenciais vulnerabilidades com alta precisão
- **Métodos de Entrada Flexíveis**: Suporta URLs, listas de arquivos, arquivos locais, entrada via stdin e descoberta recursiva
- **Arquitetura de Alto Desempenho**: Processamento concorrente multithread com limitação de taxa inteligente
- **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, documentação e formatos de relatório abrangentes prontos para uso empresarial
- **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
### Motor de Detecção Estrutural
O JSHunter analisa o JavaScript que escaneia em vez de apenas aplicar correspondência de padrões. Um scanner ECMAScript de passagem única classifica cada byte da resposta como literal de string, literal de template, comentário, literal de expressão regular ou código, e as regras de detecção são avaliadas com base nessa classificação.
Isso importa porque uma regex não tem ideia do que correspondeu. Os mesmos quarenta caracteres base64 significam "credencial" dentro de um literal de string, "hash de chunk" dentro de um identificador minificado, e absolutamente nada quando atravessam a emenda entre dois tokens adjacentes. Saber qual é o caso substitui uma pilha de heurísticas de proximidade por uma resposta estrutural:
- **Restrição por região**: uma correspondência dentro de um literal de regex é um padrão, não um valor. Uma correspondência que cruza um limite de token não é um único literal. Uma correspondência em código é um fragmento de identificador. Todas as três são rejeitadas de imediato.
- **Contexto de vinculação**: em vez de escanear uma janela fixa de caracteres em busca da palavra `key`, o motor recupera o identificador ou a chave de propriedade à qual o valor está de fato vinculado — `const stripeSecret = "..."` lê-se de forma muito diferente de `{contentHash: "..."}`, e uma regra baseada apenas em forma agora exige essa vinculação.
- **Conjuntos de chaves irmãs**: os membros de uma configuração web do Firebase, de uma configuração de busca do Algolia, de uma configuração de analytics do Segment e de um cliente de navegador do Supabase são reconhecidos pela forma do objeto em que se encontram.
- **Forma do valor**: digests, UUIDs, texto corrido, caminhos, placeholders e base64 que decodifica para um PNG, uma fonte, um documento JSON ou uma frase em inglês são cada um identificado pelo que realmente é.
- **Classificação de exposição**: valores que o emissor publica de propósito — chaves publicáveis do Stripe, tokens públicos do Mapbox, JWTs anon do Supabase lidos de sua própria claim `role`, SIDs do Twilio — são classificados em vez de reportados como vazamentos. `--include-public` os reporta mesmo assim.
- **Surpresa relativa ao arquivo**: um modelo de transição de caracteres construído a partir do arquivo sendo escaneado pontua o quão dissimilar do restante daquele arquivo um candidato se lê.
Toda rejeição é condicional ao corpo ser confiavelmente JavaScript ou JSON. Em qualquer outra coisa — um arquivo `.env`, texto corrido, HTML bruto — o motor contribui com evidências mas nunca suprime, de modo que uma entrada mal classificada jamais pode ocultar um segredo. `--no-structural` desativa toda a camada e restaura o comportamento da v0.7.
Os achados carregam o raciocínio como um objeto `evidence` em `--json`, `--ndjson` e no property bag do 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` informa o que cada estágio descartou, para que o pipeline permaneça auditável.
### Grafo de Chunks e Descoberta de Rotas
Uma aplicação moderna entrega um bundle de entrada e várias centenas de chunks
carregados sob demanda cujas URLs são montadas em tempo de execução a partir de um manifesto que o bundler embute. Nada aponta para eles, então um crawler nunca os vê. `-G` recupera esse manifesto
e imprime a lista completa de assets e a tabela de rotas do cliente:```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
```
Runtimes suportados: webpack 4 e 5 (`__webpack_require__.u`, `miniCssF`,
`jsonpScriptSrc`), manifestos de build do Next.js, Vite e Rollup (`__vite__mapDeps`,
`__vitePreload`), `import()` dinâmico simples, e tabelas de rotas do React Router,
Vue Router e Angular. A saída é separada por tabulações e deduplicada, pelo que pode ser encaminhada
diretamente como lista de entrada de uma análise subsequente:```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
```
### Suíte Profissional de HTTP e Rede
<details>
<summary><strong>Configuração de Rede de Nível Empresarial</strong></summary>
**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 stealth
**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
- **Retentativa Inteligente** (`-y`): Mecanismo de retentativa automática com backoff exponencial para requisições falhas
**Integração Profissional:**
- **Suporte a Proxy** (`-p`): Integração completa com Burp Suite e proxy personalizado (HTTP/HTTPS/SOCKS5)
- **Flexibilidade TLS** (`-k`): Bypass opcional de verificação de certificado para ambientes de teste
- **Controle de Threads** (`-t`): Manipulação configurável de requisições concorrentes para desempenho ideal
> **Recursos para Profissionais de Segurança**: Projetado para testes de penetração e avaliações de segurança
> **Exemplo**: `jshunter -l targets.txt -p 127.0.0.1:8080 -H "Authorization: Bearer token" -R 1000`
</details>
### Análise Avançada de JavaScript
<details>
<summary><strong>Suíte Completa de Análise de Código e Desofuscação</strong></summary>
**Ferramentas Principais de Análise:**
- **Motor de Desofuscação** (`-d`): Descompacta JavaScript minificado e ofuscado para análise profunda
- **Analisador de Source Map** (`-m`): Extrai e analisa o código-fonte original a partir 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 os fluxos de dados
- **Detecção Sensível ao Contexto**: Compreende 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)
</details>
### Suíte de Análise de Segurança
<details>
<summary><strong>Kit Completo de Avaliação de Segurança</strong></summary>
**Detecção Principal de Segurança:**
- **Detecção de Segredos** (`-s`): Chaves de API, tokens de acesso, senhas e credenciais embutidas no código
- **Análise de Token JWT** (`-x`): Extração, validação e inspeção de payload de tokens de autenticação
- **Segurança do Firebase** (`-F`): Análise de configuração, chaves de API e detecção de URL 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 de 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
> **Dica Profissional**: Combine flags para análise abrangente (ex.: `jshunter -u target.js -s -x -F -g`)
</details>
### Escopo e Descoberta
<details>
<summary><strong>Rastreamento e Direcionamento Inteligentes</strong></summary>
- **Descoberta Recursiva**: Rastreamento de arquivos JavaScript em múltiplos níveis de profundidade
- **Escopo de Domínio**: Foco da análise em domínios específicos
- **Filtragem de Extensão**: Direcionamento para tipos específicos de arquivos JavaScript
</details>
### Suíte Profissional de Relatórios e Exportação
<details>
<summary><strong>Saída e Integração de Nível Empresarial</strong></summary>
**Formatos Principais de Saída:**
- **Exibição no Console**: Saída de terminal com código de cores, formatação profissional e categorização clara
- **Exportação para 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 para Burp Suite** (`-n`): Integração direta com o Burp Suite Professional para testes imediatos
- **Filtragem por Regex** (`-r`): Correspondência de padrões personalizada 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 o banner para scripts automatizados e integração CI/CD
> **Fluxo de Relatórios**: Use JSON para automação, CSV para relatórios gerenciais, exportação Burp para testes imediatos
> **Exemplo**: `jshunter -l targets.txt -s -j -o security-findings.json` (relatório de segurança estruturado)
</details>
---
## Instalação
### Go Install (Recomendado)```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 de 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)
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
```
### Modelo de confiança
Cada correspondência de classe de segredo é pontuada em `[0.0, 1.0]`. A pontuação começa a partir de um prior por regra e é ajustada por:
| Sinal | Efeito |
|------------------------------------------------|------------------------------|
| O caminho de origem parece um bundle de vendor/chunk | −0.15 |
| O contexto circundante 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 limite da regra | descartada antes da pontuação |
| A linha é um marcador `//# sourceMappingURL=` | descartada antes da pontuação |
O padrão `--min-confidence 0.50` filtra a cauda longa de correspondências apenas de padrão. Use `--min-confidence 0.80` para triagem de alta precisão, `--no-fp-filter` para saída bruta e não filtrada.
### 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 na forma 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`).
| Provedor | Validador |
|----------|--------------------------------------------------------------------------|
| 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 de 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 | Forma de segmento 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 + gate de entropia |
| Azure | Corpo base64 `AccountKey=` decodifica para exatamente 64 bytes; AD `…<digit>Q~…` |
| Telegram | Divisão `<8-10 digit id>:AA…`, segredo base64url + gate de entropia |
| Intercom | base64 decodifica para um payload prefixado com `tok:` |
| Sentry | Payload de token de organização `sntrys_` decodifica em base64 para JSON contendo 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 em dois segmentos `pat<14>.<64 hex>` |
| Postman | Comprimentos de segmento `PMAK-<24 hex>-<34 hex>` + entropia |
| Database | senha de URI de conexão rejeitada se templated/default/low-entropy |
### Cobertura de provedores
O registro curado inclui **mais de 85 detectores** abrangendo cloud 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), mensagens (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 de PKI
(chaves privadas RSA/EC/DSA/OpenSSH/PGP/PKCS#8, PuTTY `.ppk`, 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. Formas de "hash puro" sem prefixo só são incluídas quando um validador
estrutural ou um gate de contexto obrigatório consegue mantê-las 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 e de 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
```
---
## Contribuindo
Aceitamos contribuições! Veja como você pode ajudar:
- **Reporte bugs** via [GitHub Issues](https://github.com/cc1a2b/jshunter/issues)
- **Sugira recursos** ou melhorias
- **Melhore a documentação**
- **Envie pull requests** com melhorias
### 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
JSHunter é distribuído sob a **Licença MIT**. Consulte [LICENSE](https://github.com/cc1a2b/jshunter/blob/master/LICENSE) para mais detalhes.```
Copyright (c) 2024-2026 Hussain Alsharman
Licensed under MIT License - free for commercial and personal use
```
---
## Suporte
Se o JSHunter ajuda na sua pesquisa de segurança ou trabalho profissional:
<div align="center">
**Dê uma estrela neste repositório** • **Siga [@cc1a2b](https://twitter.com/cc1a2b)** • **Compartilhe com outros**
</div>
---
<div align="center">
**JSHunter - Análise Profissional de Segurança em JavaScript**
*Criado por [cc1a2b](https://github.com/cc1a2b) para a comunidade de segurança*
</div>Descubra as ferramentas mais usadas pela nossa comunidade.
Sem dados de popularidade ainda.