⚠️ *Nota: Esta es una versión de desarrollo y puede ser inestable*
4. **Configuración avanzada**: Para desafíos en la nube y ejercicios de Kubernetes, consulta las instrucciones detalladas a continuación

**Lo que aprenderás:**
- Errores comunes en la gestión de secretos
- Cómo identificar credenciales expuestas
- Mejores prácticas para asegurar secretos
- Herramientas y técnicas para la detección de secretos

**Cómo funciona:**
Este repositorio contiene **código y archivos de configuración intencionalmente vulnerables** con secretos reales y falsos ocultos en todo el código base. Examinarás el código fuente, los archivos de configuración, los contenedores Docker y los despliegues en la nube para descubrir estos secretos. Cada desafío te enseña diferentes formas en que los secretos pueden exponerse accidentalmente en aplicaciones del mundo real.

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

## 📋 Requisitos previos

**Para uso básico:**
- Un navegador web
- Docker (para configuración local) - [Instalar aquí](https://docs.docker.com/get-docker/)

**Para configuraciones avanzadas:**
- Kubernetes/Minikube - [Instalar aquí](https://minikube.sigs.k8s.io/docs/start/)
- Cuenta en la nube (AWS/GCP/Azure) para desafíos en la nube
- Familiaridad con la línea de comandos

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

## Tabla de contenidos

### 🎯 Comenzando
-   [Inicio rápido](#-quick-start)
-   [Requisitos previos](#-prerequisites)
-   [Soporte](#support)

### 🐳 Opciones de despliegue
-   [Ejercicios básicos de Docker](#basic-docker-exercises)
 -   [Ejecutarlos en Heroku](#running-these-on-heroku)
 -   [Ejecutarlos en Render.io](#running-these-on-renderio)
 -   [Ejecutarlos en Railway](#running-these-on-railway)
-   [Ejercicio básico de K8s](#basic-k8s-exercise)
 -   [Basado en Minikube](#minikube-based)
 -   [Basado en k8s](#k8s-based)
 -   [Ejercicios con Vault y minikube](#vault-exercises-with-minikube)

### ☁️ Desafíos en la nube
-   [Desafíos en la nube](#cloud-challenges)
 -   [Ejecutar WrongSecrets en AWS](#running-wrongsecrets-in-aws)
 -   [Ejecutar WrongSecrets en GCP](#running-wrongsecrets-in-gcp)
 -   [Ejecutar WrongSecrets en Azure](#running-wrongsecrets-in-azure)
 -   [Ejecutar el Desafío 15 solo en tu propia nube](#running-challenge15-in-your-own-cloud-only)

### 🎮 Uso avanzado
-   [¿Quieres jugar sin guía?](#do-you-want-to-play-without-guidance-or-spoils)
-   [CTF](#ctf)
 -   [Soporte CTFD](#ctfd-support)
 -   [Soporte FBCTF](#fbctf-support-experimental)
-   [Usar OWASP WrongSecrets como punto de referencia de detección de secretos](#use-owasp-wrongsecrets-as-a-secret-detection-benchmark)

### 👨‍💻 Desarrollo y contribución
-   [Notas sobre el desarrollo](#notes-on-development)
-   [Lista de verificación para la adopción de Spring Boot 4](https://github.com/owasp/wrongsecrets/blob/master/docs/SPRING_BOOT_4_ADOPTION_CHECKLIST.md)
 -   [Gestión de dependencias](#dependency-management)
 -   [Iniciar el proyecto en IntelliJ IDEA](#get-the-project-started-in-intellij-idea)
 -   [Recarga automática durante el desarrollo](#automatic-reload-during-development)
 -   [Cómo añadir un desafío](#how-to-add-a-challenge)
 -   [Pruebas locales](#local-testing)
 -   [Pruebas automatizadas locales](#Local-automated-testing)
-   [¿Quieres deshabilitar desafíos en tu propia versión?](#want-to-disable-challenges-in-your-own-release)

### 📚 Recursos y comunidad
-   [Agradecimientos especiales y contribuyentes](#special-thanks--contributors)
-   [Patrocinios](#sponsorships)
-   [Se necesita ayuda](#help-wanted)
-   [Lecturas adicionales sobre gestión de secretos](#further-reading-on-secrets-management)

## Soporte

¿Necesitas soporte? Contáctanos
a través de [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR) para lo cual debes registrarte [aquí](https://owasp.org/slack/invite)
, presenta una [PR](https://github.com/OWASP/wrongsecrets/pulls), reporta
un [issue](https://github.com/OWASP/wrongsecrets/issues) , o
usa [discussions](https://github.com/OWASP/wrongsecrets/discussions). Ten en cuenta que este es un proyecto basado en voluntarios de OWASP, por lo que puede tomar un tiempo antes de que respondamos.

Copyright (c) 2020-2025 Jeroen Willemsen and WrongSecrets contributors.

## 🛤️ Elige tu camino

¿No estás seguro de qué configuración es la adecuada para ti? Aquí tienes una guía rápida:

| **Quiero...** | **Configuración recomendada** | **Desafíos disponibles** |
|------------------|----------------------|--------------------------|
| Probarlo rápidamente en línea | [Contenedor ejecutándose en Heroku](https://www.wrongsecrets.com/) | Desafíos básicos (0-4, 8, 12-32, 34-43, 49-52, 54-66) |
| Ejecutarlo localmente con Docker | [Docker básico](#basic-docker-exercises) | Igual que arriba, pero en tu máquina |
| Aprender secretos de Kubernetes | [Configuración K8s/Minikube](#basic-k8s-exercise) | Desafíos de Kubernetes (0-6, 8, 12-43, 48-66) |
| Practicar con secretos en la nube | [Desafíos en la nube](#cloud-challenges) | Todos los desafíos (0-66) |
| Realizar un taller/CTF | [Configuración CTF](#ctf) | Conjuntos de desafíos personalizables |
| Contribuir al proyecto | [Configuración de desarrollo](#notes-on-development) | Todos los desafíos + herramientas de desarrollo |

## Ejercicios básicos de Docker

_Puede usarse para los desafíos 0-4, 8, 12-32, 34-43, 49-52, 54-66_

Para los ejercicios básicos de Docker actualmente necesitas:

-   Docker [Instalar desde aquí](https://docs.docker.com/get-docker/)
-   Un navegador que pueda renderizar HTML

Puedes instalarlo haciendo:```bash
docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:latest-no-vault

⚠️ **Advertencia**: Esta es una versión de desarrollo creada desde la última rama master y puede contener características experimentales o inestabilidades.

**📝 Nota sobre puertos:**
- Puerto **8080**: Aplicación principal (desafíos 0-66)
- Puerto **8090**: Servidor MCP (requerido para el Desafío 60)

**📝 Nota sobre el Desafío 62 (Google Drive MCP):**
El Desafío 62 requiere que se configure una Cuenta de Servicio de Google para su funcionalidad completa. Consulta [docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md](https://github.com/owasp/wrongsecrets/blob/master/docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md) para las instrucciones de configuración. Sin configuración, el desafío mostrará un mensaje de marcador de posición.

Ahora puedes intentar encontrar los secretos resolviendo los desafíos ofrecidos en los enlaces a continuación
<details>
    <summary>Todos los enlaces para los desafíos Docker (haz clic en el triángulo para abrir el bloque).
    </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>

Ten en cuenta que estos desafíos son aún muy básicos, y sus explicaciones también. Siéntete libre de enviar un PR para mejorarlos ;-).

### Ejecutarlos en Heroku

¡También puedes probarlos en [https://wrongsecrets.herokuapp.com/](https://wrongsecrets.herokuapp.com/)! La gente de Heroku nos ha proporcionado un increíble paquete de soporte de código abierto, que nos permite ejecutar la aplicación de forma gratuita allí, donde está casi siempre activa. Aun así, no hagas fuzzing ni intentes derribarla: estarías estropeando la experiencia para otros que quieran probarla.
Usa [este enlace](https://wrongsecrets.herokuapp.com/) para usar nuestra versión alojada de la aplicación. Si deseas alojarla tú mismo en Heroku (por ejemplo, para realizar un entrenamiento), puedes hacerlo haciendo clic en [este enlace](https://heroku.com/deploy?template=https://github.com/OWASP/wrongsecrets/tree/master). Ten en cuenta que esto incurrirá en costos de los cuales este proyecto y/o sus mantenedores no pueden hacerse responsables.

### Ejecutarlos en Render.io
*estado: experimental*

Puedes probarlos en [https://wrongsecrets.onrender.com/](https://wrongsecrets.onrender.com/). Por favor, entiende que ejecutamos en una instancia de nivel gratuito, no podemos dar garantías. No hagas fuzzing ni intentes derribarla: estarías estropeando la experiencia para otros que quieran probarla.
¿Quieres desplegar tú mismo con Render? Haz clic en el botón de abajo:

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

### Ejecutarlos en Railway
*estado: mantenido por [alphasec.io](https://github.com/alphasecio)*

Si deseas alojar WrongSecrets en Railway, puedes hacerlo desplegando [esta plantilla de un clic](https://railway.com/deploy/McqJ_j?referralCode=I07F1). Railway ya no ofrece un plan siempre gratuito, pero la prueba gratuita es suficiente para probarlo antes de decidirte a actualizar. Si necesitas una guía paso a paso, consulta [esta entrada 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=I07F1)

## Ejercicio básico de K8s

_Puede usarse para los desafíos 0-6, 8, 12-43, 48-66_

### Basado en Minikube

Asegúrate de tener instalado lo siguiente:

-   Docker [Instalar desde aquí](https://docs.docker.com/get-docker/)
-   Minikube [Instalar desde aquí](https://minikube.sigs.k8s.io/docs/start/)

La configuración de K8S actualmente se basa en el uso de Minikube para diversión local. Puedes usar los comandos a continuación desde la raíz del proyecto:```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

ahora puedes usar la dirección IP y el puerto proporcionados para jugar más con la variante de K8s (en lugar 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)

### basado en k8s

¿Quieres ejecutar vanilla en tu propio k8s? Usa los comandos a continuación:```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

> **Nota:** Las pistas solo se pueden generar si la instancia de WrongSecrets tiene las pistas habilitadas (`HINTS_ENABLED=true`). La instancia de Heroku CTF ([https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)) se ejecuta con `HINTS_ENABLED=false`, por lo que seleccionar "Pistas gratuitas" o "Pistas de pago" resultará en una lista de pistas vacía. Para generar pistas, ejecuta tu propia instancia con `HINTS_ENABLED=true`.

Ahora visita la instancia de CTFD en [http://localhost:8001](http://localhost:8001) y configura tu CTF.
Luego usa la función de copia de seguridad administrativa para importar el archivo zip que creaste con el comando juice-shop-ctf.
¡A jugar usando [https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)!
¿Quieres configurar el tuyo propio? ¡Puedes! Sin embargo, ten cuidado de que otros encuentren tu clave, así que asegúrala adecuadamente: asegúrate de que el contenedor en ejecución con la clave ctf real no esté expuesto al público, similar a nuestro contenedor de Heroku.

## Soporte FBCTF (Experimental!)

NOTA: El soporte FBCTF es experimental.

Sigue los mismos pasos que con CTFD, solo que ahora elige fbctfd y como URL para el mapeo de países elige `https://raw.githubusercontent.com/OWASP/wrongsecrets/79a982558016c8ce70948a8106f9a2ee5b5b9eea/config/fbctf.yml`.
Luego sigue [https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide](https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide) para ejecutar el FBCTF.

## Notas sobre el desarrollo

Para el desarrollo en la máquina local usa el perfil `local` `./mvnw spring-boot:run -Dspring-boot.run.profiles=local,without-vault`

Si quieres probar contra vault sin K8s: inicia vault localmente con```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

Ahora usa el perfil `local-vault` para hacer tu desarrollo.```shell
./mvnw spring-boot:run -Dspring-boot.run.profiles=local,local-vault

¿Quieres subir un contenedor? Consulta `.github/scripts/docker-create-and-push.sh` para un script que genera y sube todos los contenedores. No olvides reconstruir la aplicación antes de componer el contenedor.

¿Quieres comprobar por qué algo en vault no funciona en kubernetes? Ejecuta `kubectl exec vault-0 -n vault -- vault audit enable file file_path=stdout`.

### Gestión de dependencias

Tenemos integrados CycloneDX y OWASP Dependency-check para verificar dependencias en busca de vulnerabilidades.
Puedes usar el OWASP Dependency-checker llamando a `mvn dependency-check:aggregate` y `mvn cyclonedx:makeBom` para usar CycloneDX y crear un SBOM.

### Configuración del plugin Dependency-Check Maven

OWASP WrongSecrets utiliza el plugin [`dependency-check-maven`](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) para escanear automáticamente las dependencias del proyecto en busca de vulnerabilidades conocidas (CVEs).

#### Cómo funciona

- El plugin se ejecuta durante la compilación de Maven (`./mvnw clean install`) y verifica todas las dependencias contra bases de datos de vulnerabilidades públicas.
- Por defecto, utiliza la NVD (National Vulnerability Database) y también puede usar OSS Index para una cobertura adicional.

#### Aspectos destacados de la configuración

El plugin se configura en `pom.xml` dentro de la sección `<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>

Reemplaza `YOUR_OSSINDEX_USERNAME` y `YOUR_OSSINDEX_API_TOKEN` con los detalles de tu cuenta de OSS Index.

#### Troubleshooting

- Si ves errores `401 Unauthorized` para OSS Index, verifica tus credenciales o deshabilita OSS Index configurando `<ossIndexAnalyzerEnabled>false</ossIndexAnalyzerEnabled>` en `pom.xml`.
- Siempre puedes ejecutar la compilación sin OSS Index si prefieres solo el escaneo basado en NVD.

#### More Info

Consulta la [Documentación del Plugin Maven de Dependency-Check](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) para opciones de configuración avanzadas.

### Get the project started in IntelliJ IDEA

Requisitos: asegúrate de tener instaladas las siguientes herramientas: [Docker](https://www.docker.com/products/docker-desktop/), [Java25 JDK](https://jdk.java.net/25/), [NodeJS 24](https://nodejs.org/en/download/current) e [IntelliJ IDEA](https://www.jetbrains.com/idea/download).

1. Haz un fork y clona el proyecto como se describe en la [documentación](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md).
2. Importa el proyecto en IntelliJ (por ejemplo, como proyecto mvn / fuentes locales).
3. Ve a la configuración del proyecto y asegúrate de que use Java25 (y que el JDK se pueda encontrar).
4. Ve a IDE settings > Language & Frameworks > Lombok y asegúrate de que el procesamiento de Lombok esté habilitado.
5. Abre la pestaña Maven en tu IDEA y ejecuta "Reload All Maven Projects" para sincronizar el sistema y descargar todo. Luego, en esa misma pestaña, usa la opción "install" como parte del ciclo de vida de OWASP WrongSecrets para generar el asciidoc y demás.
6. Ahora ejecuta el método `main` en `org.owasp.wrongsecrets.WrongSecretsApplication.java`. Esto debería fallar con un stack trace.
7. Ahora ve a la configuración de ejecución de la aplicación y asegúrate de tener el perfil activo `without-vault`. Esto se hace configurando los argumentos de opciones de VM en `--server.port=8080 --spring.profiles.active=local,without-vault`. Establece `K8S_ENV=docker` como argumento de entorno.
8. Repite el paso 6: ejecuta la aplicación nuevamente; deberías tener una aplicación funcionando correctamente que se puede visitar en http://localhost:8080.

**Guía ilustrada** sobre cómo iniciar el proyecto en IntelliJ IDEA está disponible en [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-get-started-with-the-project-in-intellij-idea).

Siéntete libre de editar y proponer cambios mediante pull requests. Asegúrate de seguir nuestra guía en la [documentación](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md) para que tu trabajo sea aceptado.

Ten en cuenta que oficialmente solo soportamos Linux y MacOS para desarrollo. Si deseas desarrollar usando una máquina Windows, usa WSL2 o una máquina virtual con Linux. Incluimos detección de Windows y un montón de archivos `exe` para un primer experimento, pero buscamos mantenedores activos para ellos. ¿Quieres asegurarte de que funcione en Windows? ¡Crea PRs ;-).

Si, después de leer esta sección, aún no tienes idea sobre el código de la aplicación: echa un vistazo [a algunos tutoriales sobre Spring Boot de Baeldung](https://www.baeldung.com/spring-boot).

### Automatic reload during development

Para que los cambios realizados se carguen más rápido, agregamos `spring-dev-tools` al proyecto Maven.
Para habilitar esto en IntelliJ automáticamente, asegúrate de:

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

También puedes invocar manualmente: Build -> Recompile the file you just changed, esto también forzará la recarga de la aplicación.

### How to add a Challenge

Sigue los pasos a continuación para agregar un desafío:

1. Primero asegúrate de tener un [Issue](https://github.com/OWASP/wrongsecrets/issues) reportado para el cual realmente se desee un desafío.
2. Añade el nuevo desafío en la carpeta `org.owasp.wrongsecrets.challenges`. Asegúrate de agregar una explicación en `src/main/resources/explanations` y hacer referencia a ella desde tu nueva clase Challenge.
3. Agrega pruebas unitarias, de integración y de IU según corresponda para demostrar que tu desafío funciona.
4. No olvides configurar el desafío en `src/main/resources/wrong-secrets-configuration.yaml`
5. Revisa la [guía de CONTRIBUTING](https://github.com/owasp/wrongsecrets/blob/master/CONTRIBUTING.md) para configurar tu entorno de contribución y escribir buenos mensajes de commit.

Para más detalles, consulta [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-add-a-challenge).

Si deseas mover desafíos cloud existentes a otra nube: extiende las clases Challenge en el paquete `org.owasp.wrongsecrets.challenges.cloud` y asegúrate de agregar el Terraform requerido en una carpeta con el identificador de la nube correspondiente. Asegúrate de que el entorno se agregue a `org.owasp.wrongsecrets.RuntimeEnvironment`.
Colabora con los demás en el proyecto para que tu contenedor se ejecute y puedas probar en la cuenta cloud.

### Local testing

Si has realizado algunos cambios en el código base o agregado un nuevo desafío y te gustaría ver exactamente cómo se verá el contenedor después de fusionarlo para pruebas, tenemos un script que facilita esto. Sigue los pasos a continuación:

1. Asegúrate de tener bash instalado y abierto.
2. Navega a .github/scripts.
3. Ejecuta el script docker-create `bash docker-create.sh`.
   - Nota: ¿Quieres ejecutar esto en tu minikube? entonces primero ejecuta `eval $(minikube docker-env)`.
4. Sigue las instrucciones que se den, es posible que necesites instalar/cambiar paquetes.
5. Ejecuta el contenedor recién creado:
  - para ejecutarlo localmente: `docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:local-test-no-vault`
  - para ejecutarlo en tu minikube: usa el contenedor `jeroenwillemsen/wrongsecrets:local-test-k8s-vault` en tu definición de despliegue.
  - para ejecutarlo con Vault en tu minikube: usa el contenedor `jeroenwillemsen/wrongsecrets:local-test-local-vault` en tu definición de despliegue.

### Local Automated testing

Actualmente tenemos 2 suites de pruebas diferentes, ambas ejecutadas con `./mvnw test`.
- Una suite de pruebas junit normal de pruebas unitarias y de integración, ubicada en la carpeta [`test/java`](https://github.com/owasp/wrongsecrets/blob/master/src/test/java) con salida almacenada en el directorio target predeterminado.
- Una suite de pruebas cypress, integrada mediante una prueba junit, ubicada en la carpeta [`test/e2e`](https://github.com/owasp/wrongsecrets/blob/master/src/test/e2e) con salida almacenada en [`target/test-classes/e2e/cypress/reports/`](https://github.com/owasp/wrongsecrets/blob/master/target/test-classes/e2e/cypress/reports). Consulta el [readme de cypress](https://github.com/owasp/wrongsecrets/blob/master/src/test/e2e/cypress/README.md) para más detalles.

Nota: Puedes hacer un ciclo completo de limpieza, compilación y pruebas con `./mvnw clean install`.

## 🔧 Troubleshooting

### Common Issues

**Problemas de Docker:**
- **Puerto ya en uso**: Cambia el mapeo de puertos: `docker run -p 8081:8080 -p 8091:8090 jeroenwillemsen/wrongsecrets:latest-no-vault`
- **Docker no encontrado**: Asegúrate de que Docker esté instalado y en ejecución
- **Permiso denegado**: En Linux, es posible que necesites agregar tu usuario al grupo docker

**Problemas del navegador:**
- **No se puede acceder a localhost:8080**: Verifica si el contenedor Docker se está ejecutando con `docker ps`
- **Los desafíos no cargan**: Limpia la caché del navegador o prueba el modo incógnito

**Problemas de Kubernetes:**
- **Minikube no se inicia**: Prueba `minikube delete` y luego `minikube start`
- **Pods atascados en pending**: Verifica los recursos con `kubectl describe pod <nombre-del-pod>`

**¿Necesitas ayuda?**
- Consulta nuestros [GitHub Issues](https://github.com/OWASP/wrongsecrets/issues)
- Únete a nosotros en [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR)
- Revisa la sección de [Soporte](#support)

## Want to play, but are not allowed to install the tools?

Si quieres jugar los desafíos, pero no puedes instalar herramientas como keepass, Radare, etc., pero tienes permitido ejecutar contenedores Docker, prueba lo siguiente:```shell
docker run -p 3000:3000 -v /var/run/docker.sock:/var/run/docker.sock jeroenwillemsen/wrongsecrets-desktop:latest

Y luego en [http://localhost:3000](http://localhost:3000).

Nota: ten cuidado al intentar desplegar el contenedor `jeroenwillemsen/wrongsecrets-desktop` en Heroku ;-).

## Docker en macOS con M1 y Colima (¡Experimental!)

NOTA: No brindamos soporte oficial a Colima, ya que hemos visto que los runners de Github tienen muchos problemas con él.

Si no puedes cambiar a Docker Desktop/Podman y quieres usar Colima con Apple Silicon M1
para ejecutar la imagen de Docker `jeroenwillemsen/wrongsecrets`, prueba una de las siguientes opciones:

- apagar Colima (`colima stop`)
- cambiar el contexto de Docker (`docker --context desktop-linux run -p 8080:8080 jeroenwillemsen/wrongsecrets:latest-no-vault`)
- ejecutar Colima con 1 CPU (`colima start -m 8 -c 1 --arch x86_64`)

## ¿Quieres deshabilitar desafíos en tu propia versión?

Si quieres ejecutar WrongSecrets pero sin ciertos desafíos que no deseas presentar a otros: lee esta sección.

*_NOTA_* Ten en cuenta que no brindamos ningún soporte a tu fork cuando sigas el proceso a continuación. Por favor, comprende que la licencia y los derechos de autor de la aplicación original permanecen intactos para tu Fork.

Requisitos:
- Tener instalado el JDK de Java 25;
- Tener una cuenta en un registro al que puedas subir tu variante del contenedor WrongSecrets;

Estos son los pasos que debes seguir para crear tu propia versión de WrongSecrets con ciertos desafíos deshabilitados:
1. Haz un fork del repositorio.
2. En `src/main/resources/wrong-secrets-configuration.yaml`, elimina la referencia al desafío que ya no deseas tener en tu fork.
3. En la raíz del proyecto, ejecuta `./mvnw clean install`
4. Ahora construye la imagen Docker para tu objetivo deseado:```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