Skip to content
KitploitKITPLOIT
HerramientasExploitsBlog
Log in
Enviar
HerramientasExploitsBlog
Enviar

¡Herramientas de Hacking, PenTest y Ciberseguridad para tu Arsenal de Seguridad!

Kitploit es un directorio de herramientas de hacking, ciberseguridad y pentesting. Descubre las últimas actualizaciones de proyectos para encontrar vulnerabilidades, analizar sistemas, automatizar pruebas y fortalecer tu seguridad.

FeedsContactoPrivacidad© 2026 Kitploit

Directorio de Herramientas

Categorías

Ver todas las categorías
Loading categories
JShunter — jshunter es una herramienta de línea de comandos diseñada para analizar archivos JavaScript y extraer endpoints. Esta herramienta se especializa en identificar datos sensibles, como endpoints de API y posibles vulnerabilidades de seguridad, lo que la convierte en un recurso esencial para cazadores de bugs y investigadores de seguridad. | Kitploit
Herramientas/GitHubGitHub/cc1a2b/jshunter
ReconocimientoAnálisis Estático de Código (SAST)Análisis de VulnerabilidadesAnálisis Dinámico de Código (DAST)Evasión de WAFSeguridad WebPruebas de PenetraciónDetección de SecretosSeguridad de APIs
GitHubcc1a2b/jshunter

JShunter

5295969hace 1 mesRevisado por Kitploit

Acerca de

Ver Repositorio

jshunter es una herramienta de línea de comandos diseñada para analizar archivos JavaScript y extraer endpoints. Esta herramienta se especializa en identificar datos sensibles, como endpoints de API y posibles vulnerabilidades de seguridad, lo que la convierte en un recurso esencial para cazadores de bugs y investigadores de seguridad.

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

**Herramienta profesional de análisis de seguridad de JavaScript**

*Descubrimiento completo de endpoints, detección de datos sensibles y análisis avanzado de código para profesionales de seguridad*

</div>

## Acerca de

**JSHunter** es una herramienta de línea de comandos integral para el análisis de seguridad de JavaScript y el descubrimiento de endpoints. Diseñada para profesionales de seguridad, pentesters y desarrolladores, ofrece capacidades de análisis de nivel empresarial con algoritmos de detección de alta precisión y funciones de generación de informes profesionales.

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

*JSHunter en acción — una captura real de terminal de la CLI (cada secreto mostrado son datos de prueba falsos)*

---

## Tabla de contenidos

- [Acerca de](#about)
- [Características](#features)
- [Instalación](#installation)  
- [Inicio rápido](#quick-start)
- [Ejemplos de uso](#usage-examples)
- [Referencia de comandos](#command-reference)
- [Uso avanzado](#advanced-usage)
- [Contribuir](#contributing)
- [Licencia](#license)
- [Soporte](#support)

---

## Características

### Capacidades principales
- **Descubrimiento integral de endpoints**: extrae automáticamente URLs, endpoints de API y parámetros ocultos de archivos JavaScript
- **Análisis de seguridad avanzado**: identifica claves de API, tokens JWT, credenciales y posibles vulnerabilidades con alta precisión
- **Métodos de entrada flexibles**: admite URLs, listas de archivos, archivos locales, entrada por stdin y descubrimiento recursivo
- **Arquitectura de alto rendimiento**: procesamiento concurrente multihilo con limitación de velocidad inteligente
- **Funciones profesionales de sigilo**: soporte de proxy, encabezados personalizados, rotación de user-agent y detección de bypass

### Motor de detección inteligente
> **Precisión de nivel empresarial con algoritmos de análisis avanzados**

- **Detección inteligente de Base64**: el filtrado de alta precisión elimina falsos positivos de contenido multimedia y datos codificados
- **Interfaz profesional**: terminología de nivel empresarial, documentación y formatos de informes completos
- **Análisis consciente del contexto**: algoritmos avanzados distinguen tokens de seguridad reales de datos multimedia codificados
- **Análisis de entropía**: algoritmos matemáticos identifican tokens de seguridad y credenciales genuinos con precisión

### Motor de detección estructural

JSHunter analiza el JavaScript que escanea en lugar de solo aplicar coincidencia de patrones. Un
escáner ECMAScript de una sola pasada clasifica cada byte de la respuesta como literal
de cadena, literal de plantilla, comentario, literal de expresión regular o código, y las
reglas de detección se evalúan contra esa clasificación.

Esto importa porque una regex no tiene idea de qué coincidió. Los mismos cuarenta caracteres
base64 significan "credencial" dentro de un literal de cadena, "hash de chunk" dentro de un
identificador minificado, y nada en absoluto cuando se extienden sobre la unión entre dos
tokens adyacentes. Saber cuál es cuál reemplaza un montón de heurísticas de proximidad
con una respuesta estructural:

- **Region gating**: una coincidencia dentro de un literal de regex es un patrón, no un valor.
  Una coincidencia que cruza un límite de token no es un único literal. Una coincidencia en código
  es un fragmento de identificador. Las tres se rechazan de plano.
- **Binding context**: en lugar de escanear una ventana fija de caracteres buscando la
  palabra `key`, el motor recupera el identificador o la clave de propiedad a la que el valor
  está realmente vinculado — `const stripeSecret = "..."` se lee muy distinto de
  `{contentHash: "..."}`, y una regla basada solo en la forma ahora requiere ese vínculo.
- **Sibling key-sets**: los miembros de una configuración web de Firebase, una configuración de búsqueda
  de Algolia, una configuración de analítica de Segment y un cliente de navegador de Supabase se
  reconocen por la forma del objeto en el que se encuentran.
- **Value shape**: digests, UUIDs, prosa, rutas, marcadores de posición y base64 que
  decodifica a un PNG, una fuente, un documento JSON o una frase en inglés se identifican
  cada uno por lo que son.
- **Exposure classification**: los valores que el emisor publica a propósito — claves publicables de
  Stripe, tokens públicos de Mapbox, JWT anon de Supabase leídos desde su propia
  declaración `role`, SIDs de Twilio — se clasifican en lugar de reportarse como filtraciones.
  `--include-public` los reporta de todos modos.
- **File-relative surprisal**: un modelo de transición de caracteres construido a partir del archivo
  que se está escaneando puntúa cuán distinto del resto de ese archivo se lee un candidato.

Cada rechazo está condicionado a que el cuerpo sea confiablemente JavaScript o JSON.
En cualquier otra cosa — un archivo `.env`, prosa, HTML sin procesar — el motor aporta
evidencia pero nunca suprime, por lo que una entrada mal clasificada nunca puede ocultar un secreto.
`--no-structural` desactiva toda la capa y restaura el comportamiento de v0.7.

Los hallazgos llevan el razonamiento como un objeto `evidence` en `--json`, `--ndjson` y
la bolsa de propiedades 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 qué descartó cada etapa, por lo que el pipeline permanece auditable.

### Grafo de Chunks y Descubrimiento de Rutas

Una aplicación moderna entrega un bundle de entrada y varios cientos de chunks cargados de forma diferida cuyas URLs se ensamblan en tiempo de ejecución a partir de un manifiesto que el bundler incorpora. Nada enlaza hacia ellos, por lo que un crawler nunca los ve. `-G` recupera ese manifiesto e imprime la lista completa de assets y la tabla de rutas del 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 compatibles: webpack 4 y 5 (`__webpack_require__.u`, `miniCssF`,
`jsonpScriptSrc`), manifiestos de compilación de Next.js, Vite y Rollup (`__vite__mapDeps`,
`__vitePreload`), `import()` dinámico simple, y tablas de rutas de React Router,
Vue Router y Angular. La salida está separada por tabulaciones y deduplicada, por lo que se canaliza
directamente de vuelta como la lista de entrada de un escaneo posterior:```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 Profesional de HTTP y Redes
<details>
<summary><strong>Configuración de Red de Nivel Empresarial</strong></summary>

**Autenticación y Encabezados:**
- **Encabezados Personalizados** (`-H`): Encabezados de autenticación y encabezados de solicitud personalizados repetibles
- **Gestión de Cookies** (`-c`): Cookies de sesión para acceder a recursos protegidos
- **Control de User-Agent** (`-U`): Cadenas UA personalizadas o rotación basada en archivos para sigilo

**Rendimiento y Fiabilidad:**
- **Limitación de Tasa** (`-R`): Retrasos de solicitud configurables (milisegundos) para evitar la detección
- **Tiempos de Espera Inteligentes** (`-T`): Configuración de tiempos de espera personalizados para diferentes condiciones de red
- **Reintento Inteligente** (`-y`): Mecanismo de reintento automático con retroceso exponencial para solicitudes fallidas

**Integración Profesional:**
- **Soporte de Proxy** (`-p`): Integración completa con Burp Suite y proxy personalizado (HTTP/HTTPS/SOCKS5)
- **Flexibilidad TLS** (`-k`): Omisión opcional de la verificación de certificados para entornos de prueba
- **Control de Hilos** (`-t`): Manejo configurable de solicitudes concurrentes para un rendimiento óptimo

> **Características para Profesionales de Seguridad**: Diseñado para pruebas de penetración y evaluaciones de seguridad
> **Ejemplo**: `jshunter -l targets.txt -p 127.0.0.1:8080 -H "Authorization: Bearer token" -R 1000`

</details>

### Análisis Avanzado de JavaScript
<details>
<summary><strong>Suite Completa de Análisis de Código y Desofuscación</strong></summary>

**Herramientas Principales de Análisis:**
- **Motor de Desofuscación** (`-d`): Desempaqueta JavaScript minificado y ofuscado para un análisis profundo
- **Analizador de Source Maps** (`-m`): Extrae y analiza el código fuente original de los source maps
- **Detección de Ofuscación** (`-z`): Identifica y clasifica técnicas y patrones de ofuscación

**Análisis Dinámico:**
- **Análisis de Eval** (`-e`): Analiza la ejecución dinámica de código (`eval()`, `Function()`, generación en tiempo de ejecución)

**Inteligencia de Código:**
- **Reconocimiento de Patrones**: Identifica frameworks y bibliotecas comunes de JavaScript
- **Análisis de Estructura de Código**: Mapea la arquitectura de la aplicación y los flujos de datos
- **Detección Sensible al Contexto**: Comprende el contexto del código para reducir falsos positivos

> **Uso Profesional**: Combina las herramientas de análisis con la detección de seguridad para una cobertura máxima
> **Ejemplo**: `jshunter -u target.js -d -m -e -s -g` (desofuscación completa + análisis de seguridad)

</details>

### Suite de Análisis de Seguridad
<details>
<summary><strong>Kit Completo de Evaluación de Seguridad</strong></summary>

**Detección de Seguridad Principal:**
- **Detección de Secretos** (`-s`): Claves de API, tokens de acceso, contraseñas y credenciales codificadas
- **Análisis de Tokens JWT** (`-x`): Extracción, validación e inspección de payload de tokens de autenticación
- **Seguridad de Firebase** (`-F`): Análisis de configuración, claves de API y detección de URL de bases de datos

**Análisis Avanzado:**
- **Descubrimiento de Parámetros** (`-P`): Parámetros de formulario ocultos, variables y claves de configuración
- **Extracción de Parámetros de URL** (`-PU`): Análisis avanzado de parámetros con contexto completo de URL
- **Análisis de GraphQL** (`-g`): Detección de esquemas, extracción de consultas y descubrimiento de endpoints
- **Detección de Bypass de WAF** (`-B`): Patrones de evasión y técnicas de bypass de seguridad

**Alcance y Contexto:**
- **Filtrado de Endpoints Internos** (`-i`): Identificación y clasificación de recursos privados/internos
- **Análisis de Enlaces** (`-L`): Extracción exhaustiva de URL y mapeo de relaciones

> **Consejo Profesional**: Combina las flags para un análisis exhaustivo (p. ej., `jshunter -u target.js -s -x -F -g`)

</details>

### Alcance y Descubrimiento
<details>
<summary><strong>Rastreo y Segmentación Inteligentes</strong></summary>

- **Descubrimiento Recursivo**: Rastreo de archivos JavaScript con múltiples niveles de profundidad
- **Delimitación de Dominios**: Enfoca el análisis en dominios específicos
- **Filtrado de Extensiones**: Apunta a tipos específicos de archivos JavaScript

</details>

### Suite Profesional de Informes y Exportación
<details>
<summary><strong>Salida e Integración de Nivel Empresarial</strong></summary>

**Formatos de Salida Principales:**
- **Visualización en Consola**: Salida de terminal con código de colores, formato profesional y categorización clara
- **Exportación a Archivo** (`-o`): Guarda resultados exhaustivos en ubicaciones de archivo personalizadas
- **Exportación JSON** (`-j`): Formato de datos estructurado para automatización y procesamiento programático
- **Exportación CSV** (`-C`): Formato compatible con hojas de cálculo para informes ejecutivos y análisis

**Integración Profesional:**
- **Exportación a Burp Suite** (`-n`): Integración directa con Burp Suite Professional para pruebas inmediatas
- **Filtrado por Regex** (`-r`): Coincidencia de patrones personalizada para el filtrado específico de resultados
- **Análisis Detallado** (`-v`): Salida de análisis detallada con información de depuración y contexto

**Gestión de Resultados:**
- **Modo Limpio** (`--found-only`): Oculta resultados vacíos para informes de seguridad enfocados
- **Modo Silencioso** (`-q`): Suprime el banner para scripting automatizado e integración CI/CD

> **Flujo de Trabajo de Informes**: Usa JSON para automatización, CSV para informes de gestión, exportación a Burp para pruebas inmediatas
> **Ejemplo**: `jshunter -l targets.txt -s -j -o security-findings.json` (informe de seguridad estructurado)

</details>

---

## Instalación

### Go Install (Recomendado)```bash
# Install JSHunter
go install -v github.com/cc1a2b/jshunter/cmd/jshunter@latest

# Verify installation
jshunter --help
```
### Compilar desde el código fuente```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go build -o jshunter ./cmd/jshunter
```
### Requisitos del sistema
- **Go 1.22.5+** (para compilar desde el código fuente)
- **Linux, macOS o Windows** (arquitectura de 64 bits)
- **Conectividad de red** para el análisis remoto de JavaScript

---

## Inicio rápido

### Análisis básico```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álisis de seguridad completo```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
```
## Ejemplos 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
```
---

## Referencia de Comandos

Obtén la ayuda completa en cualquier 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
```
### Modelo de confianza

Cada coincidencia de clase secreta se puntúa en `[0.0, 1.0]`. La puntuación parte de un prior por regla y se ajusta mediante:

| Señal                                          | Efecto                       |
|------------------------------------------------|------------------------------|
| La ruta de origen parece un bundle de vendor/chunk | −0.15                    |
| El contexto circundante contiene lenguaje de fixture | −0.30                  |
| Validador específico del proveedor superado    | +0.10                        |
| Palabra clave de contexto requerida presente (regla genérica) | +0.05       |
| Entropía de Shannon ≥ 4.5                      | +0.05                        |
| Diversidad de clases de caracteres ≥ 3         | +0.05                        |
| Coincidencia en la denylist de ruido de vendor | descartada antes de puntuar  |
| Longitud / entropía por debajo del mínimo de la regla | descartada antes de puntuar |
| La línea es un marcador `//# sourceMappingURL=` | descartada antes de puntuar |

El valor predeterminado `--min-confidence 0.50` filtra la larga cola de coincidencias solo por patrón. Use `--min-confidence 0.80` para triaje de alta precisión, `--no-fp-filter` para salida sin procesar y sin filtrar.

### Validadores de proveedores

Un validador es una comprobación de consistencia por regla que se ejecuta *después* de que coincida la regex.
Es la defensa más fuerte contra falsos positivos: una cadena aleatoria que
encaje en la forma todavía tiene que superar una suma de verificación, una decodificación estructural o una
prueba de longitud/charset antes de ser reportada (y superarla añade `+0.10`).

| Proveedor | Validador                                                                |
|----------|--------------------------------------------------------------------------|
| AWS      | Familia de prefijos (`AKIA/ASIA/A3T…`) + cuerpo base32 de 16 caracteres   |
| Stripe   | Familia de claves (`sk/rk/pk_live/test_`) y cuerpo base62 de webhook `whsec_` |
| GitHub   | Suma de verificación CRC32 base62 verificada contra el cuerpo aleatorio   |
| OpenAI   | Prefijo de familia + ventana de longitud (`sk-/sk-proj-/sk-svcacct-`)     |
| Slack    | Forma de segmentos con guiones (segmentos internos numéricos, cola alfanumérica) |
| JWT      | Cabecera JSON decodificada en base64url con campo `alg` + payload JSON    |
| Twilio   | Cuerpo de 32 hex + puerta de entropía                                     |
| Azure    | El cuerpo base64 de `AccountKey=` decodifica exactamente a 64 bytes; AD `…<digit>Q~…` |
| Telegram | División `<8-10 digit id>:AA…`, secreto base64url + puerta de entropía    |
| Intercom | base64 decodifica a un payload con prefijo `tok:`                         |
| Sentry   | El payload del token de organización `sntrys_` decodifica en base64 a JSON que lleva una afirmación `url` |
| Terraform| Estructura de tres segmentos `<14>.atlasv1.<60-70>`                       |
| Square   | Familia `sq0atp-/sq0csp-/sq0idp-` + longitud exacta del cuerpo + entropía |
| Braintree| Estructura de cuatro segmentos `access_token$<env>$<16 base36>$<32 hex>`  |
| Airtable | División en dos segmentos `pat<14>.<64 hex>`                              |
| Postman  | Longitudes de segmento `PMAK-<24 hex>-<34 hex>` + entropía                |
| Database | contraseña de URI de conexión rechazada si es templated/default/low-entropy |

### Cobertura de proveedores

El registro curado incluye **más de 85 detectores** que abarcan cloud y gestores de secretos
(AWS, Azure, GCP/PKCS#8, HashiCorp Vault, Terraform, Fly.io, Tailscale), control de versiones
y CI/CD (GitHub, GitLab, Docker Hub, Atlassian, Sentry, CircleCI,
Buildkite), pagos (Stripe, Square, Braintree, Plaid), proveedores de IA/LLM
(OpenAI, Anthropic, Groq, Perplexity, Replicate, OpenRouter, Fireworks,
HuggingFace), mensajería (Slack, Discord, Telegram, Twilio, Intercom, SendGrid,
Mailgun), SaaS y bases de datos (Notion, Airtable, Figma, Postman, Databricks,
PlanetScale, Grafana, New Relic, Dropbox, RubyGems, Supabase), y material PKI
(claves privadas RSA/EC/DSA/OpenSSH/PGP/PKCS#8, PuTTY `.ppk`, URIs de conexión
a bases de datos). Ejecute `jshunter --list-rules` para la tabla autoritativa y
`jshunter --explain <rule_id>` para el patrón, validador y fixtures de cualquier regla individual. Las formas de "hash desnudo" sin prefijo solo se incluyen cuando un validador estructural o una puerta de contexto obligatoria puede mantenerlas libres de falsos positivos.

---

## Uso avanzado

### Evaluación de seguridad profesional```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
```
### Integración Empresarial y de Automatización```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
```
---

## Contribuir

¡Damos la bienvenida a las contribuciones! Así es como puedes ayudar:

- **Reportar errores** a través de [GitHub Issues](https://github.com/cc1a2b/jshunter/issues)
- **Sugerir funcionalidades** o mejoras
- **Mejorar la documentación**
- **Enviar pull requests** con mejoras

### Configuración de desarrollo```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go mod tidy
go build -o jshunter ./cmd/jshunter
```
---

## Licencia

JSHunter se publica bajo la **Licencia MIT**. Consulte [LICENSE](https://github.com/cc1a2b/jshunter/blob/master/LICENSE) para más detalles.```
Copyright (c) 2024-2026 Hussain Alsharman
Licensed under MIT License - free for commercial and personal use
```
---

## Soporte

Si JSHunter te ayuda con tu investigación de seguridad o trabajo profesional:

<div align="center">

**Dale una estrella a este repo** • **Sigue a [@cc1a2b](https://twitter.com/cc1a2b)** • **Compártelo con otros**

</div>

---

<div align="center">

**JSHunter - Análisis Profesional de Seguridad en JavaScript**

*Creado por [cc1a2b](https://github.com/cc1a2b) para la comunidad de seguridad*

</div>
Descargar herramienta

Más Populares

Ver todos →

Descubre las herramientas más usadas por nuestra comunidad.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 El kit de herramientas OSINT definitivo: grafo de investigación, puntuación de confianza, familias de alias, mapa, línea de tiempo e informes. 49 módulos, más de 400 sitios, sin necesidad de claves API.

    871
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Aplicación de Ejecución con un Solo Toque GhostLock (CVE-2026-43499)

    548
  • 3

    ARTEX

    baarai/artex

    Plataforma de pruebas de penetración autónoma multiagente basada en LLM con agentes planificadores/trabajadores, grafos de activos y de exploración, registro de tráfico MITM y reevaluación de vulnerabilidades.

    383
  • 4

    redforge

    cybersecurity91/redforge

    Kit de herramientas de red team del lado del navegador con 102 herramientas offline para reconocimiento, generación de payloads, ataques de credenciales, criptografía, codificación y elaboración de informes de compromiso.

    361
  • 5

    looking-glass

    anonghosty/looking-glass

    Plataforma CSIRT que ingiere informes de Shadowserver en MongoDB y los reproduce como mapas interactivos, análisis, hallazgos, avisos y paneles ejecutivos.

    305
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    El sistema de acción para la ciberseguridad nativa de IA—donde la intención se convierte en ejecución gobernada, la evidencia se convierte en memoria operativa y cada operación mejora la siguiente.

    280

Explora todas las herramientas

Explora nuestra colección de herramientas

Ver todas las herramientas →