EasyHunt-AI
Allows the server to query a Neo4j graph database for infrastructure relationships, enabling cloud attack path analysis and reachability assessment between internet-facing entry points and valuable resources.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@EasyHunt-AI run a nuclei scan on our staging server"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
An agentic VAPT orchestrator where the control plane — not the model — is the security boundary.
Authorized testing only. Owned assets, an in-scope bug bounty program, or org
assets with documented written approval. The scope.yaml you write is the
authorization boundary, and the server refuses every request that falls outside
it. This tool will not help you test something you have no permission to test.
The one-paragraph version
Most AI security tools give a model a shell and a system prompt telling it to behave. Cordon gives the model no shell at all. Every capability is an MCP tool that passes through a fixed sequence — scope, sanitize, budget, rate-limit, approval, sandbox, parse, audit — enforced in code, server-side, with no path that skips a step. The model supplies strategy. The control plane decides what is permitted. A jailbroken prompt cannot reach the network.
Related MCP server: aegis
The whole system in one picture
Every call descends from L5 to L2 and crosses L3. There is no code path that routes around it — not a wrapper, not a chained validator, not the unattended pipeline.
One tool call, end to end
The engagement pipeline — each phase feeds the next
Why this is not another scanner wrapper
Six design decisions, each of which came from something breaking in production.
1. Absence is not a clean result
This is the whole thing. A killed scan, a tool that could not write its config, and a genuinely secure target all produce zero findings — and zero findings reads as good news.
flowchart LR
A[nuclei exits 0] --> B{why?}
B --> C[tested 13,391 templates<br/>found nothing]
B --> D[could not write its config<br/>tested NOTHING]
C --> E["findings: 0 ✓"]
D --> E
style D fill:#7f1d1d,color:#fff
style E fill:#78350f,color:#fffBoth branches used to print the same result. Every wrapper now distinguishes tested and clean from not tested, and says which in words:
"zero findings here means UNTESTED, not clean."
Twenty-five instances of this defect have been found and fixed in this codebase
— including nuclei exiting 0 while unable to create its config directory,
and a command-injection tool that discarded its own target flag for the
project's entire life and reported "no injectable parameter" every time.
2. The scope file is an authorization record, not configuration
scope.yaml is transcribed by hand from the program's published policy. The
installer refuses to create one for you — it used to copy a template that
declared authorization: bug-bounty and a fetched_at date nobody had earned,
and three separate green ticks then confirmed it.
An absent scope is a correct state. A fabricated one is not.
3. Rate limits come from the program, never from a literal
The limiter charges per request, not per tool call — so a scanner with its
own thread pool cannot out-run the published ceiling while the audit log shows
one compliant call. Every rate flag is derived from scope.rules, then clamped
to what the binary actually accepts.
4. Tools are resolved by identity, not by PATH order
pip install nuclei gets you a 2018 Kaggle package. slither on PyPI is a
children's Scratch-for-Python toy. Kali's medusa is a password brute-forcer;
ours is a fuzzer. Cordon executes each candidate and keeps the one that
identifies itself — and never "fixes" a collision by uninstalling your software.
5. Health checks run where the tool runs
cordon doctor executes every tool inside the container it will actually
run in, under the real read-only root and dropped capabilities. Checking the
host copy answers a question about a different program — that is how tools
shipped broken for days behind a green tick.
6. No PoC, no finding
Finding.confirm() requires reproduction steps and an observed result. AI
triage may rank, downgrade and drop; a taskflow that declares a confirm
verdict is rejected at load time. Scanner output is a candidate, permanently,
until a human or a validator proves it.
Quick start
git clone https://github.com/iamsecure1920/Cordon-AI.git && cd Cordon-AI
./bootstrap.shThat is the whole install. bootstrap.sh is idempotent and is also the repair
path: system packages, Go and Python runtimes, Docker enabled at boot, the
Cordon package, the tool suite, the cordon:latest image, the per-tool
images, then cordon doctor.
Budget 30–45 minutes for a first run. Needs ~15 GB free and Python ≥ 3.11.
Flag | Effect |
| skip the image build (≈46 tools then run on the host) |
| skip images entirely — no container isolation |
| package only |
cordon:latest is built from this repo's Dockerfile and is not on any
registry, so docker pull cannot find it. bootstrap.sh builds it, or:
docker build -t cordon:latest .
Then, before anything touches a network
cp scope.example.yaml scope.yaml
$EDITOR scope.yaml # transcribe the program's published policy
cordon scope validate
cordon doctor # expect 0 brokenIn any MCP-capable AI agent CLI: /cordon, or cordon connect prints the
exact registration for Claude Code, Cursor, Windsurf, Gemini CLI, Copilot, or
any stdio client.
Running an engagement
# Unattended, all phases, gated
./scripts/hunt.sh target.example.com
# Several targets
./scripts/hunt.sh a.example.com b.example.com
# Pick phases, or resume
./scripts/hunt.sh target.example.com --only probe,scan
./scripts/hunt.sh target.example.com --from scan
# Exploitation — refused unless scope.yaml permits it. Chains the validators
# over the injection points the earlier phases discovered.
./scripts/hunt.sh target.example.com --exploitEach phase appends to status.jsonl so a human or a model can watch without
touching the run:
{"phase":"probe","state":"ok","tool":"http_probe","seconds":4.1,"produced":248,"findings":0}
{"phase":"cors","state":"failed","tool":"cors_audit","message":"killed at the timeout — UNTESTED, not clean"}Phase-sliced MCP servers
One MCP server per engagement phase. Each exposes only that phase's tools plus
the shared control surface — scope_check, job_status, job_list/
job_fetch/job_cancel, fetch_slice, the task graph, brain recall/state,
cordon_status, cordon_capabilities, audit_tail, rules_list — so an
agent does not page through 101 tools to do recon:
Server | Surface |
| subdomain enum, DNS, CDN, TLS, whois, ASN |
| liveness, tech fingerprint, WAF/CORS posture, |
| gau/waybackurls/katana crawling, arjun/paramspider params, content discovery, JS analysis |
| nuclei, jaeles, ports, services, general scanners |
| every injection validator + the auto-chain |
| engagements, resumable pipeline, findings, reports |
Slicing happens at registration time only — every tool still runs through the identical scope → sanitize → budget → rate → approval → audit chain.
Running it inside any AI agent CLI
Cordon speaks MCP stdio, which Claude Code, Cursor, Windsurf, Gemini CLI,
GitHub Copilot and any other MCP client already understand. Pick the agent and
the phase, and cordon connect prints the exact registration (or runs it for
CLIs that support one-line registration):
# The agent you use is auto-detected; prints the registration for it
cordon connect --phase recon
# Or target one explicitly; Cursor/Windsurf/Gemini/Copilot print the config
# JSON for their mcp.json, Claude Code registers directly
cordon connect --agent claude --phase probe
cordon connect --agent cursor --phase scan --print-only
cordon connect --agent generic # raw stdio command for any MCP clientEvery tool it drives
101 MCP tools over 83 catalogued binaries.
· passive · ! aggressive · !! exploit — the mode decides whether a human is consulted.
Category | Binaries |
Recon |
|
HTTP / TLS |
|
Content & params |
|
Scanning |
|
Exploitation |
|
Takeover |
|
Secrets |
|
Cloud |
|
Smart contracts |
|
LLM security |
|
Run cordon doctor for the live picture, and see
USERMANUAL.md for every MCP tool
grouped by phase.
Documentation
Read this | For |
The invariants. Loaded automatically by the Claude CLI; read it first. | |
The complete reference — install, configuration, API keys, architecture, how the modules interlink, running an engagement, troubleshooting. | |
Every binary: flags, when to reach for it, what it costs. | |
Picking the project up cold: what exists, what is measured, what is left to build. | |
Architecture, bootstrap, payload store, per-class techniques. |
Development
.venv/bin/python -m pytest tests/ -q # 2,268 tests
.venv/bin/ruff check cordon/ tests/
cordon doctor # executed, not just found on PATHNearly every test in the suite exists because something broke against a live target. That is the working loop: run it against something real, distrust every clean result, verify hits by hand, fix the class rather than the instance, encode the bug in a test, then re-measure.
License
See LICENSE. Third-party tools retain their own licenses — several are
AGPL-3.0, and nmap ships under a custom non-OSI license. cordon doctor
prints the license of every tool it finds.
Available Tools
127 toolsaccount_registerAccount RegisterA
[AGGRESSIVE — requires human approval] Create a test account and register the resulting session.
This is the one action in the authenticated toolchain that creates state
rather than reading it, so it is refused unless the program said it may
happen: rules.allow_self_registration in scope.yaml, which is
transcribed from the program's published policy and defaults to false.
signup_url is the form's action (where the signup POST goes).
username_field/password_field/email_field name the form fields.
Credentials default to generated values; pass them to register a specific
account. The session that comes back (cookies + headers) is registered
under name so authz_compare can use it immediately.
The response is masked; the generated credentials are returned once so the operator can store them, and never logged.
Inputs: host (required), signup_url (required), password_field (required), username_field (required), +6 more. Returns: object
approval_pendingApproval PendingBRead-only
List aggressive actions parked awaiting human approval.
Inputs: no named parameters. Returns: object
approval_respondApproval RespondA
Relay a HUMAN decision on a parked approval. Do not call this on your own initiative — only when a person has told you their decision.
Inputs: token (required), decision (required), note. Returns: object
asn_lookupAsn LookupARead-only
Look up ASN and netblocks for a domain or organization.
Netblocks are returned for context only — an ASN belonging to the target does not put its ranges in scope. Check anything you find with scope_check before touching it.
Inputs: target (required). Returns: object
audit_tailAudit TailBRead-only
Recent audit records, including refusals. The engagement's evidence trail.
Inputs: count. Returns: object
auth_crawlAuth CrawlA
[AGGRESSIVE — requires human approval] Crawl an application as a registered session and map what is behind the login.
session names a session from session_register; it is only sent to the
host it was issued for.
Before crawling, the entry point is fetched with and without the session. If the two responses are identical the session authenticates nothing, and the crawl is refused — a list of public pages labelled "authenticated surface" would poison every conclusion drawn from it.
When a page turns out to be a single-page-app shell, its same-origin script
bundles are fetched and mined for paths — API literals, request call sites,
and the route table. Those become crawl seeds under the same guards as a
link, and are counted separately in coverage so it is visible how much
of the map a link crawler alone would have missed. max_bundles bounds
the extra requests.
Returns the discovered URLs, the forms found (read-only ones submitted with
empty values, state-changing ones reported and never touched), and — the
useful part — the URLs carrying an object reference, which is what
authz_compare must be pointed at. A URL with no identifier in it belongs
to everyone and proves nothing about access control.
Inputs: target (required), session (required), timeout, max_depth, +4 more. Returns: object
auth_surfaceAuth SurfaceARead-only
Detect authentication functionality and rank hosts by account-worthiness.
target takes one host or a comma-separated list — normally the live
URLs http_probe found, which is how scripts/hunt.sh chains it. Targets
are scope-checked before this body runs, so the list cannot be widened here.
Every request is a GET against a conventional path. Nothing is submitted,
no account is created, and no credential is sent. The output is a
recommendation to a human: register on these hosts, by hand, if the
program's rules permit it — then bring the sessions back with
session_register and authz_compare can finally test authorization.
Inputs: target (required), timeout, max_hosts. Returns: object
authz_compareAuthz CompareADestructive
[EXPLOIT — requires human approval] Fetch one URL as two identities and report whether the server told them apart.
The core authorization test. If A can read A's resource and B can read it too, the server is not checking ownership — that is an IDOR. If B is refused, it is.
Restricted to GET and HEAD on purpose. Proving broken access control never requires writing: reading another user's record is the proof, and writing to it modifies data that is not yours, which every program in this space forbids outright.
Reports a CANDIDATE, never a confirmed finding. Two identical responses can also mean the resource is public, or that neither session is actually authenticated. The result says which checks would settle it.
Inputs: target (required), session_a (required), session_b (required), method. Returns: object
bbot_scanBbot ScanARead-only
Map attack surface with BBOT. The primary recon entrypoint.
Presets: subdomain-enum (default), cloud-enum, code-enum, email-enum, web-basic, baddns, fast. Aggressive presets (web-thorough, spider, paramminer, web-screenshots, baddns-thorough, kitchen-sink) are routed through bbot_scan_active instead, which requires approval.
Returns inline if the scan finishes within wait_seconds; otherwise returns a job_id — poll it with job_status and read results with fetch_slice.
Inputs: target (required), preset, modules, max_events, +1 more. Returns: object
bbot_scan_activeBbot Scan ActiveA
[AGGRESSIVE — requires human approval] Actively probe with BBOT (web-thorough, spider, paramminer, screenshots).
Requires human approval. Prefer bbot_scan first: active probing on an unmapped surface wastes the program's rate limit on hosts you have not yet established are interesting.
Inputs: target (required), preset, modules, max_events, +1 more. Returns: object
brain_historyBrain HistoryBRead-only
The brain's episodic memory: what happened before, in order — every sensed tool call across engagements, filterable by phase, tool, or outcome. This is the 'what failed, what succeeded, what was a false positive, what was a true finding' record the synapse weights cannot express on their own.
Inputs: tool, event, limit, phase, +1 more. Returns: object
brain_learnBrain LearnA
Teach the neuron brain an observed outcome: a validator HIT, a CLEAN pass, or a FALSE_POSITIVE (the scanner fired and was wrong). The brain uses these to rank future plans and to suppress known-FP tools on similar targets. Use after a validator run, or when triage drops a finding — teaching it the false positive is what stops the same noise being re-filed next engagement. Stores methods and outcomes only.
Inputs: outcome (required), technique (required), vuln_class (required), waf_vendors, +1 more. Returns: object
brain_recallBrain RecallARead-only
What the neuron brain has LEARNED about testing this kind of target: which validators/techniques actually paid off on this vulnerability class with this observed technology stack and WAF, ranked by cross-engagement experience. Consult before choosing validators or designing a test plan — the brain remembers outcomes the static index cannot. Empty results mean no prior experience on this shape; proceed from the technique index.
Inputs: vuln_class (required), limit, waf_vendors, technologies. Returns: object
brain_stateBrain StateARead-only
What the neuron brain senses right now: the phase and tool currently running, the most recent tool calls, and the memory store's stats. The brain senses every tool call through the audit log, so this is a live pulse of the whole engagement, not a report.
Inputs: no named parameters. Returns: object
browser_verifyBrowser VerifyA
[AGGRESSIVE — requires human approval] Verify a candidate in a real browser and capture evidence.
url is the target URL. param names a query parameter and payload
is what to put in it (an XSS payload, a canary token, a URL for open
redirect — passed unescaped; this tool builds the URL itself). The
browser loads the page and reports:
reflection—raw/escaped/none(unescaped reflection of the payload is a reflected-XSS candidate),executed— whether the payload ran (dialog, page error, or console message containing it) — the strongest signal,redirect—final_urlhost differing from the requested host (open-redirect candidate),console messages and page errors,
screenshot/dom_excerpt— saved to the workspaceevidence/dir and referenced from the filed finding.
A finding is filed for raw reflection (MEDIUM), execution (HIGH), or a
host-changing redirect (LOW) — all needs_manual_review with the
screenshot as evidence.
Inputs: url (required), param, payload, screenshot. Returns: object
burp_sendBurp SendA
[AGGRESSIVE — requires human approval] Send one HTTP request per target through the operator's Burp proxy.
target is one or more comma-separated URLs (at most
BURP_HANDOFF_MAX_TARGETS); every one is scope-checked before anything
is sent. method is one of GET/POST/PUT/PATCH/DELETE/HEAD/OPTIONS.
headers overrides the default tagged User-Agent; body is the
request body for POST/PUT/PATCH.
Each request goes through the local Burp proxy (tools.burp.proxy_url
in config.yaml), lands in Burp's history, and the responses are returned so
the caller can attach them to leads. If Burp is not listening the call
fails with burp_not_running — start Burp and retry.
This is a human-handoff primitive, not a scanner: one request per target, nothing automated, and the classes it serves (IDOR, business logic, race conditions, cache poisoning) are exactly the ones that end in a human reading a request.
Inputs: target (required), body, method, headers. Returns: object
cdn_checkCdn CheckARead-only
Identify which hosts sit behind a CDN, WAF, or cloud provider.
Worth running before any port scan: scanning a CDN edge tells you about the CDN, wastes the program's rate limit, and occasionally violates the CDN's own terms rather than the target's.
Inputs: target (required). Returns: object
cloud_asset_discoveryCloud Asset DiscoveryA
[AGGRESSIVE — requires human approval] Discover public cloud storage by guessing names from a keyword.
Runs cloud_enum and S3Scanner. Every discovered bucket is checked against the engagement scope and against ownership evidence before it counts — name similarity is not ownership.
Inputs: keyword (required), providers. Returns: object
cloud_attack_pathsCloud Attack PathsA
[AGGRESSIVE — requires human approval] Build attack paths from cloud configuration (Prowler + Cartography graph).
Turns a list of misconfigurations into reachability: which public entry points lead to which privileged roles, and in how many hops. That chain is what makes a cloud finding worth a severity rating.
Inputs: profile, max_hops, provider. Returns: object
cloud_auditCloud AuditA
[AGGRESSIVE — requires human approval] Audit cloud posture with Prowler and ingest failed checks as findings.
Inputs: profile, provider, services, severity. Returns: object
cloud_permissionsCloud PermissionsC
[AGGRESSIVE — requires human approval] Map principals, permissions, and privilege-escalation paths with CloudFox.
Requires credentials the program gave you. Read-only enumeration.
Inputs: profile, provider. Returns: object
cmdi_probeCmdi ProbeBDestructive
[EXPLOIT — requires human approval] Detect OS command injection with commix. Detection only, never a shell.
parameter restricts testing to one parameter; leave it unset to let
commix test every parameter it finds in the URL. level (1-2) widens the
payload set.
The techniques available here are classic, eval-based and time-based — the three that answer "does this execute" by observing output or delay. File-based is excluded: it proves the same thing by writing a file into the target's web root, which is a change to the target, not evidence.
Read the tool-availability note if this returns UNTESTED. PyPI's
commix package is not commixproject/commix; it is an unrelated 2019
package that only knows how to print a banner. This spec carries an identity
marker so the impostor is refused rather than run — a refusal here means the
real tool is missing, and the surface is untested.
Inputs: target (required), level, parameter. Returns: object
code_auditCode AuditARead-only
Run the white-box code audit over source in the engagement workspace.
Scans path (relative to the workspace, default source — the
directory source_fetch clones into) with Semgrep's parsing rules and
gitleaks, then writes a merged deliverable:
code-audit.json— structured, redacted records from both tools.code-audit.md— human-readable audit with attack-surface implications.
Semgrep hits are filed as CANDIDATE findings (reachability is a later question — static analysis finds sinks, not exploits). Gitleaks hits are redacted and kept in the deliverable only: unvalidated regex matches are not findings, and the secret-scanning phase owns that class.
With no source in the workspace the phase reports count: 0 — run
source_fetch(repo_url=...) first and confirm the repository belongs to
the program.
Inputs: path, wait_seconds. Returns: object
content_discoveryContent DiscoveryA
[AGGRESSIVE — requires human approval] Brute-force paths with ffuf, at the engagement's rate limit.
wordlist is either a name from the vetted payload store ("admin",
"juicy-paths", "api-routes" — call payload_catalog for the list) or a
path to a file inside the engagement workspace.
There is no default. The size of the wordlist is the size of the impact on the target, and that should be a deliberate choice.
Inputs: target (required), wordlist (required), extensions, max_seconds. Returns: object
contract_static_scanContract Static ScanBRead-only
Run Slither over a Solidity project and normalize the detector output.
repo is a path inside the engagement workspace. Analysis is local: no
network request is made and no contract is executed, which is why this is
passive and costs no budget.
Every result is a CANDIDATE. Slither's high-impact detectors fire on safe code often enough that a finding without a runnable PoC is not submittable on any platform that pays for smart-contract bugs.
Inputs: repo (required), exclude_informational. Returns: object
contract_toolchainContract ToolchainARead-only
Report which smart-contract tools are present and correctly identified.
Absence is reported per tool rather than as an overall failure, so a missing fuzzer never reads as "the contract is fine".
Inputs: no named parameters. Returns: object
cordon_capabilitiesCordon CapabilitiesCRead-only
List registered capabilities with their phase, mode, and origin.
Inputs: mode, phase. Returns: object
cordon_finishCordon FinishA
Close the engagement: flush findings and assets to disk and seal the audit log.
Inputs: outcome. Returns: object
cordon_load_scopeCordon Load ScopeB
Load and validate an engagement scope file, creating the workspace. Must succeed before any target-taking tool will run.
Inputs: scope_path (required), workspace, config_path. Returns: object
cordon_statusCordon StatusARead-only
Current engagement: scope summary, assets, findings, budget, rate limits, approvals.
Inputs: no named parameters. Returns: object
cors_auditCors AuditARead-only
Check a URL's CORS policy for origin reflection and trust-boundary bugs.
Passive: a handful of GETs with different Origin headers, reading the
Access-Control-Allow-* response headers. Nothing is submitted, nothing
changes state.
A permissive policy is only a vulnerability when the endpoint returns data
worth stealing and Allow-Credentials is true — findings are filed as
candidates, never as confirmed.
Inputs: target (required). Returns: object
coverage_reportCoverage ReportARead-only
Report bug-class coverage: what Cordon finds, confirms, and bypasses.
The completeness check a client asks for before a test. Every row grades a
bug class as auto (a validator proves it), detect-only (found but not
confirmed), or manual (inherently judgement-shaped). A class is never
silently absent — gaps are named, with what would close them. Touches nothing
and costs no budget.
class_name— one class in full ("sql-injection", "xxe-injection")status— everything of one grade ("auto", "detect-only", "manual")gaps_only— just the non-auto classes, the watch-list
Inputs: status, gaps_only, class_name. Returns: object
dashboard_stateDashboard StateARead-only
The live engagement dashboard blob: which phase is running, each phase's outcome, the findings ledger with severity/status, discovered assets, and the brain's recent sensed activity. One JSON snapshot of the whole run — use it to answer 'where is the scan, what has it found' without reading workspace files directly. The CLI mirrors this as cordon dashboard.
Inputs: no named parameters. Returns: object
dns_permuteDns PermuteA
[AGGRESSIVE — requires human approval] Generate subdomain permutations with alterx and resolve them with dnsx.
Finds hosts that no passive source knows about. Requires approval: this is a brute-force pattern, just against DNS rather than HTTP.
Inputs: target (required), limit. Returns: object
dns_resolveDns ResolveARead-only
Resolve hosts and return A/AAAA/CNAME/MX/NS/TXT records.
Flags hosts whose CNAME resolves but which have no address record — the shape of a dangling delegation. Those are candidates for takeover_verify, never findings on their own.
Inputs: target (required), record_types. Returns: object
endpoint_discoveryEndpoint DiscoveryARead-only
Collect known URLs for a domain from public archives.
Sources: gau (Wayback + Common Crawl + URLScan), waybackurls, waymore. These query archives, not the target, so they cost the program nothing.
include_crawl adds a shallow katana crawl, which does touch the target — keep it off unless the archives came back thin.
Inputs: target (required), include_crawl. Returns: object
engagement_attachEngagement AttachARead-only
Re-attach to an existing engagement workspace by path.
Loads the workspace's scope, budget ledger, assets, findings, sessions and pipeline state so a new session continues exactly where the previous one left off — background jobs included, because they live in the server's event loop rather than in a dead shell process.
Inputs: workspace (required), scope_path (required). Returns: object
engagement_newEngagement NewBRead-only
Create (or re-open) an engagement and make it the active one.
This is cordon_load_scope plus the resumability an agent needs: passing
an existing workspace directory re-opens it — budget, assets, findings,
sessions, task graph and the phase runner state are all inherited — so a
session that dropped mid-run resumes instead of starting over.
Returns the workspace path; every later tool call acts on this engagement
until another engagement_new/engagement_attach switches it.
Inputs: scope_path (required), workspace, config_path. Returns: object
exploit_chainExploit ChainADestructive
[EXPLOIT — requires human approval] Run the exploit validators across discovered injection points.
target is the comma/newline-joined list of URLs the earlier phases found
(the pipeline passes the asset store's URLs). Each URL's query parameters are
extracted and tested one at a time, capped at limit injection points.
include_heavy adds sqlmap and dalfox on top of the native probes. Every
result is a CANDIDATE; the validators store their own findings.
Returns tested (injection points actually probed) for the pipeline's
"did it do anything" gate, plus a per-point summary.
Inputs: target (required), limit, include_heavy. Returns: object
exploit_promptExploit PromptARead-only
The prompt pack for one vulnerability class.
bug_class is one of: sqli, nosqli, xss, ssti, ssrf, cmdi, lfi, redirect,
auth, authz, business_logic, cache_poisoning, race_condition, takeover,
deserialization, file_upload, graphql, injection.
The pack names the role, objective, scope (including what is not allowed), the success criteria a candidate must meet before it may be called a finding, and the evidence fields a reproducible PoC must fill. Use it before driving a live test or writing up a candidate: a finding that cannot fill the evidence fields is a lead, not a finding.
Inputs: bug_class (required). Returns: object
fetch_sliceFetch SliceARead-only
Pull one window of a job's result instead of the whole set. path=dotted path into the result, where=regex filter, fields=keys to keep. Use this rather than job_fetch whenever a scan produced many rows.
Inputs: job_id (required), path, limit, where, +2 more. Returns: object
finding_detailFinding DetailARead-only
Full record for one finding, including evidence and PoC.
Inputs: finding_id (required). Returns: object
finding_noteFinding NoteCRead-only
Attach an analyst note to a finding. Notes appear in the report.
Inputs: note (required), finding_id (required). Returns: object
findings_listFindings ListARead-only
List findings, optionally filtered by status and severity.
Returns a compact table by default. Set detail=True for full records — prefer the compact form while planning; it costs a fraction of the tokens.
Inputs: limit, detail, status, min_severity. Returns: object
fingerprint_wafFingerprint WafARead-only
Identify the WAF vendor from response headers, body, and status code.
headers is a dict of response headers ({"server": "...", "cf-ray": ...}).
Pass the block page as body when you have one — the markers there are
often the only signal. Returns matches sorted by confidence; an empty list
means no signature reached threshold (no WAF, an unknown one, or a
transparent one that never modifies responses).
Inputs: headers (required), body, status_code. Returns: object
forbidden_bypassForbidden BypassA
[AGGRESSIVE — requires human approval] Test a URL that returned 403 against twelve access-bypass techniques.
url must be a URL that actually returned 403 (run forbidden_candidates
or check the probe result first — unKover refuses anything else).
prefix optionally adds an API version prefix (/v2) that the server
may not protect. Returns the first working technique with a curl PoC, or a
clean report when nothing bypasses.
Inputs: url (required), prefix. Returns: object
forbidden_candidatesForbidden CandidatesARead-only
Pre-check a list of URLs and return the ones that actually return 403.
forbidden_bypass refuses anything that is not 403, so this is the
pre-filter: one cheap HEAD per URL, returns the 403s. Give it URLs from
http_probe or content discovery that looked interesting; it tells you
which are worth the bypass pass. Read-only.
Inputs: urls (required). Returns: object
forbidden_chainForbidden ChainA
[AGGRESSIVE — requires human approval] Auto-chain 403 bypass across a list of URLs.
Pre-checks up to max_candidates URLs with one HEAD each, keeps the real
403s, then runs forbidden_bypass (unKover's 12 techniques) on up to
max_bypass of them. Every bypass files its own finding; a clean pass is
recorded as coverage evidence that the access decision held.
Give it the estate's live URLs (the pipeline passes the asset store, which arrives as a comma/newline-joined string). The chain is what makes a 403 a tested access decision instead of a dead end an operator has to revisit by hand.
Inputs: urls (required), max_bypass, max_candidates. Returns: object
fuzz_compareFuzz CompareARead-only
Diff responses against a baseline to find what a payload actually changed.
baseline_url is the unmodified request; case_urls are the injected
variants. Each case is diffed against the baseline across status, mime,
body hash, length, duration and headers, and cases are clustered by body
hash so identical responses (the catch-all page) read as one cluster.
re_request adds a second fetch of every case — the cache-poisoning
probe. If the second response differs from the first and matches the
injected body while a fresh requester asked only for the baseline URL, the
cache served the poisoned copy; that is the only honest way to move web
cache poisoning from "manual" toward detectable.
Read-only: GET requests through the engagement's rate limiter, nothing is sent beyond the URLs you name.
Inputs: case_urls (required), baseline_url (required), re_request. Returns: object
graphql_auditGraphql AuditARead-only
Audit a GraphQL endpoint: introspection, suggestions, GraphiQL, CSRF, trace mode.
Passive. Every check that remains is a single well-formed query used to read
what the server discloses. graphql-cop's denial-of-service family (alias
overloading, batching, directive overloading, circular introspection) is
excluded unconditionally — those exist to make the server burn CPU, which is
out of bounds under scope.rules.no_dos.
If the URL has no path, graphql-cop tries /, /graphql, /graphiql,
/playground and /console; give it the exact path to keep the request
count down.
Inputs: target (required). Returns: object
graph_recallGraph RecallARead-only
What this engagement already knows about a host, URL, or asset, and how it connects to everything else. Ask this before re-running recon — the answer is free and a re-scan costs the target requests.
Inputs: subject (required), depth, limit. Returns: object
guided_validateGuided ValidateA
[AGGRESSIVE — requires human approval] Run the validators the research playbook names for a class, on an asset.
vuln_class (fuzzy names work) and asset (a URL in scope) are the
same inputs research_guidance takes; this tool goes one step further and
executes the validators the coverage matrix wires to the class, capped at
limit tools. Classes whose validation row is manual/none return
the evidence checklist instead of dispatching anything — the honest answer
is "no scanner owns this", and the checklist is what a report needs.
Every dispatched validator goes through the control plane again (scope, rate, budget, approval) — guidance never becomes an unapproved action. Returns the playbook plus a per-validator outcome summary; validators that prove something file their own findings.
Inputs: asset (required), vuln_class (required), limit, stack, +1 more. Returns: object
http_probeHttp ProbeARead-only
Probe hosts for live HTTP services: status, title, tech, server, IP.
One request per host per scheme, at the engagement's rate limit. Rule-packs
are evaluated against each response, so native detections surface here.
Content-length and content-type are reported per host — the two scalars
that separate a real application from a parked page or an error shell —
and screenshots=True captures render-time evidence of the most
interesting hosts (requires a headless browser where httpx runs).
Inputs: target (required), ports, screenshots, max_screenshots, +1 more. Returns: object
hunt_planHunt PlanARead-only
Propose concrete tests based on what recon actually observed.
Sends no traffic. Reads the engagement's asset store and returns testable propositions, each citing the observation behind it.
focus optionally narrows the request ("authentication", "idor",
"business logic"). Leave it unset for a general pass.
Returns proposals — things to try — and gaps, which is the more
valuable half: what the model would need in order to say anything sharper.
On a target where everything interesting sits behind a login, gaps will
say so, and that is the honest answer rather than five generic suggestions.
Inputs: focus, limit. Returns: object
jaeles_scanJaeles ScanA
[AGGRESSIVE — requires human approval] Run Jaeles YAML signatures (plugin class C) against in-scope targets.
selector picks signatures by name or glob, e.g. 'cordon/' or 'cve/'. Signatures are loaded from rules/jaeles/ only.
Returns inline if it finishes within wait_seconds, otherwise a job_id.
Inputs: target (required), selector, wait_seconds. Returns: object
job_cancelJob CancelB
Stop a running scan. Kills the whole process tree.
Inputs: job_id (required). Returns: object
job_fetchJob FetchARead-only
Fetch a finished job's result. Prefer fetch_slice for large result sets — this returns everything and is capped.
Inputs: job_id (required), wait_seconds. Returns: object
job_listJob ListCRead-only
List background scans and their states.
Inputs: status. Returns: object
job_statusJob StatusARead-only
Check, wait on, or list long-running scans.
Tools that can outlast a single MCP call — nuclei_scan, bbot_scan,
osmedeus_flow — hand back {"completed": false, "job_id": ...} once their
internal wait (capped at 300s) elapses. This is how the result is collected
afterwards. Without it a scan longer than five minutes finishes into a job
nothing can read.
Omit job_id to list jobs. wait_seconds blocks for up to 300s, so a
nearly-finished scan can be collected in one call instead of polled.
Inputs: job_id, status, wait_seconds. Returns: object
js_analyzeJs AnalyzeARead-only
Fetch JavaScript bundles and extract endpoints, secrets, and libraries.
Fetches each URL once (a normal browser request), then runs native pattern
matching, jsluice (grammar-based URL extraction), linkfinder (regex-based
endpoint recovery over the saved files) and retire.js (known-vulnerable
library detection). Either external tool being absent is reported per-tool in
tools; it never turns into a quiet zero. Credential candidates are masked
in the output and are never tested against a live service here.
Inputs: target (required), max_files. Returns: object
jwt_inspectJwt InspectARead-only
Decode a JWT and report its algorithm, claims, and timestamps.
Fully offline: not one request leaves this machine, which is why it is
passive and costs zero requests. target is the in-scope asset the token
came from — it exists so the call is still scope-checked and the finding has
an owner, not because jwt_tool contacts it.
Every jwt_tool mode that forges a token (-T/-I/-S/-X), cracks
a key (-C), or replays one at a live host (-t/-M) is denied by the
argument policy. Proving a JWT flaw is an exploit-phase action with its own
approval gate, not something this tool can be talked into.
Inputs: token (required), target (required). Returns: object
k8s_postureK8S PostureA
[AGGRESSIVE — requires human approval] Assess Kubernetes posture with Kubescape.
Kubescape ships its own MCP server. If you are doing significant Kubernetes work, connect that directly alongside Cordon rather than routing everything through this wrapper — but vet it first, like any third-party MCP server.
Inputs: context, framework. Returns: object
llm_probe_catalogLlm Probe CatalogARead-only
List the LLM probe families, what each tests, and how findings are graded.
Read this before running llm_redteam. Choosing probes by impact rather than running everything is the difference between a report a program acts on and a list of jailbreak transcripts.
Inputs: no named parameters. Returns: object
llm_redteamLlm RedteamA
[AGGRESSIVE — requires human approval] Probe the target's AI feature with garak, one probe family at a time.
family: indirect-injection (default), tool-abuse, context-leak, output-handling, or jailbreak. Run llm_probe_catalog first to choose.
Results are candidates. An LLM probe failing is a behaviour, not yet an impact — see the note in the result for what a report needs.
Inputs: target (required), family, model_type, generations. Returns: object
llm_scan_configLlm Scan ConfigA
[AGGRESSIVE — requires human approval] Run a promptfoo or deepteam suite from a config inside the workspace.
Use this when you have a target-specific test suite — application-aware probes almost always outperform generic ones, because they know what the feature is supposed to refuse.
Inputs: target (required), config_path (required), engine. Returns: object
memory_recallMemory RecallARead-only
Retrieve proof-of-concept techniques that worked on previous engagements for this vulnerability class. Check this before designing a PoC from scratch — the store holds methods only, never credentials or target data.
Inputs: query (required), limit, vuln_class. Returns: object
nikto_scanNikto ScanA
[AGGRESSIVE — requires human approval] Scan a web server with nikto for dangerous files and misconfiguration.
Aggressive, and gated: nikto walks a database of several thousand paths, so it is loud, obvious in logs, and will trip a WAF. That is a decision for a human, not a default.
Two bounds apply and neither is negotiable. -maxtime stops nikto from the
inside so its report still gets written, and the process timeout sits above
it as a backstop. max_minutes is clamped to MAX_SCAN_MINUTES (30).
Pacing comes from scope.rules.max_rps via -Pause; there is no rate
argument. The Denial of Service test group is excluded by a sanitizer pattern
that every -Tuning value must satisfy.
Inputs: target (required), max_minutes. Returns: object
nosqli_probeNosqli ProbeADestructive
[EXPLOIT — requires human approval] Detect NoSQL injection (MongoDB operator injection) with nosqli.
data supplies one name=value body parameter, and it should be a
valid value (username=alice): the tool mutates what you give it, and a
body rejected before it reaches the query tests nothing.
One pair, not a body, because & is hard-denied for every argument in this
project and nosqli's --data takes a single string. A login form needing
both a username and a password cannot be expressed here — test that by hand,
or with a proxy-driven request. Saying so is the point: the alternative is a
probe that silently tests half the form.
Authentication bypass is the usual impact: {"password": {"$ne": ""}}
matching every document. This probe stops at detection, and enumerating a
collection to show severity is exactly what "do not exfiltrate" means.
Inputs: target (required), data. Returns: object
nuclei_scanNuclei ScanA
[AGGRESSIVE — requires human approval] Scan in-scope targets with Nuclei templates or a workflow.
templates: template files/dirs/ids to run. Custom rules under rules/nuclei/ are always included. workflow: a workflow file for conditional chaining. tags: comma-separated template tags (dos/fuzz/intrusive are refused).
Returns inline if it finishes within wait_seconds, otherwise a job_id.
Inputs: target (required), tags, severity, workflow, +3 more. Returns: object
oob_listenerOob ListenerB
[AGGRESSIVE — requires human approval] Start an interactsh listener and return the callback URL for blind classes.
Inject the returned URL into the suspected sink, wait, then check the polled interactions. A DNS or HTTP hit from the target's infrastructure is the proof.
Inputs: duration_seconds. Returns: object
osmedeus_flowOsmedeus FlowB
[AGGRESSIVE — requires human approval] Run a named Osmedeus flow from the reviewed flows directory.
Only flows present in engines.osmedeus.flows_dir may be run — arbitrary flow paths are refused because an Osmedeus flow can execute shell commands.
Inputs: target (required), flow. Returns: object
param_discoveryParam DiscoveryA
[AGGRESSIVE — requires human approval] Discover hidden request parameters on a URL with Arjun.
Guessing costs requests. Mine endpoint_discovery's archive results for parameter names first — they are free and already known to exist.
Inputs: target (required), method. Returns: object
pattern_scanPattern ScanARead-only
Scan URLs (and optionally their response bodies) with vetted gf patterns.
Classifies each URL by its query parameters and path segments, and — when
scan_bodies is true — fetches it once and scans the response for sink
shapes. Results are grouped by bug class, each candidate naming the
validator that would prove or kill it. Nothing here files a finding: a
pattern match is a lead, and the validators exist because leads are usually
wrong.
target names URLs, or "auto" to inherit the live URLs an earlier phase
recorded. The pattern library lives in rules/gf/; if it failed to load,
this returns UNTESTED rather than an empty scan.
Inputs: target (required), max_urls, scan_bodies. Returns: object
payload_catalogPayload CatalogARead-only
List the payload wordlists available to content and parameter discovery.
Names returned here are what content_discovery expects for its
wordlist argument. Touches no target and costs no budget.
Only tier A discovery wordlists appear. Tier B injection payloads belong to the approval-gated exploitation tools, and tier C is quarantined and has no name bound to it at all — see docs/PAYLOADS.md.
Inputs: tool. Returns: object
pipeline_statusPipeline StatusARead-only
Where the pipeline is right now: per-phase state, next pending phase.
Machine-readable version of the status.jsonl trail — branch on
state/next instead of tailing files.
Inputs: no named parameters. Returns: object
poc_recordPoc RecordBRead-only
Record a proof-of-concept a human reproduced, and confirm the finding.
For the classes no tool should prove on its own — IDOR, auth bypass, RCE, blind SSRF — this is how a finding becomes confirmed: a person reproduced it and wrote down exactly what they did and what happened.
All three of reproduction, expected_result, and observed_result are required. A PoC missing the observed result is a hypothesis.
Inputs: finding_id (required), reproduction (required), expected_result (required), observed_result (required), +2 more. Returns: object
port_scanPort ScanA
[AGGRESSIVE — requires human approval] Discover open TCP ports with naabu.
ports: "top-100", "top-1000", or an explicit list like "80,443,8080-8090". CDN ranges are excluded automatically.
Inputs: target (required), ports. Returns: object
program_scope_fetchProgram Scope FetchBRead-only
Fetch a bug bounty program's published scope into a scope.yaml scaffold.
program is a HackerOne handle or policy URL (e.g. acme or
https://hackerone.com/acme). The tool fetches the policy page, extracts
the in-scope and out-of-scope domains/wildcards the page declares, and
writes out (default scope.yaml) as a transcription scaffold.
The file is NOT a finished authorization: cordon scope validate keeps
warning until you review it, rename the engagement, and confirm the
entries against the policy page. Never run the pipeline on a scaffold you
have not reviewed.
Inputs: program (required), out, researcher_handle. Returns: object
prompt_classesPrompt ClassesARead-only
List the vulnerability classes that have an exploit/validation prompt pack.
Inputs: no named parameters. Returns: object
recon_reviewRecon ReviewARead-only
Rank live hosts by how worth they are of manual testing.
Reads the asset store (probe results + scope focus URLs) and returns the
top limit hosts with scores and the reasons behind each. Zero traffic.
The top of the list is the hand-off for auth_surface (find the login)
and auth_crawl/authz_compare (test behind it).
Inputs: limit. Returns: object
report_generateReport GenerateARead-only
Write Report.md, Report.csv, findings.json, and the task graph to reports/.
Confirmed findings (those with a reproducible PoC) are reported separately from unproven leads. Pass partial_reason when a run stopped early so the report says so on its first page.
Inputs: formats, partial_reason. Returns: object
research_guidanceResearch GuidanceARead-only
Research a vulnerability class and produce an actionable testing playbook.
vuln_class is a bug class ("sql-injection", "xss", "ssrf", "idor",
"request-smuggling", … — fuzzy names work). asset is the URL under
test, evidence any observation so far (a 403, a parameter, a scanner
hit), stack the observed technologies (comma-separated) to scope the
brain's memory recall. Read-only: assembles knowledge, sends no traffic.
To execute the validators it names, call guided_validate instead.
Inputs: vuln_class (required), asset, stack, evidence. Returns: object
rules_listRules ListARead-only
List loaded detection rules and plugins, plus anything rejected at load time. A rejected rule is a detection you do not have — check this when a scan finds less than expected.
Inputs: kind, phase. Returns: object
rules_reloadRules ReloadA
Re-scan the rule directories. Use after editing or adding a rule file.
Inputs: no named parameters. Returns: object
rule_testRule TestARead-only
Dry-run the loaded rule-packs against a sample observation (url/status/headers/body) without touching any host. Use this to check a rule before trusting it, and to understand why one did or did not fire.
Inputs: url, body, phase, status, +1 more. Returns: object
run_phaseRun PhaseA
[AGGRESSIVE — requires human approval] Run a single phase against a target and record its state.
phase is one of the pipeline phases (probe, scan, exploit, …).
target defaults to the engagement's first seed. extra_json is an
optional JSON object of extra kwargs for the phase's tool (e.g.
{"include_heavy": true} for the exploit phase).
The phase result is persisted to pipeline-state.json and the audit log,
so run_pipeline/pipeline_status and later sessions see it.
Inputs: phase (required), target, extra_json. Returns: object
run_pipelineRun PipelineA
[AGGRESSIVE — requires human approval] Run the engagement pipeline, gated, resumable, in-process.
phases restricts to a comma list ("probe,scan"); from_phase starts
at a named phase; exploit adds the exploit phase (still refused unless
the scope authorizes exploitation).
Each phase runs through its registered MCP tool — the full control-plane
chain applies per phase — and results land in pipeline-state.json +
the audit log. Finished phases are skipped on re-entry, so a dropped
session resumes where it stopped.
Inputs: phases, target, exploit, from_phase. Returns: object
scope_checkScope CheckARead-only
Ask whether targets are in scope WITHOUT touching them. Use this before planning work against a newly discovered host.
Inputs: targets (required). Returns: object
secret_scanSecret ScanARead-only
Scan files in the engagement workspace for credentials. No validation.
Runs Kingfisher (primary), Nosey Parker (git history + ML denoising), and gitleaks where installed. Sends no traffic anywhere — every hit is a candidate until secret_validate says otherwise.
path is workspace-relative; paths outside the workspace are refused.
Inputs: path, git_history. Returns: object
secret_validateSecret ValidateA
[AGGRESSIVE — requires human approval] Validate candidate credentials with Kingfisher and map their blast radius.
This is what makes a secrets report actionable: a live credential is critical, an unvalidated match is noise. It is gated because validation is use — the request goes to AWS/GitHub/Stripe authenticated as whoever owns the key.
Validation traffic is paced at the engagement's max_rps. That ceiling was
written for the target, and these requests go to third parties instead — but
it is the only rate this engagement has consented to, and issuing hundreds of
authenticated requests per second at anyone is not something a scan should
decide on its own.
Inputs: path. Returns: object
security_txtSecurity TxtCRead-only
Fetch /.well-known/security.txt and report the declared security contact.
Inputs: target (required). Returns: object
semgrep_scanSemgrep ScanBRead-only
Run Semgrep (plugin class D) over source in the engagement workspace.
Passive: reads files already fetched into the workspace and sends nothing to the target. Rules in rules/semgrep/ always participate; config may add a registry pack ('p/security-audit') or another workspace path.
Use source_fetch first to bring a repository into the workspace.
Inputs: path, config, severity, wait_seconds. Returns: object
service_scanService ScanA
[AGGRESSIVE — requires human approval] Fingerprint services on specific ports with nmap -sV plus safe NSE scripts.
scripts is restricted to default/discovery/version/banner. Exploit, dos,
brute, malware, intrusive, and safe-as-a-category are refused: the safe
category pulls broadcast-* scripts (which crash nmap with the
nse_nsock.cc:342 assertion and probe the LAN instead of the target) and
http-slowloris-check (which holds connections open and stalls the whole
scan at the engagement's rate limit). default is the curated category
that fingerprints without either failure mode.
ports defaults to what port_scan already discovered for the
requested hosts (the open_port assets in the store) and falls back to the
web ports 80,443 only when nothing was discovered. target may name
several hosts — the service phase feeds it every host that has an
open_port asset, so one nmap pass fingerprints the whole estate instead of
the single focus host. The old design scanned one host's 80,443 and
silently reported "no services" on every estate that runs on 3000/8080/
8443 — exactly the ports port_scan exists to find. The chain is
ports -> services; services must consume what ports produced.
Inputs: target (required), ports, scripts. Returns: object
session_listSession ListARead-only
List registered sessions. Values are masked.
Inputs: no named parameters. Returns: object
session_registerSession RegisterCRead-only
Register an authenticated session for later phases to use.
cookies takes sid=abc; csrf=def. headers takes
Authorization: Bearer xyz (semicolon or newline separated).
host is mandatory and is enforced: a session is only ever attached to
that host or its subdomains. Sending an operator's cookie to a host it was
not issued for is a credential leak, and guessing is how that happens.
role is free text — "admin", "user-a", "user-b". Register two
accounts of differing privilege and authz_compare can test authorization
properly; one account only tests that the application works.
Nothing here creates an account. Self-registration is a policy question: some programs invite it, others are silent, and silence is not permission. Read the program's rules, register by hand, then bring the session here.
Values are masked in every result, log and audit entry. The store lives in the engagement workspace, which is gitignored, mode 0600.
Inputs: host (required), name (required), note, role, +2 more. Returns: object
smuggling_canary_probeSmuggling Canary ProbeA
[AGGRESSIVE — requires human approval] Test for HTTP request smuggling, proving hits by canary reflection.
repeat is how many times each payload is retried; the framework scores
confidence statistically ("17/20 poisoned"), which is the right model for a
bug class that is inherently probabilistic. Capped at 10 by the argument
policy — every increment multiplies the whole payload set.
Returns coverage alongside findings: payloads sent, detectors run, and detectors skipped. A smuggling scan that could not find an echo gadget, or could not confirm queue poisoning, has not tested those things — and this result says so rather than letting zero findings imply a clean front-end.
Inputs: target (required), http2, repeat, timeout. Returns: object
smuggling_probeSmuggling ProbeADestructive
[EXPLOIT — requires human approval] Detect HTTP request smuggling (CL.TE / TE.CL desync) with smuggler.
Unlike everything else in this module, a hit here has collateral: a desync
poisons the connection for whoever uses it next. --exit_early is always
passed so the scan stops on the first finding instead of confirming it a
dozen more times, and the timeout is held low.
The probe is timing-based — smuggler measures whether the back-end waits for a body the front-end already terminated. Treat a hit as a strong lead and re-test manually against a target you control, or with the program's explicit agreement, before writing it up.
Inputs: target (required), method. Returns: object
source_fetchSource FetchARead-only
Clone a public repository into the workspace so it can be scanned.
Cloning is separated from scanning so the audit log always answers "what code did Cordon read". Only github/gitlab/bitbucket HTTPS URLs are accepted.
Confirm the repository actually belongs to the program before scanning it — an organization name matching the target is not proof of ownership.
Inputs: repo_url (required), depth. Returns: object
sqli_validateSqli ValidateCDestructive
[EXPLOIT — requires human approval] Detect SQL injection with sqlmap. Detection only, never data extraction.
There is no payload_list here on purpose: sqlmap takes no payload file,
and --tamper — the flag that comes closest — loads executable Python and
is denied for this tool. Its own boolean/time inference is what proves SQLi.
bypass_vendor names a WAF vendor whose sqli bypass set is looked up from
the knowledge base; its first payload is split into a boundary that sqlmap
applies via --prefix/--suffix. A WAF that flags the raw OR 1=1
keyword often lets the same condition through wrapped in the vendor's
evasive boundary. The exploit chain uses it to re-test a point whose base
pass came back clean.
Inputs: target (required), bypass_vendor. Returns: object
ssrf_probeSsrf ProbeADestructive
[EXPLOIT — requires human approval] Test one URL parameter for server-side request forgery with SSRFmap.
parameter names the query parameter suspected of taking a URL. The probe
asks the target to connect back to its own loopback interface across a port
list; a port that answers differently from the baseline means the target
performed the fetch, which is the SSRF.
This is deliberately the narrowest of SSRFmap's 24 modules. The ones that
make SSRF interesting — reading IMDS credentials, writing a Redis key,
proxying through the victim — are the ones a bug bounty program means when it
says do not exfiltrate and do not pivot, and they are not on the allowlist.
Confirm reachability here, then prove impact by hand with poc_record().
Inputs: target (required), parameter. Returns: object
ssti_probeSsti ProbeADestructive
[EXPLOIT — requires human approval] Detect server-side template injection with SSTImap.
injection_points selects where to inject: Q(uery), B(ody), H(eaders),
C(ookies) — query only by default, because headers and cookies multiply the
request count and are usually not the reported sink. engine optionally
narrows to one template engine once http_probe has told you the stack
(jinja2, twig, freemarker, velocity, smarty, …).
A hit here is arithmetic evaluated in a template — {{7*7}} returning
49 — and nothing else. SSTImap's shell, eval and file-transfer flags are
denied, so the tool cannot be talked into demonstrating RCE. Establishing
that a template engine evaluates attacker input is the finding; proving code
execution beyond that is a decision a human makes, in writing.
Inputs: target (required), level, engine, injection_points. Returns: object
strix_deepStrix DeepADestructive
[EXPLOIT — requires human approval] Delegate deep application exploitation to Strix, then ingest its results.
Disabled by default. Requires exploitation to be permitted by the engagement and explicit human approval per call.
Inputs: target (required), instruction, max_iterations. Returns: object
subdomain_enumSubdomain EnumARead-only
Enumerate subdomains from every installed passive source and merge them.
Runs whichever of subfinder / assetfinder / findomain / amass / theHarvester are present, in parallel, and returns the deduplicated union filtered through the engagement scope. Installing more sources widens coverage with no code change — the tool set is discovered, not hardcoded.
include_amass defaults off. On a real engagement amass ran the full 15
minutes and returned zero subdomains — its productive sources want API
keys — while subfinder and assetfinder found 322 and 301. It also spawns an
amass engine child that calls setsid itself, so it escapes the
process-group kill on timeout and keeps running, unthrottled, after the
engagement believes the tool stopped. Turn it on when amass is configured
with datasource credentials; leave it off otherwise.
thorough adds slower sources (theHarvester, amass with more providers). Prefer bbot_scan when BBOT is available: it covers more sources than all of these combined.
Inputs: target (required), thorough, include_amass. Returns: object
takeover_confirmTakeover ConfirmADestructive
[EXPLOIT — requires human approval] Verify a human-executed takeover PoC is live and attach it to the finding.
Fetches the proof URL, checks the proof content is actually served from the target host, and only then promotes the finding to confirmed. This is the single place a takeover can become 'confirmed'.
Inputs: target (required), proof_url (required), notes. Returns: object
takeover_detectTakeover DetectA
[AGGRESSIVE — requires human approval] Screen hosts for takeover candidates with subzy and dnsReaper.
Output is a candidate list, never findings. Run takeover_verify on each hit before treating any of them as real.
Inputs: target (required). Returns: object
takeover_poc_planTakeover Poc PlanARead-only
Produce the minimal, responsible PoC steps for a verified takeover.
Cordon does not register resources at third-party providers on your behalf. This returns the exact steps, including a unique proof path tied to your researcher handle, so the proof is unambiguous and the impact stops at 'I could have'.
Inputs: target (required). Returns: object
takeover_verifyTakeover VerifyARead-only
Verify a takeover candidate: CNAME chain + live response + fingerprint.
All three must agree before the host is recorded as a verified candidate. A verified candidate is filed as 'needs manual review' — confirming it requires actually claiming the resource, which is takeover_poc_plan followed by takeover_confirm.
NS and MX delegations are graded higher: those hand over the zone or the mail.
Inputs: target (required). Returns: object
taskgraph_nextTaskgraph NextARead-only
What to do next: pending tasks whose dependencies are met, highest priority first. Each carries the discovery that created it. Call this after every phase rather than re-deriving the plan from scratch.
Inputs: limit. Returns: object
taskgraph_updateTaskgraph UpdateA
Mark a task done, failed, blocked, or skipped after acting on it.
Inputs: state (required), task_id (required), note. Returns: object
taskgraph_viewTaskgraph ViewARead-only
Render the task graph as Mermaid, showing how discoveries drove the work.
Inputs: no named parameters. Returns: object
technique_lookupTechnique LookupARead-only
Query the PayloadsAllTheThings technique index for how to test a bug class.
The counterpart to wstg_lookup: WSTG says what to check, this says how.
Each record names the Cordon tools that test the class, the vetted payload
lists, and the gf pattern packs that correspond to it. Retrieval, not
automation — nothing here fires anything, and it costs no budget.
Five ways in, most specific first:
class_name— one technique in full ("sql-injection", "open-redirect")tool— every technique a given Cordon tool covers ("sqli_validate")technologies— comma-separated stack from http_probe ("Rails,MongoDB,GraphQL")query— free text ("jwt forgery", "deserialization")phase— everything in a phase (input_validation, authentication …)
Inputs: tool, phase, query, class_name, +1 more. Returns: object
tls_auditTls AuditARead-only
Audit a host's TLS configuration: protocols, ciphers, certificate, headers.
Passive. Every check run here is a standard TLS handshake plus one HTTP GET —
the same traffic any browser produces. testssl's vulnerability battery
(-U: Heartbleed, CCS injection, Ticketbleed, ROBOT, DROWN) is not run
and is denied at the sanitizer: those send malformed or exploit-shaped
handshakes, and Heartbleed in particular reads server memory. Reaching them
would make the "passive" label a lie. Use the exploit-phase validators, with
approval, if a TLS vulnerability needs proving.
Inputs: target (required), port. Returns: object
tls_infoTls InfoARead-only
Read TLS certificates and pull subject-alternative names.
SANs frequently reveal internal hostnames and sibling domains. They are scope-filtered before being stored, since one certificate often covers hosts belonging to several organizations.
tlsx opens TLS connections to the target, so its concurrency and inter- connection delay are pinned to the engagement. Its default concurrency is 300.
Inputs: target (required). Returns: object
triage_canary_previewTriage Canary PreviewARead-only
Show the fabricated canary findings triage would mix into a batch.
Useful for confirming the decoys look plausible enough to be a real test. They
always live on a .invalid host, which by RFC 2606 can never resolve.
Inputs: count. Returns: object
triage_findingsTriage FindingsARead-only
Run AI triage over candidate findings to cut false positives.
Fabricated canary findings are mixed into the batch; a pass that "confirms" one has its verdicts weighted down, and the measurement is reported.
Triage never confirms anything. Escalated findings go to validate_findings.
Inputs: taskflow, max_findings, min_severity. Returns: object
triage_taskflowsTriage TaskflowsARead-only
List available triage taskflows and their steps.
Inputs: no named parameters. Returns: object
upload_surfaceUpload SurfaceARead-only
Detect file-upload surfaces (multipart forms, file inputs, upload paths).
Fetches the discovered pages read-only and reports which URLs carry a file input, a multipart form, or an upload-shaped action/parameter. Nothing is uploaded — this is detection only, and every entry is a lead for a human or an approved validator, not a finding.
Inputs: target (required), max_urls. Returns: object
validate_findingsValidate FindingsADestructive
[EXPLOIT — requires human approval] Prove candidate findings with minimal PoCs. Validators run in parallel.
Only a finding whose validator produced a reproducible PoC becomes 'confirmed'. Everything else is downgraded to 'needs manual review' with the reason recorded. This is the only automatic route to a confirmed finding.
Inputs: finding_ids, max_findings, min_severity. Returns: object
waf_bypassWaf BypassARead-only
Ordered WAF-bypass payloads for (vendor, vuln_class), basic → advanced.
vendor is a wafw00f display name ("Cloudflare", "Amazon Web Services
(AWS) WAF") or a canonical key ("cloudflare", "aws_waf", "modsecurity").
vuln_class is one of xss, sqli, cmdi, ssti, ssrf,
path_traversal. level filters to basic / intermediate /
advanced / all.
Read-only: returns text payloads tagged with technique + level, nothing is sent. Payloads are the data the exploit chain feeds its validators when a base pass was clean; calling this tool does not fire anything at a target.
Inputs: vendor (required), level, vuln_class, max_payloads. Returns: object
waf_detectWaf DetectBRead-only
Identify the WAF or protection layer in front of a host.
Knowing the WAF changes what is worth trying and what will simply be blocked.
The vendor names this reports are what the exploit chain's bypass pass
consumes: waf_bypass looks up the vendor's payload set and the validators
re-fire with it only when a base pass came back clean — still behind the
exploit gate. Identifying the vendor stays passive; sending bypass payloads
is exploitation and goes through the same approvals as any other.
Inputs: target (required). Returns: object
waf_vendorsWaf VendorsARead-only
List supported WAF vendors with the classes each has bypass payloads for.
Inputs: no named parameters. Returns: object
wapiti_scanWapiti ScanA
[AGGRESSIVE — requires human approval] Crawl and attack a web application with wapiti.
Aggressive, and gated. Even profile='safe' crawls the whole application;
profile='injection' submits SQLi, XSS, command-injection, SSRF, CRLF and
XXE payloads to every parameter found. Nothing about that is observational.
Bounds, all enforced server-side: --max-scan-time caps the run,
--max-attack-time caps each module, crawl depth and links-per-page are
capped, and the process timeout sits above all of them. max_minutes is
clamped to MAX_SCAN_MINUTES (30).
wapiti exposes no requests-per-second control — the closest it offers is
--scan-force, which is set from scope.rules.max_rps here. That is an
approximation and it is reported as one: a program with a strict published
rate limit is a reason to prefer nuclei with -rl.
Inputs: target (required), depth, profile, max_minutes. Returns: object
web_injection_probeWeb Injection ProbeADestructive
[EXPLOIT — requires human approval] Detect open redirect, CRLF, LFI, XXE or HPP in one parameter.
target is the full URL carrying the parameter to test (one parameter —
& is refused project-wide). parameter names it. bug_class is one
of open-redirect, crlf, lfi, xxe, hpp.
regex_bypass expands the class's payload set with generated WAF-regex
bypass variants (every mode x every encoding, bounded at 500): a WAF regex
that blocks the textbook ../ or <script> often lets the same byte
through when written as %2e%2e/ or split by a metachar replacement. It
multiplies the request count and is strictly a second pass — run the plain
probe first and reach for this only when a parameter reflects but nothing
fires.
Every result is a CANDIDATE: the class signature must appear in the injected response and not in the baseline request. Nothing is confirmed here.
Inputs: target (required), parameter (required), bug_class, regex_bypass. Returns: object
websocket_probeWebsocket ProbeARead-only
Open a WebSocket handshake and report whether the server validates Origin.
Pass the https:// (or bare host) form of the endpoint, not wss://:
the scope engine cannot parse a ws/wss URL and fails closed on one,
so a wss:// target is refused before this ever runs. The upgrade to
wss:// happens here, after the scope check has had its say.
Passive: one upgrade request, no frames sent, connection closed immediately.
-u inhibits the send direction and -1 stops after a single message,
so nothing this tool does can be mistaken for traffic.
A handshake that succeeds with a foreign Origin is a candidate for
cross-site WebSocket hijacking. It only becomes a finding when the socket
also carries authentication that the browser would attach automatically —
which this tool cannot and does not test.
Inputs: target (required), origin. Returns: object
whois_lookupWhois LookupARead-only
WHOIS registration data for a domain: registrar, org, dates, nameservers.
Useful for confirming an asset actually belongs to the program before you spend requests on it.
Inputs: target (required). Returns: object
wstg_lookupWstg LookupARead-only
Query the OWASP Web Security Testing Guide for what to test next.
Four ways in, most specific first:
test_id— one test in full ("WSTG-INPV-05")technologies— comma-separated stack from http_probe ("Java,Tomcat,OAuth")query— free text ("session fixation", "file upload")phase— everything in a phase (recon, authentication, input_validation …)
Retrieval, not automation. A WSTG test says what to check and why; whether it applies to this target is a judgement no detector makes for you. Touches nothing and costs no budget.
Inputs: phase, query, test_id, technologies. Returns: object
xss_validateXss ValidateADestructive
[EXPLOIT — requires human approval] Confirm reflected XSS on a URL with dalfox.
payload_list optionally names a tier B list from the vetted payload store
to hand dalfox via --custom-payload. Leave it unset first: dalfox's
built-in payloads are context-aware and prove most reflected XSS on their own.
Reach for a list when a parameter reflects but nothing fires —
xss-waf-bypass against a filtering target, xss-polyglots when the
injection context is unclear, xss-js-frameworks for a Vue/Angular front
end. Tier B is injection payloads, not discovery wordlists, and this is the
only tool that can request one.
bypass_vendor names a WAF vendor whose ordered XSS bypass set is looked
up from the knowledge base and handed to dalfox via --custom-payload the
same way a tier B list would be. The exploit chain uses it to re-test a
point whose base pass came back clean: the WAF may have eaten the textbook
payloads while the vendor-specific set gets through.
Inputs: target (required), payload_list, bypass_vendor. Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 127 tools
Most tools are crisply differentiated, but several pairs genuinely overlap: code_audit and semgrep_scan both run Semgrep over workspace source, brain_recall / memory_recall / graph_recall are three near-synonymous 'recall knowledge' tools, and cordon_status vs dashboard_state both report engagement state. An agent would plausibly misselect among these. The pipeline families (takeover_detect/verify/confirm/poc_plan, forbidden_candidates/bypass, secret_scan/validate) are otherwise well-structured.
The dominant convention is snake_case verb_noun (subdomain_enum, whois_lookup, content_discovery, secret_scan) with a consistent toolname_scan sub-family (nikto_scan, nuclei_scan, wapiti_scan, semgrep_scan). Deviations exist — the cordon_* brand prefix, cmdi_probe's abbreviation, security_txt's nominal form, and fuzz_compare's verb_verb — but they are minor against the overall pattern.
With roughly 70 tools listed (127 claimed), this is an extreme count — an order of magnitude beyond the 3-15 well-scoped range and far past the 25+ threshold. Even granting the platform's broad domain (web, cloud, k8s, smart contracts, memory, reporting), no agent can navigate this surface efficiently, and the presentation overwhelms rather than assists.
The surface covers the entire offensive-security lifecycle: scope loading and checking, passive and active recon, web/cloud/k8s/smart-contract scanning, approval-gated exploitation, secrets, SAST, findings management, reporting, job control, rules management, knowledge lookup, memory, task-graph planning, audit, triage, and approvals. References to port_scan/http_probe/job_status suggest tools outside this list, but within the provided set there are no obvious dead ends.
Maintenance
Related MCP Connectors
MCP gateway with runtime security policy, tool-call-level control, and audit of agent actions.
Zero-secret MCP gateway for AI agents: risk-scored, audited calls with human-in-the-loop approval.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Security firewall for AI agents — scans MCP calls for injection, secrets, and risks.
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceA Kali Linux-based MCP server that exposes over 45 penetration testing tools for AI-assisted security auditing and vulnerability scanning. It features strict scope enforcement, structured output parsing, and persistent finding storage to automate the offensive security workflow.MIT
- FlicenseNot gradedqualityDmaintenanceMCP server for auditing AI agent permissions and access by scanning for the trifecta of credentials, injection, and reach without heavy infrastructure.-
- AlicenseNot gradedqualityCmaintenanceThis MCP server enables security auditing for MCP configurations and AI agents, including prompt injection testing, data flow tracing, and security policy generation.61 npmMIT
- FlicenseNot gradedqualityDmaintenanceMCP server for AI agent compliance that screens actions before execution and records decisions in an immutable, SIEM-ready audit trail.53 npm-