Reconnaissance passive & cartographie de la surface d'attaque — zéro requête envoyée
Démarrage rapide · Mode Chasse · Banc de travail · Modes · Exportations · vs Burp · Sous le capot
PenScope est une extension Chrome. Installez-la, naviguez sur un site que vous avez l'autorisation de tester, et elle cartographie silencieusement toute la surface d'attaque — chaque point de terminaison, chaque secret, chaque en-tête mal configuré, chaque paramètre caché. Quand vous donnez le signal, elle envoie 36 attaques de sonde différentes en utilisant vos véritables cookies de session et rapporte lesquelles ont touché.
Ou vous définissez le périmètre, cliquez sur Chasse, et PenScope fait tout le travail de manière autonome pendant que vous faites autre chose — rédigeant des rapports de prime complets au format HackerOne pour chaque constat Critique et Élevé qu'elle atterrit. Vous vous réveillez avec une file de brouillons soumis.
C'est l'outil quotidien pour les chasseurs de primes qui veulent sauter la routine « configurer un proxy, cliquer dans trois fenêtres, alt-tab vers une liste de payloads » et simplement regarder un site. Ou arrêter complètement de regarder et laisser l'outil chasser à leur place.
Lit tout, n'envoie rien — jusqu'à ce que vous le lui demandiez. Définissez le périmètre, lancez Chasse, fermez l'ordinateur. Réveillez-vous avec des critiques rédigés.
Refonte pilotée par audit sur 8 phases. Ajouts principaux :
.env, préfixes s./b. de Vault — plus des détecteurs de corps de réponse Spring Boot / Rails ActiveRecord / Django DEBUG / ASP.NET YSOD / Express / Apollo / MSSQL.alg, iss, sub, aud, exp, iat, , ...). Augmentation de la sévérité lorsque est dans le futur et que le rôle est en forme d'admin.Répartition complète par phase dans CHANGES.md. Notes de migration dans MIGRATION.md.
Épinglez l'extension. Visitez n'importe quel site. Cliquez sur l'icône **P**. PenScope observait déjà.
---
## Ce que vous pouvez faire
PenScope capture plus de 60 champs de données par onglet. Voici ce que cela signifie concrètement :
**Visualisez l'ensemble de la surface d'attaque.** Chaque point de terminaison, y compris ceux référencés en JavaScript mais jamais appelés. Les chemins d'API enfouis dans les source maps, les opérations GraphQL reconstituées à partir des corps POST, les routes admin cachées déduites de l'introspection du framework.
**Trouvez des secrets que personne n'aurait dû expédier.** Clés API codées en dur dans des bundles `.js`. JWT dans `localStorage`. Identifiants AWS dans des dumps d'environnement. Identifiants internes dans les corps de réponse. Le genre de choses qui finissent dans un rapport de criticité P1.
**Exécutez 36 étapes d'attaque dans votre navigateur.** Contournement d'authentification, BAC, IDOR, réflexion CORS, JWT alg=none, SSTI, XXE, injection CRLF, pollution de prototype, découverte de paramètres, downgrade de version d'API. Trois niveaux d'agressivité — prudent, moyen, complet. Les en-têtes personnalisés se collent. Le mode furtif mélange l'ordre des requêtes pour ne pas déclencher un WAF.
**Enchaînez les résultats individuels en exploits concrets.** Un JWT en mémoire est un résultat. Le même JWT plus un point de terminaison d'API qui accepte les tokens non signés plus le rôle décodé étant admin est un enchaînement — et PenScope vous montre l'enchaînement en haut du rapport, avec un score de confiance, une commande de reproduction et les prochaines étapes.
**Modifiez et renvoyez n'importe quelle requête.** Style clic droit. Le Repeater s'ouvre dans un nouvel onglet, en pleine fenêtre. Modifiez un paramètre. Appuyez sur Envoyer. Voyez la réponse. Déposez-la dans Diff pour la comparer à la ligne de base.
**Fuzzez avec des points d'insertion.** Marquez `§payload§` n'importe où dans une requête, choisissez un ensemble de charges utiles (40 chaînes XSS, 30 SQLi, 28 LFI, 18 SSTI, 22 SSRF, 24 injections de commandes, ID 1-100, classiques de contournement d'auth, noms d'utilisateurs courants), choisissez un mode d'attaque (Sniper / Cluster bomb / Pitchfork / Battering ram), regardez le tableau de résultats en direct. Les lignes anormales sont signalées par une étoile.
**Testez en tant que cinq utilisateurs différents simultanément.** Enregistrez des contextes d'authentification (Anonyme, Utilisateur A, Utilisateur B, Admin, Interne). Un clic change le contexte actif — chaque requête du Repeater, chaque exécution d'Intruder, chaque sonde utilise ces identifiants. Ensuite, exécutez la **Matrice d'autorisation** : PenScope parcourt chaque point de terminaison × chaque contexte et colorie une grille. Les désaccords entre les lignes sont vos résultats IDOR / BAC, automatiquement mis en évidence.
**Générez une CSP qui correspond réellement au site.** Parcourt chaque requête effectuée par la page, classe chacune par type de ressource, construit une politique stricte. Ajoute `default-src 'none'`, `frame-ancestors 'none'`, `upgrade-insecure-requests`. Détecte les scripts en ligne et `eval()` et prévient lorsqu'il a dû conserver `'unsafe-inline'`. Compare avec la CSP existante — vert pour renforcé, rouge pour assoupli.
**Dialoguez avec Claude dans les deux sens.** Cliquez sur `→ Claude` pour pousser l'intégralité du scan dans votre presse-papiers sous forme de briefing structuré. Demandez à Claude quoi tester ensuite. Claude répond avec une file d'attente en JSON délimitée. Cliquez sur `⟳ Sync from Claude` et PenScope analyse la file, exécute chaque attaque contre la cible en direct, et renvoie les résultats dans l'analyseur d'enchaînements.
**Suivez votre périmètre dans le temps.** Prenez un instantané d'un site aujourd'hui, prenez un autre instantané au prochain sprint, cliquez sur Comparer. PenScope vous indique quels résultats sont nouveaux, lesquels sont résolus, lesquels n'ont pas bougé. Exportez la différence en Markdown pour le Slack de l'équipe.
**Mappez les résultats aux contrôles de conformité.** Cliquez sur Audit de conformité. Chaque résultat correspond à des contrôles spécifiques dans PCI-DSS v4, NESA UAE IAS, SAMA CSF, DESC ISR, ISO 27001, OWASP Top 10 2021 et CWE. Exportez en JSON pour votre SIEM. Exportez en PDF pour l'auditeur.
---
## Mode Chasse
Cliquez sur `🎯 Hunt` dans l'en-tête de la popup. Un nouvel onglet s'ouvre. Le **panneau de pré-vol** en bas montre l'état de votre moteur — points de terminaison capturés, secrets, technologies détectées, contextes d'authentification enregistrés — afin que vous sachiez si vous disposez d'une surface suffisante pour une chasse productive avant de cliquer sur Démarrer. Si les points de terminaison < 20, un avertissement jaune suggère de naviguer d'abord sur la cible OU de s'appuyer sur la nouvelle étape de crawl automatique du DOM. Configurez votre périmètre cible (chemins dans le périmètre, chemins hors périmètre, niveau d'agressivité, budget de temps). Cliquez sur `▶ Start Hunt`.
PenScope de manière autonome :
1. Finalise la reconnaissance passive
2. **Active automatiquement le mode Deep** (le débogueur CDP s'attache silencieusement — aucune invite utilisateur)
3. **Crawl automatique du DOM** — parcourt chaque `<a href>`, `<form action>`, ``, `[routerLink]`, `[ng-href]`, `[to]`, `[data-href]` sur la page actuelle. Filtre les URL de même origine. Ajoute les nouvelles à la file d'attente des sondes. _Extraction d'URL pure — pas de clic, pas de navigation, pas d'effets secondaires modifiant la session._
4. Exécute le pipeline complet de 36 étapes de sondes + 8 packs d'attaque conscients de la pile
5. Parcourt la **Matrice d'autorisation** sur les contextes d'authentification enregistrés
6. Exécute le corrélateur d'enchaînements, filtre selon vos règles de périmètre
7. **Rédige un rapport complet au format HackerOne pour chaque résultat Critique et Élevé** — enchaînements *et* résultats individuels de haute sévérité (secrets exposés, JWT alg=none, SSTI/XXE/CRLF confirmés). Chaque brouillon comprend un titre, une sévérité avec estimation CVSS, un résumé, des étapes de reproduction avec curl en deux étapes (sonde sans auth + ligne de base avec auth pour la différence), un statement d'impact spécifique au résultat, une correction suggérée depuis la bibliothèque d'extraits, et des références
8. Émet une notification Chrome par critique : _"Le Mode Chasse a trouvé un IDOR Critique sur /api/users — brouillon de rapport prêt"_
9. Persiste les brouillons dans `chrome.storage.local` indexés par hôte (survivent à la fermeture de l'onglet et au redémarrage du navigateur)
L'**onglet Live** raconte chaque étape de filtrage en temps réel — nombre d'enchaînements avant/après le filtre de périmètre, distribution de sévérité, ce qui a été supprimé et pourquoi. Si la chasse se termine avec 0 rapports, un diagnostic « Pourquoi aucun rapport ? » vous guide à travers chaque point de filtrage avec des suggestions concrètes (« décocher le filtre Critique+Élevé », « enregistrer 2 contextes d'auth ou plus », « naviguer davantage sur la cible d'abord »). Fini de se demander pourquoi une chasse est revenue vide.
**Vous vous réveillez avec une file de rapports de bug bounty pré-rédigés.** Lisez chacun, cliquez sur Copier ou Exporter, collez dans votre soumission HackerOne / Bugcrowd / Intigriti.
C'est le workflow que Burp n'essaie même pas. Le Scanner actif de Burp exécute des attaques mais vous devez encore rédiger le rapport. PenScope possède l'ensemble du chemin du scan → exploit → rapport → soumission.
> Définissez le périmètre. Lancez. Fermez le portable. Réveillez-vous avec une file de rapports critiques rédigés.
### Contrôles qualité — préservez votre réputation
Le Mode Chasse filtre activement les faux positifs qui nuiraient à votre réputation s'ils étaient soumis :
- **Coquilles HTML SPA** — les pages de démarrage Angular/React/Vue renvoient un HTML identique aux requêtes authentifiées et non authentifiées car le JS gère l'auth côté client. Le Mode Chasse détecte ce motif (chemin se terminant par `.html` + `sameBody=true`) et supprime le résultat. Les vraies API signalent toujours.
- **Tokens SAS Azure bénins** — les URL SAS en lecture seule à courte durée de vie pour les médias (`image.jpg?sv=...&sp=r&se=...`) sont une diffusion CDN légitime, pas des fuites d'identifiants. Le Mode Chasse vérifie `sp=r` + extension de fichier média + `se - st < 7 jours` et supprime. Les tokens SAS à longue durée de vie, avec capacité d'écriture, ou non-média sont toujours signalés comme de vraies fuites.
- **Normalisation des fragments de hachage** — `/Dashboard#!/` est une route côté client, pas un point de terminaison serveur. Le Mode Chasse supprime les fragments de hachage avant l'analyse des enchaînements afin que le rapport montre `/Dashboard` (le chemin serveur réel).
- **`baseUrl` réelle dans chaque curl** — l'analyseur d'enchaînements dérive l'hôte cible de `tab.url` (HTTP/HTTPS uniquement) avec un repli sur le premier point de terminaison observé. Fini les URL placeholder `https://target.tld` dans vos rapports.
- **Diagnostics transparents** — chaque étape de filtrage (périmètre, sévérité, déduplication) enregistre ses comptes avant/après dans le flux en direct. Lorsqu'une chasse se termine avec 0 rapports, le flux se termine par un bloc « Pourquoi aucun rapport ? » expliquant exactement où chaque résultat potentiel a été abandonné, avec des suggestions d'étapes suivantes concrètes adaptées à votre configuration spécifique.
### Un vrai brouillon du Mode Chasse
Voici un extrait expurgé d'un vrai brouillon produit par le Mode Chasse sur un LMS gouvernemental en 4 minutes :```markdown
# Authentication bypass on sensitive endpoint: /api/DashboardApi/getUsefulLinks
**Severity:** CRITICAL (CVSS estimate: 9.0–10.0)
**Confidence:** 95%
**Target:** https://lms.example.gov/Dashboard
**Discovered:** 2026-05-01T07:31:13.151Z
**Detected by:** PenScope v6.2 Hunt Mode (chain pattern: chain-authbypass)
## Summary
PenScope's probe confirmed that GET /api/DashboardApi/getUsefulLinks returns
the same data whether or not authentication cookies are sent
(auth=200, noauth=200, sameBody=false). The path name strongly suggests this
endpoint should be role-gated — it's returning sensitive data to
unauthenticated callers.
## Steps to reproduce
# Verify unauthenticated access
curl -i "https://lms.example.gov/api/DashboardApi/getUsefulLinks"
# Compare to authenticated baseline (paste your real cookies):
curl -i "https://lms.example.gov/api/DashboardApi/getUsefulLinks" -b "session=..."
## Impact
Successful exploitation enables an attacker to bypass core security controls,
gain unauthorized access to sensitive functionality or data, and pivot to
broader compromise. This is a credible breach path warranting immediate
remediation.
## Suggested fix
Enforce server-side authentication on every endpoint that returns sensitive
data. The fact that PenScope received a 200 with no cookies means the
authorization middleware is missing or disabled for this route.
[ ... full Express/Django/Laravel snippet examples + references ... ]
C'est un rapport de prime soumettable. Rédigé pendant que vous faisiez autre chose.
Le Workbench est ce qui fait passer PenScope d'un « outil de reconnaissance passive » à « tout ce pour quoi vous ouvririez Burp ». Cliquez sur ⌘ Workbench dans l'en-tête de la fenêtre contextuelle et un onglet Chrome en plein écran s'ouvre avec six outils, partageant l'état avec votre scan.
Vous avez capturé une requête que vous souhaitez modifier ? Cliquez dessus dans la Site Map. La requête complète — méthode, URL, en-têtes, corps — se charge dans l'éditeur. Modifiez n'importe quoi. Appuyez sur Send (ou Ctrl+Entrée). La réponse s'affiche à droite avec le statut, la taille, le temps et le contexte d'authentification actif qui l'a déclenchée.
Le rail d'historique conserve vos 50 derniers envois. Trois boutons transforment la requête actuelle en artefacts exploitables : Copy as curl (pour les terminaux et rapports), Send to Intruder (avec les mêmes en-têtes et corps préchargés), Send response to Diff.
Prenez n'importe quelle requête. Encapsulez la valeur que vous souhaitez fuzzer dans §...§. Choisissez un ensemble de payloads. Appuyez sur Start.
Bibliothèque de payloads intégrée :
Ou collez votre propre liste. Quatre modes d'attaque : Sniper (une position à la fois), Cluster bomb (chaque combinaison), Pitchfork (positions verrouillées), Battering ram (même payload partout). Tableau de résultats en direct avec détection d'anomalies — les lignes où le code de statut ou la taille de la réponse diffère de la ligne de base sont signalées.
Limite absolue : 200 requêtes par attaque. Ne DDoS pas accidentellement votre cible de prime.
Conversions réversibles pour les formats que les chasseurs touchent chaque jour :``` Base64 ↔ B64-URL ↔ URL ↔ HTML ↔ Hex ↔ MD5 / SHA-1 / SHA-256 / SHA-512
Plus une carte **JWT** dédiée : collez un jeton, décodez l'en-tête et le payload, modifiez l'un ou l'autre, puis forgez-en un nouveau. Deux modes de forge :
- **alg=none** — le test classique de contournement d'authentification JWT (le serveur fait confiance aux jetons non signés)
- **HS256** — signer avec un secret faible deviné (`secret`, `key`, `password`, `jwt-secret` sont les plus courants)
Le résultat est un jeton unique, prêt à être copié-collé.
### Diff
Deux volets de texte. Envoyez les réponses de Repeater en un clic. Appuyez sur `Compute Diff`. PenScope exécute une diff de lignes LCS et colore le résultat : `+` pour ajouté, `−` pour supprimé. Un compteur récapitulatif en haut.
C'est le tueur de confirmation d'IDOR. « La réponse pour l'utilisateur A est-elle *la même* que pour l'utilisateur B, ou le serveur a-t-il réellement renvoyé les données de l'utilisateur B ? » La diff vous le dit en trois secondes.
### Site Map
Arborescence hiérarchique de chaque point d'accès capturé par PenScope, organisée par hôte → chemin. Pastilles de méthode (`GET`, `POST`, `DELETE`...). Badges de code d'état par nœud, colorés en vert/jaune/orange/rouge. Cliquez sur un chemin pour le charger dans Repeater.
La surface d'attaque complète, en une vue, prête à être testée.
### Auth Contexts + Authorization Matrix
C'est ce qui fait la différence. Burp ne propose pas cela.
Enregistrez des profils d'authentification nommés. Chaque profil = un nom + un ensemble de cookies + un ensemble d'en-têtes. Construisez-les en vous connectant en tant que chaque utilisateur, en copiant leurs cookies de session + l'en-tête Authorization, en les collant dans l'éditeur. Ajoutez des notes (« forfait payant », « rôle en lecture seule », « personnel interne »). Un clic bascule le contexte actif. Toutes les demandes Repeater / Intruder / probe sont maintenant envoyées avec ces identifiants.
Cliquez ensuite sur `Run authorization matrix`. PenScope frappe chaque point d'accès × chaque contexte et affiche une grille :```
Anonymous User A User B Admin
GET /api/me 401 200 200 200
GET /api/users 401 403 403 200
GET /api/admin 401 403 403 200
DELETE /api/orders/5 405 403 403 ★ 200
PATCH /api/users/42 401 200 ★ 403 200
Les étoiles marquent les lignes où les contextes diffèrent. Ces lignes sont vos résultats IDOR et BAC, automatiquement mis en évidence.
Un chasseur typique passe un après-midi entier à tester manuellement chaque point de terminaison en tant que chaque utilisateur, en prenant des notes dans un document. PenScope le fait en 30 secondes et colorise les résultats.
Même moteur de données, trois vues. Choisissez celle qui correspond à ce que vous faites.
Changez de mode avec le bouton Classic / Red / Blue dans l'en-tête de la popup. Chaque onglet se souvient du mode dans lequel vous étiez. Les couleurs du thème changent avec le mode.
Cliquez sur Export ▾ dans l'en-tête de la popup. Dix formats, deux objectifs :
Le rapport Markdown est conçu pour le partage — chaque identifiant est masqué, l'en-tête du rapport le mentionne explicitement. Le JSON est conçu pour la synchronisation avec votre partenaire de chasse — chaque identifiant est expédié intact.
PenScope et Burp résolvent le même problème de côtés différents. PenScope vit dans votre navigateur ; Burp est un proxy MITM. Les deux ont leur place. Voici la comparaison honnête.
Où PenScope gagne : gratuit, configuration plus rapide, natif du navigateur (utilise votre session réelle, pas de danse des certificats), corrélation de chaînes, outils pour le mode défenseur, passerelle IA.
Où Burp gagne : l'interception au niveau TLS vous permet de voir et modifier les requêtes avant qu'elles ne quittent la pile réseau — utile pour les applications natives et le smuggling WebSocket. Collaborator vous donne une infrastructure de callback hors bande pour XXE / SSRF aveugle.
Si vous faites du bug bounty exclusivement dans votre navigateur sur des applications web, PenScope remplace Burp pour ~95 % de votre flux de travail quotidien. Si vous faites de la rétro-ingénierie d'applications mobiles ou testez des clients lourds, Burp reste votre ami.
PenScope n'envoie rien sans action explicite de l'utilisateur. Il y a :
Le trafic sortant ne se produit que dans trois cas :
Zéro paquet npm. Zéro script CDN. Zéro SDK tiers. Du JavaScript vanilla pur, manifeste MV3, zéro surface d'attaque de la chaîne d'approvisionnement.
Architecture, les 36 attaques de sondes, les 13 motifs de chaînes, la carte des fichiers, et pourquoi rien de tout cela n'a besoin d'une étape de construction.
┌──────────────────────────┐
│ state[tabId] │
│ 60+ fields populated by │
│ webRequest / content / │
│ CDP / probe layers │
└──────────┬───────────────┘
│
┌───────────────────────┼───────────────────────┐
│ │ │
Classic mode Red mode Blue mode renderClassic() renderRed() renderBlue() │ │ │ └───────────────────────┴───────────────────────┘ │ ┌────────────────┴────────────────┐ │ │ Workbench Hunt Mode (Repeater · Intruder · Encoder (autonomous orchestrator · Diff · Site Map · Auth Matrix) drafting H1 reports)
**Un moteur, trois modes, trois surfaces.** Le moteur de données est indépendant du mode — chaque champ d'état collecte de la même manière quel que soit l'affichage utilisé. Les modes sont des choix de thème et de rendu sur les mêmes données. Le Workbench et le Mode Chasse sont des onglets Chrome autonomes qui partagent `state[tabId]` via des gestionnaires de messages en arrière-plan.
Les surcharges de variables CSS (`body.mode-red`, `body.mode-blue`) re-thématisent tout sans toucher un seul sélecteur de règle. C'est pourquoi le mode Classique est une expérience identique octet par octet à la v5.9.
---
## Performances
PenScope est présent dans chaque onglet, en permanence. Par défaut, il court-circuite l'enrichissement coûteux pour environ 50 suffixes d'hôtes bruyants connus (CDN vidéo comme `googlevideo.com`, réseaux publicitaires comme `doubleclick.net`, points de terminaison de télémétrie comme `sentry.io`, gros CDN statiques comme `gstatic.com`). Des centaines de requêtes de fragments `googlevideo.com` par minute sur YouTube ne passent plus par 14 expressions régulières AUTH_PATTERN + détection de paramètres de chemin + recherche Swagger — elles sont enregistrées comme points de terminaison (donc le Site Map les inclut toujours) et ignorées pour le reste.
Même chemin rapide pour les types de ressources `image`/`media`/`font`/`stylesheet`/`object`/`ping` sur n'importe quel hôte. Les bugs se cachent presque jamais dans les paramètres d'URL `.css`.
Les re-analyses DOM du script de contenu s'exécutent via `requestIdleCallback` (avec un minimum strict de 15 secondes entre les analyses) et sont totalement ignorées lorsque l'onglet est masqué. MutationObserver filtre les modifications de texte uniquement (ticks de minuteur, mises à jour de données de caractères) afin que le remaniement constant du DOM de YouTube ne déclenche pas une re-analyse complète toutes les 3 secondes.
Remplacement disponible : case à cocher **"Capture complète sur les hôtes bruyants"** dans le menu déroulant Probe. Lorsque vous auditez spécifiquement YouTube/Twitch/Sentry/etc. EN TANT QUE cible, cochez-la et le chemin rapide est contourné.
---
## Les 45 attaques de probe
Exécutées à la demande. Trois niveaux d'agressivité avec un contrat imposé : **Prudent** = uniquement GET/HEAD/OPTIONS avec un espacement minimum de 200 ms entre les requêtes ; **Moyen** = ajoute POST pour les opérations de lecture (≤3 en parallèle) ; **Complet** = toutes les méthodes y compris DELETE/PUT/PATCH plus les rafales de conditions de concurrence (≤10 en parallèle). Les en-têtes personnalisés sont collés dans chaque requête. Le mode furtif mélange l'ordre des étapes avec Fisher-Yates et ajoute un jitter de 0 à 80% aux délais entre les étapes. La méthode attendue de chaque étape est vérifiée en simulation par rapport au niveau actif au démarrage de la sonde ; les étapes bloquées sont listées dans le journal de diagnostic.
| # | Attack | Ce qu'elle fait |
|---|---|---|
| 1 | GraphQL introspection | Vide le schéma, les types, les requêtes, les mutations |
| 2 | Source map harvesting | Télécharge `.map`, extrait les secrets et les points de terminaison |
| 3 | Swagger/OpenAPI fetch | `/swagger.json`, `/openapi.json`, etc. |
| 4 | OPTIONS preflight | Preflight CORS sur chaque chemin d'API |
| 5 | Recon path probing | `/admin`, `/.env`, `/.git/HEAD`, `/actuator` |
| 6 | API prefix suffix brute | `/api/v1/<word>` |
| 7 | Smart suffix bruteforce | Préfixe × suffixe mélangés furtivement |
| 8 | BAC (broken access control) | Points de terminaison modifiant l'état sans authentification |
| 9 | IDOR auto-test | Substitution d'ID + comparaison de même corps |
| 10 | CORS reflection test | Réflexion d'origine avec informations d'identification |
| 11 | Method tampering | Échanges GET/POST/PUT/PATCH/DELETE |
| 12 | Open redirect probe | Variantes de `?redirect=evil.com` |
| 13 | Race condition probe | Requêtes concurrentes sur des points de terminaison sensibles à l'idempotence |
| 14 | HTTP parameter pollution | `?id=1&id=2` |
| 15 | Subdomain enumeration | Depuis les logs CT + trafic observé |
| 16 | GraphQL field fuzzing | Sonde chaque champ introspecté pour l'authentification |
| 17 | JWT alg=none acceptance | Le serveur fait-il confiance aux jetons non signés ? |
| 18 | Host header injection | Variantes de `X-Forwarded-Host` |
| 19 | Cache poisoning | Injection d'en-tête non clé |
| 20 | IDOR confirmed sameBody | Similarité du corps entre les IDs |
| 21 | Auth removal test | Supprimer les cookies, chercher des 200 |
| 22 | CSRF validation gap | Points de terminaison modifiant l'état sans jeton |
| 23 | gRPC reflection | Service de réflexion gRPC exposé |
| 24 | Compression oracle (BREACH) | Heuristique, n'exploite pas réellement |
| 25 | WebSocket hijacking | Connexions WS cross-origin |
| 26 | Cache poison probe | Entrée non clé basée sur l'en-tête |
| 27 | Timing oracle | Variance de temporisation du même point de terminaison |
| 28 | COOP/COEP bypass | Force de l'isolation cross-origin |
| 29 | Storage partition | Isolation du stockage cross-site |
| 30 | Smart recursive discovery | 3 vagues de sondage, enchaînées à partir des réponses précédentes |
| 31 | Parameter discovery | 38 paramètres cachés en force brute (`debug`, `admin`, `_method`, `bypass`...) |
| 32 | SSTI probing | `{{7*7}}`, `${7*7}`, `<%=7*7%>` |
| 33 | XXE probing | XML avec entités externes |
| 34 | CRLF injection | `%0d%0a` dans les paramètres de redirection |
| 35 | API version downgrade | `/v1/`, `/v2/` pour chaque `/vN/` observé |
| 36 | Prototype pollution | `__proto__` / `constructor.prototype` dans les corps JSON |
| 37 | SSRF param probing | 26 noms de paramètres SSRF avec des charges utiles de métadonnées cloud ; signale le contenu de métadonnées reflété |
| 38 | NoSQL operator injection | `{"$ne":null}` / `{"$gt":""}` / `{"$exists":true}` sur les champs d'ID JSON |
| 39 | GraphQL alias amplification | Requête à 50 alias → surface d'amplification DoS (complet uniquement) |
| 40 | GraphQL batch amplification | Lot de 25 éléments de tableau JSON → amplification DoS (complet uniquement) |
| 41 | Cache deception | Style `/api/me/avatar.css` — contenu sensible mis en cache derrière des extensions statiques |
| 42 | Subdomain takeover | Sondage de type HEAD des sous-domaines capturés ; correspond aux signatures de prise de contrôle GitHub Pages / S3 / Heroku / Netlify / Vercel / Bitbucket / Shopify |
| 43 | TabNabbing | `<a target="_blank">` cross-origin sans `rel="noopener"` |
| 44 | postMessage origin correlation | Écouteurs `addEventListener("message")` sans vérification d'origine |
| 45 | Service Worker scope abuse | Signale les portées SW larges (notamment `/`) |
Plus **8 packs d'attaque adaptés aux piles technologiques** qui se déclenchent automatiquement lorsque le mode Rouge détecte la pile correspondante : Laravel, Spring Boot, Rails, ASP.NET, Django, Next.js, GraphQL, WordPress. Chaque pack contient 4 à 9 tests spécifiques à la pile. Le pack Spring Boot à lui seul touche `/actuator/heapdump`, `/actuator/env`, `/jolokia/list`, `/h2-console`.
---
## Les 13 motifs de chaîne
Les découvertes individuelles sont du bruit. Les découvertes composées sont des exploits. L'analyseur de chaîne de PenScope parcourt l'état complet et émet des chaînes où plusieurs signaux se combinent en quelque chose d'exploitable.
1. **Auth bypass on sensitive endpoint** — authentification manquante confirmée + chemin admin/billing/user
2. **Destructive BAC** — point de terminaison vulnérable avec `delete`/`remove`/`purge` dans le chemin
3. **CSRF-vulnerable GraphQL mutation** — CSRF manquant confirmé + c'est une mutation
4. **Exposed auth token + live API** — JWT en mémoire + points de terminaison correspondants
5. **Confirmed IDOR with sensitive data** — réponse de même squelette entre les IDs
6. **CORS reflection WITH credentials** — contournement complet de SOP
7. **Open redirect on auth flow** — paramètre de redirection sur les chemins de callback OAuth
8. **Hidden admin routes** — 3 chemins admin ou plus dans le code jamais observés dans le trafic
9. **JWT alg=none accepted** — le serveur fait confiance aux jetons non signés
10. **Source map leaked secrets** — production livrée avec des fichiers `.map` contenant des clés en dur
11. **WebRTC internal IP leak** — IP privées exposées via STUN
12. **Recursive probe findings cluster** — 3 découvertes sensibles ou plus sur plusieurs points de terminaison
13. **Stack-specific RCE surface** — le pack de pile a trouvé actuator/Ignition/etc. exposé
Chaque chaîne a une sévérité, un résumé, une commande de reproduction, des prochaines étapes et un score de confiance. Trié par `severity × confidence`. Rendu en haut du mode Rouge et en haut de chaque rapport Claude.
---
## Score de santé (Mode Bleu)```
score = max(10, 100 − min(90, crit×22 + high×9))
Strict par conception. Seuls les critiques et les hautes font varier le nombre. Les moyens et les faibles apparaissent toujours dans les tuiles de décompte et les correctifs Top-5 — ils valent la peine d'être corrigés — mais ils ne font pas baisser le score.
Plancher à 10 pour qu'un site catastrophique affiche «10/100», et non «0/100» (que l'utilisateur ne pourrait pas distinguer d'un «scan échoué»).
PenScope/ ├── manifest.json MV3 manifest, v6.3.0, "type":"module" service worker ├── popup.html Mode UI shell — three modes, glassmorphism dark theme ├── popup.js Renderers, mode router, weaponize panels, fix snippets, │ compliance, Hunt + Workbench launchers, exports ├── content.js Content script — DOM scanning, secrets, JSON islands, │ tech fingerprints, XSS sinks, postMessage scan │ ├── workbench.html / .js Workbench tab — Repeater / Intruder / Encoder / │ Diff / SiteMap / AuthCtx + AuthMatrix │ ├── hunt.html / .js Hunt Mode tab — autonomous orchestrator │ ├── regex-pack.json 81 secret patterns + 44 response-body patterns │ (loaded by SW at boot, merged into RESP_PATTERNS, │ fetched by content script via getRegexPack message) │ ├── src/ Service worker entry + module tree (Phase 7 migration) │ ├── background.js Entry — webRequest, CDP, probe orchestrator, │ │ chain correlator, message router (~7,000 lines) │ ├── probe/ │ │ └── stack-packs.js STACK_ATTACK_PACKS (8 stacks) — extracted module │ └── (other audit-named files are stubs — see MIGRATION.md) │ ├── fonts/ Local woff2: JetBrains Mono + Plus Jakarta Sans │ (4 + 5 weights, ~590 KB total). Replaces the │ Google Fonts beacon that earlier versions hit on │ every popup open. │ ├── icons/ 16, 48, 128 px PNG ├── CHANGELOG.md Full version history v5.1 → v6.3.0 ├── CHANGES.md v6.3 per-phase fix breakdown ├── MIGRATION.md Phase 7 module-migration map (real vs stub) ├── LICENSE MIT └── README.md You are here
Les quatre anciens fichiers de référence (`red-attacks.js`, `blue-fixes.js`, `blue-csp.js`, `blue-compliance.js`) ont été supprimés dans la v6.3 — leur contenu était déjà intégré dans `popup.js` / `background.js` depuis la v6.0 ; les fichiers autonomes étaient du code mort. `STACK_ATTACK_PACKS` est désormais un véritable export de module ES depuis `src/probe/stack-packs.js`.
---
## Pas d'étape de construction```bash
git clone https://github.com/spider12223/PenScope
# That's it.
Pas d'installation npm. Pas de webpack. Pas de babel. Pas de TypeScript. Pas de bundler. Du JavaScript vanille pur. La balise <script> du popup.html pointe directement vers popup.js. Le service worker charge background.js directement. Le CSS est intégré dans <style>.
L'implémentation MD5 fait ~50 lignes de référence RFC 1321 intégrée (car crypto.subtle n'expose pas MD5). Le diff LCS fait ~30 lignes. La signature JWT utilise crypto.subtle.sign natif. Le corrélateur de chaînes est une simple regex + itération de tableau. Tout ce que vous lisez dans cette base de code est exactement ce qui s'exécute dans le navigateur.
Un outil de reconnaissance qui est livré avec 200 dépendances npm transitives a 200 packages de surface d'attaque de la chaîne d'approvisionnement. PenScope en a zéro.
Rapports de bugs et PR bienvenus. Quelques garde-fous :
package.json. Si vous avez besoin d'un petit utilitaire, écrivez 20 lignes.state[tabId]. N'introduisez pas de nouveaux stores globaux.:focus-visible, des étiquettes ARIA, un contraste ≥4.5:1.new Function(). Les service workers MV3 interdisent le code dynamique. Utilisez des déclarations de fonctions nommées + args pour chrome.scripting.executeScript.MIT. Utilisez-le, forkez-le, expédiez-le.
Si PenScope vous trouve un critique, ouvrez un ticket et dites-le nous. Nous collectons des histoires de guerre.
Construit par des chasseurs, pour des chasseurs.
rolescopeexpAccessibility.getFullAXTree expose les aria-labels sensibles (boutons admin/sudo/delete/destroy). Storage.getCookies expose les cookies partitionnés CHIPS que chrome.cookies.getAll ne fait pas.<script type="application/json"> (Next __NEXT_DATA__, Nuxt __NUXT__, Remix __remixContext, Apollo __APOLLO_STATE__) sont analysés pour les points de terminaison + champs ID, pas seulement scannés par regex.curl par ligne, bouton unauth par ligne (rejoue la requête sans cookies, montre le verdict côte à côte). Vue de table de routage qui réduit /users/123, /users/124 en /users/{id} avec des comptages. Rail de pivot automatique pour les sous-domaines admin.*, api.*, internal.*.ffuf -w.window.__ps_ctx ne fuit plus les en-têtes d'autorisation de l'utilisateur dans le contexte de la page après la fin de la sonde. Les commandes de reproduction de chaîne masquent les cookies de session par défaut (le mode Rouge a un bouton d'activation pour les valeurs réelles). L'IIFE de la sonde capture fetch/JSON/Promise/atob/btoa/etc. au démarrage afin que les pages instrumentées par analytics ne puissent pas intercepter la sonde en remplaçant les globaux. Approvisionnement local de polices - zéro requête sortante à l'ouverture de la fenêtre contextuelle."type":"module". L'arborescence du répertoire src/ est en place ; STACK_ATTACK_PACKS extrait vers src/probe/stack-packs.js. Les modules restants sont des stubs documentant le chemin d'extraction.| Ensemble | Nombre | Cas d'utilisation |
|---|
| XSS | 40 | Tests de réflexion, XSS DOM, variantes SVG/iframe |
| SQLi | 30 | Aveugle booléen, basé sur les erreurs, basé sur le temps, UNION |
| LFI / Path Traversal | 28 | Variantes d'encodage, Windows + Linux, empoisonnement des logs |
| SSTI | 18 | Jinja2, Twig, Freemarker, Velocity, Smarty |
| SSRF | 22 | Variantes localhost, métadonnées AWS/Azure/GCP, gopher/dict |
| Command Injection | 24 | Bash, PowerShell, contournement IFS |
| IDs 1-100 | 100 | Pour l'énumération IDOR |
| Auth bypass | 25 | Astuces de chemin, escalade de privilèges, contournement d'authentification SQL |
| Common usernames | 25 | admin, root, test, support, service... |
| Mode | Conçu pour | Ce qui est affiché à l'écran |
|---|
| 🟣 | Classic | Workflow familier, données complètes | Chaque onglet, chaque détail. Le PenScope original. |
| 🔴 | Red | Tests offensifs | Rail de chaîne d'exploit en haut avec boutons d'armement (curl, Nucléi YAML, requête Burp, brouillon de rapport H1, file d'attente Claude). Les packs d'attaque conscients de la pile se déclenchent automatiquement sur les frameworks détectés (Laravel, Spring Boot, Rails, ASP.NET, Django, Next.js, GraphQL, WordPress). Priorité à la chaîne, onglets classiques réduits en dessous. |
| 🔵 | Blue | Défenseurs / revue de sécurité | Score de santé (0-100, strict — seuls les critiques et hauts comptent). Top 5 correctifs priorisés par sévérité × facilité, chacun avec des extraits copier-coller dans Nginx / Apache / IIS / Express / Django / Laravel / Rails / ASP.NET. Générateur CSP basé sur le trafic observé. Audit de conformité sur 7 frameworks. Diff instantané et régression. Surveillance continue avec notifications Chrome en cas de fuite de nouveaux secrets. |
| Export | Inclut les identifiants ? | Utilisation |
|---|
| JSON (données complètes) | ✅ Oui | Format de partage d'équipe. Deux chasseurs travaillant sur la même cible ont besoin de contextes d'authentification partagés pour reproduire les découvertes. Envoyer via Signal / canal chiffré. |
| 📄 Rapport complet (.md) | ❌ Masqué | Soumission de bug bounty, engagement client, partout où cela quitte votre équipe. Les valeurs des en-têtes d'authentification (Authorization, Cookie, X-API-Key, X-Auth-Token, X-CSRF-Token, X-Amz-Security-Token, etc.) remplacées par <redacted, N chars>. Inclut les rapports générés par le mode de chasse, les hits des packs d'attaque, les alertes de surveillance continue, et l'état de triage marqué comme corrigé. |
| Liste d'URLs Burp | Liste d'URLs uniquement | Coller dans la portée cible de Burp ou alimenter ffuf/nuclei |
| Wordlist de paramètres | Noms uniquement | Dictionnaires de fuzzing — paramètres de requête + noms de champs de formulaire + noms de champs cachés |
| Wordlist de paramètres (ffuf) | Noms uniquement | Mêmes données émises sous forme de lignes param=FUZZ pour ffuf -w |
| Endpoints (txt) | Liste d'URLs uniquement | Méthode/statut/chemin/hôte/tags/taille séparés par des tabulations — routes observées + découvertes |
| 📤 Export HAR | En-têtes + corps | Capture HAR-1.2 complète que vous pouvez importer dans Chrome DevTools / un visualiseur HAR / donner à un coéquipier |
| 🔧 Spécification Swagger (.yaml) | Liste d'URLs uniquement | Spécification OpenAPI 3.0 reconstruite à partir du trafic observé |
| 🗺️ Source Maps (JSON) | Extraits de source uniquement | Source maps complètes parsées avec arborescences de fichiers, secrets, routes, variables d'environnement, dépendances |
| ⚔️ Modèles Nuclei (.yaml) | URLs de sonde uniquement | Déposer dans ~/.config/nuclei/custom/ pour une analyse continue |
| Fonctionnalité | PenScope (gratuit) | Burp Suite Pro (449 $/an) |
|---|
| Repeater | ✅ | ✅ |
| Intruder (4 modes d'attaque) | ✅ | ✅ |
| Decoder (B64/URL/Hex/JWT) | ✅ | ✅ |
| Comparer / Diff | ✅ | ✅ |
| Target / Site Map | ✅ | ✅ |
| Active scanner | ✅ (45 sondes + 8 packs de pile) | ✅ |
| Gestion du contexte de session/authentification | ✅ (profils sauvegardés + matrice) | ✅ (basé sur des règles) |
| Testeur de matrice d'autorisation | ✅ (intégré) | ❌ (extension payante) |
| Corrélation de chaînes (résultats composés) | ✅ (13 motifs) | ❌ |
| Heuristique de prise de contrôle de sous-domaine | ✅ (8 signatures de service) | ❌ (extension payante) |
| Tests de surface DoS GraphQL (alias + batch) | ✅ | ❌ |
| Bouton de rejeu non authentifié par point de terminaison | ✅ | ❌ |
| Import/export HAR | ✅ (aller-retour) | ✅ (unidirectionnel) |
| Diff IndexedDB (capturer les fuites d'état client) | ✅ | ❌ |
| Capture de cookies partitionnés CHIPS | ✅ | ❌ |
| Analyseur d'îlots JSON (données d'hydratation Next/Nuxt/Remix) | ✅ | ❌ |
| Cartographie de conformité (PCI/NESA/SAMA/ISO/OWASP) | ✅ (7 frameworks) | ❌ |
| Générateur CSP à partir du trafic observé | ✅ | ❌ |
| Diff de régression (instantané + comparaison) | ✅ | ❌ |
| Intégration IA (Claude bidirectionnel) | ✅ | ❌ |
| Mode de chasse autonome (rédige des rapports H1 pendant que vous dormez) | ✅ | ❌ |
| Temps de configuration | 60 secondes | ~30 minutes (proxy + certificat + configuration navigateur) |
| Interception proxy au niveau TLS | ❌ (limitation navigateur) | ✅ |
| Tests hors bande (Collaborator) | ❌ (prévu) | ✅ |
| Marketplace d'extensions | ❌ | ✅ |
| Coût | 0 $ | 449 $ / utilisateur / an |
| État | Score |
|---|
| 0 critique, 0 haute | 100 (propre) |
| 1 haute | 91 |
| 3 hautes | 73 |
| 1 critique | 78 |
| 1 critique + 3 hautes | 51 |
| 3 critiques | 34 |
| 5+ critiques | 10 (plancher) |
| Permission | Pourquoi |
|---|
webRequest | Capturer chaque requête/réponse sans re-téléchargement |
webNavigation | Détecter les changements de route SPA pushState/replaceState (v6.3+) afin que les points de terminaison de app.com ne se mélangent pas avec l'état de la nouvelle origine lorsque le SPA navigue cross-origin |
activeTab | Lire l'URL de l'onglet courant + envoyer des messages de script de contenu |
scripting | Injecter les exécuteurs de sonde, les packs de pile et les requêtes Workbench dans le contexte de la page |
tabs | Mapper les résultats à l'onglet correct ; ouvrir le Workbench dans un nouvel onglet |
cookies | Lire les cookies HttpOnly que document.cookie ne peut pas voir |
debugger | Requis pour le mode Deep — active CDP pour les corps de réponse complets, l'introspection runtime, l'extraction de sources, les problèmes d'audit, l'arbre d'accessibilité, les cookies partitionnés |
notifications | Alertes de surveillance continue sur les nouvelles fuites de secrets |
alarms | Ticks d'intervalle de 5 minutes pour la surveillance continue |
storage | Persister l'état (session) et les instantanés (local) à travers les redémarrages du SW |
<all_urls> host permission | La capture est indépendante de la cible ; l'utilisateur contrôle quel onglet est ouvert |