PENTEST-LAB

Eine moderne verwundbare Anwendung & Cyber Range zum Erlernen von Web-, API-, Cloud-, KI- und Blue-Team-Sicherheit durch praktische Angriffsketten.

╔═══════════════════════════════════════════════════════════════╗
║     ██████╗ ███████╗███╗   ██╗████████╗███████╗███████╗████████╗ ║
║     ██╔══██╗██╔════╝████╗  ██║╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝ ║
║     ██████╔╝█████╗  ██╔██╗ ██║   ██║   █████╗  ███████╗   ██║    ║
║     ██╔═══╝ ██╔══╝  ██║╚██╗██║   ██║   ██╔══╝  ╚════██║   ██║    ║
║     ██║     ███████╗██║ ╚████║   ██║   ███████╗███████║   ██║    ║
║     ╚═╝     ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚══════╝   ╚═╝    ║
║        MODERN CYBER RANGE · 50 CHALLENGES · 8 TRACKS            ║
╚═══════════════════════════════════════════════════════════════╝

★ Markiere dieses Repository mit einem Stern, wenn es dir hilft – es ist kostenlos und hilft anderen, kostenlose Sicherheitsausbildung zu entdecken.

Was dieses Projekt anders macht

PENTEST-LAB ist keine weitere einzelne Schwachstellen-Box. Es ist eine vollständige Cyber Range, die die Perspektiven von Angreifer und Verteidiger mit GRC-artigem Evidenz-Output kombiniert:

• 50 Herausforderungen in 8 Pfaden – Web, API, Auth/Session, Cloud/DevOps, KI-Sicherheit, Geschäftslogik, Angriffskette, Blue-Team-Evidenz.
• Zentrales Challenge-Register – eine einzige Quelle der Wahrheit, die die UI, den Flag-Validator und den Evidenzgenerator speist.
• Lerne, bevor du löst – jede Challenge verlinkt zu autoritativen Referenzen (OWASP, PortSwigger, MITRE, NIST), sodass du das Konzept studieren und dann ausnutzen kannst. Flags werden durch Ausnutzen verdient, nicht in der UI angezeigt.
• Transparenter KI-Simulator – der KI-Pfad läuft auf einem inspizierbaren prozessinternen 'Modell' (kein externes LLM): du siehst den vollständigen [SYSTEM][USER][RETRIEVED][HISTORY] Kontext, die generierte Ausgabe, die erkannte Injection-Technik und Umschalter für jede Gegenmaßnahme.
• Zentraler Ereignisspeicher – jede Anfrage und jedes Flag wird protokolliert; die Verteidigeransicht basiert auf denselben Ereignissen, die der Angreifer generiert.
• Geführte Angriffskette – Recon → Information Disclosure → Token Abuse → Privilege Escalation → Data Access → Evidence Report, mit Live-Fortschritt.
• Blue-Team-Modus – fehlgeschlagene Anmeldungen, verdächtiger API-Zugriff, SSRF, Privesc, Datei-Uploads, Flag-Erfassungen und Kettenfortschritt in einem Dashboard.
• GRC-Evidenzmodus – Markdown-/JSON-/CSV-Berichte, die jeden Befund Schweregrad, Endpunkt, Evidenz, geschäftliche Auswirkung, Behebung, Kontrollbereich und eine Erkennungsmöglichkeit zuordnen. (Breite Zuordnung von Kontrollbereichen – keine Compliance-Zertifizierung.)
• Verdient, nicht enthüllt – das Flag-Feld ist gesperrt, bis du es erfasst. Das Modal zeigt den Status, nicht das wörtliche Flag, sodass du den Endpunkt tatsächlich ausnutzen musst (über den API-Tester in der UI oder deinen eigenen Client).
• Empfohlenes Nächstes + gewichteter Fortschritt – jede gelöste Challenge schlägt eine sinnvolle nächste vor, und dein Fortschrittswert gewichtet schwierigere Herausforderungen stärker als einfache (4 > 3 > 2 > 1) anstatt einer flachen Zählung.
• Tragbarer Fortschritt – exportiere deine erfassten Flags und deinen Fortschritt als Markdown-Portfolio-Artefakt, das du behalten kannst, nachdem das Labor verschwunden ist.
• Standardmäßig sicher – bindet an 127.0.0.1, warnt lautstark bei 0.0.0.0, alle Geheimnisse sind gefälscht und klar gekennzeichnet, SSRF zielt auf einen lokalen prozessinternen Mock (kein echter Netzausgang), keine externen Ziele.
• Einfach auszuführen – ein Python-Skript, eine Makefile und docker-compose.
• Selbstprüfung – make verify-registry validiert das Challenge-Register (eindeutige IDs/Flags, erforderliche Felder, Ressourcen, Hinweiszählungen), sodass der Katalog konsistent bleibt.

Schnellstart

# 1. One-liner (installs deps, seeds the DB, starts the server)
python start_lab.py
# or:  make start

Öffne http://localhost:3000 in deinem Browser.

# Backend only
cd backend && npm install && npm start

# Docker (published to 127.0.0.1 only)
docker compose up --build

# Reset captured flags / events / chain progress
make reset

# Refresh demo seed data
make seed

# Smoke test core routes (start the lab first)
make test

# Validate the challenge registry (unique ids/flags, fields, resources)
make verify-registry

# Safe local-only exploit demo (5 challenges)
python demo_exploit.py

Challenge-Pfade

Jede Challenge hat: ID, Titel, Pfad, Kategorie, Schwierigkeit, Ziel, verwundbaren Endpunkt, Ausbeutungskonzept, 3 progressive Hinweise (vage → spezifisch → Antwort), Flag, Behebung, Erkennungs-/Evidenznotizen, einen zugeordneten Kontrollbereich und eine Lerne-vor-dem-Lösen-Ressourcenliste.

Das Challenge-Modal

Klicke auf eine beliebige Challenge-Karte, um das Modal zu öffnen. Es bietet dir:

• Ziel, Endpunkt und das Ausbeutungskonzept, damit du weißt, worauf du abzielen musst.
• Lerne vor dem Lösen – autoritative Links (OWASP, PortSwigger, MITRE, NIST) zum Studieren.
• 3 progressive Hinweise – zeige sie einzeln an, wenn du nicht weiterkommst; wie viele du verwendet hast, wird pro Challenge nachverfolgt.
• Im API-Tester öffnen – springe direkt zu einer vorbereiteten Anfrage gegen den verwundbaren Endpunkt oder sende sie von deinem eigenen Client.
• Empfohlenes Nächstes – sobald gelöst, wird eine sinnvolle nächste Challenge vorgeschlagen, um deinen Lernpfad fortzusetzen.
• Vorherige / Nächste-Navigation – durch Challenges navigieren, ohne das Modal zu schließen.
• Gesperrtes Flag – das wörtliche Flag ist verborgen, bis du es durch Ausnutzen des Endpunkts erfasst. Das Modal zeigt den Status erfasst/nicht erfasst.

Angriffsketten-Modus

Eine realistische, vollständig lokale Kette in sechs erkannten Schritten:

Recon → Information Disclosure → Credential/Token Abuse →
Privilege Escalation → Sensitive Data Access → Evidence Report

B=http://127.0.0.1:3000
curl -s $B/api/attack-chain/recon    # 1. debug endpoint discloses routes
curl -s $B/api/attack-chain/leak     # 2. leaked fake JWT secret (weak123)
# 3. forge admin token -> 4. escalate -> 5. read fake customer records -> 6. report
curl -s $B/api/attack-chain/progress

Verfolge den Fortschritt live im Angriffsketten-Tab.

Blue-Team-Modus

Der Defender-Tab zeigt dieselben Aktivitäten, die der Angreifer gerade durchgeführt hat: aktuelle Ereignisse, fehlgeschlagene Anmeldungen, verdächtiger API-Zugriff, Datei-Uploads, SSRF-Versuche, Privilegienerweiterungsversuche, erfasste Flags und Angriffskettenfortschritt – jedes Ereignis farblich nach Schweregrad, Flag-Erfassungen mit 🚩 markiert.

curl -s http://localhost:3000/api/blue-team/dashboard

Evidenzbericht-Modus

Erstelle einen Bericht aus deinen erfassten Flags, der jedes einem Befund zuordnet mit Schweregrad, betroffenem Endpunkt, Evidenz, geschäftlicher Auswirkung, Behebung, Kontrollbereich und einer Erkennungsmöglichkeit.

# Markdown (default)
curl -s -X POST http://localhost:3000/api/evidence/report \
  -H 'Content-Type: application/json' -d '{"format":"markdown"}'

# JSON or CSV
curl -s -X POST http://localhost:3000/api/evidence/report -d '{"format":"csv"}'

# Control domains mapped: Access Control, Logging & Monitoring,
# Secure Development, Secrets Management, Change Management,
# Configuration Management, Data Protection, Incident Response.

⚠️ Dies ist eine breite Zuordnung von Kontrollbereichen für Erkennungs-/GRC-Lernen. Es wird keine Konformität mit einem Standard behauptet.

Screenshots / Demo

🎬 Demo-GIF: docs/demo.gif – siehe docs/DEMO_WALKTHROUGH.md für ein ~6-minütiges Präsentationsskript. (Lege deine eigenen Aufnahmen in docs/screenshots/ und docs/demo.gif ab, um die Platzhalter zu ersetzen.)

Sicherheitshinweis

Dieses Labor ist absichtlich verwundbar. Führe es nur in isolierten Umgebungen aus und setze es niemals dem Internet aus.

• Bindet standardmäßig an 127.0.0.1 (HOST=127.0.0.1 in backend/.env).
• Das Setzen von HOST=0.0.0.0 gibt eine laute Warnung aus; die UI zeigt ein Gefahrenbanner.
• Alle Geheimnisse/Tokens sind gefälscht und klar gekennzeichnet. Keine echten Anmeldeinformationen.
• SSRF-/Metadaten-Endpunkte sind lokale prozessinterne Mocks – kein echter Netzausgang.
• Keine zerstörerischen Befehle, keine Persistenz, kein Angreifen externer Systeme.

Projektstruktur

├── start_lab.py              # one-command launcher (deps + seed + run)
├── demo_exploit.py           # safe local-only exploit demo (5 challenges)
├── docker-compose.yml        # localhost-only publish
├── Makefile                  # install / start / reset / test / demo / docker
├── CHALLENGES.md             # full challenge catalog
├── frontend/                 # dashboard UI (tracks, chain, defender, evidence)
├── backend/
│   ├── server.js             # Express app, localhost bind, route wiring
│   ├── challenges/registry.js # CENTRAL challenge registry (50 challenges)
│   ├── ai/                   # TRANSPARENT AI simulator + RAG store (no external LLM)
│   ├── utils/events.js       # CENTRAL event store + Blue Team feed
│   ├── routes/               # vulnerable + mode routes (api, cloud, ai, shop, ...)
│   ├── scripts/              # init-db, seed, reset, test_routes
│   └── middleware/           # auth (safe), auth.vulnerable, waf, security
├── solutions/                # Python exploit writeups
└── docs/                     # SECURITY_REPORT, SETUP, DEMO_WALKTHROUGH

Mitwirken

Einen Fehler gefunden oder eine Challenge hinzufügen möchten? Pull Requests willkommen.

1. Halte es lokal und lehrreich – keine echten Geheimnisse, keine externen Ziele.
2. Füge neue Challenges in backend/challenges/registry.js hinzu (einzige Quelle der Wahrheit).
3. Sende Flags über events.captureFlag({ flag, req }) von einer verwundbaren Route aus.
4. Ordne die Challenge einem Kontrollbereich zu und füge Erkennungsnotizen hinzu.
5. Füge eine Ressourcenliste 'Lerne vor dem Lösen' hinzu (OWASP / PortSwigger / MITRE / NIST).
6. Führe make test und make verify-registry vor dem Einreichen aus.

Fahrplan

• Seiten für einzelne Flags, die aus dem Register generiert werden
• Bewertung der Schwierigkeit + zeitgesteuerter Challenge-Modus
• GraphQL-Auflöser-Feld-Authz-Fixes als 'sicherer' Umschalter
• Mehr KI-Challenges (Jailbreak-Leiter, RAG-Vergiftung)
• Bibliothek für Blue-Team-Erkennungsregeln (Sigma-ähnlich)
• Optionaler OIDC-/SAML-Mock für den Auth-Pfad
• Mehrbenutzer-CTF-Bestenlistenmodus (weiterhin nur lokal)

Lizenz

Nur für Bildungszwecke. Siehe LICENSE, falls vorhanden. Verwende nur gegen Systeme, die dir gehören oder für die du explizit autorisiert bist zu testen – hier bedeutet das dieses lokale Labor.

Hilf diesem Projekt zu wachsen

Wenn dir dieses Labor geholfen hat, etwas Neues zu lernen:

1. Markiere dieses Repository mit einem Stern – dauert eine Sekunde und hilft anderen, es zu finden.
2. Teile es – tweete es, poste auf LinkedIn, erzähle deinen Kollegen.
3. Melde Probleme – hilf mit, das Labor für alle zu verbessern.