j3ssie/dynast-benchजानबूझकर कमजोरियों वाले ऐप्स का एक DAST बेंचमार्क, जिसमें स्कैनर्स को स्कोर करने के लिए ग्राउंड-ट्रुथ उत्तर कुंजियाँ शामिल हैं।
जानबूझकर कमजोर ऐप्स का एक DAST बेंचमार्क, जिसमें स्कैनर को स्कोर करने के लिए ग्राउंड-ट्रुथ उत्तर कुंजियाँ शामिल हैं।
⚠️ इस रिपॉजिटरी में जानबूझकर असुरक्षित एप्लिकेशन हैं। ये केवल सुरक्षा टूलिंग - DAST स्कैनर, SAST इंजन और LLM सुरक्षा एजेंटों को बेंचमार्क करने के लिए मौजूद हैं। हर ऐप
127.0.0.1से बंधा होता है, एक तेज़ बैनर भेजता है, और कोई वास्तविक डेटा नहीं रखता। इनमें से किसी को भी सार्वजनिक नेटवर्क पर कभी तैनात न करें।
19 जानबूझकर कमजोर ऐप्स का एक सूट, प्रत्येक स्टैक के लिए एक, प्रत्येक में एक प्रलेखित, मशीन-जांच योग्य ग्राउंड ट्रुथ है। उद्देश्य यह मापना है कि एक स्कैनर या एजेंट कितनी अच्छी तरह (a) लगाए गए बग ढूंढता है, (b) उनके ठीक बगल में मौजूद सुरक्षित नियर-मिस कोड को अनदेखा करता है, और (c) पैच किए गए ट्विन पर गलत निष्कर्ष नहीं निकालता।
19 ऐप्स · 549 लगाए गए कमजोरियाँ · 146 नियर-मिस · 546 चलाने योग्य PoC ·
594 सूचीबद्ध एंडपॉइंट। हर ऐप 127.0.0.1:13311 पर बूट होता है, एक
vuln/+safe/ ट्विन जोड़ी और एक सिंगल-इमेज --solo बिल्ड भेजता है। dynast-bench list
यह तालिका लाइव प्रिंट करता है; इसका एंडपॉइंट कैटलॉग प्रिंट करता है।
dynast-bench surface <app>| App | Stack | Datastore | Vulns | Near-miss | Docs |
|---|---|---|---|---|---|
| aspnet | C# / ASP.NET Core Razor Pages | SQL Server | 28 | 12 | plan |
| fastapi | Python / FastAPI + Jinja2 | Postgres | 26 | 5 | plan |
| gin | Go / Gin | Postgres | 12 | 7 | readme |
| golang | Go / chi | Postgres | 26 | 4 | plan |
| graphql | Node / GraphQL 16 API-only | Postgres | 31 | 6 | plan |
| jsp | Java / JSP + Servlets (Tomcat) | Postgres | 28 | 6 | plan |
| laravel | PHP 8.3 / Laravel 11 + Blade | MySQL | 25 | 7 | plan |
प्रति स्टैक अतिरिक्त साइडकार (Mailpit, MinIO, Redis, Jenkins, Prometheus, Ollama, …) नीचे The apps में सूचीबद्ध हैं।
प्रति-स्टैक डिज़ाइन दस्तावेज़ benchmark-plans/ में रहते हैं -
प्रत्येक ऐप की पूरी कमजोरी सूची के लिए वहीं से शुरू करें। यह README परिचालन
मार्गदर्शिका है: रिपॉजिटरी कैसे व्यवस्थित है और किसी ऐप को कैसे चलाएँ और स्कोर करें।
हर लगाया गया बग एक CWE और एक OWASP श्रेणी रखता है। वर्ग द्वारा संक्षेपित - प्रत्येक बग को उसके प्राथमिक CWE के अंतर्गत एक बार गिना जाता है - लगाए गए बग मोटे तौर पर इस प्रकार विभाजित होते हैं (रोलअप अंतिम बार 480 बग पर पुनर्जीवित किया गया; ऊपर प्रति-ऐप गणना वर्तमान हैं):
| Class | CWEs | Bugs | Apps |
|---|---|---|---|
| Sensitive data exposure (errors, logs, debug endpoints, backups, source) | 200, 209, 489, 524, 532, 538, 540, 548 | 39 | 16 |
| Default / hardcoded / leaked credentials | 321, 522, 798, 1104, 1392 | 38 | 18 |
| Missing or broken authorization (BFLA, vertical + horizontal) | 269, 284, 285, 668, 862, 863 | 37 | 18 |
| Cross-site scripting (reflected · stored · DOM) | 79 | 28 | 16 |
| Authentication bypass · weak session · JWT verification | 287, 288, 290, 306, 347, 384, 613, 614, 1385 | 28 | 13 |
| SQL injection (incl. second-order, ORDER BY, NoSQL) | 89, 943 | 27 | 17 |
| Proxy / parser interpretation conflicts (path confusion, header trust) | 345, 348, 349, 436, 441, 693, 697, 706, 807 | 27 | 10 |
| SSRF (incl. blind, redirect chains, internal-only sinks) | 918 | 20 | 17 |
| IDOR / BOLA (user-controlled object key) | 639 | 19 | 17 |
| Path traversal · LFI/RFI · zip slip | 22, 98 | 19 | 16 |
| Mass assignment / over-posting · prototype pollution | 915, 1321 | 18 | 16 |
| Brute force · missing rate limiting · resource exhaustion | 307, 400, 406, 674, 770 | 17 | 11 |
| Business-logic, pricing and quota abuse | 625, 840 | 15 | 14 |
| OS command / argument injection | 78 | 14 | 12 |
| Insecure deserialization (pickle · PHP · Java · YAML) | 470, 502 | 14 | 11 |
| CORS misconfiguration | 942 | 14 |
OWASP श्रेणी द्वारा (वेब ऐप्स के लिए 2021 Top 10, API Top 10 2023 जहाँ ऐप API-only है):
| OWASP | Bugs | OWASP API | Bugs | |
|---|---|---|---|---|
| A01 Broken Access Control | 118 | API8 Security Misconfiguration | 21 | |
| A03 Injection | 89 | API5 Broken Function Level Authorization | 6 | |
| A05 Security Misconfiguration | 72 | API1 Broken Object Level/Property Authorization | 4 | |
| A07 Identification & Authentication Failures | 65 | API2 Broken Authentication | 4 | |
| A04 Insecure Design | 34 | API7 Server Side Request Forgery | 4 | |
| A08 Software & Data Integrity Failures | 17 | API9 Improper Inventory Management | 3 | |
| A10 SSRF | 15 | API3 Broken Object Property Level Authorization | 2 | |
| A02 Cryptographic Failures | 15 | API4 Unrestricted Resource Consumption | 2 | |
| A09 Logging & Monitoring Failures | 4 | API6 Unrestricted Access to Sensitive Business Flows | 1 | |
| A06 Vulnerable & Outdated Components | 3 | API10 Unsafe Consumption of APIs | 1 |
इनके साथ दो गैर-वेब ट्रैक भी हैं: network ऐप नेटवर्क स्कैनर के लिए 32 होस्ट/पोर्ट
और सेवा-स्तरीय निष्कर्ष लगाता है, और दो LLM ऐप्स
(llmchat, llmagent) प्रॉम्प्ट-इंजेक्शन, टूल-दुरुपयोग और RAG-पॉइज़निंग बग लगाते हैं
जिन्हें एक अलग इंजेक्शन-चैनल ट्रैक पर स्कोर किया जाता है।
प्रत्येक बग को पता लगाने की कठिनाई (118 E, 68 E-M, 202
M, 61 M-H, 100 H), एक टेंट दूरी (351 in-file, 83 cross-file, 87
cross-service, 28 config) और एक पहुँच क्षमता (368 pre-auth, 181
user) के साथ भी टैग किया गया है, ताकि रिकॉल को एक संख्या के रूप में रिपोर्ट करने के बजाय
इनमें से प्रत्येक अक्ष के साथ विभाजित किया जा सके। प्रति-ऐप कैटलॉग
benchmark-plans/ में रहते हैं।
dynast-bench/
├── README.md # you are here - overview, safety, run/score guide
├── examples/ # ready-to-score findings/v1 + endpoints/v1 files
├── Makefile # top-level runner: list / run / verify / validate / solo any app
├── benchmark-plans/ # per-stack design docs (the vulnerability catalogs)
├── dynast-bench/ # the dynast-bench CLI + scorer (Bun/TS)
└── vulnerable-apps/ # the 19 apps - each a separated, self-contained folder
├── _template/ # skeleton; copy it to start a new app
├── fastapi/ golang/ nextjs/ nestjs/ springboot/
└── rails/ wordpress/ php/ jsp/ aspnet/ ...
## ऐप्स चलाना (`dynast-bench` CLI)
CLI सूट चलाने का सबसे आसान तरीका है - यह बूट्स को हेल्थ-गेट करता है, साझा पोर्ट्स का
आर्बिट्रेशन करता है, और `--json` बोलता है ताकि एक स्कैनर हार्नेस इसे उपभोग कर सके।
इसके लिए [Bun](https://bun.sh) 1.2+ और Docker की आवश्यकता है।```bash
make install # compile the CLI + link it into ~/.bun/bin
# (BIN_DIR=/somewhere/else to pick the dir)
dynast-bench list # every app: vulns, PoCs, near-misses, what's up
dynast-bench vulns nextjs # the planted bugs as a checklist, one title each
# (--full · --near · --ids for a coverage diff)
dynast-bench start nextjs # build + boot, wait for health, print the URL
dynast-bench verify nextjs # run the ground-truth PoCs (expect all exploitable)
dynast-bench validate nextjs # twin loop: vuln all-exploitable → safe all-fixed
dynast-bench status # variant, mode, target, health
dynast-bench stop --all # stop everything
dynast-bench clean --all --images --yes # reclaim containers, volumes, networks, images
dynast-bench start nextjs --variant safe # the patched twin (false-positive run)
dynast-bench start --count 5 --parallel # 5 apps at once, one port each + a summary table
dynast-bench start --all --solo --parallel # whole fleet, one image + port each
dynast-bench run nextjs -- my-scanner --url '$TARGET' # start → scan → stop
पूर्ण संदर्भ: dynast-bench/README.md।
सब कुछ एफेमरल रेंज के एक शांत हिस्से में रहता है, ताकि सूट सामान्य 3000/8000/8080/5432 भीड़ से न टकराए - और हर ऐप के पास एक निश्चित पोर्ट होता है, इसलिए एक URL का मतलब हमेशा एक ही ऐप होता है, चाहे वह अकेला हो या पाँच के बैच में:
| रेंज | क्या |
|---|---|
13311–13339 | परीक्षण के अधीन ऐप - वह URL जिस पर आप स्कैनर इंगित करते हैं, list क्रम में प्रति ऐप एक पोर्ट (aspnet 13311, fastapi 13312, … nextjs 13322) |
13340–13484 | उस ऐप के साइडकार्स (mailpit, phpMyAdmin, Jenkins, Prometheus, …), 5 प्रति ऐप |
13500–13599 | रिलोकेशन पूल |
dynast-bench list ही नक्शा है। यदि कोई चीज़ पहले से किसी ऐप के स्वामित्व वाले पोर्ट पर सुन रही है, तो dynast-bench start उसे अकेला छोड़ देता है और उस एक सेवा को रिलोकेशन पूल से प्रकाशित करता है, फिर वास्तविक URL प्रिंट (और --json-रिपोर्ट) करता है। कुछ भी कभी 127.0.0.1 से परे बाइंड नहीं होता। dynast-bench doctor दिखाता है कि कौन से ऐप पोर्ट खाली हैं; make लक्ष्य रिलोकेट नहीं करते और compose डिफ़ॉल्ट (13311+) को एक-एक करके प्रकाशित करते हैं, DYNAST_PORT=<n> का सम्मान करते हुए; --port N इसे पिन करता है।
Makefile कम-स्तरीय अनुबंध बने रहते हैं और स्वतंत्र रूप से काम करते हैं:```bash make list # show all apps (a [solo] tag = has a single-image build) make run APP=nextjs # start via compose (app + datastores) make verify APP=nextjs # run its ground-truth PoCs (expect all exploitable) make validate APP=nextjs # full twin loop: vuln all-pass -> safe all-fixed make down APP=nextjs # stop it make solo APP=nextjs # run as ONE self-contained image - no compose needed make solo-down APP=nextjs # stop the standalone image
हर ऐप को चलाने के दो तरीके:
- **Compose** (`make run`) - कैनोनिकल मल्टी-सर्विस टोपोलॉजी जो ग्राउंड
ट्रुथ टारगेट करती है (ऐप + Postgres/Redis/आदि अलग-अलग कंटेनर के रूप में)।
- **Standalone** (`make solo`) - हर ऐप के लिए एक सेल्फ-कंटेन्ड इमेज
(`vuln/Dockerfile.standalone`) जिसमें डेटास्टोर + एक आंतरिक SSRF सिंक
एम्बेडेड होते हैं, ताकि `docker build` + `docker run` बिना compose के काम करे।
व्यवहार और PoCs समान हैं (compose सर्विस नाम `127.0.0.1` पर एलियास किए गए हैं)।
रूट जानबूझकर छोटा रखा गया है: यह README, डिज़ाइन गाइड, साझा
टूलिंग, और ऐप्स। किसी दिए गए ऐप के लिए सब कुछ ऑपरेशनल उसी
ऐप के अपने फ़ोल्डर के अंदर है।
## प्रति-ऐप संरचना
`vulnerable-apps/` के अंतर्गत हर ऐप का आकार समान होता है:```
vulnerable-apps/<stack>/
├── README.md # LOUD banner + run notes
├── Makefile # up · reset · safe · verify · score · diff (uniform interface)
├── vuln/ # the vulnerable variant - this is what you scan by default
│ ├── docker-compose.yml # independent; binds 127.0.0.1 only
│ ├── app/ # application source; the planted bugs live here
│ └── db/seed.sql # seed incl. a cross-tenant user + a weak default cred
├── safe/ # the patched twin - same app, every planted bug fixed
│ ├── docker-compose.yml
│ ├── app/
│ └── db/seed.sql
└── ground-truth/ # the answer key - see "Ground truth" below
├── VULNERABILITIES.yaml # every planted bug
├── SURFACE.yaml # every endpoint the app exposes
├── verify/ # one runnable PoC per bug
└── expected/ # optional golden normalized findings
प्रत्येक ऐप git ब्रांच या पैच फ़ाइलों के बजाय दो अलग-अलग वेरिएंट फ़ोल्डर के साथ आता है:
vuln/ - वह ऐप जिसमें हर लगाया गया बग मौजूद है। डिफ़ॉल्ट लक्ष्य; जिस पर स्कैनर निशाना साधता है।safe/ - वही समान ऐप जिसमें हर लगाया गया बग ठीक कर दिया गया है और कुछ और नहीं बदला गया है (पैरामीटराइज़्ड क्वेरी, एस्केप किया गया आउटपुट, जोड़ा गया authz, सुरक्षित deserializers, …)।diff -ru vulnerable-apps/<stack>/vuln vulnerable-apps/<stack>/safe ही ग्राउंड ट्रुथ है। इसे ground-truth/VULNERABILITIES.yaml में नामित पंक्तियों को ही छूना चाहिए और कुछ और नहीं। safe/ वेरिएंट को स्कैन करना किसी टूल की गलत-सकारात्मक दर को मापता है: वहाँ की हर खोज एक झूठा अलार्म है, क्योंकि जुड़वाँ निर्माण से ही साफ़ है।
क्योंकि प्रत्येक वेरिएंट का Docker बिल्ड कॉन्टेक्स्ट उसका अपना फ़ोल्डर है (vuln/ या safe/), ऐप का ground-truth/ हर बिल्ड कॉन्टेक्स्ट के बाहर स्थित होता है और किसी इमेज में बेक नहीं किया जा सकता - उत्तर कुंजी चल रहे ऐप में लीक नहीं हो सकती, निर्माण से ही।
ground-truth/)दो उत्तर कुंजियाँ, क्योंकि दो प्रश्न हैं। VULNERABILITIES.yaml बताता है कि ऐप में क्या गलत है; SURFACE.yaml बताता है कि वहाँ क्या मौजूद है।
VULNERABILITIES.yaml प्रत्येक लगाए गए बग के लिए एक प्रविष्टि दर्ज करता है:```yaml
`SURFACE.yaml` ऐप द्वारा उजागर किए गए प्रत्येक **ऑपरेशन** के लिए एक प्रविष्टि दर्ज करता है - चाहे वह असुरक्षित हो या हानिरहित - यह [एंडपॉइंट कवरेज](#endpoint-coverage) के लिए हर (denominator) है:```yaml
operations:
- id: posts.search
kind: http # http | graphql | ws | llm | net
method: GET
path: /api/posts/search
params: [q]
discovery: js-runtime # same crawl tiers as the answer key
reachability: user
vulns: [SQLI-001] # omit when the operation is benign
- id: graphql.mutation.update-post
kind: graphql # the op BEHIND POST /graphql, which is its own entry
op: updatePost
graphql_kind: mutation
via: graphql.transport
discovery: static-html
सुरक्षित संचालन जानबूझकर वहाँ रखे गए हैं: केवल कमजोर रूट्स की सूची ऐप के बजाय उत्तर कुंजी के कवरेज को मापेगी।
verify/ में प्रत्येक बग के लिए एक चलाने योग्य PoC होता है - यह vuln/ के विरुद्ध 0 पर बाहर निकलता है और
safe/ के विरुद्ध गैर-शून्य पर। यह "बग वास्तविक है (और जुड़वां में वास्तव में ठीक किया गया है)" की निष्पादन योग्य परिभाषा है।
साझा रनर (dynast-bench/tools/poc-runner.sh) एक तीसरा परिणाम जोड़ता है जिसे
एग्जिट कोड अपने आप नहीं ले जा सकता: हार्नेस नहीं चल सका। सूट को एक ऐसे पोर्ट पर इंगित करें
जहाँ कुछ भी सुन नहीं रहा है और किसी भी ऐप के आधे से अधिक PoCs 1 पर बाहर निकलेंगे -
एक वास्तविक फिक्स से अप्रभेद्य। इसलिए रनर अस्वीकृति पर विश्वास करने से पहले लक्ष्य की स्वास्थ्य-जांच करता है,
प्रति-PoC समय-सीमा लागू करता है, और टाइमआउट, लापता टूल या उत्तर देना बंद कर चुके लक्ष्य पर दोनों पक्षों को विफल करता है। "सूट नहीं चल सका" को कभी भी "कमजोरी ठीक हो गई है" के रूप में दर्ज नहीं किया जाता।
dynast-bench/, Bun/TypeScript)एक टूलचेन, जिसका उपयोग हर ऐप करता है, ताकि क्रॉस-स्टैक परिणाम तुलनीय हों:
dynast-bench.ts - CLI: start/stop/reset/clean, स्वास्थ्य गेटिंग, पोर्ट
आर्बिट्रेशन, PoV सत्यापन, स्कोरिंग, हार्नेस के लिए --json।src/schema/ - दो रिपोर्ट प्रारूपों के लिए प्रकार + वैलिडेटर
(findings/v1, endpoints/v1) और दो उत्तर कुंजियाँ
(VULNERABILITIES.yaml, SURFACE.yaml), आंशिक क्रेडिट के लिए उपयोग की जाने वाली CWE-परिवार तालिका,
और पथ/रूट/ऑपरेशन नॉर्मलाइज़र जिनसे तुलना के दोनों पक्ष गुजरते हैं।src/normalize/ - एडेप्टर जो कच्चे स्कैनर आउटपुट (OWASP ZAP, SARIF
Semgrep/CodeQL/Snyk से, nuclei, Burp XML, nmap XML) को उस प्रारूप में परिवर्तित करते हैं। प्रारूप
स्वतः-पहचाना जाता है, इसलिए score मूल आउटपुट को सीधे लेता है।src/scorer/ - निष्कर्षों को उत्तर कुंजी से मिलाता है और precision / recall / F1 उत्सर्जित करता है,
कठिनाई / गंभीरता / पहुँच / टेंट / CWE के अनुसार recall, निकट-चूकों पर एक discrimination स्कोर, और एक डुप्लिकेट
(शोर) अनुपात। इसके साथ, एक endpoint-coverage ट्रैक
यह ग्रेड करता है कि एक रन वास्तव में ऐप के कितने हिस्से तक पहुँचा और हर चूक को विभाजित करता है:
"एंडपॉइंट कभी नहीं मिला" बनाम "मिला, बग चूक गया"।```
dynast-bench verify # run the app's ground-truth PoCs
dynast-bench score findings.json # findings → P/R/F1 + per-dimension recall
dynast-bench coverage endpoints.json # endpoint discovery → how much was reached
dynast-bench surface # the operation checklist a crawl is graded on
dynast-bench diff # the vuln↔safe delta vs the answer key
dynast-bench check --all # CI gate: schema · anchors · diff scope · binds[`examples/`](https://github.com/j3ssie/dynast-bench/blob/main/examples) में ऐसी फ़ाइलें हैं जिन्हें आप तुरंत स्कोर कर सकते हैं - एक findings रन, एक false-positive रन, तीन endpoint ट्रेस और दो खाली टेम्पलेट, जिनमें से प्रत्येक को उसके द्वारा उत्पन्न संख्याओं के साथ प्रलेखित किया गया है:```bash
dynast-bench score nextjs examples/findings.json --safe examples/findings-safe.json
dynast-bench coverage nextjs examples/endpoints.json --findings examples/findings.json
पूर्ण संदर्भ - फाइंडिंग स्कीमा, मैचिंग टियर, हर मेट्रिक:
dynast-bench/README.md।
make up # docker compose up the vuln/ variant (127.0.0.1 only), wait for health make reset # down -v && up → fresh, byte-identical state make safe # bring up the safe/ variant instead (for false-positive runs) make verify # run every ground-truth PoC; expect all PASS against vuln/ make score FINDINGS=f.json # grade a scanner's findings → P/R/F1 make diff # the vuln↔safe delta, cross-checked against the answer key make check # CI gate: schema · anchors · diff scope · PoCs · 127.0.0.1 binds
## ऐप्स
| ऐप | स्टैक | DB | अतिरिक्त सेवाएँ | डिज़ाइन दस्तावेज़ |
|------------|--------------------------------|------------|----------------------|------------|
| fastapi | Python / FastAPI + Jinja2 | Postgres | MinIO, Mailpit | [fastapi.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/fastapi.md) |
| golang | Go / chi | Postgres | Prometheus, Grafana | [golang.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/golang.md) |
| gin | Go / Gin | Postgres | chromium, ImageMagick (in-image) | [README](https://github.com/j3ssie/dynast-bench/blob/main/vulnerable-apps/gin/README.md) |
| nextjs | Node / Next.js 15 | Postgres | Redis, Mailpit | [nextjs.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/nextjs.md) |
| nestjs | Node / NestJS + Handlebars | Postgres | Redis, nginx | [nestjs.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/nestjs.md) |
| springboot | Java / Spring Boot + Thymeleaf | Postgres | Jenkins, Prometheus | [springboot.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/springboot.md) |
| rails | Ruby / Rails 7.2 | Postgres | MinIO, nginx | [rails.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/rails.md) |
| wordpress | PHP / WordPress + plugin | MySQL | nginx, Mailpit | [wordpress.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/wordpress.md) |
| php | PHP / procedural LAMP | MySQL | phpMyAdmin, Mailpit | [php.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/php.md) |
| jsp | Java / JSP + Servlets (Tomcat) | Postgres | Mailpit | [jsp.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/jsp.md) |
| aspnet | C# / ASP.NET Core Razor Pages | SQL Server | Mailpit | [aspnet.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/aspnet.md) |
साथ ही तीन **API-केवल** ऐप्स (GraphQL, WebSocket, Swagger/OpenAPI), एक
**नेटवर्क-रेंज** फ्लीट जो होस्ट/पोर्ट स्कैनर के लिए है, और दो **LLM** ऐप्स:
| ऐप | स्टैक | DB | अतिरिक्त सेवाएँ | डिज़ाइन दस्तावेज़ |
|------------|---------------------------------------------|-------------------|--------------------------------------|------------|
| llmchat | Python / FastAPI + LangChain (RAG chatbot) | Postgres+pgvector | Redis, Ollama, internal svc | [llmchat.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/llmchat.md) |
| llmagent | Node / Fastify + Vercel AI SDK + MCP (agent)| Postgres | Redis, Ollama, partner-MCP, internal svc | [llmagent.md](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/llmagent.md) |
दोनों LLM ऐप्स एक **स्थानीय मॉडल** चलाते हैं, जो केवल-आंतरिक Ollama कंटेनर
(`gemma3:1b` चैट के लिए, `qwen2.5:1.5b` टूल कॉलिंग के लिए) के माध्यम से चलता है - कोई API कुंजी नहीं, कोई egress नहीं,
कोई प्रति-रन लागत नहीं - और एक स्क्रिप्टेड `LLM_BACKEND=stub` बैकएंड के साथ आता है ताकि
ग्राउंड-ट्रुथ PoCs एक स्टोकेस्टिक मॉडल के बावजूद निर्धारणीय बने रहें।
साझा डोमेन मॉडल, OWASP-Top-10 कवरेज मैट्रिक्स, और बेंचमार्क-डिज़ाइन
सिद्धांतों (near-misses, taint distance, logic-only bugs) के लिए
[`benchmark-plans/README.md`](https://github.com/j3ssie/dynast-bench/blob/main/benchmark-plans/README.md) देखें।
## आरंभ करना```bash
make install # once: puts `dynast-bench` on your PATH
dynast-bench doctor # docker reachable? which ports are taken?
dynast-bench start fastapi # boots the vuln/ variant, waits for health
dynast-bench verify fastapi # sanity-check: every planted bug's PoC PASSes
# ...point your scanner/agent at $(dynast-bench target fastapi), collect findings.json...
dynast-bench start fastapi --variant safe # patched twin → measures false positives
dynast-bench reset fastapi # restore fresh, re-seeded state
dynast-bench clean --all --yes # give the disk back
या फिर किसी एक ऐप को सीधे उसके Makefile के साथ चलाएँ:```bash cd vulnerable-apps/fastapi make up # vuln/ variant on 127.0.0.1 make verify # every planted bug's PoC PASSes make safe # the patched twin make reset # fresh state
## स्थिति
- **19 ऐप्स में पूर्ण उत्तर कुंजी है**: 549 रोपित कमजोरियाँ, 146
निकट-चूक, 546 PoCs, और प्रत्येक में एक `Dockerfile.standalone` (`--solo`)।
`dynast-bench list` लाइव तालिका प्रिंट करता है।
- **`nextjs` संदर्भ कार्यान्वयन है** - अंत से अंत तक निर्मित और मान्य
(35 vulns + 15 निकट-चूक)। `make validate APP=nextjs` साबित करता है कि हर PoC
`vuln/` पर शोषण योग्य है और `safe/` पर ठीक है; `make solo APP=nextjs` इसे एक
इमेज से चलाता है। इसके पैटर्न कॉपी करें।
- **`dynast-bench` CLI - निर्मित**: किसी भी ऐप को चलाता, सत्यापित करता, स्कोर करता और साफ करता है,
compose या single-image मोड में, हार्नेस के लिए `--json` के साथ।
- **स्कोरर - निर्मित** (`dynast-bench/src/`): स्कैनर आउटपुट → सामान्यीकृत निष्कर्ष
→ precision/recall/F1, प्रति-कठिनाई recall, निकट-चूक पर एक भेदभाव स्कोर,
और अलग discovery (नेटवर्क) और injection-channel (LLM) ट्रैक।
- **एंडपॉइंट कवरेज - निर्मित**: प्रति ऐप एक `SURFACE.yaml` (~600 ऑपरेशन
पूरे फ्लीट में) यह ग्रेडिंग करता है कि एक रन वास्तव में ऐप के कितने हिस्से तक पहुँचा,
और हर चूक को "एंडपॉइंट कभी नहीं मिला" बनाम "मिला, बग चूक गया" में विभाजित करता है।
- सभी 19 उत्तर कुंजियों और सतह कैटलॉग पर प्रति-ऐप इनवेरिएंट
`make test` में चलते हैं; `dynast-bench check --all` CI गेट है।
## एक टूल को स्कोर करना```bash
dynast-bench start nextjs --json | jq -r .target # boot, get the URL
zap-baseline.py -t http://127.0.0.1:13311 -J zap.json # scan
dynast-bench score nextjs zap.json --full # grade it
# measure false positives properly: scan the patched twin too
dynast-bench start nextjs --variant safe
my-scanner --url http://127.0.0.1:13311 --out safe.json
dynast-bench score nextjs zap.json --safe safe.json
score एक findings/v1 फ़ाइल या मूल ZAP / SARIF / nuclei / Burp / nmap
आउटपुट पढ़ता है - प्रारूप का पता लगाया जाता है। यदि आप कोई टूल जोड़ रहे हैं तो examples/ से शुरू करें: examples/template-findings.json हर फ़ील्ड के साथ एक खाली स्केलेटन है, और examples/findings.json एक कार्यशील फ़ाइल है जिसे आप अभी स्कोर कर सकते हैं।
एंडपॉइंट खोज का मूल्यांकन अलग से किया जाता है, प्रत्येक ऐप के SURFACE.yaml के विरुद्ध:```bash
dynast-bench coverage nextjs endpoints.json --findings findings.json
यही चीज़ एक **डिस्कवरी मिस** (एंडपॉइंट तक कभी नहीं पहुँचा - क्रॉलर ठीक करें) को एक **एनालिसिस मिस** (उस तक पहुँचा, रिपोर्ट नहीं किया - स्कैनर ठीक करें) से अलग करती है।
स्कीमा, मैचिंग टियर और हर मीट्रिक के लिए [`dynast-bench/README.md`](https://github.com/j3ssie/dynast-bench/blob/main/dynast-bench/README.md#scoring) देखें।
### रिपोर्ट पढ़ना (`Leg │ Precision │ Recall │ F1`)
एक **leg** एक टारगेट स्टेट के विरुद्ध एक स्कैन रन है:
| Leg | यह क्या है |
|---|---|
| `blackbox` | कोई क्रेडेंशियल नहीं - अनऑथेंटिकेटेड अटैकर का दृश्य |
| `credentialed` | वही टारगेट जिसमें सीड किए गए लॉगिन इंजेक्ट किए गए हैं, ताकि ऑथेंटिकेटेड सरफेस (IDOR, प्रिविलेज एस्केलेशन) तक पहुँच संभव हो |
| `safe-twin` | पैच किया गया ट्विन (`--safe`), एक फॉल्स-पॉज़िटिव बेसलाइन - आदर्श रूप से कुछ भी नहीं खोजता |
तीनों `0.0`–`1.0` पर चलते हैं, और तीनों के लिए **अधिक बेहतर है** (`1.0` परफेक्ट है):
| मीट्रिक | फॉर्मूला | बेहतर | मतलब |
|---|---|---|---|
| **Precision** | `TP / (TP + FP)` | ↑ अधिक | रिपोर्ट की गई हर चीज़ में से, कितनी वास्तविक थी। `0.38` = ~38% फाइंडिंग्स असली थीं, बाकी शोर। उच्च = कम फॉल्स अलार्म। |
| **Recall** | `TP / (TP + FN)` | ↑ अधिक | वास्तव में लगाए गए बग्स में से, कितने मिले। `0.73` = 11 में से 8। उच्च = कम मिस। |
| **F1** | `2 × P × R / (P + R)` | ↑ अधिक | दोनों का हार्मोनिक माध्य - हेडलाइन "समग्र गुणवत्ता" संख्या। केवल तभी उच्च होता है जब दोनों उच्च हों, इसलिए यह शोरगुल वाले *और* बग मिस करने वाले दोनों को दंडित करता है। |
एक उलटफेर: **`safe-twin` leg पर खोजने के लिए कुछ भी वास्तविक नहीं है**, इसलिए
वहाँ हर फाइंडिंग एक फॉल्स अलार्म है - कम बेहतर है, और एक खाली रिपोर्ट
परफेक्ट स्कोर है।
## एंडपॉइंट कवरेज
Recall आपको बताता है कि एक टूल ने कितने बग खोजे। यह आपको नहीं बता सकता कि उसने बाकी को **क्यों** मिस किया - और दोनों कारणों को विपरीत फिक्स की आवश्यकता है:
| मिस | मतलब | क्या ठीक करें |
|---|---|---|
| **डिस्कवरी मिस** | बग ले जाने वाले एंडपॉइंट तक कभी नहीं पहुँचा | क्रॉलर |
| **एनालिसिस मिस** | एंडपॉइंट तक पहुँचा, बग रिपोर्ट नहीं किया | एनालिसिस |
इन्हें अलग करने के लिए एक दूसरे इनपुट की आवश्यकता है: वे एंडपॉइंट्स जो आपका टूल कहता है कि उसने खोजे।
वह `endpoints/v1` है, जिसे हर ऐप के `SURFACE.yaml` के विरुद्ध स्कोर किया जाता है।```bash
dynast-bench surface nextjs # the checklist a crawl is graded on
dynast-bench coverage nextjs endpoints.json # how much did it reach?
dynast-bench coverage nextjs endpoints.json --findings findings.json # ...and why not the rest
dynast-bench score nextjs findings.json --endpoints endpoints.json # both in one report
एक क्रॉलर जो HTML पढ़ता है और JS चलाता है लेकिन कभी भी बहु-चरणीय प्रवाह पूरा नहीं करता:``` operations 62.5% 25 of 40 detection 25.0% of the bugs on operations it reached misses: 11 never reached the operation · 18 reached it and did not report
static-html 6/6 100.0% js-static 5/5 100.0% js-runtime 11/19 57.9% interaction 3/5 60.0% flow 0/5 0.0%
टियर ब्रेकडाउन ही उपयोगी हिस्सा है: `static-html` पर 100% और `flow` पर 0% होना
एक डिस्कवरी समस्या है, स्कैनर समस्या नहीं, और ये दोनों एक ही रिकॉल नंबर में
समान रूप से पढ़े जाते हैं।
दो नियम नंबर को ईमानदार रखते हैं:
- **ट्रांसपोर्ट ऑपरेशन नहीं है।** एक `POST /graphql` उसके पीछे के 25
GraphQL ऑपरेशनों को नहीं चलाता; एक WebSocket हैंडशेक उसके
इवेंट्स को नहीं चलाता; एक `POST /api/runs` किसी एजेंट के टूल्स को नहीं चलाता। किसी URL तक पहुंचना
और वहां मौजूद चीज़ को चलाना अलग-अलग स्कोर किए जाते हैं।
- **गायब टेलीमेट्री कोई ट्रैक नहीं बनाती**, कभी `0%` नहीं। "हमने इसे मापा नहीं"
और "यह किसी चीज़ तक नहीं पहुंचा" एक टूल के बारे में विपरीत दावे हैं।
रिपोर्ट किए गए एंडपॉइंट जो किसी चीज़ से मेल नहीं खाते, प्रिसिज़न को नुकसान पहुंचाते हैं लेकिन कवरेज को कभी कम नहीं करते,
इसलिए वर्डलिस्ट स्प्रे करना उच्च स्कोर पाने का तरीका नहीं है। पूरा मॉडल:
[`dynast-bench/README.md#endpoint-coverage`](https://github.com/j3ssie/dynast-bench/blob/main/dynast-bench/README.md#endpoint-coverage)।
## लाइसेंस
`dynast-bench` को [@j3ssie](https://github.com/j3ssie) द्वारा ♥ के साथ बनाया गया है ताकि
**Vigolium** और **Gimora** (एक स्वायत्त आक्रामक-सुरक्षा एजेंट) को बेंचमार्क किया जा सके, और इसे
[MIT लाइसेंस](https://github.com/j3ssie/dynast-bench/blob/main/LICENSE) के तहत जारी किया गया है।
| llmagent | Node / Fastify + AI SDK + MCP | Postgres | 29 | 8 | plan |
| llmchat | Python / FastAPI + LangChain RAG | Postgres+pgvector | 30 | 9 | plan |
| nestjs | Node / NestJS + Handlebars | Postgres | 23 | 6 | plan |
| network | Simulated multi-host network range | mixed fleet | 32 | 5 | plan |
| nextjs | Node / Next.js 15 (reference impl) | Postgres | 35 | 15 | plan |
| php | PHP / procedural LAMP | MySQL | 21 | 5 | plan |
| rails | Ruby / Rails 7.2 | Postgres | 26 | 6 | plan |
| springboot | Java / Spring Boot + Thymeleaf | Postgres | 30 | 4 | plan |
| swagger | OpenAPI / Swagger UI + spec loading | Postgres | 19 | 5 | plan |
| websocket | Node 22 / ws + Socket.IO realtime | Postgres | 28 | 6 | plan |
| weirdproxy | nginx + Apache + Traefik over one origin | none | 16 | 4 | plan |
| wordpress | PHP / WordPress + custom plugin | MySQL | 28 | 6 | plan |
| 14 |
| Race conditions / TOCTOU | 362 | 14 | 14 |
| Open redirect | 601 | 14 | 14 |
| User & resource enumeration (observable response discrepancy) | 204, 598 | 13 | 12 |
| Code injection · SSTI · expression language | 94, 917, 1059, 1336 | 11 | 10 |
| Weak crypto & randomness · cleartext transport | 295, 319, 327, 330, 338 | 11 | 6 |
| Password reset + account recovery flaws | 184, 640 | 9 | 9 |
| Unrestricted / unsafe file upload | 434 | 9 | 9 |
| CSRF (incl. cross-site WebSocket hijacking) | 352 | 8 | 8 |
| Prompt injection & LLM tool abuse (direct · indirect · RAG) | 1427 | 7 | 2 |
| XXE / XML external entity | 611 | 5 | 5 |
| Supply chain & integrity (unsigned updates, vulnerable deps) | 494, 1035 | 2 | 2 |
| Insecure network exposure (binding, service misconfiguration) | 1327 | 2 | 1 |
| Insufficient logging / log injection | 117 | 1 | 1 |