Control API (optional local HTTP control plane)
Fissure can expose a small JSON HTTP API on 127.0.0.1 so
an external peer, an automation script, a CI job, curl, or
an MCP bridge driving Claude Code, can drive the engine without the GUI.
It is off by default, opt-in, and gated by a token. The
GUI's server binds loopback only;
fissure serve --host <addr> can bind any address, but
off loopback it requires --api-key (or an explicit
--insecure).
The transport is src/fissure_server.c (the accept loop,
request parsing, auth, and route dispatch). The engine-facing side (an
independent findings store and the hook implementations that turn a
request into engine work) is src/fissure_control.c, shared
verbatim by the GUI and the fissure serve CLI command so
both behave identically.
Every route below is also reachable from the shell without starting
the server:
fissure api <METHOD> <ROUTE> [json-body] runs
the same handler in process (no token, no port), printing the JSON reply
and exiting 0 only on a 2xx. --data-file <path> reads
the body from a file, or from stdin with -.
Route registry and the four-surface check
The extension routes live in a table (k_routes in
src/fissure_control.c), one row per route: method, exact
path, which arguments its handler takes, and the handler. The dispatcher
walks the table instead of the 167-comparison if-chain it used to be, so
adding a route is one row rather than a new comparison every request
pays for. route_eq matches an exact path (any query
ignored), so rows are order-independent. One route is not a row:
GET /api/proxy/history/<index> carries the index in
the path, so it is matched by prefix ahead of the table.
A row deliberately does NOT carry the doc anchor or the MCP tool name
as strings. The doc anchor is the method and path already in the row,
and a copied tool name would be a third place to drift.
tests/test_control_routes instead walks the registry and
checks each route against the real files:
- the path appears in this document;
- the path appears in
bridge/fissure_control_client.py, so a client function carries it; - that client function is called from inside an
@mcp.toolbody inbridge/fissure_mcp_bridge.py, so the route is reachable over MCP and not only from a Python script; - every public client-library function that issues a
_callis wrapped in a tool. That catch-all covers the core routes the dispatcher matches by hand (the scan and job lifecycle, findings, request), which are not registry rows.
It then audits the last surface against the skill catalog: the
@mcp.tool names the bridge defines must be exactly the tool
bullets
.claude/skills/fissure_bug_bounty/references/mcp_tools.md
lists, with no tool missing an entry, no entry naming a tool the bridge
does not expose, and no tool listed twice. Each entry's signature is
compared argument by argument against the tool's, so an entry cannot
omit an argument the tool takes or document one it does not: an omitted
argument is a capability an agent reading the catalog never uses, which
is how a documented TLS escape hatch and several per-call overrides sat
unreachable.
Checking only the client library is what let two routes ship with a client function and no tool at all: an agent driving Fissure over MCP could not reach them while every check passed. A route added without its documentation row, without a bridge call, without a tool, or a tool added without its catalog bullet, fails the build, with a message naming the file to edit. That turns the four-surface rule from a convention that fails when someone notices into a build-time check.
Enabling it
From the GUI
Settings has a Control API section:
- Enable local control API on 127.0.0.1 - a checkbox that starts/stops the server immediately. The checkbox reflects the real running state: if a start fails (for example the port is already in use) the box returns to off and a popup explains why.
- Port - the loopback port to bind (default 8777). A change applies the next time the server is enabled.
- Token - the bearer /
X-API-Keyvalue that gates every route except the health check. One is generated automatically the first time you enable the API; the field shows it so you can copy it into your client or bridge config. - Regenerate token - mints a fresh token and, if the server is running, restarts it on the new token.
The enabled state, the port, and the token are persisted in
~/.config/fissure/settings.json
(control_api_enabled, control_api_port,
control_api_key). If the API was enabled when you last
quit, it auto-starts on the next launch (a headless self-test never
binds a port).
From the CLI
fissure serve [--host <addr>] [--port <n>] [--api-key <key>] [--max-jobs <n>]
[--tls-cert <pem> --tls-key <pem>] [--insecure]
--host defaults to 127.0.0.1 and
--port to 8777; the port must be in 1-65535
(--port 0 is rejected with exit status 2, there is no
ephemeral-port mode). Without --api-key, serve
on a loopback host generates a random key for the run and prints it to
stderr; on a non-loopback host it refuses to start (exit status 2)
unless --insecure is given. The surface is unauthenticated
only with --insecure, which prints a warning; always set a
key when the listener is reachable by anything other than you.
--tls-cert and --tls-key serve the API over
TLS. Off loopback the API token crosses the wire on every single
request, so encrypt it; a self-signed pair is fine for a private
deployment. The two must be given together: half a TLS config is refused
rather than silently falling back, because a plaintext listener the
operator believes is encrypted is worse than an obvious error. The same
pair can be set in the GUI Settings, which applies it when the server
next starts.
Security model
Loopback by default. The GUI binds
127.0.0.1only.fissure serve --hostcan bind another address, but only with--api-key(or--insecure), and the TLS pair below should then be set. Never expose the control port to a network you do not trust; this is an offensive tool and an open control port is a liability.Token on every route except
GET /api/status(the health check) and the browser-dashboard shell atGET //GET /ui(static HTML, no data). Send it as eitherX-API-Key: <token>orAuthorization: Bearer <token>. A missing or wrong token returns401.Browser dashboard. Point a browser at
http://127.0.0.1:<port>/for a self-contained control dashboard. Tabs: server status + a findings severity summary; a findings table; start-a-scan with active/aggressive toggles (async job polling); a Repeater (send an arbitrary request through the engine and view the response); proxy control (start/stop/status, a captured-flow table, clear history); a Probes tab (run any targeted probe: smuggle, http3-smuggle, ssrf, xxe, idor, cache, takeover, protopollution, massassign, storedxss, authbypass, cspt, csrf-active, race, upload, dirlist, with a shared findings table and the raw verdict); a Jobs tab (queue a background check job, list/clear jobs, and the lifecycle Event log); a Schedules tab (add/list recurring scans, and run/enable/disable/remove by id); Recon (ingest tool output into the inventory + scope, plus the host-level asset diff); a Surface tab (the endpoint attack-surface summary); a Query tab (run HTTPQL over findings/traffic/wsframes, plus saved-query CRUD with Restore-defaults); a Workflows tab (list + instantiate a shipped template, then run a saved workflow and read its trace); an Import tab (compile a nuclei/BCheck template to an fs.* check and run it via jscheck); an AI tab (the AI-assisted shadow repeater); an OAST tab (start/stop the listener, mint a canary, poll, and the interaction history); the Multitool workshop (protobuf/gRPC decode, transform, smart-decode, remediation-guidance lookup, prettify); scope editing; and a Report tab (generate + download in markdown/html/json/ csv/sarif/burp with an optional minimum severity, and a Source / Rendered toggle: Markdown drawn as DOM nodes, HTML in a fully sandboxed iframe; see 06_REPORTING.md). The dashboard shows the control session an agent drives over the MCP bridge, and it shows it without a button press: the Status tab carries a workspace overview (active project, scope and active named scope, proxy state and flow count, traffic count, jobs), and every tab that displays state loads it when the tab is opened and again on Connect (findings, proxy status + flows + interception, traffic, jobs, purple, schedules, recon assets, surface, saved queries, workflows, OAST status + history, scope, projects, parameters, session cookies). A captured flow is clickable and shows its request and response (GET /api/proxy/history/{index}, with the body-capped warning); a Traffic tab lists the cross-tool request log (/api/traffic, filtered by tool) with each record's bytes (/api/traffic/detail) and a Clear; the Scope tab also lists the named scopes (/api/scopes: save the lists as a name, activate, delete); a Projects tab lists, creates, activates and deletes projects (/api/projects); the Findings tab can clear the store. Destructive actions ask first and name their target. Most of the remaining routes have a dedicated card, built by a small declarative view/action engine in the page: a VIEW shows one GET route's state (a key/value summary plus a table per list) with per-row buttons for its POST ops and an edit form whose fields come from the route's documented body in the catalog below; an ACTION is a form for one POST route that renders the findings and any list the response carries. These group into tabs: Config (user agents, environments, transform tags, resource pools, host routes, scan profiles, the auto-repeater ruleset), Extensions (installed bundles, the signed marketplace, and the context actions, session actions and message editors extensions contribute), Plugins (the OSS-tool roster, with a run form), Saved (the Repeater tab workspace, the organizer queue and saved Intruder attack configs, each sendable to the Repeater tab) and Relay (the raw TCP/UDP interception relay: start, status, captured chunks, hold/forward). The Proxy tab also carries the match/replace, intercept-rule and highlighter editors and the CA-certificate download; Purple, OAST, Recon, Findings, Scope, Report, Session, Repeater, Tools and Probes gain the cards for their routes (the workshops - JWT, cookie, SAML, GraphQL, compare, inspect, sequence and the rest - live on Tools). A control-bypass action (WAF/CDN or access-control bypass) shows the authorized-use-only code-of-conduct notice before it runs.tests/test_control_routesclassifies every route as having a dashboard view or being deliberately console-only with a recorded reason (only/api/target/highlight, which paints a GUI grid the browser does not have), and fails the build on an unclassified route, so the dashboard cannot fall behind the API again.An API tab is the console for anything without a dedicated card: it lists EVERY control route with its summary and documented request body, sends the call, and draws a list in the response as a table above the raw JSON, so even a route with no card is reachable from the browser. That list is generated from the route tables in this document by
packaging/gen-webui-routes.py;tests/test_control_routesfails when a registered route is missing from it andmake webui-checkfails when it is stale, so after adding a route's row here run that script and thenpackaging/gen-webui.sh. It is a thin client over the same routes: paste the token once (kept in the tab'ssessionStorage), and every call it makes carriesX-API-Key. The token field is masked with a Show/Hide toggle (masked via CSS text-security, not atype=passwordinput, so the browser's password-manager / breach-detection behaviour never freezes the page on paste; Ctrl+V works). No external assets are loaded (CSP-safe). It is an alternative operator surface, not a replacement for the desktop GUI or the raw API. An optional operator-name field (kept inlocalStorage) identifies you on the shared team: on Connect the dashboard callsPOST /api/teamadd_member(idempotent) and heartbeats presence, and a scan you start is logged to the team activity feed viaPOST /api/teamlogattributed to that operator, so a browser-driven operator appears in Team like a desktop or agent one.Independent engine session. Scans launched through the API accumulate into the control module's own findings store and are returned over HTTP; they do not mutate the interactive GUI tabs (which keeps the API thread-safe against the GUI). Active scanning through the API still honors authorized scope exactly like the interactive scanner.
Request hardening. Each request is bounded: the reader caps the total request at 64 KiB, a declared
Content-Lengthover that cap is refused with413before any body is drained, and a per-connection read timeout (15 s) keeps a stalled client from pinning the single accept-loop thread. Every accepted command is written to the log (method path), and the response status is logged too, for an audit trail.Methods. The API speaks
GET,POSTandHEAD.HEADis served whereverGETis, including the open routes, so a health check or reachability probe that sendsHEAD /api/statusgets the status line andContent-LengthitsGETwould produce and no body, instead of the401an exact-method match used to give it on an endpoint documented as open. Any other verb (PUT,DELETE,OPTIONS, ...) answers405with anAllow: GET, POST, HEADheader, which says the method is wrong rather than the404that says the resource does not exist.
Endpoints
| Method | Path | Auth | Action |
|---|---|---|---|
| GET | /api/status |
open | Liveness. Returns
{"status":"ok","name":"fissure","version":...}. |
| GET | / , /ui , /index.html |
open | The browser-served control dashboard: a single self-contained HTML
page (no external assets) that drives the routes below from a browser.
Serving the shell needs no token (it carries no data); the operator
pastes the token in the page and every data call it makes still sends it
as X-API-Key. Open
http://127.0.0.1:<port>/ after
fissure serve (or after enabling the control API in the
desktop app). |
| GET | /api/findings |
token | The findings accumulated by control-API scans, as a JSON report. |
| POST | /api/findings/clear |
token | Drop every accumulated finding and its capture evidence from the
control session (a fresh workspace for the next engagement; also
releases the capture memory that grows across scans). Returns
{"cleared":<count removed>}. The GUI analog is the
Target view's Clear-hosts action and the Findings view's Clear-all. |
| POST | /api/finding/highlight |
token | Set (or clear) one finding's manual highlight color, mirroring the
Findings/Proxy grid Highlight button. Body:
{"index":N,"color":"red"} where N is the
finding's position in the /api/findings array (report
order) and color is one of
red|orange|yellow|green|blue|purple (an empty or absent
color clears it; an unknown color is rejected with 400). The color is
stored as a reserved hl:<color> entry in the
finding's tag list, so it persists with the project and rides
/api/findings (in the finding's tags). Returns
{"ok":true,"index":N,"color":...,"tags":...}. 404 when no
finding sits at that index. |
| POST | /api/request |
token | Send one HTTP request through the engine and return the response.
Body:
{"url":...,"method":"GET","headers":{...} or "Name: Value\n...","body":"...","body_b64"?:"...","http3"?=false}.
body_b64 is a base64-encoded request body for a BINARY /
NUL-carrying body a JSON body string cannot represent
(UTF-16 encoded XML for XXE, binary uploads, protobuf): it is decoded to
raw bytes and sent whole (the transport is binary-safe and
Content-Length matches), taking precedence over body when
both are given. With "http3": true the request is re-sent
over HTTP/3 (QUIC, ALPN h3) instead of the engine's HTTP/1.1 / HTTP/2
path (the Repeater h3 send path); the response then carries
"protocol": "h3". Needs a build with the ngtcp2/nghttp3
stack. An optional "user_agent" overrides the User-Agent
for this send (else the active preset / process default, see
/api/useragents); it applies to the HTTP/1.1, HTTP/2 and
HTTP/3 paths, and an explicit User-Agent in headers still
wins. |
| POST | /api/scan |
token | Run a scan synchronously and return its JSON report. Body:
{"url":...,"active":bool,"aggressive":bool,"cookie"?}.
cookie ("a=b; c=d") is an optional captured session cookie
(e.g. from POST /api/session-action) applied to every scan
request for an authenticated scan. Loads the full check set (user JS
checks, .bcheck, nuclei templates, and enabled extension
bundles) so a headless scan runs the same checks a GUI scan does. |
| POST | /api/scans |
token | Start a scan asynchronously. Body as /api/scan, plus an
optional login login-config object for an authenticated
scan (or the simpler cookie field) and an optional
profile. An authenticated run re-authenticates
automatically if the session expires mid-scan: a re-auth-on-401 rule is
enabled for it, and the login object's optional
reauth_on_contains substring (a marker unique to the
logged-out/login page) re-runs the login and retries when a response
contains it, which catches the common redirect-to-login logout (a 200
login page) that a status rule would miss. Raw knobs
max_depth, max_pages, delay_ms,
max_threads, max_time_sec (wall-clock budget
in seconds, 0 = unlimited), scan_rps (per-host request-rate
cap in requests/sec, 0 = unlimited: every send waits for the target
host's next slot, so raising max_threads never raises
per-host request pressure past this), time_host_concurrency
(max concurrent time-based sleep-injecting blind-injection probes per
host, 0 = default, <0 = unlimited: each injected SLEEP holds a target
worker, so parallel timing probes across the audit pool can exhaust the
target and wedge an aggressive scan; a per-host watchdog also drops a
host that keeps saturating), host_backoff (adaptive
per-host concurrency for ORDINARY probes, 0 = on with the built-in floor
and the default, <0 = off, >0 = on and never cutting below that
many concurrent requests to a host: when a target starts dropping
requests the run holds itself to fewer concurrent requests to it and
lets go again once it answers, because a request that gets no response
cannot produce a finding and out-running a target silently deletes
coverage; the current allowances are on GET /api/respools),
the detection-timing knobs (each 0/omitted = the built-in default)
time_delay_secs (injected blind-SQLi/command sleep in
seconds, default 5, range 3-30: raise it on a slow or jittery target so
a true positive clears the timing floor),
time_timeout_pad_ms (extra request timeout over that sleep,
default 5000), time_reconfirm_needed and
time_reconfirm_max (independent clean re-measures that
confirm a time-based hit, and the cap on rounds spent reaching that
count, default 2/2: raising needed drops shared-contention false
positives at the cost of speed), oast_wait_ms (how long a
blind out-of-band SSRF/XXE/RCE/DNS-rebind check waits for the canary to
call back, default 600: raise it for a slow callback path) and
retry_backoff_ms (pause before retrying a failed request,
default 250), families, and points
(comma-separated name lists; empty/omitted = all) are direct overrides
that win over a named profile, so a scan is fully
configurable without first saving a profile (CLI
--depth/--max-pages/--delay/--threads/--max-time/--rps/--time-probe-concurrency/--families/--points
parity). seeds (a JSON array of absolute http(s) URLs, or a
single string) adds extra crawl-seed URLs alongside the main
url, for deep endpoints a link crawl cannot discover on its
own (an app whose navigation is a numeric-id dropdown or JS routing, or
a known endpoint list for an engagement); each seed is still scope-gated
(CLI --seed-file parity). endpoints (a JSON
array of request objects
{method,url,content_type,body,headers,params:[...]}) audits
a request CORPUS directly in targeted mode (no crawl): each request is
probed across its query, form-body and cookie insertion points (and its
allowlisted request headers), with no prior proxy capture, so a request
set exported elsewhere (an OWASP Benchmark crawler file, a
HAR/Postman-style corpus, a saved endpoint list) is scanned as-is.
headers is a Name: value\r\n block (a
Cookie line carries cookie insertion points);
params names the query/form fields to fuzz; a urlencoded
form field is given as a params entry with no
body (the body is synthesized). When endpoints
is present the crawl is skipped and exactly those requests are audited,
but url is still required and its host seeds the scope (CLI
--endpoints-file parity). spa (a bool, default
false) additionally drives a headless browser over the DevTools Protocol
AFTER the link crawl to discover client-side (single-page-app) routes
and runtime XHR/Fetch endpoints that live only in JavaScript, and feeds
them into the crawl and audit; it needs a Chromium/Chrome (or the
bundled Fissure Browser) and uses the session cookie jar for an
authenticated crawl. Use it for an Angular/React/Vue app whose
navigation and API calls a link crawl cannot see; the scan reports what
it added, or that no browser was found, as a "Scan coverage" finding.
Slower, so off by default (CLI --crawl-spa parity).
headers (a string, one "Name: Value" per line) adds extra
request headers to every scan request (auth/forwarding/marker headers; a
header the request already sets is not overridden; CLI
--header parity). exclude (a
comma/space/newline-separated list of URL-path substrings) names paths
the crawl will not follow and the audit will not probe (e.g.
/logout,/admin/delete,.pdf), matched case-insensitively on
the path only; CLI --exclude parity.
waf_encoders (a comma-separated encoder chain:
case,space2comment,space2plus,space2tab,space2hash,space2dash,space2randomblank,multiplespaces,randomcomment,commentbeforeparentheses,percentage,apostrophemask,overlongutf8,url,urlall,url2x,charunicodeurlencode,versionedkeywords,nonrecursivereplacement,symboliclogical,equaltolike,
e.g. case,url2x) turns on scan-time WAF-bypass: every
active-check payload is encoded through the chain to slip past an input
filter (WAF/CDN) while staying server-transparent so the app still
decodes the attack. The chain transforms a payload VALUE, so the two
body-shaped encoders do NOT belong in it: jsonpad only pads
a JSON OBJECT body and returns a payload value unchanged (use
waf_body for a scan's JSON bodies, below), and
utf16 emits NUL-bearing bytes only the XXE body path can
carry (use waf_xml_utf16, below). an unknown encoder name
answers {"error":"unknown waf_encoders encoder"}, and an
enabled run records a code-of-conduct notice in the event log
(control-bypass feature, authorized in-scope targets only); CLI
--waf-bypass parity. waf_request (a
comma-separated shape chain:
pollute,pollutelast,bracket,dotnotation,charset,mpboundary,mpduplicate)
is the REQUEST-shaped companion: where waf_encoders
transforms the payload VALUE, these change how the request CARRIES it,
which is the only way to express the bypasses a payload encoder cannot
(the transport URL-encodes what it is handed into one literal parameter
value). pollute sends the parameter twice with the benign
value first, for a filter that inspects the FIRST occurrence and an
application that takes the last; pollutelast is the same
pair reversed; bracket sends the name as
name[]; dotnotation sends name.x;
charset declares a character set the filter and the
application disagree about; mpboundary quotes and pads the
multipart boundary. An unknown shape name answers
{"error":"unknown waf_request shape"} rather than being
silently ignored; preview a chain with
POST /api/wafrequest; same code-of-conduct notice; CLI
--waf-request parity. waf_body (a bool) is a
separate opt-in that also WAF-bypasses the JSON request bodies of the
direct-body checks (NoSQL operators, prototype-pollution keys): every
JSON body is jsonunicode-escaped (\uXXXX on
the string-only signature characters) so a WAF body signature misses
while the JSON parser decodes it back; same code-of-conduct notice; CLI
--waf-body parity. waf_xml (a bool) is the XML
analogue for the XXE check: the XML body's DTD is rewritten
(SYSTEM becomes a PUBLIC external id,
tab-for-space) via the xmlbypass encoder so a WAF signature
on the external-entity markup misses while an XML parser resolves the
entity identically; same code-of-conduct notice; CLI
--waf-xml parity. waf_xml_utf16 (a bool)
additionally re-encodes the XXE check's XML body as UTF-16LE with a BOM
(the utf16 encoder, which also rewrites a
UTF-8 encoding declaration to UTF-16) so a WAF
that signature-matches the ASCII markup sees UTF-16 bytes and misses
entirely, while an XML parser detects UTF-16 from the BOM and resolves
the entity identically; it layers on waf_xml and is sent
over the binary-safe body path (the body carries NUL bytes); same
code-of-conduct notice; CLI --waf-xml-utf16 parity.
fuzz_settings_forms (a bool, default false) opts INTO
exercising the application's own configuration: it fuzzes the target's
settings forms and lets the crawl follow the switch links beside them (a
link whose query carries a setting name with a value, such as DVWA's
?phpids=on). It is off by default because exercising that
surface reconfigures the target mid-scan, so every later check tests a
differently-configured application and findings that were real at the
start silently disappear (measured on DVWA: following that one link
enables the application's input filter and takes the same scan from 14
high findings and 4 SQL injections to 5 high and none). What was held
back is still recorded in the inventory and counted in a "Scan coverage"
finding, so the gap is visible; CLI --fuzz-settings-forms
parity. Loads the full check set (as /api/scan). Answers
202 with {"job_id":...}. Transport
configuration: tls_client_cert and
tls_client_key (PEM paths) enable mutual-TLS
client-certificate authentication, without which a scan against a
client-cert-protected target only fails the TLS handshake;
proxy_url routes the scan's own traffic through an upstream
proxy, with no_proxy as a comma-separated bypass list.
ca_file (a PEM path: a private CA, or the target's own
self-signed certificate) is trusted on top of the detected system store,
so an https target serving a certificate the system does not trust is
scanned with verification left ON (CLI --ca-file parity);
tls_verify (a bool, default false)
controls certificate verification for the whole run: it is off by
default because engagement targets routinely serve certificates no store
trusts and a failed check stops the request rather than producing a
finding (CLI --verify-tls / --insecure
parity). Set it true to check certificates again; ca_file
is then the precise way to reach a private-certificate target, since
verification stays on and one certificate is pinned rather than any
accepted. A run started with tls_verify: true against a
target the store does not trust fails verification on every request and
GET /api/scans/{id} reports stopped_early with
a stop_reason, which is a partial run and not a clean
result. |
| GET | /api/scans/{id} |
token | Job status + progress:
{"job_id":...,"status":"running|done|cancelled|error","done":bool,"progress":{"audited":n,"total":n,"percent":n,"covered":n,"low_coverage":bool}}.
covered is the number of audited endpoints that had a
fuzzable insertion point; low_coverage is true when the job
is done, endpoints were discovered, but covered is 0 (the
active audit probed nothing, so an empty finding set is a coverage gap,
not a clean bill). Every reply also carries crawl:
{"pages":n,"page_cap":n,"left":n,"depth_capped":n,"capped":bool},
how much of the SITE the crawl reached. pages is what it
fetched against its page_cap budget (0 = unlimited),
left the in-scope URLs it queued and never crawled (a scan
still fetches each for its baseline; what was skipped is expanding them,
so anything reachable only through them was never discovered),
depth_capped the pages it fetched at the depth limit whose
own links it did not follow, and capped true when the page
budget rather than the site ended the crawl. Read it before the
findings: every URL the crawl DISCOVERS is recorded as an endpoint
whether or not it is fetched, so the endpoint total keeps rising after
the fetching stops and a bounded run is indistinguishable from a
complete one by endpoint count alone. capped true, or a
non-zero left, means the scan covered part of the target;
raise max_pages/max_depth or seed the
unvisited areas separately before concluding anything about them. The
run also records this as a Scan coverage finding. When the
run abandoned its target the reply also carries
stopped_early: true and stop_reason (a
sentence naming why: too many consecutive endpoint failures, or a
certificate that could not be verified). A run that stopped early
produced partial coverage, so its finding set must not be read as a
clean result. Every reply also carries sends:
{"sent":n,"answered":n,"dropped":n,"drop_percent":n,"timeout":n,"connect":n,"empty":n,"tls":n,"other":n,"cancelled":n},
what the target did with the run's requests. sent is every
request the run executed, answered the ones that came back
with a status, and dropped the ones that got no response at
all, split by cause (timeout no answer in time,
connect refused/unreachable, empty connected
but nothing usable came back, tls certificate rejected,
other unclassified); cancelled counts requests
the operator stopped and is deliberately NOT part of
dropped. A dropped request cannot produce a finding, so its
checks report nothing for the same reason a clean endpoint does: read a
non-zero dropped as "the result is partial by that much",
and re-run slower (fewer threads, a per-host rate cap, a delay) before
treating the finding set as complete. The run also records the same
numbers as a Scan coverage finding. |
| GET | /api/scans/{id}/findings |
token | The job's findings as a JSON report once done (a
running job returns
{"status":"running","findings":[]}). |
| POST | /api/scans/{id}/cancel |
token | Request cancellation. Sets the job's cancel flag (so the engine opens no new connection and every queued check request returns at once) and shuts down the job's in-flight sockets, so the scan stops promptly even against an unresponsive or lagging host, not just at the next crawl/audit boundary. |
| POST | /api/jobs |
token | Run a single on-demand check as an async cancellable job (default)
or synchronously ("wait":true). Body:
{"name":...,"url"?,...check-args,"wait"?,"deadline_ms"?}.
name is one of
nosqli,aclbypass,rfd,bizlogic,csrf,ssrf,idor,xxe,cache,takeover,protopollution,massassign,storedxss,authbypass,race,smuggle,dirlist,actuator;
pass the per-check args (method, content_type,
body, headers, count,
paths) at the top level. The async form runs the check on
its own worker thread with a per-job cancel flag and a wall-clock
deadline_ms (default
FISSURE_CONTROL_JOB_DEADLINE_MS, 120000) that self-cancels
a wedged check, so it does NOT block the accept loop; answers
202 with
{"job_id","kind":"check","name","status":"running"}.
"wait":true blocks and answers 200 with
{"count","findings":[...]} like the dedicated per-check
routes. Scope-checks url when present. |
| GET | /api/jobs |
token | List ALL jobs (scans + checks):
{"jobs":[{"id","kind":"scan|check","name","target","status":"queued|running|done|error|cancelled","elapsed_sec","done"}],"running","queued","total","max"}.
The list also includes the desktop operator's OWN in-progress GUI scans
(the Target view registers each scan here as a kind:"scan"
job), so an agent and the operator see one unified job list; a
POST /api/jobs/{id}/cancel on a GUI scan signals it to
stop, exactly like a control-API job. max is the
concurrency cap: at most max jobs run at once and the rest
are queued, promoted as slots free (the cap is the
control_api_max_jobs setting, default 4, clamped to
[1,64]). A cheap non-blocking snapshot; per-job scan
progress is on GET /api/scans/{id} or
GET /api/jobs/{id}. |
| GET | /api/jobs/{id} |
token | Status of any job (scan or check) by id (same shape as
GET /api/scans/{id}; a job id is kind-agnostic). |
| GET | /api/jobs/{id}/findings |
token | The job's findings once done ({"count","findings"} for
a check, a report for a scan). Each job keeps its own results, so
concurrent jobs never overwrite each other. |
| POST | /api/jobs/{id}/cancel |
token | Cancel any running job (scan or check) by id (same mechanism as
/api/scans/{id}/cancel). |
| POST | /api/jobs/clear |
token | Drop every finished job
(done/error/cancelled) from the
job store so the monitor keeps only live
(running/queued) work. Returns
{"cleared":<count removed>,"remaining":<count left>}.
Running and queued jobs are never removed. The GUI analog is the Jobs
monitor's Clear-done button. |
| GET | /api/events |
token | The shared event log (a process-global ring), newest first:
{"count","events":[{"time":"HH:MM:SS","level":"info|notice|warn|error","source","message"}]}.
A chronological activity feed - job lifecycle (a scan/check started,
queued, done with its finding count, cancelled; source
jobs), out-of-scope refusals, code-of-conduct notices, and
warnings surfaced to the operator - the same feed the GUI Event-log
panel shows. The time-ordered complement to GET /api/jobs
(current state) and /api/jobs/{id}/findings (per-job
results), so an agent following many concurrent jobs never misses a
completion. |
| POST | /api/transform |
token | Multitool encode/decode/hash. Body:
{"input":...,"op":...}; op is one of
base64_encode/base64_decode,
base64url_encode/base64url_decode,
url_encode/url_decode,
hex_encode/hex_decode,
zlib_compress/zlib_decompress,
md5, sha1, sha256,
sha512. Returns
{"op","output","output_b64","output_len","output_binary"}.
The result is BYTES, so it is reported twice: output is the
text form, empty when the bytes are not a JSON-string-safe UTF-8 string,
and output_b64 always carries the exact bytes
base64-encoded. output_len is the true byte count and
output_binary says which field holds the answer. Read
output alone and a decode is silently wrong: it stops at
the first NUL (a base64 decode of QQBC reports
A for three bytes), a zlib_compress comes back
empty, and a hex_decode of a byte like 0xFF
emits invalid UTF-8 that makes a strict JSON parser raise on the whole
response. |
| POST | /api/smartdecode |
token | Recursively auto-peel an encoding chain. Body:
{"input":...}. Returns
{"output","output_b64","output_len","output_binary","steps":[...]}.
The last decode in a chain can land on raw bytes (a decoded binary
token, a decompressed stream), so the result is reported the same way
/api/transform reports one: output is the text
form when there is one, output_b64 always carries the exact
bytes. |
| POST | /api/protobuf |
token | Decode protobuf/gRPC wire bytes into a readable field tree (the
protoc decode_raw view). Body:
{"data":...,"encoding":"base64"|"hex"} (data
is the message bytes; encoding defaults to
base64). A leading gRPC length-prefix frame is stripped.
Returns {"decoded"}. 422 when the input is not valid
protobuf. |
| POST | /api/prettify |
token | Beautify (pretty-print / re-indent) a minified JSON/XML/JS string.
Body: {"content":...,"type"?,"message"?} (type
is
json/xml/html/js/css/auto,
default auto; message":true beautifies only the body of a
raw HTTP message and keeps the headers, picking the formatter from the
Content-Type). JSON is re-serialized via cJSON; XML/HTML and JS/CSS are
re-indented structurally (a viewing aid, never removes content). Returns
{"kind":"json"|"xml"|"js","output"}. 422 when the content
is not beautifiable. |
| POST | /api/curlimport |
token | Parse a browser's "Copy as cURL" command into a request. Body:
{"cmd": "curl 'https://host/x' -H '...' --data '...'"}.
Returns {"method","url","headers","body"} (headers as a
Name: value block, one per line). Reads what the browsers
emit (-X/--request,
-H/--header,
-b/--cookie folded into a Cookie header, the
-d/--data family, --url,
backslash continuations, single/double/$'...' quoting) and
ignores the transport switches (--compressed,
-k, -L) that say nothing about the request;
the method is POST when a body is present and no -X was
given, as curl does. It PARSES ONLY and sends nothing. 422 when the
command carries no absolute scheme://host URL, which every
browser's copy-as-cURL does: without that requirement a stray word in
any pasted text would become the target. |
| POST | /api/browserlogin |
token | Log in through a REAL browser and harvest the session. Body:
{"url","fill"?,"submit"?,"success_contains"?,"settle_ms"?,"wait_ms"?,"debug_port"?,"install"?}.
This is the login class fs.send and
/api/session-action cannot drive at all: a nonce a page
script computes, a captcha or hardware key only a person can answer, an
SSO hand-off across several origins. It opens url in a
headless Chromium over CDP, fills the CSS selectors named in
fill (a {selector: value} object, set through
the native property setter and followed by input/change events, which is
what a framework-managed form listens for), clicks submit,
waits, then reads the browser's cookies for the TARGET host back and
installs them into the suite-wide shared jar
("install": false opts out) so every later scan and
/api/request is authenticated.
success_contains is a string the logged-in page must show:
pass one, because verified then reports whether the login
actually SUCCEEDED (1 seen, 0 asked-for and never appeared, -1 not
asked), which cookies alone never prove. debug_port
attaches to a browser already listening on that DevTools port instead of
launching one, which is how a person completes a captcha in their own
window while this waits and harvests; pair it with a generous
wait_ms. Only the target host's cookies are taken, never
the identity provider's. Returns
{"ok","verified","cookie","cookie_count","installed","final_url","error"?};
final_url is where an SSO hand-off landed. Needs a
Chromium/Chrome. Active and scope-checked. |
| POST | /api/oauth-pkce |
token | The OAuth2 authorization-code flow with PKCE, end
to end. Body:
{"authorize_url","token_url","client_id","redirect_uri"?,"scope"?,"client_secret"?,"fill"?,"submit"?,"success_contains"?,"wait_ms"?,"debug_port"?,"extra"?}.
The other three grants are session actions driven by credentials alone;
this one needs a browser to render consent and a redirect to carry the
code, so it is a route of its own. It mints a code_verifier
and a state, builds the authorize URL with the S256
challenge, drives it in a browser (fill and
submit behave as on /api/browserlogin, so the
credentials go into the provider's own form), reads the
code out of the landing URL, and POSTs the exchange to
token_url carrying the verifier;
client_secret, when given, goes as HTTP Basic at the token
endpoint as RFC 6749 asks rather than in the body. A code
whose state does not match the one sent is REFUSED, which
is what the state parameter exists for: a landing URL is
attacker-influenceable and a code bound to another round trip must not
be exchanged. debug_port attaches to a browser already
running so a person can clear an MFA or consent step themselves; pair it
with a generous wait_ms. Returns
{"ok","authorize_url","landing_url","code"?,"token"?,"token_status"?,"error"?},
where token is the provider's JSON. The result is a TOKEN,
not a cookie, so nothing is installed in the cookie jar: send it as an
Authorization header. Needs a Chromium/Chrome. Active and
scope-checked. |
| POST | /api/compare |
token | Diff two values. Body:
{"a":...,"b":...,"mode":"line|word|byte"}. Returns
{"diff","similarity"}. |
| GET | /api/respools |
token | The shared concurrency and rate budgets with live counters:
{"pools":[{name,max_concurrent,rps,hosts,tools,in_flight,waiting,served}],"count"}.
in_flight and waiting are live, so this also
answers "is my scan queued behind another tool". The reply also carries
host_backoff_enabled and host_backoff:
[{host,limit,in_flight,waiting,drops,backoffs,restores}],
the ADAPTIVE per-host allowances. A pool is a ceiling the operator set;
these are learned from the targets while runs are in progress. A host
appears with a non-zero limit once it started dropping
requests and the run cut its own concurrency to it. Read it when a scan
has gone slow or quiet: it names the host setting the pace. |
| POST | /api/respools |
token | Edit the shared budgets. Body:
{"op":"set"|"remove"|"clear","name",...}. set
takes max_concurrent (sends in flight at once across the
pool, 0 = unlimited), rps (requests/sec, 0 = unlimited),
hosts (comma/space separated: an exact host,
.example.com for a domain and its subdomains, empty for
any) and tools (comma separated: scanner,
intruder, repeater; empty for all). First
matching pool wins; the built-in default pool is the
fallback and cannot be removed. A pool is the only way to bound TOTAL
pressure on a target: per-attack settings cannot see each other. Changes
apply to the next send and persist to
<config>/respools.json. Returns the updated
list. |
| POST | /api/sequence |
token | Randomness verdict for session/CSRF/reset tokens, naming which part
is predictable. Body: {"tokens":[...]} to analyze a sample
you have, or {"url","name","count"?,"source"?} to CAPTURE
first: the request is issued count times (default 50, cap
1000) and one token is extracted per response, which is the step that
otherwise means harvesting hundreds by hand. source is
cookie (default), header, json (a
top-level string field) or regex (first capture group).
Returns the aggregate metrics (shannon,
monobit, chi_square, runs_p,
longest_run, bits_per_token,
alphabet) plus weak_positions (byte offsets
carrying under half of what the alphabet allows, with their
distinct-value counts) and weak_bits, a
verdict (strong/moderate/weak/predictable, or
insufficient sample when fewer tokens were captured than
the positional and bit tests need) and a summary naming the
reason. A sample built from a single distinct byte value is
predictable, not strong: it carries no entropy at all.
Thresholds scale to the token alphabet, so a hex or base32 id is not
reported as biased for being text. Capture generates traffic and is
scope-checked. |
| POST | /api/jwt |
token | JWT workshop. Body:
{"op":"decode|verify|sign|crack",...}. decode ->
{header,payload,alg,alg_none,alg_hmac}; verify
(token,secret) -> {valid};
sign
(payload[,header,alg,secret])
-> {token}; crack
(token,wordlist) ->
{cracked,secret}. |
| GET | /api/report?format= |
token | Export the control findings as a report. format is
markdown (default), html, json,
csv, sarif, or burp. Optional
filters min_severity
(info..critical), host, and
source
(proxy/scanner/plugin/manual)
narrow the model, and exclude_triaged=1 drops findings
already triaged false-positive or ignored (the CLI's
--exclude-triaged). redact=0 renders evidence
verbatim instead of masking secrets (the CLI's
--no-redact), and tool_versions=1 probes each
installed plugin tool and records its version in the report metadata
(the CLI's --tool-versions; one short-lived subprocess per
installed tool). The report reconstructs each finding's request/response
evidence from the captures accumulated across control-API scans, so a
control/MCP report is as complete as the CLI
fissure scan --format report (a finding with no inline
evidence renders its captured exchange). Returns
{"format","risk_score","risk_band","report"}; for
html it also returns template
(custom = the operator's
<config>/report.html.tmpl, bundled =
resources/report/report.html.tmpl, builtin =
the compiled-in copy) and, when a custom or bundled template was
rejected (unreadable, empty, or missing {{findings_html}}),
template_error with the reason. |
| POST | /api/report/pwndoc |
token | Push the control findings to a PwnDoc instance. Body:
{"base_url","audit","username"?,"password"?,"totp"?,"redact"?,"language"?,"audit_type"?,"company"?,"tls_verify"?}.
Logs in, selects/creates the audit, upserts findings. Returns
{"created","updated","failed"}; 502 on a
PwnDoc/login error. Credentials are used in memory only. |
| POST | /api/report/pdf |
token | Render the findings to HTML and run a PDF command over it. Body:
{"command":<template with {{in}}/{{out}}>,"out":<path>}.
The command runs without a shell (like a plugin); out is
written. Returns
{"generated","out","template","template_error"?} (the HTML
template used, as for GET /api/report?format=html);
502 if the command fails. |
| POST | /api/intruder |
token | Run a payload-position attack. Body:
{"url_template":...,"mode":"sniper|battering_ram|pitchfork|clusterbomb|recursive","payloads":[...],"grep":{"match":...,"extract":...},"threads":n,"delay_ms":n,"retries":n}.
Mark a fuzz position by wrapping it in backticks (e.g.
?id=\X`). Supply method, headers(one "Name: Value" per line) and/orbodyto attack a FULL request instead of a URL: a marker may then sit in the method, the URL, any header or the body, which is what makes brute-forcing a login form, fuzzing a JSON body and fuzzing a cookie possible. Each result records the request as it went on the wire (request line, headers, blank line, body).payloadsis either a flat array of strings (one shared set, what sniper and battering ram use) or an array of arrays, one set per marked position: the nested form is what pitchfork (sets advance in lockstep; total = the shortest set) and cluster bomb (every combination; total = the product) exist for, so[[users],[passwords]]pairs two lists in one attack. Withmode":"recursive"(recursive grep) omitpayloadsand pass"extract"(a PCRE whose group 1, else the whole match, is carried from each response into the next request's single position), optionally"seed"(the first payload, default empty) and"count"(max requests): walks a rotating token, a pagination cursor, or a step-by-step flow; the chain stops when the extract finds nothing. Returns{"count","results":[{request,status,length,time_ms,error,retries,grep_hit,grep_value,reflected}]}(recursive mode puts each response's extracted value ingrep_value). With "config":"a saved attack config supplies every field the caller did not give (an explicit field always wins), so a tuned attack can be re-run against a different URL without respecifying it: the saved mode, its per-position payload sets, its grep rule and its payload-processing pipeline all travel with it, so the re-run sends the same number of requests and the same payload BYTES the GUI attack sends."steps"is that payload-processing pipeline given inline: an array of{"kind":"prefix" |
| GET | /api/attackcfgs |
token | List the saved Intruder attack configs:
{"count","configs":[name]}. These are the attacks an
operator tuned in the GUI; without this an agent had to respecify a
whole attack (template, mode, per-position payloads, grep, threads)
inline every time. |
| POST | /api/attackcfg |
token | Read, write or drop one saved attack config. Body:
{"op":"get"|"save"|"delete","name":<name>, ...}.
get returns the config using the same field names
/api/intruder accepts, so a caller can read one, change a
field and post it straight back; save takes those same
fields. get returns mode (the numeric enum)
alongside mode_name (its readable name), and
mode is accepted on save as either the name
(sniper, battering_ram,
pitchfork, clusterbomb) or the number, so a
config read here and posted straight back re-runs as the mode it
actually is instead of collapsing to sniper. steps (the
payload-processing pipeline /api/intruder documents) is
both returned and persisted, alongside step_count: without
it a save drops the processing the GUI attack applies and the re-run
sends raw payload bytes. A name becomes a filename, so a path separator
or .. is refused. |
| GET | /api/repeater/tabs |
token | The saved Repeater tab workspace for the active project:
{"count","active","tabs":[{id,collection,name,method,url,headers,body,sends}]}.
Reads the same repeater.json the GUI Repeater writes, so an
agent sees the requests an operator collected and can leave some behind
for them. |
| POST | /api/repeater/tabs |
token | Mutate that workspace and persist it. Body:
{"op":"add"|"remove"|"update"|"activate", ...};
add needs url (plus optional
collection, name, method,
headers, body) and returns the new
id; the others take id. Returns
{"op","id","ok","count"}. Needs an active project
directory. |
| POST | /api/discover |
token | Content discovery: GET base_url/word per wordlist
entry. Body:
{"base_url":...,"wordlist":[...],"threads":n,"delay_ms":n}.
Returns {"count","hits":[{url,status,length}]}. |
| POST | /api/shadow |
token | AI-assisted variation testing (Shadow Repeater). Body:
{"url":...,"method":"GET","headers":<string or object>,"body":...,"active":bool,"max_variations":n,"focus":<param name>,"use_ai":bool}.
Detects the request's insertion points (query parameters + a
form-encoded body), generates variations of each value (a fixed
injection battery, plus bit-flip and case-modified variants of the value
via the Intruder generators, plus, when use_ai and an AI
provider is configured via
FISSURE_AI_PROVIDER/FISSURE_AI_API_KEY/FISSURE_AI_MODEL/FISSURE_AI_BASE_URL,
model-proposed values), replays each, and reports the responses whose
status/length/timing/reflection differ from the baseline. Sending
variations is active traffic, so active":true (aggressive)
is required or nothing is sent and note explains the gate;
the target's host must be in scope. focus restricts fuzzing
to one named parameter; max_variations caps the total
(default 24). Returns
{"baseline":{status,length,time_ms},"variations_count","anomaly_count","note","variations":[{point,payload,status,length,time_ms,len_delta,time_delta_ms,status_delta,reflected,anomaly,reason}],"findings_count","findings":[...]}.
Anomalies merge into the shared store as tentative candidate
findings. |
| GET | /api/scope |
token | The control-session scope allowlist:
{"allow","deny","active"}. |
| POST | /api/scope |
token | Set the control-session scope. Body:
{"allow":...,"deny":...} (pattern text: an exact host,
.suffix, re:<regex>, or *;
deny wins). Enforced on scans (both /api/scan and
/api/scans, and recurring schedules), single requests
(/api/request), intruder, and discover: a target whose host
is out of scope is refused. /api/scan answers
403 with
{"error":"seed url is out of scope..."}, so a client that
reads only the status never records an out-of-scope scan as having run.
An empty allow+deny clears it. |
| GET | /api/scopes |
token | The named-scope set:
{"active","scopes":[{name,allow,deny}]}. A project holds
several named scopes and one active; the active one drives the enforced
control-session scope. Persisted to
<config>/scopes.json. |
| POST | /api/scopes |
token | Manage named scopes. Body: {"op":"activate","name"}
switches the active scope (immediately enforced for
scans/requests/intruder/discover);
{"op":"save","name","allow"?,"deny"?} adds/updates one;
{"op":"delete","name"};
{"op":"rename","name","new_name"}. Returns the updated set.
POST /api/scope (the singular) edits the active named
scope's patterns in place. |
| GET | /api/cookiejar |
token | The suite-wide shared cookie jar:
{"cookies":[{name,value,domain,path,secure,http_only,expires}],"count"}.
This is the jar the scanner, /api/request, and intruder
read and write (send matching cookies, absorb Set-Cookie), so a cookie
captured by one is used by the others. Persisted to
<config>/cookiejar.json. |
| POST | /api/cookiejar |
token | Mutate the shared cookie jar. Body: {"op":"clear"}
empties it;
{"op":"set","name":...,"domain":...,"value"?,"path"?,"secure"?}
adds/updates one cookie (name and domain required);
{"op":"remove","name":...,"domain"?,"path"?} deletes one
cookie and adds "removed": N to the reply (name is
required; domain and path narrow it, and
name+domain names exactly one, so a stale session id can go without
clearing the jar and losing the login; nothing matched is a 404);
{"op":"import","cookie":"PHPSESSID=abc; security=low","domain":"app.test"}
bulk-imports a session pasted out of a browser and adds
"imported": N to the reply. The import accepts what a
browser actually hands over: a bare
name=value; name2=value2 (what document.cookie
returns), the same with a leading Cookie: or
Set-Cookie: header name, several such lines at once, and a
whole copy-as-cURL command (only its -H 'cookie: ...' /
-b option is read, so the URL and the other headers do not
become cookies). domain takes a bare host, a host:port, or
a full URL, from which the host is used and an https URL
additionally marks the cookies Secure. A cookie string with
nothing cookie-shaped in it is a 400, never a silent no-op. Returns the
updated jar (as GET). |
| GET | /api/matchrep |
token | The persistent proxy match-and-replace rules:
{"rules":[{index,name,leg,host,match,replace,enabled,is_regex}],"count"}.
These rules rewrite request/response bytes in flight and are applied to
BOTH the control-driven proxy's traffic AND every control scan's
requests/responses, and persist to
<config>/matchrep.json (shared with the GUI). |
| POST | /api/matchrep |
token | Edit the match-and-replace rules. Body:
{"op":"add","leg":"request|response","match":...,"replace"?,"name"?,"host"?,"enabled"?,"is_regex"?}
appends a rule; {"op":"set","index":N,...} replaces one;
{"op":"enable","index":N,"enabled":bool} toggles;
{"op":"remove","index":N} deletes;
{"op":"clear"} removes all. match is required
and non-empty. When is_regex is true, match is
a PCRE regex and replace is a template with $N
/ ${N} capture-group backreferences (e.g.
id=(\d+) -> id=${1}0); a regex that will
not compile is rejected with 400. When false it is a binary-safe literal
replace-all. Returns the updated rule list (as GET). |
| GET | /api/hae |
token | The Highlighter/Extractor rules:
{"rules":[{index,name,pattern,scope,color,highlight,extract,enabled}],"count"}.
These passive regex rules tag captured flows: a match paints the flow
row in the rule color in the GUI proxy list and extracts its first
capture group. They persist to <config>/hae.json
(shared with the GUI popup). |
| POST | /api/hae |
token | Edit the Highlighter/Extractor rules. Body:
{"op":"add","name":...,"pattern":...,"scope"?:"request|response|any","color"?,"highlight"?,"extract"?,"enabled"?,"literal"?}
appends a rule; {"op":"set","index":N,...} replaces one;
{"op":"enable","index":N,"enabled":bool} toggles;
{"op":"remove","index":N} deletes;
{"op":"clear"} removes all; {"op":"defaults"}
appends the built-in starter set. name and
pattern are required and non-empty; pattern is
a PCRE regex (a pattern that will not compile is rejected with 400)
whose first ( ) group is what an extract rule records.
color is one of
none|gray|blue|purple|cyan|green|yellow|orange|pink|red,
listed in priority order (the highest color among the matching highlight
rules wins the flow). literal:true escapes the supplied
pattern server-side so it matches that exact text. Returns
the updated rule list (as GET). |
| POST | /api/hae/apply |
token | Score one exchange with the current rules. Body:
{"request"?,"response"?} (raw text) or
{"index":N} (a proxy-history flow). Returns
{"matches","color","extracted"}: the color that exchange
would be painted with and one name: value line per matching
extract rule. |
| POST | /api/graphql |
token | GraphQL argument workshop over a query string. Body:
{"query":...,"op":"count|arg|mutate","index"?,"value"?}.
count -> {count}; arg -> {index,name};
mutate -> {query} with the arg at index
replaced. Only live inline literal arguments are enumerated: a
# comment and an operation's variable-DEFINITION list
(query Foo($id: ID! = "x")) are skipped, so neither is
fuzzed as an argument. A rewrite keeps the argument's literal KIND: a
numeric argument given a numeric probe stays unquoted, so the document
still passes GraphQL validation on an
Int/Float argument (quoting it made the server
reject the whole query, and no probe on that insertion point ever
reached the resolver); a non-numeric probe is emitted as an escaped
string literal, which an ID/String argument
accepts. |
| POST | /api/cookie |
token | Signed-cookie workshop (Flask/Django/Rails/Express). Body:
{"cookie":...,"op":"detect|payload|verify|sign|crack|decrypt","scheme"?,"secret"?,"salt"?,"value"?,"wordlist"?}.
Scheme auto-detected when omitted. |
| POST | /api/inspect |
token | Decompose an HTTP request into sections. Body:
{"method","url","headers","body","content_type"} or
{"raw"}. Returns
{method,path,is_form,headers,query,cookies,body} (each a
[{name,value}] list). |
| POST | /api/scopeimport |
token | Parse HackerOne/Bugcrowd/XML/host-list scope text. Body:
{"text":...,"apply"?}. Returns
{"format","allow","deny","allow_count","deny_count"};
apply:true also sets the control-session scope. |
| POST | /api/jstransform |
token | Run a user JavaScript transform (QuickJS) over a string. Body:
{"script":...,"input":...}. Returns
{"output"}. |
| POST | /api/bcheck |
token | Compile a .bcheck document into a runnable QuickJS
check. Handles conditions combined by and/or, the
contains/matches/is/starts-with/ends-with operators (with
does not/is not negation) on
body/headers/status, a for each loop over an inline list or
a defined variable, and multi-step checks (each
send request called <name> captured; conditions test
named responses {first.response...}; a condition value can
reference another response's field for a variable pipeline; each step
approximated as re-sending the probe). Unsupported constructs are
skipped, not fatal. Body: {"script":<bcheck>}. A
WORKFLOW document (a workflows: block instead of
http:) is recognized too and returns
{"gates":[{"detector","tags"}],"gate_count","note"} instead
of a check: it declares which detection template gates which tags.
Dropping one in the checks directory makes every check carrying a gated
tag wait until that detector reports for a host, so a scan stops probing
for a stack the target does not run; a gate whose detector is not loaded
is ignored rather than honoured, and a scan that held checks back says
so in a "Scan coverage" finding. Returns
{"name","description","js","skipped"}; run the
js via POST /api/jscheck. |
| POST | /api/jaeles |
token | Compile a Jaeles detection-signature YAML into a runnable QuickJS
check. Compiles EVERY request (method/url/headers/body,
{{.BaseURL}} resolved to the target origin; sent in order,
detections ANDed), resolves a variables block of literal
name/value pairs ({{.name}} substitution), and its
detections: StatusCode()/ContentLength() numeric
comparisons, StringSearch(component, "text") case-insensitive contains,
and RegexSearch(component, "regex"), over
component.response/body/header, combined with
&&/` |
| POST | /api/nuclei |
token | Compile a nuclei YAML template into a runnable QuickJS check.
Handles single- and multi-request templates;
word/regex/status/size/xpath/binary matchers and dsl expressions (a
parser for nuclei's expression language: grouping, the full operator
set, the helper-function library, and the response variables including
any header by its snake_case name, with or without the suffix naming an
earlier request's response, so location_2 is the Location
of the second request) (an xpath matcher must select a node
in the HTML/XML body, evaluated by a libxml2 XPath engine behind
fs.xpath; a binary matcher searches for a hex
byte sequence in the raw response body via the binary-safe
fs.bodyhex); interactsh out-of-band matchers
(part: interactsh_protocol +
{{interactsh-url}}, confirmed by an OAST canary hit);
regex/kval/json/xpath extractors (captured value added to the evidence;
an internal: true extractor becomes a chaining variable
that this request's own dsl matchers read by bare name, as
compare_versions(version, '< 2.0') against a version the
same response just yielded, and a later request references as
{{name}}); payloads in both shapes (a fuzzing:
block injects into the live request per rule: part
query/path/header/cookie, type replace/prefix/postfix, mode
single/multiple, keys; without one the sets fill the template's own
{{name}} placeholders, combined per attack:
batteringram/pitchfork/clusterbomb under a send budget), including a set
that names a wordlist, resolved beside the shipped checks; and
raw-request templates (a raw: block) reconstructed and sent
byte-for-byte via fs.sendraw, with
{{Hostname}}/{{Host}}/{{Port}}
resolved from the target origin. Body:
{"template":<yaml>}. Returns
{"name","description","js","skipped"} (skipped
lists features not compiled: matchers on the raw part, payloads from an
external file, extra payload sets, and the two dsl variables with no
offline answer, the target's resolved IP and the text of an out-of-band
interaction); run the js via
POST /api/jscheck. A template with nothing usable is
refused. |
| POST | /api/apispec |
token | Import an OpenAPI/Swagger/Postman definition. Body:
{"spec":<json or yaml string>,"base_url"?} (a
non-JSON body is converted from YAML to JSON first). Returns
{"format","count","needs_base","endpoints":[{method,url,content_type}]}. |
| POST | /api/apispecfetch |
token | Probe a live target for a served API definition: fetch the
well-known JSON spec paths (/openapi.json,
/swagger.json, /swagger/v1/swagger.json,
/v2/api-docs, /v3/api-docs,
/api-docs, /api/swagger.json,
/api/openapi.json) and the YAML paths
(/openapi.yaml, /swagger.yaml,
/v3/api-docs.yaml) under the origin, and import any OpenAPI
3 / Swagger 2 document found (a YAML body is converted to JSON first),
pinned to the live origin (the spec's API path prefix is kept; a
wrong/relative spec host is overridden). Scope-checked on the base host.
Body: {"base_url":<a URL on the target>}. Returns
{"format","hit_path","specs_found","paths_tried","count","endpoints":[{method,url,content_type}]}. |
| POST | /api/saml |
token | SAML SSO assertion workshop (decode/edit/strip/wrap/re-sign). Body:
{"op":<action>,...}. op =
decode (input base64/DEFLATE blob ->
{xml,deflated}; the binding is detected by sniffing the
decoded bytes for XML text, not by their first byte, since a raw DEFLATE
stream can itself start with 0x3C), encode
(xml, redirect? -> {encoded}),
inspect (xml ->
{info:{issuer,name_id,destination,attributes,signed,signature_valid,signature_count,signature_detail,signatures:[{index,signs,uri,result,valid}]}}:
EVERY ds:Signature is checked and reported, since a signed
Response plus a signed Assertion is the common enterprise shape and the
message is only valid when they all verify), set_nameid
(xml,value), set_attribute
(xml,name,value),
strip (xml), xsw
(xml,variant 1-3,value forged
NameID: 1 puts the forged assertion before the original as a sibling, 2
moves the original into a ds:Object inside its own
ds:Signature grafted onto the forged assertion, 3 moves the
original into a samlp:Extensions wrapper; the signed
assertion is located anywhere in the document), genkey
(-> {key_pem,cert_pem}), sign
(xml,key_pem,cert_pem? ->
{xml}), verify
(xml,cert_pem? ->
{valid,code,detail}; every signature in the message must
verify, and detail names which one failed when several are
present). The edit/strip/wrap ops return {xml}. Returns 501
if the build lacks the SAML libraries. |
| POST | /api/recon |
token | Route recon-tool output into the inventory and, when
add_scope, the control-session scope. Accepts bare hosts,
plain URLs, and JSON-per-line output (katana -jsonl, httpx
-json, whose endpoint is extracted from
request.endpoint/url/input).
Body:
{"text":<tool output>,"scheme"?="https","add_scope"?=true,"scope_filter"?=true}.
Returns
{"hosts_added","urls_added","out_of_scope","lines","scope_added","count","hosts":[...],"endpoints":[{method,url}]}. |
| POST | /api/screenshot |
token | Capture a PNG screenshot of a page with a headless browser (recon
visual triage), saved under <config>/screenshots/.
Scope-checked; a passive capture (loads the page over CDP, does not
attack). Body: {"url":...}. Returns
{"ok","url","path","name"}; returns 501 when no
Chromium/Chrome is available. |
| GET | /api/screenshots |
token | List the captured recon screenshots (the gallery index). Returns
{"screenshots":[{"name","path"}]}. |
| POST | /api/wafdetect |
token | Fingerprint the WAF/CDN fronting a target (wafw00f-class). Matches
response headers, cookies, and block-page body against known signatures
(Cloudflare, Akamai, AWS CloudFront/WAF, Imperva Incapsula, F5 BIG-IP
ASM, ModSecurity, Sucuri, Fastly, Citrix NetScaler, Fortinet FortiWeb,
Barracuda, ...). Header and cookie signatures are vendor-specific names;
a block-page BODY signature whose token could occur in ordinary prose is
corroborated by a second token from the same block page, so a page that
merely mentions a vendor, or says a request was blocked, is not
fingerprinted as one. Pure recon (inspects a response, does not
attack/evade). With url it fetches the target
(scope-checked); with headers/body it scans
those directly. Body: {"url":...} or
{"headers":...,"body"?}. Returns
{"waf":"<names>","detected":bool,"url"?,"suggested_encoders":"<chain>","suggested_request":"<shapes>"},
where the two suggestions are where to START the input-filter bypass for
the product it fingerprinted (pass them to POST /api/scans
as waf_encoders / waf_request) so an operator
does not spend a scan per guessed chain. They are a starting point and
NOT a claim that the chain defeats that product: which transform gets
through depends on the rule set in front of THIS application and on the
backend behind it, neither of which a product name settles. |
| POST | /api/wafbypass |
token | Transform a payload into input-filter (WAF/CDN) bypass variants to
demonstrate an AUTHORIZED, in-scope vulnerability past a blocking filter
(a WAF is a mitigation, not a fix). encoders is a comma
chain from the full encoder set (available in the reply
lists it: case, space2comment, space2plus, space2tab, space2hash,
space2dash, space2randomblank, multiplespaces, randomcomment,
commentbeforeparentheses, percentage, apostrophemask, overlongutf8, url,
urlall, url2x, charunicodeurlencode, versionedkeywords,
nonrecursivereplacement, symboliclogical, equaltolike, jsonpad,
jsonunicode, xmlbypass, utf16), applied in order. jsonpad
only transforms a JSON OBJECT body (anything else passes through
unchanged) and no longer leaves a trailing comma on an empty object.
utf16 produces bytes containing NULs: it must be the LAST
encoder of a chain (a chain that puts another encoder after it is
refused rather than silently truncated), and because this route answers
with a JSON string, its result is cut at the first NUL here; use the
GUI/Multitool path, or POST /api/request with
body_b64, when the raw UTF-16 bytes are what you need to
send. Pure transform, no traffic. Body:
{"payload":...,"encoders"?}. Returns
{"result","encoders","available","notice"} where
notice is the non-blocking code-of-conduct reminder (also
recorded in the event log). It defeats a blocking INPUT FILTER to prove
a bug; it must NOT be used to conceal activity from the target
owner. |
| POST | /api/wafbypass/resend |
token | The ACTIVE one-click counterpart to /api/wafbypass:
send the request as-is, then again with the encoder chain applied to its
query string and body, and report whether the response changed (a
blocked payload getting through). Body:
{"url":...,"method"?,"headers"?,"body"?,"encoders"?}.
Generates traffic and is scope-checked (an out-of-scope url is refused
with 403). Returns
{"encoders","available","original":{"status","length"},"bypassed":{"status","length"},"changed","notice"};
changed is true when the encoded request got a different
status or length than the original. Same authorized-use-only
code-of-conduct condition and notice as
/api/wafbypass. |
| POST | /api/wafrequest |
token | Preview a REQUEST-shaped input-filter bypass: the companion to
/api/wafbypass, which transforms the payload VALUE. These
change how the REQUEST carries it, which is the only way to express the
bypasses a payload encoder cannot (the transport URL-encodes what it is
handed into one literal parameter value). shapes is a comma
chain from pollute (send the parameter twice, benign value
first, for a filter that inspects the FIRST occurrence and an
application that takes the last), pollutelast (the same
pair reversed), bracket (send the name as
name[], which PHP/Rails map back to the same variable),
dotnotation (name.x, for a binder framework),
charset (declare a character set the filter and the
application disagree about) and mpboundary (quote and pad
the multipart boundary) and mpduplicate (a second
Content-Disposition name on the fuzzed part). Pure transform, no
traffic. Body: {"shapes":...,"name"?,"value"?,"original"?}
(the last three seed the preview; defaults id/payload/1). Returns
{"pair","content_type","multipart_content_type","shapes","unknown","available","notice"},
where unknown names any shape this build does not know, so
a misspelled chain is visible instead of silently doing nothing; a chain
naming ONLY unknown shapes is a 400. To run a scan with them pass the
same chain as waf_request to POST /api/scans.
Same authorized-use-only code-of-conduct condition and
notice as /api/wafbypass. |
| POST | /api/originip |
token | Origin-IP discovery (CWE-200): confirm which candidate IPs are the
real origin of a CDN/WAF-fronted host. For each IP in
candidates (a comma/space list of ip or ip:port, from
recon), connects directly to it while sending
Host: <host> (a per-host connect rewrite) and flags a
candidate that serves the site as a likely origin reachable behind the
CDN (a WAF / rate-limit / cache bypass). Both schemes are tried, and a
redirect that stays on the target host counts as reachable, so an
HTTPS-only origin is no longer missed. Serving a page is not on its own
evidence: a box that answers the same page to every Host is
not an origin. The candidate must also differ from a
bogus-Host control, and its body must match the site
fetched through its own name. Both hold gives a FIRM finding; an
unreachable reference gives TENTATIVE with the reason in the evidence; a
mismatch reports nothing, so zero findings for a reachable candidate is
a valid answer. Candidate generation is the recon side (the caller's).
Scope-checked on the host AND on every candidate: each
ip[:port] is run through the same allowlist before anything
is sent to it, the refused ones come back in out_of_scope,
and a call whose candidates are all out of scope is a 400 rather than a
sweep of arbitrary addresses. Generates traffic to each allowed
candidate. Body: {"host":...,"candidates":"ip[:port],..."}.
Returns
{"count","probed","out_of_scope":[...],"findings":[...]}. |
| GET | /api/assets |
token | Recon asset inventory + new-since-last-run diff: the endpoint
inventory and the recon feed rolled up to host-level assets, each with a
live/dead status, detected technology, and endpoint count, diffed
against the saved baseline snapshot. Returns
{"assets":[{"host","origin","status","live","tech","endpoints","new","changed"}],"gone":[host...],"summary":{"total","live","new","changed","gone"},"baseline_saved":false}. |
| POST | /api/assets |
token | Same as the GET, with two options in the body: text
(recon-tool output: bare hosts, URLs, or httpx/katana JSONL) is merged
into the asset inventory before the diff, so httpx -json
lines add live status + tech; snapshot=true saves the
current assets as the new baseline so the next diff measures the delta
from here. Body:
{"text"?=<recon output>,"snapshot"?=false}. Returns
the same shape as the GET, with baseline_saved reflecting
the save. |
| POST | /api/target/highlight |
token | Set (or clear) one endpoint's manual highlight color, mirroring the
Target grid Highlight button. Body:
{"url":...,"method":"GET","color":"red"}; the endpoint is
addressed by its method + canonical URL (as listed under
/api/surface) and color is one of
red|orange|yellow|green|blue|purple (an empty or absent
color clears it; an unknown color is rejected with 400). The color is
stored on the endpoint and persists with the endpoint inventory. Returns
{"ok":true,"method":...,"url":...,"color":...}. 404 when no
endpoint matches that method + url. |
| GET | /api/surface |
token | Attack-surface rollup over the endpoints accumulated from control
scans. The control layer keeps a durable endpoint inventory that each
/api/scan and /api/scans folds its discovered
endpoints into; this route summarizes it. Returns
{"endpoints","hosts","total_params","with_query","with_body","dynamic","static","auth_required","unauth","findings","sources":{proxy,crawl,import,discover,recon},"methods":{get,post,other},"status":{2xx,3xx,4xx,5xx,other}}.
dynamic/static split on whether an endpoint
takes input (query params or a body) vs is a plain asset;
auth_required counts endpoints whose captured request
carried an Authorization or Cookie header. An all-zero result means
nothing has been scanned yet in this control session. |
| POST | /api/reconchain |
token | One-action recon chain: run every installed recon-category plugin
(subfinder/amass/gau/waybackurls/katana/httpx/dnsx...) against a seed
host in sequence, then route their combined output into the inventory
and scope exactly as /api/recon. Scope-checked (an
out-of-scope seed is refused before any tool runs); an absent tool is
skipped and counted. Body:
{"url":<seed host or URL>,"scheme"?="https","add_scope"?=true,"scope_filter"?=true}.
Returns
{"tools_total","tools_ran","tools_absent","tools_failed","hosts_added","urls_added","out_of_scope","lines","scope_added","count","hosts":[...],"endpoints":[{method,url}]}
plus any findings the tools emitted. |
| POST | /api/headlesscrawl |
token | Headless (JS-rendering) crawl: run katana with a system Chromium
(-headless) against the seed so single-page-app routes and
dynamically built links that a static crawl never sees are discovered,
then route the rendered URLs into the inventory and scope exactly as
/api/recon. Scope-checked (an out-of-scope seed is refused
before the browser runs); tool_present is false when the
crawler is not installed. Body:
{"url":<seed URL>,"scheme"?="https","add_scope"?=true,"scope_filter"?=true}.
Returns
{"tool_present","failed","hosts_added","urls_added","out_of_scope","lines","scope_added","count","hosts":[...],"endpoints":[{method,url}]}. |
| POST | /api/spider |
token | Native CDP single-page-app interaction crawl: drive a headless
Chromium (bundled Fissure Browser or system Chrome) the way a user does,
navigating the seed, enumerating the live DOM, following addressable
client-side routes, exercising buttons/forms, and capturing the
XHR/fetch/navigation endpoints the app calls at runtime, then route the
discovered URLs into the inventory and scope exactly as
/api/recon. De-duplicated by an app-state signature and
bounded by
max_states/max_actions/settle_ms.
Complements the static crawl and the katana-delegating
/api/headlesscrawl. Scope-checked (an out-of-scope seed is
refused before the browser runs) and active (it drives a real browser).
Body:
{"url":<seed URL>,"max_states"?,"max_actions"?,"settle_ms"?,"cookie"?,"scheme"?="https","add_scope"?=true,"scope_filter"?=true}.
Returns
{"tool_present","failed","script_missing","states","actions","requests","hosts_added","urls_added","out_of_scope","scope_added","count","hosts":[...],"endpoints":[{method,url}]},
plus an error string when the crawl could not run.
script_missing marks an incomplete install (no
resources/spider/enumerate.js) rather than a missing
browser, so the caller is not told to install a Chromium it already
has. |
| POST | /api/jsmine |
token | Mine endpoint URLs (fetch/XHR/route tokens) and secrets out of a
JavaScript body, resolved against base_url. Body:
{"js":<javascript>,"base_url"?}. Returns
{"count","endpoints":[{method,url}],"secrets":[...]}. |
| POST | /api/race |
token | Automated race-condition (limit-overrun) probe (CWE-362). Fires
count (default 8) identical state-changing requests
concurrently with the single-packet / HTTP-1 last-byte-synchronized
primitive, then a settle request. Flags a limit overrun when 2+
concurrent requests were accepted with the same success response while
the settle request was then rejected (a check-then-act/TOCTOU window:
double-spend, coupon / gift-card reuse, one-time-token or
one-per-account reuse). Self-skips when fewer than 2 concurrent
successes, or when the settle also succeeds (the action is simply
repeatable, not limited). Scope-checked; SUBMITS the request many times
(aggressive). Body:
{"url":...,"method"?="POST","headers"?,"body"?,"count"?}.
Returns
{"count","concurrent_success","total","findings":[...]}. |
| POST | /api/request/raw |
token | Send BYTE-EXACT bytes to a host and return what comes back. Body:
{"host","port"?,"tls"?,"raw_b64"|"raw","timeout_ms"?,"pipeline"?}.
The only send that does not reframe the message:
/api/request builds a well-formed request from a method +
url + headers, which is exactly what you must not have when confirming a
smuggling, CRLF-injection or parser-differential finding.
raw_b64 is base64 (for bytes a JSON string cannot carry,
such as a NUL); raw is the same escape syntax the GUI raw
editor uses (\r \n \t
\0 \\ \xHH, everything else
literal), and a malformed escape is a 400 rather than a
silently different message. pipeline keeps reading past the
first framed response, which a desync differential needs. Returns
{host,port,tls,sent_bytes,connected,timed_out,ttfb_us,response_bytes,response,response_b64}.
GENERATES TRAFFIC; scope-checked. |
| POST | /api/smuggle |
token | Probe a URL for an HTTP request-smuggling (desync) vulnerability by
timing (length-ambiguous Content-Length vs Transfer-Encoding, plus CL.CL
duplicate Content-Length), then confirm a hit with the
differential-response method (a smuggled prefix poisoning a following
request); on a TLS target it also probes the HTTP/2-downgrade variants:
H2.TE (an HTTP/2-forbidden Transfer-Encoding header that hangs a
downgrading front-end), H2.CRLF (the Transfer-Encoding hidden in a
header value behind a CRLF), H2.SPLIT (a whole second request line
CRLF-injected into a header value - request splitting, the
response-queue-poisoning primitive), and H2C (the origin accepts a
cleartext h2c Upgrade over HTTP/1.1). Scope-checked; intrusive. Body:
{"url":...,"timeout_ms"?}. Returns
{"verdict":none|tecl|clte|clcl|h2te|h2crlf|h2split|h2c,"confirmed","reachable","baseline_ms","count","findings":[...]}. |
| POST | /api/deser |
token | Scan a value for serialized-object signatures
(insecure-deserialization leads, CWE-502): a Java serialized stream
(base64 rO0AB or the raw aced0005 magic), a
PHP serialized object (O:len:"Class":n:{), an ASP.NET
__VIEWSTATE field, a Python protocol-4 pickle (base64
gASV). Pure analysis (no traffic), not scope-checked. Body:
{"text":<value>,"url"?,"source"?}. Returns
{"count","findings":[...]}. |
| POST | /api/deserchain |
token | Build a BENIGN, OAST-confirmed deserialization marker to ACTIVELY
confirm a lead from /api/deser, responsibly: a
self-contained Python pickle whose only effect on load is one
out-of-band callback (an HTTP GET or a DNS lookup) to an OAST canary -
never a shell, command, or arbitrary code. Body:
{"platform":"python-pickle-http"|"python-pickle-dns","canary"?}.
Pass an explicit canary (a URL for http, a host for dns),
or start the OAST listener and one is minted (a token is
returned to poll /api/oast/history). Generating it is pure
(no traffic); SENDING it to a target goes through the scope-gated send
routes. Returns
{"platform","canary","payload_b64","benign":true,"note"[,"token"]}.
For Java/.NET/PHP gadget chains, drive ysoserial via the plugin host
using its benign DNS gadgets. |
| POST | /api/upload |
token | Test a file-upload endpoint (CWE-434): submit a set of malicious
upload variants (executable/double/alternate/mixed-case extension,
content-type spoof, magic-byte GIF+PHP polyglot, null-byte truncation,
path-traversal filename, SVG/HTML stored-XSS) to the multipart URL and
report which the server accepted without an obvious rejection. Active
and scope-checked. Body:
{"url","field"?,"cookie"?,"headers"?} (field
defaults to file; cookie is a
a=b; c=d string, or headers a raw header
block, whose Cookie/Authorization lines authenticate the probe against
an auth-gated endpoint). Only a 2xx counts as accepted. After an
accepted dangerous variant, fetches likely served locations (the
endpoint's directory, common upload dirs, the web root) and looks for
the marker to confirm the file is stored and reachable. Returns
{"url","count","accepted","confirmed","findings":[...]}
(count = findings emitted). A confirmed served file is a certain finding
(critical when the payload executed), an accepted-but-unconfirmed one is
tentative. Shared with the scan/GUI via fissure_checks_upload. |
| POST | /api/jslib |
token | Detect known-vulnerable front-end JavaScript libraries
(retire.js-style): fingerprint a library name + version from a body
and/or script URL (jQuery, AngularJS, Bootstrap, lodash, Moment.js,
Handlebars, DOMPurify, ...) and flag a version below the first fixed
release from a curated offline advisory table (CWE-1104). Pure analysis
(no traffic), not scope-checked. Body: {"body"?,"url"?} (at
least one). Returns
{"count","libs":[{lib,version,fixed_in,cve,severity,detail}]}. |
| GET | /api/scanprofiles |
token | List the named scan-configuration profiles (built-in presets: the
intensity presets Passive/Quick/Balanced/Deep plus the dedicated
API/Injection/Access control/Client-side/Gentle profiles, then the
user's saved profiles). Returns
{"count","profiles":[{name,builtin,max_depth,max_pages,delay_ms,run_active,aggressive,max_threads,scan_rps,time_host_concurrency,time_delay_secs,time_timeout_pad_ms,time_reconfirm_needed,time_reconfirm_max,oast_wait_ms,retry_backoff_ms,families,points,summary,extra_headers,exclude}]}.
The six timing fields, extra_headers and
exclude carry the same meaning as the POST
knobs below (0 / empty = the built-in default).
families/points are comma-separated name lists
("all" = every check/point). summary is a
one-line, human-readable description of what the profile enables (active
vs passive, aggressive on/off, crawl depth, and the
family/insertion-point selection), the same text the Target-view profile
picker shows. |
| POST | /api/scanprofiles |
token | Manage scan profiles. Body:
{"op":"save|delete","name",...knobs} where knobs include
max_depth, max_pages, delay_ms,
run_active, aggressive,
max_threads, max_time_sec (wall-clock budget
in seconds, 0 = unlimited), scan_rps (per-host request-rate
cap in requests/sec, 0 = unlimited), and
time_host_concurrency (max concurrent time-based sleep
probes per host, 0 = default, <0 = unlimited). It also carries the
six detection-timing knobs (each 0/omitted = the built-in default):
time_delay_secs (injected blind sleep seconds, default 5,
range 3-30), time_timeout_pad_ms (extra timeout over that
sleep, default 5000), time_reconfirm_needed and
time_reconfirm_max (clean re-measures to confirm a
time-based hit, and the round cap, default 2/2),
oast_wait_ms (out-of-band callback poll window, default
600) and retry_backoff_ms (retry pause, default 250). It
also carries extra_headers (a string, one "Name: Value" per
line, added to every scan request) and exclude
(comma/space/newline-separated URL-path substrings the crawl+audit
skip): a saved profile carries a complete scan configuration (this
tuning is per-profile, not global). save creates/updates a
user profile; a built-in preset cannot be changed (400). A
profile may restrict the scan with "families" (a comma list
of
deser,graphql,protopollution,massassign,storedxss,csrf,xxe,idor,cache,files,takeover,injection,ssrf,authbypass,nosqli,aclbypass,rfd,bizlogic,passive,xss,sqli,ssti,crlf,lfi,cmdi,redirect
(injection is an umbrella: listing it runs
xss,sqli,ssti,crlf,lfi,cmdi,redirect, and listing one of those runs ONLY
it; passive masks the native passive suite); injection is
the core engine and is itself maskable) and "points"
(query,body,headers); an empty/omitted list means all. Returns the
updated list. Reference a profile from the scan job via a
"profile" field on POST /api/scans. |
| POST | /api/auth/check |
token | Verify the target's configured authentication WITHOUT running a
scan. Body:
{"url":...,"login"?:<login-config object>}.
login is the login config itself (the same object
/api/scans takes, an ordered-steps object, or its JSON
string), not a path on the server. Fetches url twice, once
with no session and once with the session the configured route
establishes (the login config when given, else the parameter jar's
crawl-priming POSTs, else whatever the shared cookie jar holds), and
compares. Returns
{"verdict","route","detail","anon_status","auth_status","anon_length","auth_length","cookies","tracked_params","ran"};
verdict is ok / failed /
inconclusive / none / error. Pass
a URL that REQUIRES login: a public page cannot distinguish a working
session from a broken one and the verdict is then
inconclusive, deliberately, rather than a false pass.
GENERATES TRAFFIC (it logs in, and priming POSTs write to the
target). |
| GET | /api/paramjar |
token | The request parameters a crawl carries, and the jar settings.
Returns
{"params":[{name,value,live,refresh_url?,on,query,body,track,nofuzz,required}],"count","tools":[...],"crawl_post","submit_forms","post_urls":[{url,body?}],"serialized"}.
This is the cookie jar's counterpart for a session that lives in a
request PARAMETER: a rotating anti-CSRF token, an API key in the query
string, or a login form's credential fields. value is the
configured value and live is what a tracked row has since
picked up from a response, so a caller can watch a token rotate.
serialized is true when a track+required row forces
jar-carrying sends to run one at a time (correct for a single-use token,
and a real slowdown). Persisted to
<project>/paramjar.json. |
| POST | /api/paramjar |
token | Manage the request-parameter jar. Body:
{"op":"set|remove|clear|reset_live|tools|crawl_post|post_url_add|post_url_remove|post_urls_clear", ...}.
set creates/updates a row (needs name;
optional value, refresh_url and the flags
on/query/body/track/nofuzz/required
- an omitted flag defaults as the GUI does, with on,
query and nofuzz on; an enabled row with
neither query nor body is a 400,
since it would never be sent). remove deletes the row named
name; clear deletes all;
reset_live forgets every tracked value so each row falls
back to its configured one. tools sets which tools carry
the jar ("tools":"scan,repeater,intruder", empty switches
it off). crawl_post ("enabled") turns on the
priming pass that POSTs the URLs below before a crawl, which WRITES to
the target. submit_forms ("enabled") makes the
crawl SUBMIT the forms it discovers rather than only record them; that
writes to the target with data the caller did not choose, needs the
scan's aggressive mode as well, and still refuses a logout form, a file
upload and a destructive-looking form, submitting each form once.
post_url_add ("url", optional
"body"), post_url_remove
("index") and post_urls_clear manage that
list. Returns the updated jar. A jar value is never sent to an
out-of-scope host and is redacted out of finding evidence. |
| GET | /api/useragents |
token | List the named User-Agent presets and the active selection. Returns
{"count","active"?,"active_value","useragents":[{name,builtin,value}]}.
The built-in presets are the Fissure default plus common browser
(Chrome/Firefox/Safari/Edge, desktop and mobile), crawler
(Googlebot/Bingbot) and command-line-tool (curl/wget/python-requests)
strings, followed by the user's saved presets. active is
the selected preset name (absent = the built-in default);
active_value is the exact header value the engine sends.
Persisted to <config>/useragents.json. |
| POST | /api/useragents |
token | Manage User-Agent presets and the active selection. Body:
{"op":"save|delete|activate","name"?,"value"?}.
save creates/updates a user preset (needs name
+ value); a built-in preset cannot be changed
(400). delete removes a user preset by name (a
built-in cannot be removed; if it was the active selection, the active
selection resets to the built-in default). activate selects
the active preset by name (an empty/omitted name selects
the built-in default; an unknown name is a 400). Activating
pushes the resolved value into the request engine immediately, so every
subsequent scan, POST /api/request send,
POST /api/intruder attack, active check, and recon request
uses it unless that request carries its own user_agent
override. Returns the updated list. The active User-Agent applies
process-wide; a per-run override is available as a
"user_agent" field on POST /api/request,
POST /api/intruder, and POST /api/scans. |
| GET | /api/schedules |
token | List the recurring scan schedules. Returns
{"count","schedules":[{id,name,url,profile,active,aggressive,interval_sec,enabled,last_run_us,last_findings,delta_since_last,last_status}]}.
The server's scheduler thread fires each due schedule and records the
run. |
| POST | /api/schedules |
token | Manage recurring scan schedules. Body:
{"op":"add|remove|enable|disable|run",...}.
add takes
{url,name?,profile?,active?,aggressive?,interval_sec}; the
rest take {id}. run forces the schedule due so
the scheduler fires it on its next tick. Persisted to
<config>/schedules.json; schedules fire while the
control API is running. Returns the updated list. |
| POST | /api/remediation |
token | Look up curated fix guidance + authoritative references (OWASP cheat
sheets, CWE entries) for a vulnerability class, by CWE
("cwe":"CWE-89") or category
("category":"SQL Injection"). The same library the report
uses to fill in remediation and a References section. Body:
{"cwe"?,"category"?} (at least one). Returns
{"found",("cwe","category","remediation","references")}. |
| POST | /api/takeover |
token | Fingerprint a host for a subdomain takeover (a dangling DNS record
to a de-provisioned cloud/SaaS resource). Fetches https then http on the
host (or the given URL directly) and matches the body against
distinctive provider "unclaimed resource" fingerprints (GitHub Pages,
S3, Heroku, Fastly, Shopify, ...). Scope-checked. Body:
{"host":<host or URL>}. Returns
{"count","findings":[...]}. Firm - confirm the CNAME still
points to the provider. |
| POST | /api/cache |
token | Web cache poisoning + cache deception. Poisoning: for each unkeyed
request header (X-Forwarded-Host, X-Host, X-Forwarded-Server,
X-HTTP-Host-Override, Forwarded), inject a random host marker on a
cache-busted URL, then re-fetch the same URL without the header; if it
still carries the marker, the header was cached and is served to every
visitor (CWE-349, firm). Deception: a static-suffix path
(/x.css) that returns the same page with
Cache-Control: public (CWE-525, tentative). GET-only,
scope-checked; only writes a cache-busted probe entry. Body:
{"url":...}. Returns
{"count","findings":[...]}. |
| POST | /api/idor |
token | Object-ID enumeration (IDOR / broken object-level authorization):
for each id-like path segment (numeric, UUID, long hex) and numeric
query param of the URL, fetch the baseline, a control id unlikely to
exist (to confirm the endpoint is object-scoped), and neighbor ids
(value +/-1, sibling UUID); flag when a neighbor returns a distinct 200
whose body is structurally similar to the baseline but not identical
(another subject's object). GET-only (idempotent), scope-checked;
replays the control session. Body: {"url":...}. Returns
{"count","findings":[...]}. Tentative - confirm
ownership. |
| POST | /api/authbypass |
token | Reverse-proxy / auth-header authentication bypass: (1) baseline -
the URL must DENY an anonymous request (401/403 or a login redirect) or
nothing is probed; (2) control - a header the app cannot trust
(X-Fissure-Auth-Probe) must stay denied, else the endpoint
reacts to any header and is skipped; (3) forge each trusted
identity/forwarding header in turn (X-WEBAUTH-USER, X-Remote-User,
X-Forwarded-User, X-Auth-Request-User, X-SSL-Client-CN set to
admin; X-Forwarded-For / X-Real-IP / X-Client-IP set to
127.0.0.1; plus a malformed traversal Authorization token) and flag any
that flip the deny to an authorized 2xx (CWE-290, A07; critical for an
identity header that impersonates a user, high for a trusted-address or
malformed-token bypass). GET-only, unauthenticated (a fresh session),
scope-checked. Body: {"url":...}. Returns
{"count","findings":[...]}. Confirm the returned content is
the privileged resource. |
| POST | /api/dirlist |
token | Directory-listing (auto-index) probe (CWE-548). A server with
automatic directory indexing left on serves a generated file list for
any directory that has no index page, mapping everything stored there
including files nothing links to (uploads, backups, editor and swap
files, dumps, archives). Requests every ancestor directory of
url, the caller's paths (a comma/space string
or a JSON array of paths, e.g. the directories a crawl observed), and a
built-in well-known set: uploads, files, images, assets, media, backup,
backups, tmp, temp, logs, data, includes, inc, lib, vendor, config,
private, cgi-bin, plus the WordPress tree wp-content,
wp-content/uploads, wp-content/plugins, wp-content/themes, wp-includes.
A directory is reported only when it answers 200 AND the body is a
genuine generated index (Apache/nginx Index of /, Tomcat
and Python http.server Directory listing for /, IIS
[To Parent Directory]), each anchored to the title/heading
that emits it so a page merely quoting the phrase is not reported.
MEDIUM when the directory name holds uploads, backups, logs,
configuration or version-control data, LOW otherwise; the evidence names
the server flavor and the first listed entries. Capped at 128
directories per call (the well-known set is queued before
paths, so a long crawl-derived list cannot crowd it out;
anything dropped past the cap is logged); redirects are not followed;
scope-checked; generates traffic. Also runs per host in an active scan
under the files check family, and is dispatchable as an
async job (POST /api/jobs with
"name":"dirlist"). Body:
{"url":...,"paths":...}. Returns
{"count","checked","findings":[...]}. |
| POST | /api/logpoison |
token | Log-file poisoning through a file-inclusion point: the LFI-to-RCE
chain (CWE-98). A file-inclusion bug that only reads files is a medium;
if one of the files it can read is one that any request WRITES, it is
remote code execution. Every web server records requests, headers
included, in its access log, so a value in the User-Agent lands verbatim
on disk. url is the inclusion point WITH its query (e.g.
http://t/vuln.php?page=x) and param names the
inclusion parameter whose value is replaced; a param that
is not present in url is a 400 rather than a silent "not
vulnerable". Stage 1 plants a self-identifying marker in the User-Agent
of one ordinary request, then points param at each
candidate log (the Apache, nginx, lighttpd and IIS access and error
logs, plus /proc/self/environ, where the User-Agent reaches
a CGI environment instead of a file: that one exposes the CURRENT
request's process, so the marker rides on the inclusion request itself
and a control request pointed at a path that cannot exist rules out an
application that merely echoes the header), each tried as an absolute
path AND behind a traversal prefix, since an include that prepends its
own directory cannot take an absolute path; paths (a
comma/space string or a JSON array) adds target-specific candidates. The
marker coming back proves the application includes an attacker-writable
file: HIGH. Stage 2 requires "aggressive":true AND a
running OAST listener (POST /api/oast/start): it re-plants
a marker whose entire effect is ONE out-of-band callback, includes the
log again, and a canary hit proves the log contents are EXECUTED:
CRITICAL, with out-of-band proof rather than an inference. Benign by
construction (no shell, no command, nothing written outside that log
line), the same confirm-do-not-exploit line as
/api/deserchain. It APPENDS an identifiable marker line to
the target's log and never edits, truncates or removes anything; the
returned marker is what the report quotes so the owner can
find that exact line and clear it. Scope-checked; generates traffic.
cookie ("PHPSESSID=..; security=low") is added as a
Cookie: header to every request the probe sends, which most
real inclusion points need to reach anything but the login page. Body:
{"url":...,"param":...,"paths":...,"aggressive":...,"cookie":...}.
Returns
{"count","included","executed","log_path","marker","tried","oast_running","findings":[...]}. |
| POST | /api/rfd |
token | Reflected File Download (OWASP RFD, CWE-79). Detects an endpoint
that reflects a caller-controlled value into a downloadable (non-HTML)
response with no Content-Disposition filename AND accepts an arbitrary
trailing path segment (a ;/name.bat path parameter), so a
link on the trusted origin downloads an attacker-controlled
batch/command file named from the URL. Three conditions confirmed:
baseline reachable + non-HTML + no pinned filename; a command-shaped
marker injected into a query parameter (or a JSONP callback) is
reflected unescaped; the ;/name.bat probe still serves the
endpoint (2xx). Tentative MEDIUM. GET-only, aggressive, scope-checked.
Body: {"url":...}. Returns
{"count","findings":[...]}. |
| POST | /api/aclbypass |
token | URL-level access-control bypass (401/403 bypass). Distinct from
/api/authbypass (forge WHO you are); this forges WHICH url
is authorized. On an endpoint that denies an anonymous request (with an
untrusted control header first), two arms: (1) URL-override headers
(X-Original-URL / X-Rewrite-URL / X-Override-URL / X-Original-URI) sent
to the origin root naming the denied path - a served 2xx whose body
differs from a plain root fetch means the front-end re-routed to the
protected resource (CWE-284); (2) path-normalization variants of the
denied path (trailing slash, //, /.,
%2f, trailing %20/%09, a
..;/ segment) - a served 2xx on a variant is a
normalization bypass (CWE-288). Each deny-to-2xx flip is a FIRM finding.
Offensive access-control testing (reach the resource), not
detection-evasion. GET-only, unauthenticated, scope-checked. Body:
{"url":...}. Returns
{"count","findings":[...]}. |
| POST | /api/protopollution |
token | Server-side prototype pollution. With method POST
(default) send a JSON body carrying a __proto__ gadget
(then the constructor.prototype variant); with
method GET use the query-string vector instead
(?__proto__[<uniq>]=<uniq> and
?constructor[prototype][<uniq>]=<uniq>, the
bracket gadgets a qs-style parser expands). Either injects a unique
property into Object.prototype, then a second payload-free
request checks whether it comes back - meaning an object inherited it
from the polluted prototype (CWE-1321, A08, HIGH, tentative). Mutates
server-side global state, so it is aggressive and scope-checked. Body:
{"url":...,"method"?="POST"}. Returns
{"count","findings":[...]}. |
| POST | /api/storedxss |
token | Stored / second-order XSS (CWE-79) by write-then-read correlation:
write a unique executable canary (a nonce in an
<svg/onload=...> payload) through the endpoint - one
form field or JSON leaf at a time - then GET the read URL (the write URL
with the query stripped by default, or read_url) and flag
stored XSS when the canary comes back UNENCODED in that separate
response. An HTML-encoded canary is not flagged. Writes persistent
state, so it is aggressive and scope-checked (read_url is
scope-checked too). Body:
{"url":...,"method"?="POST","content_type"?,"body"?,"read_url"?}.
Returns {"count","findings":[...]}. |
| POST | /api/massassign |
token | Mass assignment (CWE-915) + HTTP parameter pollution (CWE-235). Mass
assignment: adds a random control field to the request
body; if it is echoed the endpoint just reflects input and
the probe stops, else it adds each privileged field
(role/is_admin/account_type/...) with a nonce and flags the first whose
nonce comes back while the control's did not (selective binding, HIGH
tentative). HPP: for each reflected query parameter, sets it to a nonce
then sends it duplicated with a second nonce, flagging last-wins/concat
handling (LOW tentative). Aggressive and scope-checked. Body:
{"url":...,"method"?="POST","content_type"?,"body"?}.
Returns {"count","findings":[...]}. |
| POST | /api/csrf-poc |
token | Generate a CSRF proof-of-concept HTML page (CWE-352) from a captured
request. A GET, or a POST with an x-www-form-urlencoded body
(content-type matched case-insensitively), becomes an auto-submitting
form whose action is the request URL used verbatim (HTML-escaped only,
so the PoC hits exactly the URL being demonstrated); any other method or
body becomes a credentialed fetch(), since an HTML form can only send
GET and POST and auto-submitting a POST for a PUT/PATCH/DELETE would
fire the wrong verb; a JSON object body ALSO gets a text/plain
form-trick (JSON CSRF, no CORS preflight); a PUT/PATCH/DELETE ALSO gets
a manual method-override (_method) form. Pure generator: it
produces a local artifact and sends no traffic (no scope check). Body:
{"url":...,"method"?,"content_type"?,"body"?}. Returns
{"html":"..."}. |
| POST | /api/csrf-active |
token | Deepened ACTIVE CSRF probes on one captured state-changing request
(CWE-352, aggressive, scope-checked, SUBMITS the request). Runs the
token-tamper differential, the JSON-CSRF content-type probe, the
method-override bypass (a PUT/PATCH/DELETE reachable via a plain POST
carrying _method / X-HTTP-Method-Override /
X-Method-Override), and the SameSite-Lax GET-reachability
probe (a form action that also succeeds as a top-level GET while the
session cookie is not SameSite=Strict). cookie
sets the session for these single-identity probes. Supplying BOTH
cookie_a and cookie_b (two users' Cookie
values) ALSO runs the cross-identity token-reuse differential (A's token
accepted under B's session while B rejects garbage means the token is
not session-bound). Body:
{"url":...,"body":...,"method"?,"cookie"?,"cookie_a"?,"cookie_b"?}.
Returns {"count","findings":[...]}. |
| POST | /api/cspt |
token | Client-Side Path Traversal (CSPT) heuristic (CWE-22, client-side).
Scans an HTML/JS body for a client-side request sink (fetch, an XHR
.open(), axios, jQuery.ajax/get/post) whose URL is built,
in the same statement (the source may sit before or after the sink),
from a URL-derived source the attacker controls
(location.pathname/search/hash/href, document.URL, a router param like
useParams/router.query, URLSearchParams.get). A ../ in that
source can retarget the request to a different API endpoint
(CSPT-to-CSRF / CSPT-to-XSS). A .open( call counts only
when its receiver names an XHR object (xhr, req, httpRequest, ajax), so
window.open(), dialog.open(), db.open() and modal.open() are not
reported as request sinks. With body it scans the given
text; with only url it fetches the URL (scope-checked, one
passive GET) and scans the response. Static and passive. Body:
{"url"?,"body"?} (at least one). Returns
{"count","findings":[...]}. |
| POST | /api/cspt-confirm |
token | Confirm a CSPT lead at RUNTIME (CWE-22, active, scope-checked,
drives a headless Chromium). Loads the page with a unique
../ marker injected into a client-side URL source
(source: "hash" (default), "path", or a query-parameter
name), then watches Network.requestWillBeSent and confirms
when the page's own client-side request (fetch/XHR, not the top-level
document) is retargeted to a URL carrying the marker (HIGH, FIRM).
cookie authenticates the browser. On a hit it also returns
nav_url (the crafted PoC repro URL),
request_url (the retargeted request), and poc
(an HTML page that navigates a victim there). Needs a Chromium/Chrome
(503 if none). Body:
{"url":...,"source"?,"cookie"?}. Returns
{"count","findings":[...],"nav_url"?,"request_url"?,"poc"?}. |
| POST | /api/bizlogic |
token | Business-logic assist: numeric / price-tampering probe (CWE-840,
A04). For a price-, quantity-, or amount-like numeric field (a JSON body
leaf or a query parameter whose name matches
amount/price/qty/total/cost/balance/...), sets it to a negative value
and flags it when the state-changing request still succeeds the same way
(the endpoint does not validate it, so a negative can invert a charge /
refund / balance). Field-name targeting keeps false positives low;
TENTATIVE - confirm the negative produced a real inverted effect.
Aggressive, scope-checked. Body:
{"url":...,"method"?="POST","content_type"?,"body"?} (a
JSON body, or just a url with a numeric query param). Returns
{"count","findings":[...]}. |
| POST | /api/workflow-bypass |
token | Workflow / step-order bypass probe (business logic, CWE-840 /
CWE-841; aggressive, scope-checked, SUBMITS the flow). Replays a
recorded multi-step flow in order through a fresh session (so the final
protected step succeeds with all its prerequisites, carrying
session/workflow state via cookies), then replays ONLY the final step in
a second fresh session seeded with the same auth cookie. Flags it when
the final step still succeeds without its intermediate prerequisites
(the server does not enforce the workflow order, so a user can skip
payment/approval/verification). Needs >= 2 steps (max
FISSURE_WORKFLOW_MAX_STEPS); every step url is
scope-checked. Body:
{"steps":[{"url":...,"method"?,"content_type"?,"body"?},...],"cookie"?}
(steps oldest first, the last is the target; cookie is the
persistent session held constant across both runs). Returns
{"count","findings":[...]}. |
| POST | /api/nosqli |
token | NoSQL (document-store) operator injection (CWE-943, A03). For each
scalar field of the JSON body, replaces the value with a
match-all operator {"$ne":<nonce>} and a match-none
operator {"$eq":<nonce>}; a server that evaluates the
operator responds differently to the two (the match-all bypasses an auth
check or returns rows while match-none is denied), flagging an
operator-injectable field (FIRM, HIGH). A literal-only server yields no
differential (echo endpoints do not false-positive). An error-based
{"$regex":"("} probe additionally flags a driver error
signature (MongoError/CastError/BSONError/E11000) the baseline lacked.
Aggressive and scope-checked; body (a JSON object) is
required. Body:
{"url":...,"body":<json>,"method"?="POST","content_type"?}.
Returns {"count","findings":[...]}. |
| POST | /api/xxe |
token | Test an XML-accepting endpoint for XXE (XML external entity): submit
crafted XML declaring an external entity, detecting in-band file
disclosure (file:///etc/passwd, file:///c:/windows/win.ini, matched by a
file-content signature) and, when the control OAST listener is running,
an out-of-band parser callback (external parameter + general entity to a
minted canary) plus a nested-parameter-entity probe (the internal subset
only loads an attacker external DTD, which the OAST listener serves with
the nested %eval/%exfil entities, defeating a
parser that blocks internal-subset parameter entities and exfiltrating
the read file's bytes out-of-band, reported in evidence). Reuses the
observed body's root element. Scope-checked; intrusive (reads local
files / calls out); runs the aggressive probe. Body:
{"url":...,"body":<xml>,"method"?="POST","content_type"?="application/xml"}.
Returns {"count","findings":[...]}. |
| POST | /api/ssrf |
token | Out-of-band (blind) SSRF probe of a URL's query parameters,
including alternate schemes and DNS rebinding: for each parameter,
inject a minted OAST canary, gopher://<canary>:6379/
and dict://<canary>:11211/ canaries pointing at a
DNS-channel host, and (when a domain is configured) a DNS-rebinding
canary, then poll the OAST listener; a callback proves a blind outbound
request, a gopher/dict callback proves the target processes non-HTTP
schemes reaching internal services (Redis/memcached), and a
re-resolution of the rebinding canary proves a resolve-then-connect
TOCTOU that reaches 169.254.169.254. Requires the OAST
listener running (oast_start); with none, nothing is
probed. Scope-checked and aggressive. Body:
{"url":...,"method"?="GET"}. Returns
{"count","oast_running","findings":[...]}. |
| POST | /api/domprobe |
token | Headless DOM security probe (DOM Invader-class client-side testing):
load the URL in a headless Chromium driven over the DevTools Protocol,
install taint instrumentation before any page script, navigate with a
marked URL (hash + a __proto__ payload), fire a marked
postMessage, then report which dangerous DOM sinks the
marked value reached at runtime. Confirms DOM-based XSS (a location/URL
or postMessage value flowing unsanitized into
innerHTML/outerHTML/eval/Function/document.write/insertAdjacentHTML/setTimeout-string/jQuery.html,
CWE-79, HIGH), client-side prototype pollution (a location-derived
__proto__ key polluting Object.prototype,
CWE-1321, HIGH), cross-origin message listeners (INFO), and DOM
clobbering gadgets (a named element whose
window.<name> named access resolves to a DOM node,
for a sensitive global name or a duplicate id/name, CWE-79, LOW).
Runtime-verified evidence, stronger than the static body heuristic.
Scope-checked and active (drives a real browser). Needs a
Chromium/Chrome: the bundled Fissure Browser or a system install, else
503. Findings merge into the control store. Pass
"cookie" ("a=b; c=d") to probe an
authenticated page (applied to the browser's requests). Body:
{"url":...,"cookie"?,"settle_ms"?}. Returns
{"count","findings":[...]}. |
| POST | /api/dominvader |
token | Live DOM-Invader navigation session (interactive mode), the
automatable form. Where /api/domprobe is a one-shot probe
of one URL, this drives the live session engine: it installs the taint
instrument so it runs on every navigation, navigates the seed
(taint-marked when aggressive), and collects the DOM sink
hits, DOM-clobbering gadgets, cross-origin message listeners, and
prototype pollution reached on the page. In the GUI the same engine
attaches to the operator's own headful Fissure Browser and keeps
instrumenting as they browse; over the API it is a bounded headless
navigation session capped by max_ms. Body:
{"url":...,"aggressive"?=false,"cookie"?,"max_ms"?,"overlay"?=false}
(aggressive marks the seed's query params + hash + a
__proto__ payload so query/hash-reading DOM-XSS and
prototype-pollution sinks fire; cookie "a=b; c=d" probes an
authenticated page; max_ms bounds the session, default a
few seconds, capped; overlay injects the floating in-page
overlay panel, the live sink panel the GUI shows, into each browsed
page). Scope-checked and active (drives a real browser). Needs a
Chromium/Chrome: the bundled Fissure Browser or a system install, else
503. Findings merge into the control store. Returns
{"count","findings":[...]}; when overlay was
requested the response also echoes "overlay": true/false
(whether the overlay rendered). |
| POST | /api/http3 |
token | Fetch an https URL over HTTP/3 (QUIC, ALPN h3) using the native
HTTP/3 transport (Nilorea n_http3: ngtcp2 for QUIC, nghttp3
for HTTP/3 + QPACK, OpenSSL for the TLS 1.3 handshake). Runs a single
request/response over a fresh QUIC connection, the automatable form of
the GUI HTTP/3 fetch tool. Body:
{"url":...,"method"?="GET","headers"?,"body"?,"timeout_ms"?}
(headers is extra request headers as
"Name: Value\r\n" lines; body a request body
for POST/PUT; timeout_ms bounds the exchange, capped). Use
it to compare a target across HTTP versions (an h3-only or
Alt-Svc-advertised endpoint, a request-parsing or header-handling
difference vs HTTP/1.1 or HTTP/2). Scope-checked and active (opens an
outbound QUIC connection). Needs a build with the ngtcp2/nghttp3 stack
(HAVE_HTTP3), else 501. Returns
{"status","headers","body","body_len","truncated"}
(body is capped in the JSON; body_len is the
full length). |
| POST | /api/h3proxy |
token | Control the HTTP/3 (QUIC) MITM interception listener. Body:
{"action":"start"|"stop"|"status","port"?,"upstream"?,"tls_verify"?}.
tls_verify:false forwards to an origin whose certificate
does not chain to a public root, which is what a lab or an internal CA
looks like; it defaults to true, and with it on such an origin answers
502 because the forward's own handshake fails. Where the
classic proxy intercepts HTTP/1.1 and HTTP/2, this terminates inbound
HTTP/3 with a per-SNI leaf minted by the local Fissure CA, forwards each
request upstream and captures it (so /api/report includes
the h3 exchange), and relays the response over HTTP/3.
upstream="h3" forwards each request to the origin over
HTTP/3 too (end-to-end h3; needs an h3-capable origin); the default
("engine") forwards upstream over HTTP/1.1 / HTTP/2. To use
it: install the Fissure CA (GET /api/ca) in the client's
trust store, then point an h3 client (or a transparent UDP redirect) at
127.0.0.1:curl --http3 --connect-to host:443:127.0.0.1:<port>).
Scope-checked (an out-of-scope host is blocked with 403). Needs the
ngtcp2/nghttp3 stack (HAVE_HTTP3), else 501
with the reason in the error body; no platform is excluded (one bound
UDP socket, inbound datagrams demultiplexed to connections by
destination connection id), so it runs on Windows too. Concurrent (each
QUIC connection runs on its own thread). When interception is on
(POST /api/proxy/intercept {"enabled":true}), each h3
request is held as an editable raw HTTP/1.1 request in the same
/api/proxy/intercept queue as the h1/h2 proxy (inspect via
GET, `POST /api/proxy/intercept/resolve
{"action":"forward" |
| POST | /api/http3-diff |
token | Send the same request over HTTP/1.1, HTTP/2 and HTTP/3 and report
cross-version response differences (an HTTP-version interpretation
conflict, CWE-436): a WAF, cache, load balancer, or reverse proxy that
inspects the older protocols but forwards HTTP/3 differently can be used
to bypass a control or reach a different back-end. Body:
{"url":...,"method"?="GET","headers"?,"body"?,"timeout_ms"?}.
Sends the request three ways (engine h1, engine h2, native h3) and
compares statuses + body sizes; on a difference it records a LOW finding
in the control store. Scope-checked and active. Needs the ngtcp2/nghttp3
stack, else 501. Returns
{"h1_status","h2_status","h3_status","h1_len","h2_len","h3_len","differs","summary"}. |
| POST | /api/http3-smuggle |
token | Probe an https URL for HTTP/3 downgrade request smuggling (the h3
analogue of the H2.TE smuggle, CWE-444). Sends a clean HTTP/3 request
(the baseline) and the same request carrying a
transfer-encoding: chunked header, which RFC 9114 forbids
in HTTP/3 (via the n_http3_request_ex allow-illegal-headers
path). A compliant endpoint rejects the illegal-framing request (RST /
>= 400); an endpoint - or a front-end about to downgrade it to
HTTP/1.1 - that answers it does not validate framing, the
HTTP/3-to-HTTP/1.1 downgrade-desync precondition. Body:
{"url":...,"timeout_ms"?}. Records a MEDIUM finding on a
candidate. Scope-checked and active. Needs the ngtcp2/nghttp3 stack,
else 501. Returns
{"verdict":candidate|safe|unreachable,"reachable","baseline_status","illegal_status","summary","count"}. |
| POST | /api/paramminer |
token | Discover hidden parameters the target reacts to. Body:
{"url":...,"names":[...],"threads"?}. Scope-checked.
Returns
{"count","hits":[{name,status,length,reason}]}. |
| POST | /api/groupsend |
token | Send a group of requests. Body:
{"mode":"seq_separate|seq_single|parallel|h2_single_packet","requests":[{label?,method?,url,headers?,body?}]}.
Scope-checked per url. Returns
{"mode","count","results":[{label,method,url,status,status_text,elapsed_us,response}]}. |
| POST | /api/wsrepeater |
token | Open a WebSocket, send one frame, collect replies. Body:
{"url":...,"message":...,"opcode":"text|binary","max_recv"?,"timeout_ms"?}.
Scope-checked. Returns
{"connected","sent","elapsed_us","error","messages":[{opcode,payload}]}. |
| POST | /api/jscheck |
token | Run a scriptable (QuickJS) check against a target: fetch
url, evaluate script against the response,
report findings. Body:
{"script":...,"url":...,"method"?,"active"?}.
active:true enables the script's fs.send().
Scope-checked; findings merge into the control store. Returns
{"count","findings":[...]}. |
| POST | /api/authmatrix |
token | Replay one request under N identities. Body:
{"url":...,"method"?,"headers"?,"body"?,"identities":[{name,headers}]}.
Scope-checked. Returns
{"baseline_status","results":[{name,status,similarity,verdict}]}. |
| POST | /api/authz |
token | Autorize-style access-control replay (second identity +
credential-stripped). Body:
{"url":...,"method"?,"headers"?,"body"?,"identity_headers"?}.
Scope-checked; findings merge into the store. Returns the per-replay
statuses, similarities, verdicts, and findings. |
| POST | /api/rolediff |
token | Offline access-control diff of two role site-maps. Body:
{"baseline":[{method,url,status}],"test":[...],"baseline_role"?,"test_role"?}.
Returns
{"findings_added","entries":[{method,url,status_baseline,status_test,verdict}],"findings":[...]};
broken-access findings merge into the store. |
| GET | /api/plugins |
token | List the bundled OSS-tool plugins. Returns
{"count","plugins":[{id,name,category,binary,dependency,installed}]}. |
| POST | /api/plugins/run |
token | Run an installed plugin against a target (blocking). Body:
{"plugin":<id>,"url":...,"wordlist"?,"threads"?,"extra"?}.
Scope-checked; findings merge into the store. 404 for an
unknown plugin, 400 when it is not installed. Returns
{"plugin","added","exit_code","ran","findings":[...]}.
exit_code is the tool's own exit status (127
when its binary could not be executed, -1 when it could not
be spawned) and ran is false in both of those cases, so a
tool that never started is distinguishable from one that ran and found
nothing; when ran is false an error field says
which. |
| POST | /api/plugins/install |
token | Build the shell command that installs a dependency. Body:
{"tool":<dependency id>}. Returns
{"tool","command"}. The API never runs the command (install
is an explicit user action); the caller executes it. |
| GET | /api/extensions |
token | List installed extension bundles (the extension SDK). Returns
{"count","sdk_version","extensions":[{id,name,version,author,description,sdk_version,compatible,enabled,checks,error?}]}. |
| POST | /api/extensions |
token | Manage extension bundles. Body:
{"op":"enable|disable|reload","id"?}.
enable/disable take an id;
enabling an SDK-incompatible bundle is refused (404).
reload rescans the extensions directory. Returns the
updated list. |
| GET | /api/ext-actions |
token | List the on-demand context actions every enabled extension
contributes (an extension's actions contribution, distinct
from its passive checks). Returns
{"actions":[{ext,ext_name,title}]}. |
| GET | /api/marketplace |
token | Browse the offline, signed extension marketplace. Returns
{"trusted",bool,"catalog":[{id,name,version,author,description,sdk_version,installed}]}.
trusted is the result of verifying the catalog's detached
Ed25519 signature against the bundled trust key. |
| POST | /api/marketplace |
token | Install or remove a marketplace bundle. Body:
{"op":"install|remove","id"}. install verifies
the store bundle's canonical hash against the signed catalog and copies
it into the writable per-user extensions directory (refused
400 if the catalog is not trusted or the hash mismatches);
remove deletes the per-user copy. Returns the updated
catalog. |
| POST | /api/ext-action |
token | Run one extension context action against a request. Body:
{"ext","action","url","method"?,"headers"?,"body"?,"cookie"?}
(ext is the extension id, action the action
title from /api/ext-actions). The action script (the
fs.* API, active fs.send permitted) runs
against the fetched response; cookie ("a=b; c=d") or
headers authenticates every fs.send() probe on
an auth-gated target. Findings are added to the workspace. Active and
scope-checked. Returns
{"ext","action","url","findings_raised","findings":[...]}. |
| GET | /api/session-actions |
token | List the login/session actions every enabled extension contributes
(an extension's session_actions contribution: on-demand
login flows, distinct from context actions and passive
checks). Returns
{"session_actions":[{ext,ext_name,title,params}]}, where
params is a one-line description of the fields that login
expects in the params object below, so a caller does not
have to read the script to find them. The shipped set covers the shapes
a real target uses: an HTML form login (form-login), and in
session-logins a JSON API login, the OAuth2 password /
client-credentials / refresh grants, HTTP Basic, a bearer token the
operator already holds, a two-step form, a form plus an OTP code, an SPA
CSRF-cookie login, a GraphQL login mutation, and WordPress. |
| POST | /api/session-action |
token | Run one extension session action (a login flow) against a target and
capture the session. Body:
{"ext","action","url","params"?,"cookie"?,"install"?}
(ext is the extension id, action the title
from /api/session-actions). The login script
(fs.* with active fs.send) drives the login;
params is an object exposed to the script as
fs.params (e.g.
{"user":"admin","pass":"password"}) so credentials arrive
at run time, not baked into the bundle; an optional cookie
seeds the jar. The captured Set-Cookies are serialized and
returned as cookie, AND installed into the suite-wide
shared jar (installed says how many), which every control
scan and /api/request already reads: the login
authenticates what runs after it without the caller threading the string
through by hand. "install": false opts out and keeps the
run's session to itself. A login whose session is a TOKEN rather than a
cookie (the OAuth2 grants, a JSON API, GraphQL) has no cookie to install
and publishes its token with fs.setvar instead, which comes
back in vars; send it yourself as an
Authorization header, or let a session-handling rule
resolve it as {{name}}. Active and scope-checked. The reply
also says what the run DID: sends (requests it made),
last_status (the status of the last response one received)
and log (the script's own fs.log narration).
Those separate three different failures that all look identical as "no
cookie": sends 0 means the script never reached the network
(a wrong URL), sends above 0 with last_status
0 means nothing answered (host, port or scheme), and sends
above 0 with a real status means the target is reachable and refused the
login (credentials or field names). Cookies coming back are NOT proof
the credentials were accepted, since many applications hand an anonymous
visitor a session too; confirm with POST /api/auth/check
against a page that requires login. Returns
{"ext","action","url","ok","cookie","cookie_count","installed","sends","last_status","log"?,"findings_raised","vars"?,"findings":[...]}. |
| GET | /api/editors |
token | List the interactive message editors every enabled extension
contributes (an extension's editors contribution: a
decode/encode custom editor). Returns
{"editors":[{ext,ext_name,title}]}. |
| POST | /api/editor |
token | Run one extension message editor's transform over text. Body:
{"ext","editor","op"?,"text"?} (ext is the
extension id, editor the title from
/api/editors). op is "decode"
(raw message -> an editable representation, the default) or
"encode" (the edited representation -> raw message). A
pure text transform (no traffic), so it is not scope-gated. Returns
{"ext","editor","op","result"}. |
| POST | /api/query |
token | Filter the workspace with the universal traffic-query dialect (the
same query language the Logger and Findings grids use; the boolean
engine is Nilorea n_query). Body:
{"source","query"}. source is
"findings" (the findings store), "traffic"
(the captured request/response exchanges), or "wsframes"
(WebSocket frames captured by the control-driven proxy, StreamQL over WS
frames). Fields: traffic
tool/method/url/host/path/status/length/time/mime/scope,
findings
title/severity/location/category/host/cwe/owasp/confidence/source/triage/tags/scope,
wsframes dir (c2s/s2c),
opcode
(text/binary/ping/pong/close/cont),
fin, length (payload bytes), seq
(capture order), payload (frame text), url,
host, scope. The scope field is
in or out of this control session's scope
(scope = in / scope = out). Operators
= != ~ !~ =~ > < >= <= with
AND/OR/NOT and parentheses (there
is no negated-regex operator; write NOT field =~ value) (a
value with special characters is double-quoted, e.g.
payload =~ "token=[a-z0-9]+"). A malformed query answers
400. Returns
{"source","query","count","total","capped","rows":[...]}
(capped at FISSURE_QUERY_MAX_RESULTS; wsframes rows are
{dir,opcode,fin,length,seq,url,host,payload} with a bounded
payload preview). |
| GET | /api/queries |
token | List the saved, named query filters (shareable, persisted to
<config>/queries.json; on first run seeded with a
shipped starter HTTPQL library). Returns
{"saved_queries":[{name,query}],"count"}. |
| POST | /api/queries |
token | Manage the saved named filters. Body:
{"op":"save|delete|reset","name"?,"query"?}.
save upserts name->query (a
query that does not compile is refused 400);
delete removes by name (404 if absent);
reset restores the shipped starter library (no name
needed). Returns the updated list. |
| POST | /api/macro/record |
token | Record a login (or multi-step macro) from captured traffic into a
replayable login config. Body:
{"name"?,"exchanges":[{"method","url","content_type"?,"req_body"?,"resp_body"?}],"verify"?}
(exchanges oldest first). A CSRF-style token (a request value long
enough to be a token that also appears in an earlier
resp_body) becomes a regex extract on that
step and a {{name}} substitution where it is used, so the
config re-derives a fresh token on replay; credentials stay literal.
verify adds a verify block on the last URL. Pure synthesis,
no traffic. Returns {"config" (the JSON
string),"login" (the parsed object, ready to pass as the
login field of
POST /api/scans)}. |
| POST | /api/oast/start |
token | Start the control-driven out-of-band (OAST) HTTP listener. Body:
{"host"?,"port"?,"domain"?,"dns_port"?} (defaults
127.0.0.1 and 19000; a domain also brings up
the DNS channel on dns_port, default 53, needed for DNS and
rebinding canaries). Returns
{"running","port","base_url","count","dns_port","domain"?}. |
| POST | /api/oast/stop |
token | Stop the OAST listener; recorded interactions stay readable. Returns the status. |
| GET | /api/oast/status |
token | {"running","port","base_url","count","dns_port","domain"?}. |
| POST | /api/oast/mint |
token | Mint an HTTP canary. Returns {"token","url"}.
409 when the listener is not running. |
| POST | /api/oast/rebind |
token | Mint a DNS-rebinding canary whose host resolves to a benign IP on
the first lookup and internal_ip (default
169.254.169.254) on every later lookup, catching a
resolve-then-connect (TOCTOU) SSRF. Needs the DNS channel (start it with
a domain via /api/oast/start). Body:
{"benign_ip"?,"internal_ip"?} (benign defaults to the
listener host). Returns
{"token","canary","url","internal_ip"}; 409
when the DNS channel is not running. Poll the token:
rebind_reresolved true means the target re-resolved. |
| GET | /api/oast/poll?token= |
token | Whether a canary token has been hit:
{"token","seen","detail"?,"rebind_queries"?,"rebind_reresolved"?}
(the rebind fields appear only for a rebinding token;
rebind_reresolved is true at >= 2 lookups). The
token parameter is matched on
?/& boundaries and percent-decoded, so
?csrf_token= is a different parameter and an encoded token
is looked up as its decoded value. |
| GET | /api/oast/history |
token | All recorded interactions:
{"count","hits":[{token,method,path,src,channel,created_us}]}. |
| GET | /api/oast/beacons |
token | IAST beacons only: the recorded interactions that carry structured
fields from an instrumentation agent, with those fields split out. A
plain SSRF/XXE callback proves only that something reached the
collector; a beacon says WHICH SINK the canary reached and with what
argument. Both land in the same hit list, so this is the way to list the
beacons on their own. Returns
{"count","hits_total","beacons":[{token,detail,sink?,arg?,lang?,src,channel,created_us}]};
count is the beacon count and hits_total every
interaction, so count < hits_total means some callbacks
were bare. |
| POST | /api/oast/hosted |
token | Drive a HOSTED OAST / interaction server (interactsh protocol) so
DNS/HTTP OAST needs no bring-your-own-domain. Body:
{"op":"register"|"canary"|"poll"|"status","server"?,"base_url"?}.
register (needs server, e.g.
oast.pro; optional base_url, default
https://<server>) generates an RSA keypair and POSTs
the public key to <base_url>/register;
canary mints a canary subdomain to inject into a probe;
poll fetches and locally decrypts the server's
interactions, returning
{"count","hits":[{protocol,full_id,remote,timestamp}]};
status returns
{"registered","server","correlation_id"}. The zero-setup
alternative to the local listener. |
| GET | /api/projects |
token | List projects/workspaces:
{"active","projects":[names]}. |
| POST | /api/projects |
token | Manage projects. Body:
{"op":"create|delete|activate","name"}. Returns the updated
list. activate also re-points the per-project stores the
control engine holds in memory: the extension state directory behind
fs.store is re-resolved and the shared crawl parameter jar
is cleared and reloaded from the newly active project. Without that a
switch moved only a pointer and the next write put the previous
project's data in the new project's files. The per-request stores (env,
collections, Repeater tabs, team) resolve their path on every call and
need nothing. |
| GET | /api/env |
token | The per-project environment library:
{"active","environments":[{name,vars:[{key,value}]}]}. On
first run seeded with a default env (host, base_url, token,
cookie slots). |
| POST | /api/env |
token | Mutate environments. Body:
{"op":"add_env|remove_env|activate"
(+name)|"set"|"remove"
(+key[,value,env])|"reset"}.
reset restores the shipped template environment (no
args). |
| POST | /api/env/expand |
token | Expand {{vars}} in text. Body:
{"text":...,"env"?}. Returns
{"output","unresolved_count","unresolved"}. An undefined
reference expands to itself, so unresolved names the ones
that did not resolve: without checking it, a caller cannot tell an
expansion from a silent miss, and the literal placeholder would be sent
to the target as text. |
| GET | /api/tags |
token | The inline transform tags:
{"custom":[{name,body}],"vars":[{name,value}]}. On first
run seeded with a shipped starter set (reverse, doubleurl, sqlcomment,
nowrap, and a marker variable). |
| POST | /api/tags |
token | Mutate tags. Body:
{"op":"set_custom|remove_custom|set_var|remove_var|reset","name"?,"body"?,"value"?}.
reset restores the shipped starter tags (no name
needed). |
| POST | /api/tags/eval |
token | Evaluate inline transform tags (built-in + custom JS + OAST canary)
over text. Body: {"text":...}. Returns
{"output"}. |
| GET | /api/organizer |
token | The per-project saved-request queue:
{"count","items":[{id,collection,label,method,url,request,notes,tags,created_us}]}. |
| POST | /api/organizer |
token | Stash a request. Body:
{"url":...,"method"?,"collection"?,"label"?,"request"?,"notes"?,"tags"?}.
Returns {"id","count"}. |
| POST | /api/organizer/remove |
token | Remove a saved request. Body: {"id":...}. Returns
{"removed","count"}. |
| POST | /api/session/save |
token | Persist the control findings to
sessions/<name>.ndjson, and the captures that back
them to the sibling archive. Body: {"name":...}. Returns
{"name","saved","count","captures_saved","captures"};
captures_saved is reported separately so a findings file
that saved while its evidence did not is visible as the partial save it
is. |
| POST | /api/session/load |
token | Merge a saved session's findings into the control store, and its
captures into the capture store so the reloaded findings still resolve
to a request/response pair. Body: {"name":...}.
404 when absent. Returns
{"name","loaded","total","captures"}. |
| GET | /api/team |
token | The shared-project team state:
{"members":[{name,present,joined_us,last_seen_us}],"locks":[{resource,holder,acquired_us}] (live only),"assignments":[{resource,member}],"activity":[{actor,action,target,ts_us}]}
(member tokens are never returned). |
| POST | /api/team |
token | Team-collaboration op. Body: {"op":...}. Ops:
add_member (needs name; returns
{name,token} - the member's identity token),
remove_member (name), heartbeat
(actor/token),
lock/unlock (resource +
actor/token; lock returns
409 when another member holds it),
assign/unassign
(resource[,member]), log
(actor/token +
action[,target]). Actions attribute to the
member resolved from token when given, else the
actor name. Returns the updated team status. Persisted per
project to team.json. Loopback + token-gated: coordination, not a
security boundary. |
| GET | /api/purple |
token | Purple-team status:
{"enabled","marker","run","header","probes","events","unseen","logged","detected","unmatched_events","coverage_pct","coverage":[{technique,sent,logged,alerted,blocked,detected,coverage_pct}]}.
enabled is whether probe recording is on,
marker whether each probe carries the
X-Fissure-Probe correlation header, and run
names the engagement (it prefixes every marker). A recorded probe is
unseen (no imported telemetry mentions it),
logged (the target recorded it but raised nothing) or
detected (alerted/blocked). |
| POST | /api/purple |
token | Drive purple-team mode. Body: {"op":...}. Ops:
start (record every request the engine sends; optional
run names the run), stop, marker
({"on":false} sends unmarked probes, which is the honest
setting when the question is whether the defender spots unlabelled
attack traffic), run ({"run":"PT-1234"}, which
also restarts the probe numbering), import
({"text":...,"source"?,"kind"?}: the target's own log or
alert lines, one record per line, as JSON lines, common-log-format
access lines or free text; kind is
log/alert/block for lines that do
not say so themselves. {"file":"/path/to/log"} instead of
text has the server read the file itself, which is how a
real export is imported without splitting it across 64 KB bodies: it is
a local file read as the Fissure user, on a loopback- and token-gated
API, capped at 32 MB, 404 when unreadable and
413 when too large), reconcile
({"window_ms"?}, default 300000: ties telemetry to probes
by correlation marker first, then by the payload appearing verbatim,
then the exact path, then the path alone), findings (emit
one finding per technique the target never alerted on AND one per
technique whose coverage fell against the saved baseline, into the
control findings store; returns added, gaps
and regressions), baseline (record the current
per-technique coverage as the baseline a later run is compared against;
400 when no probes have been recorded), diff
(compare the current coverage against that baseline: adds
delta[{technique,sent,detected,now_pct,was_pct,new,regressed,improved}]
plus
regressed/improved/unchanged/added_techniques/gone
counts and the baseline's run name and time; 404 when no
baseline exists), save/load (the per-project
purple.json store), clear (`{"what":"all |
| GET | /api/purple/probes |
token | The recorded probes, newest first:
{"total","probes":[{id,ts_ms,marker,tool,technique,method,host,path,url,status,state,log_hits,alert_hits,detector,wire}]}.
wire is the request as it went out (truncated), which is
what a defender searches their own logs for. Query: limit,
technique (one check family), state
(unseen/logged/alerted/blocked;
anything else is a 400). |
| GET | /api/purple/events |
token | The imported defender telemetry, newest first:
{"total","events":[{id,ts_ms,kind,source,method,path,text,probe}]}.
probe is the probe id the line was tied to, or
-1 when it matched none. Query: limit,
unmatched=1 (only the lines that matched no probe: either
the defender reacting to something that was not you, or a correlation
that failed). |
| POST | /api/proxy/start |
token | Start the control-driven intercepting proxy. Body:
{"host":...,"port":...,"max_flows"?,"history_file"?,"upstream_proxy"?,"no_proxy"?,"transparent"?,"oast_inject"?,"capture_cookies"?,"client_http2"?}
(defaults 127.0.0.1 and 8778). The optional fields are the
same transport knobs the GUI proxy applies: max_flows caps
the in-memory flow history (finite by default so a long headless run
does not grow without bound; 0 = unlimited), history_file
persists the flows across a restart,
upstream_proxy/no_proxy chain the outbound
leg, transparent routes origin-form requests by Host
header, oast_inject seeds forwarded in-scope requests with
OAST canary headers (needs a running collector, else a no-op at send
time), and client_http2 (default true) makes the
intercepted TLS leg offer ALPN "h2" and terminate HTTP/2 from the
browser, re-framing each stream onto the same interception and capture
pipeline: set it false to force every client down to HTTP/1.1.
client_http2 changes only what the BROWSER may speak to the
proxy, since the upstream leg negotiates h2 with the origin either way.
capture_cookies (default false) folds the session cookies
of IN-SCOPE proxied traffic into the suite-wide shared cookie jar: every
response's Set-Cookie and every request's
Cookie header, the latter being the only way a session
established before the proxy was attached ever gets in. Turn it on when
the browser being proxied is logged in to the target and every later
scan and /api/request is authenticated with no cookie to
copy by hand. It is scope-gated so unrelated browsing does not fill the
jar, and off by default because it changes what later tools send.
Returns the proxy status. Also accepts
tls_client_cert/tls_client_key (plus an
optional tls_client_hosts selector: comma or space
separated, a leading . covers a domain and its subdomains)
to offer a client certificate on the upstream leg, and
tls_min_version (10/11/12/13 for TLS 1.0-1.3) /
tls_ciphers to bound what the upstream handshake
negotiates. Without the first an mTLS host cannot be reached through the
proxy at all; without the second a TLS-version finding cannot be
reproduced headlessly. |
| POST | /api/proxy/stop |
token | Stop the control proxy; captured history stays browsable. Returns the status. |
| GET | /api/proxy/status |
token | {"running","host","port","flows","intercept","passive_native","passive_scripts","passive_audited","passive_pending","passive_findings","max_flows","oast_inject","client_http2"}.
The passive_* fields report the live passive audit: which
stages are on, how many captured flows have been analyzed, how many are
queued, and how many findings it contributed. |
| POST | /api/proxy/passive |
token | Configure the live passive audit of proxied traffic and optionally
re-analyze the captured history. Body:
{"native"?,"scripts"?,"rerun"?}. Both stages are ON by
default and independently opt-out; passive analysis inspects
already-observed responses and generates no traffic
(fs.send is disabled in the passive stage). Turning a stage
off does not discard traffic: flows queue as
passive_pending and are analyzed when it is switched back
on. "rerun":true rewinds the cursor over the whole captured
history and reloads the script corpus (findings dedup, so nothing is
duplicated). Returns the proxy status. |
| POST | /api/finding/annotate |
token | Record analyst judgement on a finding. Body:
{"index":N,"notes"?,"tags"?,"triage"?}; triage
is
open/confirmed/false-positive/ignored
and an unrecognised label is a 400 rather than a silent
fallback to open. Absent fields are left untouched, so
notes can be set without clearing tags. Returns
{"ok","index","notes","tags","triage"}; 404
for a bad index. |
| POST | /api/clickjack-poc |
token | Build a clickjacking (framing) proof-of-concept page. Body:
{"url":...,"decoy"?}. Returns {"url","html"}.
Scope-checked; the CSRF sibling is /api/csrf-poc. |
| GET | /api/autorepeater |
token | List the auto-replay ruleset. Returns
{"rules":[{index,name,match_all,conditions,base_match,base_replace,base_regex,test_match,test_replace,test_regex,enabled}],"count"}. |
| POST | /api/autorepeater |
token | Edit the auto-replay ruleset. Body:
{"op":"add"|"set"|"enable"|"remove"|"clear"|"defaults", ...}.
A rule watches proxied traffic for a condition, resends each matching
request twice (a base and a test rewrite) and reports where the
responses differ, which is how broken access control shows up across a
browsing session without manual replay. Rules persist to the same file
the GUI popup uses. Returns the updated list; 400 on an
unknown op or a rejected rule. |
| GET | /api/ca |
token | The proxy CA certificate as PEM. Returns
{"pem","common_name"}. A client must trust this certificate
before the intercepting proxy (or the HTTP/3 listener) can read its
HTTPS. The CA is generated on first use, so this works before the proxy
has ever been started; it is unique to the installation and must never
be shared. This is the route the h3proxy and MITM instructions refer
to. |
| GET | /api/traffic |
token | The cross-tool request log: every request the control-driven tools
actually sent, newest window first. Optional limit (newest
N) and tool
(scanner/proxy/repeater/intruder/discover/other)
narrow it. Returns
{"total","entries":[{index,tool,method,url,host,status,length,time_ms}]}.
A record whose send got NO response has status 0 and
carries two more fields naming why: error_kind
(timeout, refused, no-reply,
certificate, cancelled, or failed
when unclassified) and error (the engine's own message).
Without them a failed row says only that it failed, and a timeout, a
refused connection and a rejected certificate all read the same.
Distinct from /api/proxy/history, which covers only flows
captured through the intercepting proxy and carries full bodies; this is
metadata across every tool, and is what answers "what did that scan
actually send?". |
| POST | /api/traffic/clear |
token | Drop every record from the cross-tool request log. Returns
{"cleared","total"}. |
| GET | /api/hostroutes |
token | The per-host connection-routing rules in force. Returns
{"rules","count"}. |
| POST | /api/hostroutes |
token | Replace the per-host connection-routing rules, applied to every
control-driven scan and one-off send. Body:
{"rules":"<one rule per line>"}. Blank lines and
# comments are ignored;
pattern = address[:port] rewrites where that host connects
while the Host header, TLS SNI, scope and captured URL stay the original
name, and pattern via proxy-url routes only that host
through a chosen proxy. pattern is an exact host or a
*.suffix wildcard. An empty rules string
clears the routing. 400 when the rules cannot be parsed. A
scan already running keeps the ruleset it captured at start, so
replacing the rules never disturbs it. Returns
{"rules","count"}. |
| POST | /api/proxy/clear |
token | Drop every captured flow (and WebSocket capture) from the control
proxy's history; the on-disk history file is unaffected. Returns
{"cleared",...status}. Mirrors the Proxy view's Clear
button. |
| GET | /api/proxy/history?limit=&hae=1 |
token | Captured flows (newest window):
{"total","flows":[{index,method,url,status,tls,client_proto,body_capped?}]}.
body_capped is present and true when that flow's stored
bytes are only a PREFIX: its body went over the proxy's 16 MB hold
limit, so it was forwarded in full but relayed past the limit without
being held for interception, rewritten, or captured. On such a flow,
"the marker is not in the body" is unproven, not negative.
client_proto is the protocol the CLIENT spoke to the proxy
(h2, http/1.1, http/1.0);
tls reports the UPSTREAM leg, which is a different question
and often a different answer. With hae=1 each flow also
carries {highlight,extracted}, the Highlighter/Extractor
verdict (the color the GUI paints that row with and its extracted
values); it is opt-in because it re-reads and re-scans every returned
flow body. |
| GET | /api/proxy/history/{index} |
token | One flow's full request/response plus its Highlighter/Extractor
verdict:
{index,method,url,status,client_proto,tls,body_capped,request,response,highlight,extracted}.
body_capped true means
request/response STOP at the proxy's hold
limit and the rest was relayed uninspected, so absence of anything in
them proves nothing. The index is required and must be a number:
/api/proxy/history/ with nothing after the slash, or a
non-numeric index, answers 400 naming the shape rather than
silently resolving to flow 0. |
| GET | /api/proxy/intercept |
token | {"enabled","responses","pending","label"?,"direction"?,"message"?,"request"?}.
When pending, direction is
"request" or "response" and
message holds the bytes; request carries the
same bytes under the older name and is kept for compatibility. |
| POST | /api/proxy/intercept |
token | Arm interception. Body:
{"enabled"?:bool,"responses"?:bool}. enabled
holds requests on their way to the origin, responses
additionally holds responses on their way back to the client (and needs
enabled too, so arming interception never starts pausing
every reply on its own). Each key is independent and an omitted one
keeps its current value. |
| POST | /api/liveaudit |
token | Live active auditing of endpoints seen in proxy traffic. Body:
{"enabled"?:bool,"aggressive"?:bool,"op"?:"reset"}; each
flag is independent and an omitted one keeps its value. Returns
{"enabled","aggressive","audited"}. OFF by default because,
unlike passive analysis, it GENERATES TRAFFIC to the target; the scope
allowlist, the aggressive toggle and the authorization banner apply
exactly as they do to a scan. Each observed endpoint is audited once,
using the request actually made, so probes carry the real session.
Parameter values collapse and names are kept, so paging
/item?id=1..500 is one endpoint. |
| POST | /api/traffic/detail |
token | One cross-tool Logger record's retained bytes. Body:
{"index":<n>}. Returns
{"index","request","response","truncated"}, plus
error_kind and error when the record is a send
that got no response (its stored response is HTTP/1.1 0,
which carries no explanation of its own). GET /api/traffic
lists records (which tool, method, url, status, timing); this reads the
messages themselves, which is what makes the Logger workable rather than
an index. Each message is capped at 64 KB and truncated
says when one was clipped, so a clipped body is never mistaken for a
whole one. |
| POST | /api/extensions/bundle |
token | Inspect, install or pack a distributable extension bundle file.
Body:
{"path":"<bundle file>","op"?:"install"|"pack","accept_unsigned"?:bool,"out"?:"<path>"}.
With no op it inspects and returns
{"id","checks","request_hooks","actions","signed":false,"warning"}.
op":"install" REQUIRES accept_unsigned":true,
because the bundle is not vouched for by the signed catalog: its checks
send traffic to the target, its request hooks rewrite EVERY request the
proxy forwards, and it can persist state. op":"pack" writes
an installed bundle directory to out. Signed first-party
bundles still install through /api/marketplace, which
hash-checks them against the signed catalog. |
| POST | /api/extensions/state |
token | One extension's persisted fs.store state. Body:
{"id":"<extension id>","op"?:"clear"}. Returns
{"id","count","state"}. State is per extension AND per
project: it is what a bundle remembers about one engagement across runs
and restarts (a baseline, a seen-set, a refreshed token).
op":"clear" drops it, which is how you force a bundle to
start fresh on a re-scan. |
| GET | /api/proxy/intercept/rules |
token | The conditional intercept rules in evaluation order:
{"default","rules":[{"index","name","enabled","direction","host","method","path","content_type","status_min","status_max","action"}]}. |
| POST | /api/proxy/intercept/rules |
token | Replace the rules wholesale. Body:
{"rules":[...],"default"?:"hold"|"skip"}. Declarative
rather than incremental because order decides: the FIRST matching rule
wins, so stating the whole table gives a predictable result. A rule's
blank text field means any; direction is
any/request/response,
action is hold/skip,
status_min/status_max bound a response status
(0 = any). With no rules interception holds EVERYTHING, which is what
the plain toggle always did and what makes it unusable on a real site
(every image and beacon stops the browser). Applies live to a running
proxy. |
| POST | /api/proxy/intercept/resolve |
token | Resolve the held message. Body:
{"action":"forward|drop","data"?,"data_b64"?}
(data = the edited raw bytes for a forward;
data_b64 is the byte-exact base64 form, which wins over
data and is passed through untouched). A head that arrives
having lost ALL of its carriage returns is repaired to CRLF, because
that is what a JSON round trip does to one; a head that already uses
CRLF keeps any bare LF you put in it, because that shape is a
deliberately malformed message and repairing it would destroy the
finding. Dropping a response closes the connection, since there is then
no reply to send. 409 when nothing is held. |
| POST | /api/relay/start |
token | Start the generic non-HTTP raw TCP/UDP interception relay: listen on
listen_port and forward every byte to
upstream_host:upstream_port, capturing each chunk. Body:
{"proto":"tcp"|"udp","listen_host"?,"listen_port","upstream_host","upstream_port","upstream_tls"?}
(upstream_tls wraps the upstream TCP leg in client TLS).
Returns
{running,proto,listen_port,upstream_host,upstream_port,chunks,intercept}.
409 if already running. For a binary/proprietary protocol
the HTTP proxy cannot parse. |
| POST | /api/relay/stop |
token | Stop the raw relay (capture stays browsable until the next start). Returns the status. |
| GET | /api/relay/status |
token | Raw-relay status:
{running,proto,listen_port,upstream_host,upstream_port,chunks,intercept}. |
| GET | /api/relay/history[?limit=N] |
token | Captured relay chunks:
{count,chunks:[{index,dir,conn_id,len,data}]}.
dir is c2s/s2c; data
is base64 (binary-safe). |
| GET | /api/relay/intercept |
token | {"enabled","pending","label"?,"data"?} (the held chunk,
base64, when pending). |
| POST | /api/relay/intercept |
token | Toggle per-chunk interception. Body: {"enabled":bool}.
409 when the relay is not started. |
| POST | /api/relay/intercept/resolve |
token | Resolve the held chunk. Body:
{"action":"forward|drop","data"?} (data =
edited chunk bytes, base64, for a forward). 409 when
nothing is held. |
| POST | /api/workflow/run |
token | Run a composable workflow pipeline over a fetched exchange (the
automatable form of the Workflows builder). Body:
{"workflow":{...}|"name":<saved>,"url":...,"method"?="GET","active"?=false}
(workflow is an inline pipeline object, or
name names a saved one; active permits active
nodes and fs.send, scope-checked). Returns
{"trace":[{name,type,action,status,length,findings,findings_count}],"findings":[...],"findings_count","status","length","stopped"}. |
| GET | /api/workflows |
token | List the saved, named workflow pipelines (persisted to
<config>/workflows.json). Returns
{"workflows":[...],"count"}. |
| POST | /api/workflows |
token | Manage a saved workflow. Body:
{"op":"save|delete|instantiate","workflow":{...}|"name":<name>,"as"?:<new name>}.
save upserts a pipeline object (needs a non-empty name);
delete removes by name (404 if absent);
instantiate copies a shipped template (by its display name
or filename in name) into the store, optionally renamed via
as (404 if no such template). Returns the
updated list {"workflows":[...],"count"}. |
| GET | /api/workflow-templates |
token | List the shipped ready-made workflow templates (predefined
pipelines, like the built-in scan profiles). Returns
{"templates":[{"name","kind","description","file"}],"count"}.
Instantiate one with
POST /api/workflows {"op":"instantiate","name":<template>}. |
Beyond scanning, the API exposes the analysis workshops (the
multitool, comparer, sequencer, JWT/token workshop, GraphQL argument
tooling, the signed-cookie workshop, the request Inspector, scope-text
import, and a user-JS transform), the Intruder, content discovery,
parameter mining, API-definition import, scope management, and report
export, so an agent can encode/hash a value, diff two responses, judge a
token's entropy, forge or crack a JWT or a framework cookie, mutate a
GraphQL argument, decompose a raw request, import an OpenAPI/Postman
spec into an endpoint list, fuzz a payload position, brute-force paths,
mine hidden parameters, send a request group (including a
parallel/HTTP-2 single-packet race), replay a WebSocket frame, run a
scriptable check against a target, run an auth matrix or an
Autorize-style replay across identities, diff two role site-maps, list
and run the OSS-tool plugins, set the scope, and render the findings
without the GUI. Transform outputs that are binary (for example a
base64_decode of non-text) may not round-trip cleanly in
the output string; output_len gives the true
byte length. The Intruder, discover, param miner, and scans honor the
scope set via POST /api/scope (an out-of-scope target is
refused).
The browser dashboard at GET / drives these routes
directly: it arms interception and resolves a held message, cancels the
scan or job it started, and sends the full POST /api/scans
option set. It is a convenience front end over the same API, so anything
it can do is scriptable, and anything it cannot do yet is still
reachable over the routes.
The POST /api/proxy/start route brings up a
control-driven intercepting proxy (its own instance, separate from the
GUI's proxy) so an agent can capture live traffic: point a client at
host:port, poll GET /api/proxy/history, read a
flow with GET /api/proxy/history/{index}, and
hold/forward/drop requests via the intercept routes (enable, poll
GET /api/proxy/intercept until pending, then
POST /api/proxy/intercept/resolve). HTTPS capture uses the
per-install CA (the client must trust it). The proxy binds loopback and
applies the control scope.
The OAST routes drive an out-of-band interaction collector for blind
vulnerabilities: POST /api/oast/start brings up a loopback
HTTP listener (pass a domain to also bring up the DNS
channel), POST /api/oast/mint returns a
{token,url} canary to inject into a suspected blind
SSRF/RCE/XXE/log4shell sink, POST /api/oast/rebind mints a
DNS-rebinding canary (benign-first, internal-next) for
resolve-then-connect SSRF, and GET /api/oast/poll?token=
reports once that canary is hit (the out-of-band proof; for a rebinding
token it also reports the re-resolution count), with
GET /api/oast/history listing every recorded interaction.
The listener keeps its recorded hits after a stop.
The listener is also what makes the out-of-band scan checks work. The
ssrf family, and the blind halves of injection
and xxe, are confirmed only by a callback, so they return
nothing when no collector is running. Every scan path borrows the
control-driven listener: the synchronous POST /api/scan,
the asynchronous POST /api/scans (the path behind the MCP
start_scan tool), and the recurring scheduler. Start it
with POST /api/oast/start BEFORE launching a scan that
should cover those families; a scan started while the collector is down
runs its in-band checks normally and simply finds no out-of-band issues,
which is not the same as the target having none. The CLI equivalent is
fissure scan --oast <port>, which refuses outright
when --families ssrf is asked for without a collector.
The workspace-data routes drive the same on-disk stores the GUI uses,
so an agent can manage engagements headlessly:
/api/projects switches the active project/workspace;
/api/env is the per-project {{variable}}
environment library (with /api/env/expand);
/api/tags is the Hackvertor-style inline transform-tag
store (with /api/tags/eval, which runs built-in tags plus
custom-JS tags and, when the OAST listener is running, canary tags);
/api/organizer is the per-project saved-request queue (its
collection field groups items into collections); and
/api/session/{save,load} persist the control findings to
named session files under sessions/. Environment and
organizer data are per-project (they follow the active project); tags
are global. Session save/load are sandboxed to
<config>/sessions/<name>.ndjson (the name is
validated) and never overwrite the GUI's project findings.
POST /api/request returns
{"status":<int>,"status_text":...,"headers":[{"name":...,"value":...},...],"body":...,"timing":{"total_us":...,...},"error":...}
(error is present only when the request itself failed;
timing only when the engine populated a per-phase
breakdown). A body with no usable url returns
400.
The findings JSON is the same schema the report exporter emits
(fissure_report_json): a root object with
schema_version, summary, and a
findings array.
Coverage: what the API exposes, and what it does not
The control API mirrors essentially every engine capability the GUI
drives: the request engine and scans; the analysis workshops (multitool,
smart-decode, comparer, sequencer, JWT, signed-cookie, GraphQL, request
Inspector, scope-text import, user-JS transform, and the
.bcheck compiler); discovery and import (content discovery,
parameter mining, API-definition import); request-driving ops
(group/race send, WebSocket Repeater, scriptable checks); authorization
testing (auth matrix, Autorize-style replay, offline role diff); the
OSS-tool plugin host (list/run/install); the out-of-band (OAST)
collector; the live intercepting proxy (start/stop/history/intercept);
the workspace data stores (projects, the per-project environment
library, the inline transform tags, the saved-request
organizer/collections, and session save/load); and reporting
(multi-format export with filters and a risk score, plus PwnDoc and
PDF).
The live-proxy behavior rule stores are exposed too, so a headless
caller can install the same standing per-flow rules the GUI operator
does: match-and-replace (/api/matchrep), the HaE
highlight/extract rules (/api/hae,
/api/hae/apply), the auto-repeater ruleset
(/api/autorepeater), the conditional intercept rules
(/api/proxy/intercept/rules), and the extension
login/session actions (/api/session-actions,
/api/session-action).
A handful of GUI functions are intentionally not exposed, because they have no headless "do work" meaning, not because they were overlooked:
- Desktop presentation and interaction (theme, window
layout, DPI/
ui_scale, keyboard shortcuts, the spinner, the HTML render view, datagrid column customization). These configure how the desktop window looks and behaves; a headless caller has no window to theme, no columns to reorder, and no font to scale. The control-API's own settings (enable/port/token) are managed in-app and persisted;fissure servetakes them as flags. - Request macros (
{{name}}substitution over captured variables). The value here is the recorded-login "macro run", which is exposed: authenticated scans pass aloginconfig toPOST /api/scans. The bare substitution helper is covered by/api/env/expand. - Data-model and persistence internals (the capture
store, traffic log, endpoint/host inventory and site-map models, and the
finding/request/response structs). These are plumbing the exposed
endpoints already use; the findings they hold surface through
/api/findingsand the report exporters, and the inventory surfaces through API-spec import, discovery, and parameter mining. - The proxy-side WebSocket frame buffer
(
wscap), which backs the live-proxy WS history; the standalone WebSocket capability (send a frame, collect replies) is exposed as/api/wsrepeater. - The first-run authorization banner acknowledgement, a one-time GUI consent marker. The API is off by default, token-gated, and scope-enforcing; enabling it is the operator's authorization step.
Examples
# health (no token)
curl http://127.0.0.1:8777/api/status
# findings
curl -H "X-API-Key: <token>" http://127.0.0.1:8777/api/findings
# send one request through the engine (token also works as a Bearer header)
curl -H "Authorization: Bearer <token>" -H "Content-Type: application/json" \
-d '{"url":"https://target.test/login","method":"POST","headers":{"X-Test":"1"},"body":"a=b"}' \
http://127.0.0.1:8777/api/request
# run a passive scan synchronously and read its report
curl -H "X-API-Key: <token>" -H "Content-Type: application/json" \
-d '{"url":"http://target.test/","active":false}' \
http://127.0.0.1:8777/api/scan
# or start it asynchronously, poll, and read the findings when done
job=$(curl -s -H "X-API-Key: <token>" -d '{"url":"http://target.test/","active":true}' \
http://127.0.0.1:8777/api/scans | grep -o '"job_id":"[^"]*"' | cut -d'"' -f4)
curl -H "X-API-Key: <token>" http://127.0.0.1:8777/api/scans/$job # status + progress
curl -H "X-API-Key: <token>" http://127.0.0.1:8777/api/scans/$job/findings # once done
POST /api/scan runs the scan inline and returns when it
finishes; for long scans prefer the async POST /api/scans
and poll GET /api/scans/{id} (this is also the pattern the
MCP bridge uses so an agent stays in control). Cancel a running job with
POST /api/scans/{id}/cancel.
Authenticated scans
POST /api/scans accepts an optional login
field, a login-config object (the same schema as
resources/login/*.json; see
resources/login/README.md). When present, the job's worker
replays the login first to establish a session that the scan then
carries on every request, so it can reach pages behind a login. If the
login fails, the job reports "status":"error". The
synchronous POST /api/scan does not take a login (use the
async job API for authenticated scans).
# authenticated async scan (a DVWA-style login config passed inline)
curl -s -H "X-API-Key: <token>" -H "Content-Type: application/json" -d '{
"url":"http://127.0.0.1:4280/","active":true,
"login":{"name":"dvwa","steps":[
{"method":"GET","url":"http://127.0.0.1:4280/login.php",
"extract":[{"name":"t","from":"regex","pattern":"user_token['\"][^>]*?value=['\"]([0-9a-fA-F]+)"}]},
{"method":"POST","url":"http://127.0.0.1:4280/login.php",
"headers":"Content-Type: application/x-www-form-urlencoded",
"body":"username=admin&password=password&Login=Login&user_token={{t}}"}],
"verify":{"url":"http://127.0.0.1:4280/index.php","contains":"Welcome"}}
}' http://127.0.0.1:8777/api/scans
MCP bridge (drive it from Claude Code)
The control plane is plain HTTP, so curl, Python, and CI
drive it directly. For an MCP host (Claude Code), the repository ships a
thin stdio bridge under bridge/ that exposes one MCP tool
per control-API route (the routes tabled above, plus the
analysis-workshop and engine tools such as send_request,
start_scan, transform, report,
smuggle, ssrf, xxe,
oast_start, workflow_run, and the rest) and
translates each tool call into a control-API request. The authoritative,
per-tool catalog (each tool's signature, arguments, and return fields)
is the skill reference
.claude/skills/fissure_bug_bounty/references/mcp_tools.md,
kept in exact parity with the @mcp.tool definitions in
bridge/fissure_mcp_bridge.py; run that bridge, or read the
catalog, for the complete current list rather than relying on an inline
enumeration here:
Install the SDK into a virtualenv and point the MCP config at that
interpreter (a bare python will not have
mcp):
python3 -m venv ~/.venvs/fissure-mcp
~/.venvs/fissure-mcp/bin/pip install "mcp>=1.27,<2"
claude mcp add fissure-control \
--env SUITE_API_URL=http://127.0.0.1:8777 \
--env SUITE_API_TOKEN=<token-from-app-settings> \
-- ~/.venvs/fissure-mcp/bin/python <bridge-dir>/fissure_mcp_bridge.py
<bridge-dir> is bridge/ in a
checkout, /opt/fissure/bridge with the .deb,
and for the AppImage or the Windows installer see step 1b of
docs/13_MCP_AND_SKILL_SETUP.md. Only
bridge/fissure_mcp_bridge.py needs the MCP Python SDK
(tested with 1.28); its HTTP client
(bridge/fissure_control_client.py) is pure standard library
and is independently usable and tested. Scans use the poll pattern
(start_scan -> get_scan_status until done
-> get_scan_findings) so each tool call stays short and
the agent stays in control. start_scan also takes an
optional login login-config object for authenticated scans
(see the Authenticated scans section above). See
bridge/README.md for a quick end-to-end verification
recipe.
To drive a whole engagement (not just one tool) from Claude Code, the
repository ships a fissure_bug_bounty skill under
.claude/skills/fissure_bug_bounty/ that uses these MCP
tools with the full methodology; see the "Automating a bug-bounty
engagement" section below.
The bridge runs stdio by default (a local subprocess, how Claude Code
and Claude Desktop launch it). Set
FISSURE_MCP_TRANSPORT=streamable-http (or
=sse), with optional FISSURE_MCP_HOST /
FISSURE_MCP_PORT (default 127.0.0.1:8779, one
above the control-driven proxy's default 8778 so both run with
defaults), to serve a remote MCP endpoint instead, at /mcp
(streamable-HTTP) or /sse (SSE). A remote endpoint serves,
for example, a ChatGPT developer-mode connector behind a trusted tunnel.
The complete step-by-step for starting the endpoint and connecting
Claude Code, Claude Desktop, or ChatGPT (with the skill / methodology)
is in docs/13_MCP_AND_SKILL_SETUP.md.
Automating a bug-bounty engagement
The control plane is built to run a whole engagement headlessly. The
same flow works three ways: raw HTTP (curl or any
language), the bundled Python client, or an MCP host (Claude Code)
driving the tools as an agent. Pick whichever fits; the engine work is
identical. The ethics rules are enforced in the engine regardless of
driver: only test targets you are authorized to assess, set scope first,
and default to safe over aggressive (aggressive adds intrusive,
sometimes multi-second, probes).
The engagement is one disciplined loop:
- Enable the API and set scope. Start the server
(Settings toggle or
fissure serve --api-key <token>), then constrain scope withPOST /api/scope, or import a program's scope withPOST /api/scopeimport(HackerOne/Bugcrowd/XML/host-list). Scope matches by hostname (it is port-blind and path-blind); an out-of-scope target is refused. - Recon, passive first. Run a passive scan
(
active:false) and read its findings. Optionally bring up the control proxy (/api/proxy/*) and browse the target through it, import an API definition (/api/apispec), brute-force paths (/api/discover), and mine hidden parameters (/api/paramminer). - Authenticated active scan. Pass a
loginconfig toPOST /api/scans(async), pollGET /api/scans/{id}todone, readGET /api/scans/{id}/findings. - Confirm by hand. A scan finishing is not proof of
coverage: check the job's
progress.audited/progress.total. If it is low or zero the active audit under-covered (app-specific GET forms and authenticated endpoints are commonly missed), so confirm known-injectable endpoints yourself withPOST /api/request(and/api/intruderfor a position sweep). Every scanner hit is a hypothesis; a scanner silence is not a clean bill of health. - Report. Export with
GET /api/report?format=(markdown/html/json/csv/sarif/burp, withmin_severity/host/sourcefilters and a risk score), push to PwnDoc (/api/report/pwndoc), or render a PDF (/api/report/pdf). Save the session with/api/session/save.
With curl
API=http://127.0.0.1:8777; H="X-API-Key: <token>"
# 1. scope
curl -s -H "$H" -d '{"allow":"target.test"}' $API/api/scope
# 2-3. authenticated async active scan (login config inline or from a file)
job=$(curl -s -H "$H" -H "Content-Type: application/json" \
-d @scan-request.json $API/api/scans | grep -o '"job_id":"[^"]*"' | cut -d'"' -f4)
# 3. poll to completion
until curl -s -H "$H" $API/api/scans/$job | grep -q '"status":"done"'; do sleep 2; done
# 4. read findings, then confirm leads by hand with POST /api/request
curl -s -H "$H" $API/api/scans/$job/findings
# 5. report
curl -s -H "$H" "$API/api/report?format=markdown&min_severity=low"
With Python (the bundled client)
bridge/fissure_control_client.py is a
pure-standard-library client (no MCP SDK needed), usable from any
script. It reads SUITE_API_URL /
SUITE_API_TOKEN from the environment.
import sys, time, json
sys.path.insert(0, "bridge")
import fissure_control_client as api # SUITE_API_URL / SUITE_API_TOKEN from env
api.set_scope(allow="target.test") # 1. scope first (authorized target only)
job = api.start_scan("http://target.test/", active=True, # 2-3. authenticated scan
login=json.load(open("resources/login/target.json")))
jid = job["job_id"]
while api.get_scan_status(jid)["status"] not in ("done", "cancelled", "error"):
time.sleep(1) # 3. poll pattern
findings = api.get_scan_findings(jid) # 4. then confirm leads via api.send_request(...)
print(api.report(fmt="markdown", min_severity="low")["report"]) # 5. reportWith Claude Code (MCP + the bug-bounty skill)
Register the MCP bridge (see the "MCP bridge" section above), then
ask Claude to run the engagement. The repository ships a
fissure_bug_bounty skill
(.claude/skills/fissure_bug_bounty/) that drives these
exact tools with the right methodology: scope-first, the poll pattern,
manual confirmation of scanner leads, scope hygiene, and evidence-driven
reporting. Working inside the repo Claude loads it automatically;
otherwise name Fissure or invoke /fissure_bug_bounty. A
prompt is enough:
I'm authorized to test http://target.test (my own staging lab). Using the Fissure
MCP: set scope to it, run an authenticated scan with resources/login/target.json,
confirm the findings by hand, and give me a report with severities.
Limitations
POST /api/scanandPOST /api/requestare synchronous (they block the connection until the work completes) and the server handles one connection at a time. For long scans use the asyncPOST /api/scansjob API, which returns immediately and runs the scan on a worker thread. Do not pointPOST /api/requestat the control API's own port: the accept loop is busy serving that request and cannot answer the nested one. Reachability follows the usual rule: the target and the OAST collector, if any, must be reachable from the host running Fissure.- Async scan jobs live for the lifetime of the process unless cleared:
POST /api/jobs/cleardrops every finished (done/error/cancelled) job, and the rest are stopped and reclaimed when the server shuts down. Progress is best-effort (a sample is skipped rather than blocking the accept loop while the worker holds the scan lock). - Response bodies are returned as a JSON string; a non-text (binary) body may not round-trip cleanly.
- The control API operates its own findings store; it does not surface the interactive proxy/scan history, by design.