Vulnerable target lab: integration plan
Status: Phase 0 BUILT (the generic target contract, the generic runner
lab/run-target.sh, and the scoring harnesslab/score.pyare 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 ownlab/<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_bountyskill. 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.1or 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 underlab/.- A single generic runner (
lab/run-target.sh <id>or a small harness undertests/) readstarget.yamland 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.1only, or to a host-only / internal Docker network. Never0.0.0.0on a reachable machine: several targets contain RCE by design. - Each target ships a
scope.jsonconfined to its own127.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_bountyskill 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, thenPOST /rest/user/loginfor a JWT bearer. - Reset: restart the container (state is in-memory/ephemeral).
- Scoring oracle:
GET /api/Challengesreturns every challenge with asolvedflag. 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(orlab/mutillidae/run.sh), which brings uplab/mutillidae/docker-compose.yml(the three services, pinned by digest) and builds the database through theset-up-database.phpbootstrap. 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 athttp://127.0.0.1:4281with 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(orlab/bwapp/run.sh) runs the communityraesene/bwappimage fromlab/bwapp/docker-compose.ymlon127.0.0.1:4282, builds the DB viainstall.php?install=yes, and logs in asbee/bug(seelab/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:
The scripts need Maven and Java. Containerise them if the host should stay clean.
git clone https://github.com/OWASP-Benchmark/BenchmarkJava.git cd BenchmarkJava ./runBenchmark.sh # serves https://localhost:8443/benchmark/ - Scoring flow:
- Run Fissure (DAST against
:8443). - Drop Fissure's report into
results/(convert to a supported format if needed). - Run
./createScorecards.shto generate the HTML scorecard.
- Run Fissure (DAST against
- 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 /createdbto 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:
On ARM Macs, build locally with
docker run -d --name dvga -p 127.0.0.1:5013:5013 -e WEB_HOST=0.0.0.0 dolevf/dvgaDockerfile.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:3000Run 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 to127.0.0.1may 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.0on 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.