Fissuredocumentation v5.3.1
On this page

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:

  1. the path appears in this document;
  2. the path appears in bridge/fissure_control_client.py, so a client function carries it;
  3. that client function is called from inside an @mcp.tool body in bridge/fissure_mcp_bridge.py, so the route is reachable over MCP and not only from a Python script;
  4. every public client-library function that issues a _call is 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-Key value 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.1 only. fissure serve --host can 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 at GET / / GET /ui (static HTML, no data). Send it as either X-API-Key: <token> or Authorization: Bearer <token>. A missing or wrong token returns 401.

  • 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_routes classifies 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_routes fails when a registered route is missing from it and make webui-check fails when it is stale, so after adding a route's row here run that script and then packaging/gen-webui.sh. It is a thin client over the same routes: paste the token once (kept in the tab's sessionStorage), and every call it makes carries X-API-Key. The token field is masked with a Show/Hide toggle (masked via CSS text-security, not a type=password input, 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 in localStorage) identifies you on the shared team: on Connect the dashboard calls POST /api/team add_member (idempotent) and heartbeats presence, and a scan you start is logged to the team activity feed via POST /api/team log attributed 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-Length over that cap is refused with 413 before 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, POST and HEAD. HEAD is served wherever GET is, including the open routes, so a health check or reachability probe that sends HEAD /api/status gets the status line and Content-Length its GET would produce and no body, instead of the 401 an exact-method match used to give it on an endpoint documented as open. Any other verb (PUT, DELETE, OPTIONS, ...) answers 405 with an Allow: GET, POST, HEAD header, which says the method is wrong rather than the 404 that 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: (a manual test: 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 serve takes 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 a login config to POST /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/findings and 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:

  1. Enable the API and set scope. Start the server (Settings toggle or fissure serve --api-key <token>), then constrain scope with POST /api/scope, or import a program's scope with POST /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.
  2. 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).
  3. Authenticated active scan. Pass a login config to POST /api/scans (async), poll GET /api/scans/{id} to done, read GET /api/scans/{id}/findings.
  4. 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 with POST /api/request (and /api/intruder for a position sweep). Every scanner hit is a hypothesis; a scanner silence is not a clean bill of health.
  5. Report. Export with GET /api/report?format= (markdown/html/json/csv/sarif/burp, with min_severity/host/source filters 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. report

With 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/scan and POST /api/request are synchronous (they block the connection until the work completes) and the server handles one connection at a time. For long scans use the async POST /api/scans job API, which returns immediately and runs the scan on a worker thread. Do not point POST /api/request at 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/clear drops 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.