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.
# 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)
**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>