Pin die Erweiterung. Besuche eine beliebige Website. Klicke auf das **P**-Symbol. PenScope hat bereits beobachtet.

---

## Was du tun kannst

PenScope erfasst über 60 Datenfelder pro Tab. Was das in der Praxis bedeutet:

**Sieh die gesamte Angriffsfläche.** Jeder Endpunkt, einschließlich derer, die in JavaScript referenziert, aber nie aufgerufen werden. API-Pfade, die in Source Maps vergraben sind, GraphQL-Operationen, die aus POST-Bodies rekonstruiert wurden, versteckte Admin-Routen, die aus Framework-Introspection abgeleitet wurden.

**Finde Geheimnisse, die niemand ausliefern wollte.** API-Keys, die in `.js`-Bundles fest kodiert sind. JWTs im `localStorage`. AWS-Anmeldeinformationen in Umgebungsdumps. Interne IDs in Response-Bodies. Die Art von Dingen, die in einem P1-Report landen.

**Führe 36 Angriffsschritte in deinem Browser aus.** Auth Bypass, BAC, IDOR, CORS Reflection, JWT alg=none, SSTI, XXE, CRLF Injection, Prototype Pollution, Parameter Discovery, API Version Downgrade. Drei Aggressionsstufen – Vorsichtig, Mittel, Voll. Benutzerdefinierte Header einfügbar. Stealth-Modus mischt die Reihenfolge der Anfragen, sodass du kein WAF auslöst.

**Verkette einzelne Funde zu echten Exploits.** Ein JWT im Speicher ist ein Fund. Derselbe JWT plus ein API-Endpunkt, der unsignierte Token akzeptiert, plus die dekodierte Rolle, die Admin ist, ist eine Kette – und PenScope zeigt dir die Kette oben im Report, mit Konfidenzwert, Reproduktionsbefehl und nächsten Schritten.

**Bearbeite und sende jede Anfrage erneut.** Im Rechtsklick-Stil. Repeater öffnet sich in einem neuen Tab, im Vollfenster. Ändere einen Parameter. Drücke Senden. Sieh die Antwort. Lege sie in Diff ab, um sie mit der Baseline zu vergleichen.

**Fuzze mit Einfügepunkten.** Markiere `§payload§` irgendwo in einer Anfrage, wähle ein Payload-Set (40 XSS-Strings, 30 SQLi, 28 LFI, 18 SSTI, 22 SSRF, 24 Command Injection, IDs 1-100, Auth Bypass-Klassiker, gängige Benutzernamen), wähle einen Angriffsmodus (Sniper / Cluster bomb / Pitchfork / Battering ram), beobachte die Live-Ergebnistabelle. Anomalie-Zeilen werden mit einem Stern markiert.

**Teste gleichzeitig als fünf verschiedene Benutzer.** Speichere Auth-Kontexte (Anonym, Benutzer A, Benutzer B, Admin, Intern). Ein Klick wechselt den aktiven Kontext – jede Repeater-Anfrage, jeder Intruder-Durchlauf, jeder Probe verwendet diese Anmeldeinformationen. Führe dann die **Authorization Matrix** aus: PenScope durchläuft jeden Endpunkt × jeden Kontext und färbt ein Raster farblich ein. Abweichungen zwischen den Zeilen sind deine IDOR-/BAC-Funde, automatisch aufgedeckt.

**Erzeuge ein CSP, das wirklich zur Website passt.** Durchläuft jede Anfrage, die die Seite gemacht hat, klassifiziert jede nach Ressourcentyp, erstellt eine strenge Richtlinie. Fügt `default-src 'none'`, `frame-ancestors 'none'`, `upgrade-insecure-requests` hinzu. Erkennt Inline-Skripte und `eval()` und warnt, wenn es `'unsafe-inline'` behalten musste. Hebt Abweichungen zum bestehenden CSP hervor – grün für verschärft, rot für gelockert.

**Kommuniziere mit Claude in beide Richtungen.** Klicke auf `→ Claude`, um den gesamten Scan als strukturierte Zusammenfassung in die Zwischenablage zu kopieren. Frage Claude, was als nächstes getestet werden soll. Claude antwortet mit einem JSON-Queue in einem Codeblock. Klicke auf `⟳ Sync from Claude` und PenScope parst die Queue, führt jeden Angriff gegen das Live-Ziel aus und speist die Ergebnisse zurück in den Chain Analyzer.

**Verfolge deinen Scope im Zeitverlauf.** Erstelle einen Snapshot einer Website heute, erstelle einen weiteren nächsten Sprint, klicke auf Vergleichen. PenScope zeigt dir, welche Funde neu sind, welche behoben wurden, welche sich nicht verändert haben. Exportiere den Diff als Markdown für den Team-Slack.

**Ordne Funde Compliance-Kontrollen zu.** Klicke auf Compliance Audit. Jeder Fund wird bestimmten Kontrollen in PCI-DSS v4, NESA UAE IAS, SAMA CSF, DESC ISR, ISO 27001, OWASP Top 10 2021 und CWE zugeordnet. Exportiere JSON für dein SIEM. Exportiere PDF für den Auditor.

---

## Hunt-Modus

Klicke im Popup-Header auf `🎯 Hunt`. Ein neuer Tab öffnet sich. Das **Pre-Flight-Panel** unten zeigt den Engine-Status – erfasste Endpunkte, Secrets, erkannte Technologien, gespeicherte Auth-Kontexte – sodass du weißt, ob du genug Angriffsfläche für eine erfolgreiche Jagd hast, bevor du auf Start klickst. Wenn Endpunkte < 20, erscheint eine gelbe Warnung, die vorschlägt, das Ziel zuerst zu durchsuchen ODER sich auf den neuen DOM-Auto-Crawl-Schritt zu verlassen. Konfiguriere deinen Ziel-Scope (In-Scope-Pfade, Out-of-Scope-Pfade, Aggressionsstufe, Zeitbudget). Klicke auf `▶ Start Hunt`.

PenScope autonom:

1. Führt passive Reconnaissance durch
2. **Aktiviert automatisch den Deep-Modus** (CDP-Debugger wird still angehängt – keine Benutzerabfrage)
3. **DOM-Auto-Crawl** – durchläuft jedes `<a href>`, `<form action>`, ``, `[routerLink]`, `[ng-href]`, `[to]`, `[data-href]` auf der aktuellen Seite. Filtert auf Same-Origin-URLs. Fügt neue zur Probe-Queue hinzu. _Reine URL-Extraktion – kein Klicken, keine Navigation, keine Session-ändernden Nebeneffekte._
4. Führt die vollständige 36-Schritte-Probe-Pipeline + 8 Stack-bewusste Angriffspakete aus
5. Durchläuft die **Authorization Matrix** über alle gespeicherten Auth-Kontexte
6. Führt den Chain Correlator aus, filtert nach deinen Scope-Regeln
7. **Erstellt einen vollständigen HackerOne-format Report für jeden Critical- und High-Fund** – Chains *und* einzelne High-Severity-Funde (offengelegte Secrets, JWT alg=none, bestätigte SSTI/XXE/CRLF). Jeder Entwurf enthält Titel, Severity mit CVSS-Schätzung, Zusammenfassung, Schritte zur Reproduktion mit Zwei-Schritt-curl (No-Auth-Probe + Auth-Baseline für Diff), auf den Fund zugeschnittene Impact-Beschreibung, vorgeschlagene Lösung aus der Snippet-Bibliothek und Referenzen
8. Sendet eine Chrome-Benachrichtigung pro Critical: _"Hunt Mode hat einen kritischen IDOR auf /api/users gefunden – Report-Entwurf bereit"_
9. Speichert Entwürfe in `chrome.storage.local`, keyed by Host (überlebt Tab-Schließen + Browser-Neustart)

Der **Live-Tab** erzählt jeden Filter-Schritt in Echtzeit – Chain-Anzahl vor/nach Scope-Filter, Severity-Verteilung, was verworfen wurde und warum. Wenn die Jagd mit 0 Reports endet, führt ein "Warum keine Reports?"-Diagnose durch jeden Filterpunkt mit konkreten Vorschlägen ("Critical+High-Filter deaktivieren", "2+ Auth-Kontexte speichern", "das Ziel zuerst mehr durchsuchen"). Keine Rätselraten mehr, warum eine Jagd leer ausgegangen ist.

**Du wachst auf mit einer Warteschlange fertig geschriebener Bounty-Reporte.** Lies jeden, klicke auf Kopieren oder Exportieren, füge sie in deine HackerOne / Bugcrowd / Intigriti-Einreichung ein.

Dies ist der Workflow, den Burp nicht einmal versucht. Burps Active Scanner führt Angriffe aus, aber du musst trotzdem den Report schreiben. PenScope besitzt den gesamten Pfad vom Scan → Exploit → Report → Einreichung.

> Scope setzen. Auf Start drücken. Laptop schließen. Aufwachen mit einer Warteschlange verfasster Criticals.

### Qualitätskontrollen – schütze deinen Ruf

Der Hunt-Modus filtert aktiv False Positives, die deinen Ruf bei Einreichung schädigen würden:

- **SPA HTML-Shells** – Angular/React/Vue-Bootstrap-Seiten geben identisches HTML für authentifizierte und nicht authentifizierte Anfragen zurück, weil das JS Auth clientseitig behandelt. Der Hunt-Modus erkennt dieses Muster (Pfad endet auf `.html` + `sameBody=true`) und unterdrückt den Fund. Echte APIs werden weiterhin gemeldet.
- **Harmlose Azure SAS-Token** – kurzlebige Read-Only-SAS-URLs für Medien (`image.jpg?sv=...&sp=r&se=...`) sind legitime CDN-Auslieferung, keine Credential-Leaks. Der Hunt-Modus prüft `sp=r` + Mediendatei-Endung + `se - st < 7 Tage` und unterdrückt sie. Langlebige, schreibfähige oder Nicht-Medien-SAS-Token werden weiterhin als echte Leaks gemeldet.
- **Hash-Fragment-Normalisierung** – `/Dashboard#!/` ist eine clientseitige Route, kein Server-Endpunkt. Der Hunt-Modus entfernt Hash-Fragmente vor der Chain-Analyse, sodass der Report `/Dashboard` (den tatsächlichen Server-Pfad) zeigt.
- **Echte `baseUrl` in jedem curl** – der Chain Analyzer leitet den Ziel-Host aus `tab.url` ab (nur HTTP/HTTPS) mit einem Fallback auf den ersten beobachteten Endpunkt. Keine `https://target.tld`-Platzhalter-URLs mehr in deinen Reports.
- **Transparente Diagnose** – jeder Filter-Schritt (Scope, Severity, Deduplizierung) protokolliert seine Vorher/Nachher-Zählungen im Live-Feed. Wenn eine Jagd mit 0 Reports endet, endet der Feed mit einem "Warum keine Reports?"-Block, der genau erklärt, wo jeder potenzielle Fund verworfen wurde, mit konkreten nächsten Schritten, die auf deine spezifische Konfiguration zugeschnitten sind.

### Ein echter Hunt-Modus-Entwurf

Hier ein bearbeiteter Auszug aus einem tatsächlichen Entwurf, den der Hunt-Modus in 4 Minuten auf einer Regierungs-LMS produziert hat:```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

Two text panes. Send responses from Repeater with one click. Hit `Compute Diff`. PenScope runs an LCS line-diff and color-codes the result: `+` for added, `−` for removed. Summary count at the top.

This is the IDOR-confirmation killer. "Is the response for User A *the same* as for User B, or did the server actually return User B's data?" Diff tells you in three seconds.

### Site Map

Hierarchical tree of every endpoint PenScope captured, organized by host → path. Method pills (`GET`, `POST`, `DELETE`...). Status code badges per node, color-coded green/yellow/orange/red. Click any path to load it into Repeater.

The full attack surface, in one view, ready to test.

### Auth Contexts + Authorization Matrix

This is the differentiator. Burp doesn't ship this.

Save named auth profiles. Each profile = a name + a set of cookies + a set of headers. Build them by logging in as each user, copying their session cookies + Authorization header, pasting into the editor. Add notes ("paid plan", "read-only role", "internal staff"). One click switches the active context. Every Repeater / Intruder / probe request now fires with those credentials.

Then click `Run authorization matrix`. PenScope hits every endpoint × every context and renders a grid:```
                     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      │
                └──────────┬───────────────┘
                           │
   ┌───────────────────────┼───────────────────────┐
   │                       │                       │

**Eine Engine, drei Modi, drei Oberflächen.** Die Daten-Engine ist modusunabhängig – jedes Zustandsfeld wird unabhängig davon, in welcher Ansicht Sie sich befinden, auf die gleiche Weise erfasst. Modi sind Themen + Renderer-Auswahlen über denselben Daten. Der Workbench- und der Hunt-Modus sind eigenständige Chrome-Tabs, die `state[tabId]` über Hintergrundnachrichten-Handler gemeinsam nutzen.

CSS-Variablen-Überschreibungen (`body.mode-red`, `body.mode-blue`) ändern das gesamte Design, ohne einen einzigen Selektoren-Regel zu berühren. Deshalb ist der Classic-Modus bytegenau die v5.9-Erfahrung.

---

## Performance

PenScope ist auf jedem Tab, die ganze Zeit. Standardmäßig wird die teure Aufbereitung für etwa 50 bekannte laute Host-Suffixe abgekürzt (Video-CDN wie `googlevideo.com`, Werbenetzwerke wie `doubleclick.net`, Telemetrie-Endpunkte wie `sentry.io`, große statische CDNs wie `gstatic.com`). Hunderte von `googlevideo.com`-Chunk-Anfragen pro Minute auf YouTube durchlaufen nicht mehr 14 AUTH_PATTERN-Regexe + Pfadparameter-Erkennung + Swagger-Suche – sie werden als Endpunkte protokolliert (damit die Site Map sie weiterhin enthält) und für den Rest übersprungen.

Gleicher schneller Pfad für `image`/`media`/`font`/`stylesheet`/`object`/`ping`-Ressourcentypen auf jedem Host. Fehler verstecken sich fast nie in `.css`-URL-Parametern.

Content-Script-DOM-Rescans werden über `requestIdleCallback` ausgeführt (mit einer harten 15-Sekunden-Untergrenze zwischen Scans) und werden vollständig übersprungen, wenn der Tab ausgeblendet ist. MutationObserver filtert reine Textänderungen (Timer-Ticks, Zeichendaten-Updates), sodass die ständige DOM-Änderung von YouTube nicht alle 3 Sekunden einen vollständigen Rescan auslöst.

Überschreibung verfügbar: **"Full capture on noisy hosts"**-Kontrollkästchen im Probe-Dropdown. Wenn Sie speziell YouTube/Twitch/Sentry/etc. ALS Ziel prüfen, aktivieren Sie es, und der schnelle Pfad wird umgangen.

---

## Die 45 Probe-Angriffe

Auf Abruf ausführbar. Drei Aggressionsstufen mit einem durchgesetzten Vertrag: **Careful** = nur GET/HEAD/OPTIONS mit mindestens 200ms Abstand zwischen den Anfragen; **Medium** = fügt POST für Lese-shape-Operationen hinzu (≤3 parallel); **Full** = alle Methoden einschließlich DELETE/PUT/PATCH plus Race-Condition-Bursts (≤10 parallel). Benutzerdefinierte Header werden in jede Anfrage eingefügt. Der Stealth-Modus mischt die Schritt-Reihenfolge mit Fisher-Yates und fügt eine Verzögerungs-Jitter von 0–80% zwischen den Schritten hinzu. Die erwartete Methode jedes Schrittes wird zu Beginn des Probes im Trockentest gegen die aktive Stufe geprüft; blockierte Schritte werden im Diagnoseprotokoll aufgelistet.

| # | Attack | What it does |
|---|---|---|
| 1 | GraphQL-Introspection | Dumpft Schema, Typen, Abfragen, Mutationen |
| 2 | Source-Map-Harvesting | Lädt `.map` herunter, extrahiert Geheimnisse + Endpoints |
| 3 | Swagger/OpenAPI-Abruf | `/swagger.json`, `/openapi.json`, etc. |
| 4 | OPTIONS-Preflight | CORS-Preflight auf jedem API-Pfad |
| 5 | Recon-Pfad-Sondierung | `/admin`, `/.env`, `/.git/HEAD`, `/actuator` |
| 6 | API-Präfix-Suffix-Brute | `/api/v1/<wort>` |
| 7 | Intelligentes Suffix-Brute-Force | Stealth-gemischtes Präfix × Suffix |
| 8 | BAC (Broken Access Control) | Zustandsändernde Endpunkte ohne Authentifizierung |
| 9 | IDOR-Autotest | ID-Ersetzung + gleicher Body-Vergleich |
| 10 | CORS-Reflection-Test | Ursprungsreflexion mit Credentials |
| 11 | Methoden-Tampering | GET/POST/PUT/PATCH/DELETE-Vertauschungen |
| 12 | Open-Redirect-Sonde | `?redirect=evil.com`-Varianten |
| 13 | Race-Condition-Sonde | Gleichzeitige Anfragen auf idempotenz-sensitive Endpoints |
| 14 | HTTP-Parameter-Verschmutzung | `?id=1&id=2` |
| 15 | Subdomain-Enumeration | Aus CT-Logs + beobachtetem Traffic |
| 16 | GraphQL-Feld-Fuzzing | Testet jedes introspizierte Feld auf Auth |
| 17 | JWT alg=none-Akzeptanz | Vertraut der Server unsignierten Tokens? |
| 18 | Host-Header-Injection | `X-Forwarded-Host`-Varianten |
| 19 | Cache-Poisoning | Unkeyed-Header-Injection |
| 20 | IDOR bestätigt sameBody | Body-Ähnlichkeit über IDs hinweg |
| 21 | Auth-Entfernungstest | Cookies entfernen, nach 200ern suchen |
| 22 | CSRF-Validierungslücke | Zustandsändernde Endpoints ohne Token |
| 23 | gRPC-Reflection | Exponierter gRPC-Reflection-Service |
| 24 | Kompressionsorakel (BREACH) | Heuristisch, nutzt nicht tatsächlich aus |
| 25 | WebSocket-Entführung | Cross-Origin-WS-Verbindungen |
| 26 | Cache-Poison-Sonde | Header-basierte unkeyed-Eingabe |
| 27 | Timing-Orakel | Zeitvarianz am selben Endpoint |
| 28 | COOP/COEP-Umgehung | Cross-Origin-Isolation-Stärke |
| 29 | Speicherpartition | Cross-Site-Speicher-Isolation |
| 30 | Intelligente rekursive Erkennung | 3 Wellen der Sondierung, verknüpft aus vorherigen Antworten |
| 31 | Parameter-Erkennung | 38 versteckte Parameter-Brute (`debug`, `admin`, `_method`, `bypass`...) |
| 32 | SSTI-Sondierung | `{{7*7}}`, `${7*7}`, `<%=7*7%>` |
| 33 | XXE-Sondierung | XML mit externen Entitäten |
| 34 | CRLF-Injection | `%0d%0a` in Redirect-Parametern |
| 35 | API-Versions-Herabstufung | `/v1/`, `/v2/` für jedes beobachtete `/vN/` |
| 36 | Prototype-Pollution | `__proto__` / `constructor.prototype` in JSON-Bodies |
| 37 | SSRF-Parameter-Sondierung | 26 SSRF-Parameternamen mit Cloud-Metadaten-Payloads; kennzeichnet reflektierte Metadaten-Inhalte |
| 38 | NoSQL-Operator-Injection | `{"$ne":null}` / `{"$gt":""}` / `{"$exists":true}` auf JSON-ID-Feldern |
| 39 | GraphQL-Alias-Amplifikation | 50-Alias-Abfrage → DoS-Amplifikationsoberfläche (nur Full) |
| 40 | GraphQL-Batch-Amplifikation | 25-Element-JSON-Array-Batch → DoS-Amplifikation (nur Full) |
| 41 | Cache-Täuschung | `/api/me/avatar.css`-Stil – sensible Inhalte hinter statischen Erweiterungen gecacht |
| 42 | Subdomain-Übernahme | HEAD-artige Sondierung erfasster Subdomains; erkennt GitHub Pages / S3 / Heroku / Netlify / Vercel / Bitbucket / Shopify-Übernahme-Signaturen |
| 43 | TabNabbing | Cross-Origin `<a target="_blank">` ohne `rel="noopener"` |
| 44 | postMessage-Ursprungskorrelation | `addEventListener("message")`-Listener ohne Ursprungsprüfung |
| 45 | Service Worker-Bereichsmissbrauch | Kennzeichnet breite SW-Bereiche (besonders `/`) |

Plus **8 stack-bewusste Angriffspakete**, die automatisch feuern, wenn der Red-Modus das passende Framework erkennt: Laravel, Spring Boot, Rails, ASP.NET, Django, Next.js, GraphQL, WordPress. Jedes Paket enthält 4–9 stack-spezifische Tests. Allein das Spring-Boot-Paket trifft `/actuator/heapdump`, `/actuator/env`, `/jolokia/list`, `/h2-console`.

---

## Die 13 Kettenmuster

Einzelne Funde sind Rauschen. Zusammengesetzte Funde sind Exploits. PenScopes Kettenanalysator durchläuft den gesamten Zustand und gibt Ketten aus, bei denen mehrere Signale zu etwas Ausnutzbarem kombiniert werden.

1. **Auth-Bypass auf sensiblen Endpoint** – bestätigte fehlende Auth + Admin-/Billing-/User-Pfad
2. **Destruktives BAC** – anfälliger Endpoint mit `delete`/`remove`/`purge` im Pfad
3. **CSRF-anfällige GraphQL-Mutation** – bestätigte fehlende CSRF + es ist eine Mutation
4. **Exponiertes Auth-Token + Live-API** – JWT im Speicher + passende Endpoints
5. **Bestätigtes IDOR mit sensiblen Daten** – gleiches Skelett-Antwort über IDs hinweg
6. **CORS-Reflection MIT Credentials** – vollständige SOP-Umgehung
7. **Open-Redirect im Auth-Flow** – Redirect-Parameter auf OAuth-Callback-Pfaden
8. **Versteckte Admin-Routen** – 3+ Admin-Pfade im Code, nie im Traffic beobachtet
9. **JWT alg=none akzeptiert** – Server vertraut unsignierten Tokens
10. **Source-Map geleakte Geheimnisse** – Produktion hat `.map`-Dateien mit hartcodierten Schlüsseln ausgeliefert
11. **WebRTC-Internal-IP-Leak** – private IPs via STUN exponiert
12. **Rekursive Sondierungsfund-Cluster** – 3+ sensible Funde über mehrere Endpoints
13. **Stack-spezifische RCE-Oberfläche** – Stack-Paket fand exponierte Actuator/Ignition/etc.

Jede Kette hat einen Schweregrad, eine Zusammenfassung, einen Reproduktionsbefehl, nächste Schritte und einen Konfidenzscore. Sortiert nach `severity × confidence`. Wird oben im Red-Modus und oben in jedem Claude-Bericht angezeigt.

---

## Gesundheitswert (Blue-Modus)```
score = max(10, 100 − min(90, crit×22 + high×9))

Die vier alten Referenzdateien (`red-attacks.js`, `blue-fixes.js`, `blue-csp.js`, `blue-compliance.js`) wurden in v6.3 entfernt – ihr Inhalt war bereits seit v6.0 in `popup.js` / `background.js` integriert; die eigenständigen Dateien waren toter Code. `STACK_ATTACK_PACKS` ist jetzt ein echter ES-Modul-Export aus `src/probe/stack-packs.js`.

---

## Kein Build-Schritt```bash
git clone https://github.com/spider12223/PenScope
# That's it.