Fissa l'estensione. Visita un sito qualsiasi. Fai clic sull'icona **P**. PenScope stava già osservando.

---

## Cosa puoi fare

PenScope cattura più di 60 campi dati per scheda. Ecco cosa significa in pratica:

**Vedi l'intera superficie d'attacco.** Ogni endpoint, inclusi quelli referenziati in JavaScript ma mai effettivamente chiamati. Percorsi API sepolti nelle source map, operazioni GraphQL ricostruite dai corpi POST, route admin nascoste dedotte dall'introspezione del framework.

**Trova segreti che nessuno intendeva pubblicare.** Chiavi API hardcoded in bundle `.js`. JWT in `localStorage`. Credenziali AWS in dump di ambiente. ID interni nei corpi delle risposte. Il genere di cose che finisce in un report P1.

**Esegui 36 passaggi di attacco nel tuo browser.** Auth bypass, BAC, IDOR, CORS reflection, JWT alg=none, SSTI, XXE, CRLF injection, prototype pollution, parameter discovery, API version downgrade. Tre livelli di aggressività: careful, medium, full. Incolla header personalizzati. La modalità stealth mescola l'ordine delle richieste per non innescare un WAF.

**Collega risultati individuali in exploit reali.** Un JWT in memoria è un risultato. Lo stesso JWT più un endpoint API che accetta token non firmati e il ruolo decodificato che è admin è una catena — e PenScope ti mostra la catena all'inizio del report, con punteggio di confidenza, comando di riproduzione e passaggi successivi.

**Modifica e reinvia qualsiasi richiesta.** Stile clic destro. Repeater si apre in una nuova scheda, finestra intera. Cambia un parametro. Premi Invia. Vedi la risposta. Trascinalo in Diff per confrontarlo con la baseline.

**Fuzz con punti di inserimento.** Segna `§payload§` ovunque in una richiesta, scegli un set di payload (40 stringhe XSS, 30 SQLi, 28 LFI, 18 SSTI, 22 SSRF, 24 command injection, ID 1-100, classici auth bypass, nomi utente comuni), scegli una modalità di attacco (Sniper / Cluster bomb / Pitchfork / Battering ram), guarda la tabella dei risultati in tempo reale. Le righe anomale sono contrassegnate con una stella.

**Testa come cinque utenti diversi contemporaneamente.** Salva contesti di autenticazione (Anonimo, Utente A, Utente B, Admin, Interno). Un clic cambia il contesto attivo — ogni richiesta di Repeater, ogni esecuzione di Intruder, ogni sonda utilizza quelle credenziali. Quindi esegui la **Authorization Matrix**: PenScope percorre ogni endpoint × ogni contesto e colora una griglia. Le discrepanze tra le righe sono i tuoi risultati IDOR/BAC, individuati automaticamente.

**Genera un CSP che si adatti effettivamente al sito.** Analizza ogni richiesta fatta dalla pagina, classifica ciascuna per tipo di risorsa, costruisce una politica restrittiva. Aggiunge `default-src 'none'`, `frame-ancestors 'none'`, `upgrade-insecure-requests`. Rileva script inline e `eval()` e avvisa quando ha dovuto mantenere `'unsafe-inline'`. Confronta con il CSP esistente — verde per rafforzato, rosso per indebolito.

**Parla con Claude in entrambe le direzioni.** Clicca `→ Claude` per inviare l'intera scansione negli appunti come brief strutturato. Chiedi a Claude cosa testare dopo. Claude risponde con una coda JSON delimitata. Clicca `⟳ Sync from Claude` e PenScope analizza la coda, esegue ogni attacco contro il target live e reinserisce i risultati nell'analizzatore di catene.

**Tieni traccia del tuo scope nel tempo.** Scatta un'istantanea di un sito oggi, scattala di nuovo al prossimo sprint, clicca Confronta. PenScope ti dice quali risultati sono nuovi, quali sono risolti, quali non sono cambiati. Esporta la differenza come Markdown per Slack del team.

**Mappa i risultati ai controlli di compliance.** Clicca Compliance Audit. Ogni risultato viene mappato a controlli specifici in PCI-DSS v4, NESA UAE IAS, SAMA CSF, DESC ISR, ISO 27001, OWASP Top 10 2021 e CWE. Esporta JSON per il tuo SIEM. Esporta PDF per il revisore.

---

## Hunt Mode

Clicca `🎯 Hunt` nell'intestazione del popup. Si apre una nuova scheda. Il **pannello pre-volo** in basso mostra lo stato del motore: endpoint catturati, segreti, tecnologia rilevata, contesti di autenticazione salvati — così sai se hai abbastanza superficie per una caccia produttiva prima di cliccare Start. Se gli endpoint < 20, un avviso giallo suggerisce di navigare prima il target OPPURE affidarsi al nuovo passo di auto-crawl del DOM. Configura il tuo scope target (percorsi in-scope, percorsi out-of-scope, livello di aggressività, budget di tempo). Clicca `▶ Start Hunt`.

PenScope autonomamente:

1. Effettua la ricognizione passiva
2. **Abilita automaticamente la modalità Deep** (il debugger CDP si collega silenziosamente — nessun prompt per l'utente)
3. **Auto-crawl del DOM** — analizza ogni `<a href>`, `<form action>`, ``, `[routerLink]`, `[ng-href]`, `[to]`, `[data-href]` nella pagina corrente. Filtra per URL dello stesso dominio. Aggiunge nuovi URL alla coda di probe. _Pura estrazione di URL — nessun clic, nessuna navigazione, nessun effetto collaterale che cambi la sessione._
4. Esegue l'intera pipeline di probe a 36 passi + 8 pacchetti di attacco consapevoli dello stack
5. Spazza la **Authorization Matrix** attraverso i contesti di autenticazione salvati
6. Esegue il correlatore di catene, filtra in base alle tue regole di scope
7. **Redige un report completo in formato HackerOne per ogni risultato Critical e High** — catene *e* risultati individuali ad alta gravità (segreti esposti, JWT alg=none, SSTI/XXE/CRLF confermati). Ogni bozza include titolo, gravità con stima CVSS, riepilogo, passaggi per riprodurre con curl in due fasi (probe senza autenticazione + baseline autenticata per il diff), dichiarazione di impatto specifica per il risultato, fix suggerito dalla libreria di snippet e riferimenti
8. Invia una notifica Chrome per ogni critico: _"Hunt Mode ha trovato un IDOR Critico su /api/users — bozza del report pronta"_
9. Salva le bozze in `chrome.storage.local` indicizzate per host (sopravvive alla chiusura della scheda + al riavvio del browser)

La **scheda Live** narra ogni passo del filtro in tempo reale: conteggio catene prima/dopo il filtro di scope, distribuzione della gravità, cosa è stato scartato e perché. Se la caccia termina con 0 report, un diagnostico "Perché nessun report?" ti guida attraverso ogni punto del filtro con suggerimenti concreti ("deseleziona filtro Critical+High", "salva 2+ contesti di autenticazione", "naviga prima di più il target"). Niente più dubbi sul perché una caccia sia risultata vuota.

**Ti svegli con una coda di report di bounty già scritti.** Leggi ciascuno, clicca Copia o Esporta, incolla nella tua segnalazione HackerOne / Bugcrowd / Intigriti.

Questo è il flusso di lavoro che Burp non tenta nemmeno. Lo scanner attivo di Burp esegue attacchi ma devi comunque scrivere il report. PenScope possiede l'intero percorso dalla scansione → exploit → report → invio.

> Imposta lo scope. Premi Start. Chiudi il laptop. Svegliati con una coda di Critical pronti.

### Controlli di qualità — mantieni la tua reputazione

La modalità Hunt filtra attivamente i falsi positivi che brucerebbero la tua reputazione se inviati:

- **Shell HTML SPA** — Le pagine bootstrap Angular/React/Vue restituiscono HTML identico a richieste autenticate e non autenticate perché il JS gestisce l'auth lato client. Hunt Mode rileva questo pattern (percorso termina con `.html` + `sameBody=true`) e sopprime il risultato. Le API reali segnalano ancora.
- **Token SAS Azure benigni** — URL SAS di sola lettura a breve scadenza per media (`image.jpg?sv=...&sp=r&se=...`) sono consegna CDN legittima, non fughe di credenziali. Hunt Mode controlla `sp=r` + estensione file media + `se - st < 7 giorni` e sopprime. Token SAS a lunga durata, con capacità di scrittura o non media segnalano ancora come fughe reali.
- **Normalizzazione dei frammenti hash** — `/Dashboard#!/` è una route lato client, non un endpoint server. Hunt Mode rimuove i frammenti hash prima dell'analisi delle catene in modo che il report mostri `/Dashboard` (il percorso server effettivo).
- **`baseUrl` reale in ogni curl** — l'analizzatore di catene deriva l'host target da `tab.url` (solo HTTP/HTTPS) con un fallback al primo endpoint osservato. Niente più URL segnaposto `https://target.tld` nei tuoi report.
- **Diagnostica trasparente** — ogni passo del filtro (scope, gravità, deduplicazione) registra i suoi conteggi prima/dopo nel feed live. Quando una caccia termina con 0 report, il feed termina con un blocco "Perché nessun report?" che spiega esattamente dove ogni potenziale risultato è stato scartato, con suggerimenti concreti per i passaggi successivi adattati alla tua configurazione specifica.

### Una bozza reale di Hunt Mode

Ecco un estratto oscurato da una bozza reale prodotta da Hunt Mode su un LMS governativo in 4 minuti:```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 ... ]

Plus a dedicated **JWT card**: paste a token, decode the header and payload, edit either, then forge a new one. Two forge modes:

- **alg=none** — the classic JWT auth bypass test (server trusts unsigned tokens)
- **HS256** — sign with a guessed weak secret (`secret`, `key`, `password`, `jwt-secret` are the common ones)

Output is a single token, copy-paste ready.

### Diff

Due riquadri di testo. Invia le risposte da Repeater con un clic. Premi `Compute Diff`. PenScope esegue un LCS line-diff e codifica a colori il risultato: `+` per aggiunte, `−` per rimozioni. Riepilogo dei conteggi in alto.

Questo è il killer per la conferma di IDOR. "La risposta per l'Utente A è *la stessa* di quella per l'Utente B, o il server ha effettivamente restituito i dati dell'Utente B?" Diff te lo dice in tre secondi.

### Site Map

Albero gerarchico di ogni endpoint catturato da PenScope, organizzato per host → percorso. Pillole dei metodi (`GET`, `POST`, `DELETE`...). Badge dei codici di stato per nodo, codificati a colori verde/giallo/arancione/rosso. Clicca su qualsiasi percorso per caricarlo in Repeater.

L'intera superficie d'attacco, in una vista, pronta per essere testata.

### Auth Contexts + Authorization Matrix

Questo è il differenziatore. Burp non include questa funzionalità.

Salva profili di autenticazione nominati. Ogni profilo = un nome + un insieme di cookie + un insieme di header. Creali effettuando l'accesso come ciascun utente, copiando i loro cookie di sessione + l'header Authorization, incollandoli nell'editor. Aggiungi note ("piano a pagamento", "ruolo di sola lettura", "personale interno"). Un clic cambia il contesto attivo. Ogni richiesta di Repeater / Intruder / probe ora viene inviata con quelle credenziali.

Poi clicca su `Run authorization matrix`. PenScope colpisce ogni endpoint × ogni contesto e mostra una griglia:```
                     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

                ┌──────────────────────────┐
                │   state[tabId]            │
                │   60+ fields populated by │
                │   webRequest / content /  │
                │   CDP / probe layers      │
                └──────────┬───────────────┘
                           │
   ┌───────────────────────┼───────────────────────┐
   │                       │                       │

**Un motore, tre modalità, tre superfici.** Il motore dati è indipendente dalla modalità — ogni campo di stato viene raccolto allo stesso modo indipendentemente dalla vista in cui ci si trova. Le modalità sono scelte di tema + renderer sugli stessi dati. La Workbench e la Hunt Mode sono schede Chrome autonome che condividono `state[tabId]` tramite gestori di messaggi in background.

Gli override delle variabili CSS (`body.mode-red`, `body.mode-blue`) ri-tematizzano tutto senza toccare un singolo selettore di regole. Ecco perché la Classic mode è identica byte per byte all'esperienza v5.9.

---

## Performance

PenScope è su ogni scheda, sempre. Per impostazione predefinita, evita l'arricchimento costoso per ~50 suffissi di host rumorosi noti (CDN video come `googlevideo.com`, reti pubblicitarie come `doubleclick.net`, endpoint di telemetria come `sentry.io`, grandi CDN statiche come `gstatic.com`). Centinaia di richieste di chunk di `googlevideo.com` al minuto su YouTube non passano più attraverso 14 regex AUTH_PATTERN + rilevamento parametri percorso + ricerca Swagger — vengono registrate come endpoint (quindi la Site Map le include ancora) e saltate per il resto.

Stesso percorso veloce per i tipi di risorsa `image`/`media`/`font`/`stylesheet`/`object`/`ping` su qualsiasi host. I bug quasi mai si nascondono nei parametri URL `.css`.

Le riescansioni DOM degli script di contenuto vengono eseguite tramite `requestIdleCallback` (con un intervallo minimo di 15 secondi tra le scansioni) e saltano completamente quando la scheda è nascosta. MutationObserver filtra le modifiche di solo testo (ticchettii di timer, aggiornamenti di dati carattere) in modo che il continuo rimescolamento DOM di YouTube non inneschi una riescrizione completa ogni 3 secondi.

Override disponibile: casella di controllo **"Full capture on noisy hosts"** nel menu a discesa Probe. Quando si esegue specificamente un audit di YouTube/Twitch/Sentry/ecc. COME target, spuntarla e il percorso veloce viene bypassato.

---

## I 45 attacchi probe

Eseguiti su richiesta. Tre livelli di aggressività con un contratto vincolante: **Careful** = solo GET/HEAD/OPTIONS con un intervallo minimo di 200 ms tra le richieste; **Medium** = aggiunge POST per operazioni di lettura-shape (≤3 paralleli); **Full** = tutti i metodi inclusi DELETE/PUT/PATCH più raffiche di race condition (≤10 paralleli). Intestazioni personalizzate incollate in ogni richiesta. La modalità Stealth mescola l'ordine dei passi con Fisher-Yates e aggiunge un jitter dello 0–80% ai ritardi tra i passi. Il metodo previsto per ogni passo viene controllato a secco rispetto al livello attivo all'avvio del probe; i passi bloccati sono elencati nel registro diagnostico.

| # | Attacco | Cosa fa |
|---|---|---|
| 1 | GraphQL introspection | Scarica schema, tipi, query, mutazioni |
| 2 | Source map harvesting | Scarica `.map`, estrae segreti + endpoint |
| 3 | Swagger/OpenAPI fetch | `/swagger.json`, `/openapi.json`, ecc. |
| 4 | OPTIONS preflight | Preflight CORS su ogni percorso API |
| 5 | Recon path probing | `/admin`, `/.env`, `/.git/HEAD`, `/actuator` |
| 6 | API prefix suffix brute | `/api/v1/<parola>` |
| 7 | Smart suffix bruteforce | Prefisso × suffisso mescolato furtivamente |
| 8 | BAC (broken access control) | Endpoint che modificano lo stato non autenticati |
| 9 | IDOR auto-test | Sostituzione ID + confronto stesso corpo |
| 10 | CORS reflection test | Riflessione dell'Origine con credenziali |
| 11 | Method tampering | Scambio GET/POST/PUT/PATCH/DELETE |
| 12 | Open redirect probe | Varianti `?redirect=evil.com` |
| 13 | Race condition probe | Richieste concorrenti su endpoint sensibili all'idempotenza |
| 14 | HTTP parameter pollution | `?id=1&id=2` |
| 15 | Subdomain enumeration | Da log CT + traffico osservato |
| 16 | GraphQL field fuzzing | Sonda ogni campo introspettato per l'autenticazione |
| 17 | JWT alg=none acceptance | Il server si fida di token non firmati? |
| 18 | Host header injection | Varianti `X-Forwarded-Host` |
| 19 | Cache poisoning | Iniezione di intestazione non chiavata |
| 20 | IDOR confirmed sameBody | Somiglianza del corpo tra ID |
| 21 | Auth removal test | Rimuovi cookie, cerca 200 |
| 22 | CSRF validation gap | Endpoint che modificano lo stato senza token |
| 23 | gRPC reflection | Servizio di riflessione gRPC esposto |
| 24 | Compression oracle (BREACH) | Euristico, non sfrutta effettivamente |
| 25 | WebSocket hijacking | Connessioni WS cross-origin |
| 26 | Cache poison probe | Input non chiavato basato su intestazione |
| 27 | Timing oracle | Variazione di tempistica sullo stesso endpoint |
| 28 | COOP/COEP bypass | Forza isolamento cross-origin |
| 29 | Storage partition | Isolamento storage cross-sito |
| 30 | Smart recursive discovery | 3 ondate di probing, concatenate dalle risposte precedenti |
| 31 | Parameter discovery | 38 parametri nascosti brute (`debug`, `admin`, `_method`, `bypass`...) |
| 32 | SSTI probing | `{{7*7}}`, `${7*7}`, `<%=7*7%>` |
| 33 | XXE probing | XML con entità esterne |
| 34 | CRLF injection | `%0d%0a` nei parametri di reindirizzamento |
| 35 | API version downgrade | `/v1/`, `/v2/` per ogni `/vN/` osservato |
| 36 | Prototype pollution | `__proto__` / `constructor.prototype` nei corpi JSON |
| 37 | SSRF param probing | 26 nomi di parametri SSRF con payload di metadati cloud; segnala contenuto metadati riflesso |
| 38 | NoSQL operator injection | `{"$ne":null}` / `{"$gt":""}` / `{"$exists":true}` su campi ID JSON |
| 39 | GraphQL alias amplification | Query con 50 alias → superficie amplificazione DoS (solo full) |
| 40 | GraphQL batch amplification | Batch array JSON di 25 elementi → amplificazione DoS (solo full) |
| 41 | Cache deception | Stile `/api/me/avatar.css` — contenuto sensibile memorizzato nella cache dietro estensioni statiche |
| 42 | Subdomain takeover | Probe in stile HEAD dei sottodomini acquisiti; corrisponde alle firme di takeover GitHub Pages / S3 / Heroku / Netlify / Vercel / Bitbucket / Shopify |
| 43 | TabNabbing | `<a target="_blank">` cross-origin senza `rel="noopener"` |
| 44 | postMessage origin correlation | Listener `addEventListener("message")` senza controlli di origine |
| 45 | Service Worker scope abuse | Segnala ambiti SW ampi (soprattutto `/`) |

Più **8 pacchetti di attacco consapevoli dello stack** che si attivano automaticamente quando la Red mode rileva il framework corrispondente: Laravel, Spring Boot, Rails, ASP.NET, Django, Next.js, GraphQL, WordPress. Ogni pacchetto ha 4–9 test specifici dello stack. Il solo pacchetto di Spring Boot colpisce `/actuator/heapdump`, `/actuator/env`, `/jolokia/list`, `/h2-console`.

---

## I 13 schemi di catena

I singoli risultati sono rumore. I risultati composti sono exploit. L'analizzatore di catene di PenScope esamina l'intero stato ed emette catene in cui più segnali si combinano in qualcosa di sfruttabile.

1. **Auth bypass su endpoint sensibile** — autenticazione mancante confermata + percorso admin/billing/utente
2. **BAC distruttivo** — endpoint vulnerabile con `delete`/`remove`/`purge` nel percorso
3. **Mutazione GraphQL vulnerabile a CSRF** — CSRF mancante confermato + è una mutazione
4. **Token auth esposto + API attiva** — JWT in memoria + endpoint corrispondenti
5. **IDOR confermato con dati sensibili** — risposta con stessa struttura tra ID
6. **Riflessione CORS CON credenziali** — bypass completo SOP
7. **Reindirizzamento aperto su flusso di autenticazione** — parametro di reindirizzamento su percorsi callback OAuth
8. **Route admin nascoste** — 3+ percorsi admin nel codice mai osservati nel traffico
9. **JWT alg=none accettato** — il server si fida di token non firmati
10. **Segreti trapelati da source map** — file `.map` distribuiti in produzione con chiavi hardcoded
11. **Perdita IP interno WebRTC** — IP privati esposti tramite STUN
12. **Cluster di risultati di probe ricorsivo** — 3+ risultati sensibili su più endpoint
13. **Superficie RCE specifica dello stack** — pacchetto stack ha trovato actuator/Ignition/ecc. esposti

Ogni catena ha una gravità, un riepilogo, un comando di riproduzione, i passi successivi e un punteggio di confidenza. Ordinato per `severity × confidence`. Visualizzato nella parte superiore della Red mode e nella parte superiore di ogni report Claude.

---

## Punteggio di salute (Blue mode)```
score = max(10, 100 − min(90, crit×22 + high×9))

I quattro vecchi file di riferimento (`red-attacks.js`, `blue-fixes.js`, `blue-csp.js`, `blue-compliance.js`) sono stati rimossi nella v6.3 — il loro contenuto era già stato integrato in `popup.js` / `background.js` dalla v6.0; i file standalone erano codice morto. `STACK_ATTACK_PACKS` è ora un vero export di modulo ES da `src/probe/stack-packs.js`.

---

## Nessun passaggio di build```bash
git clone https://github.com/spider12223/PenScope
# That's it.