PENTEST-LAB

Une application vulnérable moderne et un cyber range pour apprendre la sécurité Web, API, Cloud, IA et Blue Team grâce à des chaînes d'attaque pratiques.

╔═══════════════════════════════════════════════════════════════╗
║     ██████╗ ███████╗███╗   ██╗████████╗███████╗███████╗████████╗ ║
║     ██╔══██╗██╔════╝████╗  ██║╚══██╔══╝██╔════╝██╔════╝╚══██╔══╝ ║
║     ██████╔╝█████╗  ██╔██╗ ██║   ██║   █████╗  ███████╗   ██║    ║
║     ██╔═══╝ ██╔══╝  ██║╚██╗██║   ██║   ██╔══╝  ╚════██║   ██║    ║
║     ██║     ███████╗██║ ╚████║   ██║   ███████╗███████║   ██║    ║
║     ╚═╝     ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚══════╝╚══════╝   ╚═╝    ║
║        CYBER RANGE MODERNE · 50 DÉFIS · 8 PISTES                 ║
╚═══════════════════════════════════════════════════════════════╝

★ Mettez une étoile à ce dépôt s'il vous aide – c'est gratuit et ça aide d'autres à découvrir une éducation gratuite à la sécurité.

Ce qui rend ce projet différent

PENTEST-LAB n'est pas un simple boîte à vulnérabilité unique. C'est un cyber range complet qui associe les perspectives de l'attaquant et du défenseur avec une sortie de preuves de type GRC :

• 50 défis répartis sur 8 pistes – Web, API, Auth/Session, Cloud/DevOps, Sécurité IA, Logique Métier, Chaîne d'Attaque, Preuves Blue Team.
• Registre central des défis – une source de vérité qui alimente l'interface, le validateur de drapeaux et le générateur de preuves.
• Apprenez avant de résoudre – chaque défi est lié à des références faisant autorité (OWASP, PortSwigger, MITRE, NIST) afin que vous puissiez étudier le concept, puis l'exploiter. Les drapeaux sont obtenus en exploitant, pas révélés dans l'interface.
• Simulateur IA transparent – la piste IA fonctionne sur un « modèle » inspectable en cours de processus (aucun LLM externe) : vous voyez l'intégralité du contexte [SYSTEM][USER][RETRIEVED][HISTORY], la sortie générée, la technique d'injection détectée et les bascules pour chaque mesure d'atténuation.
• Magasin central d'événements – chaque requête et chaque drapeau est journalisé ; la vue défenseur est construite à partir des mêmes événements que l'attaquant génère.
• Chaîne d'attaque guidée – Reconnaissance → Divulgation d'informations → Abus de jetons → Élévation de privilèges → Accès aux données → Rapport de preuves, avec progression en direct.
• Mode Blue Team – échecs de connexion, accès API suspects, SSRF, élévation de privilèges, téléchargements de fichiers, captures de drapeaux et progression de la chaîne dans un seul tableau de bord.
• Mode preuves GRC – rapports Markdown / JSON / CSV mappant chaque constatation à une sévérité, un point d'accès, une preuve, un impact métier, une correction, un domaine de contrôle et une opportunité de détection. (Mapping large de domaine de contrôle – pas une certification de conformité.)
• Gagné, pas révélé – le champ du drapeau est verrouillé jusqu'à ce que vous le capturiez. La fenêtre modale montre le statut, pas le drapeau littéral, donc vous devez réellement exploiter le point d'accès (via le testeur d'API intégré à l'interface ou votre propre client).
• Suivant recommandé + progression pondérée – chaque défi résolu suggère un prochain défi pertinent, et votre score de progression pondère les défis plus difficiles plus que les faciles (4 > 3 > 2 > 1) au lieu d'un simple comptage.
• Progression portable – exportez vos drapeaux capturés et votre progression sous forme d'artefact de portfolio Markdown que vous pouvez conserver après la disparition du lab.
• Sûr par défaut – écoute sur 127.0.0.1, avertit fortement sur 0.0.0.0, tous les secrets sont factices et clairement marqués, les cibles SSRF sont simulées en local dans le processus (pas de véritable sortie réseau), pas de cibles externes.
• Facile à exécuter – un script Python, un Makefile et docker-compose.
• Auto-vérification – make verify-registry valide le registre des défis (identifiants/drapeaux uniques, champs requis, ressources, nombre d'indices) pour que le catalogue reste cohérent.

Démarrage rapide

# 1. Commande unique (installe les dépendances, initialise la base de données, lance le serveur)
python start_lab.py
# ou :  make start

Ouvrez http://localhost:3000 dans votre navigateur.

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

# Docker (publié sur 127.0.0.1 uniquement)
docker compose up --build

# Réinitialiser les drapeaux/événements/progression capturés
make reset

# Recharger les données de démonstration
make seed

# Test rapide des routes principales (lancez d'abord le lab)
make test

# Valider le registre des défis (identifiants/drapeaux uniques, champs, ressources)
make verify-registry

# Démonstration d'exploitation locale sécurisée (5 défis)
python demo_exploit.py

Pistes de défis

Chaque défi comporte : identifiant, titre, piste, catégorie, difficulté, objectif, point d'accès vulnérable, concept d'exploitation, 3 indices progressifs (vague → précis → réponse), drapeau, correction, notes de détection/preuves, un domaine de contrôle mappé et une liste de ressources apprenez avant de résoudre.

La fenêtre modale du défi

Cliquez sur n'importe quelle carte de défi pour ouvrir la fenêtre modale. Elle vous donne :

• L'objectif, le point d'accès et le concept d'exploitation pour que vous sachiez sur quoi viser.
• Apprenez avant de résoudre – liens faisant autorité (OWASP, PortSwigger, MITRE, NIST) pour étudier d'abord.
• 3 indices progressifs – révélez-les un par un si vous êtes bloqué ; le nombre d'indices utilisés est suivi par défi.
• Ouvrir dans le testeur d'API – accédez directement à une requête préchargée vers le point d'accès vulnérable, ou envoyez-la depuis votre propre client.
• Recommandé suivant – une fois résolu, un défi pertinent est suggéré pour poursuivre votre apprentissage.
• Navigation Précédent / Suivant – parcourez les défis sans fermer la fenêtre modale.
• Drapeau verrouillé – le drapeau littéral est caché jusqu'à ce que vous le capturiez en exploitant le point d'accès. La fenêtre modale montre le statut capturé / non capturé.

Mode chaîne d'attaque

Une chaîne réaliste, entièrement locale, en six étapes détectées :

Reconnaissance → Divulgation d'informations → Abus de jetons/identifiants →
Élévation de privilèges → Accès aux données sensibles → Rapport de preuves

B=http://127.0.0.1:3000
curl -s $B/api/attack-chain/recon    # 1. le point d'accès de débogage divulgue les routes
curl -s $B/api/attack-chain/leak     # 2. secret JWT factice divulgué (weak123)
# 3. forger jeton admin -> 4. élever -> 5. lire les enregistrements clients factices -> 6. rapport
curl -s $B/api/attack-chain/progress

Suivez la progression en direct dans l'onglet Chaîne d'attaque.

Mode Blue Team

L'onglet Défenseur montre la même activité que l'attaquant vient d'effectuer : événements récents, échecs de connexion, accès API suspects, téléchargements de fichiers, tentatives SSRF, tentatives d'élévation de privilèges, drapeaux capturés et progression de la chaîne d'attaque – chaque événement est coloré par sévérité, les captures de drapeaux sont signalées par 🚩.

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

Mode rapport de preuves

Générez un rapport à partir de vos drapeaux capturés, mappant chacun à une constatation avec sévérité, point d'accès affecté, preuve, impact métier, correction, domaine de contrôle et une opportunité de détection.

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

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

# Domaines de contrôle mappés : Contrôle d'accès, Journalisation et supervision,
# Développement sécurisé, Gestion des secrets, Gestion des changements,
# Gestion de la configuration, Protection des données, Réponse aux incidents.

⚠️ Il s'agit d'un mapping large de domaines de contrôle pour l'apprentissage de la détection/GRC. Il n'affirme aucune conformité à une norme.

Captures d'écran / démonstration

🎬 Démo GIF : docs/demo.gif – consultez docs/DEMO_WALKTHROUGH.md pour un script de présentation d'environ 6 minutes. (Déposez vos propres captures dans docs/screenshots/ et docs/demo.gif pour remplacer les placeholders.)

Avis de sécurité

Ce lab est intentionnellement vulnérable. Exécutez-le uniquement dans des environnements isolés et ne l'exposez jamais à Internet.

• Écoute sur 127.0.0.1 par défaut (HOST=127.0.0.1 dans backend/.env).
• Définir HOST=0.0.0.0 affiche un avertissement sonore ; l'interface montre une bannière de danger.
• Tous les secrets/jetons sont factices et clairement marqués. Aucun identifiant réel.
• Les points d'accès SSRF/metadata sont des simulations locales en cours de processus – aucune sortie réseau réelle.
• Pas de commandes destructrices, pas de persistance, pas de ciblage de systèmes externes.

Structure du projet

├── start_lab.py              # Lanceur en une commande (dépendances + initialisation + exécution)
├── demo_exploit.py           # Démonstration d'exploitation locale sécurisée (5 défis)
├── docker-compose.yml        # Publication uniquement sur localhost
├── Makefile                  # Installer / démarrer / réinitialiser / tester / démo / docker
├── CHALLENGES.md             # Catalogue complet des défis
├── frontend/                 # Interface utilisateur du tableau de bord (pistes, chaîne, défenseur, preuves)
├── backend/
│   ├── server.js             # Application Express, liaison localhost, routage
│   ├── challenges/registry.js # REGISTRE CENTRAL des défis (50 défis)
│   ├── ai/                   # Simulateur IA TRANSPARENT + stockage RAG (pas de LLM externe)
│   ├── utils/events.js       # Magasin central d'événements + flux Blue Team
│   ├── routes/               # Routes vulnérables + modes (api, cloud, ai, shop, ...)
│   ├── scripts/              # init-db, seed, reset, test_routes
│   └── middleware/           # auth (sûr), auth.vulnerable, waf, security
├── solutions/                # Scripts d'exploitation Python
└── docs/                     # SECURITY_REPORT, SETUP, DEMO_WALKTHROUGH

Contribuer

Vous avez trouvé un bug ou souhaitez ajouter un défi ? Les PR sont les bienvenues.

1. Restez local et éducatif – pas de secrets réels, pas de cibles externes.
2. Ajoutez de nouveaux défis dans backend/challenges/registry.js (source unique de vérité).
3. Émettez les drapeaux via events.captureFlag({ flag, req }) depuis une route vulnérable.
4. Mappez le défi à un domaine de contrôle et ajoutez des notes de détection.
5. Ajoutez une liste de ressources « apprenez avant de résoudre » (OWASP / PortSwigger / MITRE / NIST).
6. Exécutez make test et make verify-registry avant de soumettre.

Feuille de route

• Pages de résolution par drapeau générées à partir du registre
• Score de difficulté + mode chronométré
• Corrections d'autorisation au niveau des champs du résolveur GraphQL comme bascule « sécurisée »
• Davantage de défis IA (échelle de jailbreak, empoisonnement RAG)
• Bibliothèque de règles de détection Blue Team (façon Sigma)
• Simulation OIDC/SAML optionnelle pour la piste Auth
• Mode classement CTF multi-utilisateurs (toujours en local)

Licence

Usage éducatif uniquement. Consultez LICENSE si présent. Utilisez uniquement contre des systèmes que vous possédez ou que vous êtes explicitement autorisé à tester – ici, cela signifie ce lab local.

Aidez ce projet à grandir

Si ce lab vous a aidé à apprendre quelque chose de nouveau :

1. Mettez une étoile à ce dépôt – cela prend une seconde et aide d'autres à le trouver.
2. Partagez – tweetez-le, postez sur LinkedIn, parlez-en à vos collègues.
3. Signalez des problèmes – aidez à améliorer le lab pour tout le monde.