Skip to content
KitploitKITPLOIT
FerramentasBlog
Log in
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

FeedsContatoPrivacidade© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
Ferramentas/GitHubGitHub/cc1a2b/jshunter
ReconhecimentoAnálise Estática de Código (SAST)Análise de VulnerabilidadesAnálise Dinâmica de Código (DAST)Bypass de WAFSegurança WebTestes de PenetraçãoDetecção de SegredosSegurança de API
GitHubcc1a2b/jshunter

JShunter

5295969há 1 mêsRevisado pelo Kitploit

Sobre

Ver Repositório

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.

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

**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>
Baixar ferramenta

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Sem dados de popularidade ainda.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →