Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
Outils/GitHubGitHub/cc1a2b/jshunter
ReconnaissanceAnalyse Statique de Code (SAST)Analyse des VulnérabilitésAnalyse Dynamique de Code (DAST)Contournement de WAFSécurité WebTests d'IntrusionDétection de SecretsSécurité des API
GitHubcc1a2b/jshunter

JShunter

5295969il y a 2 moisVérifié par Kitploit

À propos

Voir le dépôt

jshunter est un outil en ligne de commande conçu pour analyser les fichiers JavaScript et extraire des points de terminaison. Cet outil se spécialise dans l'identification de données sensibles, telles que les points de terminaison d'API et les potentielles vulnérabilités de sécurité, ce qui en fait une ressource essentielle pour les chasseurs de bugs et les chercheurs en sécurité.

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

**Outil professionnel d'analyse de sécurité JavaScript**

*Découverte complète de points de terminaison, détection de données sensibles et analyse avancée de code pour les professionnels de la sécurité*

</div>

## À propos

**JSHunter** est un outil en ligne de commande complet pour l'analyse de sécurité JavaScript et la découverte de points de terminaison. Conçu pour les professionnels de la sécurité, les testeurs d'intrusion et les développeurs, il offre des capacités d'analyse de niveau entreprise avec des algorithmes de détection de haute précision et des fonctionnalités de reporting professionnelles.

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

*JSHunter en action — une capture réelle du terminal de l'interface CLI (chaque secret affiché est une fausse donnée de test)*

---

## Table des matières

- [À propos](#about)
- [Fonctionnalités](#features)
- [Installation](#installation)  
- [Démarrage rapide](#quick-start)
- [Exemples d'utilisation](#usage-examples)
- [Référence des commandes](#command-reference)
- [Utilisation avancée](#advanced-usage)
- [Contribution](#contributing)
- [Licence](#license)
- [Support](#support)

---

## Fonctionnalités

### Capacités principales
- **Découverte complète de points de terminaison** : Extrait automatiquement les URL, les points de terminaison d'API et les paramètres cachés des fichiers JavaScript
- **Analyse de sécurité avancée** : Identifie les clés d'API, les jetons JWT, les identifiants et les vulnérabilités potentielles avec une grande précision
- **Méthodes d'entrée flexibles** : Prend en charge les URL, les listes de fichiers, les fichiers locaux, la redirection stdin et la découverte récursive
- **Architecture haute performance** : Traitement concurrent multi-thread avec limitation de débit intelligente
- **Fonctionnalités de furtivité professionnelles** : Prise en charge de proxy, en-têtes personnalisés, rotation de user-agent et détection de contournement

### Moteur de détection intelligent
> **Précision de niveau entreprise avec des algorithmes d'analyse avancés**

- **Détection intelligente de Base64** : Un filtrage de haute précision élimine les faux positifs provenant de contenus multimédias et de données encodées
- **Interface professionnelle** : Terminologie, documentation et formats de reporting complets adaptés à l'entreprise
- **Analyse contextuelle** : Des algorithmes avancés distinguent les véritables jetons de sécurité des données multimédias encodées
- **Analyse d'entropie** : Des algorithmes mathématiques identifient avec précision les véritables jetons de sécurité et identifiants

### Moteur de détection structurelle

JSHunter analyse le JavaScript qu'il scanne au lieu de se contenter de le comparer à des motifs. Un scanner ECMAScript à passe unique classe chaque octet de la réponse comme littéral de chaîne, littéral de gabarit, commentaire, littéral d'expression régulière ou code, et les règles de détection sont évaluées par rapport à cette classification.

Cela est important car une regex n'a aucune idée de ce qu'elle a trouvé. Les mêmes quarante caractères base64 signifient « identifiant » à l'intérieur d'un littéral de chaîne, « hash de chunk » à l'intérieur d'un identifiant minifié, et rien du tout lorsqu'ils chevauchent la jointure entre deux jetons adjacents. Savoir de quoi il s'agit remplace un tas d'heuristiques de proximité par une réponse structurelle :

- **Filtrage par région** : une correspondance à l'intérieur d'un littéral d'expression régulière est un motif, pas une valeur. Une correspondance qui franchit une frontière de jeton n'est pas un littéral unique. Une correspondance dans du code est un fragment d'identifiant. Les trois sont rejetées d'emblée.
- **Contexte de liaison** : au lieu de scanner une fenêtre fixe de caractères à la recherche du mot `key`, le moteur récupère l'identifiant ou la clé de propriété à laquelle la valeur est réellement liée — `const stripeSecret = "..."` se lit très différemment de `{contentHash: "..."}`, et une règle basée uniquement sur la forme exige désormais cette liaison.
- **Ensembles de clés voisines** : les membres d'une configuration web Firebase, d'une configuration de recherche Algolia, d'une configuration d'analyse Segment et d'un client navigateur Supabase sont reconnus par la forme de l'objet dans lequel ils se trouvent.
- **Forme de la valeur** : les condensés, UUID, prose, chemins, espaces réservés et base64 qui se décode en PNG, police, document JSON ou phrase anglaise sont chacun identifiés pour ce qu'ils sont.
- **Classification de l'exposition** : les valeurs que l'émetteur publie intentionnellement — clés publiables Stripe, jetons publics Mapbox, JWT anon Supabase lus depuis leur propre revendication `role`, SID Twilio — sont classifiées plutôt que signalées comme des fuites. `--include-public` les signale quand même.
- **Surprise relative au fichier** : un modèle de transition de caractères construit à partir du fichier scanné évalue à quel point un candidat diffère du reste de ce fichier.

Chaque rejet est conditionné au fait que le corps soit de manière fiable du JavaScript ou du JSON. Sur tout autre chose — un fichier `.env`, de la prose, du HTML brut — le moteur apporte des preuves mais ne supprime jamais, de sorte qu'une entrée mal classifiée ne peut jamais masquer un secret. `--no-structural` désactive toute cette couche et restaure le comportement de la v0.7.

Les résultats portent le raisonnement sous forme d'un objet `evidence` dans `--json`, `--ndjson` et le sac de propriétés 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` indique ce que chaque étape a supprimé, afin que le pipeline reste auditable.

### Graphe de chunks et découverte de routes

Une application moderne livre un bundle d'entrée et plusieurs centaines de chunks chargés paresseusement dont les URLs sont assemblées à l'exécution à partir d'un manifeste que le bundler intègre. Rien ne pointe vers eux, donc un crawler ne les voit jamais. `-G` récupère ce manifeste et affiche la liste complète des assets ainsi que la table des routes côté client :```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 pris en charge : webpack 4 et 5 (`__webpack_require__.u`, `miniCssF`,
`jsonpScriptSrc`), manifestes de build Next.js, Vite et Rollup (`__vite__mapDeps`,
`__vitePreload`), `import()` dynamique simple, et tables de routes de React Router,
Vue Router et Angular. La sortie est séparée par des tabulations et dédupliquée, ce qui permet
de la réinjecter directement comme liste d'entrée d'un scan de suivi :```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 professionnelle HTTP et réseau
<details>
<summary><strong>Configuration réseau de niveau entreprise</strong></summary>

**Authentification et en-têtes :**
- **En-têtes personnalisés** (`-H`) : En-têtes d'authentification répétables et en-têtes de requête personnalisés
- **Gestion des cookies** (`-c`) : Cookies de session pour accéder aux ressources protégées
- **Contrôle du User-Agent** (`-U`) : Chaînes UA personnalisées ou rotation basée sur fichier pour la furtivité

**Performance et fiabilité :**
- **Limitation de débit** (`-R`) : Délais de requête configurables (millisecondes) pour éviter la détection
- **Timeouts intelligents** (`-T`) : Paramètres de timeout personnalisés pour différentes conditions réseau
- **Nouvelle tentative intelligente** (`-y`) : Mécanisme de nouvelle tentative automatique avec backoff exponentiel pour les requêtes échouées

**Intégration professionnelle :**
- **Prise en charge des proxys** (`-p`) : Intégration complète de Burp Suite et de proxys personnalisés (HTTP/HTTPS/SOCKS5)
- **Flexibilité TLS** (`-k`) : Contournement optionnel de la vérification des certificats pour les environnements de test
- **Contrôle des threads** (`-t`) : Gestion configurable des requêtes concurrentes pour des performances optimales

> **Fonctionnalités pour professionnels de la sécurité** : Conçu pour les tests d'intrusion et les évaluations de sécurité
> **Exemple** : `jshunter -l targets.txt -p 127.0.0.1:8080 -H "Authorization: Bearer token" -R 1000`

</details>

### Analyse avancée de JavaScript
<details>
<summary><strong>Suite complète d'analyse de code et de désobfuscation</strong></summary>

**Outils d'analyse principaux :**
- **Moteur de désobfuscation** (`-d`) : Décompresse le JavaScript minifié et obfusqué pour une analyse approfondie
- **Analyseur de source maps** (`-m`) : Extrait et analyse le code source original à partir des source maps
- **Détection d'obfuscation** (`-z`) : Identifie et classe les techniques et motifs d'obfuscation

**Analyse dynamique :**
- **Analyse d'eval** (`-e`) : Analyse l'exécution dynamique de code (`eval()`, `Function()`, génération à l'exécution)

**Intelligence du code :**
- **Reconnaissance de motifs** : Identifie les frameworks et bibliothèques JavaScript courants
- **Analyse de la structure du code** : Cartographie l'architecture de l'application et les flux de données
- **Détection contextuelle** : Comprend le contexte du code pour réduire les faux positifs

> **Utilisation professionnelle** : Combinez les outils d'analyse avec la détection de sécurité pour une couverture maximale
> **Exemple** : `jshunter -u target.js -d -m -e -s -g` (désobfuscation complète + analyse de sécurité)

</details>

### Suite d'analyse de sécurité
<details>
<summary><strong>Boîte à outils complète d'évaluation de sécurité</strong></summary>

**Détection de sécurité principale :**
- **Détection de secrets** (`-s`) : Clés API, jetons d'accès, mots de passe et identifiants codés en dur
- **Analyse de jetons JWT** (`-x`) : Extraction, validation et inspection de la charge utile des jetons d'authentification
- **Sécurité Firebase** (`-F`) : Analyse de configuration, clés API et détection d'URL de base de données

**Analyse avancée :**
- **Découverte de paramètres** (`-P`) : Paramètres de formulaire cachés, variables et clés de configuration
- **Extraction de paramètres d'URL** (`-PU`) : Analyse avancée des paramètres avec contexte d'URL complet
- **Analyse GraphQL** (`-g`) : Détection de schéma, extraction de requêtes et découverte de points de terminaison
- **Détection de contournement de WAF** (`-B`) : Motifs de contournement de sécurité et techniques d'évasion

**Périmètre et contexte :**
- **Filtrage des points de terminaison internes** (`-i`) : Identification et classification des ressources privées/internes
- **Analyse des liens** (`-L`) : Extraction complète des URL et cartographie des relations

> **Astuce professionnelle** : Combinez les options pour une analyse complète (par ex., `jshunter -u target.js -s -x -F -g`)

</details>

### Périmètre et découverte
<details>
<summary><strong>Exploration et ciblage intelligents</strong></summary>

- **Découverte récursive** : Exploration multi-niveaux des fichiers JavaScript
- **Délimitation de domaine** : Concentrer l'analyse sur des domaines spécifiques
- **Filtrage par extension** : Cibler des types de fichiers JavaScript spécifiques

</details>

### Suite professionnelle de reporting et d'export
<details>
<summary><strong>Sortie et intégration de niveau entreprise</strong></summary>

**Formats de sortie principaux :**
- **Affichage console** : Sortie terminal colorée avec formatage professionnel et catégorisation claire
- **Export de fichier** (`-o`) : Enregistrer les résultats complets à des emplacements de fichier personnalisés
- **Export JSON** (`-j`) : Format de données structuré pour l'automatisation et le traitement programmatique
- **Export CSV** (`-C`) : Format compatible avec les tableurs pour le reporting et l'analyse de direction

**Intégration professionnelle :**
- **Export Burp Suite** (`-n`) : Intégration directe avec Burp Suite Professional pour des tests immédiats
- **Filtrage par regex** (`-r`) : Correspondance de motifs personnalisés pour un filtrage ciblé des résultats
- **Analyse verbeuse** (`-v`) : Sortie d'analyse détaillée avec informations de débogage et contexte

**Gestion des résultats :**
- **Mode propre** (`--found-only`) : Masquer les résultats vides pour un reporting de sécurité ciblé
- **Mode silencieux** (`-q`) : Supprimer la bannière pour les scripts automatisés et l'intégration CI/CD

> **Flux de reporting** : Utilisez JSON pour l'automatisation, CSV pour les rapports de direction, l'export Burp pour les tests immédiats
> **Exemple** : `jshunter -l targets.txt -s -j -o security-findings.json` (rapport de sécurité structuré)

</details>

---

## Installation

### Installation via Go (recommandée)```bash
# Install JSHunter
go install -v github.com/cc1a2b/jshunter/cmd/jshunter@latest

# Verify installation
jshunter --help
```
### Compiler depuis les sources```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go build -o jshunter ./cmd/jshunter
```
### Configuration requise
- **Go 1.22.5+** (pour la compilation depuis les sources)
- **Linux, macOS ou Windows** (architecture 64 bits)
- **Connectivité réseau** pour l'analyse JavaScript à distance

---

## Démarrage rapide

### Analyse de base```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
```
### Analyse de sécurité complète```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
```
## Exemples d'utilisation```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
```
---

## Référence des commandes

Obtenez l'aide complète à tout moment avec `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
```
### Modèle de confiance

Chaque correspondance de classe de secret est notée dans `[0.0, 1.0]`. Le score part d'un a priori par règle et est ajusté par :

| Signal                                         | Effet                        |
|------------------------------------------------|------------------------------|
| Le chemin source ressemble à un bundle vendor/chunk | −0.15                   |
| Le contexte environnant contient une formulation de fixture | −0.30          |
| Validateur spécifique au fournisseur réussi    | +0.10                        |
| Mot-clé de contexte requis présent (règle générique) | +0.05                  |
| Entropie de Shannon ≥ 4.5                      | +0.05                        |
| Diversité des classes de caractères ≥ 3        | +0.05                        |
| Correspondance dans la denylist de bruit vendor | écartée avant notation       |
| Longueur / entropie sous le seuil de la règle  | écartée avant notation       |
| La ligne est un marqueur `//# sourceMappingURL=` | écartée avant notation     |

Le `--min-confidence 0.50` par défaut filtre la longue traîne des correspondances basées uniquement sur le motif. Utilisez `--min-confidence 0.80` pour un triage à haute précision, `--no-fp-filter` pour une sortie brute, non filtrée.

### Validateurs de fournisseurs

Un validateur est une vérification de cohérence par règle qui s'exécute *après* la correspondance regex.
C'est la défense la plus solide contre les faux positifs : une chaîne aléatoire qui
correspond à la forme doit encore survivre à une somme de contrôle, un décodage structurel, ou une
preuve de longueur/charset avant d'être signalée (et en réussir un ajoute `+0.10`).

| Fournisseur | Validateur                                                                |
|----------|--------------------------------------------------------------------------|
| AWS      | Famille de préfixes (`AKIA/ASIA/A3T…`) + corps base32 de 16 caractères    |
| Stripe   | Famille de clés (`sk/rk/pk_live/test_`) et corps base62 de webhook `whsec_` |
| GitHub   | Somme de contrôle CRC32 base62 vérifiée contre un corps aléatoire         |
| OpenAI   | Préfixe de famille + fenêtre de longueur (`sk-/sk-proj-/sk-svcacct-`)     |
| Slack    | Forme à segments séparés par des tirets (segments internes numériques, queue alphanumérique) |
| JWT      | En-tête JSON décodé en base64url avec champ `alg` + payload JSON          |
| Twilio   | Corps de 32 hex + filtre d'entropie                                       |
| Azure    | Le corps base64 `AccountKey=` se décode en exactement 64 octets ; AD `…<digit>Q~…` |
| Telegram | Découpage `<8-10 digit id>:AA…`, secret base64url + filtre d'entropie     |
| Intercom | Le base64 se décode en un payload préfixé par `tok:`                      |
| Sentry   | Le payload du token d'organisation `sntrys_` se décode en base64 vers du JSON portant une revendication `url` |
| Terraform| Structure à trois segments `<14>.atlasv1.<60-70>`                        |
| Square   | Famille `sq0atp-/sq0csp-/sq0idp-` + longueur de corps exacte + entropie   |
| Braintree| Structure à quatre segments `access_token$<env>$<16 base36>$<32 hex>`     |
| Airtable | Découpage en deux segments `pat<14>.<64 hex>`                             |
| Postman  | Longueurs de segments `PMAK-<24 hex>-<34 hex>` + entropie                 |
| Database | Mot de passe d'URI de connexion rejeté s'il est templatisé/par défaut/à faible entropie |

### Couverture des fournisseurs

Le registre curé embarque **plus de 85 détecteurs** couvrant le cloud et les gestionnaires de secrets
(AWS, Azure, GCP/PKCS#8, HashiCorp Vault, Terraform, Fly.io, Tailscale), le contrôle de version
et CI/CD (GitHub, GitLab, Docker Hub, Atlassian, Sentry, CircleCI,
Buildkite), les paiements (Stripe, Square, Braintree, Plaid), les fournisseurs d'IA/LLM
(OpenAI, Anthropic, Groq, Perplexity, Replicate, OpenRouter, Fireworks,
HuggingFace), la messagerie (Slack, Discord, Telegram, Twilio, Intercom, SendGrid,
Mailgun), les SaaS et bases de données (Notion, Airtable, Figma, Postman, Databricks,
PlanetScale, Grafana, New Relic, Dropbox, RubyGems, Supabase), et le matériel PKI
(clés privées RSA/EC/DSA/OpenSSH/PGP/PKCS#8, PuTTY `.ppk`, URI de connexion
à des bases de données). Exécutez `jshunter --list-rules` pour la table de référence et
`jshunter --explain <rule_id>` pour le motif, le validateur et les fixtures de n'importe quelle règle unique. Les formes « bare hash » sans préfixe ne sont livrées que lorsqu'un validateur structurel ou une porte de contexte obligatoire peut les garder exemptes de faux positifs.

---

## Utilisation avancée

### Évaluation de sécurité professionnelle```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
```
### Intégration Entreprise et Automatisation```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
```
---

## Contribution

Nous accueillons favorablement les contributions ! Voici comment vous pouvez aider :

- **Signaler des bugs** via [GitHub Issues](https://github.com/cc1a2b/jshunter/issues)
- **Suggérer des fonctionnalités** ou des améliorations
- **Améliorer la documentation**
- **Soumettre des pull requests** avec des améliorations

### Configuration de développement```bash
git clone https://github.com/cc1a2b/jshunter.git
cd jshunter
go mod tidy
go build -o jshunter ./cmd/jshunter
```
---

## Licence

JSHunter est publié sous la **licence MIT**. Voir [LICENSE](https://github.com/cc1a2b/jshunter/blob/master/LICENSE) pour plus de détails.```
Copyright (c) 2024-2026 Hussain Alsharman
Licensed under MIT License - free for commercial and personal use
```
---

## Support

Si JSHunter vous aide dans vos recherches en sécurité ou votre travail professionnel :

<div align="center">

**Star ce dépôt** • **Suivez [@cc1a2b](https://twitter.com/cc1a2b)** • **Partagez avec d'autres**

</div>

---

<div align="center">

**JSHunter - Analyse professionnelle de sécurité JavaScript**

*Créé par [cc1a2b](https://github.com/cc1a2b) pour la communauté de la sécurité*

</div>
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    891
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    547
  • 3

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    369
  • 4

    redforge

    cybersecurity91/redforge

    Boîte à outils red team côté navigateur avec 102 outils hors ligne pour la reconnaissance, la génération de payloads, les attaques par identifiants, la cryptographie, l'encodage et le reporting d'engagement.

    366
  • 5

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    309
  • 6

    CyberStrikeAI

    ed1s0nz/cyberstrikeai

    Le système d'action pour la cybersécurité native IA—où l'intention devient une exécution gouvernée, les preuves deviennent une mémoire opérationnelle, et chaque opération améliore la suivante.

    282

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →