⚠️ *Nota: Esta é uma versão de desenvolvimento e pode ser instável*
4. **Configuração Avançada**: Para desafios em nuvem e exercícios Kubernetes, veja as instruções detalhadas abaixo

**O que você aprenderá:**
- Erros comuns de gerenciamento de segredos
- Como identificar credenciais expostas
- Melhores práticas para proteger segredos
- Ferramentas e técnicas para detecção de segredos

**Como funciona:**
Este repositório contém **código e arquivos de configuração intencionalmente vulneráveis** com segredos reais e falsos ocultos em toda a base de código. Você examinará código-fonte, arquivos de configuração, contêineres Docker e implantações em nuvem para descobrir esses segredos. Cada desafio ensina diferentes maneiras pelas quais segredos podem ser acidentalmente expostos em aplicações do mundo real.

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

## 📋 Pré-requisitos

**Para uso básico:**
- Um navegador web
- Docker (para configuração local) - [Instale aqui](https://docs.docker.com/get-docker/)

**Para configurações avançadas:**
- Kubernetes/Minikube - [Instale aqui](https://minikube.sigs.k8s.io/docs/start/)
- Conta na nuvem (AWS/GCP/Azure) para desafios na nuvem
- Familiaridade com linha de comando

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

## Índice

### 🎯 Introdução
-   [Início Rápido](#-quick-start)
-   [Pré-requisitos](#-prerequisites)
-   [Suporte](#support)

### 🐳 Opções de Implantação
-   [Exercícios básicos com Docker](#basic-docker-exercises)
 -   [Executando no Heroku](#running-these-on-heroku)
 -   [Executando no Render.io](#running-these-on-renderio)
 -   [Executando no Railway](#running-these-on-railway)
-   [Exercício básico de K8s](#basic-k8s-exercise)
 -   [Baseado em Minikube](#minikube-based)
 -   [Baseado em k8s](#k8s-based)
 -   [Exercícios com Vault e minikube](#vault-exercises-with-minikube)

### ☁️ Desafios na Nuvem
-   [Desafios na Nuvem](#cloud-challenges)
 -   [Executando WrongSecrets na AWS](#running-wrongsecrets-in-aws)
 -   [Executando WrongSecrets no GCP](#running-wrongsecrets-in-gcp)
 -   [Executando WrongSecrets no Azure](#running-wrongsecrets-in-azure)
 -   [Executando o Desafio15 apenas na sua nuvem](#running-challenge15-in-your-own-cloud-only)

### 🎮 Uso Avançado
-   [Quer jogar sem orientação?](#do-you-want-to-play-without-guidance-or-spoils)
-   [CTF](#ctf)
 -   [Suporte CTFD](#ctfd-support)
 -   [Suporte FBCTF (experimental)](#fbctf-support-experimental)
-   [Use OWASP WrongSecrets como um benchmark de detecção de segredos](#use-owasp-wrongsecrets-as-a-secret-detection-benchmark)

### 👨‍💻 Desenvolvimento e Contribuição
-   [Notas sobre desenvolvimento](#notes-on-development)
-   [Checklist de adoção do Spring Boot 4](https://github.com/owasp/wrongsecrets/blob/master/docs/SPRING_BOOT_4_ADOPTION_CHECKLIST.md)
 -   [Gerenciamento de dependências](#dependency-management)
 -   [Iniciar o projeto no IntelliJ IDEA](#get-the-project-started-in-intellij-idea)
 -   [Recarga automática durante o desenvolvimento](#automatic-reload-during-development)
 -   [Como adicionar um Desafio](#how-to-add-a-challenge)
 -   [Testes locais](#local-testing)
 -   [Testes automatizados locais](#Local-automated-testing)
-   [Quer desabilitar desafios em sua própria versão?](#want-to-disable-challenges-in-your-own-release)

### 📚 Recursos e Comunidade
-   [Agradecimentos especiais e Contribuidores](#special-thanks--contributors)
-   [Patrocínios](#sponsorships)
-   [Ajuda Desejada](#help-wanted)
-   [Leitura adicional sobre gerenciamento de segredos](#further-reading-on-secrets-management)

## Suporte

Precisa de suporte? Entre em contato conosco
via [Slack do OWASP](https://owasp.slack.com/archives/C02KQ7D9XHR) para o qual você se inscreve [aqui](https://owasp.org/slack/invite)
, envie um [PR](https://github.com/OWASP/wrongsecrets/pulls), abra
uma [issue](https://github.com/OWASP/wrongsecrets/issues) , ou
use [discussões](https://github.com/OWASP/wrongsecrets/discussions). Observe que este é um projeto baseado em voluntários
do OWASP, então pode levar um tempo até que respondamos.

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

## 🛤️ Escolha Seu Caminho

Não tem certeza de qual configuração é ideal para você? Aqui está um guia rápido:

| **Eu quero...** | **Configuração Recomendada** | **Desafios Disponíveis** |
|------------------|----------------------|--------------------------|
| Experimente rapidamente online | [Contêiner executando no Heroku](https://www.wrongsecrets.com/) | Desafios básicos (0-4, 8, 12-32, 34-43, 49-52, 54-66) |
| Execute localmente com Docker | [Docker Básico](#basic-docker-exercises) | Mesmo que acima, mas na sua máquina |
| Aprenda segredos do Kubernetes | [Configuração K8s/Minikube](#basic-k8s-exercise) | Desafios Kubernetes (0-6, 8, 12-43, 48-66) |
| Pratique com segredos na nuvem | [Desafios na Nuvem](#cloud-challenges) | Todos os desafios (0-66) |
| Realize um workshop/CTF | [Configuração CTF](#ctf) | Conjuntos de desafios personalizáveis |
| Contribua com o projeto | [Configuração de Desenvolvimento](#notes-on-development) | Todos os desafios + ferramentas de desenvolvimento |

## Exercícios básicos com Docker

_Pode ser usado para os desafios 0-4, 8, 12-32, 34-43, 49-52, 54-66_

Para os exercícios básicos com Docker, você precisa atualmente de:

-   Docker [Instale aqui](https://docs.docker.com/get-docker/)
-   Algum navegador que possa renderizar HTML

Você pode instalá-lo fazendo:```bash
docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:latest-no-vault

⚠️ **Aviso**: Esta é uma versão de desenvolvimento construída a partir do branch master mais recente e pode conter funcionalidades experimentais ou instabilidades.

**📝 Nota sobre Portas:**
- Porta **8080**: Aplicação principal (desafios 0-66)
- Porta **8090**: Servidor MCP (necessário para o Desafio 60)

**📝 Nota sobre o Desafio 62 (Google Drive MCP):**
O Desafio 62 requer que uma Conta de Serviço do Google seja configurada para funcionalidade completa. Consulte [docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md](https://github.com/owasp/wrongsecrets/blob/master/docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md) para instruções de configuração. Sem configuração, o desafio exibirá uma mensagem de espaço reservado.

Agora você pode tentar encontrar os segredos resolvendo os desafios oferecidos nos links abaixo
<details>
    <summary>todos os links para os desafios docker (clique no triângulo para abrir o bloco).
    </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>

Note que estes desafios ainda são muito básicos, assim como suas explicações. Sinta-se à vontade para abrir um PR para melhorá-los ;-).

### Executando no Heroku

Você também pode testá-los em [https://wrongsecrets.herokuapp.com/](https://wrongsecrets.herokuapp.com/)! O pessoal da Heroku nos deu um pacote de suporte open source incrível, que nos permite executar o aplicativo gratuitamente lá, onde ele fica quase sempre no ar. Ainda assim, por favor, não faça fuzzing e/ou tente derrubá-lo: você estaria estragando a experiência para outros que desejam testá-lo.
Use [este link](https://wrongsecrets.herokuapp.com/) para usar nossa versão hospedada do aplicativo. Se você quiser hospedá-lo no Heroku por conta própria (por exemplo, para realizar um treinamento), pode fazê-lo clicando [neste link](https://heroku.com/deploy?template=https://github.com/OWASP/wrongsecrets/tree/master). Esteja ciente de que isso incorrerá em custos pelos quais este projeto e/ou seus mantenedores não podem ser responsabilizados.

### Executando no Render.io
*status: experimental*

Você pode testá-los em [https://wrongsecrets.onrender.com/](https://wrongsecrets.onrender.com/). Por favor, entenda que executamos em uma instância gratuita, não podemos dar garantias. Por favor, não faça fuzzing e/ou tente derrubá-lo: você estaria estragando a experiência para outros que desejam testá-lo.
Quer implantar você mesmo com o Render? Clique no botão abaixo:

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


### Executando no Railway
*status: mantido por [alphasec.io](https://github.com/alphasecio)*

Se você quiser hospedar o WrongSecrets no Railway, pode fazê-lo implantando [este modelo de um clique](https://railway.com/deploy/McqJ_j?referralCode=I07F1). O Railway não oferece mais um plano sempre gratuito, mas o teste gratuito é suficiente para testar isso antes de decidir atualizar. Se você precisar de um guia passo a passo, veja [esta postagem no 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)

## Exercício básico de K8s

_Pode ser usado para os desafios 0-6, 8, 12-43, 48-66_

### Baseado em Minikube

Certifique-se de ter o seguinte instalado:

-   Docker [Instale a partir daqui](https://docs.docker.com/get-docker/)
-   Minikube [Instale a partir daqui](https://minikube.sigs.k8s.io/docs/start/)

A configuração do K8S atualmente é baseada no uso do Minikube para diversão local. Você pode usar os comandos abaixo a partir da raiz do projeto:```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

agora você pode usar o endereço IP e a porta fornecidos para continuar a explorar a variante K8s (em vez 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)

### baseado em k8s

Quer executar o vanilla no seu próprio k8s? Use os comandos abaixo:```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:** As dicas só podem ser geradas se a instância do WrongSecrets tiver dicas habilitadas (`HINTS_ENABLED=true`). A instância Heroku CTF ([https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)) executa com `HINTS_ENABLED=false`, então selecionar "Dicas gratuitas" ou "Dicas pagas" resultará em uma lista vazia de dicas. Para gerar dicas, execute sua própria instância com `HINTS_ENABLED=true`.

Agora visite a instância CTFD em [http://localhost:8001](http://localhost:8001) e configure seu CTF.
Em seguida, use a função de backup administrativo para importar o arquivo zip que você criou com o comando juice-shop-ctf.
Jogue em [https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)!
Quer configurar o seu próprio? Você pode! Mas cuidado para que outros não encontrem sua chave, então proteja-a adequadamente: certifique-se de que o contêiner em execução com a chave real do CTF não esteja exposto ao público, similar ao nosso contêiner Heroku.

## Suporte FBCTF (Experimental!)

NOTA: O suporte FBCTF é experimental.

Siga os mesmos passos que com CTFD, mas agora escolha fbctfd e como URL para o countrymapping escolha `https://raw.githubusercontent.com/OWASP/wrongsecrets/79a982558016c8ce70948a8106f9a2ee5b5b9eea/config/fbctf.yml`.
Em seguida, siga [https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide](https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide) para executar o FBCTF.

## Notas sobre desenvolvimento

Para desenvolvimento em máquina local use o perfil `local` `./mvnw spring-boot:run -Dspring-boot.run.profiles=local,without-vault`

Se você quiser testar contra o vault sem K8s: inicie o vault localmente com```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

Agora use o perfil `local-vault` para fazer seu desenvolvimento.```shell
./mvnw spring-boot:run -Dspring-boot.run.profiles=local,local-vault

Quer enviar um contêiner? Veja `.github/scripts/docker-create-and-push.sh` para um script que gera e envia todos os contêineres. Não se esqueça de reconstruir o aplicativo antes de compor o contêiner.

Quer verificar por que algo no vault não está funcionando no kubernetes? Execute `kubectl exec vault-0 -n vault -- vault audit enable file file_path=stdout`.

### Gerenciamento de dependências

Temos CycloneDX e OWASP Dependency-check integrados para verificar dependências em busca de vulnerabilidades.
Você pode usar o OWASP Dependency-checker chamando `mvn dependency-check:aggregate` e `mvn cyclonedx:makeBom` para usar o CycloneDX e criar um SBOM.

### Configuração do Plugin Dependency-Check Maven

OWASP WrongSecrets usa o plugin [`dependency-check-maven`](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) para escanear automaticamente as dependências do projeto em busca de vulnerabilidades conhecidas (CVEs).

#### Como Funciona

- O plugin é executado durante a compilação Maven (`./mvnw clean install`) e verifica todas as dependências em relação a bancos de dados públicos de vulnerabilidades.
- Por padrão, ele usa o NVD (National Vulnerability Database) e também pode usar o OSS Index para cobertura adicional.

#### Destaques da Configuração

O plugin é configurado em `pom.xml` na seção `<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>

Substitua `YOUR_OSSINDEX_USERNAME` e `YOUR_OSSINDEX_API_TOKEN` pelos detalhes da sua conta OSS Index.

#### Resolução de Problemas

- Se você vir erros `401 Unauthorized` para OSS Index, verifique suas credenciais ou desative o OSS Index definindo `<ossIndexAnalyzerEnabled>false</ossIndexAnalyzerEnabled>` em `pom.xml`.
- Você sempre pode executar a build sem o OSS Index se preferir apenas a varredura baseada em NVD.

#### Mais Informações

Consulte [Documentação do Plugin Maven Dependency-Check](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) para opções de configuração avançadas.

### Iniciar o projeto no IntelliJ IDEA

Requisitos: certifique-se de ter as seguintes ferramentas instaladas: [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. Faça um fork e clone o projeto conforme descrito na [documentação](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md).
2. Importe o projeto no IntelliJ (por exemplo, importar como projeto mvn / fontes locais)
3. Vá para as configurações do projeto e certifique-se de que ele usa Java25 (E que o JDK pode ser encontrado)
4. Vá para Configurações da IDE > Language & Frameworks > Lombok e certifique-se de que o processamento Lombok está habilitado
5. Abra a aba Maven no seu IDEA e execute "Reload All Maven Projects" para sincronizar o sistema e baixar tudo. Em seguida, na mesma aba use a opção "install" como parte do ciclo de vida do OWASP WrongSecrets para gerar o asciidoc e outros.
6. Agora execute o método `main` em `org.owasp.wrongsecrets.WrongSecretsApplication.java`. Isso deve falhar com um stack trace.
7. Agora vá para a configuração de execução do aplicativo e certifique-se de ter o perfil ativo `without-vault`. Isso é feito definindo os argumentos de opções da VM para `--server.port=8080 --spring.profiles.active=local,without-vault`. Defina `K8S_ENV=docker` como argumento de ambiente.
8. Repita o passo 6: execute o aplicativo novamente, você deve ter um aplicativo funcionando corretamente que pode ser visitado no seu navegador em http://localhost:8080.

**Guia Pictórico** sobre como iniciar o projeto no IntelliJ IDEA está disponível em [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-get-started-with-the-project-in-intellij-idea).

Sinta-se à vontade para editar e propor alterações via pull requests. Certifique-se de seguir nossas orientações na [documentação](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md) para que seu trabalho seja aceito.

Por favor, observe que oficialmente suportamos apenas Linux e MacOS para desenvolvimento. Se você quiser desenvolver usando uma máquina Windows, use WSL2 ou uma máquina virtual rodando Linux. Incluímos detecção do Windows e vários arquivos `exe` para um primeiro experimento, mas estamos procurando mantenedores ativos para eles. Quer garantir que funcione no Windows? Crie PRs ;-).

Se, após ler esta seção, você ainda não tem ideia sobre o código do aplicativo: Dê uma olhada [em alguns tutoriais sobre Spring boot do Baeldung](https://www.baeldung.com/spring-boot).

### Recarga automática durante o desenvolvimento

Para tornar as alterações carregadas mais rapidamente, adicionamos `spring-dev-tools` ao projeto Maven.

Para habilitar isso automaticamente no IntelliJ, certifique-se de:

-   Em Compiler -> Automatically build project está habilitado, e
-   Em Advanced settings -> Allow auto-make to start even if developed application is currently running.

Você também pode invocar manualmente: Build -> Recompile o arquivo que você acabou de alterar, isso também forçará a recarga do aplicativo.

### Como adicionar um Desafio

Siga os passos abaixo para adicionar um desafio:

1. Primeiro, certifique-se de que você tem uma [Issue](https://github.com/OWASP/wrongsecrets/issues) reportada para a qual um desafio é realmente desejado.
2. Adicione o novo desafio na pasta `org.owasp.wrongsecrets.challenges`. Certifique-se de adicionar uma explicação em `src/main/resources/explanations` e referencie-a a partir da sua nova classe Challenge.
3. Adicione testes de unidade, integração e UI conforme apropriado para mostrar que seu desafio está funcionando.
4. Não se esqueça de configurar o desafio em `src/main/resources/wrong-secrets-configuration.yaml`
5. Revise o [guia CONTRIBUTING](https://github.com/owasp/wrongsecrets/blob/master/CONTRIBUTING.md) para configurar seu ambiente de contribuição e escrever boas mensagens de commit.

Para mais detalhes, consulte [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-add-a-challenge).

Se você quiser mover desafios de nuvem existentes para outra nuvem: estenda as classes Challenge no pacote `org.owasp.wrongsecrets.challenges.cloud` e certifique-se de adicionar o Terraform necessário em uma pasta com a nuvem separada identificada. Certifique-se de que o ambiente seja adicionado a `org.owasp.wrongsecrets.RuntimeEnvironment`.
Colabore com os outros no projeto para colocar seu contêiner em execução para que você possa testar na conta da nuvem.

### Teste local

Se você fez algumas alterações no codebase ou adicionou um novo desafio e gostaria de ver exatamente como o contêiner ficará após o merge para teste, temos um script que torna isso muito fácil. Siga os passos abaixo:

1. Certifique-se de ter o bash instalado e aberto.
2. Navegue até .github/scripts.
3. Execute o script docker-create `bash docker-create.sh`.
   - Nota: Quer executar isso no seu minikube? então primeiro execute `eval $(minikube docker-env)`.
4. Siga quaisquer instruções fornecidas, você pode precisar instalar/alterar pacotes.
5. Execute o contêiner recém-criado:
  - para executar localmente: `docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:local-test-no-vault`
  - para executar no seu minikube: use o contêiner `jeroenwillemsen/wrongsecrets:local-test-k8s-vault` na sua definição de deployment.
  - para executar com Vault no seu minikube: use o contêiner `jeroenwillemsen/wrongsecrets:local-test-local-vault` na sua definição de deployment.

### Teste automatizado local

Atualmente temos 2 suítes de teste diferentes, ambas executadas com `./mvnw test`.
- Uma suíte de teste junit normal de testes de unidade e integração, localizada na pasta [`test/java`](https://github.com/owasp/wrongsecrets/blob/master/src/test/java) com saída armazenada no diretório target padrão.
- Uma suíte de teste cypress, integrada por meio de um teste junit, localizada na pasta [`test/e2e`](https://github.com/owasp/wrongsecrets/blob/master/src/test/e2e) com saída armazenada em [`target/test-classes/e2e/cypress/reports/`](https://github.com/owasp/wrongsecrets/blob/master/target/test-classes/e2e/cypress/reports). Consulte o [cypress readme](https://github.com/owasp/wrongsecrets/blob/master/src/test/e2e/cypress/README.md) para mais detalhes.

Nota: Você pode fazer um ciclo completo de limpeza, construção e teste com `./mvnw clean install`.

## 🔧 Resolução de Problemas

### Problemas Comuns

**Problemas com Docker:**
- **Porta já em uso**: Altere o mapeamento de porta: `docker run -p 8081:8080 -p 8091:8090 jeroenwillemsen/wrongsecrets:latest-no-vault`
- **Docker não encontrado**: Certifique-se de que o Docker está instalado e em execução
- **Permissão negada**: No Linux, você pode precisar adicionar seu usuário ao grupo docker

**Problemas com Navegador:**
- **Não é possível acessar localhost:8080**: Verifique se o contêiner Docker está em execução com `docker ps`
- **Desafios não carregam**: Limpe o cache do navegador ou tente o modo anônimo

**Problemas com Kubernetes:**
- **Minikube não inicia**: Tente `minikube delete` depois `minikube start`
- **Pods travados em pending**: Verifique os recursos com `kubectl describe pod <nome-do-pod>`

**Precisa de Ajuda?**
- Verifique nossas [Issues no GitHub](https://github.com/OWASP/wrongsecrets/issues)
- Junte-se a nós no [Slack da OWASP](https://owasp.slack.com/archives/C02KQ7D9XHR)
- Revise a seção [Suporte](#support)

## Quer jogar, mas não tem permissão para instalar as ferramentas?

Se você quer jogar os desafios, mas não pode instalar ferramentas como keepass, Radare, etc. Mas tem permissão para executar contêineres Docker, tente o seguinte:```shell
docker run -p 3000:3000 -v /var/run/docker.sock:/var/run/docker.sock jeroenwillemsen/wrongsecrets-desktop:latest

E então em [http://localhost:3000](http://localhost:3000).

Nota: tenha cuidado ao tentar implantar o contêiner `jeroenwillemsen/wrongsecrets-desktop` no Heroku ;-).

## Docker no macOS com M1 e Colima (Experimental!)

NOTA: Não oferecemos suporte oficial ao Colima, pois percebemos que os runners do Github têm muitos problemas com ele.

Se você não puder mudar para Docker Desktop/Podman e quiser usar Colima com Apple Silicon M1 para executar a imagem Docker `jeroenwillemsen/wrongsecrets`, tente uma das opções:

- desligar o Colima (`colima stop`)
- alterar o contexto Docker (`docker --context desktop-linux run -p 8080:8080 jeroenwillemsen/wrongsecrets:latest-no-vault`)
- executar Colima com 1 CPU (`colima start -m 8 -c 1 --arch x86_64`)

## Quer desabilitar desafios em sua própria versão?

Se você deseja executar o WrongSecrets mas sem determinados desafios que não quer apresentar a outros: leia esta seção.

*_NOTA_* Observe que não fornecemos nenhum suporte ao seu fork quando você segue o processo abaixo. Por favor, entenda que a licença e os direitos autorais do aplicativo original permanecem intactos para o seu Fork.

Requisitos:
- Ter o JDK do Java 25 instalado;
- Ter uma conta em um registro para o qual você possa enviar sua variante do contêiner WrongSecrets;

Aqui estão as etapas que você deve seguir para criar sua própria versão do WrongSecrets com determinados desafios desabilitados:
1. Faça um fork do repositório.
2. Em `src/main/resources/wrong-secrets-configuration.yaml` remova a referência ao desafio que você não deseja mais ter em seu fork.
3. Na raiz do projeto execute `./mvnw clean install`
4. Agora construa a imagem Docker para o destino de sua escolha:```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