Fissuredocumentation v5.3.1
On this page

Fissure feature and functionality inventory

The canonical list of everything Fissure does. This file is kept current: whenever a user-visible feature or functionality is added or changed, it is updated in the same change (see CLAUDE.md). It is a "what exists" index; the design docs (00_MASTER_PLAN.md through 12_DVWA_LAB.md) and the in-app Help cover the "how".

Fissure is a native Linux web-security toolkit written in C99 on Allegro 5 and the Nilorea library: an intercepting HTTPS proxy, a full website scanner, an OSS-tool plugin host, a set of forging/analysis workshops, and a synthetic report generator, all in one offline-first GUI.

Intercepting proxy (MITM)

  • HTTP/HTTPS intercepting proxy with a live flow list (method, URL, status, type, length, timing), filtering, and search. The captured-flow list can be cleared (the Proxy view "Clear" button, POST /api/proxy/clear, MCP proxy_clear); the on-disk history file is left untouched.
  • TLS man-in-the-middle: a per-install CA (generated once), per-host leaf-cert minting cached per host, and SNI-aware per-connection certificates. The user installs the CA in their trust store; it is never shared.
  • A saved session round-trips without duplicating its evidence archive either: merging captures skips any whose id the store already holds, so reloading the same session repeatedly leaves the capture count unchanged. Before, every load appended a second copy of each capture while the id index moved onto it, so the archive grew without bound and the older copies became unreachable but were never freed.
  • A saved session round-trips without duplicating findings. Whether a finding is site-wide (keyed on host/category/title) or per-URL (which also keys on the location) is now stored on the finding and written to the session file, so reloading a session and merging it back into the live store leaves the count unchanged. Before, every finding rebuilt as per-URL, so a reloaded host-level finding got a key that no longer matched the original and appeared twice, and it stopped collapsing across URLs. Session files written before the flag existed still load, rebuilding per-URL as they always did.
  • IP-addressed HTTPS targets can be intercepted with certificate verification left on. RFC 6066 forbids sending SNI for an IP literal, so the proxy takes the leaf's name from the CONNECT target when the client sends no server name, and mints CN=127.0.0.1 with an IP Address SAN instead of a CN=localhost leaf the client would refuse. Thick clients and internal services addressed by IP no longer need verification disabled.
  • A captured HTTPS flow keeps its non-default port (https://host:8443/path). The URL is the only record of which service a flow hit, so dropping the port sent a Repeater, organizer or control-API replay to 443, silently testing a different service or nothing.
  • HTTP/2 upstream from the intercepting proxy: the proxy offers ALPN "h2,http/1.1" on its upstream TLS leg and, when the origin selects h2, forwards the flow over HTTP/2 and re-frames the response back into the HTTP/1.1 bytes its client leg speaks, so flow capture, match/replace, the passive audit and the history all keep seeing one wire format. An origin that does not select h2 takes the unchanged HTTP/1.1 path, as do the two request shapes h2 cannot express: a WebSocket upgrade (HTTP/2 forbids the Upgrade header) and a chunked request body (which the proxy relays still framed). Each request to an h2 origin gets its own upstream connection (the exchange is single-shot, so a kept h2 leg is never reused), where an HTTP/1.1 leg keeps its keep-alive reuse. The HTTP/1.1 client's hop-by-hop headers never cross into HTTP/2: Connection, Keep-Alive, Proxy-Connection, every header the Connection header nominates, and TE (kept only as te: trailers) are removed, since a strict h2 origin resets a stream that carries one and the client would see a 502. Without this the proxy advertised no ALPN and every browser flow through it was silently downgraded, hiding protocol-dependent behaviour and making the proxy's traffic distinguishable from the browser's. The negotiated protocol is shown in each flow's TLS note ("trusted, h2" / "trusted, http/1.1", or "UNTRUSTED (h2): "), so a downgraded flow is visible rather than silent.
  • HTTP/2 on the proxy's CLIENT leg: the intercepted TLS handshake offers ALPN "h2" then "http/1.1", and when the browser picks h2 the connection is served by the HTTP/2 state machine. Each stream's request is re-framed as HTTP/1.1 bytes and run through the same pipeline as an HTTP/1.1 request (interception, match and replace, the request hook, OAST injection, the upstream exchange, capture) before the response is re-framed back into HTTP/2, so every check, rule, view and report keeps working unchanged. Cookie fields, which HTTP/2 lets a browser split one per crumb, are joined back into the single Cookie header HTTP/1.1 has (otherwise the session cookie reaches the origin as only its first crumb), and a chunk-framed response is de-chunked, since HTTP/2 has no chunked transfer encoding. A blocked, failed or dropped request is answered on ITS stream (403 / 502 / RST_STREAM) instead of tearing down a connection still carrying other requests. On by default; Settings -> "Accept HTTP/2 from the browser on the intercepted leg" turns it off, and then no ALPN is offered and every client falls back to HTTP/1.1. The target sees no difference either way (the upstream leg negotiates h2 on its own): what this adds is that the proxy can observe and EDIT a request a browser could only express over h2, and that an h2-only client can use the proxy at all. Exposed over the control API as client_http2 on POST /api/proxy/start (and reported in the proxy status), and as the client_http2 argument of the proxy_start MCP tool.
  • A body larger than the proxy's hold limit (16 MB) is forwarded whole but relayed past the limit instead of being buffered: the transfer completes at full size and full speed, starts reaching its destination while it is still arriving, and one large download no longer grows a worker's buffer until the process dies. Such a flow is NOT held for interception, rewritten by match-and-replace or an extension hook, or captured in full, so it is reported three ways: a popup notice plus a WARN line in the event log, a Body column in the Proxy view reading "capped", and a body_capped field on GET /api/proxy/history, /api/proxy/history/{index} and the proxy_history / proxy_flow MCP tools (persisted in the NDJSON history). An HTTP/2 client leg keeps reading the whole body, because it re-frames the response from a complete buffer before it can write a frame.
  • Every refusal the proxy makes on its own (a WebSocket capture it could not take, a body too large to hold) is surfaced as an operator popup AND recorded in the event log, so it survives the popup and is readable from a headless run.
  • Each captured flow records the protocol the CLIENT spoke to the proxy ("h2", "http/1.1", "http/1.0"), shown in the Proxy view's "Client" column and returned as client_proto by GET /api/proxy/history, /api/proxy/history/{index} and the proxy_history / proxy_flow MCP tools. The TLS note answers a different question, the UPSTREAM leg's protocol, and the two routinely differ (a browser on h2 to the proxy, the proxy on HTTP/1.1 to an origin that offers nothing else). It persists in the NDJSON history, so a reopened project still says which requests the client could only have sent over HTTP/2. A chunked request body is de-chunked into a plain body with a real Content-Length before the h2 reframing, so it goes over HTTP/2 like any other request rather than being forced down HTTP/1.1; malformed framing is refused and left on the h1 path rather than half-converted into a request whose length lies about its body.
  • Web dashboard: it shows what the control session holds, and reaches every route. An operator driving Fissure through an agent saw findings in the browser but not the proxy history, the project or the scope the agent could read. The Status tab now has a workspace overview (active project, scope, proxy, traffic, jobs); every tab that displays state loads on open and on Connect instead of waiting for a button; a captured flow opens its request and response; a Traffic tab lists every request every tool sent, with each record's bytes; the Scope tab manages the named scopes; a Projects tab lists, creates, activates and deletes projects; Findings has a Clear. An API tab lists every control route with its documented body and draws list results as a table, so nothing the MCP bridge can call is out of reach in the browser. A failed proxy-history load reports on the Proxy tab (it used to write into the Tools tab), and a status line no longer stays red after a later success.
  • Web dashboard: dedicated cards for the routes that used to be reachable only from the API console. A declarative view/action engine derives each card from the route's documented body, so the page cannot drift from the API docs. New/extended tabs: Config (user agents, environments, transform tags, resource pools, host routes, scan profiles, auto-repeater), Extensions (bundles, marketplace, contributed actions/editors), Plugins, Saved (Repeater tabs, organizer, attack configs), Relay (raw TCP/UDP), plus match/replace, intercept-rule and highlighter editors and the CA download on Proxy, and the workshops (JWT, cookie, SAML, GraphQL, compare, inspect, sequence, ...) on Tools. Control-bypass actions show the code-of-conduct notice first. Project Delete is disabled on the default and active rows; deleting the active named scope spells out which scope becomes enforced. Every route is enforced to have a dashboard card or a recorded console-only reason (tests/test_control_routes), and a committed headless-Chrome smoke (tests/test_webui_browser, skipped when no browser is present) opens every tab and round-trips a view and an action.
  • Web dashboard: interception, scan and job cancel, and the full scan-option set. The browser dashboard could start and stop the proxy but never HOLD anything, which is the one thing an intercepting proxy is for; it polled a scan forever with no way to stop it, so a runaway run needed the desktop app or a restart; and its Scan tab sent 3 of the ~20 fields the route accepts. It now arms interception (requests, and optionally responses), polls for the held message, and forwards it edited or drops it; cancels the scan it started and any running job from the job list; and exposes the whole scan-option set (depth, pages, threads, delay, time budget, per-host rate, time-probe concurrency, families, insertion points, session cookie, path excludes, extra headers, the WAF-bypass switches, an upstream proxy and a client certificate) behind a collapsed "Scan options" section. An empty field is not sent, so a blank box still means "leave the default alone" rather than zero.
  • Resource pools (Config toolbar category, the command palette, GET/POST /api/respools, the respools / respools_op MCP tools): named concurrency and rate budgets that apply ACROSS the tools. Every tool already bounds itself, and none of them can bound each other: two Intruder attacks plus a scan against one host each open their own workers and the target sees the sum, which is how an authorized test knocks a service over and how a rate-limited API starts answering 429 to everything. A pool is a cap on sends in flight and on requests per second, plus the rules that decide what belongs to it (host patterns and tool names: scanner, intruder, repeater). The first matching pool wins; the built-in "default" is unlimited and cannot be removed, so an install that configures nothing behaves exactly as before. The popup shows each pool's live in-flight and waiting counts, which is what distinguishes "my scan is slow" from "my scan is queued behind an Intruder attack". Pools persist to <config>/respools.json and are loaded by both the GUI and the control server, so an agent-driven scan honours a budget the operator set in the GUI. The proxy's own forwarding is deliberately not pooled: it relays what a browser asked for, so queueing it would stall the operator rather than protect the target.
  • Sequencer with LIVE CAPTURE and a per-position / per-bit verdict (Analysis & inspection toolbar category, the command palette, POST /api/sequence, the sequence MCP tool): point it at a URL, say where the token lives (cookie, header, JSON field or a regex whose first group is the token) and how many to collect, and it issues the request that many times and extracts one token per response. Harvesting a few hundred tokens by hand is why this analysis normally never gets run. The verdict then names WHICH part of the token is predictable rather than scoring the pile: per-byte-position entropy (how many distinct values that position took, and how many bits it carries) and per-bit balance, on top of the aggregate Shannon / monobit / chi-square, a NIST-style runs test and the longest run of equal bits. A token whose first half is a constant prefix and a counter reports as "predictable" with the exact byte offsets, which is what a report needs; an aggregate score would call the same token moderately random. Thresholds scale to the token's own alphabet, so a hex or base32 session id is judged against what its character set allows instead of against a byte's theoretical 8 bits, and the bits that are constant purely because the token is ASCII text are reported but never drive the verdict. Capture is scope-checked and capped; analyzing a pasted list is not. In the GUI the capture runs on a worker thread, so a 50 to 1000 request harvest never freezes the window: a progress bar beside Analyze shows "collected / requested", the status line carries the live count plus a spinner, and the Capture button becomes "Stop" (pressing it ends the run after the request in flight and analyzes what was collected so far).
  • Raw request editor (Analysis & inspection toolbar category, the command palette, the Repeater's "Raw edit" button, and the Proxy view's "Raw edit" on a held request): author an HTTP message as BYTES and send it with no reframing at all. Everywhere else a request is composed for you (the Repeater builds one from a method, URL, headers and body; the proxy reframes what it forwards), which is right for ordinary work and wrong for confirming a smuggling, CRLF-injection or parser-differential finding by hand, where the point is the bytes nobody would generate: a lone LF between header lines, a NUL in a header value, two Content-Lengths, a verb no combobox offers. Two views sit over one buffer and stay in sync: an escaped-text editor (\r \n \t \0 \ and \xHH, everything else literal, so a head stays readable and every unprintable byte is visible and typeable) and an EDITABLE hex view (type a hex digit to overwrite a nibble, Insert adds a byte, Delete removes one). The status line says whether the message would survive an ordinary text editor, so a tester knows when the raw path is the only safe one. Send connects to the host/port fields (never the Host header, since the bytes are sent as typed) and shows the reply escaped the same way; Forward hands the exact bytes to a held interception with no line-ending repair. The exchange runs on a worker thread (it waits up to the raw-editor timeout for an answer), so an unresponsive target never freezes the window: the Send button reads "Sending" and is disabled while the bytes are in flight and the status line animates a spinner until the reply, the connection failure, or the timeout comes back. Exposed headlessly as POST /api/request/raw and the send_raw MCP tool (bytes as base64 or as the same escape syntax), and as data_b64 on the interception resolve route and its intercept_resolve MCP tool.
  • Fissure Browser (one-click proxying; the toolbar "Browser" button and the Proxy view "Browser" button): launches a Chromium with an isolated profile pre-pointed at the intercepting proxy on 127.0.0.1 (and --proxy-bypass-list=<-loopback> so local targets route through the proxy too), with the Fissure CA trusted in the profile's OWN NSS store so it never touches the user's real trust store, so a user proxies HTTPS with one click instead of hand-configuring a browser and importing the CA. The button starts the proxy first if it is not running (which creates the CA), then trusts it in the profile via certutil with HOME overridden to the profile. The distributed packages make this automatic: the .deb depends on libnss3-tools (certutil) and the AppImage bundles certutil next to the binary; a build without certutil says so ON SCREEN when the browser is launched ("Fissure Browser: HTTPS not intercepted"), naming the missing package and the Settings -> Export CA fallback, because an untrusted CA turns every intercepted HTTPS page into a certificate warning and that used to be a log line nobody read. The window is tagged WM_CLASS "FissureBrowser" with a fissure-browser.desktop carrying the Fissure icon/name. The bundled Chromium is fetched at package time (packaging/fetch-chromium.sh, a pinned Chrome for Testing) into the AppImage/deb as chromium/ next to the binary; when it is absent the app falls back to a system Chromium/Chrome (or $FISSURE_CHROME). The same browser resolution backs the headless DOM probe. Authorized targets only.
  • Request/response interception with an editor: pause a flow, edit it, forward or drop. The intercept editor reuses the structured request editor (Inspector) and the response views. Two independent toggles in the Proxy view: "Intercept" holds requests on their way to the origin, "Responses" additionally holds each response on its way back to the client. They are separate because holding every reply is far more intrusive than holding requests, so arming interception never starts pausing the whole browsing session on its own; a response is held only when both are on. A held message is labelled with its direction ("HELD REQUEST" / "HELD RESPONSE"), since Forward means something different for each. Editing a response is how a client-side-only control is demonstrated: flip an "admin": false in a JSON reply, strip a disabled attribute from a returned form, or change a status code, then show the server accepts the action it unlocks. The edited bytes are what the flow capture records, because the capture logs what actually reached the client. Dropping a response closes the connection (there is no reply left to send); a 101 is never held, so a WebSocket upgrade is not stranded mid-handshake. Headless parity: GET/POST /api/proxy/intercept (with responses, and a direction on the held message) and the intercept_status / intercept_set / intercept_resolve MCP tools.
  • The flow capture records what was SENT: by the time a flow is stored the request has been through match/replace, the PwnFox strip, OAST injection and any extension request hooks, and on the plain path its head is in origin form, which is what the origin received. Previously the capture stored the client's original bytes, so a report could cite a request that was never sent, and the gap widened with every rewriting feature. Responses follow the same rule (an edited response is captured as edited), so both directions agree. The absolute URL is kept as its own field, so re-sending a captured request from the Repeater or the organizer still resolves its target; the PwnFox identity is still read from the client's request, since the forwarded copy has that header stripped by design.
  • Conditional intercept rules ("Intercept rules" popup, Capture toolbar category and the command palette): an ORDERED table deciding which messages interception actually stops on, because a single on/off switch is unusable on a real site (every image, font and beacon stops the browser). The FIRST matching rule wins, so a narrow rule sits above a broad one, and Move up / Move down make the order editable. A rule constrains any of direction (request/response/both), host substring, exact method, path or URL substring (an extension such as .js works), Content-Type substring, and a response status range; a blank field means any and matching is case-insensitive. Traffic no rule matches takes the set's default action. An empty set holds everything, exactly as the plain toggle always did, so the feature is opt-in and changes nothing until a rule is written. Rules are per project (<project>/interceptrules.json) and apply live to a running proxy. Headless parity: GET/POST /api/proxy/intercept/rules and the intercept_rules / intercept_rules_set MCP tools (declarative whole-table replace, since order decides the outcome).
  • Selectable request/response panes: the HTTP-highlighted request and response panes are read-only but support mouse text selection (drag to select), Ctrl+C to copy, and Ctrl+A to select all, so an operator can lift a token, header, or value straight out of a captured flow. Implemented as an n_gui syntax-view selection model, so every syntax view in the app is copyable. Copy/paste goes through the Nilorea n_clipboard backend on Linux, which owns the X11 CLIPBOARD (and PRIMARY) selections and serves the full target set (UTF8_STRING, STRING, text/plain, text/plain;charset=utf-8, TARGETS), so text copied from Fissure pastes into strict consumers such as Chromium, not only GTK apps.
  • Per-flow annotation: a free-text Comment (edited in a shared prompt dialog) and a manual Highlight color cycled from a fixed palette on the selected flow, shown in the grid's Note and Highlight columns (a manual highlight overrides the HaE color) and persisted with the proxy history so they survive a restart.
  • Per-request send history.
  • Match-and-replace rules (regex or literal, request/response, header/body) with an in-app editor, applied to proxy flows and to the scan engine. A regex rule's replacement is a template with $N / ${N} capture-group backreferences (e.g. id=(\d+) -> id=${1}0, via the Nilorea npcre_replace helper). The same persistent ruleset (<config>/matchrep.json, shared with the GUI) is driveable headless over the control API (GET/POST /api/matchrep) and the matchrep MCP tool (list/add/set/enable/remove/clear; an uncompilable regex is rejected), and it applies to the control proxy and control scans, so an agent has the same match-and-replace power as the GUI operator.
  • Highlighter/Extractor (HaE): passive regex rules over every captured flow that color-highlight matching flows and extract capture-group values into grid columns; a starter ruleset ships and edits persist to hae.json. A matching flow's row is PAINTED in the rule color in the proxy list (nine colors, gray < blue < purple < cyan < green < yellow < orange < pink < red by priority; the highest wins when several rules match, and a manual per-flow highlight overrides them), with the color name kept in the Highlight column so it stays sortable and filterable. The rule editor previews each rule in its own color, and its Literal button escapes plain text you typed (a disposable mail address, an order number) into a pattern that matches exactly. A "Restore defaults" button in the editor (mirrored by the POST /api/hae {op:defaults} route and the hae(op="defaults") MCP tool) replaces the current rules with the built-in starter set. Driven headless too: GET/POST /api/hae + POST /api/hae/apply and the hae / hae_apply MCP tools share the same ruleset, and a captured flow carries its highlight/extracted verdict over GET /api/proxy/history/{index} (and over the listing with hae=1), so an agent can triage a browsing session by tag.
  • Transparent (non-proxy-style) proxying and per-host routing (DNS rewrites and per-host upstreams).
  • Generic non-HTTP relay (raw TCP/UDP interception): a non-HTTP intercepting proxy for any protocol the HTTP proxy cannot parse (a proprietary binary protocol, a database wire protocol, a game protocol, a custom TLV). Point a client at a local listen port; every byte is forwarded to a fixed upstream host:port and captured in both directions, with optional client TLS on the upstream leg. Enable interception to hold each chunk (or datagram, for UDP) for edit-and-forward or drop, reusing the same hold FIFO as the HTTP intercept. Driven from the "Raw proxy" toolbar popup, the control API (/api/relay/start|stop|status|history|intercept|intercept/resolve, chunk bytes base64), and the MCP relay_* tools. Authorized targets only.
  • PwnFox-style multi-identity tagging: recognize an identity header a browser adds to requests (X-PwnFox-Color, or the X-Fissure-Identity alias), strip it before forwarding upstream, and tag the captured flow with that identity/color (shown in the proxy grid's Ident column). Fissure ships no browser code; the browser side is documented.

Target, site map, and scope

  • Site map in three displays (the Target view "View" button cycles them): a flat endpoint grid, a host/path tree, and a node-graph overlay. The graph is a custom-drawn visual map of the host/path model (hosts in the accent colour, endpoints coloured by HTTP status: 2xx green, 3xx blue, 4xx amber, 5xx red), laid out left-to-right by path depth, for a bird's-eye view of the attack surface; the tree and grid stay for detail. The graph draws at a constant, legible scale; a large site map scrolls INSIDE the graph pane (mouse wheel, Shift+wheel for sideways, drag-to-pan on empty space, or the two scrollbars) while the heading, the column ruler, and the Target view's own controls stay put, so a big map never pushes the URL / Scan / profile rows off the top. Every depth column is sized to the widest label actually in it (auto-fit, measured in the live font and clamped so one absurd name cannot push the rest off-screen), so host names and long path segments read in full instead of being cut to the same stub. The fit is adjustable: a ruler strip above the graph carries a resize grip on each column edge (drag to size that one column, right-click a grip to return it to auto-fit), Ctrl+wheel over the graph spreads or compresses every column at once, and the "Fit columns" button drops every hand-sized column and the spread together. The spread and the pinned widths are persisted, so a hand-tuned graph survives a restart. Labels are still truncated to their column, so a column pinned narrower than its contents cannot overrun the nodes beside it. Double-clicking a node that has children focuses the graph on that subtree (it becomes the root, so a deep map is read one branch at a time); to go back, double-click that focus root again (the same gesture, toggled) or click the "Whole map" button that appears while focused. Double-clicking a final (leaf) node, which has no subtree to focus, loads its URL into the URL field instead, ready to Scan or send. The View button names the current display (Grid / Tree / Graph) and cycles on click, and the OS window title reflects the active view (and the Target sub-mode), so the current mode is visible at a glance. Hovering any node shows its full URL in a hint bubble at the cursor (an endpoint uses its own URL, a host root its origin, a directory its origin + path; the graph carries no widget tooltip of its own, so nothing is drawn over that bubble), and right-clicking ANY node - host root, directory, or endpoint - opens the same cross-tool context menu as an endpoint row (Send to Repeater/Intruder, add or deny scope, Scan, Scan with profile, CSRF/Clickjack PoC, AI assist), so the graph is not just a picture but an action surface at every level of the tree.
  • Site map with content discovery. The Discover tool loads a curated resources/wordlists/paths.txt (falling back to a built-in list), and a companion resources/wordlists/params.txt feeds parameter mining; both are curated from the nuclei-templates path/parameter lists (MIT).
  • Inventory of discovered endpoints (method, URL, source, status, content type, body, headers, params), persisted per project.
  • Row highlight coloring on the endpoint grid (parity with the Proxy and Findings grids): a Highlight button cycles the selected endpoint's manual color from a fixed palette (red / orange / yellow / green / blue / purple), painting the row; a passive HaE-rule match against the endpoint's recorded request material paints any row with no manual color. The manual color is stored on the endpoint and persists with the inventory, and it is settable headless over POST /api/target/highlight and the MCP tool target_highlight.
  • Recon-to-inventory bridge: a recon-category plugin (subfinder, gau, waybackurls, katana, httpx) run from the Plugins view feeds the site map, not just findings. Bare-host output is added to the scope allowlist and seeded as a crawlable origin; URL output (gau/waybackurls) is merged into the inventory as a crawl-frontier endpoint (optionally scope-filtered); and a JSON-object line (katana -jsonl, httpx -json) has its endpoint URL extracted from the JSON (request.endpoint / url / input) and merged the same way, so those two tools widen the crawl frontier and not only the findings list. All tagged with a recon source. This closes the recon -> crawl -> scan loop. Exposed headless as POST /api/recon and the MCP tool recon so an agent can run its own recon toolchain and feed the loop.
  • One-action recon chain: a Recon all button in the Plugins view (and POST /api/reconchain / the MCP tool reconchain) runs every installed recon-category tool against a seed host in sequence and routes their combined output through the recon bridge, widening the surface in one action instead of running each tool by hand. Scope-checked before any tool runs; absent tools are skipped and counted, and the outcome (tools run/absent/failed and hosts/URLs seeded) is reported on screen.
  • Recon asset view + new-since-last-run diff: the Dashboard rolls the endpoint inventory up to host-level assets and shows, per host, its representative origin, a live/dead status (an HTTP status means the host answered), the detected technology (from httpx -json webserver + tech), and its endpoint count. Each asset is flagged new (absent from a saved baseline) or changed (its status/liveness moved), and disappeared hosts are listed as gone, so a hunter acts on the delta instead of re-triaging the whole surface. The Snapshot baseline button re-bases the diff (saving the current assets to a per-install snapshot under the config dir). Exposed headless as GET/POST /api/assets (POST optionally merges recon output and/or saves a new baseline) and the MCP tool assets.
  • Origin-IP discovery (CDN/WAF bypass, CWE-200): confirm which candidate IPs are the real origin of a CDN/WAF-fronted host. For each candidate IP (from recon: historical DNS, an ASN/CIDR sweep, resolved subdomains), Fissure connects directly to it while sending the target Host header (a per-host connect rewrite, fissure_hostroute), on http AND https (an explicit :443/:8443 tries TLS first; the second scheme is tried only when the first got no HTTP answer at all), and counts a 2xx with a substantial body OR a 3xx whose Location keeps the browser on the target host - the everyday origin that redirects cleartext to TLS - as reachable. Reachability is not confirmation: a box running a stock web server answers any Host, so a reachable candidate must also clear two differentials before anything is reported. A CONTROL request asks the same address again with a Host header it cannot know; if it gets the same page, the address answers everything alike and proves nothing. A REFERENCE fetch pulls the site through its own name (over the caller's normal routing) and the candidate's body must match it. Both hold: a FIRM finding. No reference fetchable: the finding is downgraded to TENTATIVE and its evidence says the content could not be matched against the real site. Body does not match an available reference, or no reference and the control got the same page: nothing is reported. The evidence names the scheme, the similarity, and what the control answered, so a report never claims a bypass the run did not demonstrate. Candidate generation is the recon side; Fissure does the origin confirmation. The scope allowlist covers the CANDIDATES, not just the fronted host: every ip[:port] is checked 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 refused outright, so a candidate list cannot be used to sweep arbitrary addresses past the allowlist. Exposed headless as POST /api/originip and the MCP tool originip (the module fissure_originip is unit-tested, tests/test_originip).
  • WAF/CDN fingerprinting (wafw00f-class): identify the protection fronting a target by matching its response headers, cookies, and block-page body against a signature table (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 ("we use Barracuda spam filters") or says a request was blocked is not fingerprinted as a WAF. Pure recon (it inspects a response, it does not attack or evade). Exposed as POST /api/wafdetect (fetch a URL, or scan a supplied header block) and the MCP tool wafdetect (fissure_wafdetect, unit-tested). The reply also carries suggested_encoders and suggested_request: where to START the input-filter bypass for the product it fingerprinted, droppable straight into a scan as waf_encoders / waf_request, so an operator does not spend a run per guessed chain. It is a starting point and not a claim that the chain defeats that product: a product name says what KIND of filter is in front of the application, not which rule fires on this endpoint, and the backend behind it decides as much as the filter does. It informs both reaching the origin directly (origin-IP above) and the input-filter-bypass encoders below.
  • Input-filter (WAF/CDN) bypass encoders (for authorized vulnerability demonstration): a WAF is a mitigation, not a fix, so when a real vulnerability exists but the canonical payload is blocked, a tester must show the underlying bug is still exploitable. This transforms a payload into input-filter-bypass variants - alternating case, an empty inline comment for whitespace, whitespace-to-plus/tab, single and double URL encoding, and a nowafpls-style JSON body padding (a large padding key that pushes the real payload past a WAF's body-inspection window; it applies to a JSON object body only, and leaves an empty object valid JSON). An encoder whose output carries NUL bytes (utf16) must be the LAST of a chain: a chain that puts another encoder after it is refused with a log line instead of silently returning the few bytes before the first NUL. Exposed as POST /api/wafbypass (apply a comma-separated encoder chain) and the MCP tool wafbypass (fissure_wafbypass, unit-tested). Scope, per CLAUDE.md: it defeats a blocking INPUT FILTER to prove a bug on an authorized, in-scope target; it adds NOTHING to conceal, delay, or misattribute the tester's activity to evade the target owner's logging, monitoring, or incident response. In the GUI the encoders are Multitool transforms (alternating case, space to comment, double URL-encode, JSON body padding), listed in the Multitool's transform selector like any other encoder. As a control-bypass feature it carries the enforced non-blocking code-of-conduct notice: applying a WAF-bypass transform in the Multitool shows the shared fissure_gui_confirm_info popup (FISSURE_COC_NOTICE) and records the use in the event log before it runs, and the headless POST /api/wafbypass returns the same notice string (and logs it). The warning is acknowledged, not blocking. One-click retry (active): a "WAF-bypass retry" request context-menu action (Proxy, Findings, and Target right-click) resends the selected request as-is, then again with the encoder chain applied to its query string and body, and shows the original-vs-bypassed status/length (did the block lift). It runs off the UI thread, needs aggressive mode and an in-scope url, and surfaces the code-of-conduct notice first. Headless as POST /api/wafbypass/resend and the MCP tool wafbypass_resend (returning {original, bypassed, changed, notice}), so an agent runs the same retry: confirm the WAF (wafdetect), then resend a blocked payload encoded to prove exploitability.
  • Recon screenshots (visual triage): drive a headless browser (the bundled Fissure Browser or a system Chromium/Chrome) over CDP to capture a PNG screenshot of a discovered host or endpoint, saved under <config>/screenshots/, so an operator eyeballs a large attack surface fast (spot login pages, admin panels, default installs, parked hosts). Scope-gated; a passive capture (it loads the page, it does not attack it). Exposed headless as POST /api/screenshot (capture one URL) and GET /api/screenshots (the gallery index), and the MCP tools screenshot / screenshots; when no browser is available the capture route returns 501. The module fissure_screenshot is unit-tested (tests/test_screenshot, guard paths + a browser-gated real capture).
  • Attack-surface analyzer: a rollup over the discovered endpoint inventory summarizing the target's attack surface, in an "Attack surface" popup (Analysis & inspection toolbar category + command palette). It tallies total endpoints and distinct hosts, total query parameters, the query-vs-body split, the static-vs-dynamic split, the auth-required split (from each endpoint's captured Authorization/Cookie headers), and the discovery-source (proxy/crawl/import/discover/ recon), HTTP-method, and response-status breakdowns, plus the findings count, so an operator can size and prioritize a target at a glance. Populated as the crawler and scanner discover endpoints; a Refresh button recomputes. Exposed headless as GET /api/surface and the MCP tool surface (the control layer accumulates a durable endpoint inventory across control scans to back it). The engine (fissure_surface) is unit-tested (tests/test_surface).
  • Scope allowlist (host/regex) enforced across active scanning, fuzzing, and MITM; out-of-scope actions are refused with an on-screen reason. Patterns are an exact host, a .suffix, a re:<regex>, or *, each optionally with a :port (host:8080) to constrain to one port (a bare host matches every port), so a co-hosted service on another port of an in-scope host can be kept out. Scope is per-project: it is saved to and restored from the active project (<project>/scope.json), so each engagement keeps its own in/out lists and switching projects reloads that project's scope (a legacy global scope from an older settings.json migrates into the active project once).
  • Named scope profiles: a project can hold several named scopes (e.g. Production, Staging, API only) and switch the active one, so an engagement flips its whole in/out scope between segmented targets without retyping patterns. The active named scope drives the one enforced scope everywhere (scanning, fuzzing, MITM, and the query-filter scope). Managed in the Scope popup's scope selector (New/Rename/Delete/switch), over the control API (GET/POST /api/scopes: list/activate/save/delete/rename), and the MCP scopes tool; persisted to <project>/scopes.json, with the current scope.json migrated into a "Default" named scope on first use.
  • Scope editor popup: a dedicated window that edits the in-scope and out-of-scope pattern lists as multi-row editors (one pattern per row with a "+" to add and an "x" to delete, an "In scope" / "Out of scope" tab, a live in/out count, Save and Import scope) instead of free-text fields. The pattern column header names the active list ("In scope patterns" / "Out of scope patterns"), so the shown list is clear without toggling the tab buttons. Launched from the Proxy capture-list toolbar ("Edit scope"), the Target view, the "Scope" toolbar entry (Capture group), and the command palette ("Open Scope editor"). It reads and writes the same scope the whole app enforces.
  • A failed scope write is always reported, never shown as a save. The scope file is the authorization boundary that gates active scanning, so fissure_scope_write_file checks the open, the write length and the flush at close, and every caller that told the operator the scope changed reflects a failure: the editor's Save shows a "Scope not saved" popup and a persistent "NOT SAVED (write failed)" status instead of "Saved.", switching named scopes shows the same status, and the context-menu add-to-scope and Import-scope confirmations append a warning that the change applies to this session only. Without this an unwritable or full project directory would silently restore a stale or empty scope on the next load, and a later scan could run outside the authorized boundary.
  • Add-host-to-scope AND add-to-out-of-scope, plus per-endpoint "Scan this", from the cross-tool right-click context menu (Proxy history, Findings, and the Target endpoint grid), not only the Targets host list.
  • Program-scope import (Import scope): load a bug-bounty program's in/out-of-scope hosts from a HackerOne/Bugcrowd scope JSON, a scanner target-scope JSON, or a plain host list (offline, no live API) into the scope allow/deny lists.
  • Cross-role site-map comparison (diff two roles' reachable maps for access-control gaps).
  • Target view Findings button: jumps straight from the Target view to the Findings view (next to the Snapshot role / Compare roles controls), so what the crawl, the scan and the role comparison raised is one click away.

Website scanner

  • Crawler with configurable depth and an authorization banner before active scans.

  • JavaScript endpoint mining: inline <script> bodies and fetched external .js bundles are mined for URL/route tokens (fetch/axios/XHR targets, relative and absolute paths, templated API roots), resolved against the page base and recorded in the inventory like a link, so SPA/XHR endpoints that never appear as an href become audit targets. Secrets in JavaScript are covered by the passive audit. Also exposed headless as POST /api/jsmine and the MCP tool jsmine, and on demand from any request's context menu via "Mine JS": it fetches the URL as a bundle on a worker thread, seeds the mined endpoints into the site map, and scans the body for secrets, reporting the counts in a popup (so an operator can mine one specific bundle rather than waiting for a crawl; the headless equivalent is jsmine on the fetched body followed by recon to seed).

  • JavaScript source-map unpacking: a minified bundle hides most of its endpoint surface, but a linked source map (//# sourceMappingURL=...) carries the original unminified sources where fetch/route/API strings are readable. The miner (fissure_jsmine) decodes an inline (data-URI) source map of any size (a bundler writes the whole map into that one directive, routinely tens of kilobytes, so it is read in place rather than copied into a buffer) and mines its original sources, and follows an external .map reference: the crawl fetches and mines the .map automatically, the GUI "Mine JS" action does too, and POST /api/jsmine / the MCP jsmine tool mine an inline map and return an external map URL as sourcemap to fetch and mine. Recovers the pre-minification endpoint surface a static crawl misses.

  • Passive checks: missing security headers, weak cookie flags, server banners, exposed secrets, permissive CORS, vulnerable front-end JavaScript libraries (retire.js-style: fingerprint a library name + version from the body or a 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; also POST /api/jslib / MCP jslib), a DOM-based XSS heuristic, a Client-Side Path Traversal (CSPT) heuristic (a client-side request sink - fetch, an XHR .open() (only on an XHR-ish receiver, so window.open/dialog.open/db.open are not sinks), axios, jQuery.ajax/get/post - whose URL is built in the same statement, before or after the sink, from a URL-derived source the attacker controls - location.pathname/search/ hash/href, document.URL, a router param such as useParams/router.query, URLSearchParams.get - where a ../ can retarget the request to a different API endpoint, CWE-22, escalating to CSPT-to-CSRF or CSPT-to-XSS; static + passive, runs on HTML/JS bodies in the scan and on live proxy traffic; also POST /api/cspt / MCP cspt), a CSPT runtime confirmation (drives a headless Chromium, injects a ../ marker into a client-side URL source - the location fragment/path or a query parameter - and watches Network.requestWillBeSent to verify the page's own fetch/XHR is retargeted at runtime, upgrading the static MEDIUM lead to a HIGH/FIRM finding and emitting a CSPT PoC page; POST /api/cspt-confirm / MCP cspt_confirm), a client-side prototype-pollution heuristic (a script that both reads a URL source - location.hash/search, document.URL, window.name - and uses a recursive merge / deep-set gadget - $.extend(true), deepmerge, lodash .merge/.set, object-path - CWE-1321, on HTML and .js bodies), and insecure-deserialization leads (serialized-object signatures - a Java serialized stream, a PHP serialized object, an ASP.NET __VIEWSTATE field, a Python pickle - in the response body and Set-Cookie values; the scan also scans captured request bodies and headers/cookies, and POST /api/deser / MCP deser scans a targeted value). To ACTIVELY confirm a deserialization lead responsibly, the deserialization marker generator (POST /api/deserchain / MCP deserchain, and the OAST view's "Deser marker" button) builds a BENIGN, OAST-confirmed payload: a self-contained Python pickle whose only effect on deserialization is a single out-of-band callback (an HTTP GET or a DNS lookup) to a Fissure OAST canary - never a shell, a command, or arbitrary code (the ysoserial URLDNS philosophy: prove the sink runs, do nothing harmful). The operator sends it to an authorized, in-scope sink via the scope-gated send/repeater/intruder path; a canary callback confirms the sink. Java/.NET/PHP gadget chains are delegated to ysoserial via the plugin host using its benign DNS gadgets. These run both during a scan and live on each captured in-scope proxy flow (a background passive audit), so passive-first browsing surfaces the native checks without starting a scan; findings deduplicate against a later scan.

  • The headless control API refuses to be published unauthenticated by accident. fissure serve binding a non-loopback address without --api-key is refused outright (the API can scan arbitrary targets, run plugin binaries, evaluate scripts and write files, so an exposed unauthenticated listener hands all of that to anyone who can reach the port); an explicit --insecure is required to do it anyway, and says so loudly. On a loopback bind with no key, one is generated and printed for the run, so omitting the flag yields an authenticated server rather than an open one.

  • Cross-origin requests to the control API are refused. Its clients are the CLI, the MCP bridge and the dashboard Fissure serves itself, so a page on another origin has no business calling it. Sec-Fetch-Site is honoured where the browser sends it (same-origin and none pass), with Origin as the fallback, matched against the Host the request arrived on; an opaque null origin is refused. A client that sends neither header is not a browser and passes, so the CLI and the bridge are unaffected. Fissure emits no Access-Control-Allow-Origin, so a browser already blocks reading the response; this stops a cross-site request from being acted on at all, which closes the drive-by path even when a token is absent.

  • The proxy CA is fetchable over the API: GET /api/ca returns the certificate PEM and its common name, and the MCP ca tool exposes it. A client must trust this certificate before the intercepting proxy or the HTTP/3 listener can read its HTTPS, and previously the only way to get it was the GUI Settings "Export CA" button, which left a headless agent unable to set up MITM at all. The export logic now lives in the non-GUI CA module (fissure_ca_export_cert), shared by the route and the GUI button, and it reports a refused open, a short write or a failed flush rather than swallowing them, since a truncated certificate installs cleanly and then validates nothing.

  • Relative redirects are resolved per RFC 3986, not concatenated. A path-relative Location such as login.php (legal, and what PHP applications commonly emit) is resolved against the base path's directory; a root-relative /x and a protocol-relative //host/x are handled too. Previously such a redirect was appended straight to the authority, which either produced an unparseable URL, so the redirect was silently not followed and the caller saw the bare 3xx, or a valid-looking but bogus host (example.comlogin.php), which triggered a DNS lookup for a name the target chose and then failed to connect. This affected every surface, since all of them share the request engine.

  • The cross-tool request log is available headlessly, not only in the GUI Logger. Every control-driven tool feeds one shared log: the scanner, one-off sends (POST /api/request), and the proxy, which bypasses the request engine and is mirrored in explicitly. Read it with GET /api/traffic (optional limit and tool filters) and reset it with POST /api/traffic/clear; MCP traffic / traffic_clear. It answers "what did that scan actually send?", which was previously unanswerable for an agent: the log carries per-request metadata (tool, method, url, host, status, length, time) across every tool, where proxy_history covers only proxy-captured flows but with full bodies.

  • Per-host connection routing works headlessly: GET/POST /api/hostroutes and the MCP hostroutes tool set the same DNS-rewrite and per-host-upstream rules the GUI Settings textarea does, applied to every control-driven scan and one-off send. pattern = address[:port] rewrites where a host connects while its Host header, TLS SNI, scope and captured URL stay the original name (so a staging box is reachable by its real hostname without touching /etc/hosts), and pattern via proxy-url routes a single host through a chosen proxy. Without this a target that resolves only inside a network you are not in, or that needs a jump proxy, could not be scanned headlessly at all. Replacing the rules does not disturb a running scan, which keeps the ruleset it captured at start.

  • Headless scans accept the transport configuration the GUI scan applies: POST /api/scans takes tls_client_cert / tls_client_key (PEM paths for mutual-TLS client-certificate auth, without which a client-cert-protected target only fails the TLS handshake) and proxy_url / no_proxy (route the scan's own traffic through an upstream proxy, for a target reachable only through a corporate or jump proxy). Exposed as MCP start_scan arguments.

  • TLS trust for a target with a custom certificate. Certificate verification is OFF by default, on Linux and on Windows alike. The hosts a web-security tool is aimed at are staging environments, self-signed labs, appliances and targets behind the operator's own interception proxy far more often than public sites with a clean chain, and a failed verification there produces no finding at all: it stops the request before it is sent, which reads as an unreachable target rather than as a trust problem. Turn it back on per run with the CLI's --verify-tls, the Settings "Verify TLS certificates on requests" toggle, or tls_verify on POST /api/scans and MCP start_scan (--insecure still exists and now restates the default, so an existing script keeps working). Every scan launcher (the Target view, the fissure scan CLI and the control API) resolves TLS trust the same way the single-request tools do: it detects the system CA bundle and honours that choice, rather than verifying against whatever the process happened to have. When you do want verification against a private certificate, a trusted CA file is the precise option, since it pins one certificate instead of accepting any: Settings -> "Trusted CA file", the CLI's --ca-file <pem>, and the ca_file field on POST /api/scans and MCP start_scan. The system bundle is located on Windows as well as Linux: after SSL_CERT_FILE, a bundle placed in the install's own resources/ca-bundle.crt (nothing ships one today, so that path is for an operator or a future packaging step to fill), then the MSYS2 OpenSSL roots. Without this a Windows install had no trust store at all and verified every https request against an empty one, so a Windows operator whose target is publicly trusted should still set SSL_CERT_FILE or a trusted CA file until packaging ships a bundle.

  • A scan that cannot reach its target stops and says why. A rejected certificate is reported with the actual verification reason ("self signed certificate", "certificate has expired") rather than a bare "TLS handshake failed", and is treated as permanent: it is not retried, because a certificate does not become valid on the second attempt. When a run abandons its target (a permanent transport failure, or FISSURE_SCAN_MAX_CONSEC_FAIL endpoints failing in a row) every loop stops at its next unit, a "Scan stopped" informational finding records it in the report, and the reason is shown to the operator: a popup in the GUI, a stderr block from the CLI, and stopped_early + stop_reason on GET /api/scans/{id} and MCP get_scan_status. An aborted run yields partial coverage, so it is never presented as a clean result.

  • The headless proxy applies the same transport configuration the GUI proxy does: POST /api/proxy/start accepts max_flows (in-memory capture cap, finite by default so a long agent session does not grow without bound), history_file (persist the captured flows across a restart), upstream_proxy plus no_proxy (chain the outbound leg), transparent (route origin-form requests by Host header), and oast_inject (seed forwarded in-scope requests with OAST canary headers, catching blind SSRF from ordinary browsing). GET /api/proxy/status reports max_flows and oast_inject so the applied configuration is visible rather than assumed.

  • The live passive audit runs on the headless proxy too, not only the GUI one. The control-driven proxy analyzes each captured flow on a background worker that walks new flows by index, so an agent that starts POST /api/proxy/start and browses gets the same findings a GUI operator would. Passive analysis inspects responses Fissure has already observed and generates no traffic of its own (fs.send throws in the passive stage), so it is safe to leave on anywhere.

  • Two independently opt-out passive stages, both ON by default: the native C suite, and the scripted stage (the resources/checks JS scripts, .bcheck files, imported nuclei templates, and enabled extension bundles), which is the more expensive half and the one that runs third-party code. They are opt-out rather than opt-in because an analysis that silently does not run turns a browse into a confident clean report. Configured with POST /api/proxy/passive and the MCP proxy_passive tool; the state is reported in GET /api/proxy/status (passive_native, passive_scripts, passive_audited, passive_pending, passive_findings) so "no findings" is always distinguishable from "the audit was off". Switching a stage off does not discard traffic: flows queue as passive_pending and are analyzed when it is switched back on.

  • The same two opt-outs in the GUI: Settings -> Proxy carries "Passive audit of proxied traffic: built-in checks" and "... scripted checks", persisted as passive_native / passive_scripts, and the GUI proxy honours them per flow. A "Re-run passive" button in the Proxy view toolbar re-analyzes the captured history and reloads the script corpus; it says so when there are no captured flows yet, and when both stages are switched off it says a re-run would analyze nothing instead of appearing to do work.

  • Re-run the passive audit over the captured history (POST /api/proxy/passive {"rerun":true}, MCP proxy_passive(rerun=True)): rewinds the cursor over every already-captured flow and reloads the script corpus. This is the action needed after enabling an extension mid-engagement, importing a nuclei template, or discovering the audit was off for part of a session, since history captured while a stage was disabled is otherwise never revisited. Findings deduplicate, so a re-run adds no duplicates.

  • Headless DOM security probe (DOM Invader-class client-side testing; the Target-view "DOM probe" button, POST /api/domprobe, MCP domprobe): loads the page in a headless Chromium driven over the Chrome DevTools Protocol (fissure_cdp), installs taint instrumentation before any page script, navigates with a marked URL (hash + a __proto__ payload), fires a marked postMessage, then reports which dangerous DOM sinks the marked value actually 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 security-relevant global name or a duplicate id/name HTMLCollection primitive, CWE-79, LOW: a clobbering surface an attacker can weaponize from a markup- injection or stored-content sink). This is dynamic, runtime-verified evidence, stronger than the static DOM-XSS body heuristic above. Scope-checked and active (it drives a real browser); it uses the bundled Fissure Browser when present, else a system Chromium/Chrome. Findings merge into the shared store. The GUI runs it off the UI thread with a busy status and a result popup; a missing browser is surfaced on screen.

  • Live DOM-Invader session (interactive mode): where the DOM probe above is a one-shot probe of a single URL, the "DOM Invader" popup (Capture toolbar category + command palette) launches the headful Fissure Browser and attaches over CDP, installing the taint instrument on EVERY navigation so it keeps analyzing each page the operator visits, surfacing DOM-XSS sinks, DOM-clobbering gadgets, message listeners, and prototype pollution live (a running count while you browse; findings land in the Findings view). An Aggressive toggle canaries each page's query/hash + a marked postMessage so location-driven DOM-XSS and prototype-pollution sinks fire. An In-page overlay toggle injects a small floating panel (isolated in a shadow root) into each browsed page showing the live sink hits, message listeners, and clobbering gadgets as you browse, so the detection is visible inside the target page itself; it is off by default (it adds UI to the target page) and the GUI panel is the safe default. A Follow new tabs toggle also discovers and instruments the other tabs and popups you open during the session (each on its own CDP connection), so DOM analysis follows a whole multi-tab flow (an OAuth popup, a target=_blank hand-off), not just the attached tab's navigations. Stop ends the session and leaves the browser open. Headless parity: POST /api/dominvader {url[,aggressive, cookie,max_ms,overlay,multi_target]} runs a bounded instrumented navigation session (the automatable form, echoing back whether the overlay rendered) and the dominvader MCP tool exposes it; the session engine (fissure_dominvader) is unit-tested (tests/test_dominvader). Built on the CDP client (fissure_cdp, with a browser-attach mode) and the headful debug launch (fissure_browser).

  • HTTP/3 fetch (native HTTP/3 over QUIC): a mini Repeater for HTTP/3. The "HTTP/3 fetch" popup (Capture toolbar category + command palette) sends one request (method, URL, optional extra headers and body) to an https URL over HTTP/3 (ALPN h3) on a worker thread and shows the status, response headers, and body. Built on the Nilorea n_http3 transport (ngtcp2 for QUIC, nghttp3 for HTTP/3 framing + QPACK, OpenSSL for the TLS 1.3 handshake). 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, a WAF or cache that only inspects the older protocols). Headless parity: POST /api/http3 {url[,method,headers,body,timeout_ms]} runs the same fetch and the http3 MCP tool exposes it; the wrapper (fissure_http3) is unit-tested (tests/test_http3). HTTP/3 support is optional and auto-detected at build time (HAVE_HTTP3): when the ngtcp2/nghttp3 stack is absent the feature reports it is unavailable (the control API returns 501) and the rest of Fissure builds unchanged.

  • Re-send a captured request over HTTP/3: a "Send over HTTP/3" entry on the request context menu (Proxy, Logger, Findings, Repeater) opens the HTTP/3 fetch tool pre-filled with the selected request, so an existing request is replayed over h3 without re-typing. Headless parity: POST /api/request {..., "http3": true} re-sends the request over HTTP/3 (the response carries "protocol": "h3") and the send_request(..., http3=True) MCP tool exposes it.

  • HTTP-version differential (an HTTP/3-specific attack): the "Diff h1/h2/h3" button in the HTTP/3 fetch tool sends the same request over HTTP/1.1, HTTP/2 and HTTP/3 and reports cross-version response differences (CWE-436). A status-code mismatch between h3 and an older version indicates a WAF, cache, load balancer, or reverse proxy that inspects the older protocols but forwards h3 differently (a control bypass or a different back-end). On a difference it records a LOW finding. Headless parity: POST /api/http3-diff {url[,method,headers,body,timeout_ms]} and the http3_diff MCP tool; the comparator is unit-tested (tests/test_http3).

  • HTTP/3 downgrade request smuggling (an HTTP/3-specific desync check): probes an https URL by sending a clean HTTP/3 request and the same request carrying a transfer-encoding: chunked header, which RFC 9114 forbids in HTTP/3 (placed on the wire via the Nilorea n_http3_request_ex allow-illegal-headers mode). A compliant endpoint rejects the illegal-framing request (RST / a 4xx); 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 and the h3 analogue of the H2.TE smuggle. A candidate records a MEDIUM finding (CWE-444). Exposed as POST /api/http3-smuggle and the http3_smuggle MCP tool; the verdict classifier is unit-tested (tests/test_http3) and the live path validated against a compliant h3 endpoint (which correctly rejects it). Needs the ngtcp2/nghttp3 stack (HAVE_HTTP3).

  • HTTP/3 MITM interception (the h3 proxy): where the classic intercepting proxy handles HTTP/1.1 and HTTP/2, the "HTTP/3 proxy" popup (Capture toolbar category + command palette) starts a QUIC listener that terminates inbound HTTP/3 with a per-SNI leaf minted by the local Fissure CA, forwards each request upstream through the engine and captures it (so the report includes the h3 exchange), and relays the response over HTTP/3, making h3 traffic captured and interceptable like the older protocols. Install the Fissure CA in the client's trust store, then point an h3 client (a transparent UDP redirect for a browser, or curl --http3 --connect-to host:443:127.0.0.1:port for a manual test) at the listener. An "Upstream over HTTP/3" toggle (the upstream param) forwards each request to the origin over HTTP/3 too (end-to-end h3; needs an h3-capable origin); the default forwards upstream over the engine's HTTP/1.1 / HTTP/2. Scope-checked (an out-of-scope host is blocked with 403). Concurrent: one bound UDP socket serves every client, with a listen thread routing each inbound datagram to its connection by the packet's destination connection id and that connection's own thread taking it from there, so many h3 clients are handled at once. Request-pause interception: when intercept is on, each h3 request is held (as an editable raw HTTP/1.1 request) in the SAME /api/proxy/intercept queue and UI as the HTTP/1.1 / HTTP/2 proxy, so it can be inspected, edited, or dropped before it is forwarded (a dropped request returns 403 to the client, an edited one is re-parsed and sent). Headless parity: POST /api/h3proxy {action[,port,upstream]} and the h3proxy MCP tool control it; the listener (fissure_h3proxy, built on the ngtcp2/nghttp3 server side) is covered by tests/test_h3proxy, which drives its lifecycle and then runs three real QUIC clients through it at once on the loopback interface, each asserting it got its own response back. Needs a build with the ngtcp2/nghttp3 stack (HAVE_HTTP3), else it reports unavailable with that reason (shown in the popup, in the /api/h3proxy 501 body and in the log). No platform is excluded: the single-socket, connection-id-demultiplexed design is the portable QUIC-server shape and needs no UDP port sharing, so the listener runs on Windows as well as on POSIX.

  • Active checks (behind the safe/aggressive toggle): reflected XSS, stored / second-order XSS (write a unique executable canary through a form field or JSON leaf, then re-read the render page and flag it when the canary comes back unencoded in that separate response - CWE-79; also a "Stored XSS" context-menu action + POST /api/storedxss / MCP storedxss), SQL injection (error-, boolean-, and time-based; the error-based oracle recognises both the classic PHP-style DB-error text (MySQL/PostgreSQL/MSSQL/Oracle/SQLite) and typed Java/JDBC exceptions (Hibernate, HSQLDB, H2, and the JDBC drivers, e.g. java.sql.SQLSyntaxError- Exception / org.hsqldb), so a Java application's SQL injection is not missed, and confirms the DB-error signature with a balanced two-quote control that must NOT error, so a generic/validation/concurrency DB error that fires regardless of quote parity is not reported, AND re-sends the single-quote probe and requires the same DB-error to REPRODUCE before reporting, so a transient one-off DB error (a brief lock or per-request state glitch) that the balanced control happened to miss is not reported either; the boolean oracle requires the TRUE/FALSE split to reproduce in an INDEPENDENT second observation so a stateful endpoint that flips state once by itself, e.g. a registration that answers "registered" once then "already exists", is not scored as an injectable query; the time-based oracle requires the delay to track the requested sleep across a long and a shorter probe so ambient load or a concurrent scan cannot forge a hit, and then re-confirms the hit with INDEPENDENT re-measurement - repeated until two clean re-measures track, taken with the host held exclusively when it can be drained - so a non-injectable field whose probe merely blocked behind another field's real injected sleep over a shared session lock is dropped unless the delay repeats across rounds (a genuine injection re-confirms every time; an inconclusive re-measure under load keeps the first-pass hit rather than lose a real slow-base injection like ping $ip), a per-host governor caps concurrent sleep-injecting probes (default 6; lower it toward 1 = fully serialized on a small/fragile target) plus a watchdog that drops a saturating host so an aggressive scan does not wedge - operator knob "Timing probes/host" / --time-probe-concurrency / time_host_concurrency, and an adaptive probe timeout that measures a slow base-command latency so a sink like ping $ip whose base command runs for seconds is still detected), LFI / path traversal (relative traversal, an absolute path, and file:// / php://filter stream wrappers, the base64 wrapper matched after decoding; plus a path-reflection oracle that flags a file-path sink which does not return the file content but reflects the server-constructed path it would open - a server base directory directly followed by the injected ../ sequence, with the slashes raw or HTML/URL-encoded - so a plain echo of the input, which carries no server-prepended base, is not a false positive), XPath injection (a single quote breaks the server-side XPath query - an XPath parser error or a 5xx - while a repairing boolean (' or '1'='1) restores it and a benign value is clean, a break-then-repair oracle that bows out when the error is actually SQL so it never double-reports with SQLi; CWE-643), command injection (time-based blind and in-band id proof), server-side template injection (an arithmetic polyglot across ten engine delimiter styles, confirmed by a second operand pair), CRLF / HTTP header injection, in-band SSRF to the cloud instance-metadata service (AWS IMDSv1 including a decimal-IP blocklist bypass, AWS IAM credentials, GCP, and Azure, each confirmed by that service's distinctive metadata in the response) plus out-of-band blind SSRF including gopher:// and dict:// alternate-scheme canaries (DNS-confirmed via the OAST listener, reaching internal Redis/memcached services an http canary cannot) and a DNS-rebinding canary (the OAST DNS answers a benign IP first and 169.254.169.254 on re-resolution, flagging a resolve-then-connect TOCTOU that an allowlist alone cannot stop; also a "Test SSRF" context-menu action + POST /api/ssrf / MCP ssrf for an on-demand probe), active CORS (send attacker/null/look-alike/subdomain Origins once per endpoint and flag a reflected Access-Control-Allow-Origin, high when combined with credentials), active CSRF (for a urlencoded form body, replay it with the anti-CSRF token tampered three ways - an invalid same-length value, an empty value, and the field removed - and flag it when the state change still succeeds; for a JSON body, resend the same body as text/plain and flag it when the endpoint accepts it, since a cross-site enctype=text/plain form can then forge the JSON request with no CORS preflight, JSON CSRF; plus three depth probes: a method-override bypass, where a PUT/PATCH/DELETE endpoint that rejects a plain cross-site POST still honours a _method / X-HTTP-Method-Override / X-Method-Override override on a POST, so a form forges the CSRF-safe verb; a SameSite-Lax bypass, where a no-token state change also succeeds as a top-level GET while a Set-Cookie does not pin the session cookie to SameSite=Strict; and a cross-identity token-reuse differential (on-demand, needs two sessions), where one user's anti-CSRF token is accepted under another user's session while a garbage token is rejected, meaning the token is not session-bound; the whole active check is exposed on demand at POST /api/csrf-active / MCP csrf_active), active XXE (on an XML-accepting endpoint, submit external-entity payloads: an in-band file-read entity confirmed by a file-content signature in the response; an out-of-band external parameter/general entity pointing at a minted OAST canary confirmed by a callback; and an out-of-band nested-parameter-entity probe whose internal subset only loads an attacker external DTD (%remote) that the OAST listener serves with the nested %eval/%exfil entities, so it defeats a parser that blocks parameter entities in the internal subset yet still processes an external DTD, and exfiltrates the read file's contents out-of-band (reported with the leaked bytes in evidence); all reuse the observed root element; also a "Test XXE" context-menu action + POST /api/xxe / MCP xxe for an on-demand probe), object-ID enumeration (IDOR/BOLA: vary an id-like path segment or numeric query param to neighbor ids under the session and flag when a neighbor returns another subject's object, with a bogus-id control to confirm the endpoint is object-scoped; GET-only, also a "Test for IDOR" context-menu action + POST /api/idor / MCP idor), reverse-proxy / auth-header authentication bypass (on an endpoint that denies an anonymous request, forge each trusted identity/forwarding header a misconfigured reverse-proxy setup honors - 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, with an untrusted control header first to rule out an endpoint that reacts to any header; CWE-290, critical for an identity impersonation, high for a trusted-address/malformed-token bypass; GET-only and unauthenticated - enforced, not assumed: baseline, control and probes all go through a credential-free config (no session cookie jar, no session rules or re-auth hook, and Cookie / Authorization / Proxy-Authorization stripped from extra headers), so an authenticated scan still sees the anonymous deny instead of being served the baseline and abandoning the endpoint. The same holds for the URL-level access-control bypass below. Also a "Test auth bypass" context-menu action + POST /api/authbypass / MCP authbypass), URL-level access-control bypass (401/403 bypass: distinct from the auth-header bypass - this forges WHICH url the back-end authorizes, not who you are. On an endpoint that denies an anonymous request, try URL-override headers - X-Original-URL / X-Rewrite-URL / X-Override-URL / X-Original-URI sent to the origin root naming the denied path, CWE-284 - and path-normalization variants of the denied path - a trailing slash, //, /., %2f, a trailing %20/%09, a ..;/ path-parameter segment, CWE-288 - and flag any that flip the deny to a served 2xx, with an untrusted control header first; offensive access-control testing, not detection-evasion; the aclbypass family, also POST /api/aclbypass / MCP aclbypass), Reflected File Download (RFD: an endpoint that reflects a caller-controlled value into a downloadable non-HTML response with no Content-Disposition filename and accepts an arbitrary trailing ;/name.bat path segment lets a link on the trusted origin download an attacker-controlled batch/command file named from the URL, CWE-79 / OWASP RFD; confirmed by a reflected command-shaped marker + the served .bat path + the missing disposition; the rfd family, also POST /api/rfd / MCP rfd), web cache poisoning (inject a random host marker via an unkeyed header - X-Forwarded-Host and friends - on a cache-busted URL, then re-fetch without the header; if the marker is still served, the unkeyed input was cached and reaches every visitor) and cache deception (a static-suffix path that returns the same page in a response a shared cache may store: an explicit public, a positive max-age/s-maxage, or no Cache-Control at all, and never no-store / private / no-cache / max-age=0. The finding is host-scoped, since static-suffix path confusion is a property of the front end rather than of one page; also a "Test cache poisoning" context-menu action + POST /api/cache / MCP cache), subdomain takeover (fingerprint each in-scope inventory host - the subdomains recon seeds - against a set of cloud/SaaS "unclaimed resource" pages: GitHub Pages, S3, Heroku, Fastly, Shopify, ...; on a match the host's CNAME chain is resolved (following intermediate hops) and checked against the provider's DNS suffix, confirming a dangling record - certain, with the CNAME in the evidence - or left firm to verify; also a "Subdomain takeover" context-menu action + POST /api/takeover / MCP takeover), server-side prototype pollution (a JSON body carrying a proto then a constructor.prototype gadget on body endpoints, or the query-string vector ?proto[k]=v / ?constructor[prototype][k]=v that qs-style parsers expand on GET endpoints, injecting a unique property into Object.prototype then a payload-free probe; if the property comes back the server merges untrusted keys into the prototype - CWE-1321; also a "Prototype pollution" context-menu action

    • POST /api/protopollution / MCP protopollution with method GET/POST), mass assignment (add a privileged field - role/is_admin/ account_type - to a JSON/form body carrying a nonce and flag it when the nonce is bound back while a random control field is not, so an autobinding endpoint that accepts privilege-related attributes is caught without a false positive on echo endpoints - CWE-915) and HTTP parameter pollution (duplicate a reflected query parameter and flag last-wins/concat handling that can bypass a first-occurrence control - CWE-235; also a "Mass assignment / HPP" context-menu action + POST /api/massassign / MCP massassign), business-logic numeric/price tampering (set a price/quantity/amount-like numeric field - a JSON leaf or query param whose name matches amount/price/qty/total/cost/balance/... - to a negative value and flag it when the state change still succeeds, since a negative price/quantity can invert a charge, refund, or balance; field-name targeting keeps it low-FP; CWE-840, an assist, pair with the race check; the bizlogic family, also POST /api/bizlogic / MCP bizlogic), business-logic workflow / step-order bypass (replay a recorded multi-step flow in order through a fresh cookie jar so the final protected step succeeds with all its prerequisites, then replay ONLY the final step in a second fresh jar seeded with the same auth cookie, and flag 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; CWE-840, on-demand POST /api/workflow-bypass / MCP workflow_bypass), NoSQL injection (on a JSON body endpoint for a Mongo/Couch-class document store, replace each field value with a match-all operator {"$ne":} and a match-none operator {"$eq":}; a response differential means the value is evaluated as a query operator, so an attacker can bypass authentication or extract data - a literal-only endpoint yields no differential and is not flagged, and the differential arm runs only on a page that repeats itself: the baseline is sent twice and both bodies are linearized before comparison, so a reply carrying a request id or a timestamp is not read as two different pages - plus an error-based {"$regex":"("} probe that flags a document-store driver error, CWE-943; the nosqli scan family, also POST /api/nosqli / MCP nosqli), file-upload restriction bypass (submit malicious upload variants - executable/double/alternate/mixed-case extension, content-type spoof, magic-byte GIF+PHP polyglot, null-byte truncation, path-traversal filename, and SVG/HTML stored-XSS, each part carrying the common submit-trigger fields so the handler actually processes it - to a multipart upload endpoint, flag a dangerous variant the server accepts (a 2xx) without an obvious rejection, and confirm the file when it is stored and served back from a likely location, CWE-434. Every variant carries its OWN marker (the run marker plus a per-technique suffix) in both its filename and its body, so two techniques can never share a stored file and one technique's upload can no longer confirm another's; the confirmation fetch looks for that variant's marker. The benign image is uploaded FIRST as a control and its answer is kept as the baseline: a dangerous variant answered exactly as the benign image was (same status, same body once the marker is stripped) has demonstrated no bypass and is only reported when its file is genuinely fetched back. The served locations probed include, for a ../ filename, each candidate directory's ancestors, one level per leading ../, which is where a successful traversal actually lands the file; the endpoint's query string is cut off before its directory is derived and the list is deduplicated. A session cookie or header block authenticates the probe against an auth-gated endpoint; right-click a request and pick "Test file upload" (reuses that request's session), POST /api/upload / MCP upload, all sharing one probe), and more, across a unified set of insertion points (query, path segments, body, multipart, JSON, headers/cookies, GraphQL arguments). Every insertion point runs the SAME probe list (the only surface-specific omission is open redirect, a query-link phenomenon), so a sink reached through a JSON leaf, a form or multipart field, a header or a cookie yields the same findings it yields through a query parameter. The SSTI, in-band command-injection, and CRLF checks and the expanded sensitive-file list are harvested from the ProjectDiscovery nuclei-templates matchers (MIT).
  • Sensitive-file probes: a curated list of 47 well-known paths probed once per host and confirmed by a body content signature. Covers VCS metadata (.git, .svn, .hg), credential and cloud config (.htpasswd, .netrc, .npmrc, .pgpass, .s3cfg, .aws credentials/config, SSH keys, Docker/registry auth, GCP service-account keys, Rails database.yml/secrets.yml), logs and management endpoints (Laravel log, Symfony profiler, Spring Boot actuator/env and heapdump, Go pprof, Prometheus metrics, Apache server-status/server-info), source maps and API docs, shell history, and text-served source/database backups. WordPress, the most deployed CMS, has its own block in the same list: wp-config.php.bak and wp-config.php~ (the database credentials and auth salts served as text, critical), a reachable wp-admin/install.php setup form (anyone who gets there first installs the site against their own database, critical - the already-installed page carries no form fields, so it is not flagged), wp-content/debug.log (PHP errors with absolute paths and plugin internals), xmlrpc.php (password-guessing amplification via system.multicall, and pingback fetches), wp-json/wp/v2/users (unauthenticated user enumeration) and readme.html (pins the exact WordPress version). Every one is signature-confirmed, so a host that is not WordPress 404s straight through the block. The content-discovery wordlist (resources/wordlists/paths.txt) carries the matching path set, so the Discover tool finds the same tree.

  • Directory-listing (auto-index) probe: a server with automatic directory indexing left on serves a generated file list for any directory that has no index page, and that list maps everything stored there including files nothing links to: uploads, backups, editor and swap files, database dumps, archives, logs. The probe requests every ancestor directory of the seed URL, the directories the crawl actually observed, and a 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), and reports a directory 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 phrase is anchored to the title or heading that emits it, so an article headlined "How to turn off Index of / pages" or a search page echoing the words is not reported. Severity is MEDIUM when the directory name is one that holds uploads, backups, logs, configuration or version-control data and LOW otherwise; the evidence names the server flavor and the first listed entries, and the confirming exchange is archived with the finding. The entry list is read relative to the directory probed, because IIS directory browsing writes every listed file as an ABSOLUTE path (/uploads/dump.bak inside the listing of /uploads/): an absolute link counts as an entry when it names something strictly below that directory, while the parent link, a link to another branch and the column-sort links stay navigation, so an IIS finding names the exposed files instead of reading "listing 0 entries". Capped at 128 directories per call (the well-known set is queued before the caller's list so a long crawl cannot crowd it out, and anything dropped past the cap is logged), redirects not followed. Runs per host in an active scan under the files check family, on demand from the Probes popup ("Directory listing", with an optional extra-directories field), and headless as POST /api/dirlist / MCP dirlist (or as an async job, name dirlist). The module fissure_dirlist is unit-tested (tests/test_dirlist).

  • Spring Boot Actuator exposure probe (fissure_checks_actuator): a dedicated host-level check that requests the common management endpoints and flags each one reachable unauthenticated, confirmed by a signature on the JSON body (not the status alone): /actuator/env (configuration and secrets, HIGH), /actuator/threaddump, /actuator/beans, /actuator/configprops, /actuator/mappings (threads, the bean graph, resolved properties, the full URL map, MEDIUM), the /actuator index (the _links map of what is open, MEDIUM) and /actuator/health (LOW); /actuator/heapdump is covered CRITICAL by the sensitive-file probe above. It runs once per host during an active scan (the FILES family) and standalone over POST /api/jobs name actuator / MCP run_check(name="actuator"). Unit-tested in tests/test_checks_active.

  • Log poisoning through a file-inclusion point (the LFI-to-RCE chain, CWE-98). A file-inclusion bug that only reads files is a medium finding; 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 placed in the User-Agent lands verbatim in a file on disk, and an inclusion point aimed at that log includes attacker-authored content. The probe runs in two stages. Stage 1 plants a self-identifying marker in the User-Agent of one ordinary request, then points the inclusion parameter 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 process environment rather than a file. A /proc/self/ candidate exposes the process serving the CURRENT request, so for those 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 User-Agent back. Each candidate is tried both as an absolute path and behind a traversal prefix, because an include that prepends a directory of its own cannot take an absolute path. The marker coming back is proof the application includes an attacker-writable file, reported HIGH. Stage 2, gated behind the aggressive toggle AND a running OAST listener, re-plants a marker whose entire effect is one out-of-band callback and includes the log again; a canary hit proves the log's contents are executed and is reported CRITICAL, with out-of-band evidence instead of an inference. It is benign by construction, the same confirm-do-not-exploit line the deserialization marker draws: no shell, no command, nothing written outside that log line. The probe APPENDS to the target's log and never edits, truncates or removes anything, and the marker names Fissure and carries the probe token so the owner can find precisely what the test left and clear it; the marker is returned by every surface for exactly that reason. Reached from the Probes popup ("Log poisoning", with an inclusion-parameter field and an aggressive checkbox), and headless as POST /api/logpoison / MCP logpoison. The module fissure_logpoison is unit-tested (tests/test_logpoison), including that the execution stage stays off without the aggressive toggle, that the /proc/self/environ candidate really can hit, and that a User-Agent-echoing application is not reported.

  • HTTP request smuggling (desync) probe: a safe timing-based check that sends length-ambiguous requests over a raw-bytes transport path and flags a desync when one hangs the server while an unambiguous request returns promptly - the TE.CL, CL.TE, and CL.CL (duplicate/conflicting Content-Length) variants (CWE-444). A timing hit is then confirmed with the differential-response method (a smuggled request-line prefix poisoning a following request on one keep-alive connection): a confirmed desync is a firm finding, an unconfirmed one a tentative candidate. The probed target keeps its query string ("/app?id=1" and "/app" are different resources, and a chain routes, caches and body-parses them differently), and the pipelined response stream is split by walking each response's declared body length, so a body that quotes a status line (an API reference page, a gateway error page reprinting the upstream answer) is not counted as another response. On an endpoint that speaks HTTP/2 three HTTP/2 downgrade variants are also probed: over TLS that is ALPN, and on cleartext only where the origin has just answered 101 Switching Protocols to an h2c Upgrade (the probe speaks h2 with prior knowledge there, so without that gate a plain HTTP/1.1 origin would be probed with frames it cannot parse). The variants are H2.TE (an HTTP/2 request carrying a Transfer-Encoding header, forbidden in HTTP/2, that hangs a front-end which downgrades to an ambiguous HTTP/1.1 request); H2.CRLF (the Transfer-Encoding hidden inside a benign header's value behind a CRLF - HPACK carries the CRLF verbatim - which catches a stricter front-end that strips illegal HTTP/2 headers but does not sanitize CRLF when it downgrades); and H2.SPLIT (a whole second request line CRLF-injected into a header value, so a front-end that writes the value verbatim on downgrade splices a full smuggled request into the HTTP/1.1 back-end stream - request splitting, the primitive behind HTTP/2 response-queue poisoning, a strict superset of the H2.CRLF header-only smuggle). The probe also checks H2C: an origin that answers a cleartext HTTP/2 (h2c) Upgrade over HTTP/1.1 with 101 Switching Protocols, the precondition for tunnelling HTTP/2 requests past an HTTP/1.1 front-end (h2c smuggling), and the gate that lets the downgrade family run on a cleartext endpoint. Runs once per host in an aggressive scan (scope-gated) and is exposed as a targeted test via POST /api/smuggle and the MCP tool smuggle (verdict none/tecl/clte/clcl/h2te/h2crlf/h2split/h2c).

  • Automated race-condition (limit-overrun) probe: an on-demand check that runs three phases against one state-changing request. First a SEQUENTIAL baseline of a few requests, one at a time, to learn how often the action is accepted when the requests cannot overlap; then N identical requests fired concurrently over the single-packet / HTTP-1 last-byte-synchronized primitive (fissure_groupsend, the classic race primitive); then a settle request. A limit overrun is flagged only when the concurrent burst was accepted at least twice AND more often than the sequential baseline was, while the settle request is then rejected (a check-then-act / TOCTOU window: double-spend, coupon / gift-card reuse, one-time-token or one-per-account reuse, CWE-362). The comparison is what makes the verdict mean anything: an endpoint that atomically allows N > 1 answers the same N whether the requests are serialized or concurrent, and is reported as clean. Responses are classified on their BODY alone, so a per-response header (Date, Set-Cookie, a request id) does not split identical grants into different outcomes. It self-skips when the sequential baseline gets no response, when fewer than two concurrent requests succeed, when the concurrent count does not exceed the sequential one, or when the settle also succeeds (the action is simply repeatable, not limited). The baseline spends part of the allowance it measures, so an action limited to a SINGLE use is consumed by the baseline and reports nothing rather than a guess; the probe is meaningful where the allowance is larger than the baseline (a quota, a rate limit, a multi-use token). Scope-gated and aggressive (it submits the request many times: baseline + burst + settle); exposed as POST /api/race and the MCP tool race (a Race-probe request context action drives the same engine, fissure_race).

  • GraphQL tooling: native introspection detection and, when a plain __schema query is refused, introspection-filter bypass probing (a newline before the selection set that defeats a naive string filter, and the same query over GET when only POST is blocked; CWE-200, MEDIUM); per-argument and variables fuzzing; GraphQL CSRF detection (a benign {__typename} executed over a cross-site-forgeable transport, a GET query or a form-encoded POST, means a mutation sent the same way is a CSRF; CWE-352, MEDIUM); array-batching DoS detection; alias-based rate-limit bypass (a single operation that aliases one field several times and executes every alias in one request, defeating per-request brute-force protections; CWE-799, MEDIUM); missing query-depth / complexity limits and circular-fragment acceptance (a deeply nested query that executes with no depth error, or a self-referential fragment that is not rejected, is a denial-of-service lever; CWE-770/674, MEDIUM. A depth/complexity/cost marker only counts as a guard when it appears inside an entry of the response's errors array, so a schema that merely has a field named cost does not pass for one); field-suggestion schema disclosure (a misspelled field that returns a "did you mean" suggestion leaks real field names even when introspection is off; CWE-200, LOW); plus graphw00f/clairvoyance plugins and a QuickJS introspection check. Also an interactive GraphQL argument workshop (a "GraphQL" popup in the Test & attack toolbar category and the command palette): paste a query, List arguments to enumerate its injectable inline literal arguments (index: field.arg), and Mutate one at a chosen index with a probe value to get a rewritten, ready-to-send query, the manual form of the same fissure_graphql argument tooling exposed over POST /api/graphql and the MCP graphql tool. Only live arguments are enumerated: a # comment and an operation's variable-DEFINITION list (query Foo($id: ID! = "x")) are skipped rather than fuzzed, and a rewrite preserves the argument's literal kind, so a numeric argument given a numeric probe stays unquoted and the query still passes GraphQL validation on an Int argument (quoting it made the server reject the document, so no probe on that insertion point ever reached the resolver).

  • OAuth / OIDC flow analysis: a shipped passive scripted check (resources/checks/oauth-flow.js) recognizes an authorization request from the URL and flags a missing state (CSRF), a missing OIDC nonce, the implicit flow (token in the URL), a code flow without PKCE, and a cleartext redirect_uri; runs on live proxy traffic and in a scan.

  • Scan pause/resume, with an animated progress indicator and a Stop control.

  • Responsive scan cancellation: Stop (and quitting the app during a scan) aborts in-flight crawl and audit requests immediately rather than waiting out each request's timeout, even against an unresponsive or lagging host. Two mechanisms combine: (1) a per-run cancel flag threaded into the request engine, checked before every connection attempt and between redirect hops, so once Stop is pressed no queued check request opens a new connection (each returns at once instead of eating a connect/read timeout, the pile-up that otherwise made a scan against a dead host feel unstoppable); (2) a broadcast socket shutdown that breaks the requests already blocked on a read across the audit thread pool; and (3) an interruptible TCP connect (the n_network connect-abort callback) so a Stop pressed while a request is blocked in connect() to an unresponsive host aborts within a poll interval instead of waiting out the connect timeout - the case that dominates a stop during the single-threaded crawl phase. The same engine gate covers the smuggling probes, which deliberately wait out hangs. This applies both to the GUI Stop control and to the loopback control-API / MCP scan-cancel route (POST /api/scans/{id}/cancel), so an agent-driven scan stops as fast as a GUI one. Quitting signals the running scan to cancel as soon as the confirmation is accepted, so teardown does not block. A Stop reaches a scan waiting on its audit thread pool too: the pool wait polls rather than blocking on a semaphore, which on Windows could strand the scan thread after its work had already finished, leaving a scan that neither completed nor stopped. The broadcast in (2) reaches a request by the IDENTITY of the transport config it was issued through, and several phases run on a shallow COPY of the run's config (the scan's per-run audit config, the origin-IP per-candidate route, a per-probe header tweak). A copy lives at a different address, so it used to land in a cancel group nobody broadcast on: Stop could not break the crawl or any active check, and those requests ran to their timeouts, which read as an unstoppable scan. FISSURE_CONFIG.cancel_group now carries the run's identity through every copy (fissure_config_derive), and the engine keys on the resolved group (fissure_config_cancel_group), so a Stop reaches every phase. Any new code that copies a config must derive it rather than assign it.

  • Audit-coverage reporting: the scan tracks how many audited endpoints had a fuzzable insertion point; an active scan that discovered endpoints but covered none records an informational "Scan coverage" finding (so an empty active result is not mistaken for a clean target), and the control-API scan status exposes covered and a low_coverage flag. Forms are audited at any crawl depth and an authenticated scan carries its login session through the active-audit phase.

  • Dropped-request accounting: every scan counts what the target did with its requests (sent, answered, and got no response at all, split into timed out / refused / connected-but-empty / certificate-rejected / unclassified, with operator cancellations counted apart). A request that gets no response cannot produce a finding, so the checks it carried report exactly what a clean endpoint reports and a lossy run reads as a quiet one. The counts appear in the CLI's end-of-scan line, live in the Target view status line plus an end-of-scan popup, in the control-API scan status (sends), and, when a non-trivial share was lost, as an informational "Scan coverage" finding naming the numbers and the remedy (re-run with fewer threads, a per-host rate cap or a delay).

  • Per-request failure reason in the Logger: a send that got no response is logged with status 0 and a stored response of HTTP/1.1 0, which cannot say why. The engine's classification travels with the record instead, so the Logger has an Error column (timeout / refused / no-reply / certificate / cancelled / failed) and the control API's traffic and traffic/detail carry error_kind and the engine's own message.

  • Parallel audit on every surface: fissure scan --threads <n> now drives the same threaded runner the GUI and control API use (0 = one worker per CPU core), and Ctrl+C stops a run gracefully, still writing the report for what it audited. Previously the CLI audited one endpoint at a time and the flag did nothing there.

  • Adaptive per-host concurrency (--host-backoff, scan option "Host backoff", API host_backoff): the run reacts to what it counted. Several dropped sends in a row to a host halve how many requests it will keep in flight to that host (floor of one); runs of answered sends give the slots back one at a time and then lift the cap. A healthy target is never capped. Off (-1) keeps the old flat-out behaviour; a positive value sets the floor. The current per-host allowances, with their drop and backoff counts, are on GET /api/respools (host_backoff) and in the Resource pools popup.

  • Session-safe crawl/audit: logout-like URLs are never fetched or audited, so an authenticated scan does not log itself out and downgrade every later request to unauthenticated (which would silently hide the injection findings behind the login). Recognized three ways: a logout verb in the path (logout/logoff/signout), a param whose key is a logout verb (?logout), or a command-dispatch key whose value is a logout verb (?do=logout); an ordinary redirect-target param such as ?next=/logout does not trip it.

  • Configuration-safe crawl/audit: the parts of the target that change the TARGET'S OWN configuration are left alone by default, in two places. Its settings forms are not fuzzed (a form whose action is the settings surface, or that carries a security/seclev/debug/safe_mode/difficulty/phpids field), and its switch links are recorded but never requested, by the crawl or by the audit (a link whose query carries a setting name with a value, such as DVWA's <a href="?phpids=on">, a command-dispatch value that is a state-change verb, such as Mutillidae's ?do=toggle-security / ?action=clear_log, or a bare valueless toggle flag such as ?enforce-ssl; a content link whose value is only a page noun, such as ?page=ssl-misconfiguration.php, stays crawlable; the crawl records a refused link so the surface is visible, and the audit refuses to fetch it out of the inventory). Exercising either one retunes the application in the middle of the scan, so every check that runs afterwards tests a differently-configured target and a vulnerability that was real at the start is simply gone when the scanner reaches it, reported as clean with nothing to say why. Measured on DVWA: following that single 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, and --fuzz-settings-forms (CLI) / fuzz_settings_forms (POST /api/scans, MCP start_scan) opts back in for a target that can be reset.

  • Mid-scan re-authentication: if the session expires part-way through a long authenticated scan, the engine re-establishes it and retries the request once instead of silently downgrading the rest of the run to unauthenticated. Two triggers: a re-auth-on-401 session rule (enabled automatically for an authenticated scan) and, for the common redirect-to-login logout (a 200 login page, which a status rule misses), the login config's optional reauth_on_contains substring, a marker unique to the logged-out/login page. The shared handler (fissure_reauth) replays the login into the same jar under a lock so concurrent workers do not re-auth at once. Wired identically for the GUI sitemap scan, the CLI (fissure scan --login), and the control-API / MCP scan job (the login object, including its reauth_on_contains, rides in the request).

  • Safe / aggressive active-check toggle; scope + rate limits enforced.

  • Crawl budget: an operator knob, and an account of what it cost. The crawl page cap is edited in the Target view's Scan options popup ("Crawl pages", blank or 0 = unlimited, persisted as scan_max_pages), alongside the crawl depth, and it is the same knob the CLI exposes as --max-pages and the API/MCP as max_pages. It used to be a fixed 200 in the GUI with no way to change it, which mattered because of how invisibly a spent budget ends a crawl: every URL the crawl finds is recorded as an endpoint whether or not it is ever fetched, so the endpoint count keeps climbing from discovery while the fetching has already stopped, and a run on a large site looks complete when it has seen its first few hundred pages. A scan now reports the gap rather than leaving it to be inferred - a "Scan coverage" finding naming the budget that ran out, how many in-scope URLs were still queued and never crawled (each is still fetched once for its baseline; what was skipped is expanding them, so anything reachable only through them was never discovered), and how many pages sat at the depth limit with their own links unfollowed - and the same figures ride on the scan status as crawl.pages / crawl.page_cap / crawl.left / crawl.depth_capped / crawl.capped (GET /api/scans/{id}, MCP get_scan_status), so an agent can tell a bounded run from a complete one. The browser dashboard says it too: a capped run finishes as "done - PARTIAL" naming the budget and what was left, rather than as a plain "done".

  • Named scan-configuration profiles: a saved library of scan settings (crawl depth, page cap, request delay, active/aggressive mode, thread cap, rate caps, check-family/insertion-point masks, extra headers, exclude list) with built-in presets: the four intensity presets (Passive, Quick, Balanced, Deep) plus dedicated profiles that each narrow the check-family and insertion-point masks to one testing angle - API (server-side JSON/REST classes on query+body), Injection (the aggressive SQLi/NoSQLi/LFI/cmdi/XXE hammer, all points), Access control (IDOR/BOLA, 401/403 and auth-header bypass, mass assignment, price tamper - no time-based probes, safe with a login), Client-side (reflected/stored XSS, CSRF, reflected file download on query+body), and Gentle (low-and-slow shallow crawl with a long delay, low rate cap, one time-based probe at a time, and a destructive-path exclude, for a fragile or rate-sensitive target) - plus user-defined profiles, persisted to <config>/scanprofiles.json. Reference a profile by name to configure a scan: the CLI fissure scan --profile <name>, the control API (GET/POST /api/scanprofiles to list/save/delete, and a profile field on the scan job), the MCP tools (scanprofiles, scanprofiles_op, and start_scan's profile), and a Scan-profile picker in the Target view scan bar (next to the Scan button, where scans launch). Selecting a profile applies its full configuration to the next GUI scan (active/passive, aggressive, crawl depth, request delay, thread cap, wall-clock time budget, and the family/insertion-point selection). The picker is flanked by Save and Delete buttons: Save prompts for a name and stores the current scan selection (active/aggressive, crawl depth, families/points, and the settings delay/threads/time/rps) as a user profile in <config>/scanprofiles.json, then re-selects it; Delete removes the selected user profile after a confirmation that names it. Built-in presets cannot be overwritten or deleted (the attempt is refused with an on-screen notice). This is the GUI face of the already-scriptable POST /api/scanprofiles (op:"save"|"delete") and the MCP scanprofiles_op tool, so the operator can now create and remove profiles from the GUI as well as headless. The wall-clock budget (scan_max_time_sec, the Target Scan-options "Time budget"; --max-time <sec>; a profile's max_time_sec; 0 = unlimited) stops the whole run early once reached and records a "Scan stopped: time budget exceeded" finding so a truncated run reads as partial. A per-host request-rate governor (scan_rps, the Target Scan-options "Rate (req/s/host)"; --rps <n>; a profile's scan_rps; the scan_rps field on /api/scans / MCP start_scan; 0 = unlimited) caps how fast the scan hits any single host: a per-host token bucket in the engine send path (shared by the crawl, audit, and active checks) spaces sends to one host at least 1/rps apart, so raising the thread count never raises per-host request pressure past the cap, and staying under a program's rate rule does not mean going single-threaded. Extra request headers (the Target Scan-options "Extra request headers", one "Name: Value" per line; CLI --header repeatable; the headers field on /api/scans / MCP start_scan) are appended to every scan request for the auth/forwarding/marker headers a target requires; a header the request already sets is not overridden. A crawl/audit exclude list (the Target Scan-options "Exclude paths"; CLI --exclude; the exclude field on /api/scans / MCP start_scan) names URL-path substrings the crawler will not follow and the scanner will not audit (e.g. /logout,/admin/delete,.pdf), matched case-insensitively on the path only (the query is ignored, so a ?next=/admin redirect does not trip it), generalizing the built-in logout skip. Each profile carries a one-line, human-readable summary of exactly what it enables, shown as a persistent label beside the picker (and hover tooltip), and returned as a summary field by GET /api/scanprofiles so a headless caller reads the same description. A profile can also restrict WHICH checks run: a families list (any of deser, graphql, protopollution, massassign, storedxss, csrf, xxe, idor, cache, files, takeover, injection, ssrf, authbypass, nosqli, aclbypass, rfd, bizlogic) selects which active check families run - injection is the core engine (reflected XSS, open redirect, SSTI, CRLF, CORS, and aggressive SQLi/LFI/command injection and in-band/blind SSRF across every insertion point), and ssrf is a standalone out-of-band (OAST) blind-SSRF pass; selecting only a specialized family (e.g. idor) now truly runs only that family, since the injection engine is itself maskable - and a points list (query, body, headers) selects which insertion points are fuzzed (an empty list = all). The masks flow through the CLI (--families/--points, or the profile), the control API + MCP (families/points name lists on scanprofiles_op), and the GUI scan.

  • Out-of-band checks run on every scan surface. The ssrf family, and the blind halves of injection (the SSRF/RCE callback canary) and xxe, are confirmed only by a callback to the OAST collector, so they do nothing when no collector is configured. All four scan paths now borrow one: the GUI scan takes the listener started from the OAST popup, the synchronous POST /api/scan, the asynchronous POST /api/scans (the path behind the MCP start_scan tool) and the recurring scheduler all borrow the control-driven listener from POST /api/oast/start, and the CLI starts its own with fissure scan --oast <port> (plus --oast-host and --oast-domain <delegated domain> to enable the DNS canary channel).

  • A scan that cannot run what was asked for says so rather than reporting a clean result. fissure scan --families ssrf without --oast exits 2 and explains that the family is callback-confirmed and would probe nothing; any other active run without a collector prints a prominent notice naming the skipped out-of-band checks, so a zero-finding result is never mistaken for a tested-and-clean target.

  • Custom scan-options picker (Target view "Scan options" button): a popup to hand-pick exactly which check families and insertion points a scan runs, with per-family and per-insertion-point checkboxes plus the active/aggressive toggles, crawl depth, and the per-host rate governor (Rate req/s/host, on the "Rate & timing" tab; 0 = unlimited), and All/None shortcuts. The options are grouped onto four in-window tabs (a toggle-button row at the top of the one popup window shows one group and hides the rest, so the popup is wide-and-shallow instead of one tall scroll): "Scope & crawl" (active/aggressive, crawl-SPA and settings-fuzz toggles, crawl depth, crawl pages, exclude paths, seed URLs), "Rate & timing" (rate, threads, delay, time budget, host backoff, timing probes/host, and the Detection-timing block), "WAF bypass" (the encoder chain, the JSON/XML/UTF-16 body-bypass toggles, and the extra request headers), and "Checks" (the family grid, the insertion points, and All/None). Within each tab the checkboxes are stacked and left-aligned in their column. The family grid sizes its columns to the widest family label (measured) and fits as many columns as the live width allows (1 to 4), so a label never truncates; each family carries a tooltip with the detail its short label leaves out. Applying writes the selection to the Target-view scan (the same families/points masks used by the CLI/API) and marks the profile picker "Custom" with an updated on-screen summary. A full or empty group selection normalizes to "all" (the engine has no run-nothing mask; an empty family selection warns that all families will run). The popup re-flows to its live size: the window floor fits the tallest tab so no tab clips, widening it stretches the inputs and the family grid and keeps Apply/Close on the right edge, and making it taller grows the active tab's flex editor (seed URLs, or extra headers) instead of leaving dead space.

  • Configurable detection timing (Scan-options popup "Detection timing" section): the delays that trade scan speed for detection reliability are editable per scan profile instead of being compile-time constants. Six knobs in a two-column layout: the injected blind-SQLi/command sleep seconds (default 5, range 3-30), the request-timeout headroom over that sleep (default 5000ms), the independent clean re-measures that confirm a time-based hit and the round cap (default 2/2), the out-of-band callback poll window the blind SSRF/XXE/RCE/DNS-rebind checks wait (default 600ms), and the request-retry backoff (default 250ms). Each has a default-value placeholder; double-click a field's label to reset just it, or use "Reset timing to defaults" for all six. The values persist in settings, snapshot into a saved scan profile, and are exposed over the control API (/api/scans, /api/scanprofiles), the MCP bridge (start_scan, scanprofiles_op) and the web dashboard. Raise the sleep on a slow/jittery target, reconfirm-needed on a shared host, or the OAST wait for a slow callback path.

  • Scan seed URLs (Scan-options popup "Seed URLs" field / CLI --seed-file / control-API seeds / MCP start_scan seeds): extra crawl-seed URLs added to a scan for deep endpoints a link crawl cannot discover on its own - an app whose navigation is a numeric-id dropdown (bWAPP's portal) or JavaScript routing, or a curated endpoint list for an engagement. Each seed joins the crawl frontier and its host joins scope, still subject to the run's scope. The GUI field takes one absolute http(s) URL per line (saved in settings); the CLI reads a file (one per line, # comments); the control API/MCP take an array. Reach for it when a scan of the entry page leaves known pages undiscovered (a non-zero crawl left).

  • Scan a request CORPUS directly (CLI --endpoints-file / control-API endpoints / MCP start_scan endpoints): a targeted scan (no crawl) over a JSON array of fully-described requests [{method, url, content_type, body, headers, params:[...]}], each audited across its query, form-body and cookie insertion points (and its allowlisted request headers) with no prior proxy capture. For a request set exported elsewhere: an OWASP Benchmark crawler file (see lab/benchmark/gen-requests.py), a HAR/Postman-style corpus, or an engagement's known deep requests. headers is a Name: value\r\n block (a Cookie line carries cookie insertion points); a urlencoded form field is a params entry with no body (the body is synthesized from the field names). When endpoints is given the crawl is skipped and exactly those requests are audited, but the seed url is still required and its host seeds the scope. (Where seeds adds URLs to CRAWL for more endpoints, endpoints audits the exact requests given. Request headers are fuzzed only for the fuzzable-header allowlist - User-Agent, Referer, X-Forwarded-For and the rest - so a corpus whose taint is in an arbitrarily-named custom header is not covered at the header point.)

  • Dropdown-dispatcher discovery (crawler, under --crawl-submit-forms): when a form has a <select> whose options route to different pages (a numeric-id dispatcher such as bWAPP's portal, where the page names live only in a server-side map and no link points at them), the crawl submits the form once per option value and follows the dispatcher's landing page into the crawl, so those pages are discovered and audited automatically rather than needing a hand-written seed list. Bounded per select and destructive option values skipped. This is the discovery counterpart to the seed-URLs feature: seeds are the explicit list, this finds them. (The HTML parser captures each select's option values upstream in nilorea's n_html.)

  • A finding found through an input filter says which transform carried it, and whether the filter was involved at all: when an encoded probe produces a finding, the canonical payload is sent once more and both outcomes go into the evidence. A canonical payload refused with a filter status (403/406/419/429/501) next to a transformed one that was answered reads as an input-filter bypass and names the chain, which is a finding about the FILTER the owner can act on; a canonical payload that was not refused says so, and states that the transform is not what made the bug reachable. Naming the transform without that comparison would be a claim about the scan's own configuration: on a target with no filter the untransformed payload works just as well. One extra request per finding, never per probe.

  • Scan-time WAF-bypass (Scan options "WAF-bypass encoders" field): an optional comma-separated encoder chain that makes the active scanner encode every injected payload through the chain before it goes on the wire, so a blocking input filter (WAF/CDN) does not match the raw attack string. The encoders (sqlmap-tamper-equivalent) are: case, space2comment/space2plus/space2tab/space2hash/space2dash/space2randomblank/ multiplespaces (whitespace substitution, including a space that becomes a comment running to a newline and a space that becomes another whitespace byte the parser accepts, cycled rather than randomised so a finding reproduces byte for byte), randomcomment/commentbeforeparentheses (an empty inline comment inside a keyword or before a call, which the engine collapses and a word-matching rule does not), percentage (each letter percent-prefixed, which IIS/ASP strips), apostrophemask (the fullwidth apostrophe), overlongutf8 (the overlong two-byte form of the metacharacters), url/urlall/url2x (percent-encoding), charunicodeurlencode (IIS/ASP %uXXXX), versionedkeywords (wrap SQL keywords in MySQL conditional comments /*!SELECT*/, which MySQL still runs), symboliclogical (AND/OR -> &&/||), equaltolike (= -> LIKE), nonrecursivereplacement (double a keyword so a WAF that STRIPS it once leaves it behind), and jsonpad (JSON body-size padding, which applies to a JSON OBJECT body only and passes a payload value through unchanged, so it is not a scan-chain encoder); e.g. case,versionedkeywords.

  • Request-shaped input-filter bypass (--waf-request / waf_request, fissure_wafrequest). The companion to the encoders above: where those transform 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 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[], which PHP and Rails map back to the same variable while a rule keyed on the exact name misses; dotnotation sends name.x for a binder framework; charset declares a character set the filter and the application disagree about; and mpboundary quotes and pads the multipart boundary, a form RFC 2046 allows and strict and lenient parsers split on differently; mpduplicate emits a SECOND Content-Disposition name on the fuzzed part, so a filter that stops at the first attributes the payload to a field it does not guard while a parser that takes the last binds it to the one that reaches the sink (only the fuzzed part gets it, so the form still validates). Each is a disagreement between two parsers that both claim to read the same request, chosen so the APPLICATION's reading is unchanged and the payload still reaches the same sink. The JSON insertion point speaks the same shapes in its own notation: pollute/pollutelast emit the same KEY twice in the object holding the target scalar, and bracket sends the scalar as a one-element array. An unknown shape name is a hard error rather than a silently ignored option. Preview a chain with the wafrequest route/tool before scanning with it. Combines with the encoder chain; same authorization gating.

    Encoder output is in WIRE form: an encoder that wants the application to read a particular BYTE emits its percent-escape rather than the byte, which keeps every result printable and valid UTF-8 so it survives a JSON control-API field. The query, path and form insertion points percent-encode the value for you, so the chain output is decoded once there before insertion; without that the escape would arrive as literal text and the transform would do nothing. Like sqlmap's tamper scripts, the operator picks a chain that survives the target's own decoding: the keyword/operator encoders (case, space2*, versionedkeywords, symboliclogical, equaltolike) are the broadly useful ones for the aggressive injection checks (SQLi/LFI/cmdi), whose behavioral oracle still fires after the target decodes the payload; nonrecursivereplacement targets a WAF that sanitizes by stripping; and the url-family encoders (url/urlall/url2x/charunicodeurlencode) suit non-URL-encoded points (headers/cookies/raw bodies). The single insertion seam applies to query, path, form, multipart, JSON, GraphQL, header, and cookie points of the core injection engine. A check whose oracle is the payload's own literal bytes never goes through the encoders at all (the reflected-XSS and open-redirect marker echo, the CRLF marker header, the traversal path the target has to open, the id command the shell has to resolve, and the cloud-metadata URL the server has to fetch), so an encoder chain can never silently turn one of those into a reported-nothing run. Blank = off. An unknown encoder name is rejected with an on-screen error. Because this bypasses a protective control it carries the enforced code-of-conduct contract: when a scan with WAF-bypass active starts, the non-blocking code-of-conduct notice shows and the use is recorded in the event log before any traffic goes out. Exposed everywhere the scan is: the setting persists (scan_waf_encoders), the CLI fissure scan --waf-bypass <chain>, the control-API waf_encoders field on POST /api/scans, and the MCP start_scan(..., waf_encoders=...) tool (all four validate the chain and record the notice; authorized in-scope targets only).

  • Scan-time WAF-bypass for request BODIES (Scan options "WAF-bypass request bodies (JSON operators)" checkbox): a separate, opt-in toggle that also bypasses a WAF inspecting JSON request bodies. The encoder-chain option above covers the query/path/form/header string payloads, but the specialized direct-body checks (NoSQL operators like $ne/$where, prototype-pollution keys like __proto__, JSON-embedded metacharacters) build their own JSON bodies where a generic tamper encoder would corrupt the structure. This toggle instead passes every JSON body sent by the scanner through the jsonunicode encoder, which unicode-escapes (\uXXXX) only the string-only signature characters ($ _ < > ' ( ), none of which appear in JSON structure or number tokens), so a WAF body signature does not match while the receiving JSON parser decodes the body back to the identical object. Off by default; carries the same code-of-conduct notice. Four-surface: the setting persists (scan_waf_body), the CLI fissure scan --waf-body, the control-API waf_body flag on POST /api/scans, and the MCP start_scan(..., waf_body=True).

  • Scan-time WAF-bypass for XML/XXE bodies (Scan options "WAF-bypass XML bodies (XXE)" checkbox): the XML analogue of the JSON body option, for a WAF that inspects XML request bodies. XML markup keywords (<!ENTITY, SYSTEM, <!DOCTYPE) cannot be char-reference-encoded, so the XXE check's XML body is passed through the xmlbypass encoder: it rewrites the DTD so a WAF signature on the external-entity markup misses while an XML parser resolves the entity identically, using two byte-safe, parser-transparent transforms: the SYSTEM keyword becomes a PUBLIC external id (an external identifier declared PUBLIC carries a public id plus the same system URI, which the parser fetches the same way, so a WAF keyed on SYSTEM is evaded), and the space after the DTD keywords becomes a tab (still valid XML whitespace). Off by default; same code-of-conduct notice. Four-surface: the setting persists (scan_waf_xml), the CLI fissure scan --waf-xml, the control-API waf_xml flag on POST /api/scans, and the MCP start_scan(..., waf_xml=True).

  • Scan-time UTF-16 WAF-bypass for XML/XXE bodies (Scan options "WAF-bypass XML as UTF-16 (XXE)" checkbox): the second classic XXE bypass, now available because the request-body path is binary-safe. The XXE check's XML body is re-encoded as UTF-16LE with a byte-order mark (the utf16 encoder, which also rewrites a UTF-8 encoding declaration to UTF-16), so a WAF that signature-matches the ASCII XXE markup (<!DOCTYPE/<!ENTITY/SYSTEM) sees UTF-16 bytes (each ASCII char interleaved with a NUL) and misses entirely, while an XML parser detects UTF-16 from the BOM and resolves the entity identically. It layers on the DTD rewrite (apply both) and is sent via fissure_request_set_body_n (the body carries NUL bytes). Off by default; same code-of-conduct notice. Four-surface: the setting persists (scan_waf_xml_utf16), the CLI fissure scan --waf-xml-utf16, the control-API waf_xml_utf16 flag on POST /api/scans, and the MCP start_scan(..., waf_xml_utf16=True). The utf16 encoder is also in the general wafbypass encoder set (last in a chain), so wafbypass_resend/send_request can UTF-16-encode any crafted XML body.

  • Scheduled / recurring scans: a saved scan (target + optional profile + active/aggressive) recurs on an interval. The control server runs a scheduler thread that fires each due schedule, runs the scan (profile-aware, scope-enforced), records the finding count, and reports the delta since the last run (pairs with the recon asset-diff). Managed over the control API (GET/POST /api/schedules with op add|remove|enable|disable|run), the MCP tools (schedules, schedules_op), and a toolbar "Schedules" popup (add a schedule, run-now, enable/ disable, remove). Persisted to /schedules.json; schedules fire while the control API is enabled. The core (fissure_schedule: the model + due logic + per-run diff) is unit-tested.

  • Tool-version probe: records external-tool versions into the report.

Repeater

  • The saved tab workspace is reachable headlessly: GET /api/repeater/tabs lists the collections an operator built for the engagement and POST /api/repeater/tabs (add/remove/update/activate) edits them, reading and writing the same project repeater.json the GUI writes. An agent can see the requests a human collected, and leave some behind for them.

  • Multiple request tabs and named collections.

  • Resizable panes in the views: the Findings list against its detail pane, the Intruder payload box against its results table, and the Multitool's input, script and output editors all have draggable dividers whose positions are remembered across sessions. The Dashboard's severity chart scales with the window height.

  • Resizable panes: drag the divider between the left tab list and the request editor to resize the list; drag the two horizontal dividers in the request editor to resize the request headers vs body, and the whole request area vs the response pane. All pane sizes (here and in the Proxy view) are remembered across sessions.

  • Structured request editor (Inspector): parsed headers/params/body editing.

  • Binary-safe request body: the transport sends a request body byte-exactly, including embedded NUL bytes, so a binary / UTF-16-encoded / protobuf body reaches the target intact with a matching Content-Length (the engine appends the raw body bytes, not a NUL-truncated string; fissure_request_set_body_n stores an explicit length). Internal encoders that build such bodies (e.g. UTF-16 XXE) and automation both rely on it: the control API / MCP send_request accepts a body_b64 (base64-encoded) body that is decoded to raw bytes and sent whole, for a body a JSON string cannot carry.

  • Response views: raw, pretty, hex, and rendered (HTML) views.

  • Per-request User-Agent selector in the request bar (between the method and the URL): "UA: active" sends with the active preset (the global default), or pick any preset to override the User-Agent for that one send. See "User-Agent presets" below.

  • Request grouping with synchronized ("single-packet"-style) send across a group.

  • Send-to-Repeater from the proxy, findings, and context menus (full request).

  • Shadow Repeater (AI-assisted variation testing): right-click a request (proxy, logger, findings) and choose "Shadow Repeater" to auto-fuzz its parameters in the background. It detects the insertion points (query parameters and a form-encoded body), generates variations of each value (a fixed injection battery, plus bit-flip and case-modified variants of the current value via the Intruder generators, plus, when an AI provider is configured, model-proposed values), replays each variation, and surfaces the responses whose status, body length, response timing, or payload reflection differs from the baseline as tentative candidate findings (a spinner shows progress; a popup reports the summary). It sends active traffic, so it needs aggressive mode enabled. Headless parity: POST /api/shadow and the shadow_repeater MCP tool (with a focus parameter to fuzz only the value just edited); the engine (fissure_shadowrepeater) is unit-tested (tests/test_shadowrepeater).

User-Agent presets

  • A named User-Agent preset library with an active selection. The active preset is the User-Agent every request Fissure sends adopts (scan, repeater, intruder, active checks, recon, workflows, and the request-smuggling and HTTP/3 probes) unless that request carries its own User-Agent header or override. Built-in presets ship for the Fissure default, a broad set of well-known desktop and mobile browsers (Chrome, Firefox, Safari, Edge, Opera, Samsung Internet, and Internet Explorer 11, across Windows, macOS, Linux, Android, iOS, and iPadOS), crawlers (Googlebot, Bingbot), and command-line tools (curl, wget, python-requests); the operator saves, edits, and deletes their own on top. Built-in presets cannot be edited or deleted.
  • The "User Agents" popup (toolbar Recon & infra category, and the command palette) manages the library: a grid of every preset (with the active one marked), a name + value form to Save a preset, Delete for your own presets, Set active to switch the active preset, and Use default to fall back to the built-in Fissure User-Agent. Every change persists to <config>/useragents.json and takes effect immediately for subsequent requests.
  • Per-request override in the Repeater request bar (the "UA: active" selector) picks a preset for a single send without changing the global selection.
  • Precedence, resolved by the engine for every send: an explicit User-Agent request header wins, then a per-request override (the Repeater picker / control-API user_agent field), then a per-run config override, then the active preset, then the compile-time Fissure/<version> default. A User-Agent line in a scan's extra-headers is honored without producing a duplicate header.
  • Headless parity: GET /api/useragents lists the presets and the active selection; POST /api/useragents ({op:"save"|"delete"|"activate"}) manages them; the useragents and useragents_op MCP tools mirror both. A per-run override is available as a user_agent field on send_request, intruder, and start_scan (and the matching control-API routes). The preset library is unit-tested (tests/test_useragent) and the engine precedence is covered by tests/test_engine.

Intruder

  • Saved attack configs are reachable headlessly: GET /api/attackcfgs lists them, POST /api/attackcfg (get/save/delete) reads and writes one, and POST /api/intruder accepts "config":"<name>" to run one, filling every field the caller did not give (an explicit field always wins, so "my saved attack, against this other URL" is one call). An agent no longer has to respecify a whole attack inline to reuse one an operator tuned in the GUI. What travels with a config is the WHOLE attack, not a subset: the attack mode (written as its readable name and accepted as either the name or the enum, so a saved cluster bomb re-runs as a cluster bomb instead of collapsing to a sniper that sends a fraction of the requests and never uses the second position's payload set), the per-position payload sets, the grep rule, and the payload-processing pipeline. That pipeline is persisted, returned and applied on re-run, and it can also be passed inline as "steps" on POST /api/intruder (an array of {kind, arg1, arg2, xform} steps, the same prefix/suffix/match-replace/transform/skip-if/regex-replace/ script vocabulary the GUI's Process popup edits), so a headless attack sends the same payload BYTES the GUI attack sends rather than the raw ones. Both fields reach the MCP tools too: intruder(config=..., steps=[...]) and attackcfg(..., steps=[...]).

  • Attack positions with payload types and payload generators (List, Numbers, Null, Wordlist file, Dates, Charset, Case-mod, a scriptable QuickJS generator that programmatically produces payloads - the Turbo-Intruder-style attack driver - plus three exotic generators: a Username generator (common username forms from a person's name), a Bit flipper (each single-bit variant of an encoded token, for padding-oracle and bit-flip work), and an ECB shuffle (adjacent block swaps and duplications of a block-cipher ciphertext, for ECB cut-and-paste analysis)).

  • Recursive grep (a payload type, and control-API/MCP mode="recursive"): a chained run where each request's payload is extracted from the previous response by a regex, walking a rotating CSRF token, a pagination cursor, or a step-by-step flow. In the GUI the "Recursive grep" payload type carries the extract regex (line 1), an optional seed (line 2), and an optional count (line 3); headless it takes extract, seed, and count. The chain stops when the extract finds nothing or the count is reached.

  • Per-position payload-set editor.

  • Payload-processing pipeline (ordered, composable processors) with an editor and a QuickJS script preprocessor.

  • Per-attack rate, delay, and retries.

  • Response analysis: a Grep-match Hit column, a Grep-extract capture column, and a payload-reflection Refl column that flags each response echoing that request's own payload value back (a reflection lead, computed for every run).

  • Save/load attack configurations (persisted per project).

Findings, triage, and reporting

  • One findings store fed by the proxy, native checks, and plugins.
  • Detection-coverage findings from purple-team mode (see below): a technique the target never alerted on, and a technique whose coverage fell against a saved baseline.
  • Finding annotations, status, and triage; multi-select group actions. The Findings grid supports native multi-selection: a plain click selects one finding, Ctrl-click toggles a row, and Shift-click selects a range; selected rows are highlighted and marked in the leading column ([x] selected, [ ] not). Every per-finding action is available on the whole selection: set triage, cycle the highlight color, append a note (the Note sel button appends the Notes-box text as a new line to each selected finding), add a tag, delete, send to Repeater, stash to the Organizer, push to PwnDoc, and the right-click request actions (right-clicking inside the selection raises the cross-tool menu over every selected finding's request at once).
  • Findings detail-pane selection navigator: when several findings are selected, a Prev / "k / N" / Next row above the detail pane steps the detail view through the selection one finding at a time. The finding currently shown is marked distinctly in the grid ([>] rather than [x]) and the list scrolls to keep it in view, so it is always clear which of the selected rows the detail pane is on. Navigation never changes which findings are selected.
  • Row highlight coloring (parity with the Proxy grid): a Highlight button on the Findings view cycles the selected finding's color from a fixed palette (red / orange / yellow / green / blue / purple), painting the row (when several findings are selected it applies the cycled color to the whole selection); a passive HaE-rule match against the finding's evidence paints any row that has no manual color. The manual color is stored as a reserved hl:<color> entry in the finding's tag list, so it persists with the project and rides the report/JSON, and it is settable headless over POST /api/finding/highlight and the MCP tool finding_highlight.
  • Capture-backed evidence: findings link to captured request/response pairs, persisted with the session and resolved at render time. All three save paths archive them: the CLI --save-session, the GUI's project persistence, and the control-API POST /api/session/save (with POST /api/session/load restoring them), so a headless engagement's saved session reloads as evidence rather than as bare claims. The save response reports captures_saved separately, so a findings file that wrote while its evidence did not is visible as the partial save it is.
  • Synthetic report generator that aggregates, dedups, and groups findings, with triage-aware filtering (exclude triaged-out).
  • The report options are on every surface, not just the CLI: exclude_triaged (drop findings already triaged false-positive or ignored, so a hand-over report does not re-raise dismissed work), redact (evidence is masked by default; turn it off when the leaked secret IS the finding and the report goes to the asset owner), and tool_versions (probe each installed plugin tool and record its version, making a finding attributable to a specific tool build). Available as CLI flags (--exclude-triaged, --no-redact, --tool-versions), as GET /api/report query parameters, and as MCP report arguments.
  • The control-API job concurrency cap is configurable everywhere it runs: the GUI Settings "Max jobs" field (applied live to a running control instance) and the headless fissure serve --max-jobs <n>. Previously the setting existed but the headless server ignored it and ran the compiled-in default.
  • Per-issue remediation and reference library: a curated offline table (fissure_ remediation, keyed by CWE with a category fallback) of generic fix guidance and authoritative references (OWASP cheat sheets, CWE entries) for the common vulnerability classes. The report fills in remediation when a finding carries none and adds a References section, so every issue reads consistently regardless of its source (native check, plugin, scripted check); the same library is queryable over POST /api/remediation and the MCP tool remediation.
  • Multi-format report export: HTML, Markdown, JSON, CSV, SARIF (CI code-scanning), and issue XML (the burp format, imports findings into an external scanner), from both the Report view and the CLI (--format). The Markdown renderer parts consecutive findings with a --- thematic break so a long report reads as distinct findings rather than one unbroken run of sections.
  • Report preview Source / Rendered toggle (the "Show: Source" button next to the format): Source is the raw report text for every format; Rendered draws a Markdown report in place (headings, tables, lists, code, links that open in the browser, with drag / double-click / Ctrl+A / Ctrl+C selection), and opens an HTML or PDF report in the desktop browser (written to a temporary file) while the preview shows a short note.
  • Customisable HTML report template: the HTML report (and the PDF printed from it) uses the operator's <config>/report.html.tmpl when present, else the bundled resources/report/report.html.tmpl, else an identical built-in copy. The file is read at every preview and export, so an edit applies without a restart. Variables: {{report_title}}, {{generated_at}}, {{fissure_version}}, {{risk_score}}, {{sev_critical}}..{{sev_info}}, {{total}}, {{tools_html}}, {{findings_html}}. A template that is unreadable, empty or lacks {{findings_html}} is rejected (a report silently missing its findings would read as a clean result) and the next source is used; the reason shows in a Report-view popup, as a fissure scan/report --format html stderr line, and as template_error in the control-API / MCP report response, which also names the template used (custom, bundled or builtin). JSON, SARIF, CSV and issue XML have no rendering: the toggle greys out and the source shows. Opening the browser only ever follows a click (switching to Rendered, or picking HTML/PDF while Rendered), never a background re-render.
  • PDF export via a user-configured external generator (Settings > Reporting, a {{in}}/{{out}} command template such as wkhtmltopdf {{in}} {{out}}); the PDF option is disabled when no command is set.
  • PwnDoc connector: push findings and generate a report to a PwnDoc instance (async jobs, credential/token auth).

Purple team (detection coverage)

Fissure never hides from the target owner (see Safety below: no anti-forensics, no log poisoning to conceal activity, no traffic-source concealment). Purple-team mode is the other side of that line: instead of evading the owner's monitoring it MEASURES it, and turns "did they see us" into a reported coverage gap. Driven from the "Purple team" toolbar popup (Results category, and the command palette), the control API (GET/POST /api/purple, GET /api/purple/probes, GET /api/purple/events) and the MCP tools purple / purple_op / purple_probes / purple_events. Full description in 15_PURPLE_TEAM.md.

  • Probe recording: while the mode is on, every request the transport engine puts on the wire is recorded with its timestamp, the tool that sent it (scanner, repeater, intruder, crawler, ...), the attack technique it carried, its method / host / path, its response status and the request bytes themselves (truncated to a per-probe cap). Recorded per ATTEMPT, so a redirect hop is its own probe, because it is its own request in the target's logs too. The recorder is a process-global store with a bounded probe count (oldest drop), so a long run cannot grow without limit.
  • Technique attribution: an active check tags the recording thread as it enters its family gate, so its probes are filed under that family (sqli, xss, lfi, cmdi, ssti, ...). A request sent outside a check (a Repeater send, a hand-built attack) is classified from its own bytes by payload signature, and plain navigation is filed as traffic rather than inheriting the last check's label.
  • Correlation marker: with the marker on (the default), every recorded probe also carries an X-Fissure-Probe: <run>-<id> header, so a line in the target's own logs can be tied to one exact request. The marker is deliberately identifying, and it is the opposite of the evasion Fissure does not do. Turn it off to ask the harder question: whether unlabelled attack traffic is spotted at all.
  • Named runs: the run name prefixes every marker, so the markers mean something in someone else's log pipeline (a ticket id, a date). Naming a run restarts the probe numbering, since run plus number is the identity a marker carries.
  • Telemetry import: the target's own logging and alerting output is imported one record per line, in any of three shapes with no configuration: JSON object lines (time, action/severity, source, method, path read from the usual key names, including @timestamp and epoch seconds or milliseconds), common-log-format access lines (bracketed date with its UTC offset, quoted request line), and free text (an ISO-8601 or bracketed timestamp anywhere in the line, a quoted request, a uri=/path=/url= key, or the first slash-token). Each event is a log line, an alert or a block: taken from the line's own words (blocked, denied, alert, attack, modsecurity, ...) and from the caller's default when the line does not say. Those words are read only from what the sensor wrote: the quoted request line, and a JSON line's path value, are masked out first, so an XSS payload spelling alert(1) in a logged request is not counted as an alert the defenders raised.
  • Reconciliation: telemetry is matched to probes by correlation marker first (exact, and a whole-token match, so run-1 is not satisfied by run-12), then, within a time window (five minutes by default), by the payload appearing verbatim in the line (which is how a sensor that logs request parameters rather than headers is matched at all), then the exact path, then the path alone. Within a rank an event prefers a probe no event from the SAME source has claimed yet, then the closest in time: N requests to a path produce N log lines, and otherwise one probe absorbs the burst while its neighbours read as unseen. Every probe is reset and re-matched on each pass, so reconciling twice, or after importing more telemetry, gives the same answer as reconciling once with everything.
  • Three outcomes per probe, not two: unseen (no telemetry mentions it at all), logged (the target recorded the request but raised nothing about it) and alerted/blocked (the defenders detected it). The middle state is the one a plain detected/not-detected view loses, and it is the difference between "we have no evidence" and "the evidence is there and nothing read it".
  • Coverage table: per technique, probes sent, logged, alerted, blocked and a coverage percentage. In the GUI the rows nothing caught are painted (red when the probes left no trace, orange when they were logged but silent).
  • Reported, not just displayed: Emit findings turns each undetected technique into a host-scoped finding (CWE-778, OWASP A09:2021 Security Logging and Monitoring Failures), low severity when the probes left no trace and informational when they were logged but never alerted on, with the run, the counts and the first probe's URL as evidence, and remediation that covers the case where a rule exists but the traffic never reaches its sensor. So the coverage gap lands in the same report as everything else instead of staying a side conversation. A technique the target alerted on or blocked produces nothing (that is coverage that works), and neither does the traffic bucket of requests that carried no attack, since a defender is right to ignore those.
  • The weak ranks cannot tell two of the tester's own runs apart: telemetry from another window that names the same paths will match if it falls inside the window and credit this run with another run's detections. The marker is what separates runs (it carries the run name); slicing the export to the run's window, or reconciling with a tighter window, is the operator's part.
  • Unmatched telemetry is kept and listed separately: those lines are either the defenders reacting to something that was not the tester, or a correlation that failed, and both are worth reading before a coverage number is quoted.
  • Run-to-run comparison: a run's coverage table can be kept as the baseline a later run is diffed against, so each technique comes back unchanged, improved, regressed, new or not-re-tested. A technique whose coverage FELL becomes its own finding (Detection regression: <technique> coverage fell from X% to Y%, low when it went to zero and informational when it merely fell), which is the failure a single measurement cannot show: the rule was working when it was last measured, so something changed on the defending side. Baseline/Diff in the popup, {"op":"baseline"} / {"op":"diff"} on the API, the same ops over MCP, and fissure purple baseline / diff on the CLI, where a regression exits 1 so a scheduled run can gate on it.
  • Telemetry is imported as pasted text or as a file the Fissure host reads itself (the popup's Import file, the API's {"file":...}, fissure purple import <path>): a real export runs to megabytes and the control API caps a request body, so the file route removes the caller's chunking loop. Capped at 32 MB, 404 when unreadable.
  • A complete CLI half: fissure scan --purple <run> records the scan's own requests (and starts after the --login replay, so credentials never enter the probe store), and fissure purple status|import|reconcile|findings|baseline|diff|clear|marker drives the rest. The store is the project's, so the CLI, the GUI popup and the control API are all looking at one run.
  • The run (mode, marker, name, probes, telemetry, reconciled states) persists to the active project as purple.json and reloads with it, and the popup reads it back on its own when nothing is recorded in memory yet (a live recording is never overwritten).
  • The popup keeps itself live: while a run is recording its panes refresh every couple of seconds, and only when the store has actually grown, so a scan in progress shows probes arriving without an idle popup rebuilding anything. The two large grids list the newest few hundred rows and say so when there are more; the tallies count the whole run.

Forging and analysis workshops

  • Signed-token workshop (Tokens): the stateful JWT + framework-cookie forging workshop (distinct from the Multitool's quick read-only JWT inspection). JWT decode/edit/re-sign (HS256/384/512), alg:none stripping, HS/RS algorithm confusion, and offline HS-secret cracking; plus framework signed cookies: Flask/itsdangerous, Django, Rails signed, Express cookie-session, Rails encrypted (AES-256-GCM), and a generic HMAC signed-string mode. Decode/sign/verify/crack, and apply-to-Repeater. See 10_TOKENS.md.
  • SAML workshop (SAML Raider style): decode a base64 (optionally DEFLATE-compressed, for the HTTP-Redirect binding) SAMLRequest/SAMLResponse into XML, inspect and edit the identity it asserts (Issuer, NameID, attributes), and exercise the three classic XML-DSig attacks: signature exclusion (strip the ds:Signature), XML signature wrapping (three variants: keep the validly signed assertion but smuggle a forged one a vulnerable SP may process - 1 the forged assertion precedes the original as a sibling, 2 the original is moved into a ds:Object inside its own ds:Signature grafted onto the forged assertion, 3 the original is moved into a samlp:Extensions wrapper - with the signed assertion located anywhere in the document), and self-signed re-signing (generate a throwaway key + cert and re-sign a tampered message, which passes an SP that does not pin the IdP cert). Sign/verify use enveloped RSA-SHA256; verify is a pure signature/digest check (cert chain/validity deliberately not enforced) over EVERY ds:Signature in the message, not just the first, since a signed Response plus a signed Assertion is the common enterprise shape: inspect reports each signature (what it signs, its reference URI, its result) and the message is valid only when they all verify. Decoding tells the POST binding from the Redirect one by sniffing the decoded bytes for XML text rather than by their first byte, since a raw DEFLATE stream can itself begin with 0x3C ('<'). Built on libxml2 + xmlsec1, linked in Fissure. See 10_TOKENS.md.
  • Prettify (beautify) JSON/XML/JS: a Prettify button on the Repeater request body and response, a Prettify button on the Proxy flow's request/response panes, a Multitool "Prettify (JSON/XML/JS)" transform, the control API (POST /api/prettify, with a message flag to beautify only the body of a raw HTTP message and keep the headers), and the MCP prettify tool. JSON is re-serialized via cJSON; XML/HTML and JS/CSS are re-indented structurally (a viewing aid that never removes content). Auto-detected from the content or the Content-Type.
  • Multitool (a resizable popup, Analysis & inspection or F9): quick, stateless one-off tools - encode/decode (base64, base64url, hex, URL, zlib, ...), hashing and hash-type identification, read-only JWT inspect + an HS256 crack, smart-decode (auto-peel nested encodings), a protobuf/gRPC wire-format decoder (the protoc decode_raw view), a JSON/XML/JS prettifier, and a QuickJS convert-transform runner. For editing/signing/forging JWTs or framework cookies, the Tokens workshop is the tool.
  • Protobuf / gRPC decode: decode a raw protobuf message (which carries no field names, only numbers + wire types) into an indented field tree - varints, fixed32/64, quoted strings, hex byte dumps, and recursion into nested messages. A leading gRPC length-prefix frame (compression flag + 4-byte big-endian length) is detected and stripped. Available as a Multitool transform, over the control API (/api/protobuf, base64 or hex bytes), and as the MCP protobuf tool.
  • Inline transform tags (Hackvertor-style): <@name>...<@/name> expansion in the Repeater/Intruder send path and the Multitool, with a custom-tag manager (tags.json). On first run it ships a starter set (reverse, doubleurl, sqlcomment, nowrap, and a marker variable), with a "Restore defaults" button and a reset op on POST /api/tags / tags_op("reset") to bring them back. Removing a custom tag, removing a variable, and restoring the starter set each ask first through the shared confirm dialog, naming the tag or variable (and, for the restore, how many custom tags and variables it replaces, since a hand-written JavaScript body is not recoverable). Both grids resolve a clicked row from that row's own cells, so sorting by name or body cannot make an edit or a removal land on a different record, and they keep their scroll position across a set or a removal.
  • Comparer: word- and byte-level diff of any two values; a "Send to Comparer" request-context action loads the selected request(s) into its two sides (select two rows to fill both at once, or send one then another to fill side A then side B).
  • Sequencer: token randomness/entropy analysis.
  • Universal traffic query language (HTTPQL-class): one boolean query dialect (status >= 500 AND method = POST, operators = != ~ !~ =~ > < >= <=, AND/OR/NOT, parentheses; the engine is Nilorea n_query) with a shared HTTP field vocabulary (traffic tool/method/url/host/path/status/length/time/mime/scope, findings title/severity/location/category/host/cwe/owasp/confidence/source/tags/scope) that filters every grid in place; the scope field is in or out of the configured target scope (scope = in / scope = out), so the in/out scope filter is available in every URL list, and editing the scope live re-filters the Proxy, Findings, and Sitemap grids. Beyond typing the query, every URL list carries a visible Scope: all cycle button next to its filter box (Proxy, Findings, Sitemap, and the Logger popup) that cycles all / in-scope only / out-of-scope only, so scope filtering is one click, not a typed query; the button tests each row against the same shared target scope, so it tracks Scope-editor edits live. The Logger, Findings, Proxy, and Sitemap filter boxes each doubling as a query box (a query when it parses, a substring otherwise; the Proxy box is a query only when its regex toggle is off), plus the Global Search popup across captured traffic and findings. Named filters are saved (Save/Load in the Search popup), shareable, and persisted to <config>/queries.json; on first run the store is seeded with a shipped starter HTTPQL library (in-scope, status classes, JSON/JS, admin/API paths, large responses), and a "Reset to defaults" button (and the reset op on POST /api/queries) restores it. The same dialect also filters WebSocket frames (StreamQL over WS frames): the Proxy view's WebSocket frame pane carries a filter box over the WS field vocabulary (dir c2s/s2c, opcode text/binary/ping/pong/close/cont, fin, length, seq, payload, url, host, scope), so dir = c2s AND opcode = text AND payload ~ token narrows a busy socket to the frames of interest. Headless parity: POST /api/query {source, query} filters the findings store (source":"findings"), captured exchanges ("traffic"), or WebSocket frames ("wsframes"), GET/POST /api/queries manage saved filters, and the query/saved_queries/saved_queries_op MCP tools mirror them.
  • CSRF PoC generator and Clickjacking PoC generator (from a request/URL). The CSRF PoC emits an auto-submitting form (GET, or a POST with a urlencoded body: the content-type test is case-insensitive, and the form action is the request URL used verbatim and HTML-escaped, so the PoC hits exactly the URL being demonstrated) or a credentialed fetch (any other method or body, 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); additionally, a JSON object body gets a JSON-CSRF text/plain form-trick (a form with enctype=text/plain and a padding key that reconstructs valid JSON, so a cross-site form POSTs the JSON with the victim's cookies and no CORS preflight) and a PUT/PATCH/DELETE gets a manual method-override (_method) form. Exposed headless too: POST /api/csrf-poc and the MCP csrf_poc tool return the PoC HTML.

Out-of-band and IAST

  • IAST beacons have their own surface, separate from plain out-of-band callbacks. A bare SSRF/XXE canary fetch proves only that something reached the collector; an instrumentation agent's beacon carries fields naming WHICH SINK the canary reached and with what argument, which is what turns a "maybe" into a reportable finding. Both land in the same interaction list, so the beacons are listable on their own with their fields split out: the OAST popup's "IAST beacons" button, GET /api/oast/beacons, and the oast_beacons MCP tool (which reports count beacons out of hits_total interactions, so a bare-callback-only run is obvious).

  • OAST out-of-band testing: mint canary tokens, collect callbacks, correlate hits back to findings, over three channels - HTTP (loopback), DNS (<token>.<domain>), and SMTP (<token>@<domain>); the interaction grid shows the channel per hit. The active scanner auto-injects an HTTP canary at each insertion point and, when a domain is configured, a DNS canary too (to catch resolve-only blind SSRF/XXE) and a DNS-rebinding canary (the DNS responder answers a benign IP first and the cloud metadata IP 169.254.169.254 on re-resolution, on a low TTL, to catch a resolve-then-connect TOCTOU SSRF). Rebinding canaries are minted over the control API (POST /api/oast/rebind, MCP oast_rebind) and from the OAST view's Mint, and oast_poll reports the per-token re-resolution count. The rebind timing profile is tunable: ttl sets the served record TTL (a short TTL forces a fast re-query) and flip_after the number of benign answers before the flip to internal (raise it to survive a resolver that pins or pre-fetches the first answer). oast_poll also returns the observed rebind window (rebind_window_ms, the interval from the first lookup to the flip) plus the profile, a per-target report to tune the next mint.

  • Turnkey hosted OAST (interactsh): a zero-setup alternative to the local listener for DNS/HTTP callbacks with no bring-your-own-domain. The client (fissure_hostedoast) speaks the open interactsh protocol against a public interaction server (oast.pro, oast.live, oast.site, ...) or a self-hosted one: it generates an RSA keypair, registers its public key, mints canary subdomains under the server's domain, and decrypts the server's poll response locally (the AES session key is RSA-OAEP-SHA256 encrypted to the client; each interaction is AES-256-CFB). Driven from the OAST view (a Hosted server field + Register/Poll buttons, server remembered in Settings), the control API (POST /api/oast/hosted with op register/canary/poll/status), and the MCP oast_hosted tool. The openssl already linked for TLS does the crypto.

  • OAST canary injection: an opt-in passive proxy mode that seeds forwarded in-scope requests with OAST canary forwarding headers (Referer, X-Forwarded-For, and similar) and correlates any pingback into a certain blind-SSRF finding.

  • IAST beacon protocol: a documented canary/beacon format so an instrumentation agent can report which sink a canary reached (and the exact code line and tainted source), with reference observe-only agents for Node.js, Python, Ruby, PHP, Java, and .NET under agents/ covering command-exec, filesystem, outbound-HTTP, code-evaluation, deserialization, and SQL-query sinks (SQL drivers hooked on require/import; the PHP agent auto-hooks via the uopz extension and always offers a manual sink hook). The Java agent is fully automatic: agents/java/FissureIastAgent.java (built into a -javaagent jar by agents/java/build.sh) installs an ASM ClassFileTransformer that rewrites the app's bytecode at load time, injecting a FissureIast.autoSink call before every sink call site with no app change (regression- tested in tests/test_iast_java_auto.c); it also keeps the manual FissureIast.sink API (beacon carries a Class.method(File.java:line) frame) and an optional jakarta/javax servlet filter that tags the tainted request parameter/header as the beacon src. The .NET agent is fully automatic too: agents/dotnet/FissureIastWeaver.cs, armed from the DOTNET_STARTUP_HOOKS entry point, detours the framework's own sink methods so the app makes no Fissure call at all (regression-tested in tests/test_iast_dotnet_auto.c, where the target calls Type.GetType(canary) and nothing else). The CLR gives managed code no load-time class transformer, so where the JVM agent rewrites every CALLER of a sink, this detours the SINK itself: same guarantee, and it also covers callers in assemblies loaded later. It needs a patch library resolved by reflection, so the manual Sink API stays dependency-free and the automatic half reports itself off when the library is absent, the same shape as the JVM agent's dependency on ASM. See 08_IAST_BEACON.md.

Plugins and dependencies

  • Structured plugin output wherever the tool can produce it. Seven manifests that used to collapse a whole run into one text blob now ask their tool for JSON and map it field by field: gitleaks, grype, nikto, testssl.sh, trufflehog (JSONL), wpscan and trivy. A records path may contain a * segment (Results.*.Vulnerabilities) to fan out across a nested array, which is how trivy reports one finding per vulnerability instead of one per scanned target.

  • A response header that appears more than once reaches a check with its values joined by a newline rather than collapsed to the last: Set-Cookie is repeated by almost every application that sets more than one cookie, and keeping only the last hid the session cookie behind whatever was set after it, so a check looking for it found nothing and reported nothing, which reads exactly like a clean target.

  • sslyze reports structured findings through a DEDICATED parser rather than a field map. A field map copies values out of records; sslyze reports a tree of check results per scanned server, where whether something is a finding is a judgement about the values (a protocol version that still accepts cipher suites, a path validation that failed, a suite whose name carries RC4), not a field to copy. The manifest says "format": "sslyze" and the reading lives in code, which is the shape any future tool with tree-shaped output takes. It reports, per scanned server: obsolete protocol versions still accepting suites (SSL 2.0 critical, SSL 3.0 high, TLS 1.0/1.1 medium); accepted cipher suites graded by their primitive (null/anonymous/export critical, RC4/single-DES/MD5 high, 3DES medium), each named once however many versions accept it; certificate chains that fail to validate, told apart into expired, hostname mismatch and untrusted rather than collapsed into one generic problem, plus SHA-1 signatures, out-of-order chains and distrusted legacy anchors; and the single-purpose probes (Heartbleed, CCS injection, ROBOT, insecure and client-initiated renegotiation, TLS compression, missing TLS_FALLBACK_SCSV). A server whose checks all pass still gets one informational line naming what it does offer, since this replaced a parser that always produced exactly one finding and silence would read as a broken parse rather than a sound configuration; a server sslyze could not scan is reported too, because absence of findings there is absence of evidence.

  • Five previously installable-but-unusable tools gained manifests and are now runnable: wapiti and OWASP ZAP (web scans), bandit, semgrep and OWASP Dependency-Check (code and dependency scans of a local path). Four others were dropped from resources/dependencies.json instead, because Fissure has no surface that consumes them and offering an install for a tool that can never run is worse than not listing it: hashcat and john (offline hash cracking, and the Token workshop already cracks HS secrets), hydra (online credential brute force, which Fissure has no attack surface for), and jwt_tool (superseded by the built-in signed-token workshop).

  • OSS-tool plugin host: external tools run as detached subprocesses; per-plugin manifests declare how to launch them and how to parse their output into findings. Plugin output opens in its own tab (closable).

  • Bundled nuclei plugin: rate-limited, with timeout/retries, and an {{extra}} passthrough so an operator can scope by tag/severity, point -t at a templates dir, or pass -H auth headers. Two tag-scoped presets ship alongside it: nuclei-cves (high/critical CVE templates) and nuclei-exposures (exposure/config/backup/misconfiguration templates).

  • Dependency manager: dependencies.json holds download URLs/methods; automatic install via github_release / go_install / pip / gem / apt / git_clone / script. Plugins are optional (present if installed, gracefully skipped if absent). Installs are root-free wherever the tool allows it: a Python tool goes through pipx, then pip install --user (retried with --break-system-packages), then a private venv under the install root whose script is linked into its bin/, so a PEP 668 externally-managed Python does not block the install; a Ruby tool (wpscan) installs with gem --user-install and is linked the same way; when such a gem has native parts that fail to compile, its declared build_deps (for wpscan ruby-dev build-essential) are installed and the install is retried once, so the only password prompt is the one a failed build actually made necessary. A pip entry can name a url (a git+https spec) to install the repository version when the PyPI name is not the tool. A step that does need root (apt) asks for the password through an askpass helper or pkexec and, when nothing can prompt, prints the exact command to run in a terminal: install jobs have no controlling terminal, where a bare sudo can only fail. An install that exits successfully without producing a runnable binary is reported as "still not installed" (status line plus a popup naming the tool), never as a silent success.

  • Roster (bundled manifests): recon/crawl (httpx, subfinder, amass, findomain, katana [+ headless], gau, waybackurls, gobuster, ffuf, feroxbuster), DAST/vuln (nuclei [+ cves/exposures], nikto, dalfox, xsstrike, sqlmap, commix), TLS (testssl, sslyze), secrets/deps (gitleaks, trufflehog, trivy, grype), GraphQL (graphw00f, clairvoyance), WordPress (wpscan), and parameter discovery (arjun active + paramspider archive-mined), plus three subdomain sources that run side by side in the recon chain (subfinder, amass and findomain, so one recon action queries more than one data set; amass writes a progress bar into the same capture as its results, which its manifest picks apart with the regex parser), plus naabu (unprivileged CONNECT port scan of an in-scope host: each open host:port is a finding), masscan (a faster host port scan that needs root/CAP_NET_RAW; naabu is the unprivileged default), and dnsx (DNS records A/AAAA/CNAME for a host). A manifest may declare a stdin template (expanded per run) for a stdin-driven tool like dnsx that reads its target from standard input rather than a flag. New integrations are surveyed and prioritized in docs/audits/OSS_TOOL_INTEGRATION_SURVEY.md.

Scripting and extensibility

  • Extension guide: docs/EXTENDING.md documents the three extension surfaces (the fs.* scripted-check API, transform/generator scripts, and OSS-tool plugin manifests) as the native-extension-API equivalent - all file-based, no rebuild.
  • Extension SDK (packaged, versioned bundles): the extension-API-plus-marketplace analogue. An extension is a self-describing bundle (a directory with an extension.json manifest: id, name, version, author, description, sdk_version, enabled, and its contributions) that Fissure discovers, validates against the host SDK version, and enables or disables (persisted) without editing files. The first bundle contributes checks (fs.* scriptable checks, run wherever user checks run: the GUI scanner, the proxy passive node, the Findings action, AND headless control-API scans, which now load the full check set), panels (a GUI panel an extension owns, its text produced by a render script and drawn with the n_gui owner-draw custom widget, opened from the Extensions manager's "Open panel"), tabs (a top-level view an extension owns, shown inline in the Extensions manager: select an extension and its tabs appear in a picker below the bundle list, the chosen tab's rendered content shown as scrollable, selectable text), and actions (on-demand, request-contextual fs.* scripts run against one request from the context menu's "Extension actions", GET /api/ext-actions + POST /api/ext-action, the ext_actions/ext_action MCP tools, session-aware so fs.send() probes carry the request's cookie on an auth-gated target), and session_actions (on-demand login flows: a script drives the login and Fissure keeps the resulting session, run from the Session-handling rules popup's "Session actions" launcher, GET /api/session-actions + POST /api/session-action, and the session_actions/session_action MCP tools; credentials are injected at run time via fs.params, never baked into the bundle, and each entry declares the fields it expects so the operator does not have to read the script. The captured cookies are INSTALLED into the suite-wide shared jar, not merely displayed, so a scan, the Repeater and manual sends are authenticated afterwards without anyone copying a string; a login whose session is a token instead publishes it with fs.setvar and it comes back as the run's captured values, which a session rule's {{name}} header resolves. Eleven login shapes ship beyond the HTML form: a JSON API login, the OAuth2 password / client-credentials / refresh grants, HTTP Basic, a bearer token the operator already holds, a two-step form login, a form login plus an OTP / 2FA code, an SPA CSRF-cookie login, a GraphQL login mutation and WordPress). A run reports what it DID, not only what it captured: how many requests it made, the status of the last response one received, and the script's own narration, so a login the target REFUSED is distinguishable from one that never reached it, which look identical otherwise and need opposite fixes. The launcher is reachable from the Target view's "Log in" button next to the scan controls and from the command palette, as well as from the Session-handling rules popup it lives in); the manifest is designed so further contribution types add without an SDK bump. A curated set ships enabled: web-hardening (a CSP-content audit and a cross-origin isolation/privacy-header check), secret-radar (provider-specific credential patterns), jwt-exposure (JWTs in responses with a weak property), api-leaks (parses JSON responses with fs.json() and flags leaked stack traces / framework internals / server paths), param-tools (a "Reflected-input probe" context action), active-probes (four on-demand active actions: CORS misconfiguration, open redirect, HTTP method tampering, and IDOR/BOLA), form-login (a CSRF-aware HTML form login session action), json-tools (a JSON pretty-print/minify custom message editor), and codec-tools (four two-way message editors: Base64, URL, hex, and JWT decode/tamper/re-encode). The editors contribution is an interactive custom message editor (a decode script raw->editable and an encode script editable->raw, in the decode-encode model, edited in a standard text area), opened from a request's context menu or the command palette. Managed in the GUI (the Extensions popup), over the control API (GET/POST /api/extensions, GET /api/ext-actions, POST /api/ext-action, GET /api/session-actions, POST /api/session-action, GET /api/editors, POST /api/editor), and via the MCP tools (extensions, extensions_op, ext_actions, ext_action, session_actions, session_action, editors, editor). An offline, signed marketplace lets you browse, install, and remove community bundles from a local catalog (resources/marketplace): a catalog.json with a per-bundle canonical sha256, a detached Ed25519 signature (catalog.json.sig) verified against a bundled trust key (trust.pub), and packaged payloads under store/. Install verifies both the signature and the bundle hash, then copies the bundle into a writable per-user extensions directory the registry also scans; remove deletes that copy. Managed in the Extensions popup's Marketplace section (Install / Remove), GET/POST /api/marketplace, and the marketplace / marketplace_op MCP tools; the bundled catalog ships csp-reportonly (flags a report-only CSP). See docs/14_EXTENSION_SDK.md.
  • Scriptable checks load on every scan surface: the GUI Target scan, the control-API scan job (and therefore the MCP start_scan tool and the recurring scheduler), and the CLI fissure scan all call fissure_scan_load_checks, which loads the *.js scripts under resources/checks/, any .bcheck files, any imported nuclei templates, and the checks contributed by enabled extension bundles. A CLI run that cannot locate resources/checks reports that on stderr and continues with the built-in native checks only, rather than silently auditing with fewer checks.
  • Scriptable checks are scope-checked on their way out: fs.send() and fs.sendraw() refuse a target outside the workspace allowlist and throw inside the script, so the refusal reaches the extension author instead of being silent. The SDK documented this before it was enforced; a script could previously reach any host the process could. The scan, the control-API extension checks, and the ad-hoc POST /api/jscheck route each stage the allowlist for the run. With none staged (a bare unit test, a standalone transform) sending is unrestricted.
  • make webui-check fails when src/fissure_webui.c no longer matches the dashboard HTML it is generated from, so an ungenerated edit is caught rather than shipping a dashboard that silently differs from its source.
  • The injection family is split into selectable sub-families: xss, sqli, ssti, crlf, lfi, cmdi, redirect. One bit used to bundle eight unrelated check kinds, so an operator who wanted only SQLi had to accept XSS, SSTI, CRLF, LFI, cmdi and redirect traffic too; on a fragile target, or a programme that limits probing, the only alternative was turning injection off entirely and losing all of it. Selecting injection still enables every sub-family, so existing profiles, --families flags and saved scans behave exactly as before. The native passive suite is maskable too (passive), so a targeted re-scan can be kept clean instead of re-collecting every header finding. Selectable from the Scan-options popup, --families, the control API and MCP.
  • The scanner retries a fetch that fails for a retryable reason (transport error, 429, 503) and backs off between attempts. One dropped connection used to lose that endpoint from the run permanently while the coverage figure still counted it as audited. After enough consecutive endpoint failures the audit stops and says why, since a target that is down or refusing the scan turns retrying into a long pointless hammering.
  • Nested and encoded insertion points: a parameter carrying a base64 blob or a JSON document is opened and probed INSIDE, instead of being opaque. A flat probe put its payload in the wrapper, so the application decoded the parameter and the injection landed somewhere it never reads: the scan came back clean on a genuinely vulnerable field. The payload is re-wrapped at the single placement seam every check goes through, so XSS, SQLi, LFI, SSTI, cmdi, OAST and SSRF all work nested without knowing they are. Findings name where they landed ("base64-wrapped JSON field 2 of parameter 'data'"). Applied to query parameters and to JSON body leaves, which is where encoded blobs actually turn up (tokens, "state" fields). Bounded deliberately: one level only, a size cap on what a decode may expand to, a cap on positions probed per blob, and a base64 SHAPE test so ordinary words are not opened (the decoder is permissive enough that "hello" decodes to printable noise, which would have roughly doubled the traffic a scan puts on normal parameters).
  • Static assets are excluded from the active audit and from the coverage figure. An image, font or stylesheet has no server-side interpreter behind it, so probing it spent the scan's budget for nothing and, worse, counted toward coverage: a run that probed 400 sprites and 3 endpoints reported 403 audited. Passive analysis still runs on them, since headers and secrets matter on a stylesheet too. The content type decides when known and the path extension is the fallback; only the path is examined, so /view?file=logo.png keeps its insertion point, and JavaScript is deliberately still audited.
  • Form probes fill the fields they are not testing with a plausible value chosen from the field name, not the literal "1". A form that validates server-side used to reject the whole submission, so the payload never reached its sink and the check reported nothing, which reads as a clean result rather than a bounced request. The filler values are inert and obviously synthetic.
  • Live active auditing over proxy traffic: with it armed, every endpoint the proxy observes is actively audited once, using the request that was actually made, so the probes carry the real session, headers and body. That covers surface a crawl cannot reach: a flow behind a multi-step wizard, a form that only appears after a state change, an endpoint only the application's own JavaScript calls. Parameter VALUES collapse and NAMES are kept, so paging /item?id=1..500 audits once while /item?q=x is treated as new surface. OFF by default, because unlike passive analysis it generates traffic; the scope allowlist, the aggressive toggle and the authorization banner apply exactly as they do to a scan. Its probes appear in the cross-tool Logger tagged scanner, so traffic it sends is never invisible. Driven from the Proxy view's "Live audit" toggle, which warns on arm that it sends traffic and whose label carries the audited count; the probes run on their own worker thread rather than a per-frame tick, since one endpoint can mean dozens of requests. Headless parity: POST /api/liveaudit and the liveaudit MCP tool.
  • The cross-tool Logger keeps the bytes. Each record retains the request and response it carried, so the one view that spans every tool (proxy, Repeater, Intruder, scanner, discover) can show what the traffic actually was instead of only that it happened. Selecting a row fills a two-pane request/response detail, and "To Repeater" loads the record's request for editing and resending. Messages are capped per record and a clipped one is flagged, so a truncated body is never presented as complete evidence. Headless parity: POST /api/traffic/detail and the traffic_detail MCP tool.
  • Third-party extension bundles: a bundle nobody signed can be installed deliberately, where previously only the signed first-party catalog could install anything. A distributable bundle is one JSON document (manifest plus scripts, no archive dependency); "Install file" in the Extensions manager inspects it and names what it contributes ("2 checks, 1 request hook") before asking, and the API refuses without an explicit accept_unsigned. That gate is substantive: an unsigned bundle's checks send traffic to the target, its request hooks rewrite every request the proxy forwards, and it persists state. The id, the SDK version and every file path are validated before anything is written, an existing install is never overwritten, and a new bundle lands DISABLED. Packing an installed bundle back into a file is the other half, so anyone can hand one to someone else. Headless parity: POST /api/extensions/bundle and the extension_bundle MCP tool.
  • Per-extension isolation and persisted state. Each extension's scripts run in their own QuickJS context (separate globals, one shared runtime, so isolation costs a context rather than a runtime per bundle), and fs.store (get/set/remove/keys) gives it a capped key/value space stored per project under <project>/extstate/<id>.json. Before, every script shared one global object and enabled/disabled was the only thing an extension could remember between runs, which ruled out anything comparing this run to the last. Headless parity: POST /api/extensions/state and the extension_state MCP tool. Ships a reference bundle, "State demo", that counts responses seen across runs and restarts.
  • Extension request hooks: a bundle contributes request_hooks ({"title","run"} entries) whose scripts rewrite every request the proxy forwards, on its way out. This is the most common extension category and the SDK previously could not express it at all, since checks only observe and actions only run on demand. The script sees the raw request as request and returns its replacement, or defines mutate(request); returning nothing or the input unchanged leaves it alone. Hooks from all enabled bundles chain in registry order, so two bundles can both stamp one request. A throwing hook is logged and leaves the request untouched. Attaching hooks logs a NOTICE naming how many are active, since they rewrite ALL forwarded traffic. Ships with a reference bundle, "Request stamping" (disabled by default): one hook stamps a correlation header so an authorized test is identifiable in the target's own logs, the other refreshes an Authorization bearer from fs.params so a long crawl does not die on an expired token.
  • async / await work in scriptable checks. QuickJS queues each await continuation as a pending job, and the engine now drains that queue after the script returns, so an async check runs to completion and the findings it reports in a continuation are collected. Before, an async check silently did nothing past its first await and raised no error either. A rejected job logs its exception rather than vanishing, and the drain is bounded so a promise loop cannot spin inside one check.
  • Import checks popup (Power-ups toolbar group, and the command palette): the native GUI entry point for all three offline template compilers. Pick the source format (BCheck, nuclei or Jaeles), paste the template or load it from a file, Compile to review the generated check plus its name, description and any clauses the compiler had to skip, then Install to write it into the per-user checks directory. Previously the three compilers were reachable only over the control API, the MCP bridge and the browser dashboard, and the in-app help pointed the operator at the dashboard to use them.
  • In-message find: a "Find" button in the Repeater, the Proxy view and the Findings view searches the message on screen, and Ctrl+F / Ctrl+G (plus the command palette) do the same from the keyboard. It searches the Repeater's highlighted and rendered response views, the selected proxy flow's response pane, and the Findings detail pane. The match is selected and scrolled into view, the search is case-insensitive and wraps once, and a miss says so instead of leaving the view where it was. A response is routinely tens of kilobytes with the interesting token one line in the middle, so scrolling was previously the only way to reach it, and the dialog itself was previously reachable only from a key.
  • Global Search reads response bodies. Its field vocabulary gains body alongside host, method, path, url, status and mime, so body contains "api_key" finds the flow that leaked a secret rather than only the ones whose URL says so. Bodies are fetched only when the query mentions body, since pulling every body for an unrelated query would crawl through the whole capture history.
  • Global Search results are links, and the list filters as you type. Picking a result row, or selecting it and pressing the new "Go to" button, switches to the view that owns the record (Proxy for a captured flow, Findings for a finding), selects it there so that view loads its request/response or finding detail, and closes the popup, so a hit leads somewhere instead of being a line of text to retype. Each row carries the record's identity in a hidden column, so the jump survives sorting the results by any header. The jump is the owning view's own reveal entry point, not a walk of that view's widgets, so when the destination's filter bar hides the record that view clears its filter bar and says so (status line plus an info popup) instead of leaving the operator on a view that appears not to hold their hit; a record the owning store no longer holds is reported the same way instead of switching views. Typing in the query box also re-runs the search live, so the result list narrows keystroke by keystroke; a half-typed query is reported as incomplete rather than clearing the list, and a body query still waits for the Search button because it reads every captured response.
  • fissure api <METHOD> <ROUTE> [json-body]: call any control-API route in process, with no server to start, no token to pass and no port to pick. The CLI had three subcommands against roughly 170 route pairs, so almost everything the GUI and the MCP bridge can do was out of reach from a shell script, even though the in-process dispatcher already existed and the GUI already used it. The body can be a positional argument or --data-file <path> (- for stdin). The exit code is the result, so a script can branch without parsing JSON: 0 on a 2xx, 1 on any other status or an unrouted path, 2 on a usage error. A non-2xx reply is still printed, so the error body is visible.
  • GET /api/status is answered by the in-process dispatcher as well as the server. It was the one route every client uses as a liveness check and the one route an in-process caller could not reach.
  • fissure -h prints one authoritative usage block, shared with the subcommand help rather than kept as a second hand-maintained copy. The copy had drifted: it omitted serve entirely, omitted the burp report format, and listed 2 of the 22 scan flags.
  • The Intruder attacks a FULL request, not just a URL. POST /api/intruder and the MCP intruder tool take method, headers and body alongside the URL template, and a payload marker may sit in any of them. Previously the engine hardcoded a GET and sent no headers and no body, so it could not brute-force a login form, credential-stuff, fuzz a JSON API body, or fuzz a header or cookie: the audit called this the largest single gap against Burp and Caido. The parts are joined into one template before fan-out, so every attack mode gains this at once, and cluster bomb and pitchfork pair positions ACROSS parts (a role header against a username body field, for example). Each result records the request as it went on the wire.
  • The Intruder view carries Method, Headers and Body fields beside the URL template, so a full-request attack is driven from the GUI and not only headlessly; leaving them empty keeps the original GET-to-a-URL behaviour. Environment {{variables}} are expanded in the header block and body exactly as they are in the URL.
  • "Send to Intruder" from a request's right-click menu now carries the whole captured request. It previously passed only the URL, so an attack on a login form had to be retyped from the capture, which is the step where a Content-Type or a session cookie goes missing and the attack silently tests nothing.
  • Analyst judgement is recordable headlessly: POST /api/finding/annotate and the MCP finding_annotate tool set a finding's notes, tags and triage state. The GUI Findings view could write all three and the API could write none, so an agent could raise findings but never record why one matters, what it was grouped under, or whether it survived review. An unrecognised triage label is refused rather than silently treated as open.
  • Clickjacking proof-of-concept over the API: POST /api/clickjack-poc and MCP clickjack_poc build the framing page, closing the asymmetry where the CSRF PoC had a route and its sibling did not.
  • Auto-replay rules headlessly: GET/POST /api/autorepeater and the MCP autorepeater tool manage the same ruleset the GUI popup does, persisted to the same file. 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 finds broken access control across a whole browsing session without replaying by hand.
  • Report view "Save session" / "Open session": write the findings and the captures behind them to a session file you choose, and merge a saved one back in. Sessions were only ever written by automatic per-project persistence, so archiving an engagement under a chosen name, handing one to a colleague, or reloading one later was possible over the control API but not from the GUI. A save whose captures could not be archived says so, because the reloaded findings would otherwise have no evidence behind them.
  • HTTP/3 popup "Smuggle probe": drives POST /api/http3-smuggle, which had no GUI caller. It probes for a desync where the front end speaks HTTP/3 to the client and HTTP/1.1 upstream, so the two disagree about where a request ends in a version the origin never sees.
  • OAST popup "Deser marker (DNS)": the deserialization-marker builder only ever produced the HTTP-callback variant, leaving the DNS platform unreachable from the GUI. Both channels now have a button, because a sink behind egress filtering that blocks outbound HTTP can still resolve a name, so a sink that looks dead over HTTP can still be proven over DNS.
  • Multitool "WAF encode": encode the input through any of the 13 WAF-bypass encoders as a named chain. The transform list exposes four of them as fixed entries; the other nine were reachable only as a scan-wide setting, so a single payload could not be tried against the filter to see what it accepts. An unknown encoder name is reported rather than silently ignored, and the run records the code-of-conduct notice like every other control-bypass feature.
  • Recon seeded from the Target view now reaches the persistent asset store, so seeded hosts appear in the Dashboard's new / changed / gone diff. Seeding previously populated only the site map, which left GUI-driven recon invisible to the very diff that exists to track it, while the same text posted to /api/assets was not.
  • Probes popup (Recon & infra toolbar group, and the command palette): host-level probes and page capture for one target, in one place. "Find origin IP" tests candidate addresses as the real origin behind a CDN or WAF; "Detect WAF" fingerprints the filter in front of the app from its headers and block pages; "Screenshot" renders the page in a headless browser as report evidence, with "List captures" and "Open" to review them. All four (/api/originip, /api/wafdetect, /api/screenshot, GET /api/screenshots) previously had no GUI entry point at all. Each probe runs on a worker with a spinner, a negative result says what it does and does not prove, and origin-IP discovery explains where candidate addresses come from rather than just refusing an empty field.
  • Jobs monitor "Show findings": select a job and read what that run produced, instead of hunting through the whole findings store to work out which finding came from which job. It drives GET /api/jobs/{id}/findings, which previously had no GUI caller at all, and distinguishes a job that found nothing from one that is still running rather than showing an empty list for both.
  • Per-user checks directory (<config>/checks): a writable home for imported or hand-written .js checks, loaded by every path that loads the shipped resources/checks (scans on all three surfaces, the GUI proxy's live passive audit, the headless passive audit, and the Findings "Run scripts" action). The install tree is read-only on a packaged build, so without this an imported check could not run at all on an AppImage or a deb install.
  • BCheck importer: drop .bcheck files into resources/checks/ and Fissure compiles them (metadata + given/send/if-condition/report) into an equivalent QuickJS check that runs in the scan and proxy passes, so a slice of the public BCheck library runs unchanged. Response conditions combined by and/or, the contains/matches/is/starts-with/ends-with operators (with does not/is not negation) on the body, headers, or status, the in operator (which puts the needle FIRST: "root:" in {latest.response.body} is the same condition as {latest.response.body} contains "root:", and inside a for each block "X" in {loopvar} asks which value the loop is on), a status compared by regex ({latest.response.status_code} matches "40(1|3)"), to_lower() around a response reference (the comparisons are case-SENSITIVE, so the fold changes what matches), regex_replace() (nested calls lowered innermost-first, over the request URL or its path, a canary, a marker or an earlier call), conditions that WRAP ACROSS LINES (gathered until their then, with the and/or precedence they were written with preserved), the block form of run for each: and its loop variable inside a step field, the out-of-band Collaborator idiom ({generate_collaborator_address()} mints a canary from Fissure's own OAST collector and http/dns/smtp/any interactions asks whether it was called back, WAITING for a window rather than answering "not yet"; the confirm-then-deny shape that sends a deliberately broken variant and requires no callback works because the second payload is really sent and the negative question really waits), nested if ... end if blocks ANDed as the nesting means (an else branch is refused instead, being an alternative rather than a requirement), a define: variable as a condition needle and {random_str(N)} as a per-run marker (fixed text would match a previous run's reflection still sitting in a cache), a {base.response} that is its OWN response (the target with no payload in it, actually sent, rather than an alias for the latest one, which would collapse the marker idiom into a condition that can never be true), and a for each loop over an inline payload list or a defined variable (<name> = [ ... ]) all compile. Multi-step checks compile too: each send request called <name> step is sent and its response captured, and a condition tests the response it names ({first.response.body}, {latest.response.status_code}); a condition value can reference another response's field ({first.response.headers}) for a cross-response comparison (a variable pipeline). Per-step request customization is modeled: a step's method/path/body/headers fields (with replacing/adding prefixes, values in backticks) compile into that step's own fs.send (the path is resolved against the target origin), so each step issues its own request instead of re-sending the probe; a multi-step check with no such fields is still noted as a pure re-send. Constructs still outside the shape (unresolved variable conditions) are skipped and reported (the skipped field of POST /api/bcheck / the bcheck MCP tool), not silently dropped. A document that names the OBSERVED request ({base.request.headers} / .body / .method) and sends nothing of its own is compiled as a PASSIVE check and run over recorded proxy traffic, where fs.request() is lent the exchange the proxy saw: it carries no fs.active gate and makes no request of its own, so a check about "the request as it was" reads the real one instead of the scanner's. A document whose given clause names an INSERTION POINT places its payload into each query parameter the target actually has, one at a time, rather than appending a parameter of the check's own invention (which tests an input the application very likely ignores, and misses any sink that reads one specific parameter); a URL with no parameters falls back to appending one. A document whose REQUEST field still holds an interpolation the importer could not resolve is refused rather than compiled: a check that sends a literal {name} matches nothing and reports nothing, which reads exactly like a clean result. A define: written in terms of itself (a = "{a}z") is one such unresolved interpolation and is refused the same way, rather than expanded: substituting it used to restart the search at the head of the text every pass, so the reference just inserted was found again and the parse grew the buffer forever without returning. A chain of defines that each repeat the one before, the entity-expansion bomb, stops at a size cap and says so. Both matter because an imported document is untrusted input and the importer is reachable over the control API and the bcheck MCP tool: a 129-byte file used to hold the parse indefinitely. The fuzz campaign found it (tests/fuzz/corpus/bcheck/selfref-define-hang.bcheck keeps it). A finding from a document that replaces the PATH is HOST-scoped, since a fixed-path discovery check describes the host rather than each page the crawl reached (one that fuzzes an insertion point stays URL-scoped, because there the URL is the finding), and its report text has the document's own backticks stripped and any interpolation that could not be resolved dropped rather than printed.
  • Nuclei-template importer (offline): drop nuclei .yaml/.yml templates into resources/checks/ and Fissure compiles the supported shape, one or more http requests, each with a method, {{BaseURL}} paths, and word/regex/status/size/xpath/binary matchers plus dsl expressions, combined by matchers-condition, into an equivalent QuickJS check that runs once per host, no nuclei binary required. The dsl is compiled by a parser for nuclei's expression language, not matched against a fixed set of shapes, so grouping parentheses, the full operator set, nested calls, the helper-function library (contains/contains_all/regex/len/to_lower/compare_versions/ md5/sha1/sha256/base64/base64_py/hex_encode/url_encode/mmh3/word_count and the rest) and the response variables all work, including any response header under its snake_case name (set_cookie, location, server), duration in seconds, and the suffixed forms naming an earlier request's response (body_2, status_code_1). A variables: block gives a template its own named values, referenced as {{name}} or by bare name. A matcher's part: reads the same vocabulary: body, header, all / response, raw (the whole response, status line included), one response header by name (part: location), and an earlier request's response (part: body_2). Measured over the 10,970-template upstream http corpus, this took the templates that compile with nothing skipped from 69% to 92%, and every emitted script is checked to parse under the same QuickJS engine that runs it. Multi-request templates emit one probe block per request. A binary matcher searches for a hex byte sequence in the raw response body via the binary-safe fs.bodyhex() primitive (a byte-aligned hex search, so an embedded NUL a UTF-8 string body would drop is still matched); an xpath matcher selects a node in the HTML/XML body via the libxml2-backed fs.xpath(). The importer also compiles:
    • interactsh out-of-band matchers (part: interactsh_protocol) and the {{interactsh-url}} placeholder: the check mints an OAST canary (the engine's fs.oast()), injects its URL where the template asks, and confirms the finding when the canary is hit (fs.oast_seen() / fs.oast_wait()), so blind SSRF/RCE templates work; a DNS or SMTP canary needs a delegated domain, and a collector started with just a port falls back to the channel-agnostic canary rather than handing the check an empty address it would plant and never see;
    • regex, kval (response-header), json (dotted-path), and xpath (HTML/XML node) extractors: when the matchers fire, each runs against its part and appends its captured value (named) to the finding evidence, so a match reports the leaked value, not just "matched"; an internal: true extractor is exported as a chaining variable that this request's OWN dsl matchers read by bare name and a later request references by {{name}} (request-to-request chaining);
    • xpath matchers: an XPath expression that must select a node in the HTML/XML body (compiled to fs.xpath(body, expr).length > 0, backed by a libxml2 XPath engine installed into the QuickJS runtime through an injectable seam so libxml2 stays out of the unit-test link);
    • payload sets in both shapes. With a fuzzing: block the template is a DAST one and each rule compiles as written: part (query, path, header, cookie), type (replace/prefix/postfix), mode (single/multiple) and keys, injecting into the live request being audited. Without one, the sets fill the {{name}} placeholders in the template's OWN path, raw request or body, combined the way attack: says (batteringram, pitchfork, clusterbomb), under a send budget so a combinatorial run stays a check; that is the shape a default-credential template has, and treating it as a query injection instead tested something the template never asked for. A set may name a wordlist rather than list its values, resolved relative to the directory the templates came from and never outside it;
    • raw-request templates (raw:): the verbatim request block (request line, headers, body) is reconstructed and sent byte-for-byte via the fs.sendraw() primitive, with the {{Hostname}}/{{Host}}/{{Port}} placeholders resolved from the target origin, so a template that hand-crafts an odd request (malformed method, duplicate header, explicit Content-Length) runs without the nuclei binary; the matchers evaluate the parsed response as usual;
    • method+path requests carry their body (inline or a body: | block) and headers map, so a PUT/POST template actually uploads or sends them (previously the request body and headers were dropped, which silently neutered an upload- or write-based template);
    • a multi-request CHAIN runs every step in order, including a SETUP step that has a body or headers but NO matchers (a PUT that uploads a web shell, a login): it is fired for its side effect before the later matching request instead of being dropped, which is what lets a two-step template like Tomcat PUT-then-GET RCE (CVE-2017-12615) detect. A request with extractors and no matchers compiles as a harvester, but only in a single-request template: capturing something is itself the finding there, while the same shape inside a chain is a step feeding later requests and must not report. A matcher marked internal: true is likewise a condition rather than a finding, so a chain's steps gate the report instead of each producing one, and a request that gets no response leaves the chain unproven. A matcher that cannot be compiled refuses its whole request when the set is ANDed (the survivors would fire on less than the template asked for) and is simply dropped when it is ORed (that only narrows the condition). Nuclei WORKFLOW documents are imported as tag GATES: a workflow names a detection template and the tags it makes relevant, so dropping one in the checks directory holds every check carrying a gated tag back until that detector has reported for a host (per host, never globally). That is what stops a scan probing for a stack the target does not run. A gate whose detector template is not loaded is ignored rather than honoured, so a missing file cannot silently become missing coverage, and a scan that held checks back says so in a "Scan coverage" finding instead of looking clean. Features still outside the shape (the target's resolved IP and the text of an out-of-band interaction, workflows) are skipped and reported (the skipped field); a template with nothing usable is refused, as is a self-contained one, whose paths name a fixed external host instead of the target. Also exposed as POST /api/nuclei and the MCP tool nuclei_import.
  • Jaeles-signature importer (offline): the third format compiler, alongside the nuclei and BCheck importers. It compiles a Jaeles detection-signature YAML (id, an info name/risk, optional variables, and a requests list) into an equivalent QuickJS check, no jaeles binary required. EVERY request in the list is compiled (method/url/ headers/body, {{.BaseURL}} resolved to the target origin): the requests are sent in order and the signature reports when ANY detection-bearing request matched. Several requests in one signature are alternatives to TRY, not conditions to AND: measured over the upstream corpus, 21 of its 61 multi-request signatures repeat one request with the SAME detections and only the headers changed, where the second exists precisely for the case the first is refused, and the rest are alternative endpoints or payload variants for one bug. A request carrying NO detections is not a condition either: it is a step that exists for its SIDE EFFECT (write a webshell, then read it back; enable a template engine, then use it), so it is sent in order and contributes nothing to the verdict, and a failed setup step cannot masquerade as a finding. The report quotes the first response that matched. A top-level origin: request is a BASELINE, pointed at a path that should not exist, so a target that answers everything with the same page (a soft 404) can be told from a real hit: it is sent once before the requests and the detections compare against it (Diff(), OriginContentLength(), OriginStatusCode(), CommonError(), Math.abs() over a length difference, and the oresponse/oresHeaders search targets). An origin-dependent detection in a signature that declares no origin is refused rather than compiled into a comparison of the response with itself. A variables block is resolved, so {{.name}} in a url/body/header/detection substitutes before compiling: literal name/value pairs substitute their text, and the RandomString(n)/RandomNumber generators become a fresh per-run value (so a random-marker reflection signature works). A variable whose value is a block scalar or an inline sequence is not one value but the LIST of values to TRY, which is how most of the upstream corpus names its paths: the request that references it is sent once per value and it MATCHED if any value did (requiring all of them would be the opposite of what the signature says), several list variables in one request expand as a product, and the loops stop at the first value that matched so the report quotes the response that matched. A list is capped at 256 values and a run at 512 sends, with the truncation reported in skipped: a signature that walks 1240 paths (the corpus has one) is content discovery, not a check. Expanding these took the upstream corpus from 150 of 373 signatures to 299. The detections expressions compile to response tests: the StatusCode() and ContentLength() helpers as numeric comparisons, StringSearch(component, "text") as a case-insensitive contains, and RegexSearch(component, "regex"), over the components component.response / component.body / component.header, combined with && / || / !. A type: passive signature (or a top-level detections: block) compiles to a passive check that evaluates against the current response without sending. A detection using an unsupported helper is dropped and recorded, and generator-function variables, request middlewares/ chaining, and a truncated value list are reported in the skipped field (a signature with no compilable detection is refused). headers: is a YAML sequence of one-key maps and its item marker is not part of the header name: a signature that adds a header to change what the target returns (the spoofed-IP variants the corpus uses to reach a restricted page) now sends X-Forwarded-For rather than - X-Forwarded-For. Also exposed as POST /api/jaeles and the MCP tool jaeles_import; run the emitted check via POST /api/jscheck.
  • In-app convert-transform scripting (QuickJS) in the Multitool.
  • User scripts: passive hooks over traffic and active scripts run against a request (from the context menu), reporting into the findings store.
  • Authorization matrix (Auth Analyzer): replay a request under N named identities (each a header/cookie block) to find broken access control, with a per-identity BYPASSED/ENFORCED verdict grid. An optional parameter-extraction rule pulls a CSRF token or nonce from the baseline response (regex capture / response header / JSON key) and substitutes {{name}} into each replay so guarded flows stay valid. Scope-gated; identities/extraction edited in the Auth-matrix popup, persisted to authmatrix.json; run from an "Auth matrix" context-menu action.
  • Auto-replay (AutoRepeater): condition-matched request mutation with a diff log. A rule has boolean conditions (host/method/scheme/ext/url/source), a base replacement (keep the request valid), and a test replacement (the mutation); right-click a request and choose Auto-replay to resend one mutant per matching rule on a worker thread and diff each response against a fresh baseline (status/length/similarity), with a log row you can open in the Repeater. Scope- gated; rules edited in the Auto-replay popup, persisted to autorepeater.json. A disabled starter rule ships on first run, and a "Restore defaults" button in the popup replaces the current set with it.
  • Authentication check ("Test authentication" in the Parameters popup, POST /api/auth/check, the MCP auth_check tool, and fissure scan --auth-check <url>): runs whichever authentication route is configured (a login config, the parameter jar's crawl-priming POSTs, or an existing cookie session) exactly once and reports whether it actually works, without running a scan. The verdict comes from a comparison, not a status code: the URL is fetched with and without the session and the two responses compared, which is the only way to separate "the session works" from "that page is public" from "the session has no effect". Verdicts are ok, failed, inconclusive, none (nothing configured, a scan would run anonymous) and error (the target could not be reached, which is not a verdict about the session). Pointed at a public page it deliberately returns inconclusive rather than a false pass. This exists because the alternative is running a full scan and inferring from the findings, and a scan that never authenticated reports what an anonymous visitor sees, which reads like a clean target rather than a failed run.
  • Request-parameter jar ("Parameters", from the Target view or the command palette): the cookie jar's counterpart for a session that lives in a request PARAMETER rather than a cookie. Each row pairs a name with a value and six toggles: On, Query, Body (merged into a urlencoded, JSON or multipart body, whichever the request uses), Track (replace the value whenever a response supersedes it, from a hidden form field, a JSON member or a redirect Location - this is what makes a rotating anti-CSRF token survive a whole run), No fuzz (keep the audit from mutating a session value, which would log the scan out and manufacture false findings), and Required (skip a request rather than send it unauthenticated). An optional per-row refresh URL re-reads a token that is bound to one form rather than to the session. A jar row only ever FILLS IN what a request does not already set, so an active check fuzzing a parameter always beats a jar row of the same name. Which tools carry the jar is a per-project choice (Scan, Repeater, Intruder). Two separate crawl-write options sit alongside it, both off by default. Submit discovered forms makes the crawl SUBMIT the forms it finds rather than only record them, reaching pages that only exist after a submission; it needs the aggressive toggle as well, and the crawler still refuses a logout form (it would end the session mid-crawl), a file upload, and any form whose action or controls look destructive (delete, remove, reset, revoke and the like), submitting each form action once however many pages carry it. The A priming-authenticated crawl also keeps its session: a 401 (or a session rule, or a logout marker) re-runs the priming POSTs and retries the request, serialized across audit workers, counted, and capped per run so a target that 401s anonymous resources cannot turn the crawl into a login flood. 403 does not trigger it, since that means authenticated-but-forbidden. The crawl-priming option additionally POSTs a declared list of URLs before a crawl starts, so a session behind a login form is established before any page is fetched - that WRITES to the target and says so in a warning popup before it is enabled. A row that is both Track and Required serializes jar-carrying sends, because a single-use token consumed by one audit worker would otherwise be stale for every other worker; the status line says when that is in effect, since it slows a scan. Values are never sent to an out-of-scope host, never enter the canonical URL the site map dedups on, and are redacted out of finding evidence before a report can publish them. Applies on HTTP/1.1, HTTP/2 and HTTP/3. Saved to <project>/paramjar.json, and process-global so the GUI, the control API and the CLI all edit one jar. Reachable on every surface: the Parameters popup, GET/POST /api/paramjar, the MCP paramjar and paramjar_op tools, a Parameters tab in the browser dashboard, and the CLI flags --param name=value with --param-in query|body, --param-track and --crawl-post-url.
  • Suite-wide shared cookie jar: one cookie store consulted by the Repeater, the scanner, and manual sends, so a cookie captured by one tool is reused by the others and the engine sends matching cookies and absorbs Set-Cookie automatically. A Target-view scan with no login config uses it too (exactly as a control-API/MCP scan does), so a session already captured by the proxy or the Repeater authenticates the crawl and the audit instead of them running logged out; a scan that does have a login config still gets a private, freshly replayed session jar so its login state is never mixed with the shared one. Domain/path/secure aware (Nilorea n_cookiejar), thread-safe across scan workers. Viewed and edited in the "Cookie jar" popup (Auth & session category, command palette, list/set/delete/clear/import), over the control API (GET/POST /api/cookiejar), and the MCP cookiejar tool; persisted to <config>/cookiejar.json so a session survives a restart. One cookie can be removed on its own ("Delete cookie" on the selected row, {"op":"remove","name",...} over the API and MCP): a stale session id or a cookie the target keeps re-setting goes away without clearing the jar and losing the login with it. The delete names the cookie in a confirmation before it drops it. The Repeater's cookie count and Clear button act on this jar.
  • Proxy session capture: the shortest route to an authenticated run. The intercepting proxy watches the operator's own logged-in browsing, and with "Capture cookies" on (the Proxy view toggle, capture_cookies on POST /api/proxy/start and the MCP proxy_start tool, persisted in settings) it folds what it sees into the shared cookie jar: every in-scope response's Set-Cookie, and every request's Cookie header, which is the only way a session established BEFORE the proxy was attached ever gets in. Browse the target logged in, then scan: the crawl and the audit carry the session with no login config, no session action and nothing to copy by hand. Scope-gated so unrelated browsing does not fill the jar, and off by default because it changes what every later tool sends.
  • OAuth2 authorization-code with PKCE, end to end. The password, client-credentials and refresh grants ship as session actions because credentials alone drive them; the authorization-code flow does not, since it needs a browser for the consent screen and a redirect to carry the code back. POST /api/oauth-pkce and the MCP oauth_pkce tool mint the verifier and a state, build the authorize URL with the S256 challenge, drive it through the browser login (so the credentials go into the provider's own form), read the code out of where the browser landed, and exchange it at the token endpoint carrying the verifier; a confidential client's secret goes as HTTP Basic as RFC 6749 asks. A code whose state does not match the one sent is refused, which is what the state parameter is for. Attaching to a running browser lets a person clear an MFA or consent step themselves. The result is a token rather than a cookie, so nothing is installed in the jar: it is sent as an Authorization header.
  • Browser-driven login: the login class a script cannot perform at all. A nonce computed by page JavaScript, a captcha or hardware key only a person can answer, and an SSO hand-off that walks several origins before dropping a cookie on the one under test are all out of reach of fs.send, and were simply not automatable. fissure_browserlogin drives a real Chromium over CDP instead: it opens the login page, fills the CSS selectors it is given (through the native property setter plus input and change events, which is what a framework-managed form actually listens for), clicks submit, waits, and harvests the browser's cookies for the target host into the shared jar, so the scanner, the Repeater and manual sends carry the session afterwards. Only the target's cookies are taken, never the identity provider's. Given a success marker it reports whether the login genuinely succeeded, which cookies alone never prove. Attaching to a browser already running (a DevTools port) is the second mode: the operator completes the login by hand in their own window and this harvests when they are done, which is the only route past a captcha. Reachable from "Browser login" in the Session-handling rules popup, POST /api/browserlogin and the MCP browserlogin tool.
  • Copy-as-cURL import: turn a browser's "Copy as cURL" into a request. Right-clicking a request in a browser's network tab is how an operator gets a REAL, already-authenticated request into a tool, complete with the session cookie, the CSRF header and the exact body the application expects, none of which a crawl reliably reconstructs. "From cURL" in the Repeater loads the method, URL, headers and body into the tab; POST /api/curlimport and the MCP curlimport tool return the same parts for an agent to feed to send_request, the Intruder or any check. It reads what the browsers emit (-X, -H, -b folded into a Cookie header, the -d family, --url, backslash continuations and single, double or $'...' quoting) and ignores the transport switches that say nothing about the request; the method is POST when there is a body and no -X, as curl does. It parses and sends nothing, and refuses text with no absolute scheme://host URL rather than treating a stray word as the target.
  • One session, every entry point. The suite-wide jar is loaded at startup and saved at exit by all three of them: the GUI, the control server, and the CLI. So a session established anywhere is usable everywhere without copying a string: capture it by browsing through the proxy, paste it into the Cookie-jar popup, or let a session action install it, then fissure scan picks it up with no arguments at all. fissure scan --cookie "PHPSESSID=abc; security=low" seeds it directly for a one-shot run and accepts the same shapes the popup and the route do (a Cookie: header line, a whole copy-as-cURL command); text with no cookie in it is refused with exit 2 rather than scanning anonymously.
  • Pasted-session import: hand Fissure the cookie the browser already has instead of retyping it a field at a time. The Cookie-jar popup carries a paste box and a site field, POST /api/cookiejar {"op":"import","cookie":...,"domain":...} is the headless form (it replies with imported: N), and the MCP cookiejar tool takes the same cookie argument. It accepts the shapes a browser actually produces: a bare name=value; name2=value2 (what document.cookie returns and what the Cookie request header carries), the same with a leading Cookie: or Set-Cookie: header name (a Set-Cookie: line keeps its own Domain/Path/Secure/expiry), several lines pasted at once, and a whole copy-as-cURL command, of which only the cookie option is read so the URL and the other headers never become cookies. The site is a bare host, a host:port, or a full page URL, and an https URL marks the imported cookies Secure so they are not replayed in clear. Text with nothing cookie-shaped in it is refused on screen rather than imported as nothing.
  • Session-handling rules: a scope-gated automation engine that keeps long runs authenticated. An "always" rule injects/replaces request headers before every matching send with {{token}} placeholders resolved from the login's captured variables; an "on-status" rule re-runs the login and retries the request on a status (e.g. 401). A content trigger complements the status rule for the common redirect-to-login logout (a 200 login page): the login config's reauth_on_contains marker re-runs the login when a response contains it (see Mid-scan re-authentication above). Applied uniformly by the request engine through the config, edited in the Session popup, persisted to sessrules.json. Two disabled starter templates (re-auth on 401, CSRF-token header) ship on first run, and a "Restore defaults" button in the popup replaces the current set with them.
  • Login / macro recorder: build a replayable login config from captured traffic instead of hand-writing one. Multi-select the login-sequence flows in the Proxy and Record login: each becomes a step, and a CSRF-style token (a request value that also appears in an earlier response) becomes a regex extract plus a {{name}} substitution so a fresh token is re-derived on replay, while credentials stay literal. The result is the login-config schema the CLI (--login), the scan routes, and the session rules already consume; saved to <config>/logins/. Headless: POST /api/macro/record {exchanges} and the record_login MCP tool return the config ready to feed to a scan.
  • Environments: reusable variables substituted into requests; on first run a project is seeded with a default environment (host, base_url, token, cookie slots), with a "Restore defaults" button and a reset op on POST /api/env / env_op("reset"). Deleting an environment, deleting a variable, and restoring the defaults each ask first through the shared confirm dialog, naming the environment or variable (and, for the restore, how many environments and variables it replaces). The variable grid resolves a clicked row from that row's own Key/Value cells, so sorting it by Key or Value cannot make an edit or a removal land on a different variable, and setting or removing one keeps the list where the operator had scrolled it.
  • Projects (workspaces): named project containers with a switcher; per-project persistence of findings, inventory, proxy history, Repeater tabs, attack configs, environments, organizer, and match-replace. Switching saves the leaving project's data under its own files BEFORE the active project flips (so it cannot land in the incoming project and clobber it), then reloads every store for the new one. Two deliberate exceptions, stated in the switch confirmation: a RUNNING proxy keeps writing to the project it was started under until it is restarted, and a RUNNING scan keeps its project until it finishes, because moving live capture or audit traffic mid-flight would split one engagement's data across two workspaces. Stop either first if the switch should take effect immediately. A new project starts empty rather than inheriting the previous one's data. tests/test_project_stores pins the round-trip and the isolation: each of the four workspaces (Repeater tabs, proxy history, findings, Target inventory) is written with distinct data under two projects, and each project must still see only its own after switching back and forth.
  • Team collaboration (shared project): a lightweight multi-operator coordination layer over a shared project so several operators (or agents) working one Fissure instance do not collide. A member roster (each member gets an identity token so actions attribute to a real person), presence (a heartbeat marks who is online), advisory locks (a member claims a resource - a host, a finding, a scan - and teammates see the holder; locks time out so a crashed client cannot wedge a resource), resource assignments (ownership), and a bounded activity feed (who did what, when). Members can be added (mints their identity token) and removed (revokes the token and drops their locks/assignments); in the "Team" popup, select a member and press Remove (confirmed), or type the name. Persisted per project to team.json. Driven from the "Team" toolbar popup, the control API (GET/POST /api/team, op remove_member), and the MCP team / team_op tools. Loopback + token-gated, so this is coordination, not a security boundary (all members already reach the port). Because every action in the popup is a control-API call, a refusal is now shown rather than swallowed: with the control engine off, the popup says so (and the member list explains why it is empty instead of reading as "no members"), and a route that answers a failing status raises a dialog naming the status and the response body.
  • Organizer: a save-for-later queue with collections. "Send collection to Repeater" sends every stashed request in the selected item's collection to the Repeater at once, each as its own tab carrying the collection name (so a whole group can be replayed or group-sent together); a lone request is just a one-item collection.

Protocols and transport

  • Network-layer HTTP authentication (Basic and Digest). A target behind it answered every request with 401, so the crawler saw one page and the scanner audited nothing; the operator had to hand-build an Authorization header for each tool separately. Set the credentials once in Settings and the engine answers the challenge and retries the request, for every tool that goes through it. Digest covers RFC 7616 (MD5, MD5-sess, SHA-256, SHA-256-sess, qop=auth and auth-int) plus the RFC 2069 no-qop fallback that appliances still speak, verified against the RFC's own published vectors. The challenge is read as the challenge list it is: auth-param names match case-insensitively (they are tokens, so Digest Realm=..., Nonce=... is answered as Digest instead of falling through to Basic and putting the password base64-in-the-clear on the wire), a parameter name written inside a quoted value stays part of that value, and one scheme's parameters are never read out of the next scheme's. Of the qop list auth is preferred wherever it appears, auth-int only when auth is not offered; the Authorization value is sized from the fields it carries, so a long query string is answered in full and a header that cannot be built is refused with a logged error rather than sent truncated. Exactly one retry: a second 401 means the credentials are wrong, and looping locks accounts out. NTLM and Negotiate are deliberately absent, being multi-leg connection-bound handshakes rather than a single computed header.

  • Client certificates on the PROXY path, selectable per host. mTLS hosts could be scanned but not browsed, because the proxy connected without a certificate and the origin closed the handshake. The host selector (comma or space separated; a leading . covers a domain and its subdomains) exists because a client certificate is issued for one service: offering it to every host a browser reaches would hand it to whoever asks.

  • TLS version floor and cipher-list control on the upstream leg, so "does this host still accept TLS 1.0" and "reproduce this over TLS 1.2" are answerable. Backed by two new Nilorea setters (netw_ssl_set_versions, netw_ssl_set_ciphers); the cipher setter covers both the TLS 1.2-and-below list and the TLS 1.3 ciphersuites, which OpenSSL keeps as separate knobs, so restricting one no longer silently leaves the other at default.

  • TLS for the control server: fissure serve --tls-cert <pem> --tls-key <pem>, or the Settings pair, so a deployment reachable over anything but loopback does not put its API token on the wire in plaintext on every request. Half a TLS config is refused rather than falling back silently, because a plaintext listener the operator believes is encrypted is worse than an obvious error.

  • HTTP/1.1 with Content-Length and chunked response framing.

  • HTTP/2: wire framing codec (HPACK), ALPN negotiation, an HTTP/2 engine, an HTTP/2 server state machine terminating the proxy's client leg, and the single-packet attack.

  • WebSocket: frame-level capture, a history view, intercept, replay, and a StreamQL filter box over the captured frames (query by dir/opcode/fin/length/seq/payload/url/host).

  • Transport core with a native engine and an optional curl backend, TLS config, proxy chaining, and cancellation.

GUI and UX

  • Four frameless layout windows (toolbar/nav/main/statusbar); primary views: Dashboard (session metrics, a severity chart, and the recon asset view with a new-since-last-run diff), Proxy, Target, Repeater, Intruder, Findings, Report. The Multitool (Analysis & inspection, F9) and Plugins (Config, F7) are resizable tool popups rather than work-area views, so a running tool stays reachable over whatever view is in front; the Plugins popup has a draggable divider between the plugin list and the tabbed output pane.
  • Every resizable popup re-flows to its live window size: the pane worth enlarging takes the slack (a list, a grid, a text pane), fixed rows keep their height and follow the width, and bottom buttons stay anchored to the bottom edge, so nothing is clipped or stranded when the window is dragged. Popup sizes persist across sessions.
  • Resizable Targets nav pane: drag the divider between the left Targets pane and the work area to widen or narrow the host list (a grip at the boundary brightens on hover/drag).
  • Persisted layout adjustments: manual layout changes are remembered across sessions, unified in n_gui's layout.json. It stores window/popup positions and sizes, and the user-adjustable state of keyed widgets: the draggable splitpane ratios (Proxy, Repeater), the datagrid column widths/order/visibility (seven grids: Proxy, Findings, Target, Intruder, Logger, HaE, and the Jobs monitor), and the Targets nav-pane width. (The toolbar grouping stays in toolbar.json and app preferences in settings.json.)
  • Collapsible toolbar category dropdowns: each category panel now widens to fit its longest entry, so entries like "DOM Invader" or "HTTP/3 proxy" under the Capture category are never clipped by a narrow category button.
  • Resizable tool popups: tool/workshop dialogs are user-resizable (drag the bottom-right grip) and their chosen size is remembered across sessions (in layout.json). Content- bearing dialogs reflow as you resize - the primary grid/list/editor panes grow to fill the window while the controls stay put (e.g. the Comparer's diff panes, the Event log's table). Simple confirm/prompt modals stay fixed.
  • Tool popups as real OS windows: Settings > Appearance > "Tool popups in their own OS windows" promotes every tool/workshop dialog to a native window, so it can be moved to a second monitor, alt-tabbed and managed by the window manager while Fissure keeps running. Toggling it back returns them to in-program popups. Either way a dialog keeps its own themed title bar, buttons and reflow behaviour, so only where it lives changes. The fixed modals (confirm/prompt/quit, the command palette, search, the context menu) always stay in-program. The choice is persisted.
  • Maximisable tool popups: the title-bar maximize icon expands any tool/workshop popup to fill the display and restores it to its previous size and position, so a grid, diff or editor pane can be read full-screen without losing the layout you had.
  • Minimisable tool popups: the title-bar reduce icon collapses any tool/workshop popup to its title bar without losing its state, so it can be parked on screen instead of closed; clicking the icon again (or its toolbar/palette entry) restores it. The reduced state is remembered across sessions along with the window size and position. Confirm/prompt/quit, the command palette, search and the context menu are not minimisable by design.
  • Reset GUI: Settings > Appearance > "Reset GUI to defaults" returns the whole interface to its shipped state behind a confirmation that names what it discards - theme, font, interface size, corner style and tooltip delay; the toolbar categories; every window size, position and reduced state; every splitpane divider, the Targets pane width and every grid-column layout. Scanning, proxy, TLS and AI settings are not touched and no captured traffic, findings or projects are affected. The narrower "Reset windows and position" button remains for resetting dialog geometry alone.
  • Utility popups: Organizer, Env, Project, OAST, Raw proxy (TCP/UDP relay), Team, Rules (match-replace), Tags, HaE, Tokens, SAML, Session (session-handling rules), Auto-replay, Comparer, Search, Logger, Sequencer, AI chat, Workflows, Schedules, Extensions (the extension SDK manager, with the selected bundle's tabs shown inline), Help, Settings, plus the Keyboard-shortcuts editor (Settings > Appearance > "Edit keyboard shortcuts", or the palette; not a toolbar popup), the Command palette, Grid-columns, Toolbar customizer, Auth-matrix, CSRF/Clickjack PoC, AI assistant, and the shared confirm/prompt/info dialogs. The Fissure Browser launches from a toolbar entry. Every standalone view/popup also has a command-palette entry, and every one carries per-widget tooltips and input hints (both enforced rules).
  • Collapsible category toolbar: the top buttons are grouped into labelled category dropdowns on a single row (Home, Organize & collaborate, Auth & session, Recon & infra, Capture, Test & attack, Results, Analysis & inspection, Power-ups, and Config last: the setup groups come before the ones that generate traffic) rather than a flat button strip; the row wraps to further visual lines when the window is too narrow, and the model still supports moving categories onto a second row from the customizer. Each category is a button with a chevron that opens a dropdown of its modules; clicking a module runs its action (switch a view, open a popup). Only one dropdown is open at a time, the chevron flips while open, and the category holding the active view is labelled "Category: Module" so the operator sees where they are. The grouping is data-driven (rows -> categories -> modules, each with a stable id, order, and visibility), persisted to toolbar.json, and reconciled on load so a module is never lost. The Toolbar customizer (the "Customize toolbar" button in Settings > Appearance, or the command palette) shows/hides and reorders categories and modules, renames categories, reassigns a module to another category, and resets to defaults, applied live. View-switch shortcuts (F2-F10) keep working and select a view directly.
  • Cross-tool traffic log (Logger): one filterable log of every request the engine issues, tagged with its source tool (repeater, intruder, scanner, discover, and the proxy mirrored in), filterable by tool, status family, and a host/URL/method substring. Fed by a central tap in the request engine (config.traffic_log); opened from the Logger toolbar button or the command palette, with Refresh and Clear.
  • Event log: a chronological, in-memory panel of engine events and errors (the app starting, out-of-scope refusals, and every message surfaced to the operator via the shared info/error dialog), newest first, tagged with a source and a level (info/notice/warn/error). Distinct from the traffic Logger (which records HTTP exchanges), so a blockage is not lost when its popup is dismissed. A capped ring buffer (fissure_eventlog); opened from the "Event log" toolbar button (Analysis & inspection) or the command palette, with Refresh and Clear.
  • Cross-tool right-click context menus, UNIFIED across the Findings, Proxy, and Target/site-map lists (all three offer the same request-context action set, from the shared FISSURE_CTX_ACTIONS_REQUEST mask; open_impl hides the single-target-only actions when several rows are selected). The direct actions are buttons - Send to Repeater/ Intruder/Comparer, add to scope, add to out-of-scope, set as filter, Scan this, Scan with profile (a dropdown of profiles), CSRF PoC, Clickjack PoC, AI assist - and the test/attack actions are GROUPED by type into category dropdowns (like Scan with profile) rather than a long flat list: "Injection & data" (SSRF, XXE, stored XSS, mass assignment/HPP, prototype pollution, NoSQL injection, reflected file download, business-logic probe), "Access control" (check access control, IDOR/BOLA, auth-header bypass, 401/403 bypass, CSRF deep, auth matrix), "Server & infra" (request smuggling, cache poisoning, subdomain takeover, race probe), and "Recon & tools" (mine JS, file upload, confirm CSPT, Shadow Repeater, send over HTTP/3, run scripts, signed tokens, auto-replay, extension actions, message editor). The last-added tests wire the technique-coverage on-demand checks to a one-click action (NoSQL injection, 401/403 access-control bypass, reflected file download, business-logic numeric tamper, race-condition limit overrun, the deepened CSRF check, and the runtime CSPT confirmation over a headless browser); the action bitmask is 64-bit to carry them. The body-fuzzers (NoSQL injection, CSRF deep) appear only when the row has a request body. Each test runs on a worker thread with a spinner and a verdict popup. The menu dismisses on a click-away or Escape. From the Proxy and Findings request lists it also offers "Add to collection": a picker (an existing-collection combobox plus a new-name field and a tags field) that stashes the selected request(s) into the organizer under that collection with those tags (the same capability as the organizer_add MCP tool / POST /api/organizer). The Targets pane (the left host list) has its own host-level right-click menu: Add host to scope, Add to out-of-scope, Set as filter (filter the Target view to that host), Scan this, and Scan with profile (a dropdown of scan profiles: picking one applies that profile's options and scans the target, where plain "Scan this" uses the current Target-view options).
  • Target-view actions: Scan, Quick scan, Seed from Proxy, Import API, Discover, Headless crawl (run katana with a system Chromium so JS-rendered SPA routes enter the site map, on a worker thread; katana is capped at depth 2 and a 180s crawl duration so it cannot run indefinitely, the button reads "Stop crawling" while it runs and clicking it stops the crawl early - killing the katana + Chromium process group and keeping whatever it found so far - with an outcome popup, scope-gated and skipped when the crawler is absent), SPA crawl (a native, no-external-tool interaction crawler: drives a headless Chromium over CDP to follow client-side router links, click buttons, submit forms, and capture the XHR/fetch endpoints the app calls at runtime, feeding them into the site map; on a worker thread with a "Stop SPA crawl" label that cancels in-process, de-duplicated by app state and bounded by state/interaction/time caps, scope-gated and needing a Chromium/Chrome; this same CDP SPA crawl also runs INSIDE a scan on demand - the --crawl-spa CLI flag, the spa option on POST /api/scans and MCP start_scan, and a "Crawl client-side (SPA) routes with a headless browser" Scan-options checkbox: after the link crawl drains, the scan drives the headless browser, feeds the discovered routes and runtime XHR/Fetch endpoints into its own crawl and audit (scope-gated), uses the session cookie jar for an authenticated crawl, and reports what it added - or that no browser was found - as a Scan-coverage finding), Import scope, Seed recon (load a recon-tool output file and route its hosts into scope and its URLs into the inventory), Fetch spec (probe the target for a served OpenAPI/Swagger definition and seed its operations, on a worker thread with a busy label and an outcome popup, scope-gated), Clear hosts (empty the discovered host/endpoint site map for the active project, behind a confirmation; findings are kept), User Agents (opens the User Agents manager, since the active preset is the User-Agent the scan, the crawl, every check and content discovery send), and Parameters (the GET/POST parameters the crawl carries, and the login URLs POSTed before it starts). The crawler also mines JavaScript for endpoints automatically during a scan, and a recon-category plugin run auto-seeds the site map - the GUI counterparts of the jsmine and recon tools. The control-API/MCP clear_findings resets the accumulated headless workspace (findings + capture evidence).
  • Command palette and a keyboard-shortcut editor with persisted bindings. The palette is opened with Ctrl+K or by clicking the Fissure entry in the Home category dropdown (so it has a discoverable clickable control, not only a shortcut), and by an enforced parity rule it lists every view and every standalone popup; a purely request-contextual action (AI assist, CSRF/Clickjack PoC, Add to collection) stays a context-menu action.
  • Datagrid column customization (hide/show, resize, reorder) persisted globally. Columns are resized by dragging a column's right border in the header (the pointer shows a horizontal-resize cursor over the border for discoverability), and vertical separators delineate the columns. When the columns are wider than the grid's pane (a narrow window, or widened columns), the grid scrolls horizontally within its own pane instead of clipping the rightmost columns: a horizontal scrollbar appears along the bottom, Shift+mouse-wheel scrolls the columns, and the scrollbar thumb is draggable (the header scrolls in lockstep). The horizontal position is preserved across a grid rebuild (saved/restored alongside the vertical scroll + selection in the wide grids). Toolbar customization (show/hide, reorder, rename, regroup) is persisted to toolbar.json.
  • Responsive/DPI-aware UI: a single ui_scale recomputed on init/resize/settings with font reload; adaptive per-window resize policy.
  • Theming: 18 built-in themes (dark default) selectable in Settings, via live FISSURE_C_* macros: Dark, Light, Solarized Dark, High Contrast, a cybersecurity-inspired set (Dim, Matrix, Amber CRT, Synthwave, Red Team, Blue Team), and popular editor palettes (Dracula, Nord, Gruvbox Dark, Slate (neutral grey), Tokyo Night, Catppuccin Mocha, One Dark, GitHub Light); in-app Help.
  • About box: Home > About (also in the command palette, and --selftest-about) shows the running version, the author, the copyright and the freeware license notice, and the list of third-party components with a pointer to THIRD_PARTY_LICENSES, which ships beside the program. It is a decorated popup laid out one line per notice line rather than a wrapped block, because n_gui only wraps a label under ALIGN_JUSTIFIED, which would reflow the notice into one unreadable justified paragraph.
  • Bundled fonts: five proportional TrueType faces ship under resources/fonts and are chosen in Settings > Appearance > Font, applied live and persisted. The picker is proportional only, because the chosen face is the single typeface for the whole interface and a fixed-width one makes prose labels overflow their boxes: DejaVu Sans (the default, the widest in character coverage and the widest and tallest per line), Inter (drawn for screen interfaces), Noto Sans (the broadest script coverage), Roboto (matching the default's line height) and Liberation Sans (the metrics of the common system sans). Two fixed-width faces (JetBrains Mono and IBM Plex Mono) stay bundled for the Markdown renderer, which draws inline code and raw bytes in a monospace that lines columns up, but they are not UI-font choices. Shipping them means the interface never depends on a system font: when no TTF can be loaded, Allegro falls back to a builtin bitmap font that is stuck at one pixel size and ignores the Interface-size setting entirely, which is how a Windows build used to render (its only candidates were two hardcoded Linux paths). The loader tries the chosen face, then the other bundled faces, then a few well-known Linux/Windows/macOS system fonts, and logs a warning if it ever reaches the bitmap fallback, since that means the install lost its resources. Each font's license travels with it in resources/fonts/LICENSES. Pure table + clamping in fissure_font, tested by tests/test_font (which also verifies each declared TTF really is present and is a real font file).
  • Widget shape: Settings > Appearance > "Rounded widget corners" switches the whole GUI live between a rounded and a square look (buttons, comboboxes, and the toolbar category dropdowns); rounded by default and persisted. The cascading category dropdowns are rounded to match the other round widgets.
  • Persisted window layout: the tool dialogs (Settings and the workshop/utility popups) carry minimize + close titlebar buttons and are sized to their content; they are not user-resizable (only the main program window resizes), but they can be moved, and their size and position are saved to <config>/layout.json and restored next session (via n_gui's layout JSON I/O). A "Reset windows and position" button in Settings (Appearance) returns every window to its default. The Settings window is wide enough to show the full-width fields without truncation.
  • Hover tooltips and input hints: resting the pointer on a control shows a one-line description. By an enforced rule, every interactive widget across the views and the workshop/editor popups carries a tooltip and every text input/output carries a placeholder hint (or a descriptive adjacent label); only self-evident controls are exempt (a plain Close/Cancel/OK button, an obvious Refresh, pure section labels, the context-menu items whose label is self-describing, and the Help topic toggles). The hover delay is configurable in Settings > Appearance (Tooltip delay, default 1300 ms; 0 disables tooltips) and persists.
  • Visual workflow builder (toolbar "Workflows"): compose a pipeline of typed nodes over one HTTP exchange and run it. Node types reuse the scriptable primitives: filter (a traffic-query gate that stops the pipeline on a non-match), match_replace (literal/regex rewrite of a request/response leg+part), transform (a JS convert over a leg+part), passive/active (a JS check emitting findings; active enables fs.send), send (replay the current request), js (arbitrary JS over the WHOLE exchange serialized as a JSON object {method,url,req_headers,req_body,status,resp_headers,resp_body}: parse input, rewrite any field, return JSON.stringify), and shell (pipe a leg+part through an external command: the field is written to a temp file whose path replaces {{in}} in the command, and the command's stdout replaces the field; aggressive-gated). The builder edits nodes (type, enabled, leg/part, match/replace/regex, or a query/script box) with add/remove/reorder, saves and loads named workflows (/workflows.json), and Runs the pipeline over an input URL (Active toggle gates the active/send/shell nodes; in-scope only), showing the per-node trace and any findings. Predefined templates: a "From template" picker and a "New from template" button load a shipped ready-made pipeline (like the built-in scan profiles) into the editor as a starting point, drawn from resources/workflows/*.json: a passive secrets/errors triage, a security-header audit, a cookie-security-flags audit, a sensitive-data-in-URL check, a reflected-input (XSS) probe, a SQL-error probe, a CORS misconfiguration probe, a JSON-response normalizer, and a replay-and-re-check chain. Headless parity: POST /api/workflow/run, GET/POST /api/workflows (op save|delete|instantiate), and GET /api/workflow-templates, with the workflow_run / workflows / workflows_op / workflow_templates MCP tools; the engine (fissure_workflow), the shipped templates, and the js/shell node round-trip are unit-tested (tests/test_workflow).
  • AI assistant popup (explain a request, triage a finding, draft a PoC, or Ask a question: a free-form question the assistant answers using the attached request/ finding as context) with a multi-provider client: Anthropic, OpenAI, Google Gemini, Mistral, DeepSeek, local Ollama, and any OpenAI-compatible endpoint (each with its own wire protocol, auth header, and default URL/model), selected in Settings. The answer renders as Markdown (headings, lists, tables, code blocks, links) in a selectable pane: drag, double-click a word, Ctrl+A / Ctrl+C, or the Copy button (the selection, or the whole answer when nothing is selected). An error shows literally.
  • Agentic AI chat (toolbar "AI chat"): a conversation where the assistant can drive Fissure through its control API. The agent calls tools (read the scope, list/query findings and traffic, read assets and workflows, read scan-job status/findings, set scope, start a scan, send a request, run a workflow) via a provider-agnostic @@TOOL@@ directive; read-only tools run automatically, while write/active tools run only when the operator turns on the "Aggressive write mode" toggle, and every action is scope-enforced (the operator's scope is pushed into the control context first). Conversations are saved/loaded under /aichats. Reuses the multi-provider AI client; needs an API key in Settings. The core (fissure_aichat: conversation, tool registry, agent prompt, directive parser) is unit-tested; the loop runs on a worker thread with live on-screen progress. The message field is multi-line: Enter starts a new line, and Ctrl+Enter or Shift+Enter (with the field focused and the chat the topmost window) sends the message, the same as the Send button (fissure_gui_aichat_handle_key, fissure_aichat_is_send_chord). The transcript renders as Markdown: each turn opens with its speaker in bold and turns are separated by a rule; the assistant's formatting is drawn, tool results show as code blocks, and the operator's own text is escaped so markup typed into a question shows exactly as typed and cannot break the transcript (fissure_aichat_render_markdown, unit-tested). Selection and the Copy button work as in the AI assistant popup.

CLI and automation

  • Launch modes: one binary, several modes (documented end to end in docs/17_STARTING_AND_USING.md). fissure with no subcommand launches the GUI; fissure scan <URL> runs a headless scan and report for CI; fissure report --session <file> regenerates a report from a saved session; fissure serve runs the engine as a daemon with no GUI, serving the REST control API, the browser dashboard (web portal) at /, and the MCP endpoint on the same port; fissure api <METHOD> <ROUTE> [body] calls one control-API route in-process without a server; fissure purple <subcommand> drives the purple-team reconciler; fissure plugins list|install lists the OSS-tool plugins and installs the external tools they wrap, headless (the equivalent of the GUI Plugins view's "Install all"). fissure --help prints the authoritative options and fissure --version the build version.
  • Headless plugin management: fissure plugins list shows each bundled plugin's id, category, and whether its tool is present; fissure plugins install --all installs every missing tool and fissure plugins install <id>... installs named plugins (by plugin id or dependency id), both with --dry-run to print the install command without running it. Installs run the recipe from resources/dependencies.json; a tool with no recipe is reported to install by hand. The control API / MCP (plugins, plugin_install) deliberately return the install command rather than executing it, so a remote caller never triggers a third-party installer; running it stays a local action (this CLI or the GUI).
  • Purple-team mode from the command line: fissure scan <url> --purple <run> records every request the scan sends as a probe under that run (starting after the --login replay, so credentials never enter the store) and reports the per-technique tally when it finishes, and fissure purple status|import <file>|reconcile|findings|baseline|diff| clear|marker drives the rest. fissure purple diff exits 1 when a technique's detection coverage regressed, so a scheduled run can gate on it.
  • Command-line interface for scans and session import/export, including a headless authenticated scan: fissure scan --login <config.json> replays a login config to establish a session before the scan (aborts with exit 2 if the login fails), the CLI equivalent of the Settings Login config.
  • DVWA lab target: a local, loopback-only DVWA integration for training and regression under lab/dvwa/ (Docker compose + HTTPS gateway + cert script + a per-level regression runner), a ready-made DVWA login config (resources/login/dvwa.json, login + security-level flow), and an audit/how-to mapping the integration plan to Fissure's features (docs/12_DVWA_LAB.md).
  • Optional local control API on 127.0.0.1: a token-gated JSON HTTP surface (GET /api/status, GET /api/findings, POST /api/request to send one request through the engine, POST /api/scan synchronous, and an async scan job API POST /api/scans + GET /api/scans/{id} status/progress + /findings + /cancel, where POST /api/scans takes an optional login login-config object for an authenticated scan. On-demand checks also run as async cancellable jobs: POST /api/jobs runs a named check (nosqli, aclbypass, rfd, bizlogic, csrf, ssrf, idor, xxe, cache, takeover, protopollution, massassign, storedxss, authbypass, race, smuggle) on its own worker thread with a per-job cancel flag and a wall-clock deadline (or synchronously with "wait":true), so a check never blocks the control API, several run at once, and a stalled one self-cancels; GET /api/jobs is the unified monitor of all jobs (scans + checks: id, kind, name, target, status, elapsed, running/queued/total counts), with GET /api/jobs/{id}[/findings] and POST /api/jobs/{id}/cancel (a job id is kind-agnostic, reusing the scan hooks). Each job keeps its own results, so concurrent scans/checks are never lost track of. A concurrency cap (the control_api_max_jobs setting, default 4) bounds how many jobs run at once; the rest queue and are promoted as slots free (GET /api/jobs reports running/queued/max), so a burst of checks never exhausts threads or sockets. The GUI surfaces the same live view: a Jobs monitor popup (Results toolbar category + command palette) is a self-refreshing grid of every job (kind, name, target, status, elapsed) with per-row Cancel, Cancel all, and Clear done (drops finished done/error/cancelled jobs, keeping live work; POST /api/jobs/clear + the jobs_clear MCP tool), so the operator watches what an agent drives over the control API/MCP, cancels a stalled one, and prunes the list, from the same window (fed by the in-process GET /api/jobs, which auto-refreshes every few seconds). The operator's OWN Target-view scans are registered as jobs too (fissure_control_gui_job_*), so a manual scan shows in the same monitor with live status and finding count, and a Cancel from the monitor stops it, unifying the operator and agent job views in one list. Every failure is surfaced rather than swallowed: with the control engine off the monitor says so in place of an empty grid (which would read as "no jobs are running") and each button explains that the action was not carried out, and a job list or a Clear done that the control API refuses reports the status and the response body instead of leaving the list silently stale. The on-demand context-menu checks (every worker in fissure_gui_findings.c: the shared ctxcheck runner for nosqli/aclbypass/rfd/bizlogic/csrfdeep/race, plus shadow, waf-bypass retry, smuggle, ssrf, xxe, cache, upload, idor, takeover, prototype-pollution, DOM probe, mass-assignment, stored-XSS, and JS-mine) register as "check" jobs the same way, so every short-lived right-click action also appears in the monitor and settles with its finding count. Alongside the current-state view, every job emits lifecycle events (started, queued, done with its finding count, cancelled/error) into the shared event log, exposed as GET /api/events / MCP events ({count, events:[{time,level,source,message}]} newest first) and shown live in the GUI Event-log panel - a chronological feed so neither the operator nor an agent misses a completion across many concurrent jobs (the time-ordered complement to per-job results). Plus the analysis workshops and report export: POST /api/transform (multitool encode/decode/hash), POST /api/smartdecode (both report a BYTE result as text plus exact base64: output, output_b64, output_len, output_binary, so a decode that lands on NULs or non-UTF-8 bytes is readable instead of truncated at the first NUL, empty, or invalid JSON that breaks a strict client's parser), POST /api/protobuf (protobuf/gRPC wire decode), POST /api/prettify (beautify JSON/XML/JS), POST /api/compare (diff), POST /api/sequence (token entropy), POST /api/jwt (decode/verify/sign/crack), and GET /api/report?format= (markdown/html/json/csv/sarif/burp, with optional min_severity/host/source filters and a risk score/band), PwnDoc export POST /api/report/pwndoc and PDF rendering POST /api/report/pdf, the GraphQL argument workshop POST /api/graphql, the signed-cookie workshop POST /api/cookie, the SAML workshop POST /api/saml (decode/inspect/edit/strip/ wrap/genkey/sign/verify), the request Inspector POST /api/inspect, scope-text import POST /api/scopeimport, a user-JS transform POST /api/jstransform, a .bcheck compiler POST /api/bcheck, and a nuclei-template compiler POST /api/nuclei; plus the Intruder POST /api/intruder (sniper/battering-ram/pitchfork/clusterbomb with grep; payloads takes either a flat array for one shared set or an array of arrays for one set per marked position, so pitchfork and cluster bomb can pair a username list with a password list headlessly, as they always could in the GUI), content discovery POST /api/discover, parameter mining POST /api/paramminer, API-definition import POST /api/apispec (OpenAPI/Swagger/Postman, JSON or YAML) and live spec auto-fetch POST /api/apispecfetch (probe a target's well-known /openapi.json, /swagger.json, /v2/api-docs, /openapi.yaml, ... and import what it serves, JSON or YAML), the recon-to-inventory bridge POST /api/recon (route recon-tool host/URL output into the inventory and scope), the recon asset diff GET/POST /api/assets (host-level assets with live/dead status, detected tech, endpoint count, and a new/changed/gone diff vs a saved baseline; POST optionally merges recon output and/or re-bases the baseline) and the headless JS-render crawl POST /api/headlesscrawl (katana -headless routed into the inventory), the JavaScript endpoint/secret miner POST /api/jsmine, the HTTP request-smuggling desync probe POST /api/smuggle, group send POST /api/groupsend (sequential/parallel/HTTP-2 single-packet race), the WebSocket Repeater POST /api/wsrepeater, a scriptable check runner POST /api/jscheck (fetch + QuickJS check -> findings), authorization testing (the auth matrix POST /api/authmatrix, the Autorize-style replay POST /api/authz, and the offline role diff POST /api/rolediff), the OSS-tool plugin host (list GET /api/plugins, run POST /api/plugins/run -> findings, and build a dependency install command POST /api/plugins/install, which the API never executes), the extension SDK registry (list installed bundles GET /api/extensions, enable/disable/reload them POST /api/extensions), the out-of-band (OAST) collector for blind vulnerabilities (start POST /api/oast/start, mint a canary POST /api/oast/mint, poll it GET /api/oast/poll, and read interactions GET /api/oast/history), the workspace data stores that drive the same on-disk files as the GUI (projects GET/POST /api/projects - activating one also re-points the per-project stores the control engine holds in memory, re-resolving the extension state directory behind fs.store and reloading the shared crawl parameter jar, so a switch does not leave the next write putting the previous project's data in the new project's files -, the per-project environment library GET/POST /api/env + POST /api/env/expand, the inline transform tags GET/POST /api/tags + POST /api/tags/eval, the saved-request organizer/collections GET/POST /api/organizer + /remove, session save/load POST /api/session/save/load, and the shared-project team collaboration GET/POST /api/team (members, presence, advisory locks, assignments, activity)), and scope management GET/POST /api/scope applied to scans, intruder, discover, and the param miner; and a control-driven live intercepting proxy POST /api/proxy/start/stop, GET /api/proxy/status, GET /api/proxy/history[/{index}], and GET/POST /api/proxy/intercept (+ /resolve to forward/drop a held request), the generic non-HTTP raw TCP/UDP relay POST /api/relay/start/stop, GET /api/relay/status, GET /api/relay/history and GET/POST /api/relay/intercept (+ /resolve to forward/drop a held chunk)) that drives the engine and the workshops without the GUI, for automation / CI / an MCP bridge. Off by default; toggled in Settings (enable checkbox, port, auto-generated bearer token, and a regenerate action) with the enabled state, port, and token persisted and auto-started on the next launch, or run headless via fissure serve (--host / --port / --api-key). Loopback only; token as X-API-Key or Authorization: Bearer; request-size capped (413 over 64 KiB), a per-connection read timeout, and every command audited to the log. See docs/11_CONTROL_API.md.
  • MCP endpoint for AI agents: the bridge/ MCP bridge exposes one MCP tool per control-API route, so Claude Code, Claude Desktop, or a ChatGPT connector can drive the engine as an agent (with the fissure_bug_bounty skill / methodology). The bridge speaks stdio by default (how Claude Code / Claude Desktop launch it) and can serve a remote MCP endpoint (FISSURE_MCP_TRANSPORT=streamable-http at /mcp or sse at /sse, optional FISSURE_MCP_HOST / FISSURE_MCP_PORT, default port 8779) for a ChatGPT developer-mode connector behind a tunnel. The step-by-step to start the endpoint and connect each client is in docs/13_MCP_AND_SKILL_SETUP.md.
  • Browser control dashboard: the control server also serves a self-contained HTML page at GET / (and /ui) so an operator can drive Fissure from a browser instead of curl or the desktop GUI. The page (no external assets, CSP-safe) is a thin client over the existing routes, with tabs for: server status + a findings severity summary; a findings table; a start-a-scan form (active/aggressive toggles, async job polling); a Repeater that sends an arbitrary request through the engine (method, URL, raw header block, body) and shows the response; proxy control (start/stop/status, a captured-flow table, clear history); a Probes tab that runs any targeted probe (smuggle, http3-smuggle, ssrf, xxe, idor, cache, takeover, protopollution, massassign, storedxss, authbypass, cspt, csrf-active, race, upload) with a shared findings table and the raw verdict JSON; a Jobs tab (queue a background check job, list/clear jobs, and the lifecycle Event log); a Purple tab (start/stop the probe recorder under a named run, import the defenders' telemetry as pasted text or as a file the host reads itself, reconcile, emit the coverage findings, and take or diff a coverage baseline, with the per-technique table showing each technique's baseline percentage next to its current one); 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 with a snapshot-baseline button); a Surface tab (the endpoint attack-surface summary); a Query tab (run HTTPQL over findings/traffic/wsframes with saved-query save/delete/restore-defaults); a Workflows tab (list + instantiate a shipped workflow template, then run a saved workflow and read its per-node 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 with focus/max-variations/active toggles); an OAST tab (start/stop the listener, mint a canary, poll a token, and the interaction history); the Multitool workshop (protobuf/gRPC decode, transform, smart-decode, a remediation-guidance lookup by CWE/category, and prettify); scope editing; and a Report tab that generates a report in any format (markdown/html/json/csv/sarif/burp) with an optional minimum severity and a download button, plus a Show: Source / Show: Rendered toggle (remembered per browser): Markdown renders through a DOM-building renderer (adapted from DarkChan's portal renderer; never innerHTML, http(s) links only) and HTML renders in an iframe with an empty sandbox (no scripts, no same-origin access) behind a CSP that blocks every network load; the other formats show the source. Tabs lazy-load their data when opened; a probe/check/workflow run is attributed to the operator in the team feed. The shell loads without a token (it carries no data); the operator pastes the token once (held in the tab's sessionStorage) and every data 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). An optional operator-name field (held in localStorage) identifies you on the shared team: on Connect the dashboard registers that name as a team member (idempotent) and heartbeats presence, and scans you start from the dashboard are logged to the team activity feed attributed to that operator, so a browser-driven operator shows up in Team the same as a desktop or agent one. Open http://127.0.0.1:<port>/ after fissure serve or after enabling the control API in Settings. The page source is resources/webui/dashboard.html.
  • MCP bridge (bridge/): a thin FastMCP stdio server exposing one tool per control-API route (health, send_request, start_scan, get_scan_status, get_scan_findings, cancel_scan, the async job tools run_check, jobs, job_status, job_findings, job_cancel, events, get_findings, plus the workshop tools transform, smart_decode, protobuf, prettify, compare, sequence, jwt, report, graphql, cookie, inspect, scope_import, js_transform, bcheck, nuclei_import, the engine tools apispec, apispec_fetch, recon, assets, reconchain, originip, wafdetect, wafbypass, screenshot, screenshots, headless_crawl, spider, jsmine, cspt, cspt_confirm, csrf_poc, csrf_active, smuggle, race, ssrf, deser, deserchain, jslib, remediation, scanprofiles, scanprofiles_op, upload, massassign, nosqli, bizlogic, workflow_bypass, storedxss, paramminer, groupsend, wsrepeater, jscheck, authmatrix, authz, rolediff, aclbypass, rfd, plugins, plugin_run, plugin_install, the extension SDK tools extensions and extensions_op, the OAST tools oast_start/stop/status/mint/poll/history and the hosted-OAST client oast_hosted, the workspace tools projects, project_op, env, env_op, env_expand, tags, tags_op, tags_eval, organizer, organizer_add, organizer_remove, session_save, session_load, the team-collaboration tools team and team_op, report_pwndoc, report_pdf, intruder, discover, get_scope, and set_scope, the live-proxy tools proxy_start/stop/status/history/flow and intercept_status/set/resolve, and the raw TCP/UDP relay tools relay_start/stop/status/history and relay_intercept_status/set/resolve) so Claude Code can drive the engine, the workshops, and a live proxy as an agent (claude mcp add). Its HTTP client is pure standard library (no third-party HTTP dep) and independently tested. The .deb, the AppImage and the Windows installer ship the bridge and the Claude skills next to the binary (.deb: /opt/fissure/bridge/ and /opt/fissure/skills/), so connecting an MCP host needs no source checkout. See bridge/README.md and docs/13_MCP_AND_SKILL_SETUP.md.
  • fissure_bug_bounty skill (.claude/skills/fissure_bug_bounty/): a Claude Code skill that drives the MCP tools to run a full authorized bug-bounty engagement (scope, recon, authenticated scan, manual confirmation, reporting) with the Fissure methodology. See the "Automating a bug-bounty engagement" section of docs/11_CONTROL_API.md.
  • Settings persistence and a Settings GUI.
  • Headless GUI self-test screenshots (--selftest-shot plus per-view/per-popup flags) for regression of the GUI.
  • Headless GUI layout audit (--selftest-geometry): opens every view and every popup the command palette indexes, plus the request-contextual dialogs and shared modals it does not (the PoC generators, AI assist, add-to-collection, the extension panel, the context menu, confirm/prompt/quit), then reports each widget the window clips, each widget another one covers, each label showing less than its text (truncated on one line, or a wrapped paragraph clipped by its box), and each data grid narrower than its own columns. Exits non-zero on any defect, so tests/test_guigeom turns "this dialog opens with a scrollbar and a half-hidden button" into a failing build instead of something noticed on screen. A window whose content cannot fit the display, and a grid with more columns than any screen holds, scroll by design and are not defects. The test runs seven configurations: four window sizes from 800x500 (the smallest the program allows) to 1600x1000, each with an Xvfb screen to match via --selftest-size, and 1024x700 at each of the four interface sizes. A layout that fits at one is not proven at another, and both axes are needed because what a view lays out in is the window divided by the interface scale. Each question is answered against what the widget's own window can attain rather than the display: a pop-up can be dragged out to the display, a tiled layout panel cannot be resized at all, so for a panel it is its own scrollbar that decides whether content past its edge is reachable (the views scroll; the toolbar, nav pane and status bar do not, and content past theirs is still reported).
  • Grid columns follow the interface size: widths are declared at scale 1.0 and applied at the live scale, and a live interface-size change carries them (including a width the operator dragged) rather than leaving them at the scale the view was built at.
  • Action rows wrap instead of running off the panel: the Target, Findings, Intruder and Repeater control rows start a new line when the next control would not fit, so a large interface size or a narrow window costs a row of height rather than leaving buttons unreachable past the right edge or painted over their neighbours.
  • Wrapped headings are sized from what their text measures at the live width and font, so a paragraph that needs another line at a smaller interface size gets one instead of being silently clipped.
  • Grid columns that fit the pane at any window size: each view grid names one flex column (URL in Target, Title in Findings, Request in Intruder, Tab in the Repeater tab list, Path and Line in the two Purple team tables) that absorbs whatever the other columns leave, down to a per-grid floor below which the grid scrolls sideways. The other columns stay drag-resizable and persisted; hiding one through "Customize grid columns" hands its width to the flex column.
  • The Dashboard's recon-asset table takes as many rows as the window has room for, and its "N more host(s) not shown" line counts what is actually off the list, so the line that says the list is partial is never itself the first thing pushed below the fold.

Safety and ethics (enforced in code)

  • Active scanning, fuzzing, and MITM only against authorized targets: a scope allowlist, rate limits, and a safe/aggressive toggle.
  • An authorization banner on first run and before active scans.
  • No target-owner evasion: Fissure adds nothing to conceal, delay, obfuscate, or misattribute the tester's activity to evade the target owner's own logging, monitoring, or incident response (no anti-forensics, no log-poisoning, no traffic-source concealment). Input-filter (WAF/CDN) bypass to demonstrate an authorized, in-scope vulnerability is permitted (a WAF is a mitigation, not a fix), behind the scope allowlist, the aggressive toggle, and the authorization banner.
  • Purple-team mode is the constructive counterpart of the no-evasion rule: it records what each probe looked like on the wire and reconciles it against what the target's own logging and alerting caught, so the tester reports a detection-coverage gap to the owner rather than exploiting it quietly (see Purple team above). Its probes are deliberately identifiable, and it destroys nothing on the target.
  • Code-of-conduct warning window: any feature that bypasses a protective control (the WAF/CDN input-filter bypass, and any future control-bypass capability) displays a non-blocking warning popup naming the action and its authorized-use-only condition before it runs. The warning informs and is acknowledged; it does not block the action.
  • Every refusal/blockage surfaces on screen (popup or persistent text), and every background operation shows progress (spinner or progress bar with a busy-state control). In particular, none of these fail quietly any more:
    • A desktop handler that could not be started (Help -> Docs, Open dashboard, Open screenshot) reports the failure instead of returning success. The detached opener carries its exec errno back over a close-on-exec pipe, so a machine with no xdg-open says so.
    • A plugin whose binary could not be executed says "did not run" and names the binary, rather than reporting "0 finding(s) added", which read as "ran, found nothing". The recon chain counts such a tool as failed, not as one that ran. Over the control API, /api/plugins/run returns exit_code and ran.
    • A job cancel that the control API refuses is reported, with the status and the API's own reason; Cancel all reports how many of how many could not be cancelled. A refused cancel used to look identical to a successful one while the scan kept hitting the target.
    • A broken extension message-editor script shows the QuickJS exception and LEAVES the pane alone. It used to erase the operator's message and report success.
    • A missing resources/checks is stated when a scan starts (the scriptable checks, the imported nuclei/BCheck templates and the extension checks are all absent), and is recorded in the event log for headless runs.
    • A missing resources/wordlists/paths.txt is stated when content discovery starts, with the reduced path count, so an empty result is not read as a clean one.
    • A missing SPA crawl script (resources/spider/enumerate.js) is reported as an incomplete install, not as "no browser found", which sent operators to install a browser they already had. The /api/spider route returns script_missing.
    • A missing certutil is reported when the Fissure Browser is launched, because without it every intercepted HTTPS page shows a certificate warning.
    • A response larger than the viewer can hold ends with a truncation marker naming how many body bytes were dropped and where to raise the limit. It used to be cut at a fixed 256 KB with no marker at all, so a cut multi-MB JavaScript bundle read as a short response. The pane's size is the Response view (KiB) setting (64-65536, default 1024); the widget's capacity is fixed when it is built, so a change applies at the next start. The Hex view is fed the response's own bytes (verbatim, NULs intact) rather than that text rendering, so it shows what the server actually sent.

Build, tests, and packaging

  • Makefile targets: all, tests (full regression suite), checks (cppcheck, zero findings), asan-tests / tsan-tests (the SAME suite rebuilt under AddressSanitizer+UBSan or ThreadSanitizer: tests compiles at -O3 with no instrumentation, so it proves behaviour and nothing about memory or threading, and a use-after-free that happens to read plausible bytes passes it every time; for the GUI, which no test drives, build with make SAN=tsan and run the headless --selftest-* flags with TSAN_OPTIONS=suppressions=tests/tsan-suppressions.txt), fuzz / fuzz-smoke (libFuzzer targets over every parser that reads bytes Fissure did not write: the proxy's own HTTP/1.1 framing, the three template importers, YAML, protobuf, SAML, JWT, API specs; needs clang), corpus-measure (the three template importers against real signature corpora, re-parsing every emitted script with the engine that runs it), docs (doxygen), docs-html (Markdown docs + tutorials to a self-contained HTML set, via pandoc, with links between pages rewritten from .md to .html and the build failing on a dead link; every page uses the Fissure theme from packaging/docs-html/: the presentation palette dark by default with a light toggle, a left page list, a right-hand table of contents, offline title/heading search, text that reflows to the full width of the window, code blocks that wrap long lines instead of cutting them off (ASCII diagrams stay unwrapped and scroll, and a per-block Wrap / No wrap toggle sits next to Copy), tables whose long cells break instead of overflowing, previous/next links, and an index of page cards), format (clang-format), appimage (distributable AppImage), deb (self-contained Debian package: binary + resources
    • bundled libs under /opt/fissure, a /usr/bin launcher, and a desktop menu entry + icon), appimage-test (verify the AppImage is self-contained on a clean host via a fresh debian:trixie-slim container that lacks the app-specific bundled libs, needs docker), docker-build (build the .deb + AppImage inside a Debian container, see below), show-version and bump-version (print and change the stored version, see the next entry; deb-pkg/appimage-pkg are the names CI and the release scripts use for deb/appimage), clean. Run packaging/fetch-chromium.sh before appimage/deb to bundle the Fissure Browser (see below).
  • Stored version, changed by hand: FISSURE_VERSION lives in src/fissure_version.h (shown by fissure --version, the /api/status version, and report metadata) and changes only with make bump-version, which raises the last number by one (a plain increment with no rollover, 5.3.9 becomes 5.3.10) and prints old -> new; make bump-version VERSION=x.y.z stores that exact value instead and refuses anything that is not three numbers. make show-version prints the stored version alone. No other target writes it: make deb, make appimage, make docker-build, make installer-windows, make windows-installer and make release package the version the tree carries, so building twice gives the same file names and the second build overwrites the first. A release is: bump, commit, build. Passing an explicit VERSION= to docker-build.sh names that one build and writes nothing. The version lives in its own small header, so a change recompiles only the few files that show it, not the whole tree. The non-cross installer-windows builds a setup.exe from a NATIVE MSYS2 build; the Windows binary can also be produced WITHOUT Windows, see the cross-build entry below.
  • Single-version full release (make release): builds every distributable at the version the tree carries; it does not change the version (run make bump-version and commit first). It produces the local .deb and AppImage (deb-pkg, appimage-pkg), the Docker release .deb and AppImage (docker-build.sh given the version explicitly; codename-tagged as usual), the cross-built Windows binary staged with its DLLs in dist/windows/ (make windows), and the Windows installer dist/fissure-<version>-setup.exe (make windows-installer). A preflight (release-preflight: docker, dpkg-deb, the mingw-w64 cross compiler, makensis, the make windows-deps sysroot, and osslsigncode with the pinned signing key, because the Windows steps of a release run with WIN_SIGN=1) runs before anything is built, so a release refused for a missing tool builds nothing. BASE_IMAGE, FETCH_CHROMIUM, DOCKER and NILOREA_DIR reach the Docker step as with make docker-build.
  • Reproducible Debian release build in Docker (make docker-build, packaging/Dockerfile + packaging/docker-build.sh): build the .deb and AppImage inside a Debian container instead of on the host, so no toolchain is needed on the host and no host-built objects (linked against a different glibc) leak into the artifacts. The script mounts this repo and the sibling nilorea-library read-only, compiles a clean copy inside the container (Fissure builds nilorea from source via the Makefile NILOREA path), runs make deb appimage, and copies the artifacts back to the host. This is the RELEASE path, so unlike a local make deb/make appimage testing build it bundles the Fissure Browser (Chromium) by default (so the .deb ships the browser AND declares its runtime libraries, NSS/nspr/CUPS/gbm/...) and tags the artifacts with the container Debian codename, making them distinct from the generically named local builds: dist/fissure_<version>-<codename>_amd64.deb and dist/fissure-<version>-<codename>-x86_64.AppImage (release) versus dist/fissure_<version>_amd64.deb and dist/fissure-<version>-x86_64.AppImage (local testing). The container base fixes which Debian release the .deb targets, because a native .deb's computed Depends are release-specific (the t64 package names differ per release): the default debian:trixie-slim targets current Debian 13 stable, so the release artifacts run on Debian 13+ and equivalent-or-newer distros with Depends matching a fresh trixie install; to target an OLDER release for wider reach, override the base with BASE_IMAGE=debian:bookworm-slim (Debian 12) or BASE_IMAGE=debian:bullseye-slim (Debian 11, glibc 2.31, the widest, binary needs only GLIBC_2.29); FETCH_CHROMIUM=0 skips bundling the browser; NILOREA_DIR, IMAGE, and DOCKER are also overridable. Requires docker.
  • Packaging dependencies and the bundled browser: both appimage and deb optionally bundle a pinned Chromium (the Fissure Browser) fetched by packaging/fetch-chromium.sh into chromium/ next to the binary; absent, the app falls back to a system Chromium/Chrome. The two formats handle runtime libraries differently. The AppImage bundles the app's own library closure (everything except the always-present host desktop stack: glibc, X11, OpenGL/libglvnd, GTK), and the bundled Chromium relies on the host having its standard runtime libraries (NSS, gbm, ALSA, CUPS, pango, ...), the same expectation as any Chrome install; appimage-test covers the app's self-containment. The .deb instead DECLARES its runtime dependencies: packaging/deb-depends.sh runs at build time, ldd's the Fissure binary and the bundled Chromium, drops the libraries already shipped under /opt/fissure/lib, and maps the rest to the packages that provide them, so apt install ./fissure.deb pulls the host desktop stack AND Chromium's runtime libraries automatically (the control file's Depends is computed, not hand-maintained). A native .deb targets the Debian release it is built on: the computed package names (e.g. the t64 set) are release-specific, so install it on a matching release or rebuild for an older one; the AppImage, which bundles its libs and only assumes the desktop stack, is the more portable option for older or mixed hosts. Both are verified end to end in a clean container (the app runs and the bundled browser drives a DOM probe).
  • Bundled documentation: the AppImage and .deb carry the Fissure user documentation (the design/reference docs and the Fissure tutorials) as HTML next to the binary, with a uniform index. Internal project-management docs (the roadmap, backlog, and parity plans) and third-party tutorials are deliberately excluded, so the bundle is Fissure-only. The .deb adds a "Fissure Documentation" application-menu entry, and the in-app Help view's "Documentation" button opens the bundled docs in the browser (falling back to a pointer to the source docs when a dev build has no bundled HTML). Fissure installs under the Internet menu category.
  • Regression tests under tests/ grow with every feature.
  • Nilorea infrastructure is compiled from source (not linked); crypto/GUI/network primitives live upstream in Nilorea with Doxygen + example + test.

Vulnerable-target lab and scoring harness

  • Local, loopback-only vulnerable targets under lab/<id>/ for regression-testing and scoring the scanner, checks and reporting against a labelled corpus: lab/dvwa/ (DVWA, the reference target), lab/juiceshop/ (OWASP Juice Shop, a Node SPA + REST/JSON API with JWT bearer auth), lab/mutillidae/ (OWASP Mutillidae II, a param-routed PHP app with wide OWASP Top-10 coverage, scanned authenticated as admin via a form login), lab/vampi/ (OWASP VAmPI, a Flask REST API run as a vulnerable + a hardened "secure twin" for a clean false-positive count), lab/bwapp/ (bWAPP, a wide PHP target reached through its <select> bug-choice dropdown), lab/dvga/ (DVGA, the Damn Vulnerable GraphQL Application, scanned unauthenticated for GraphQL introspection and the deeper GraphQL surface), lab/crapi/ (OWASP crAPI, a microservice REST API + Angular SPA scanned authenticated with a JWT bearer and a curated deep-endpoint seed list), lab/dvws/ (DVWS, a PHP REST/SOAP/XML web-service target scanned for command injection, SQL injection and reflected XSS), lab/webgoat/ (OWASP WebGoat, a Java/Spring target scanned authenticated for the exposed Spring Boot Actuator and framework information disclosure), lab/benchmark/ (OWASP Benchmark, a Java measurement target of ~2740 labeled test cases with its own per-test-case scorer for true/false-positive rates per vulnerability category), lab/vulhub/ (a parametrized OWASP Vulhub CVE-regression runner that stands up one CVE environment on loopback and verifies the expected finding via Fissure's nuclei templates) and lab/lfi/ (an LFI-to-RCE configuration for the log-poisoning chain). Every target binds to 127.0.0.1 only and is intentionally vulnerable; see each lab/<id>/README.md and docs/12_DVWA_LAB.md / docs/16_VULNERABLE_TARGET_LAB.md.
  • A single generic runner, lab/run-target.sh <id>, drives every target through one code path: generate gateway certs, docker compose up, wait on a healthcheck, bootstrap (DB init / reset), then per authentication variant reset, scan and report, score, and optionally tear down. Auth is pluggable: a form mode replays a cookie login config (DVWA), a header_cmd mode runs a per-target auth.sh that prints the auth header line(s) (a JWT Authorization: Bearer, a token cookie, an API key) which the runner injects into every scan request (Juice Shop, VAmPI), and a none mode scans an unauthenticated surface (DVGA). For the --drive api path the runner pushes the target's scope.json into the control-API session (POST /api/scope) before scanning, so a scan is not refused as out-of-scope, and it drives the ASYNC POST /api/scans (polling the job to completion) so an authenticated or seeded target gets its auth headers and seed URLs applied over the api the same way the cli drive does (the sync POST /api/scan honors only a cookie). A target may also declare a secure_twin (a hardened instance): the runner scans it after the vulnerable one and scores it against an empty-expected ground truth, so any finding there is a false positive - the clean FP measurement (VAmPI). It reads a machine-readable descriptor lab/<id>/target.yaml (id, category, setup, base URL, healthcheck, bootstrap, auth variants, reset, teardown, expected findings) via the tiny lab/labdesc.py helper, and confines work to the target's lab/<id>/scope.json. Drive modes: --drive cli (the direct fissure scan path, the default) and --drive api (the control API, fissure serve + the async POST /api/scans); the agent/skill path (fissure_bug_bounty over MCP) is driven through the MCP tools and scored the same way.
  • A scoring harness, lab/score.py, diffs the findings in a Fissure JSON report against the target's expected_findings.json and reports recall and precision, per target and per vulnerability class, writing score.json + score.md into the timestamped run directory under reports/<id>_<DATE_TIME>/. Ground truth is split into expected (what recall is measured over) and allowed (legitimate but unscored classes, so passive header/info volume does not sink precision); a finding matching neither is a false positive, and on a secure twin every finding counts as a false positive. The scorer is regression-tested without Docker by make lab-selftest (lab/score.py --selftest) against a committed fixture.
  • DVWA runs through this generic runner with no behaviour change: lab/dvwa/run.sh is a thin wrapper over lab/run-target.sh dvwa, preserving the DVWA_URL / DVWA_LEVELS / FISSURE / OUT / DVWA_STOP overrides and the per-level Markdown + JSON reports, now with a score summary added.

Platform notes (Windows / MSYS2)

Fissure is Linux-first but builds and runs natively on Windows under MSYS2 mingw64 (make installer-windows produces a setup.exe). The same fissure.exe can also be CROSS-COMPILED on a plain Linux box with no Windows and no MSYS2: make windows-deps builds a dependency sysroot under external/mingw/ (Allegro prebuilt from the Allegro project's mingw release; zlib, pcre2, libyaml, openssl, libxml2 and xmlsec1 cross-built from source), then make windows cross-links the exe and stages it beside its DLLs in dist/windows/. make windows-check cross-compiles every unit against the sysroot (the complete version of the syntax-only make winsweep), and make windows-installer cross-builds the NSIS dist/fissure-<version>-setup.exe too (makensis runs on Linux, reusing packaging/installer.nsi; collect-dlls stages via objdump instead of the native ldd). The windows-cross CI workflow runs all of it on Linux and uploads both the loose build and the setup.exe. The packaged Windows files say what they are: fissure.exe and fissure-cli.exe carry a version resource (company NiloreaStudio, product, file name, version), every exe and DLL in dist/windows/ and in the installer is stripped of its debug sections, and, when osslsigncode and the publisher's key are on the build machine, each of them, the installer and the uninstaller are signed with the self-signed NiloreaStudio certificate, whose public half ships beside the exe as NiloreaStudio.cer (WIN_SIGN=auto|1|0; the key lives outside the tree, a build never creates it, the Makefile pins its fingerprint, and make release fails rather than build unsigned; README "Windows: the signature" has the fingerprint and the certutil commands, and docs/PORTABILITY.md "Signing the Windows build" the build side). HTTP/3 is built in: the sysroot includes nghttp3 and ngtcp2 with the vanilla-OpenSSL QUIC backend (which is why the cross OpenSSL is 3.5.x), so the cross build has the same h3 fetch tool and h3proxy as the native build. See docs/PORTABILITY.md. These points differ on Windows:

  • Configuration directory: %APPDATA%\Fissure (falling back to %USERPROFILE%\.config\fissure, and only then to $HOME), not the POSIX $HOME/.config/fissure. It holds the proxy CA, the projects, the scan history and the settings. The location matters because MSYS2 sets HOME inside its own installation: a $HOME-derived directory put all of that under C:\msys64\home\<user>, and a launch from Explorer, the Start Menu or a plain cmd - where HOME is not set at all - then found none of it and came up as a fresh install with no CA and no past scans. %APPDATA% is set in both cases. A configuration tree left by an earlier build is moved across automatically on the first run, and Fissure says on screen what it moved (or, if the move failed, where the old tree still is). XDG_CONFIG_HOME still overrides everything, on Windows as on Linux.

  • Saved settings and workspaces really persist. Every store Fissure keeps (settings, keyboard shortcuts, sessions, projects, the cookie jar, saved queries) is written by creating a temporary beside the file and renaming it over the original, so a crash leaves either the old file or the new one, never half of one. The Windows C runtime's rename refuses to replace an existing file, so the first write of a fresh file landed and every save after it silently failed: a Windows operator could set a preference once and never change it. The replace is now the platform's own (MoveFileEx), and the temporary is flushed to disk before it is put in place.

  • The OSS-tool plugins are not available on Windows. Plugins run external tools that a Unix-shell dependency manager installs, so the plugin host and the dependency manager are compiled out there and the GUI, control API and MCP say so rather than failing quietly. Use extensions (in-process JavaScript) or the built-in checks instead.

  • The headful CDP debug browser (DOM Invader's own launch) is Linux-only. The ordinary Fissure Browser launch works on Windows; only the isolated debug-port launch is not built there, and it reports that rather than starting a browser with no debug port.

  • Embedded browser: the bundled Fissure Browser (Chromium) is not shipped on Windows. The Fissure Browser, DOM Invader and CDP features instead drive a system-installed Chrome or Edge (discovered under %ProgramFiles%/%ProgramFiles(x86)%/%LocalAppData%, or $FISSURE_CHROME).

  • Stopping the proxy does not wait for the browser. A browser leaves several kept-alive connections open and idle, each parking a proxy worker in a read, and Winsock does not reliably wake a thread blocked in recv when another thread shuts its socket down (the same divergence the accept loop already works around). Stop therefore used to wait out each connection's full 30-second idle timeout, and with the browser reconnecting it read as "the proxy will not stop until I close the browser". Client legs now read in short slices and check the running flag between them, so Stop returns promptly with the browser still open, on both platforms.

  • Browser CA trust: automatic. Chrome and Edge read the Windows certificate store and have no per-profile NSS database to seed, so launching the browser from the Proxy view installs the Fissure CA into the Trusted Root store of the CURRENT USER (the Win32 certificate API, no elevation, no other account touched) and reports that it did. This is a wider and longer-lived grant than the Linux path makes - there the CA goes into the throwaway profile's own NSS database and dies with it - so the launch message says so explicitly, and Settings carries "Trust CA for this account" / "Remove CA from this account" buttons beside "Export CA certificate" to do it and undo it by hand. Remove it when you finish testing. (Firefox uses its own NSS store on Windows and is not covered; export the CA and import it there.)

  • Plugins: the OSS-tool plugin host and its dependency manager run external tools installed by a Unix shell dependency manager (apt/pip/go/git), so the plugin subsystem is disabled on Windows. The Plugins view stays launchable but shows why it is empty, and the /api/plugins* and /api/reconchain control-API routes return 501. Use Extensions or the built-in scanner checks instead.

  • Extensions: fully available on Windows. They are interpreted in-process by the bundled QuickJS engine (no external tools), so extension checks, panels and actions work the same as on Linux.

  • No console window: fissure.exe is a GUI-subsystem binary, so launching it from Explorer, the Start Menu or the installer opens the GUI alone, with no terminal window behind it. Run from cmd.exe or PowerShell it re-attaches to that console, so the CLI subcommands (fissure scan, fissure serve, -v, -h) still print there and output redirection to a file still works. External console tools Fissure launches (the PDF generator, certutil) also run without popping up a console window.

  • fissure-cli.exe (scripted runs): the installer puts a small console front end next to fissure.exe. Windows does not make a shell wait for a GUI-subsystem process, so fissure.exe scan ... returns the prompt immediately; fissure-cli.exe runs the same program, blocks until it finishes and exits with its exit code, which is what a batch file or a CI step needs:

    fissure-cli scan https://target --format html > report.html
    if errorlevel 1 goto :failed

    Arguments are forwarded byte for byte (the raw command line is passed through, never re-quoted), stdin/stdout/stderr and redirections are inherited, and Ctrl+C stops both. Use fissure-cli from scripts and fissure for the GUI; on Linux the single fissure binary already does both.

  • Installer docs: the setup.exe bundles an optional Documentation component (the HTML docs and tutorials, opened from a Start Menu link). It is included only when pandoc is present at build time to generate them; without pandoc the installer is built without that component (no empty section, no NSIS warning).

Appendix: every control-API route and MCP tool, by name

The sections above describe what Fissure does; this appendix names the identifiers, so a reader searching for a route path or an MCP tool name finds it here even when the prose calls the capability something else. The authoritative descriptions live in 11_CONTROL_API.md (routes) and in the skill's references/mcp_tools.md (tools); a build-time check (tests/test_control_routes) already fails when a route is missing from its documentation row, missing a client-library call, or missing an @mcp.tool that reaches it, and when the bridge's tool names and the skill catalog's tool bullets are not exactly the same set (no tool without an entry, no entry naming a tool the bridge does not expose, no tool listed twice) or when a catalog entry's signature omits an argument the tool takes or documents one it does not. This list is generated from the same sources.

Control-API routes (190)

POST   /api/aclbypass
POST   /api/apispec
POST   /api/apispecfetch
GET    /api/assets
POST   /api/assets
POST   /api/attackcfg
GET    /api/attackcfgs
POST   /api/auth/check
POST   /api/authbypass
POST   /api/authmatrix
POST   /api/authz
GET    /api/autorepeater
POST   /api/autorepeater
POST   /api/bcheck
POST   /api/bizlogic
GET    /api/ca
POST   /api/cache
POST   /api/clickjack-poc
POST   /api/compare
POST   /api/cookie
GET    /api/cookiejar
POST   /api/cookiejar
POST   /api/cspt
POST   /api/cspt-confirm
POST   /api/csrf-active
POST   /api/csrf-poc
POST   /api/deser
POST   /api/deserchain
POST   /api/dirlist
POST   /api/discover
POST   /api/dominvader
POST   /api/domprobe
POST   /api/editor
GET    /api/editors
GET    /api/env
POST   /api/env
POST   /api/env/expand
GET    /api/events
POST   /api/ext-action
GET    /api/ext-actions
GET    /api/extensions
POST   /api/extensions
POST   /api/extensions/bundle
POST   /api/extensions/state
POST   /api/finding/annotate
POST   /api/finding/highlight
POST   /api/findings/clear
POST   /api/graphql
POST   /api/groupsend
POST   /api/h3proxy
GET    /api/hae
POST   /api/hae
POST   /api/hae/apply
POST   /api/headlesscrawl
GET    /api/hostroutes
POST   /api/hostroutes
POST   /api/http3
POST   /api/http3-diff
POST   /api/http3-smuggle
POST   /api/idor
POST   /api/inspect
POST   /api/intruder
POST   /api/jaeles
GET    /api/jobs
POST   /api/jobs
POST   /api/jobs/clear
POST   /api/jscheck
POST   /api/jslib
POST   /api/jsmine
POST   /api/jstransform
POST   /api/jwt
POST   /api/liveaudit
POST   /api/logpoison
POST   /api/macro/record
GET    /api/marketplace
POST   /api/marketplace
POST   /api/massassign
GET    /api/matchrep
POST   /api/matchrep
POST   /api/nosqli
POST   /api/nuclei
GET    /api/oast/beacons
GET    /api/oast/history
POST   /api/oast/hosted
POST   /api/oast/mint
GET    /api/oast/poll
POST   /api/oast/rebind
POST   /api/oast/start
GET    /api/oast/status
POST   /api/oast/stop
GET    /api/organizer
POST   /api/organizer
POST   /api/organizer/remove
POST   /api/originip
GET    /api/paramjar
POST   /api/paramjar
POST   /api/paramminer
GET    /api/plugins
POST   /api/plugins/install
POST   /api/plugins/run
POST   /api/prettify
GET    /api/projects
POST   /api/projects
POST   /api/protobuf
POST   /api/protopollution
POST   /api/proxy/clear
GET    /api/proxy/history
GET    /api/proxy/intercept
POST   /api/proxy/intercept
POST   /api/proxy/intercept/resolve
GET    /api/proxy/intercept/rules
POST   /api/proxy/intercept/rules
POST   /api/proxy/passive
POST   /api/proxy/start
GET    /api/proxy/status
POST   /api/proxy/stop
GET    /api/queries
POST   /api/queries
GET    /api/purple
POST   /api/purple
GET    /api/purple/events
GET    /api/purple/probes
POST   /api/query
POST   /api/race
POST   /api/recon
POST   /api/reconchain
GET    /api/relay/history
GET    /api/relay/intercept
POST   /api/relay/intercept
POST   /api/relay/intercept/resolve
POST   /api/relay/start
GET    /api/relay/status
POST   /api/relay/stop
POST   /api/remediation
GET    /api/repeater/tabs
POST   /api/repeater/tabs
GET    /api/report
POST   /api/report/pdf
POST   /api/report/pwndoc
POST   /api/request/raw
GET    /api/respools
POST   /api/respools
POST   /api/rfd
POST   /api/rolediff
POST   /api/saml
GET    /api/scanprofiles
POST   /api/scanprofiles
GET    /api/schedules
POST   /api/schedules
GET    /api/scope
POST   /api/scope
POST   /api/scopeimport
GET    /api/scopes
POST   /api/scopes
POST   /api/screenshot
GET    /api/screenshots
POST   /api/sequence
POST   /api/session-action
GET    /api/session-actions
POST   /api/session/load
POST   /api/session/save
POST   /api/shadow
POST   /api/smartdecode
POST   /api/smuggle
POST   /api/spider
POST   /api/ssrf
POST   /api/storedxss
GET    /api/surface
GET    /api/tags
POST   /api/tags
POST   /api/tags/eval
POST   /api/takeover
POST   /api/target/highlight
GET|POST /api/team
GET    /api/traffic
POST   /api/traffic/clear
POST   /api/traffic/detail
POST   /api/transform
POST   /api/upload
GET    /api/useragents
POST   /api/useragents
POST   /api/wafbypass
POST   /api/wafbypass/resend
POST   /api/wafdetect
POST   /api/workflow-bypass
GET    /api/workflow-templates
POST   /api/workflow/run
GET    /api/workflows
POST   /api/workflows
POST   /api/wsrepeater
POST   /api/xxe

MCP tools (198)

aclbypass                   apispec                     apispec_fetch               assets
attackcfg                   attackcfgs                  auth_check                  authbypass
authmatrix                  authz                       autorepeater                bcheck
bizlogic                    ca                          cache                       cancel_scan
clear_findings              clickjack_poc               compare                     cookie
cookiejar                   cspt                        cspt_confirm                csrf_active
csrf_poc                    deser                       deserchain                  dirlist
discover                    dominvader                  domprobe                    editor
editors                     env                         env_expand                  env_op
events                      ext_action                  ext_actions                 extension_bundle
extension_state             extensions                  extensions_op               finding_annotate
finding_highlight           get_assets                  get_findings                get_scan_findings
get_scan_status             get_scope                   graphql                     groupsend
h3proxy                     hae                         hae_apply                   headless_crawl
health                      hostroutes                  http3                       http3_diff
http3_smuggle               idor                        inspect                     intercept_resolve
intercept_rules             intercept_rules_set         intercept_set               intercept_status
intruder                    jaeles_import               job_cancel                  job_findings
job_status                  jobs                        jobs_clear                  js_transform
jscheck                     jslib                       jsmine                      jwt
liveaudit                   logpoison                   marketplace                 marketplace_op
massassign                  matchrep                    nosqli                      nuclei_import
oast_beacons                oast_history                oast_hosted                 oast_mint
oast_poll                   oast_rebind                 oast_start                  oast_status
oast_stop                   organizer                   organizer_add               organizer_remove
originip                    paramjar                    paramjar_op                 paramminer
plugin_install              plugin_run                  plugins                     prettify
project_op                  projects                    protobuf                    protopollution
proxy_clear                 proxy_flow                  proxy_history               proxy_passive
proxy_start                 proxy_status                proxy_stop                  purple
purple_events               purple_op                   purple_probes               query
race                        recon                       reconchain                  record_login
relay_history               relay_intercept_resolve     relay_intercept_set         relay_intercept_status
relay_start                 relay_status                relay_stop                  remediation
repeater_tabs               repeater_tabs_op            report                      report_pdf
report_pwndoc               respools                    respools_op                 rfd
rolediff                    run_check                   saml                        saved_queries
saved_queries_op            scan                        scanprofiles                scanprofiles_op
schedules                   schedules_op                scope_import                scopes
screenshot                  screenshots                 send_raw                    send_request
sequence                    session_action              session_actions             session_load
session_save                set_scope                   shadow_repeater             smart_decode
smuggle                     spider                      ssrf                        start_scan
storedxss                   surface                     tags                        tags_eval
tags_op                     takeover                    target_highlight            team
team_op                     traffic                     traffic_clear               traffic_detail
transform                   upload                      useragents                  useragents_op
wafbypass                   wafbypass_resend            wafdetect                   workflow_bypass
workflow_run                workflow_templates          workflows                   workflows_op
wsrepeater                  xxe