Fissuredocumentation v5.3.1
On this page

Vulnerable target lab: integration plan

Status: Phase 0 BUILT (the generic target contract, the generic runner lab/run-target.sh, and the scoring harness lab/score.py are in, with DVWA ported onto them and driven through the generic runner with no behaviour change; see section 5). Phases 1-3 are DONE: Juice Shop, Mutillidae, bWAPP, OWASP Benchmark, VAmPI, crAPI, DVGA, DVWS and WebGoat each run from their own lab/<id>/ directory. Phase 4 (the Vulhub CVE regression runner, lab/vulhub/) is BEGUN, and Phase 5 (the heavy infra/AD/K8s targets) is not started. Remaining work is tracked in TODO.md. This doc is the design and rollout plan; start new work from the rollout table in section 5.

Context: Fissure already ships two local labs, DVWA (lab/dvwa/, 12_DVWA_LAB.md) and an LFI-to-RCE lab (lab/lfi/), plus the agent-driven fissure_bug_bounty skill. This plan adds more deliberately vulnerable targets in the same shape so the scanner, checks, reporting and the skill can be regression-tested and scored against a broad, labelled corpus: setup -> health check -> reset -> test -> expected findings -> teardown.

Scope: everything runs locally (Docker, Docker Compose or Vagrant). Nothing here is ever exposed beyond 127.0.0.1 or an isolated host-only network, exactly as the DVWA and LFI labs already are.


0. How this plugs into Fissure (read first)

This section is the Fissure-specific contract the generic plan below must satisfy. It is what makes the plan processable without further decisions.

0.1 Where the files go

Each target is a sibling of lab/dvwa/, same shape:

lab/<id>/
  docker-compose.yml        # or run.sh wrapping `docker run` for single-container targets
  run.sh                    # up + bootstrap + healthcheck + print base_url, mirrors lab/dvwa/run.sh
  README.md                 # loopback-only warning, start, reset, credentials, module map
  gen-certs.sh              # only if the target needs an HTTPS gateway (as lab/dvwa does)
  target.yaml               # the machine-readable descriptor (section 1)
  expected_findings.json    # ground truth for scoring (section 5)
  • lab/ is lab glue, not shipped product code. The runner and descriptors are shell / YAML / JSON, driven by Docker; do NOT add a YAML or Docker client to Nilorea for this. If a genuine general-purpose helper is ever needed it follows the upstream-first rule (Nilorea + doxygen + example + test); lab orchestration itself stays under lab/.
  • A single generic runner (lab/run-target.sh <id> or a small harness under tests/) reads target.yaml and drives every target uniformly, so DVWA and the new targets go through one code path. Refactoring DVWA onto that runner with no behaviour change is rollout phase 0.

0.2 Safety and scope (non-negotiable, same as the existing labs)

  • Every target binds to 127.0.0.1 only, or to a host-only / internal Docker network. Never 0.0.0.0 on a reachable machine: several targets contain RCE by design.
  • Each target ships a scope.json confined to its own 127.0.0.1:<port> (or lab hostname). All active scanning, fuzzing and MITM stays behind Fissure's scope allowlist, the safe/aggressive toggle and the authorization banner. The lab does not relax any of that.
  • Tear down after a run (docker compose down -v). Pin every image tag/commit so scores are reproducible and an upstream change cannot silently alter the corpus.

0.3 Driving and scoring with Fissure's own surfaces

Score by diffing the FISSURE_FINDING records Fissure produces against each target's expected_findings.json, and cross-check against the target's own oracle where one exists (Juice Shop /api/Challenges, the OWASP Benchmark scorecards, the VAmPI secure twin). Drive each target three ways so the lab exercises the same paths an operator would:

  • the CLI: fissure scan <base_url> ... --format json -o report.json;
  • the control API (/api/scan, /api/report) for the headless path;
  • the fissure_bug_bounty skill over the MCP bridge, which is the agent-driven path the DVWA validation rule already requires.

Each target's report is written with Fissure's own report generator under reports/dvwa_<DATE_TIME>/-style timestamped directories (reuse the existing convention, one directory per run, so runs never overwrite each other).

0.4 Validation and documentation rules that apply

  • Per the DVWA end-to-end rule in CLAUDE.md: a target is not "integrated" until it is driven two ways (directly AND through the skill over MCP) and the outcome is recorded in a timestamped report. The deterministic loopback tests under tests/ stay the authoritative regression; the lab is the end-to-end check.
  • Keep docs current in the same change: cross-link 12_DVWA_LAB.md, add the target to FEATURES.md lab inventory and to this doc's status, write lab/<id>/README.md, and when a rollout phase ships, harvest its TODO entry into TODO_DONE.md.
  • ASCII only, no unicode, per CLAUDE.md. (This doc is ASCII; keep it that way.)

0.5 What this is NOT

Not a new runtime capability, so the four-surface (GUI / control API / MCP / skill) parity rule does not create new product surfaces here: the lab reuses the scan and report surfaces that already exist. The deliverable is test infrastructure plus the scoring harness, not new Fissure features. Any genuinely new check a target reveals as missing is its own TODO item, built under the normal rules.


1. Target descriptor contract (derived from the DVWA lab)

Every new target exposes the same interface so the generic runner can treat them uniformly. Store it as lab/<id>/target.yaml plus lab/<id>/expected_findings.json.

Field Purpose DVWA example Fissure mechanism it feeds
id Short slug dvwa directory name lab/<id>/
category web, api, graphql, benchmark, cve, infra, ad, k8s web runner grouping, CI cost tier
setup Command(s) to start the target docker run ... vulnerables/web-dvwa run.sh / docker compose up
base_url Entry point for the tools http://127.0.0.1:8081 scan seed + scope.json host
healthcheck HTTP probe + expected status/string GET /login.php -> 200 runner readiness gate (retry + timeout)
bootstrap One-time init (DB creation, seed, login) POST /setup.php (Create/Reset DB) run.sh step before scanning
auth How tools obtain a session/token form login admin/password + security cookie Fissure login config / --login, --cookie
reset Return to a known state between runs re-run DB setup runner idempotency
expected_findings Ground truth used to score the tools SQLi, XSS, CMDi, CSRF, LFI, upload, and more scoring diff vs FISSURE_FINDING
teardown Stop and clean up docker rm -f dvwa docker compose down -v
resources RAM/CPU/time estimate ~300 MB, under 30 s CI tier selection

A YAML descriptor per target plus an expected_findings.json lets the same runner drive every target and compute a detection score (section 5).


2. Target catalogue

Port suggestions avoid collisions when several targets run together (DVWA assumed on 8081; note Fissure's own DVWA lab uses 4280, adjust to match). All ports are bound to 127.0.0.1.

Tier 1: Web applications (closest to DVWA, integrate first)

2.1 OWASP Juice Shop [DONE: lab/juiceshop/]

  • URL: https://github.com/juice-shop/juice-shop , https://owasp.org/www-project-juice-shop/
  • Stack: Node.js / Express / Angular SPA, REST API, SQLite
  • Why: modern JS-heavy SPA, 100+ challenges. The best test of whether the crawler and the DAST path cope with client-side routing and JSON APIs.
  • Setup:
    docker run -d --name juiceshop -p 127.0.0.1:3000:3000 bkimminich/juice-shop
  • Healthcheck: GET http://127.0.0.1:3000/rest/admin/application-version -> 200
  • Auth: self-register via POST /api/Users, then POST /rest/user/login for a JWT bearer.
  • Reset: restart the container (state is in-memory/ephemeral).
  • Scoring oracle: GET /api/Challenges returns every challenge with a solved flag. Diff it before and after a tool run to know exactly what was exploited.
  • Resources: ~400 MB RAM.

2.2 OWASP WebGoat (+ WebWolf) [DONE: lab/webgoat/]

  • URL: https://github.com/WebGoat/WebGoat
  • Stack: Java / Spring Boot
  • Why: lesson-based, each lesson isolates one vulnerability class. WebWolf provides an attacker-side mail/file host for out-of-band tests (pairs with Fissure OAST).
  • Setup:
    docker run -d --name webgoat -p 127.0.0.1:8080:8080 -p 127.0.0.1:9090:9090 webgoat/webgoat
  • Base URLs: http://127.0.0.1:8080/WebGoat , http://127.0.0.1:9090/WebWolf
  • Auth: register a user through the form; session cookie.
  • Reset: recreate the container.
  • Notes: Java app, startup is slower (allow ~60 s in the healthcheck retry loop).

2.3 OWASP Mutillidae II [DONE: lab/mutillidae/]

  • URL: https://github.com/webpwnized/mutillidae-docker (source app: https://github.com/webpwnized/mutillidae)
  • Stack: PHP / Apache / MySQL / OpenLDAP (5 containers upstream; the Fissure lab runs 3: database, LDAP directory and web, dropping the two admin UIs)
  • Why: very wide OWASP Top 10 coverage with security levels like DVWA, so it is the easiest one to port from the DVWA lab.
  • Setup in Fissure: lab/run-target.sh mutillidae (or lab/mutillidae/run.sh), which brings up lab/mutillidae/docker-compose.yml (the three services, pinned by digest) and builds the database through the set-up-database.php bootstrap. Upstream's own setup, for reference:
    git clone https://github.com/webpwnized/mutillidae-docker.git
    cd mutillidae-docker
    docker compose -f .build/docker-compose.yml up --build --detach
  • Ports: the Fissure lab publishes only the web port, on 127.0.0.1:4281 (upstream defaults are 80/8080 app, 81 phpMyAdmin, 82 phpLDAPadmin).
  • Gotcha: upstream's compose expects the site at mutillidae.localhost; the Fissure lab reaches it directly at http://127.0.0.1:4281 with no hosts entry.

2.4 bWAPP [DONE: lab/bwapp/]

  • URL: http://www.itsecgames.com/
  • Stack: PHP / MySQL
  • Why: 100+ bugs, including classes DVWA lacks (SSRF, XXE, HTML5, Heartbleed in bee-box).
  • Setup in Fissure: lab/run-target.sh bwapp (or lab/bwapp/run.sh) runs the community raesene/bwapp image from lab/bwapp/docker-compose.yml on 127.0.0.1:4282, builds the DB via install.php?install=yes, and logs in as bee/bug (see lab/bwapp/README.md). The equivalent manual run:
    docker run -d --name bwapp -p 127.0.0.1:4282:80 raesene/bwapp
  • Notes: unmaintained upstream. Keep it as a breadth target, not a reference.

2.5 DVNA and NodeGoat (Node.js-specific)

  • DVNA: https://github.com/appsecco/dvna
    docker run -d --name dvna -p 127.0.0.1:9091:9090 appsecco/dvna:sqlite
  • NodeGoat: https://github.com/OWASP/NodeGoat. Clone it, then run docker compose up --build (default port 4000).
  • Why: both include source code, so the same target serves source review (scan the repo) and DAST (scan the running app). Useful to correlate findings across types.

2.6 Hackazon (optional)

  • URL: https://github.com/rapid7/hackazon
  • Why: a realistic e-commerce site with AJAX/JSON/XML flows, built by Rapid7 specifically to evaluate DAST scanners.
  • Notes: old, no official maintained image. Build from the repo or use a community image you have vetted. Lowest priority.

Tier 2: Tool-accuracy benchmarks (most valuable for scoring)

2.7 OWASP Benchmark (Java) [DONE: lab/benchmark/]

  • URL: https://github.com/OWASP-Benchmark/BenchmarkJava , scorecards: https://github.com/OWASP-Benchmark/BenchmarkUtils , docs: https://owasp.org/www-project-benchmark/
  • Why: thousands of test cases, each labelled true or false positive. It produces a scorecard (TPR vs FPR) per tool. This is the reference for measuring scanner precision, not just recall, which matters for Fissure's no-false-positives goals.
  • Setup:
    git clone https://github.com/OWASP-Benchmark/BenchmarkJava.git
    cd BenchmarkJava
    ./runBenchmark.sh          # serves https://localhost:8443/benchmark/
    The scripts need Maven and Java. Containerise them if the host should stay clean.
  • Scoring flow:
    1. Run Fissure (DAST against :8443).
    2. Drop Fissure's report into results/ (convert to a supported format if needed).
    3. Run ./createScorecards.sh to generate the HTML scorecard.
  • Integration tip: Fissure emits SARIF; if BenchmarkUtils does not read it directly, write a small converter or add a reader.

2.8 Vulhub (real CVEs) [BEGUN: lab/vulhub/]

  • URL: https://github.com/vulhub/vulhub , https://vulhub.org/
  • Why: hundreds of docker-compose environments, each reproducing one real CVE (Struts2, Log4Shell, Spring, Jenkins, Confluence, Redis, and more). Ideal for regression-testing detection templates (the nuclei importer, native checks) one CVE at a time.
  • Setup (per CVE):
    git clone --depth 1 https://github.com/vulhub/vulhub.git
    cd vulhub/log4j/CVE-2021-44228
    docker compose up -d
    # ... run Fissure ...
    docker compose down -v
  • Integration: treat Vulhub as a parametrised target (vulhub:<path>). Each directory's README gives the exposed port and the expected vulnerability, which becomes the single expected finding.

Tier 3: API and GraphQL

2.9 OWASP crAPI [DONE: lab/crapi/]

  • URL: https://github.com/OWASP/crAPI
  • Why: microservices API covering the OWASP API Security Top 10 (BOLA, BFLA, mass assignment, SSRF, JWT issues, and more).
  • Setup:
    curl -o docker-compose.yml https://raw.githubusercontent.com/OWASP/crAPI/main/deploy/docker/docker-compose.yml
    docker compose pull
    docker compose -f docker-compose.yml --compatibility up -d
  • URLs: app http://localhost:8888 , MailHog (captures signup/OTP emails) http://localhost:8025
  • Auth: sign up, then read the verification mail from the MailHog API to automate the login flow.
  • Resources: heaviest target here (several services + DBs). Allow 2-4 GB RAM.

2.10 VAmPI [DONE: lab/vampi/]

  • URL: https://github.com/erev0s/VAmPI
  • Why: small Flask REST API with an OpenAPI spec and a vulnerable/secure toggle. Run both modes to measure false positives cleanly.
  • Setup:
    docker run -d --name vampi-vuln   -e vulnerable=1 -p 127.0.0.1:5000:5000 erev0s/vampi:latest
    docker run -d --name vampi-secure -e vulnerable=0 -p 127.0.0.1:5001:5000 erev0s/vampi:latest
  • Bootstrap: GET /createdb to seed the database.
  • Scoring: a finding reported on the secure instance is a false positive.

2.11 DVGA (Damn Vulnerable GraphQL Application) [DONE: lab/dvga/]

  • URL: https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application
  • Why: GraphQL-specific issues: introspection, batching/DoS, injections, authz bypass, SSRF. Pairs with Fissure's GraphQL workshop.
  • Setup:
    docker run -d --name dvga -p 127.0.0.1:5013:5013 -e WEB_HOST=0.0.0.0 dolevf/dvga
    On ARM Macs, build locally with Dockerfile.arm64.
  • URL: http://127.0.0.1:5013 (GraphQL endpoint /graphql). It has beginner and expert modes, similar to DVWA security levels.

2.12 DVWS-node [DONE: lab/dvws/, classic DVWS image]

  • URL: https://github.com/snoopysecurity/dvws-node
  • Why: REST, SOAP/XML and GraphQL in one target, good for XXE and SOAP-capable tooling.
  • Setup: clone it, then run docker compose up -d. Check the repo's compose file for the current ports before mapping.

Tier 4: Infrastructure, AD and Kubernetes (optional, heavier)

Target URL Method Use it for
Metasploitable 3 https://github.com/rapid7/metasploitable3 Vagrant + VirtualBox/VMware (Ubuntu and Windows builds) Network scanners, service fingerprinting, exploit modules
Metasploitable 2 https://sourceforge.net/projects/metasploitable/ Prebuilt VM image, host-only network Same, lighter and older
GOAD (Game of Active Directory) https://github.com/Orange-Cyberdefense/GOAD Vagrant/Ansible, multiple Windows VMs AD enumeration, Kerberos attacks, lateral movement. Needs tens of GB of RAM for the full lab
Kubernetes Goat https://github.com/madhuakula/kubernetes-goat kind/minikube + setup-kubernetes-goat.sh, then access-kubernetes-goat.sh for port-forwards Container/K8s scanners, misconfig and RBAC checks
VulnHub https://www.vulnhub.com/ Downloadable VMs Ad-hoc boot2root scenarios

3. Unified lab: docker-compose skeleton (NOT BUILT)

As built, there is no unified compose file: each target has its own compose under lab/<id>/docker-compose.yml (loopback-only ports, pinned images) and is run through the generic runner, lab/run-target.sh <id> (OWASP Benchmark and Vulhub have their own run.sh). lab/seclab/ does not exist. The sketch below is the original design idea of one compose file for the lightweight Docker targets, on an internal-only network with the toolkit container attached, kept for reference only; its ports predate the per-target layout and do not match the built targets.

# lab/seclab/docker-compose.yml
name: seclab

networks:
  lab:
    driver: bridge
    internal: true      # no egress to the internet from targets

services:
  dvwa:
    image: vulnerables/web-dvwa
    ports: ["127.0.0.1:8081:80"]
    networks: [lab]

  juiceshop:
    image: bkimminich/juice-shop
    ports: ["127.0.0.1:3000:3000"]
    networks: [lab]

  webgoat:
    image: webgoat/webgoat
    ports: ["127.0.0.1:8080:8080", "127.0.0.1:9090:9090"]
    networks: [lab]

  bwapp:
    image: raesene/bwapp
    ports: ["127.0.0.1:8082:80"]
    networks: [lab]

  dvna:
    image: appsecco/dvna:sqlite
    ports: ["127.0.0.1:9091:9090"]
    networks: [lab]

  vampi-vuln:
    image: erev0s/vampi:latest
    environment: { vulnerable: "1" }
    ports: ["127.0.0.1:5000:5000"]
    networks: [lab]

  vampi-secure:
    image: erev0s/vampi:latest
    environment: { vulnerable: "0" }
    ports: ["127.0.0.1:5001:5000"]
    networks: [lab]

  dvga:
    image: dolevf/dvga
    environment: { WEB_HOST: "0.0.0.0" }
    ports: ["127.0.0.1:5013:5013"]
    networks: [lab]

  # toolkit:
  #   image: <fissure-image>
  #   networks: [lab]       # tools reach targets by service name, e.g. http://juiceshop:3000

Run the multi-container targets (Mutillidae, crAPI, Benchmark, Vulhub, NodeGoat, DVWS-node) with their own compose files. Attach them to the seclab_lab network with docker network connect, or with an external: true network declaration, so they stay upgradeable from upstream.

WARNING: with internal: true, ports published to 127.0.0.1 may not be reachable from the host on every Docker setup. If you need host access, give each target a second, non-internal network bound only to localhost, or run the toolkit inside the lab network (recommended).


4. Per-target integration checklist


5. Rollout plan (start here)

Phase Targets Goal Exit criteria
0. Refactor (DONE) DVWA Extract the DVWA lab onto the generic target contract (section 1) and the generic runner DONE: lab/run-target.sh + lab/labdesc.py + lab/score.py are in; DVWA is described by lab/dvwa/target.yaml + expected_findings.json + scope.json; lab/dvwa/run.sh is a thin wrapper over the generic runner (same env overrides, same per-level Markdown+JSON reports, plus a score.md/score.json); make lab-selftest regression-tests the scorer offline; the C suite stays green
1. Quick wins (DONE) Juice Shop (DONE), Mutillidae (DONE), bWAPP (DONE) Broaden web coverage with targets close to DVWA Setup, healthcheck, auth and reset automated; first detection report, both drive paths. Juice Shop DONE: lab/juiceshop/ on the generic contract, JWT bearer via the header_cmd auth mode (auth.sh prints the Authorization + token-cookie headers), scored (recall 100% on the headless-reachable high-value issues), driven both ways. Mutillidae DONE: lab/mutillidae/ (three-container compose reduced from the upstream five, pinned by digest, loopback-only), form auth as admin via resources/login/mutillidae.json, DB built via set-up-database.php bootstrap; authenticated it detects SQLi (error/boolean/time-based) and reflected XSS on its param-routed wrapper pages, scored and driven both ways. Standing it up surfaced and drove a general engine fix (do not follow a redirect that only upgrades http->https on the same host:port, which was aborting plain-HTTP scans; see docs/TODO_DONE.md). bWAPP DONE: lab/bwapp/, unblocked by the new scan seed feature (its bug pages are not link-discoverable, so a curated seeds.txt is fed to the crawl via fissure --seed-file); form auth as bee with a per-scan reset that re-pins bee's password, scored recall 67% (SQLi + reflected XSS) / precision 100%, driven both ways.
2. Measurement (DONE) OWASP Benchmark (DONE), VAmPI (vuln + secure) (DONE) Get precision numbers, not just "found something" Scorecard generated for Fissure; FP rate tracked over time. OWASP Benchmark DONE: lab/benchmark/ (owasp/benchmark image via mvn package cargo:run -Pdeploy -Drunenv=remote, which binds all interfaces and starts the HSQLDB server; HTTPS on loopback :8446) with its OWN per-test-case scorer (score.py) and seed generator (gen-seeds.py) since Benchmark scoring is per-test-case, not by class/path. Scanning the 334 GET-query cases of the DAST-detectable categories gives a real scorecard: overall TPR 59%, FPR 0% (zero false positives); xss 100%, cmdi 96%, sqli 32%, pathtraver 0%, xpathi 0%. It surfaced concrete detection gaps (tracked in TODO): pathtraver (the Benchmark cases reflect the constructed path rather than leaking file content, which Fissure's content-signature LFI oracle does not catch), no XPath-injection check, and low GET-query SQLi recall. The form/cookie/header cases need a Benchmark crawler-file importer (TODO). VAmPI DONE: lab/vampi/ runs the vulnerable (:5000) + secure (:5001) twins via the secure_twin runner feature; the vuln instance is scored for recall (SQLi detected, 100% on the expected class) and the secure twin for the clean false-positive count (empty expected, so any finding is an FP) - it surfaced a spurious error-based SQLi on the hardened /users/v1/register (tracked in TODO).
3. Modern surfaces (DONE) crAPI (DONE), DVGA (DONE), DVWS (DONE), WebGoat (DONE) Cover API, GraphQL, SOAP/XXE and OOB testing API/GraphQL findings mapped to expected lists. WebGoat DONE: lab/webgoat/, the Java/Spring Top-10 app scanned authenticated (Spring Security form login via auth.sh -> JSESSIONID cookie) with the actuator endpoints seeded; its lessons are interaction-gated so the automatable finding is information disclosure - the generic scan detects the Spring Boot Actuator /actuator/health internal-path leak (CWE-209, recall + precision 100%), driven both cli and api. WebGoat exposes the actuator UNAUTHENTICATED (incl. /actuator/env) - a high-value finding Fissure has no dedicated check for yet, tracked as the actuator-exposure follow-up in TODO. DVWS DONE: lab/dvws/ (the published classic-DVWS image; the dvws-node variant has no pinned public image), served under /dvws/, scanned unauthenticated; the generic crawl reaches the linked vulnerability pages and detects command injection (critical), SQL injection and reflected XSS (recall + precision 100% on 3 classes), driven both cli and api; it also detects an IDOR on the REST api.php/users/{id} endpoint (CWE-639) but that is crawl-order/timing dependent, so it is kept in allowed rather than scored to keep recall stable. Its SOAP/XML service bugs (XXE, XPath over a posted XML body) need a captured XML-POST operation and are the XML/SOAP case of the crawler-discovery item in TODO. DVGA DONE: lab/dvga/, scanned unauthenticated (auth.mode: none, new); the generic scan detects GraphQL introspection (recall + precision 100% on the expected class), driven both cli and api. DVGA's deeper GraphQL surface (batching, GET/CSRF, field-suggestion, depth DoS) needs a captured GraphQL operation and is the GraphQL case of the crawler-discovery item in TODO. crAPI DONE: lab/crapi/, the multi-container stack trimmed to the loopback web port and digest-pinned, scanned authenticated (JWT bearer from auth.sh) with a curated deep-endpoint seeds.txt; the generic scan detects the exposed /.env credential file (recall + precision 100%), driven both cli and api. crAPI's by-design API-logic flaws (BOLA/mass-assignment/SSRF/JWT/excessive-data-exposure) need stateful JSON-POST driving and are exercised through the skill/MCP path (the SPA/JSON-POST coverage gap in TODO).
4. CVE regression (BEGUN) Vulhub (curated subset, e.g. 20-30 high-value CVEs) Per-template / per-check regression suite Each CVE env: up -> detect -> down. BEGUN: lab/vulhub/ is the parametrized runner + registry; it sparse-clones one Vulhub env, re-publishes it on loopback, loads the CVE's nuclei template into Fissure, scans and verifies. CVE-2021-41773 (Apache 2.4.49 path traversal / RCE) validated end to end (PASS). It surfaced a detection gap (TODO): Fissure's nuclei engine does not fire chained multi-request templates (CVE-2017-12615 Tomcat PUT RCE stands up but is not detected). Grow the curated subset next.
5. Optional Metasploitable 3, Kubernetes Goat, GOAD Infra / K8s / AD tooling Separate, manually triggered jobs (too heavy for every CI run)

6. Scoring model

For every target and tool run:

  • TP: reported finding matching an expected finding (match on vuln class + endpoint/parameter)
  • FP: reported finding with no match, or any finding on a secure twin (VAmPI secure, Benchmark "false" cases)
  • FN: expected finding not reported

Track recall = TP / (TP + FN) and precision = TP / (TP + FP) per target and per vulnerability class. Use Juice Shop's /api/Challenges and the Benchmark scorecards as independent oracles to validate Fissure's own matcher.


7. Safety rules

  • Never bind targets to 0.0.0.0 on a machine reachable from other networks; these apps include RCE by design.
  • Keep targets on an internal Docker network or a host-only VM network. Block egress where possible (some targets fetch remote resources or call back).
  • Do not reuse the lab host for anything sensitive. Tear down after each run (docker compose down -v).
  • Pin images and re-check upstream repos periodically: several projects here (bWAPP, Hackazon, Metasploitable 2) are unmaintained, and community images can change owners.

8. Quick reference

ID Category Run method Default local URL Maintained
dvwa [DONE] web compose (lab/dvwa/) :4280 (HTTPS gateway :8443) yes
juiceshop [DONE] web / SPA / API compose (lab/juiceshop/) :3000 yes
webgoat [DONE] web (lessons) compose (lab/webgoat/) :8080/WebGoat, :9090/WebWolf yes
mutillidae [DONE] web compose (lab/mutillidae/, 3 containers) :4281 yes
bwapp [DONE] web compose (lab/bwapp/, community image) :4282 no
dvna web / source+DAST docker :9091 partial (low activity)
nodegoat web / source+DAST compose :4000 partial (low activity)
hackazon web (DAST eval) build from repo n/a no
owasp-benchmark [DONE] benchmark compose + own runner (lab/benchmark/run.sh) https://127.0.0.1:8446 yes
vulhub [BEGUN] real CVEs compose per CVE (lab/vulhub/run.sh) per README yes
crapi [DONE] API compose (lab/crapi/, digest-pinned) :8888 (+ MailHog :8025) yes
vampi [DONE] API compose (lab/vampi/; vuln + secure) :5000 / :5001 yes
dvga [DONE] GraphQL compose (lab/dvga/) :5013 yes
dvws [DONE] REST/SOAP/XML compose (lab/dvws/, classic DVWS image) :4284/dvws yes
metasploitable3 infra Vagrant VM IP partial
goad Active Directory Vagrant/Ansible VM IPs yes
kubernetes-goat K8s kind/minikube + scripts port-forwards yes

Maintenance status is indicative as of late 2026. Re-verify image names and ports against each repository before pinning.