⚠️ *Nota: Questa è una versione di sviluppo e potrebbe essere instabile*
4. **Configurazione Avanzata**: Per le sfide cloud e gli esercizi Kubernetes, consulta le istruzioni dettagliate qui sotto

**Cosa imparerai:**
- Errori comuni nella gestione dei segreti
- Come identificare le credenziali esposte
- Migliori pratiche per la protezione dei segreti
- Strumenti e tecniche per il rilevamento dei segreti

**Come funziona:**
Questo repository contiene **codice e file di configurazione intenzionalmente vulnerabili** con segreti reali e fittizi nascosti in tutto il codice. Esaminerai codice sorgente, file di configurazione, container Docker e deployment cloud per scoprire questi segreti. Ogni sfida ti insegna diversi modi in cui i segreti possono essere accidentalmente esposti in applicazioni reali.

![screenshot della sfida 1](https://assets.kitploit.com/production/public/readmes/6937/ad02ece4104616d09ac232d1423d84111048b3437c4439ebf44172a60c673546.png)

## 📋 Prerequisiti

**Per uso base:**
- Un browser web
- Docker (per configurazione locale) - [Installa qui](https://docs.docker.com/get-docker/)

**Per configurazioni avanzate:**
- Kubernetes/Minikube - [Installa qui](https://minikube.sigs.k8s.io/docs/start/)
- Account cloud (AWS/GCP/Azure) per le sfide cloud
- Familiarità con la riga di 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>

## Indice dei contenuti

### 🎯 Per Iniziare
-   [Avvio Rapido](#-quick-start)
-   [Prerequisiti](#-prerequisites)
-   [Supporto](#support)

### 🐳 Opzioni di Deployment
-   [Esercizi docker base](#basic-docker-exercises)
 -   [Eseguirli su Heroku](#running-these-on-heroku)
 -   [Eseguirli su Render.io](#running-these-on-renderio)
 -   [Eseguirli su Railway](#running-these-on-railway)
-   [Esercizio K8s base](#basic-k8s-exercise)
 -   [Basato su Minikube](#minikube-based)
 -   [Basato su k8s](#k8s-based)
 -   [Esercizi Vault con minikube](#vault-exercises-with-minikube)

### ☁️ Sfide Cloud
-   [Sfide Cloud](#cloud-challenges)
 -   [Eseguire WrongSecrets su AWS](#running-wrongsecrets-in-aws)
 -   [Eseguire WrongSecrets su GCP](#running-wrongsecrets-in-gcp)
 -   [Eseguire WrongSecrets su Azure](#running-wrongsecrets-in-azure)
 -   [Eseguire Challenge15 solo nel tuo cloud](#running-challenge15-in-your-own-cloud-only)

### 🎮 Uso Avanzato
-   [Vuoi giocare senza aiuto?](#do-you-want-to-play-without-guidance-or-spoils)
-   [CTF](#ctf)
 -   [Supporto CTFD](#ctfd-support)
 -   [Supporto FBCTF](#fbctf-support-experimental)
-   [Usa OWASP WrongSecrets come benchmark per il rilevamento di segreti](#use-owasp-wrongsecrets-as-a-secret-detection-benchmark)

### 👨‍💻 Sviluppo e Contributi
-   [Note sullo sviluppo](#notes-on-development)
-   [Checklist di adozione Spring Boot 4](https://github.com/owasp/wrongsecrets/blob/HEAD/docs/SPRING_BOOT_4_ADOPTION_CHECKLIST.md)
 -   [Gestione dipendenze](#dependency-management)
 -   [Avviare il progetto in IntelliJ IDEA](#get-the-project-started-in-intellij-idea)
 -   [Ricaricamento automatico durante lo sviluppo](#automatic-reload-during-development)
 -   [Come aggiungere una Sfida](#how-to-add-a-challenge)
 -   [Test locale](#local-testing)
 -   [Test automatico locale](#Local-automated-testing)
-   [Vuoi disabilitare sfide nella tua release?](#want-to-disable-challenges-in-your-own-release)

### 📚 Risorse e Community
-   [Ringraziamenti speciali e Contributori](#special-thanks--contributors)
-   [Sponsorizzazioni](#sponsorships)
-   [Aiuto Richiesto](#help-wanted)
-   [Letture consigliate sulla gestione dei segreti](#further-reading-on-secrets-management)

## Supporto

Hai bisogno di supporto? Contattaci tramite [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR) per il quale ti registri [qui](https://owasp.org/slack/invite), apri una [PR](https://github.com/OWASP/wrongsecrets/pulls), segnala un [problema](https://github.com/OWASP/wrongsecrets/issues) o usa le [discussioni](https://github.com/OWASP/wrongsecrets/discussions). Nota che questo è un progetto basato su volontari OWASP, quindi potrebbe volerci un po' prima di ricevere una risposta.

Copyright (c) 2020-2025 Jeroen Willemsen e contributori di WrongSecrets.

## 🛤️ Scegli il tuo Percorso

Non sei sicuro di quale configurazione sia giusta per te? Ecco una guida rapida:

| **Voglio...** | **Configurazione Raccomandata** | **Sfide Disponibili** |
|------------------|----------------------|--------------------------|
| Provarlo rapidamente online | [Container in esecuzione su Heroku](https://www.wrongsecrets.com/) | Sfide base (0-4, 8, 12-32, 34-43, 49-52, 54-66) |
| Eseguire localmente con Docker | [Docker Base](#basic-docker-exercises) | Come sopra, ma sulla tua macchina |
| Imparare i segreti di Kubernetes | [Configurazione K8s/Minikube](#basic-k8s-exercise) | Sfide Kubernetes (0-6, 8, 12-43, 48-66) |
| Praticare con segreti cloud | [Sfide Cloud](#cloud-challenges) | Tutte le sfide (0-66) |
| Organizzare un workshop/CTF | [Configurazione CTF](#ctf) | Set di sfide personalizzabili |
| Contribuire al progetto | [Configurazione Sviluppo](#notes-on-development) | Tutte le sfide + strumenti di sviluppo |

## Esercizi docker base

_Possono essere usati per le sfide 0-4, 8, 12-32, 34-43, 49-52, 54-66_

Per gli esercizi docker base attualmente hai bisogno di:

-   Docker [Installa da qui](https://docs.docker.com/get-docker/)
-   Un browser in grado di renderizzare HTML

Puoi installarlo eseguendo:```bash
docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:latest-no-vault

⚠️ **Avviso**: Questa è una versione di sviluppo costruita dall'ultimo ramo master e potrebbe contenere funzionalità sperimentali o instabilità.

**📝 Nota sulle porte:**
- Porta **8080**: Applicazione principale (challenge 0-66)
- Porta **8090**: Server MCP (richiesto per Challenge 60)

**📝 Nota sul Challenge 62 (Google Drive MCP):**
Il Challenge 62 richiede che un account di servizio Google sia configurato per la piena funzionalità. Vedi [docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md](https://github.com/owasp/wrongsecrets/blob/HEAD/docs/CHALLENGE62_GOOGLE_DRIVE_SETUP.md) per le istruzioni di configurazione. Senza configurazione, il challenge mostrerà un messaggio placeholder.

Ora puoi provare a trovare i segreti risolvendo i challenge offerti ai link seguenti
<details>
    <summary>tutti i link per i challenge docker (clicca sul triangolo per aprire il blocco).
    </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>

Nota che questi challenge sono ancora molto basilari, così come le loro spiegazioni. Sentiti libero di aprire una PR per migliorarli ;-).

### Eseguirli su Heroku

Puoi provarli anche su [https://wrongsecrets.herokuapp.com/](https://wrongsecrets.herokuapp.com/)! Le persone di Heroku ci hanno dato un fantastico pacchetto di supporto open source, che ci permette di eseguire l'app gratuitamente lì, dove è quasi sempre attiva. Tuttavia, per favore non fare fuzzing e/o cercare di mandarla giù: rovineresti l'esperienza per altri che vogliono provarla.
Usa [questo link](https://wrongsecrets.herokuapp.com/) per utilizzare la nostra versione hostata. Se vuoi ospitarla tu stesso su Heroku (ad esempio per eseguire un training), puoi farlo cliccando [questo link](https://heroku.com/deploy?template=https://github.com/OWASP/wrongsecrets/tree/master). Tieni presente che ciò comporterà dei costi per i quali questo progetto e/o i suoi manutentori non possono essere ritenuti responsabili.

### Eseguirli su Render.io
*stato: sperimentale*

Puoi provarli su [https://wrongsecrets.onrender.com/](https://wrongsecrets.onrender.com/). Tieni presente che eseguiamo su un'istanza gratuita, non possiamo fornire garanzie. Per favore non fare fuzzing e/o cercare di mandarla giù: rovineresti l'esperienza per altri che vogliono provarla.
Vuoi distribuire tu stesso su Render? Clicca il pulsante qui sotto:

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


### Eseguirli su Railway
*stato: mantenuto da [alphasec.io](https://github.com/alphasecio)*

Se vuoi ospitare WrongSecrets su Railway, puoi farlo distribuendo [questo template con un clic](https://railway.com/deploy/McqJ_j?referralCode=I07F1). Railway non offre più un piano sempre gratuito, ma la prova gratuita è sufficiente per provare questo prima di decidere di aggiornare. Se hai bisogno di una guida passo passo, vedi [questo post sul blog](https://alphasec.io/test-your-secret-management-skills-with-owasp-wrongsecrets/).

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

## Esercizio base K8s

_Può essere usato per i challenge 0-6, 8, 12-43, 48-66_

### Basato su Minikube

Assicurati di avere installato quanto segue:

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

La configurazione K8S attualmente si basa sull'uso di Minikube per divertimento locale. Puoi usare i comandi seguenti dalla radice del progetto:```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

ora puoi utilizzare l'indirizzo IP e la porta forniti per giocare ulteriormente con la variante K8s (invece di 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)

### basato su k8s

Vuoi eseguire vanilla sul tuo k8s? Usa i comandi seguenti:```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:** Gli indizi possono essere generati solo se l'istanza di WrongSecrets ha gli indizi abilitati (`HINTS_ENABLED=true`). L'istanza CTF di Heroku ([https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)) esegue con `HINTS_ENABLED=false`, quindi selezionando "Free hints" o "Paid hints" si otterrà una lista di indizi vuota. Per generare indizi, esegui la tua istanza con `HINTS_ENABLED=true`.

Ora visita l'istanza CTFD all'indirizzo [http://localhost:8001](http://localhost:8001) e configura il tuo CTF.
Quindi usa la funzione di backup amministrativo per importare il file zip che hai creato con il comando juice-shop-ctf.
Gioca usando [https://wrongsecrets-ctf.herokuapp.com](https://wrongsecrets-ctf.herokuapp.com)!
Vuoi configurarne uno tuo? Puoi! Tuttavia fai attenzione che qualcuno trovi la tua chiave, quindi proteggila adeguatamente: assicurati che il contenitore in esecuzione con la vera chiave CTF non sia esposto al pubblico, simile al nostro contenitore Heroku.

## Supporto FBCTF (Sperimentale!)

NOTA: Il supporto FBCTF è sperimentale.

Segui gli stessi passaggi di CTFD, solo che ora scegli fbctfd e come URL per il countrymapping scegli `https://raw.githubusercontent.com/OWASP/wrongsecrets/79a982558016c8ce70948a8106f9a2ee5b5b9eea/config/fbctf.yml`.
Poi segui [https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide](https://github.com/facebookarchive/fbctf/wiki/Quick-Setup-Guide) per eseguire FBCTF.

## Note sullo sviluppo

Per lo sviluppo su macchina locale usa il profilo `local` `./mvnw spring-boot:run -Dspring-boot.run.profiles=local,without-vault`

Se vuoi testare con vault senza K8s: avvia 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

Ora usa il profilo `local-vault` per fare il tuo sviluppo.```shell
./mvnw spring-boot:run -Dspring-boot.run.profiles=local,local-vault

Vuoi caricare un container? Consulta `.github/scripts/docker-create-and-push.sh` per uno script che genera e carica tutti i container. Non dimenticare di ricostruire l'app prima di comporre il container.

Vuoi verificare perché qualcosa in vault non funziona in Kubernetes? Esegui `kubectl exec vault-0 -n vault -- vault audit enable file file_path=stdout`.

### Gestione delle dipendenze

Abbiamo integrato CycloneDX e OWASP Dependency-check per controllare le dipendenze alla ricerca di vulnerabilità.
Puoi utilizzare OWASP Dependency-checker chiamando `mvn dependency-check:aggregate` e `mvn cyclonedx:makeBom` per usare CycloneDX e creare un SBOM.

### Configurazione del Plugin Maven Dependency-Check

OWASP WrongSecrets utilizza il plugin [`dependency-check-maven`](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) per scansionare automaticamente le dipendenze del progetto alla ricerca di vulnerabilità note (CVE).

#### Come Funziona

- Il plugin viene eseguito durante la build Maven (`./mvnw clean install`) e controlla tutte le dipendenze confrontandole con database pubblici di vulnerabilità.
- Di default, utilizza l'NVD (National Vulnerability Database) e può anche usare OSS Index per una copertura aggiuntiva.

#### Punti Salienti della Configurazione

Il plugin è configurato in `pom.xml` sotto la sezione `<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>

Sostituisci `YOUR_OSSINDEX_USERNAME` e `YOUR_OSSINDEX_API_TOKEN` con i tuoi dati dell'account OSS Index.

#### Risoluzione dei problemi

- Se vedi errori `401 Unauthorized` per OSS Index, verifica le tue credenziali o disabilita OSS Index impostando `<ossIndexAnalyzerEnabled>false</ossIndexAnalyzerEnabled>` in `pom.xml`.
- Puoi sempre eseguire la build senza OSS Index se preferisci solo la scansione basata su NVD.

#### Maggiori informazioni

Consulta la [Documentazione del Plugin Maven Dependency-Check](https://jeremylong.github.io/DependencyCheck/dependency-check-maven/index.html) per opzioni di configurazione avanzate.

### Avvia il progetto in IntelliJ IDEA

Prerequisiti: assicurati di avere installati i seguenti strumenti: [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. Fai il fork e clona il progetto come descritto nella [documentazione](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md).
2. Importa il progetto in IntelliJ (es. importa come progetto mvn / sorgenti locali)
3. Vai nelle impostazioni del progetto e assicurati che utilizzi Java25 (e che il JDK sia trovabile)
4. Vai in Impostazioni IDE > Language & Frameworks > Lombok e assicurati che l'elaborazione di Lombok sia abilitata
5. Apri la scheda Maven nella tua IDEA ed esegui "Reload All Maven Projects" per sincronizzare il sistema e scaricare tutto. Successivamente, nella stessa scheda, usa l'opzione "install" come parte del Lifecycle di OWASP WrongSecrets per generare asciidoc e simili.
6. Ora esegui il metodo `main` in `org.owasp.wrongsecrets.WrongSecretsApplication.java`. Dovrebbe fallire con uno stack trace.
7. Ora vai nella configurazione di esecuzione dell'app e assicurati di avere il profilo attivo `without-vault`. Questo si fa impostando gli argomenti delle opzioni VM su `--server.port=8080 --spring.profiles.active=local,without-vault`. Imposta `K8S_ENV=docker` come argomento di ambiente.
8. Ripeti il passaggio 6: esegui di nuovo l'app, dovresti avere un'applicazione funzionante correttamente e visitabile nel browser all'indirizzo http://localhost:8080.

**Guida illustrata** su come avviare il progetto in IntelliJ IDEA è disponibile su [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-get-started-with-the-project-in-intellij-idea).

Sentiti libero di modificare e proporre modifiche tramite pull request. Segui le nostre indicazioni nella [documentazione](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md) per far accettare il tuo lavoro.

Nota che supportiamo ufficialmente solo Linux e MacOS per lo sviluppo. Se vuoi sviluppare usando una macchina Windows, utilizza WSL2 o una macchina virtuale con Linux. Abbiamo incluso il rilevamento di Windows e alcuni file `.exe` per un primo esperimento, ma cerchiamo mantenitori attivi per essi. Vuoi assicurarti che funzioni su Windows? Crea PR ;-).

Se, dopo aver letto questa sezione, non hai ancora idea del codice dell'applicazione: Dai un'occhiata [ad alcuni tutorial su Spring Boot da Baeldung](https://www.baeldung.com/spring-boot).

### Ricarica automatica durante lo sviluppo

Per velocizzare il caricamento delle modifiche, abbiamo aggiunto `spring-dev-tools` al progetto Maven.
Per abilitarlo automaticamente in IntelliJ, assicurati che:

-   In Compiler -> Build automaticamente il progetto sia abilitato, e
-   In Impostazioni avanzate -> Consenti avvio automatico anche se l'applicazione in sviluppo è in esecuzione.

Puoi anche invocare manualmente: Build -> Ricompila il file appena modificato, questo forzerà anche la ricarica dell'applicazione.

### Come aggiungere una challenge

Segui i passaggi seguenti per aggiungere una challenge:

1. Prima assicurati di avere una [Issue](https://github.com/OWASP/wrongsecrets/issues) segnalata per la quale una challenge è realmente desiderata.
2. Aggiungi la nuova challenge nella cartella `org.owasp.wrongsecrets.challenges`. Assicurati di aggiungere una spiegazione in `src/main/resources/explanations` e di farvi riferimento dalla tua nuova classe Challenge.
3. Aggiungi test unitari, di integrazione e UI appropriati per dimostrare che la tua challenge funziona.
4. Non dimenticare di configurare la challenge in `src/main/resources/wrong-secrets-configuration.yaml`
5. Rivedi la [guida CONTRIBUTING](https://github.com/owasp/wrongsecrets/blob/HEAD/CONTRIBUTING.md) per configurare il tuo ambiente di contribuzione e scrivere buoni messaggi di commit.

Per maggiori dettagli, consulta [_Contributing.md_](https://github.com/OWASP/wrongsecrets/blob/master/CONTRIBUTING.md#how-to-add-a-challenge).

Se vuoi spostare challenge cloud esistenti su un altro cloud: estendi le classi Challenge nel pacchetto `org.owasp.wrongsecrets.challenges.cloud` e assicurati di aggiungere il Terraform richiesto in una cartella con il cloud specifico identificato. Assicurati che l'ambiente sia aggiunto a `org.owasp.wrongsecrets.RuntimeEnvironment`.
Collabora con gli altri nel progetto per far funzionare il tuo container in modo da poter testare sull'account cloud.

### Test locale

Se hai apportato alcune modifiche al codebase o aggiunto una nuova challenge e desideri vedere esattamente come sarà il container dopo il merge per il test, abbiamo uno script che rende tutto molto semplice. Segui i passaggi seguenti:

1. Assicurati di avere bash installato e aperto.
2. Naviga in .github/scripts.
3. Esegui lo script docker-create: `bash docker-create.sh`.
   - Nota: Vuoi eseguirlo sul tuo minikube? Allora prima esegui `eval $(minikube docker-env)`.
4. Segui le eventuali istruzioni fornite; potresti dover installare/modificare pacchetti.
5. Esegui il container appena creato:
  - per esecuzione locale: `docker run -p 8080:8080 -p 8090:8090 jeroenwillemsen/wrongsecrets:local-test-no-vault`
  - per esecuzione su minikube: usa il container `jeroenwillemsen/wrongsecrets:local-test-k8s-vault` nella definizione del deployment.
  - per esecuzione con Vault su minikube: usa il container `jeroenwillemsen/wrongsecrets:local-test-local-vault` nella definizione del deployment.

### Test automatico locale

Attualmente abbiamo 2 suite di test diverse, entrambe lanciate con `./mvnw test`.
- Una normale suite di test junit di unit e integration test, situata nella cartella [`test/java`](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/java) con output salvato nella directory target predefinita.
- Una suite di test cypress, integrata tramite un test junit, situata nella cartella [`test/e2e`](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/e2e) con output salvato in [`target/test-classes/e2e/cypress/reports/`](https://github.com/owasp/wrongsecrets/blob/HEAD/target/test-classes/e2e/cypress/reports/). Vedi il [readme di cypress](https://github.com/owasp/wrongsecrets/blob/HEAD/src/test/e2e/cypress/README.md) per maggiori dettagli.

Nota: Puoi fare un roundtrip completo di pulizia, build e test con `./mvnw clean install`.

## 🔧 Risoluzione dei problemi

### Problemi comuni

**Problemi Docker:**
- **Porta già in uso**: Cambia il mapping delle porte: `docker run -p 8081:8080 -p 8091:8090 jeroenwillemsen/wrongsecrets:latest-no-vault`
- **Docker non trovato**: Assicurati che Docker sia installato e in esecuzione
- **Permesso negato**: Su Linux, potresti dover aggiungere il tuo utente al gruppo docker

**Problemi browser:**
- **Impossibile accedere a localhost:8080**: Controlla se il container Docker è in esecuzione con `docker ps`
- **Le challenge non si caricano**: Pulisci la cache del browser o prova la modalità incognito

**Problemi Kubernetes:**
- **Minikube non si avvia**: Prova `minikube delete` poi `minikube start`
- **Pod bloccati in pending**: Controlla le risorse con `kubectl describe pod <nome-pod>`

**Hai bisogno di aiuto?**
- Controlla le nostre [GitHub Issues](https://github.com/OWASP/wrongsecrets/issues)
- Unisciti a noi su [OWASP Slack](https://owasp.slack.com/archives/C02KQ7D9XHR)
- Rivedi la sezione [Supporto](#support)

## Vuoi giocare, ma non ti è permesso installare gli strumenti?

Se vuoi giocare alle challenge ma non puoi installare strumenti come keepass, Radare, ecc. ma ti è consentito eseguire container Docker, prova quanto segue:```shell
docker run -p 3000:3000 -v /var/run/docker.sock:/var/run/docker.sock jeroenwillemsen/wrongsecrets-desktop:latest

E poi su [http://localhost:3000](http://localhost:3000).

Nota: fai attenzione a quando provi a distribuire il container `jeroenwillemsen/wrongsecrets-desktop` su Heroku ;-).

## Docker su macOS con M1 e Colima (Sperimentale!)

NOTA: non supportiamo ufficialmente Colima, poiché possiamo constatare che i runner di GitHub hanno molti problemi con esso.

Se non puoi passare a Docker Desktop/Podman e vuoi usare Colima con Apple Silicon M1 per eseguire l'immagine Docker `jeroenwillemsen/wrongsecrets`, prova una delle seguenti:

- spegnere Colima (`colima stop`)
- cambiare il contesto Docker (`docker --context desktop-linux run -p 8080:8080 jeroenwillemsen/wrongsecrets:latest-no-vault`)
- eseguire Colima con 1 CPU (`colima start -m 8 -c 1 --arch x86_64`)

## Vuoi disabilitare le sfide nella tua release?

Se vuoi eseguire WrongSecrets ma senza alcune sfide che non vuoi presentare ad altri: leggi questa sezione.

*_NOTA_* Ti informiamo che non forniamo alcun supporto al tuo fork quando segui la procedura qui sotto. Comprendi che la licenza e il copyright dell'applicazione originale rimangono intatti per il tuo Fork.

Requisiti:
- Avere installato il JDK di Java 25;
- Avere un account su un registro a cui puoi inviare la tua variante del container WrongSecrets;

Ecco i passaggi che devi seguire per creare la tua release di WrongSecrets con alcune sfide disabilitate:
1. Forka il repository.
2. In `src/main/resources/wrong-secrets-configuration.yaml` rimuovi il riferimento alla sfida che non vuoi più avere nel tuo fork.
3. Nella radice del progetto esegui `./mvnw clean install`
4. Ora costruisci l'immagine Docker per la tua destinazione preferita:```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