⚠️ *Hinweis: Dies ist eine Entwicklungsversion und kann instabil sein.*
4. **Erweiterte Einrichtung**: Für Cloud-Challenges und Kubernetes-Übungen siehe die detaillierten Anweisungen unten

**Was Sie lernen werden:**
- Häufige Fehler bei der Verwaltung von Geheimnissen
- Wie man exponierte Anmeldeinformationen identifiziert
- Best Practices für die Sicherung von Geheimnissen
- Werkzeuge und Techniken zur Erkennung von Geheimnissen

**So funktioniert es:**
Dieses Repository enthält **absichtlich verwundbaren Code und Konfigurationsdateien** mit echten und gefälschten Geheimnissen, die im gesamten Code versteckt sind. Sie werden Quellcode, Konfigurationsdateien, Docker-Container und Cloud-Bereitstellungen untersuchen, um diese Geheimnisse zu entdecken. Jede Herausforderung lehrt Ihnen verschiedene Wege, wie Geheimnisse in realen Anwendungen versehentlich preisgegeben werden können.

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

## 📋 Voraussetzungen

**Für die grundlegende Nutzung:**
- Ein Webbrowser
- Docker (für lokale Einrichtung) - [Hier installieren](https://docs.docker.com/get-docker/)

**Für erweiterte Einrichtungen:**
- Kubernetes/Minikube - [Hier installieren](https://minikube.sigs.k8s.io/docs/start/)
- Cloud-Konto (AWS/GCP/Azure) für Cloud-Challenges
- Vertrautheit mit der Kommandozeile

<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>

## Inhaltsverzeichnis

### 🎯 Erste Schritte
-   [Schnellstart](#-quick-start)
-   [Voraussetzungen](#-prerequisites)
-   [Support](#support)

### 🐳 Bereitstellungsoptionen
-   [Docker-Grundlagenübungen](#basic-docker-exercises)
 -   [Ausführung auf Heroku](#running-these-on-heroku)
 -   [Ausführung auf Render.io](#running-these-on-renderio)
 -   [Ausführung auf Railway](#running-these-on-railway)
-   [Grundlegende K8s-Übung](#basic-k8s-exercise)
 -   [Basierend auf Minikube](#minikube-based)
 -   [Basierend auf k8s](#k8s-based)
 -   [Vault-Übungen mit Minikube](#vault-exercises-with-minikube)

### ☁️ Cloud-Challenges
-   [Cloud-Challenges](#cloud-challenges)
 -   [Ausführen von WrongSecrets in AWS](#running-wrongsecrets-in-aws)
 -   [Ausführen von WrongSecrets in GCP](#running-wrongsecrets-in-gcp)
 -   [Ausführen von WrongSecrets in Azure](#running-wrongsecrets-in-azure)
 -   [Ausführen von Challenge15 nur in Ihrer eigenen Cloud](#running-challenge15-in-your-own-cloud-only)

### 🎮 Erweiterte Nutzung
-   [Möchten Sie ohne Anleitung spielen?](#do-you-want-to-play-without-guidance-or-spoils)
-   [CTF](#ctf)
 -   [CTFD-Unterstützung](#ctfd-support)
 -   [FBCTF-Unterstützung](#fbctf-support-experimental)
-   [Verwendung von OWASP WrongSecrets als Benchmark zur Erkennung von Geheimnissen](#use-owasp-wrongsecrets-as-a-secret-detection-benchmark)

### 👨‍💻 Entwicklung & Beitrag
-   [Hinweise zur Entwicklung](#notes-on-development)
-   [Checkliste zur Übernahme von Spring Boot 4](https://github.com/owasp/wrongsecrets/blob/HEAD/docs/SPRING_BOOT_4_ADOPTION_CHECKLIST.md)
 -   [Abhängigkeitsverwaltung](#dependency-management)
 -   [Projekt in IntelliJ IDEA starten](#get-the-project-started-in-intellij-idea)
 -   [Automatisches Neuladen während der Entwicklung](#automatic-reload-during-development)
 -   [Wie man eine Challenge hinzufügt](#how-to-add-a-challenge)
 -   [Lokales Testen](#local-testing)
 -   [Lokales automatisiertes Testen](#Local-automated-testing)
-   [Möchten Sie Challenges in Ihrer eigenen Veröffentlichung deaktivieren?](#want-to-disable-challenges-in-your-own-release)

### 📚 Ressourcen & Gemeinschaft
-   [Besonderer Dank & Mitwirkende](#special-thanks--contributors)
-   [Sponsoring](#sponsorships)
-   [Hilfe gesucht](#help-wanted)
-   [Weiterführende Literatur zur Geheimnisverwaltung](#further-reading-on-secrets-management)

## Support

Brauchen Sie Unterstützung? Kontaktieren Sie uns
über [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR), für den Sie sich [hier](https://owasp.org/slack/invite) anmelden können,
reichen Sie einen [PR](https://github.com/OWASP/wrongsecrets/pulls) ein, erstellen Sie
ein [Issue](https://github.com/OWASP/wrongsecrets/issues) oder nutzen Sie
[Diskussionen](https://github.com/OWASP/wrongsecrets/discussions). Bitte beachten Sie, dass dies ein OWASP-Freiwilligenprojekt
ist, daher kann es eine Weile dauern, bis wir antworten.

Copyright (c) 2020-2025 Jeroen Willemsen und die Mitwirkenden von WrongSecrets.

## 🛤️ Wählen Sie Ihren Weg

Sie sind sich nicht sicher, welches Setup für Sie richtig ist? Hier ist eine Kurzanleitung:

| **Ich möchte...** | **Empfohlenes Setup** | **Verfügbare Challenges** |
|-------------------|-----------------------|----------------------------|
| Es schnell online ausprobieren | [Container, der auf Heroku läuft](https://www.wrongsecrets.com/) | Grundlegende Challenges (0-4, 8, 12-32, 34-43, 49-52, 54-66) |
| Lokal mit Docker ausführen | [Docker-Grundlagen](#basic-docker-exercises) | Gleiche wie oben, aber auf Ihrem Rechner |
| Kubernetes-Geheimnisse lernen | [K8s/Minikube-Setup](#basic-k8s-exercise) | Kubernetes-Challenges (0-6, 8, 12-43, 48-66) |
| Mit Cloud-Geheimnissen üben | [Cloud-Challenges](#cloud-challenges) | Alle Challenges (0-66) |
| Einen Workshop/CTF leiten | [CTF-Setup](#ctf) | Anpassbare Challenge-Sets |
| Zum Projekt beitragen | [Entwicklungssetup](#notes-on-development) | Alle Challenges + Entwicklungstools |

## Docker-Grundlagenübungen

_Kann für Challenges 0-4, 8, 12-32, 34-43, 49-52, 54-66 verwendet werden_

Für die Docker-Grundlagenübungen benötigen Sie derzeit:

-   Docker [Hier installieren](https://docs.docker.com/get-docker/)
-   Einen Browser, der HTML rendern kann

Sie können es wie folgt installieren:```bash
docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:latest-no-vault

⚠️ **Warnung**: Dies ist eine Entwicklungsversion, die auf dem neuesten Master-Branch basiert und möglicherweise experimentelle Funktionen oder Instabilitäten enthält.

**📝 Hinweis zu Ports:**
- Port **8080**: Hauptanwendung (Challenges 0-66)
- Port **8090**: MCP-Server (erforderlich für Challenge 60)

**📝 Hinweis zu Challenge 62 (Google Drive MCP):**
Challenge 62 erfordert ein konfiguriertes Google Service Account für die volle Funktionalität. Siehe [docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md](https://github.com/owasp/wrongsecrets/blob/HEAD/docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md) für Einrichtungsanweisungen. Ohne Konfiguration zeigt die Challenge eine Platzhalternachricht an.

Jetzt können Sie versuchen, die Geheimnisse zu finden, indem Sie die unten angebotenen Challenges lösen.
<details>
    <summary>alle Links für Docker-Challenges (Klicke auf das Dreieck, um den Block zu öffnen).
    </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>

Beachten Sie, dass diese Challenges noch sehr grundlegend sind, ebenso wie ihre Erklärungen. Fühlen Sie sich frei, einen PR einzureichen, um sie besser aussehen zu lassen ;-).

### Diese auf Heroku ausführen

Sie können sie auch unter [https://wrongsecrets.herokuapp.com/](https://wrongsecrets.herokuapp.com/) testen! Die Leute von Heroku haben uns ein großartiges Open-Source-Supportpaket zur Verfügung gestellt, das es uns ermöglicht, die App dort kostenlos zu betreiben, wo sie fast immer verfügbar ist. Dennoch: Bitte fuzzen Sie nicht und/oder versuchen Sie nicht, sie zum Absturz zu bringen: Sie würden es anderen verderben, die sie testen möchten.
Verwenden Sie [diesen Link](https://wrongsecrets.herokuapp.com/), um unsere gehostete Version der App zu nutzen. Wenn Sie sie selbst auf Heroku hosten möchten (z. B. für ein Training), können Sie dies tun, indem Sie auf [diesen Link](https://heroku.com/deploy?template=https://github.com/OWASP/wrongsecrets/tree/master) klicken. Bitte beachten Sie, dass dabei Kosten anfallen können, für die dieses Projekt und/oder seine Betreuer nicht haftbar gemacht werden können.

### Diese auf Render.io ausführen
*Status: experimentell*

Sie können sie unter [https://wrongsecrets.onrender.com/](https://wrongsecrets.onrender.com/) testen. Bitte haben Sie Verständnis, dass wir auf einer Free-Tier-Instanz laufen, wir können keine Garantien geben. Bitte fuzzen Sie nicht und/oder versuchen Sie nicht, sie zum Absturz zu bringen: Sie würden es anderen verderben, die sie testen möchten.
Möchten Sie selbst mit Render deployen? Klicken Sie auf den Button unten:

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


### Diese auf Railway ausführen
*Status: gewartet von [alphasec.io](https://github.com/alphasecio)*

Wenn Sie WrongSecrets auf Railway hosten möchten, können Sie dies durch das Deployment [dieses One-Click-Templates](https://railway.com/deploy/McqJ_j?referralCode=I07F1) tun. Railway bietet keinen immer kostenlosen Plan mehr an, aber die kostenlose Testversion ist gut genug, um dies zu testen, bevor Sie sich für ein Upgrade entscheiden. Wenn Sie eine Schritt-für-Schritt-Anleitung benötigen, lesen Sie [diesen Blogbeitrag](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)

## Grundlegende K8s-Übung

_Kann für Challenges 0-6, 8, 12-43, 48-66 verwendet werden_

### Minikube-basiert

Stellen Sie sicher, dass Folgendes installiert ist:

-   Docker [Hier installieren](https://docs.docker.com/get-docker/)
-   Minikube [Hier installieren](https://minikube.sigs.k8s.io/docs/start/)

Das K8S-Setup basiert derzeit auf der Verwendung von Minikube für lokalen Spaß. Sie können die folgenden Befehle aus dem Projektstammverzeichnis verwenden:```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

Jetzt können Sie die bereitgestellte IP-Adresse und den Port verwenden, um weiter mit der K8s-Variante zu spielen (anstatt 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-basiert

Möchten Sie die Standardvariante auf Ihrem eigenen k8s ausführen? Verwenden Sie die folgenden Befehle:```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

> **Hinweis:** Hinweise können nur generiert werden, wenn die WrongSecrets-Instanz Hinweise aktiviert hat (`HINTS_ENABLED=true`). Die Heroku-CTF-Instanz ([https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)) läuft mit `HINTS_ENABLED=false`, daher führt die Auswahl von "Kostenlose Hinweise" oder "Bezahlte Hinweise" zu einer leeren Hinweisliste. Um Hinweise zu generieren, starten Sie Ihre eigene Instanz mit `HINTS_ENABLED=true`.

Besuchen Sie nun die CTFD-Instanz unter [http://localhost:8001](http://localhost:8001) und richten Sie Ihren CTF ein.
Verwenden Sie dann die administrative Backup-Funktion, um die Zip-Datei zu importieren, die Sie mit dem Befehl juice-shop-ctf erstellt haben.
Los geht's mit [https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)!
Möchten Sie Ihre eigene einrichten? Das können Sie! Achten Sie jedoch darauf, dass Ihr Schlüssel nicht gefunden wird. Sichern Sie ihn ordnungsgemäß: Stellen Sie sicher, dass der laufende Container mit dem eigentlichen ctf-key nicht dem Publikum ausgesetzt ist, ähnlich wie bei unserem Heroku-Container.

## FBCTF-Unterstützung (Experimentell!)

HINWEIS: Die FBCTF-Unterstützung ist experimentell.

Befolgen Sie die gleichen Schritte wie bei CTFD, wählen Sie jetzt jedoch 'fbctfd' und als URL für das Länder-Mapping wählen Sie `https://raw.githubusercontent.com/OWASP/wrongsecrets/79a982558016c8ce70948a8106f9a2ee5b5b9eea/config/fbctf.yml`.
Folgen Sie dann [https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide](https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide), um das FBCTF auszuführen.

## Hinweise zur Entwicklung

Für die Entwicklung auf dem lokalen Rechner verwenden Sie das `local`-Profil: `./mvnw spring-boot:run -Dspring-boot.run.profiles=local,without-vault`

Wenn Sie Vault ohne K8s testen möchten: Starten Sie Vault lokal mit```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

Verwenden Sie nun das `local-vault`-Profil für Ihre Entwicklung.```shell
./mvnw spring-boot:run -Dspring-boot.run.profiles=local,local-vault

Möchten Sie einen Container pushen? Siehe `.github/scripts/docker-create-and-push.sh` für ein Skript, das alle Container erstellt und pusht. Vergessen Sie nicht, die App neu zu erstellen, bevor Sie den Container erstellen.

Möchten Sie überprüfen, warum etwas in Vault in Kubernetes nicht funktioniert? Führen Sie `kubectl exec vault-0 -n vault -- vault audit enable file file_path=stdout` aus.

### Abhängigkeitsverwaltung

Wir haben CycloneDX und OWASP Dependency-Check integriert, um Abhängigkeiten auf Schwachstellen zu überprüfen.
Sie können den OWASP Dependency-Checker mit dem Aufruf `mvn dependency-check:aggregate` und `mvn cyclonedx:makeBom` verwenden, um mit CycloneDX eine SBOM zu erstellen.

### Konfiguration des Dependency-Check Maven-Plugins

OWASP WrongSecrets verwendet das [`dependency-check-maven`](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) Plugin, um Projektabhängigkeiten automatisch auf bekannte Schwachstellen (CVEs) zu scannen.

#### Funktionsweise

- Das Plugin wird während des Maven-Builds (`./mvnw clean install`) ausgeführt und prüft alle Abhängigkeiten gegen öffentliche Schwachstellendatenbanken.
- Standardmäßig verwendet es die NVD (National Vulnerability Database) und kann auch den OSS Index für eine zusätzliche Abdeckung nutzen.

#### Konfigurations-Highlights

Das Plugin ist in der `pom.xml` im Abschnitt `<build><plugins>` konfiguriert:```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>

Ersetzen Sie `YOUR_OSSINDEX_USERNAME` und `YOUR_OSSINDEX_API_TOKEN` durch Ihre OSS-Index-Kontodaten.

#### Fehlerbehebung

- Wenn Sie für den OSS-Index Fehler vom Typ `401 Unauthorized` sehen, überprüfen Sie Ihre Anmeldedaten oder deaktivieren Sie den OSS-Index, indem Sie `<ossIndexAnalyzerEnabled>false</ossIndexAnalyzerEnabled>` in `pom.xml` setzen.
- Sie können den Build jederzeit ohne OSS-Index ausführen, wenn Sie nur NVD-basiertes Scannen bevorzugen.

#### Weitere Informationen

Siehe [Dokumentation des Dependency-Check Maven-Plugins](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) für erweiterte Konfigurationsmöglichkeiten.

### Projekt in IntelliJ IDEA starten

Voraussetzungen: Stellen Sie sicher, dass Sie die folgenden Tools installiert haben: [Docker](https://www.docker.com/products/docker-desktop/), [Java25 JDK](https://jdk.java.net/25/), [NodeJS 24](https://nodejs.org/en/download/current) und [IntelliJ IDEA](https://www.jetbrains.com/idea/download).

1. Forken und clonen Sie das Projekt wie in der [Dokumentation](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md) beschrieben.
2. Importieren Sie das Projekt in IntelliJ (z. B. als Maven-Projekt / lokale Quellen importieren).
3. Gehen Sie zu den Projekteinstellungen und stellen Sie sicher, dass Java25 verwendet wird (und dass das JDK gefunden werden kann).
4. Gehen Sie zu den IDE-Einstellungen > Language & Frameworks > Lombok und stellen Sie sicher, dass die Lombok-Verarbeitung aktiviert ist.
5. Öffnen Sie den Maven-Tab in Ihrer IDEA und führen Sie "Reload All Maven Projects" aus, um das System zu synchronisieren und alles herunterzuladen. Verwenden Sie anschließend in demselben Tab die Option "install" als Teil des OWASP WrongSecrets Lifecycle, um das AsciiDoc und Ähnliches zu generieren.
6. Führen Sie nun die `main`-Methode in `org.owasp.wrongsecrets.WrongSecretsApplication.java` aus. Dies sollte mit einem Stacktrace fehlschlagen.
7. Gehen Sie nun zur Ausführungskonfiguration der App und stellen Sie sicher, dass das aktive Profil `without-vault` ist. Dies erfolgt durch Setzen der VM-Optionen auf `--server.port=8080 --spring.profiles.active=local,without-vault`. Setzen Sie `K8S_ENV=docker` als Umgebungsargument.
8. Wiederholen Sie Schritt 6: Starten Sie die App erneut. Sie sollten nun eine ordnungsgemäß laufende Anwendung haben, die Sie in Ihrem Browser unter http://localhost:8080 aufrufen können.

**Bildlicher Leitfaden** zum Starten des Projekts in IntelliJ IDEA ist unter [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-get-started-with-the-project-in-intellij-idea) verfügbar.

Sie können gerne Änderungen vorschlagen und Pull Requests einreichen. Beachten Sie unsere Anleitung in der [Dokumentation](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md), damit Ihre Arbeit akzeptiert wird.

Bitte beachten Sie, dass wir offiziell nur Linux und MacOS für die Entwicklung unterstützen. Wenn Sie auf einem Windows-Rechner entwickeln möchten, verwenden Sie WSL2 oder eine virtuelle Maschine mit Linux. Wir haben Windows-Erkennung und einige `exe`-Dateien für einen ersten Versuch eingefügt, suchen aber aktive Betreuer dafür. Möchten Sie sicherstellen, dass es unter Windows läuft? Erstellen Sie PRs ;-).

Wenn Sie nach dem Lesen dieses Abschnitts immer noch keine Ahnung vom Anwendungscode haben: Werfen Sie einen Blick [auf einige Tutorials zu Spring Boot von Baeldung](https://www.baeldung.com/spring-boot).

### Automatisches Neuladen während der Entwicklung

Um Änderungen schneller zu laden, haben wir `spring-dev-tools` zum Maven-Projekt hinzugefügt.
Um dies in IntelliJ automatisch zu aktivieren, stellen Sie Folgendes sicher:

-   Unter Compiler -> Automatisch Projekt erstellen ist aktiviert, und
-   Unter Erweiterte Einstellungen -> Automatische Erstellung auch starten, wenn die entwickelte Anwendung gerade ausgeführt wird, ist aktiviert.

Sie können auch manuell aufrufen: Build -> Datei, die Sie gerade geändert haben, neu kompilieren. Dies erzwingt ebenfalls das Neuladen der Anwendung.

### Hinzufügen einer Challenge

Befolgen Sie die folgenden Schritte zum Hinzufügen einer Challenge:

1. Stellen Sie zunächst sicher, dass ein [Issue](https://github.com/OWASP/wrongsecrets/issues) gemeldet wurde, für das eine Challenge wirklich gewünscht ist.
2. Fügen Sie die neue Challenge im Ordner `org.owasp.wrongsecrets.challenges` hinzu. Stellen Sie sicher, dass Sie eine Erklärung in `src/main/resources/explanations` hinzufügen und von Ihrer neuen Challenge-Klasse darauf verweisen.
3. Fügen Sie nach Bedarf Unit-, Integrations- und UI-Tests hinzu, um zu zeigen, dass Ihre Challenge funktioniert.
4. Vergessen Sie nicht, die Challenge in `src/main/resources/wrong-secrets-configuration.yaml` zu konfigurieren.
5. Überprüfen Sie die [CONTRIBUTING-Anleitung](https://github.com/owasp/wrongsecrets/blob/HEAD/CONTRIBUTING.md) zum Einrichten Ihrer Beitragsumgebung und zum Verfassen guter Commit-Nachrichten.

Weitere Einzelheiten finden Sie unter [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-add-a-challenge).

Wenn Sie bestehende Cloud-Herausforderungen in eine andere Cloud verschieben möchten: Erweitern Sie die Challenge-Klassen im Paket `org.owasp.wrongsecrets.challenges.cloud` und stellen Sie sicher, dass Sie das erforderliche Terraform in einem Ordner mit der entsprechenden Cloud-Kennung hinzufügen. Stellen Sie sicher, dass die Umgebung zu `org.owasp.wrongsecrets.RuntimeEnvironment` hinzugefügt wird.
Arbeiten Sie mit anderen im Projekt zusammen, um Ihren Container zum Laufen zu bringen, damit Sie im Cloud-Konto testen können.

### Lokales Testen

Wenn Sie einige Änderungen am Codebase vorgenommen oder eine neue Challenge hinzugefügt haben und genau sehen möchten, wie der Container nach dem Merge für Tests aussehen wird, haben wir ein Skript, das dies sehr einfach macht. Befolgen Sie die unten stehenden Schritte:

1. Stellen Sie sicher, dass Bash installiert und geöffnet ist.
2. Navigieren Sie zu .github/scripts.
3. Führen Sie das Skript docker-create aus: `bash docker-create.sh`.
   - Hinweis: Möchten Sie dies auf Ihrem Minikube ausführen? Führen Sie zuerst `eval $(minikube docker-env)` aus.
4. Befolgen Sie alle gegebenen Anweisungen. Möglicherweise müssen Sie Pakete installieren/ändern.
5. Führen Sie den neu erstellten Container aus:
  - für lokale Ausführung: `docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:local-test-no-vault`
  - zur Ausführung auf Ihrem Minikube: Verwenden Sie den Container `jeroenwillemsen/wrongsecrets:local-test-k8s-vault` in Ihrer Deployment-Definition.
  - zur Ausführung mit Vault auf Ihrem Minikube: Verwenden Sie den Container `jeroenwillemsen/wrongsecrets:local-test-local-vault` in Ihrer Deployment-Definition.

### Lokales automatisiertes Testen

Wir haben derzeit 2 verschiedene Test-Suiten, die beide mit `./mvnw test` gestartet werden.
- Eine normale JUnit-Testsuite mit Unit- und Integrationstests, die sich im [`test/java`-Ordner](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/java) befindet, mit Ausgabe im Standard-Zielverzeichnis.
- Eine Cypress-Testsuite, die mittels eines JUnit-Tests integriert ist, befindet sich im [`test/e2e`-Ordner](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/e2e) mit Ausgabe in [`target/test-classes/e2e/cypress/reports/`](https://github.com/owasp/wrongsecrets/blob/HEAD/target/test-classes/e2e/cypress/reports/). Weitere Einzelheiten finden Sie in der [Cypress-Readme](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/e2e/cypress/README.md).

Hinweis: Sie können einen vollständigen Durchlauf von Bereinigen, Bauen und Testen mit `./mvnw clean install` durchführen.

## 🔧 Fehlerbehebung

### Häufige Probleme

**Docker-Probleme:**
- **Port bereits belegt**: Ändern Sie das Port-Mapping: `docker run -p 8081:8080 -p 8091:8090 jeroenwillemsen/wrongsecrets:latest-no-vault`
- **Docker nicht gefunden**: Stellen Sie sicher, dass Docker installiert und ausgeführt wird.
- **Zugriff verweigert**: Unter Linux müssen Sie möglicherweise Ihren Benutzer zur Docker-Gruppe hinzufügen.

**Browser-Probleme:**
- **localhost:8080 nicht erreichbar**: Überprüfen Sie mit `docker ps`, ob der Docker-Container läuft.
- **Challenges werden nicht geladen**: Leeren Sie den Browser-Cache oder versuchen Sie den Inkognito-Modus.

**Kubernetes-Probleme:**
- **Minikube startet nicht**: Versuchen Sie `minikube delete` und dann `minikube start`.
- **Pods hängen in Pending**: Überprüfen Sie die Ressourcen mit `kubectl describe pod <Pod-Name>`.

**Hilfe benötigt?**
- Überprüfen Sie unsere [GitHub Issues](https://github.com/OWASP/wrongsecrets/issues)
- Treten Sie uns auf [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR) bei.
- Lesen Sie den Abschnitt [Support](#support).

## Möchten Sie spielen, dürfen aber die Tools nicht installieren?

Wenn Sie die Challenges spielen möchten, aber Tools wie keepass, Radare usw. nicht installieren können, aber Docker-Container ausführen dürfen, versuchen Sie Folgendes:```shell
docker run -p 3000:3000 -v /var/run/docker.sock:/var/run/docker.sock jeroenwillemsen/wrongsecrets-desktop:latest

Und dann unter [http://localhost:3000](http://localhost:3000).

Hinweis: Seien Sie vorsichtig beim Versuch, den `jeroenwillemsen/wrongsecrets-desktop`-Container auf Heroku bereitzustellen ;-).

## Docker auf macOS mit M1 und Colima (Experimentell!)

HINWEIS: Wir unterstützen Colima nicht offiziell, da wir feststellen, dass Github-Runner viele Probleme damit haben.

Wenn Sie nicht zu Docker Desktop/Podman wechseln können und Colima mit Apple Silicon M1 verwenden möchten, um das Docker-Image `jeroenwillemsen/wrongsecrets` auszuführen, versuchen Sie eines der folgenden:

- Colima ausschalten (`colima stop`)
- Docker-Kontext ändern (`docker --context desktop-linux run -p 8080:8080 jeroenwillemsen/wrongsecrets:latest-no-vault`)
- Colima mit 1 CPU ausführen (`colima start -m 8 -c 1 --arch x86_64`)

## Möchten Sie Herausforderungen in Ihrer eigenen Version deaktivieren?

Wenn Sie WrongSecrets ausführen möchten, aber ohne bestimmte Herausforderungen, die Sie anderen nicht präsentieren möchten: Lesen Sie bitte diesen Abschnitt.

*_HINWEIS_* Bitte beachten Sie, dass wir keinen Support für Ihren Fork leisten, wenn Sie den untenstehenden Prozess befolgen. Bitte verstehen Sie, dass Lizenz und Urheberrecht der ursprünglichen Anwendung für Ihren Fork erhalten bleiben.

Anforderungen:
- JDK von Java 25 installiert haben;
- Ein Konto bei einer Registry haben, in die Sie Ihre Variante des WrongSecrets-Containers pushen können;

Hier sind die Schritte, die Sie befolgen müssen, um Ihre eigene Version von WrongSecrets mit deaktivierten Herausforderungen zu erstellen:
1. Forken Sie das Repository.
2. Entfernen Sie in `src/main/resources/wrong-secrets-configuration.yaml` den Verweis auf die Herausforderung, die Sie in Ihrem Fork nicht mehr haben möchten.
3. Führen Sie im Root des Projekts `./mvnw clean install` aus
4. Erstellen Sie nun das Docker-Image für Ihr gewünschtes Ziel:```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