orthrus - Automated vuln discovery & exploitation-confirmati

项目说明

Project ORTHRUS

Automated discovery & exploitation-confirmation framework for authorized security testing.

![Python]()
![Open in Colab]()

ORTHRUS crawls a target, fingerprints its stack, runs 70 scanners,
and then re-proves the interesting findings with a dedicated
exploitation-confirmation phase - so a report distinguishes "this looks
" (tentative) from "this was demonstrably exploited" (confirmed). It
produces JSON / CSV / HTML / PDF / SARIF / Markdown reports with CVSS v3.1 + v4.0
scoring and OWASP / CWE / PCI-DSS / NIST-CSF / MITRE ATT&CK mappings - and, optionally,
an AI-written consultant report (Markdown / HTML / PDF)
grounded strictly in those findings and their e.

Run a scan, then explore the results in the built-in dashboard (orthrus serve):

!ORTHRUS dashboard - a completed scan's findings, chipped by se, with confidence, type, URL and CWE, plus a link to the attack-surface graph

!ORTHRUS attack-surface graph - target → host → path → endpoint, force-laid-out from the scan's recon data

_{The dashboard shows findings by se/confidence/CWE, an interactive attack-surface graph (orthrus surface), and a Repeater for hands-on . Prefer the terminal? The full run renders there too:}

!Orthrus terminal output: the banner, the AUTHORIZED SCOPE panel, the scan summary, OWASP Top-10 co, and the colour-coded findings table

_{A real scan of the bundled, 127.0.0.1-only practice target. Regenerate this view from any JSON report with examples/render_report_ui.py.}

Try it in one command

📊 Proof it works on real targets: docs/PROOF.md records
reproducible li against an authorized range (D, an Oracle
WebLogic console matched to 7 CISA-KEV CVEs, unauthenticated Redis) plus the
1534-test / lint-clean quality gates.

🎯 Accuracy & methodology: docs/METHODOLOGY.md - how ORTHRUS
measures precision (not just recall): a CI-gated corpus of *and*
known-clean inputs (currently 0 false positives / 0 misses on 39 hard cases), the
confirmation-efficacy metric, and exactly where AI is and isn't in the loop (deterministic
code finds and proves; AI only explains and plans).

🎬 See it run: docs/DEMO.md - a 6-step walkthrough (scan →
attack-graph → runbook → patches → cloud posture → agent) with real output,
reproducible in one command via demo.sh.

📐 Full system spec: docs/PRD.md - the granular,
implemented-system PRD: every subsystem (70 scanners, 28 confirmers, 18 recon
modules), the data/config/scope/store models, the confirmation doctrine, and the
roadmap for ad scanners & methods.

🛡 Frontier-AI alignment: docs/GLASSWING_ALIGNMENT.md -
how ORTHRUS maps to Anthropic's Project Glasswing and Visa's open-source agentic
harness (VVAH): the S1-S11 co ledger, the 12 non-negotiable architectural
practices, deterministic P1-P4 exploitability prioritisation, and the MTTA roadmap.

> Status & positioning. ORTHRUS is an early (v0.1.0), acti
> project built as a deep, hands-on exploration of how a modern DAST pipeline
> fits together end to end. It's an *integrated framework* - recon → scan →
> exploitation-confirmation → correlation → reporting in one tool - meant to
> complement, not replace, mature and battle-tested tools like Burp Suite,
> OWASP ZAP, or nuclei. its findings, and expect rough edges. Bug reports,
> false-positi, and feedback are very welcome.

---

> ## ⚠️ Legal & Ethical Use - read before running anything
>
> **ORTHRUS is an offensi tool. It sends real attack payloads and, in
> its confirmation phase, actively attempts to exploit findings.**
>
> - ✅ Use it only against systems you own, or for which you hold
> explicit, written authorization to test (a signed engagement / scope
> document, bug-bounty program rules, or your own lab).
> - ❌ Scanning, exploiting, or accessing systems without permission is
> illegal in most jurisdictions (e.g. the U.S. CFAA, the UK Computer
> Misuse Act, the EU directive on attacks against information systems) and can
> result in criminal prosecution and ci.
> - 🧭 You are solely responsible for how you use this software and for
> staying within the bounds of your authorization and local law.
> - 🚫 The authors and contributors provide this tool as-is, with no warranty,
> and accept no liability for misuse or for any damage it causes.
>
> If you do not ha permission to test a target, **do not point ORTHRUS
> at it.** Use the bundled deliberately- practice target or a
> self-hosted lab instead (see Try it safely).
>
> As a guardrail, ORTHRUS is deny-by-default: every outbound request is
> against your declared engagement scope before it is sent, and the
> resol is printed at the start of every run. This is a safety aid, not
> a substitute for authorization. See Scope enforcement.

---

Table of contents

Features

How it works

Scope enforcement

Requirements

Installation

Run in VS Code or Google Colab

Quickstart

Try it safely

Usage guide

Configuration

Reporting

Production: PostgreSQL & distributed scanning

Architecture & project layout

Extending ORTHRUS (plugins)

De

Legal & Ethical Use

Contributing

License

---

✨ Features

Reconnaissance (18 modules)

Scope-aware web crawler, passi fingerprinting

Headless-browser (dynamic) crawl + SPA client-side route discovery - captures JS-rendered XHR/fetch endpoints

Parameter mining (Arjun-style hidden-parameter discovery)

Ja analysis (endpoint + secret extraction), source-map recovery (reco from leaked .map files), content discovery

robots.txt / sitemap.xml endpoint discovery (sitemap index + .gz) and /.well-known/ probing (security.txt, OpenID/OAuth config → auth endpoints)

Subdomain enumeration, DNS enumeration (+ AXFR attempt), WAF detection

REST/GraphQL API discovery, Wayback Machine historical URLs

Passi intelligence (re / ASN / geo / cloud attribution) + co-hosted host gathering

Nmap port scan (optional; needs the nmap binary)

scanners (67)

| Category | Scanners |
|---|---|
| Injection | SQLi (error / boolean / time-based, WAF-e), command injection, SSTI, LFI, XXE, NoSQL, LDAP, XPath / XQuery, CRLF / response splitting, HTTP request smuggling (CL.TE/TE.CL + CL.0 desync), CS injection |
| XSS | Reflected (content-type aware), DOM-based, stored (browser-), second-order / planted-payload registry (plant a canary in a writable field, correlate its later OOB detonation in a staff console or its reflection on another page back to the plant site - no browser needed), browser taint engine (instrumented source→sink: URL data reaching e/document.write = DOM XSS, location.assign/window.open = client-side redirect) |
| Access / logic | IDOR, multi-identity authorization matrix (BOLA/BFLA, Autorize-style --identities), pri forced-browse (unlinked admin routes via the identity lattice), CSRF, open redirect, race conditions, business-logic (parameter tampering / HPP), host-header injection (password-reset poisoning) |
| API (OWASP API Top 10) | Mass assignment / object-property injection |
| Auth / session | Auth-session analysis, default credentials, OTP/2FA (brute-force / rate-limit absence, client-trusted result tamper), rate-limit / abuse (missing throttling on login / reset / / bonus micro-bursts), account enumeration (login/register/reset existence oracles), JWT (alg:none, weak secret, jku/x5u/kid header attacks, RS->HS algorithm confusion JWKS), OAuth/OIDC flow misconfig (missing state/PKCE, implicit flow, redirect_uri takeover), SAML response inspection (unsigned assertion, signature-wrapping, NameID comment-truncation), session fixation (session id in the URL; ser an attacker-supplied session id without regenerating it) |
| Ser | SSRF (out-of-band + metadata), OS command injection (output / time / OOB-callback blind RCE), deserialization, prototype pollution (client- & ser) |
| Config / transport | Security headers, CSP weakness analysis, mixed-content / insecure-transport refs, CORS, TLS analysis, exposed files, directory-listing / autoindex, cache poisoning, web cache deception, framework debug-exposure, unrestricted file upload, subdomain takeover, internal-IP exposure (public host resolving to RFC1918 / loopback / CGNAT / cloud-metadata), origin-IP exposure (CDN bypass: in-scope host on a non-Cloudflare/Fastly/CloudFront IP while the app is CDN-fronted), HTTP misconfig (TRACE/XST, dangerous methods), email-auth posture (SPF / DMARC / DKIM: missing or monitor-only policy = spoofable domain, the phishing / BEC enabler) |
| Protocol / API | GraphQL (introspection, field-suggestion leakage, query batching + alias-o + circular-fragment DoS, debug/stack-trace disclosure, argument injection - introspect the schema, then fuzz mutation/query arguments for SQLi / OS-command / SSTI - D), WebSocket, gRPC ser exposure, shadow / improper-in API (API9) |
| Secrets | Exposed-secret scanner - AWS/Google/Slack/Stripe/GitHub keys + pri blocks in responses/JS (redacted) |
| Supply chain | SCA - known- JS libraries (retire.js-style), Subresource Integrity - third-party <script>/<link> loaded without an integrity= hash (the CDN-compromise / Magecart ) |
| Templates | Declarati YAML/JSON template engine (--templates) |
| Intelligence | C ( → known-CVE) plus product fingerprinting (WebLogic, Confluence, Jenkins, Solr → known-exploited CVEs), all enriched with CISA KEV + EPSS (orthrus update) |
| AI / LLM | Prompt injection + system-prompt / sensiti disclosure (OWASP LLM Top 10) |
| Services / infra | Unauthenticated service exposure (Redis, Memcached) protocol probes |

Acti scanners share a WAF-e encoder library (URL / double-URL /
mixed-case / comment-spacing / HTML-entity / unicode); transport-sur
are tried automatically under --aggressive.

Exploitation confirmation (18 modules) - re-pro to upgrade their
confidence to confirmed:

Injection - SQLi, command injection, SSTI, LFI, XXE, NoSQL (dri replay)

XSS - browser-executed by default when Playwright is present (window-flag/dialog + screenshot)

Redirect / headers - open redirect, CRLF / response splitting (fresh-nonce header survives), host-header injection (a freshly-forged attacker host re-reflected into links/redirects)

Access / objects - IDOR (sequential object enumeration reproduced: adjacent IDs resolve, an implausible ID does not), mass assignment (a fresh per-field nonce re-bound into the response object)

Cross-origin / tokens - CORS (arbitrary-origin reflection re-proven with a freshly-minted attacker origin), JWT (a weak HMAC secret is recovered and used to forge a token - the secret is ne)

JS-runtime / DoS - ser prototype pollution (a fresh __proto__ sentinel re-persists onto a new object via a clean-before/polluted-after differential), GraphQL DoS (query-batching and alias-o amplification re-issued and re-observed)

Out-of-band - SSRF (collaborator callback)

Confirmation works on query-string and POST/JSON body parameters and runs
concurrently (bounded by concurrency) so WAN round-trips o instead of
summing.

It deliberately covers the *acti* classes. Findings already
definitively proven by obser (missing security headers, deprecated TLS,
known-C exposure, banner disclosure, exposed services, request
smuggling, GraphQL introspection) ship as firm/confirmed from detection
itself. A few classes are intentionally detection-only because no *safe*,
generic automated exploit exists - most notably insecure deserialization
(a passi signature; proving RCE needs a target-specific gadget
chain) - so ORTHRUS reports them rather than in a misleading confirmation.

Reporting

Formats: JSON, CSV, HTML, PDF, SARIF, Markdown, MITRE ATT&CK Na layer

Templates: executive, technical, compliance

CVSS v3.1 + v4.0 scoring; OWASP Top 10 / CWE / PCI-DSS / NIST-CSF / MITRE ATT&CK mappings

Se filtering, logo branding, embedded screenshots & raw request/response e

Platform

Async core (httpx, HTTP/2), per-host token-bucket rate limiting, User-Agent rotation

Headless-browser engine (Playwright/Chromium) for DOM/stored XSS & JS-rendered crawling

Out-of-band callback server (local listener) for blind SSRF/RCE detection

Pluggable scanner/exploit/recon/reporter modules auto-discovered at startup

SQLite (dev) or PostgreSQL (+ Alembic migrations); optional distributed scanning /Redis

OpSec: AES-256-GCM e encryption, operator audit log, HAR export

Platform & integrations

REST API (orthrus serve, FastAPI) with auto Swagger docs at /docs, plus a served web dashboard

MCP server (orthrus mcp) exposing scans/findings as tools for AI agents

External-tool orchestration (--tools nuclei) - runs best-of-breed CLIs and normalizes their output into ORTHRUS findings

IaC misconfiguration audit (orthrus iac) - Dockerfile / docker-compose / Terraform, fully offline

v2.0 operator platform (a persistent, program-anchored layer over the scan engine)

Operator graph - programs -> assets -> endpoints -> deduped findings persist across scans, with a hash-chained audit log and cost ledger

Continuous recon (orthrus recon-run / recon-watch) - crt.sh/certspotter/DNS/wayback (+ subfinder/amass), wildcard-DNS detection, new-asset diff, Slack/Discord alerts

Scan -> graph (orthrus program-scan) promotes findings into a cross-tool-deduped, priority-ranked triage queue (orthrus program-findings)

Traffic bridge (orthrus import-traffic) folds a Burp / Caido / HAR proxy history into the graph (deny-by-default on import); orthrus plan suggests the grounded next steps

Grounded copilot + tagged notes over your own program data (cites, ne); multi-domain adapters (--tools slither,checko)

Team mode (orthrus team) - per-program roles (owner/member/) + per-user API keys; cockpit (React/Tauri) and a Postgres deploy (docker/docker-compose.operator.yml). Full guide: docs/BUG_BOUNTY.md

🔁 How it works

ORTHRUS runs a four-phase pipeline. Every network request - in every phase - goes
through the scope-enforced HTTP client.

1. Recon - disco, endpoints, parameters, and technology.
2. Scan - run the selected scanners against discovered injection points;
emit findings with a confidence of tentative/firm.
3. Exploit / Confirm - re-issue a controlled payload (and, for XSS, execute
it in a real browser; for SSRF, await an out-of-band callback) to upgrade
pro to confirmed.
4. Report - render the findings (with CVSS, compliance mappings, and
e) to your chosen format.

🛡️ Scope enforcement (the safety boundary)

orthrus.utils.scope.Scope is the load-bearing safety control. It is
deny-by-default: a host / port / path is only contacted if your
ScopeConfig explicitly authorizes it. orthrus.core.http_client.HttpClient
consults it before every request and re- every redirect hop, and
the headless browser is bound by the same check. Scanner modules must use
HttpClient rather than raw httpx, so the boundary cannot be bypassed.

The resol is printed at the start of every run so you can confirm the
engagement boundary before any traffic leaves your machine:

--scope auto derives a minimal scope from the target host; **real engagements
should always pass an explicit --scope.**

📋 Requirements

Python 3.11+ (de on 3.14, Windows 11)

The "lean core" dependencies are pure-Python / wheels and install on Windows

with no external binaries. Heavier integrations are opt-in extras.

📦 Installation

Optional dependency groups:

Or skip the clone - run the published container image or a standalone binary:

Prebuilt binaries for Linux / macOS / Windows and the container image are attached
to each GitHub release.

> The jwt and tls scanners need [scanners]; dom-xss / stored-xss
> and XSS confirmation need [browser] + playwright install chromium. Each
> module self-disables cleanly if its extra is missing - the lean core still runs
> e else.

💻 Run in VS Code or Google Colab

Prefer a guided, copy-paste setup? Two detailed step-by-step walkthroughs live in
docs/USAGE_.md:

VS Code - setup, recommended extensions, running the

bundled practice target, breakpoint debugging (launch.json), and the
test/lint workflow.

Google Colab - zero local install, all in the browser. Open the

ready-to-run notebook and choose Runtime → Run all:
![Open in Colab]()

🚀 Quickstart

🧪 Try it safely

Do not learn the tool on someone else's systems. Use one of these authorized
targets:

Bundled practice target. This repo ships a deliberately- app at

tests/integration/reflecting_target.py that exercises every scanner locally:

Self-hosted labs (you own the instance): OWASP Juice Shop, DVWA, OWASP

WebGoat, bWAPP, OWASP Mutillidae II.

public test sites that explicitly permit scanning:

testphp..com, testasp..com, rest..com (Acunetix),
demo.testfire.net (IBM), ginandjuice.shop (PortSwigger).

> ⚠️ Public exploit/C (e.g. Exploit-DB) catalog **,
> not authorized targets. Ne ORTHRUS at a li you found
> listed somewhere; that is unauthorized access.

📖 Usage guide

ORTHRUS's core sub-commands are recon, scan, exploit, and report, plus
post-scan analysis and delivery: findings (terminal triage view), triage
(dedup/cluster + optional LLM false-positi), chains / graph
(correlate findings into attack paths / maximal kill-chains), runbook
(consolidated remediation plan, ordered so the highest-le fix - one that
breaks an attack path - comes first), finding (set a finding's status/owner),
notify (push high-se findings to Slack / Jira, with --dry-run),
patch (generate concrete config/code remediation patches per finding), and
ai-report (a Big-Four-grade consultant report - deterministic e + AI
narrative, via a local or any market LLM).
Autonomous & posture: agent (a bounded LLM planner that sequences the existing
scope-enforced, non-destructi - no shells, no arbitrary code), cloud
(read-only CSPM/IAM posture + toxic-combination analysis), and proxy (a
scope-aware capturing proxy that feeds the scanner from a manual browse).
Utility commands: doctor (en readiness), modules (module in),
diff (compare two scans), scans (list past scans), benchmark
(detection-accuracy harness), update (refresh CISA-KE), serve (REST
API + dashboard), mcp (MCP server for AI agents), iac (Infrastructure-as-Code
audit), and completion (shell completion). Run orthrus --help for the full
list.

orthrus scan - the full pipeline

Common scan options: --modules, --aggressive, --rate-limit,
--crawl-depth, --max-pages, --timeout, --proxy, --auth-cookie,
--user-agent, --callback, --no-exploit, --browser/--no-browser,
--exclude-paths, --headers, --threads, --scan-id, -o/--output,
--format, --template, --min-se, --logo, --har, -.

Full end-to-end scan of a site you own (recommended workflow)

orthrus scan runs all four phases - recon → scan → exploit-confirm → report - in
a single command, and writes the report when you pass -o + --format. With the
[browser] extra installed, DOM/stored-XSS and JS-rendered crawling are included
automatically. A safe, li flow for **a site you own or are
explicitly authorized to test**:

Tune it for your target:

Deeper testing (more load - use deliberately, ideally on staging): add

--aggressive for time-based blind SQLi/command tests and race-condition probes.

Authenticated areas: add --auth-cookie "session=…; csrf=…" (copy a logged-in

cookie from your browser's de), or drive a login with --login-url and the
related flags (orthrus scan --help).

Watch every request: route through Burp/ZAP with --proxy .

Gate CI: add --fail-on high to exit non-zero when a high-or-worse finding appears.

> Only scan hosts you own or hold written authorization for, and keep
> --scope tight (deny-by-default - only listed hosts are contacted). On shared
> hosting, check your provider's policy before acti.

orthrus recon - reconnaissance only

orthrus report - render an existing scan

orthrus exploit

> Note: confirmation runs automatically during orthrus scan. Standalone
> replay-from-DB is not yet implemented - re-run the scan to (re-)confirm.

orthrus bounty - authorized bug-bounty engagements

Runs a whole engagement from a program's authorized scope: enumerate in-scope
subdomains, scan every asset, confirm what it can, and write submission-ready
reports shaped for the target platform. It is deny-by-default and refuses a public
scope with no authorization, or a high-sensitivity host (gov/mil/edu/health)
without explicit attestation.

Program-anchored, so it carries cross-run intelligence: new in-scope assets
since the last run are flagged, bugs you reported before are marked as likely
duplicates, and per-program mute rules drop known noise. Companion
commands cover the rest of the workflow - program-policy, bounty-assets,
suppress/suppressions, submission/submissions, note/notes, copilot
(RAG over your own data), cost, audit, bounty-report (re-render without
re-scanning), and bounty-status (one-view cockpit). Optional external tools
fold in via --tools, spanning web (nuclei / dalfox / testssl / ffuf / nikto /
wpscan), code (semgrep), cloud & IaC (checkov), web3 (slither), and mobile (mobsfscan) - each
self-skips if its binary is absent. Full guide:
docs/BUG_BOUNTY.md.

⚙️ Configuration

Runtime settings are read from en (prefix ORTHRUS_) or a
.env file. None are required for a basic SQLite run.

| | Purpose | Default |
|---|---|---|
| ORTHRUS_DB_URL | Database URL (SQLite or PostgreSQL) | sqlite+aiosqlite:///./orthrus.sqlite3 |
| ORTHRUS_DATA_DIR | Screenshots / scan artifacts directory | ./scan_data |
| ORTHRUS_LOG_LEVEL | Default log level | info |
| ORTHRUS_ENCRYPTION_KEY | base64 AES-256 key; encrypts sensiti at rest | _(off)_ |
| ORTHRUS_REDIS_URL | Celery broker/backend (distributed mode) | redis://localhost:6379/0 |
| ORTHRUS_PLUGINS_DIR | External plugin directory auto-loaded at startup | _(none)_ |
| ORTHRUS_SHODAN_API_KEY, ORTHRUS_CENSYS_API_ID/_SECRET, ORTHRUS_, ORTHRUS_N, ORTHRUS_GITHUB_TOKEN | Optional passi / C credentials | _(none)_ |

📑 Reporting

JSON - full structured output (every field, e, exploitation results).

CSV - one row per finding (se, confidence, CVSS, type, URL, parameter,

param location, CWE, OWASP) for spreadsheets/triage.

HTML - styled report; technical includes raw request/response e and

screenshots, executive is a summary, compliance emphasises framework mappings.

PDF - the HTML report rendered to PDF Chromium (needs [browser]).

SARIF - Static Analysis Results Interchange Format for CI / code-scanning

dashboards (e.g. GitHub code scanning); pair with --fail-on to gate a pipeline.

Markdown - portable plain-text report for tickets, pull requests, and wikis.

ATT&CK Na (--format na) - a MITRE ATT&CK Na layer JSON,

heat-mapped by finding count; drop it into
mitre-attack.github.io/attack-na
to see the scan on the ATT&CK matrix.

🌟 AI consultant report (orthrus ai-report)

Turn a scan into a Big-Four-grade penetration-test deli: every finding,
C, and recorded request/response is rendered **, and a language
model writes the consultant narrati those facts - executi,
per-finding technical description / business impact / likelihood / exploitation
walkthrough / remediation, correlated attack-chain stories, and a phased
remediation roadmap. Because the findings are fixed and the e is quoted,
the model cannot hallucinate a - it explains and contextualises
only what the scanner already proved.

Native PDF / HTML, not Markdown. --format html|pdf renders a styled,
paginated Big-Four document (cover, classification banner, document-control table,
se finding tables); PDF reuses the headless-Chromium pipeline. Markdown
(--format md, default) stays a for diffing and pipelines.

Deduplicated like a consultant would write it. Findings that share a root
cause - e.g. reflected XSS across se, or a cookie missing a flag on
four responses - collapse into one finding with an *affected-instances* table
listing every endpoint/parameter, instead of se entries
(--no-group to keep them separate). Inherited default C are reconciled
against each finding's own se, so a low-se sub-finding ne a
critical score.

Model-agnostic: Claude, OpenAI, any OpenAI-compatible endpoint (Azure, Groq,
OpenRouter, vLLM, LM Studio - via ORTHRUS_LLM_BASE_URL), or a local Ollama
model so sensiti ne your infrastructure. Credentials and
cookies in captured e are redacted before anything is sent to a remote
model. The narrative is AI-generated and grounded in the recorded e -
review before client delivery. Slow or cold-starting hosted models can be given
more headroom with ORTHRUS_LLM_TIMEOUT (seconds per call; default 180).

See samples/ for a full report generated this way against the
bundled test target (HTML, PDF, JSON, and SARIF).

Every finding carries CVSS v3.1 + v4.0 /scores and is mapped to OWASP Top
10, CWE, PCI-DSS, NIST-CSF, MITRE ATT&CK (structured technique IDs), and
MITRE D3FEND countermeasures. The per-vuln ATT&CK technique selection was
informed by the Anthropic-Cybersecurity-Skills
catalogue (Apache-2.0); the IDs are public MITRE facts.

Share the terminal view. examples/render_report_ui.py renders any JSON
report into the themed terminal UI (banner, scope panel, summary, OWASP co,
findings table) and exports an SVG + HTML frame (and a PNG when the
[browser] extra is installed) - useful for docs, slides, and tickets:

🏭 Production: PostgreSQL & distributed scanning

> Distributed out-of-band detection needs a shared, externally-reachable callback
> server (e.g. Interactsh); the built-in local listener only ser targets.

🧱 Architecture & project layout

🔌 Extending ORTHRUS (plugins)

Scanners, exploits, recon modules, and reporters are auto-discovered via
decorators. Drop a module that subclasses the relevant base class and registers
itself into ORTHRUS_PLUGINS_DIR (or the in-tree package) and it joins the
pipeline - no core changes needed. A new scanner is roughly:

🧰 De

The suite is offline and deterministic (unit tests + a bundled target);
it does not touch the network or any external host.

⚖️ Legal & Ethical Use

This software is provided for **authorized security testing, education, and
research only.**

Only use ORTHRUS against systems you own or are **explicitly authorized in

writing** to test. Keep a copy of that authorization.

Define an accurate --scope and respect it. Scope enforcement is a safety aid,

not legal cover.

Running acti/exploits against systems without permission may

computer-misuse laws (CFAA, UK CMA, EU 2013/40, and equi) and can lead to
criminal and ci.

The software is provided "AS IS", without warranty of any kind. The authors

and contributors are not liable for any misuse, damage, data loss, or legal
consequence arising from its use.

By using ORTHRUS you accept full responsibility for your actions and confirm you

have the authorization required for every target you test.

If in doubt, don't. Practice on the bundled target or a self-hosted lab.

📚 Documentation

| Doc | What it covers |
|---|---|
| docs/CLI.md | Full CLI reference - every command and flag (auto-generated). |
| docs/BUG_BOUNTY.md | Bug-bounty mode (orthrus bounty) - scan an authorized program's scope, confirm, and write submission-ready reports. |
| docs/COMPARISON.md | Honest comparison vs ZAP, Nuclei, Burp, w3af, Wapiti, StackHawk - including where ORTHRUS *loses*. |
| docs/WRITING_A_SCANNER.md | "Your first scanner in 15 minutes" - build a Log4Shell detector from empty file to merged PR. |
| docs/ROADMAP.md | Sequenced roadmap of upcoming technical + adoption work. |
| samples/ | Real reports from a scan of the bundled target (HTML/PDF/JSON/SARIF). |
| docs/PRD.md · docs/PROOF.md | Product spec and proof-of-work. |

🤝 Contributing

Issues and pull requests are welcome - see CONTRIBUTING.md
for de, the quality gates (ruff check orthrus tests + pytest -q), and
docs/WRITING_A_SCANNER.md for a full walkthrough of
adding a scanner. Keep changes scope-safe (all network access goes through the
scope-enforced HttpClient) and add tests for new detectors. A one-click dev
en is a via the bundled .de (VS Code / GitHub Codespaces).

Found a security issue in ORTHRUS itself? Please follow the responsible-disclosure
process in SECURITY.md rather than opening a public issue.

💼 Commercial support

ORTHRUS is MIT-licensed and free to use. Commercial support - priority help,
custom scanner de, or a managed/hosted deployment - is on the roadmap; the
paid layer and its terms are still being defined.

> ⚑ your call: decide the model (hosted scan-as-a-service · managed instance ·
> priority support/SLA · custom scanner de) and drop a contact link here
> (email or a Cal.com booking). Stating a commercial path - e it fully
> exists - is what lets enterprise users adopt an open-source tool. See
> docs/ROADMAP.md (item A15). The TRADEMARKS.md
> policy keeps the *name* protected while the code stays MIT.

📄 License

MIT © 2026 Ankit Jha. See the additional authorized-use notice in
the LICENSE file and the Legal & Ethical Use section above.

项目信息

开发语言：Python

Star 数：11

技术要点

该项目属于安全软件方向的开源资源，代码结构清晰，适合安全研究人员学习参考。项目围绕Automated vuln discovery & exploitation-confirmation DAST for authorized testing. 70 scanners (web/API/LLM/auth-flow, incl. GraphQL-aware & second-order injection), 28 confirmers, attack-graph chain synthesis, AI consultant reports, cloud CSPM/IAM, bounded LLM agent, proxy + Repeater; CVSS/OWASP/KEV/EPSS; API + dashboard + MCP. pip/Docker/binaries.展开，提供了可运行的实现，对理解相关安全机制、工具原理与攻防技术具有较高的研究价值。

从技术实现角度看，此类项目的核心在于对底层原理的深入理解与工程化落地。开发者在研究过程中可以结合官方文档与社区讨论，梳理项目的初始化流程、核心模块职责与数据流转，逐步掌握其中的技术细节与设计思路。

使用与学习建议

1. 下载源码压缩包，解压到本地环境。

2. 根据项目类型准备对应的运行环境与依赖。

3. 按照 README 中的步骤完成配置与部署。

4. 在隔离的测试环境中运行验证，避免影响生产系统。

免责声明

本资源来源于开源社区，仅供安全研究、技术学习与合法授权范围内的攻防演练使用，请勿用于任何非法或侵害他人权益的用途。使用本项目产生的一切后果由使用者自行承担。