feat: add challenge 76 with simulated RAG vector store secret leak

Author: bhushan4work

README.md

@@ -232,6 +232,7 @@ Now you can try to find the secrets by means of solving the challenge offered at
 -   [localhost:8080/challenge/challenge-71](http://localhost:8080/challenge/challenge-71)
 -   [localhost:8080/challenge/challenge-72](http://localhost:8080/challenge/challenge-72)
 -   [localhost:8080/challenge/challenge-73](http://localhost:8080/challenge/challenge-73)
+-   [localhost:8080/challenge/challenge-76](http://localhost:8080/challenge/challenge-76)
 </details>
 
 Note that these challenges are still very basic, and so are their explanations. Feel free to file a PR to make them look

src/main/java/org/owasp/wrongsecrets/challenges/docker/Challenge76.java

@@ -0,0 +1,60 @@
+package org.owasp.wrongsecrets.challenges.docker;
+
+import java.util.List;
+import java.util.Locale;
+import lombok.extern.slf4j.Slf4j;
+import org.owasp.wrongsecrets.challenges.FixedAnswerChallenge;
+import org.springframework.stereotype.Component;
+
+/**
+ * Challenge about a retrieval augmented generation (RAG) vector store that indexed development
+ * documents containing a synthetic secret. The simulated vector store exposes its indexed text
+ * chunks through an unauthenticated search endpoint, exactly like a misconfigured vector database
+ * that is reachable without authentication.
+ */
+@Slf4j
+@Component
+public class Challenge76 extends FixedAnswerChallenge {
+
+  static final String DEVELOPMENT_SECRET = "vector-store-dev-secret-e5c91a7b";
+
+  private static final List<IndexedChunk> INDEXED_CHUNKS =
+      List.of(
+          new IndexedChunk(
+              "chunk-0",
+              "Onboarding guide: the staging environment is reset every night at 02:00 UTC."),
+          new IndexedChunk(
+              "chunk-1",
+              "Runbook: restart the ingestion worker with `kubectl rollout restart"
+                  + " deployment/ingestion`."),
+          new IndexedChunk(
+              "chunk-2",
+              "Draft API note: the development vector store uses the credential "
+                  + DEVELOPMENT_SECRET
+                  + " for the nightly embedding job. Rotate before production."),
+          new IndexedChunk(
+              "chunk-3", "Meeting notes: evaluation set v3 improved recall from 0.71 to 0.78."));
+
+  /** A single text chunk as it is stored in the simulated vector store. */
+  public record IndexedChunk(String id, String text) {}
+
+  @Override
+  public String getAnswer() {
+    return DEVELOPMENT_SECRET;
+  }
+
+  /**
+   * Simulates a similarity search against the in-app vector store: every indexed chunk whose text
+   * contains the query (case-insensitive) is returned, including the chunk that leaks the
+   * development secret.
+   */
+  public List<IndexedChunk> search(String query) {
+    if (query == null || query.isBlank()) {
+      return INDEXED_CHUNKS;
+    }
+    var normalizedQuery = query.toLowerCase(Locale.ROOT);
+    return INDEXED_CHUNKS.stream()
+        .filter(chunk -> chunk.text().toLowerCase(Locale.ROOT).contains(normalizedQuery))
+        .toList();
+  }
+}

src/main/java/org/owasp/wrongsecrets/challenges/docker/Challenge76Controller.java

@@ -0,0 +1,29 @@
+package org.owasp.wrongsecrets.challenges.docker;
+
+import java.util.List;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.RestController;
+
+/** REST controller for Challenge 76 exposing the simulated RAG vector store search. */
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+public class Challenge76Controller {
+
+  private final Challenge76 challenge;
+
+  /**
+   * Unauthenticated search endpoint of the simulated vector store. It returns the indexed text
+   * chunks that match the query, leaking the development secret that was indexed along with the
+   * other documents.
+   */
+  @GetMapping("/rag/search")
+  public List<Challenge76.IndexedChunk> search(
+      @RequestParam(value = "q", required = false) String query) {
+    log.info("Searching the simulated vector store for Challenge 76...");
+    return challenge.search(query);
+  }
+}

src/main/resources/explanations/challenge76.adoc

@@ -0,0 +1,28 @@
+=== Challenge 76: Find the Secret Indexed in the RAG Vector Store
+
+Retrieval augmented generation (RAG) pipelines answer questions by first looking
+up relevant passages in a vector store and then feeding those passages to a large
+language model. To build that store, documents are split into chunks, turned into
+embeddings and indexed. The chunks themselves stay readable: a search endpoint
+returns the original text of every chunk it considers relevant.
+
+That is exactly what went wrong in this challenge. A development team indexed its
+runbooks, meeting notes and draft API documentation into a vector store that is
+reachable from the application without any authentication:
+
+`GET /rag/search`
+
+The endpoint takes an optional query parameter `q` and returns the indexed text
+chunks that contain it. Without a query it returns every indexed chunk. One of the
+chunks was indexed while it still contained a draft note with the credential of
+the nightly embedding job.
+
+Browse the indexed chunks through the endpoint and submit the credential you find
+in them.
+
+[NOTE]
+====
+The vector store, the endpoint and every credential in this challenge are
+simulated and fictional. Nothing is sent over the network: the application only
+searches its own in-memory index.
+====

src/main/resources/explanations/challenge76_de.adoc

@@ -0,0 +1,30 @@
+=== Challenge 76: Finde das Geheimnis im RAG-Vektorstore
+
+Retrieval-Augmented-Generation-(RAG)-Pipelines beantworten Fragen, indem sie zuerst
+relevante Passagen in einem Vektorstore nachschlagen und diese Passagen dann an ein
+großes Sprachmodell übergeben. Um diesen Store aufzubauen, werden Dokumente in
+Chunks zerlegt, in Embeddings umgewandelt und indiziert. Die Chunks selbst bleiben
+lesbar: Ein Suchendpoint gibt den Originaltext jedes Chunks zurück, der als relevant
+gilt.
+
+Genau das ist in dieser Challenge schiefgegangen. Ein Entwicklungsteam hat seine
+Runbooks, Meeting-Notizen und API-Entwurfsdokumentation in einem Vektorstore
+indiziert, der aus der Anwendung heraus ohne jegliche Authentifizierung erreichbar
+ist:
+
+`GET /rag/search`
+
+Der Endpoint akzeptiert einen optionalen Query-Parameter `q` und gibt die
+indizierten Textchunks zurück, die ihn enthalten. Ohne Query gibt er jeden
+indizierten Chunk zurück. Einer der Chunks wurde indiziert, als er noch eine
+Entwurfsnotiz mit dem Zugangscredential des nächtlichen Embedding-Jobs enthielt.
+
+Durchsuche die indizierten Chunks über den Endpoint und reiche das darin gefundene
+Zugangscredential ein.
+
+[NOTE]
+====
+Der Vektorstore, der Endpoint und jedes Zugangscredential in dieser Challenge sind
+simuliert und fiktiv. Nichts wird über das Netzwerk gesendet: Die Anwendung
+durchsucht nur ihren eigenen Index im Speicher.
+====

src/main/resources/explanations/challenge76_es.adoc

@@ -0,0 +1,29 @@
+=== Desafío 76: Encuentra el secreto indexado en el almacén vectorial RAG
+
+Los pipelines de generación aumentada por recuperación (RAG) responden preguntas
+buscando primero los pasajes relevantes en un almacén vectorial y alimentando
+después esos pasajes a un gran modelo de lenguaje. Para construir ese almacén, los
+documentos se dividen en fragmentos, se convierten en embeddings y se indexan. Los
+fragmentos en sí siguen siendo legibles: un endpoint de búsqueda devuelve el texto
+original de cada fragmento que considera relevante.
+
+Exactamente eso es lo que salió mal en este desafío. Un equipo de desarrollo indexó
+sus runbooks, notas de reuniones y documentación de API en borrador en un almacén
+vectorial que es accesible desde la aplicación sin ninguna autenticación:
+
+`GET /rag/search`
+
+El endpoint acepta un parámetro de consulta opcional `q` y devuelve los fragmentos
+de texto indexados que lo contienen. Sin una consulta devuelve todos los fragmentos
+indexados. Uno de los fragmentos fue indexado mientras aún contenía una nota en
+borrador con la credencial del trabajo nocturno de embeddings.
+
+Recorre los fragmentos indexados a través del endpoint y envía la credencial que
+encuentres en ellos.
+
+[NOTE]
+====
+El almacén vectorial, el endpoint y todas las credenciales de este desafío son
+simulados y ficticios. No se envía nada por la red: la aplicación solo busca en su
+propio índice en memoria.
+====

src/main/resources/explanations/challenge76_fr.adoc

@@ -0,0 +1,30 @@
+=== Challenge 76 : Trouvez le secret indexé dans le magasin vectoriel RAG
+
+Les pipelines de génération augmentée par récupération (RAG) répondent aux
+questions en recherchant d'abord les passages pertinents dans un magasin vectoriel,
+puis en alimentant ces passages avec un grand modèle de langage. Pour construire ce
+magasin, les documents sont découpés en fragments, convertis en embeddings et
+indexés. Les fragments eux-mêmes restent lisibles : un point d'accès de recherche
+renvoie le texte original de chaque fragment jugé pertinent.
+
+C'est exactement ce qui s'est mal passé dans ce challenge. Une équipe de
+développement a indexé ses runbooks, comptes rendus de réunion et documentation API
+de brouillon dans un magasin vectoriel accessible depuis l'application sans aucune
+authentification :
+
+`GET /rag/search`
+
+Le point d'accès accepte un paramètre de requête optionnel `q` et renvoie les
+fragments de texte indexés qui le contiennent. Sans requête, il renvoie tous les
+fragments indexés. L'un des fragments a été indexé alors qu'il contenait encore une
+note de brouillon avec l'identifiant du travail d'embedding nocturne.
+
+Parcourez les fragments indexés via le point d'accès et soumettez l'identifiant que
+vous y trouvez.
+
+[NOTE]
+====
+Le magasin vectoriel, le point d'accès et tous les identifiants de ce challenge
+sont simulés et fictifs. Rien n'est envoyé sur le réseau : l'application ne fait
+que chercher dans son propre index en mémoire.
+====

src/main/resources/explanations/challenge76_hint.adoc

@@ -0,0 +1,14 @@
+You can solve this challenge using the following steps:
+
+1. Open the unauthenticated search endpoint of the simulated vector store:
+- `http://localhost:8080/rag/search`
+- It returns all four indexed text chunks as JSON.
+
+2. Read the chunks and look for the one that mentions a credential:
+- The chunk with the "Draft API note" contains the credential of the nightly
+  embedding job.
+
+3. Submit that credential (everything after "uses the credential ") as the answer.
+
+You can also narrow the search, for example with `q=credential`, but the secret is
+only exposed because the chunk was indexed before the draft note was scrubbed.

src/main/resources/explanations/challenge76_hint_de.adoc

@@ -0,0 +1,16 @@
+Du kannst diese Challenge mit den folgenden Schritten lösen:
+
+1. Öffne den unauthentifizierten Suchendpoint des simulierten Vektorstores:
+- `http://localhost:8080/rag/search`
+- Er gibt alle vier indizierten Textchunks als JSON zurück.
+
+2. Lies die Chunks und suche nach demjenigen, der ein Zugangscredential erwähnt:
+- Der Chunk mit der "Draft API note" enthält das Zugangscredential des nächtlichen
+  Embedding-Jobs.
+
+3. Reiche dieses Zugangscredential als Antwort ein (alles nach
+  "uses the credential ").
+
+Du kannst die Suche auch eingrenzen, zum Beispiel mit `q=credential`, aber das
+Geheimnis liegt nur offen, weil der Chunk indiziert wurde, bevor die Entwurfsnotiz
+bereinigt wurde.

src/main/resources/explanations/challenge76_hint_es.adoc

@@ -0,0 +1,16 @@
+Puedes resolver este desafío con los siguientes pasos:
+
+1. Abre el endpoint de búsqueda sin autenticación del almacén vectorial simulado:
+- `http://localhost:8080/rag/search`
+- Devuelve los cuatro fragmentos de texto indexados como JSON.
+
+2. Lee los fragmentos y busca el que menciona una credencial:
+- El fragmento con la "Draft API note" contiene la credencial del trabajo nocturno
+  de embeddings.
+
+3. Envía esa credencial como respuesta (todo lo que hay después de
+  "uses the credential ").
+
+También puedes acotar la búsqueda, por ejemplo con `q=credential`, pero el secreto
+solo queda expuesto porque el fragmento fue indexado antes de que la nota en
+borrador se limpiara.