⚠️ *Note: Ceci est une version de développement et peut être instable*
4. **Configuration avancée** : Pour les challenges cloud et les exercices Kubernetes, voir les instructions détaillées ci-dessous

**Ce que vous allez apprendre :**
- Erreurs courantes de gestion des secrets
- Comment identifier les identifiants exposés
- Bonnes pratiques pour sécuriser les secrets
- Outils et techniques de détection des secrets

**Comment ça marche :**
Ce dépôt contient **du code et des fichiers de configuration intentionnellement vulnérables** avec des secrets réels et faux cachés dans toute la base de code. Vous examinerez le code source, les fichiers de configuration, les conteneurs Docker et les déploiements cloud pour découvrir ces secrets. Chaque challenge vous apprend différentes façons dont les secrets peuvent être accidentellement exposés dans des applications réelles.

![screenshotOfChallenge1](https://assets.kitploit.com/production/public/readmes/6937/ad02ece4104616d09ac232d1423d84111048b3437c4439ebf44172a60c673546.png)

## 📋 Prérequis

**Pour une utilisation de base :**
- Un navigateur web
- Docker (pour configuration locale) - [Installer ici](https://docs.docker.com/get-docker/)

**Pour les configurations avancées :**
- Kubernetes/Minikube - [Installer ici](https://minikube.sigs.k8s.io/docs/start/)
- Compte cloud (AWS/GCP/Azure) pour les challenges cloud
- Familiarité avec la ligne de commande

<a href="https://github.com/vshymanskyy/StandWithUkraine/blob/main/README.md"><img src="https://raw.githubusercontent.com/vshymanskyy/StandWithUkraine/main/banner2-no-action.svg" /></a>

## Table des matières

### 🎯 Getting Started
-   [Démarrage rapide](#-quick-start)
-   [Prérequis](#-prerequisites)
-   [Assistance](#support)

### 🐳 Deployment Options
-   [Exercices Docker de base](#basic-docker-exercises)
 -   [Exécution sur Heroku](#running-these-on-heroku)
 -   [Exécution sur Render.io](#running-these-on-renderio)
 -   [Exécution sur Railway](#running-these-on-railway)
-   [Exercice K8s de base](#basic-k8s-exercise)
 -   [Basé sur Minikube](#minikube-based)
 -   [Basé sur k8s](#k8s-based)
 -   [Exercices Vault avec Minikube](#vault-exercises-with-minikube)

### ☁️ Cloud Challenges
-   [Challenges Cloud](#cloud-challenges)
 -   [Exécution de WrongSecrets dans AWS](#running-wrongsecrets-in-aws)
 -   [Exécution de WrongSecrets dans GCP](#running-wrongsecrets-in-gcp)
 -   [Exécution de WrongSecrets dans Azure](#running-wrongsecrets-in-azure)
 -   [Exécution du Challenge15 dans votre propre cloud uniquement](#running-challenge15-in-your-own-cloud-only)

### 🎮 Advanced Usage
-   [Vous voulez jouer sans guide ?](#do-you-want-to-play-without-guidance-or-spoils)
-   [CTF](#ctf)
 -   [Support CTFD](#ctfd-support)
 -   [Support FBCTF](#fbctf-support-experimental)
-   [Utiliser OWASP WrongSecrets comme benchmark de détection de secrets](#use-owasp-wrongsecrets-as-a-secret-detection-benchmark)

### 👨‍💻 Development & Contribution
-   [Notes sur le développement](#notes-on-development)
-   [Spring Boot 4 adoption checklist](https://github.com/owasp/wrongsecrets/blob/HEAD/docs/SPRING_BOOT_4_ADOPTION_CHECKLIST.md)
 -   [Gestion des dépendances](#dependency-management)
 -   [Démarrer le projet dans IntelliJ IDEA](#get-the-project-started-in-intellij-idea)
 -   [Rechargement automatique pendant le développement](#automatic-reload-during-development)
 -   [Comment ajouter un challenge](#how-to-add-a-challenge)
 -   [Tests locaux](#local-testing)
 -   [Tests automatisés locaux](#Local-automated-testing)
-   [Vous souhaitez désactiver des challenges dans votre propre version ?](#want-to-disable-challenges-in-your-own-release)

### 📚 Resources & Community
-   [Remerciements spéciaux & Contributeurs](#special-thanks--contributors)
-   [Sponsorings](#sponsorships)
-   [Aide recherchée](#help-wanted)
-   [Lectures complémentaires sur la gestion des secrets](#further-reading-on-secrets-management)

## Support

Besoin d'aide ? Contactez-nous
via [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR) pour lequel vous vous inscrivez [ici](https://owasp.org/slack/invite)
, soumettez une [PR](https://github.com/OWASP/wrongsecrets/pulls), créez
un [issue](https://github.com/OWASP/wrongsecrets/issues) , ou
utilisez [discussions](https://github.com/OWASP/wrongsecrets/discussions). Veuillez noter qu'il s'agit d'un projet basé
sur des bénévoles OWASP, donc il se peut qu'il faille un peu de temps avant que nous répondions.

Copyright (c) 2020-2025 Jeroen Willemsen et contributeurs de WrongSecrets.

## 🛤️ Choose Your Path

Pas sûr de la configuration qui vous convient ? Voici un guide rapide :

| **Je veux...** | **Configuration recommandée** | **Challenges disponibles** |
|------------------|----------------------|--------------------------|
| L'essayer rapidement en ligne | [Conteneur tournant sur Heroku](https://www.wrongsecrets.com/) | Challenges de base (0-4, 8, 12-32, 34-43, 49-52, 54-66) |
| Exécuter localement avec Docker | [Docker de base](#basic-docker-exercises) | Idem, mais sur votre machine |
| Apprendre les secrets Kubernetes | [Configuration K8s/Minikube](#basic-k8s-exercise) | Challenges Kubernetes (0-6, 8, 12-43, 48-66) |
| Pratiquer avec les secrets cloud | [Challenges Cloud](#cloud-challenges) | Tous les challenges (0-66) |
| Animer un atelier/CTF | [Configuration CTF](#ctf) | Ensembles de challenges personnalisables |
| Contribuer au projet | [Configuration de développement](#notes-on-development) | Tous les challenges + outils de développement |

## Basic docker exercises

_Peut être utilisé pour les challenges 0-4, 8, 12-32, 34-43, 49-52, 54-66_

Pour les exercices Docker de base, vous avez actuellement besoin de :

-   Docker [Installer à partir d'ici](https://docs.docker.com/get-docker/)
-   Un navigateur capable d'afficher du HTML

Vous pouvez l'installer en faisant :```bash
docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:latest-no-vault

⚠️ **Avertissement** : Il s'agit d'une version de développement construite à partir de la branche master la plus récente et peut contenir des fonctionnalités expérimentales ou des instabilités.

**📝 Remarque sur les ports :**
- Port **8080** : Application principale (défis 0-66)
- Port **8090** : Serveur MCP (nécessaire pour le défi 60)

**📝 Remarque sur le défi 62 (Google Drive MCP) :**
Le défi 62 nécessite qu'un compte de service Google soit configuré pour une fonctionnalité complète. Voir [docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md](https://github.com/owasp/wrongsecrets/blob/HEAD/docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md) pour les instructions de configuration. Sans configuration, le défi affichera un message de substitution.

Vous pouvez désormais essayer de trouver les secrets en résolvant les défis proposés aux liens ci-dessous.
<details>
    <summary>tous les liens pour les défis docker (cliquez sur le triangle pour ouvrir le bloc).
    </summary>

-   [localhost:8080/challenge/challenge-0](http://localhost:8080/challenge/challenge-0)
-   [localhost:8080/challenge/challenge-1](http://localhost:8080/challenge/challenge-1)
-   [localhost:8080/challenge/challenge-2](http://localhost:8080/challenge/challenge-2)
-   [localhost:8080/challenge/challenge-3](http://localhost:8080/challenge/challenge-3)
-   [localhost:8080/challenge/challenge-4](http://localhost:8080/challenge/challenge-4)
-   [localhost:8080/challenge/challenge-8](http://localhost:8080/challenge/challenge-8)
-   [localhost:8080/challenge/challenge-12](http://localhost:8080/challenge/challenge-12)
-   [localhost:8080/challenge/challenge-13](http://localhost:8080/challenge/challenge-13)
-   [localhost:8080/challenge/challenge-14](http://localhost:8080/challenge/challenge-14)
-   [localhost:8080/challenge/challenge-15](http://localhost:8080/challenge/challenge-15)
-   [localhost:8080/challenge/challenge-16](http://localhost:8080/challenge/challenge-16)
-   [localhost:8080/challenge/challenge-17](http://localhost:8080/challenge/challenge-17)
-   [localhost:8080/challenge/challenge-18](http://localhost:8080/challenge/challenge-18)
-   [localhost:8080/challenge/challenge-19](http://localhost:8080/challenge/challenge-19)
-   [localhost:8080/challenge/challenge-20](http://localhost:8080/challenge/challenge-20)
-   [localhost:8080/challenge/challenge-21](http://localhost:8080/challenge/challenge-21)
-   [localhost:8080/challenge/challenge-22](http://localhost:8080/challenge/challenge-22)
-   [localhost:8080/challenge/challenge-23](http://localhost:8080/challenge/challenge-23)
-   [localhost:8080/challenge/challenge-24](http://localhost:8080/challenge/challenge-24)
-   [localhost:8080/challenge/challenge-25](http://localhost:8080/challenge/challenge-25)
-   [localhost:8080/challenge/challenge-26](http://localhost:8080/challenge/challenge-26)
-   [localhost:8080/challenge/challenge-27](http://localhost:8080/challenge/challenge-27)
-   [localhost:8080/challenge/challenge-28](http://localhost:8080/challenge/challenge-28)
-   [localhost:8080/challenge/challenge-29](http://localhost:8080/challenge/challenge-29)
-   [localhost:8080/challenge/challenge-30](http://localhost:8080/challenge/challenge-30)
-   [localhost:8080/challenge/challenge-31](http://localhost:8080/challenge/challenge-31)
-   [localhost:8080/challenge/challenge-32](http://localhost:8080/challenge/challenge-32)
-   [localhost:8080/challenge/challenge-34](http://localhost:8080/challenge/challenge-34)
-   [localhost:8080/challenge/challenge-35](http://localhost:8080/challenge/challenge-35)
-   [localhost:8080/challenge/challenge-36](http://localhost:8080/challenge/challenge-36)
-   [localhost:8080/challenge/challenge-37](http://localhost:8080/challenge/challenge-37)
-   [localhost:8080/challenge/challenge-38](http://localhost:8080/challenge/challenge-38)
-   [localhost:8080/challenge/challenge-39](http://localhost:8080/challenge/challenge-39)
-   [localhost:8080/challenge/challenge-40](http://localhost:8080/challenge/challenge-40)
-   [localhost:8080/challenge/challenge-41](http://localhost:8080/challenge/challenge-41)
-   [localhost:8080/challenge/challenge-42](http://localhost:8080/challenge/challenge-42)
-   [localhost:8080/challenge/challenge-43](http://localhost:8080/challenge/challenge-43)
-   [localhost:8080/challenge/challenge-49](http://localhost:8080/challenge/challenge-49)
-   [localhost:8080/challenge/challenge-50](http://localhost:8080/challenge/challenge-50)
-   [localhost:8080/challenge/challenge-51](http://localhost:8080/challenge/challenge-51)
-   [localhost:8080/challenge/challenge-52](http://localhost:8080/challenge/challenge-52)
-   [localhost:8080/challenge/challenge-54](http://localhost:8080/challenge/challenge-54)
-   [localhost:8080/challenge/challenge-55](http://localhost:8080/challenge/challenge-55)
-   [localhost:8080/challenge/challenge-56](http://localhost:8080/challenge/challenge-56)
-   [localhost:8080/challenge/challenge-57](http://localhost:8080/challenge/challenge-57)
-   [localhost:8080/challenge/challenge-58](http://localhost:8080/challenge/challenge-58)
-   [localhost:8080/challenge/challenge-59](http://localhost:8080/challenge/challenge-59)
-   [localhost:8080/challenge/challenge-60](http://localhost:8080/challenge/challenge-60)
-   [localhost:8080/challenge/challenge-61](http://localhost:8080/challenge/challenge-61)
-   [localhost:8080/challenge/challenge-62](http://localhost:8080/challenge/challenge-62)
-   [localhost:8080/challenge/challenge-63](http://localhost:8080/challenge/challenge-63)
-   [localhost:8080/challenge/challenge-64](http://localhost:8080/challenge/challenge-64)
-   [localhost:8080/challenge/challenge-65](http://localhost:8080/challenge/challenge-65)
-   [localhost:8080/challenge/challenge-66](http://localhost:8080/challenge/challenge-66)
</details>

Notez que ces défis sont encore très basiques, de même que leurs explications. N'hésitez pas à soumettre une PR pour les améliorer ;-).

### Exécution sur Heroku

Vous pouvez également les tester sur [https://wrongsecrets.herokuapp.com/](https://wrongsecrets.herokuapp.com/) ! Les gens de Heroku nous ont offert un excellent package de support open source, ce qui nous permet d'exécuter l'application gratuitement là-bas, où elle est presque toujours disponible. Néanmoins, veuillez ne pas fuzzer et/ou essayer de la faire tomber : vous gâcheriez le plaisir des autres qui souhaitent l'essayer.
Utilisez [ce lien](https://wrongsecrets.herokuapp.com/) pour accéder à notre version hébergée de l'application. Si vous souhaitez l'héberger vous-même sur Heroku (par exemple pour organiser une formation), vous pouvez le faire en cliquant sur [ce lien](https://heroku.com/deploy?template=https://github.com/OWASP/wrongsecrets/tree/master). Veuillez noter que cela engendrera des frais dont ce projet et/ou ses mainteneurs ne peuvent être tenus responsables.

### Exécution sur Render.io
*statut : expérimental*

Vous pouvez les tester sur [https://wrongsecrets.onrender.com/](https://wrongsecrets.onrender.com/). Veuillez comprendre que nous fonctionnons sur une instance gratuite, nous ne pouvons donner aucune garantie. Veuillez ne pas fuzzer et/ou essayer de la faire tomber : vous gâcheriez le plaisir des autres qui souhaitent l'essayer.
Vous souhaitez déployer vous-même avec Render ? Cliquez sur le bouton ci-dessous :

[![Deploy to Render](https://render.com/images/deploy-to-render-button.svg)](https://render.com/deploy?repo=https://github.com/OWASP/wrongsecrets)

### Exécution sur Railway
*statut : maintenu par [alphasec.io](https://github.com/alphasecio)*

Si vous souhaitez héberger WrongSecrets sur Railway, vous pouvez le faire en déployant [ce modèle en un clic](https://railway.com/deploy/McqJ_j?referralCode=I07F1). Railway ne propose plus de plan toujours gratuit, mais l'essai gratuit est suffisant pour tester avant de décider de passer à une offre payante. Si vous avez besoin d'un guide pas à pas, consultez [cet article de blog](https://alphasec.io/test-your-secret-management-skills-with-owasp-wrongsecrets/).

[![Deploy on Railway](https://railway.com/button.svg)](https://railway.com/deploy/McqJ_j?referralCode=I07F1j)

## Exercice K8s de base

_Peut être utilisé pour les défis 0-6, 8, 12-43, 48-66_

### Basé sur Minikube

Assurez-vous d'avoir installé les éléments suivants :

-   Docker [Installer à partir d'ici](https://docs.docker.com/get-docker/)
-   Minikube [Installer à partir d'ici](https://minikube.sigs.k8s.io/docs/start/)

La configuration K8S actuelle est basée sur l'utilisation de Minikube pour s'amuser en local. Vous pouvez utiliser les commandes ci-dessous depuis la racine du projet :```bash
    minikube start
    kubectl apply -f k8s/secrets-config.yml
    kubectl apply -f k8s/secrets-secret.yml
    kubectl apply -f k8s/challenge33.yml
    kubectl apply -f k8s/challenge53/secret-challenge53.yml
    echo "Setting up the bitnami sealed secret controler"
    kubectl apply -f https://github.com/bitnami-labs/sealed-secrets/releases/download/v0.27.0/controller.yaml
    kubectl apply -f k8s/sealed-secret-controller.yaml
    kubectl apply -f k8s/main.key
    kubectl delete pod -n kube-system -l name=sealed-secrets-controller
    kubectl create -f k8s/sealed-challenge48.json
    echo "finishing up the sealed secret controler part"
    wait 10 #or check whether secret48 is there
    kubectl apply -f k8s/secret-challenge-deployment.yml
    while [[ $(kubectl get pods -l app=secret-challenge -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}') != "True" ]]; do echo "waiting for secret-challenge" && sleep 2; done
    kubectl expose deployment secret-challenge --type=LoadBalancer --port=8080
    minikube service secret-challenge

maintenant vous pouvez utiliser l'adresse IP et le port fournis pour continuer à jouer avec la variante K8s (au lieu de localhost).

-   [localhost:8080/challenge/challenge-5](http://localhost:8080/challenge/challenge-5)
-   [localhost:8080/challenge/challenge-6](http://localhost:8080/challenge/challenge-6)
-   [localhost:8080/challenge/challenge-33](http://localhost:8080/challenge/challenge-33)
-   [localhost:8080/challenge/challenge-48](http://localhost:8080/challenge/challenge-48)
-   [localhost:8080/challenge/challenge-53](http://localhost:8080/challenge/challenge-53)

### k8s basé

Vous voulez exécuter vanilla sur votre propre k8s ? Utilisez les commandes ci-dessous :```bash
    kubectl apply -f k8s/secrets-config.yml
    kubectl apply -f k8s/secrets-secret.yml
    echo "Setting up the bitnami sealed secret controler"
    kubectl apply -f https://github.com/bitnami-labs/sealed-secrets/releases/download/v0.27.0/controller.yaml
    kubectl apply -f k8s/sealed-secret-controller.yaml
    kubectl apply -f k8s/main.key
    kubectl delete pod -n kube-system -l name=sealed-secrets-controller
    kubectl create -f k8s/sealed-challenge48.json
    echo "finishing up the sealed secret controler part"
    wait 10 #or check whether secret48 is there
    kubectl apply -f k8s/challenge33.yml
    kubectl apply -f k8s/secret-challenge-deployment.yml
    while [[ $(kubectl get pods -l app=secret-challenge -o 'jsonpath={..status.conditions[?(@.type=="Ready")].status}') != "True" ]]; do echo "waiting for secret-challenge" && sleep 2; done
    kubectl port-forward \
        $(kubectl get pod -l app=secret-challenge -o jsonpath="{.items[0].metadata.name}") \
        8080:8080

> **Note :** Les indices ne peuvent être générés que si l'instance WrongSecrets a les indices activés (`HINTS_ENABLED=true`). L'instance CTF Heroku ([https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)) fonctionne avec `HINTS_ENABLED=false`, donc sélectionner "Indices gratuits" ou "Indices payants" donnera une liste d'indices vide. Pour générer des indices, exécutez votre propre instance avec `HINTS_ENABLED=true`.

Visitez maintenant l'instance CTFD à [http://localhost:8001](http://localhost:8001) et configurez votre CTF.
Utilisez ensuite la fonction de sauvegarde administrative pour importer le fichier zip que vous avez créé avec la commande juice-shop-ctf.
Que le jeu commence en utilisant [https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com) !
Vous voulez configurer votre propre instance ? Vous le pouvez ! Attention toutefois à ne pas exposer votre clé : assurez-vous que le conteneur en cours d'exécution avec la véritable clé CTF n'est pas exposé au public, comme notre conteneur Heroku.

## Support FBCTF (Expérimental !)

REMARQUE : Le support FBCTF est expérimental.

Suivez les mêmes étapes qu'avec CTFD, mais choisissez maintenant fbctfd et comme URL pour le mappage des pays, choisissez `https://raw.githubusercontent.com/OWASP/wrongsecrets/79a982558016c8ce70948a8106f9a2ee5b5b9eea/config/fbctf.yml`.
Suivez ensuite [https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide](https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide) pour exécuter le FBCTF.

## Notes sur le développement

Pour le développement sur machine locale, utilisez le profil `local` : `./mvnw spring-boot:run -Dspring-boot.run.profiles=local,without-vault`

Si vous voulez tester contre vault sans K8s : démarrez vault localement avec```shell
 export SPRING_CLOUD_VAULT_URI='http://127.0.0.1:8200'
 export VAULT_API_ADDR='http://127.0.0.1:8200'
 vault server -dev

Utilisez maintenant le profil `local-vault` pour faire votre développement.```shell
./mvnw spring-boot:run -Dspring-boot.run.profiles=local,local-vault

Vous voulez pousser un conteneur ? Consultez `.github/scripts/docker-create-and-push.sh` pour un script qui génère et pousse tous les conteneurs. N'oubliez pas de reconstruire l'application avant de composer le conteneur.

Vous voulez vérifier pourquoi quelque chose dans vault ne fonctionne pas dans kubernetes ? Exécutez `kubectl exec vault-0 -n vault -- vault audit enable file file_path=stdout`.

### Gestion des dépendances

Nous avons intégré CycloneDX et OWASP Dependency-check pour vérifier les dépendances pour les vulnérabilités. Vous pouvez utiliser l'outil OWASP Dependency-checker en appelant `mvn dependency-check:aggregate` et `mvn cyclonedx:makeBom` pour utiliser CycloneDX et créer un SBOM.

### Configuration du plugin Maven Dependency-Check

OWASP WrongSecrets utilise le plugin [`dependency-check-maven`](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) pour analyser automatiquement les dépendances du projet à la recherche de vulnérabilités connues (CVE).

#### Comment ça fonctionne

- Le plugin s'exécute pendant la construction Maven (`./mvnw clean install`) et vérifie toutes les dépendances par rapport aux bases de données publiques de vulnérabilités.
- Par défaut, il utilise la NVD (National Vulnerability Database) et peut également utiliser OSS Index pour une couverture supplémentaire.

#### Points forts de la configuration

Le plugin est configuré dans `pom.xml` dans la section `<build><plugins>` :```xml
<plugin>
  <groupId>org.owasp</groupId>
  <artifactId>dependency-check-maven</artifactId>
  <version>${dependency-check-maven.version}</version>
  <configuration>
    <nvdApiKey>...</nvdApiKey>
    <assemblyAnalyzerEnabled>false</assemblyAnalyzerEnabled>
    <ossIndexServerId>ossindex</ossIndexServerId>
    <ossIndexAnalyzerEnabled>true</ossIndexAnalyzerEnabled> <!-- SET THIS TO FALSE IF YOU HAVE NO SONATYPE ACCOUNT! -->
  </configuration>
  <executions>
    <execution>
      <goals>
        <goal>check</goal>
      </goals>
    </execution>
  </executions>
</plugin>

Remplacez `YOUR_OSSINDEX_USERNAME` et `YOUR_OSSINDEX_API_TOKEN` par les détails de votre compte OSS Index.

#### Dépannage

- Si vous voyez des erreurs `401 Unauthorized` pour OSS Index, vérifiez vos identifiants ou désactivez OSS Index en définissant `<ossIndexAnalyzerEnabled>false</ossIndexAnalyzerEnabled>` dans `pom.xml`.
- Vous pouvez toujours exécuter la build sans OSS Index si vous préférez uniquement l'analyse basée sur NVD.

#### Plus d'informations

Voir la [Documentation du plugin Maven Dependency-Check](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) pour les options de configuration avancées.

### Démarrer le projet dans IntelliJ IDEA

Prérequis : assurez-vous d'avoir installé les outils suivants : [Docker](https://www.docker.com/products/docker-desktop/), [JDK Java25](https://jdk.java.net/25/), [NodeJS 24](https://nodejs.org/en/download/current) et [IntelliJ IDEA](https://www.jetbrains.com/idea/download).

1. Forkez et clonez le projet comme décrit dans la [documentation](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md).
2. Importez le projet dans IntelliJ (par exemple, importez en tant que projet mvn / sources locales)
3. Allez dans les paramètres du projet et assurez-vous qu'il utilise Java25 (et que le JDK peut être trouvé)
4. Allez dans Paramètres IDE > Languages & Frameworks > Lombok et assurez-vous que le traitement Lombok est activé
5. Ouvrez l'onglet Maven dans votre IDEA et exécutez "Reload All Maven Projects" pour synchroniser le système et tout télécharger. Ensuite, dans le même onglet, utilisez l'option "install" dans le cadre du cycle de vie OWASP WrongSecrets pour générer l'asciidoc et autres.
6. Exécutez maintenant la méthode `main` dans `org.owasp.wrongsecrets.WrongSecretsApplication.java`. Cela devrait échouer avec une stack trace.
7. Allez maintenant dans la configuration d'exécution de l'application et assurez-vous d'avoir le profil actif `without-vault`. Cela se fait en définissant les arguments des options VM sur `--server.port=8080 --spring.profiles.active=local,without-vault`. Définissez `K8S_ENV=docker` comme argument d'environnement.
8. Répétez l'étape 6 : exécutez à nouveau l'application, vous devriez avoir une application fonctionnelle accessible dans votre navigateur à http://localhost:8080.

**Guide illustré** pour démarrer le projet dans IntelliJ IDEA est disponible dans [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-get-started-with-the-project-in-intellij-idea).

N'hésitez pas à modifier et proposer des changements via des pull requests. Assurez-vous de suivre nos conseils dans la [documentation](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md) pour que votre travail soit accepté.

Veuillez noter que nous ne supportons officiellement que Linux et MacOS pour le développement. Si vous souhaitez développer en utilisant une machine Windows, utilisez WSL2 ou une machine virtuelle sous Linux. Nous avons inclus la détection Windows et un tas de fichiers `exe` pour une première expérience, mais nous cherchons des mainteneurs actifs pour ceux-ci. Vous voulez vous assurer que cela fonctionne sous Windows ? Créez des PRs ;-).

Si, après avoir lu cette section, vous n'avez toujours aucune idée du code de l'application : jetez un œil [à quelques tutoriels sur Spring Boot de Baeldung](https://www.baeldung.com/spring-boot).

### Rechargement automatique pendant le développement

Pour que les modifications soient chargées plus rapidement, nous avons ajouté `spring-dev-tools` au projet Maven. Pour activer cela automatiquement dans IntelliJ, assurez-vous :

-   Sous Compiler -> Automatically build project est activé, et
-   Sous Advanced settings -> Allow auto-make to start even if developed application is currently running.

Vous pouvez également invoquer manuellement : Build -> Recompile the file you just changed, cela forcera également le rechargement de l'application.

### Comment ajouter un défi

Suivez les étapes ci-dessous pour ajouter un défi :

1. Tout d'abord, assurez-vous d'avoir un [Issue](https://github.com/OWASP/wrongsecrets/issues) signalé pour lequel un défi est vraiment souhaité.
2. Ajoutez le nouveau défi dans le dossier `org.owasp.wrongsecrets.challenges`. Assurez-vous d'ajouter une explication dans `src/main/resources/explanations` et d'y faire référence depuis votre nouvelle classe Challenge.
3. Ajoutez des tests unitaires, d'intégration et d'interface utilisateur pour montrer que votre défi fonctionne.
4. N'oubliez pas de configurer le défi dans `src/main/resources/wrong-secrets-configuration.yaml`
5. Consultez le [guide CONTRIBUTING](https://github.com/owasp/wrongsecrets/blob/HEAD/CONTRIBUTING.md) pour configurer votre environnement de contribution et rédiger de bons messages de commit.

Pour plus de détails, veuillez vous référer à [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-add-a-challenge).

Si vous souhaitez déplacer des défis cloud existants vers un autre cloud : étendez les classes Challenge dans le package `org.owasp.wrongsecrets.challenges.cloud` et assurez-vous d'ajouter le Terraform requis dans un dossier avec le cloud séparé identifié. Assurez-vous que l'environnement est ajouté à `org.owasp.wrongsecrets.RuntimeEnvironment`. Collaborez avec les autres membres du projet pour faire fonctionner votre conteneur afin de pouvoir tester sur le compte cloud.

### Tests locaux

Si vous avez apporté des modifications au code ou ajouté un nouveau défi et souhaitez voir exactement à quoi ressemblera le conteneur après la fusion pour les tests, nous avons un script qui rend cela très simple. Suivez les étapes ci-dessous :

1. Assurez-vous d'avoir bash installé et ouvert.
2. Accédez à .github/scripts.
3. Exécutez le script docker-create `bash docker-create.sh`.
   - Remarque : Voulez-vous exécuter cela sur votre minikube ? alors exécutez d'abord `eval $(minikube docker-env)`.
4. Suivez les instructions données, vous pourriez avoir besoin d'installer/modifier des paquets.
5. Exécutez le conteneur nouvellement créé :
  - pour exécuter localement : `docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:local-test-no-vault`
  - pour exécuter sur votre minikube : utilisez le conteneur `jeroenwillemsen/wrongsecrets:local-test-k8s-vault` dans votre définition de déploiement.
  - pour exécuter avec Vault sur votre minikube : utilisez le conteneur `jeroenwillemsen/wrongsecrets:local-test-local-vault` dans votre définition de déploiement.

### Tests automatisés locaux

Nous avons actuellement 2 suites de tests différentes, toutes deux lancées avec `./mvnw test`.
- Une suite de tests junit normale de tests unitaires et d'intégration, située dans le dossier [`test/java`](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/java) avec les résultats stockés dans le répertoire target par défaut.
- Une suite de tests cypress, intégrée via un test junit, située dans le dossier [`test/e2e`](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/e2e) avec les résultats stockés dans [`target/test-classes/e2e/cypress/reports/`](https://github.com/owasp/wrongsecrets/blob/HEAD/target/test-classes/e2e/cypress/reports/). Voir le [readme cypress](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/e2e/cypress/README.md) pour plus de détails.

Remarque : Vous pouvez faire un cycle complet de nettoyage, construction et test avec `./mvnw clean install`.

## 🔧 Dépannage

### Problèmes courants

**Problèmes Docker :**
- **Port déjà utilisé** : Changez le mappage de port : `docker run -p 8081:8080 -p 8091:8090 jeroenwillemsen/wrongsecrets:latest-no-vault`
- **Docker introuvable** : Assurez-vous que Docker est installé et en cours d'exécution
- **Permission refusée** : Sous Linux, vous devrez peut-être ajouter votre utilisateur au groupe docker

**Problèmes de navigateur :**
- **Impossible d'accéder à localhost:8080** : Vérifiez si le conteneur Docker est en cours d'exécution avec `docker ps`
- **Les défis ne se chargent pas** : Videz le cache du navigateur ou essayez le mode navigation privée

**Problèmes Kubernetes :**
- **Minikube ne démarre pas** : Essayez `minikube delete` puis `minikube start`
- **Pods bloqués en attente** : Vérifiez les ressources avec `kubectl describe pod <nom-du-pod>**

**Besoin d'aide ?**
- Consultez nos [GitHub Issues](https://github.com/OWASP/wrongsecrets/issues)
- Rejoignez-nous sur [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR)
- Consultez la section [Support](#support)

## Vous voulez jouer, mais n'êtes pas autorisé à installer les outils ?

Si vous voulez jouer les défis, mais ne pouvez pas installer des outils comme keepass, Radare, etc. Mais êtes autorisé à exécuter des conteneurs Docker, essayez ce qui suit :```shell
docker run -p 3000:3000 -v /var/run/docker.sock:/var/run/docker.sock jeroenwillemsen/wrongsecrets-desktop:latest

Et ensuite sur [http://localhost:3000](http://localhost:3000).

Note : soyez prudent si vous essayez de déployer le conteneur `jeroenwillemsen/wrongsecrets-desktop` sur Heroku ;-).

## Docker sur macOS avec M1 et Colima (Expérimental !)

REMARQUE : Nous ne supportons pas officiellement Colima, car nous constatons que les runners Github ont beaucoup de problèmes avec.

Si vous ne pouvez pas passer à Docker Desktop/Podman et que vous souhaitez utiliser Colima avec Apple Silicon M1
pour exécuter l'image Docker `jeroenwillemsen/wrongsecrets`, essayez l'une des solutions suivantes :

- désactivez Colima (`colima stop`)
- changez le contexte Docker (`docker --context desktop-linux run -p 8080:8080 jeroenwillemsen/wrongsecrets:latest-no-vault`)
- exécutez Colima avec 1 CPU (`colima start -m 8 -c 1 --arch x86_64`)

## Vous souhaitez désactiver des challenges dans votre propre version ?

Si vous souhaitez exécuter WrongSecrets mais sans certains challenges que vous ne voulez pas présenter aux autres : veuillez lire cette section.

*_REMARQUE_* Veuillez noter que nous ne fournissons aucun support pour votre fork lorsque vous suivez le processus ci-dessous. Veuillez comprendre que la licence et les droits d'auteur de l'application originale restent intacts pour votre fork.

Prérequis :
- Avoir le JDK de Java 25 installé ;
- Avoir un compte dans un registre sur lequel vous pouvez pousser votre variante du conteneur WrongSecrets ;

Voici les étapes à suivre pour créer votre propre version de WrongSecrets avec certains challenges désactivés :
1. Forkez le dépôt.
2. Dans `src/main/resources/wrong-secrets-configuration.yaml`, supprimez la référence au challenge que vous ne souhaitez plus conserver dans votre fork.
3. À la racine du projet, exécutez `./mvnw clean install`
4. Construisez maintenant l'image Docker pour votre cible de votre choix :```sh
   docker buildx create --name mybuilder
   docker buildx use mybuilder
   docker buildx build --platform linux/amd64,linux/arm64 -t <registry/container-name>:<yourtag>-no-vault --build-arg "argBasedPassword='this is on your command line'" --build-arg "PORT=8081" --build-arg "argBasedVersion=<yourtag>" --build-arg "spring_profile=without-vault" --push
   docker buildx build --platform linux/amd64,linux/arm64 -t <registry/container-name>:<yourtag>-kubernetes-vault--build-arg "argBasedPassword='this is on your command line'" --build-arg "PORT=8081" --build-arg "argBasedVersion=<yourtag>" --build-arg "spring_profile=kubernetes-vault" --push