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, MCPproxy_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.1with anIP AddressSAN instead of aCN=localhostleaf 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_http2on POST /api/proxy/start (and reported in the proxy status), and as theclient_http2argument of theproxy_startMCP 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
Bodycolumn in the Proxy view reading "capped", and abody_cappedfield onGET /api/proxy/history,/api/proxy/history/{index}and theproxy_history/proxy_flowMCP 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_protobyGET /api/proxy/history,/api/proxy/history/{index}and theproxy_history/proxy_flowMCP 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, therespools/respools_opMCP 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.jsonand 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, thesequenceMCP 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_rawMCP tool (bytes as base64 or as the same escape syntax), and asdata_b64on the interception resolve route and itsintercept_resolveMCP 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 onlibnss3-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 aschromium/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": falsein a JSON reply, strip adisabledattribute 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(withresponses, and adirectionon the held message) and theintercept_status/intercept_set/intercept_resolveMCP 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
.jsworks), 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/rulesand theintercept_rules/intercept_rules_setMCP 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 Niloreanpcre_replacehelper). The same persistent ruleset (<config>/matchrep.json, shared with the GUI) is driveable headless over the control API (GET/POST /api/matchrep) and thematchrepMCP 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 thePOST /api/hae {op:defaults}route and thehae(op="defaults")MCP tool) replaces the current rules with the built-in starter set. Driven headless too:GET/POST /api/hae+POST /api/hae/applyand thehae/hae_applyMCP tools share the same ruleset, and a captured flow carries itshighlight/extractedverdict overGET /api/proxy/history/{index}(and over the listing withhae=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 MCPrelay_*tools. Authorized targets only. - PwnFox-style multi-identity tagging: recognize an identity header a
browser adds to requests (
X-PwnFox-Color, or theX-Fissure-Identityalias), 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 companionresources/wordlists/params.txtfeeds 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/highlightand the MCP tooltarget_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 asPOST /api/reconand the MCP toolreconso an agent can run its own recon toolchain and feed the loop. - One-action recon chain: a
Recon allbutton in the Plugins view (andPOST /api/reconchain/ the MCP toolreconchain) 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
-jsonwebserver + 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. TheSnapshot baselinebutton re-bases the diff (saving the current assets to a per-install snapshot under the config dir). Exposed headless asGET/POST /api/assets(POST optionally merges recon output and/or saves a new baseline) and the MCP toolassets. - 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 inout_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 asPOST /api/originipand the MCP tooloriginip(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 toolwafdetect(fissure_wafdetect, unit-tested). The reply also carriessuggested_encodersandsuggested_request: where to START the input-filter bypass for the product it fingerprinted, droppable straight into a scan aswaf_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 asPOST /api/wafbypass(apply a comma-separated encoder chain) and the MCP toolwafbypass(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 headlessPOST /api/wafbypassreturns 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 asPOST /api/wafbypass/resendand the MCP toolwafbypass_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 asPOST /api/screenshot(capture one URL) andGET /api/screenshots(the gallery index), and the MCP toolsscreenshot/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/surfaceand the MCP toolsurface(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, are:<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 MCPscopestool; persisted to<project>/scopes.json, with the currentscope.jsonmigrated 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_filechecks 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.jsbundles 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 asPOST /api/jsmineand the MCP tooljsmine, 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 isjsmineon the fetched body followed byreconto 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.mapreference: the crawl fetches and mines the.mapautomatically, the GUI "Mine JS" action does too, andPOST /api/jsmine/ the MCPjsminetool mine an inline map and return an external map URL assourcemapto 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/ MCPjslib), 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; alsoPOST /api/cspt/ MCPcspt), 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/ MCPcspt_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, andPOST /api/deser/ MCPdeserscans a targeted value). To ACTIVELY confirm a deserialization lead responsibly, the deserialization marker generator (POST /api/deserchain/ MCPdeserchain, 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 servebinding a non-loopback address without--api-keyis 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--insecureis 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-Siteis honoured where the browser sends it (same-originandnonepass), withOriginas the fallback, matched against theHostthe request arrived on; an opaquenullorigin is refused. A client that sends neither header is not a browser and passes, so the CLI and the bridge are unaffected. Fissure emits noAccess-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/careturns the certificate PEM and its common name, and the MCPcatool 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
Locationsuch aslogin.php(legal, and what PHP applications commonly emit) is resolved against the base path's directory; a root-relative/xand a protocol-relative//host/xare 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 withGET /api/traffic(optionallimitandtoolfilters) and reset it withPOST /api/traffic/clear; MCPtraffic/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, whereproxy_historycovers only proxy-captured flows but with full bodies.Per-host connection routing works headlessly:
GET/POST /api/hostroutesand the MCPhostroutestool 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), andpattern via proxy-urlroutes 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/scanstakestls_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) andproxy_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 MCPstart_scanarguments.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, ortls_verifyonPOST /api/scansand MCPstart_scan(--insecurestill exists and now restates the default, so an existing script keeps working). Every scan launcher (the Target view, thefissure scanCLI 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 theca_filefield onPOST /api/scansand MCPstart_scan. The system bundle is located on Windows as well as Linux: afterSSL_CERT_FILE, a bundle placed in the install's ownresources/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 setSSL_CERT_FILEor 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_reasononGET /api/scans/{id}and MCPget_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/startacceptsmax_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_proxyplusno_proxy(chain the outbound leg),transparent(route origin-form requests by Host header), andoast_inject(seed forwarded in-scope requests with OAST canary headers, catching blind SSRF from ordinary browsing).GET /api/proxy/statusreportsmax_flowsandoast_injectso 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/startand 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.sendthrows 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/checksJS scripts,.bcheckfiles, 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 withPOST /api/proxy/passiveand the MCPproxy_passivetool; the state is reported inGET /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 aspassive_pendingand 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}, MCPproxy_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, MCPdomprobe): 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 pollutingObject.prototype, CWE-1321, HIGH), cross-origin message listeners (INFO), and DOM clobbering gadgets (a named element whosewindow.<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 thedominvaderMCP 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 thehttp3MCP 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 thesend_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 thehttp3_diffMCP 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: chunkedheader, which RFC 9114 forbids in HTTP/3 (placed on the wire via the Nilorean_http3_request_exallow-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 asPOST /api/http3-smuggleand thehttp3_smuggleMCP 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:portfor a manual test) at the listener. An "Upstream over HTTP/3" toggle (theupstreamparam) 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/interceptqueue 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 theh3proxyMCP 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/h3proxy501 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 likeping $ipwhose base command runs for seconds is still detected), LFI / path traversal (relative traversal, an absolute path, andfile:///php://filterstream 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-bandidproof), 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-Overrideoverride 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 aSet-Cookiedoes not pin the session cookie toSameSite=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 atPOST /api/csrf-active/ MCPcsrf_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/%exfilentities, 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).
- 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":
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.bakinside 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 thefilescheck family, on demand from the Probes popup ("Directory listing", with an optional extra-directories field), and headless asPOST /api/dirlist/ MCPdirlist(or as an async job, namedirlist). 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/actuatorindex (the _links map of what is open, MEDIUM) and/actuator/health(LOW);/actuator/heapdumpis covered CRITICAL by the sensitive-file probe above. It runs once per host during an active scan (the FILES family) and standalone overPOST /api/jobsnameactuator/ MCPrun_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/ MCPlogpoison. 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/smuggleand the MCP toolsmuggle(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/raceand the MCP toolrace(a Race-probe request context action drives the same engine, fissure_race).GraphQL tooling: native introspection detection and, when a plain
__schemaquery 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 andvariablesfuzzing; 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 samefissure_graphqlargument tooling exposed overPOST /api/graphqland the MCPgraphqltool. 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 anIntargument (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_groupnow 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
coveredand alow_coverageflag. 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'strafficandtraffic/detailcarryerror_kindand 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", APIhost_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 onGET /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=/logoutdoes 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/phpidsfield), 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, MCPstart_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_containssubstring, 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 itsreauth_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-pagesand the API/MCP asmax_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 ascrawl.pages/crawl.page_cap/crawl.left/crawl.depth_capped/crawl.capped(GET /api/scans/{id}, MCPget_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 CLIfissure scan --profile <name>, the control API (GET/POST /api/scanprofilesto list/save/delete, and aprofilefield on the scan job), the MCP tools (scanprofiles,scanprofiles_op, andstart_scan'sprofile), 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-scriptablePOST /api/scanprofiles(op:"save"|"delete") and the MCPscanprofiles_optool, 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'smax_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'sscan_rps; thescan_rpsfield on/api/scans/ MCPstart_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--headerrepeatable; theheadersfield on/api/scans/ MCPstart_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; theexcludefield on/api/scans/ MCPstart_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=/adminredirect 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 asummaryfield byGET /api/scanprofilesso a headless caller reads the same description. A profile can also restrict WHICH checks run: afamilieslist (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 -injectionis 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), andssrfis 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 apointslist (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/pointsname lists onscanprofiles_op), and the GUI scan.Out-of-band checks run on every scan surface. The
ssrffamily, and the blind halves ofinjection(the SSRF/RCE callback canary) andxxe, 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 synchronousPOST /api/scan, the asynchronousPOST /api/scans(the path behind the MCPstart_scantool) and the recurring scheduler all borrow the control-driven listener fromPOST /api/oast/start, and the CLI starts its own withfissure scan --oast <port>(plus--oast-hostand--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 ssrfwithout--oastexits 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/pointsmasks 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-APIseeds/ MCPstart_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 crawlleft).Scan a request CORPUS directly (CLI
--endpoints-file/ control-APIendpoints/ MCPstart_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 (seelab/benchmark/gen-requests.py), a HAR/Postman-style corpus, or an engagement's known deep requests.headersis aName: value\r\nblock (aCookieline carries cookie insertion points); a urlencoded form field is aparamsentry with nobody(the body is synthesized from the field names). Whenendpointsis given the crawl is skipped and exactly those requests are audited, but the seedurlis still required and its host seeds the scope. (Whereseedsadds URLs to CRAWL for more endpoints,endpointsaudits 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), andjsonpad(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).pollutesends the parameter twice with the benign value first, for a filter that inspects the FIRST occurrence and an application that takes the last;pollutelastis the same pair reversed;bracketsends the name asname[], which PHP and Rails map back to the same variable while a rule keyed on the exact name misses;dotnotationsendsname.xfor a binder framework;charsetdeclares a character set the filter and the application disagree about; andmpboundaryquotes and pads the multipart boundary, a form RFC 2046 allows and strict and lenient parsers split on differently;mpduplicateemits 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/pollutelastemit the same KEY twice in the object holding the target scalar, andbracketsends 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 thewafrequestroute/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
idcommand 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 CLIfissure scan --waf-bypass <chain>, the control-APIwaf_encodersfield onPOST /api/scans, and the MCPstart_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 thejsonunicodeencoder, 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 CLIfissure scan --waf-body, the control-APIwaf_bodyflag onPOST /api/scans, and the MCPstart_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 thexmlbypassencoder: 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: theSYSTEMkeyword becomes aPUBLICexternal 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 onSYSTEMis 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 CLIfissure scan --waf-xml, the control-APIwaf_xmlflag onPOST /api/scans, and the MCPstart_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
utf16encoder, which also rewrites aUTF-8encoding declaration toUTF-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 viafissure_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 CLIfissure scan --waf-xml-utf16, the control-APIwaf_xml_utf16flag onPOST /api/scans, and the MCPstart_scan(..., waf_xml_utf16=True). Theutf16encoder is also in the generalwafbypassencoder set (last in a chain), sowafbypass_resend/send_requestcan 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/tabslists the collections an operator built for the engagement andPOST /api/repeater/tabs(add/remove/update/activate) edits them, reading and writing the same projectrepeater.jsonthe 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_nstores an explicit length). Internal encoders that build such bodies (e.g. UTF-16 XXE) and automation both rely on it: the control API / MCPsend_requestaccepts abody_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.jsonand 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-Agentrequest header wins, then a per-request override (the Repeater picker / control-APIuser_agentfield), then a per-run config override, then the active preset, then the compile-timeFissure/<version>default. AUser-Agentline in a scan's extra-headers is honored without producing a duplicate header. - Headless parity:
GET /api/useragentslists the presets and the active selection;POST /api/useragents({op:"save"|"delete"|"activate"}) manages them; theuseragentsanduseragents_opMCP tools mirror both. A per-run override is available as auser_agentfield onsend_request,intruder, andstart_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/attackcfgslists them,POST /api/attackcfg(get/save/delete) reads and writes one, andPOST /api/intruderaccepts"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"onPOST /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=[...])andattackcfg(..., 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 takesextract,seed, andcount. 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 overPOST /api/finding/highlightand the MCP toolfinding_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-APIPOST /api/session/save(withPOST /api/session/loadrestoring them), so a headless engagement's saved session reloads as evidence rather than as bare claims. The save response reportscaptures_savedseparately, 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), andtool_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), asGET /api/reportquery parameters, and as MCPreportarguments. - 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/remediationand the MCP toolremediation. - Multi-format report export: HTML, Markdown, JSON, CSV, SARIF (CI
code-scanning), and issue XML (the
burpformat, 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.tmplwhen present, else the bundledresources/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 afissure scan/report --format htmlstderr line, and astemplate_errorin the control-API / MCP report response, which also names thetemplateused (custom,bundledorbuiltin). 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 aswkhtmltopdf {{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
trafficrather 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
@timestampand 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, auri=/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 spellingalert(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-1is not satisfied byrun-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) andalerted/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
trafficbucket 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, andfissure purple baseline/diffon 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,404when unreadable. - A complete CLI half:
fissure scan --purple <run>records the scan's own requests (and starts after the--loginreplay, so credentials never enter the probe store), andfissure purple status|import|reconcile|findings|baseline|diff|clear|markerdrives 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.jsonand 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:Objectinside its ownds:Signaturegrafted onto the forged assertion, 3 the original is moved into asamlp:Extensionswrapper - 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 with0x3C('<'). Built on libxml2 + xmlsec1, linked in Fissure. See10_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 amessageflag to beautify only the body of a raw HTTP message and keep the headers), and the MCPprettifytool. 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 MCPprotobuftool. - 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 amarkervariable), with a "Restore defaults" button and aresetop onPOST /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 Nilorean_query) with a shared HTTP field vocabulary (traffictool/method/url/host/path/status/length/time/mime/scope, findingstitle/severity/location/category/host/cwe/owasp/confidence/source/tags/scope) that filters every grid in place; thescopefield isinoroutof 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 visibleScope: allcycle 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 theresetop onPOST /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 (dirc2s/s2c,opcodetext/binary/ping/pong/close/cont,fin,length,seq,payload,url,host,scope), sodir = c2s AND opcode = text AND payload ~ tokennarrows 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/queriesmanage saved filters, and thequery/saved_queries/saved_queries_opMCP 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-pocand the MCPcsrf_poctool 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 theoast_beaconsMCP tool (which reportscountbeacons out ofhits_totalinteractions, 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, MCPoast_rebind) and from the OAST view's Mint, andoast_pollreports the per-token re-resolution count. The rebind timing profile is tunable:ttlsets the served record TTL (a short TTL forces a fast re-query) andflip_afterthe number of benign answers before the flip to internal (raise it to survive a resolver that pins or pre-fetches the first answer).oast_pollalso 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/hostedwith op register/canary/poll/status), and the MCPoast_hostedtool. 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-javaagentjar byagents/java/build.sh) installs an ASMClassFileTransformerthat rewrites the app's bytecode at load time, injecting aFissureIast.autoSinkcall before every sink call site with no app change (regression- tested intests/test_iast_java_auto.c); it also keeps the manualFissureIast.sinkAPI (beacon carries aClass.method(File.java:line)frame) and an optionaljakarta/javaxservlet filter that tags the tainted request parameter/header as the beaconsrc. The .NET agent is fully automatic too:agents/dotnet/FissureIastWeaver.cs, armed from theDOTNET_STARTUP_HOOKSentry point, detours the framework's own sink methods so the app makes no Fissure call at all (regression-tested intests/test_iast_dotnet_auto.c, where the target callsType.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 manualSinkAPI 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. See08_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
textblob 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.jsoninstead, 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-tat a templates dir, or pass-Hauth headers. Two tag-scoped presets ship alongside it:nuclei-cves(high/critical CVE templates) andnuclei-exposures(exposure/config/backup/misconfiguration templates).Dependency manager:
dependencies.jsonholds 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, thenpip install --user(retried with--break-system-packages), then a private venv under the install root whose script is linked into itsbin/, so a PEP 668 externally-managed Python does not block the install; a Ruby tool (wpscan) installs withgem --user-installand is linked the same way; when such a gem has native parts that fail to compile, its declaredbuild_deps(for wpscanruby-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 aurl(agit+httpsspec) 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 orpkexecand, 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 (arjunactive +paramspiderarchive-mined), plus three subdomain sources that run side by side in the recon chain (subfinder,amassandfindomain, 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), plusnaabu(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), anddnsx(DNS records A/AAAA/CNAME for a host). A manifest may declare astdintemplate (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 indocs/audits/OSS_TOOL_INTEGRATION_SURVEY.md.
Scripting and extensibility
- Extension guide:
docs/EXTENDING.mddocuments the three extension surfaces (thefs.*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.jsonmanifest: 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 contributeschecks(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), andactions(on-demand, request-contextualfs.*scripts run against one request from the context menu's "Extension actions",GET /api/ext-actions+POST /api/ext-action, theext_actions/ext_actionMCP tools, session-aware sofs.send()probes carry the request's cookie on an auth-gated target), andsession_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 thesession_actions/session_actionMCP tools; credentials are injected at run time viafs.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 withfs.setvarand 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 withfs.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), andcodec-tools(four two-way message editors: Base64, URL, hex, and JWT decode/tamper/re-encode). Theeditorscontribution 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): acatalog.jsonwith a per-bundle canonicalsha256, a detached Ed25519 signature (catalog.json.sig) verified against a bundled trust key (trust.pub), and packaged payloads understore/. 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 themarketplace/marketplace_opMCP tools; the bundled catalog shipscsp-reportonly(flags a report-only CSP). Seedocs/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_scantool and the recurring scheduler), and the CLIfissure scanall callfissure_scan_load_checks, which loads the*.jsscripts underresources/checks/, any.bcheckfiles, any imported nuclei templates, and the checks contributed by enabled extension bundles. A CLI run that cannot locateresources/checksreports 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()andfs.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-hocPOST /api/jscheckroute each stage the allowlist for the run. With none staged (a bare unit test, a standalone transform) sending is unrestricted. make webui-checkfails whensrc/fissure_webui.cno 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
injectionfamily 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. Selectinginjectionstill enables every sub-family, so existing profiles,--familiesflags 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.pngkeeps 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..500audits once while/item?q=xis 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 taggedscanner, 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/liveauditand theliveauditMCP 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/detailand thetraffic_detailMCP 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/bundleand theextension_bundleMCP 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/stateand theextension_stateMCP 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 asrequestand returns its replacement, or definesmutate(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 fromfs.paramsso a long crawl does not die on an expired token. async/awaitwork in scriptable checks. QuickJS queues eachawaitcontinuation 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
bodyalongside host, method, path, url, status and mime, sobody 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 mentionsbody, 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
bodyquery 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/statusis 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 -hprints one authoritative usage block, shared with the subcommand help rather than kept as a second hand-maintained copy. The copy had drifted: it omittedserveentirely, omitted theburpreport format, and listed 2 of the 22 scan flags.- The Intruder attacks a FULL request, not just a URL.
POST /api/intruderand the MCPintrudertool takemethod,headersandbodyalongside 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/annotateand the MCPfinding_annotatetool 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 asopen. - Clickjacking proof-of-concept over the API:
POST /api/clickjack-pocand MCPclickjack_pocbuild 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/autorepeaterand the MCPautorepeatertool 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/assetswas 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.jschecks, loaded by every path that loads the shippedresources/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
.bcheckfiles intoresources/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 (withdoes not/is notnegation) on the body, headers, or status, theinoperator (which puts the needle FIRST:"root:" in {latest.response.body}is the same condition as{latest.response.body} contains "root:", and inside afor eachblock"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 theirthen, with the and/or precedence they were written with preserved), the block form ofrun 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 andhttp/dns/smtp/any interactionsasks 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), nestedif ... end ifblocks ANDed as the nesting means (anelsebranch is refused instead, being an alternative rather than a requirement), adefine: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 afor eachloop over an inline payload list or a defined variable (<name> = [ ... ]) all compile. Multi-step checks compile too: eachsend 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 (withreplacing/addingprefixes, values in backticks) compile into that step's ownfs.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 (theskippedfield ofPOST /api/bcheck/ thebcheckMCP 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, wherefs.request()is lent the exchange the proxy saw: it carries nofs.activegate 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 whosegivenclause 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. Adefine: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 thebcheckMCP tool: a 129-byte file used to hold the parse indefinitely. The fuzz campaign found it (tests/fuzz/corpus/bcheck/selfref-define-hang.bcheckkeeps 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/.ymltemplates intoresources/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 plusdslexpressions, 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),durationin seconds, and the suffixed forms naming an earlier request's response (body_2,status_code_1). Avariables:block gives a template its own named values, referenced as{{name}}or by bare name. A matcher'spart: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. Abinarymatcher searches for a hex byte sequence in the raw response body via the binary-safefs.bodyhex()primitive (a byte-aligned hex search, so an embedded NUL a UTF-8 string body would drop is still matched); anxpathmatcher selects a node in the HTML/XML body via the libxml2-backedfs.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'sfs.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), andxpath(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"; aninternal: trueextractor 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);xpathmatchers: an XPath expression that must select a node in the HTML/XML body (compiled tofs.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) andkeys, 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 wayattack: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 thefs.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, explicitContent-Length) runs without the nuclei binary; the matchers evaluate the parsed response as usual; - method+path requests carry their
body(inline or abody: |block) andheadersmap, 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: trueis 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 (theskippedfield); a template with nothing usable is refused, as is aself-containedone, whose paths name a fixed external host instead of the target. Also exposed asPOST /api/nucleiand the MCP toolnuclei_import.
- interactsh out-of-band matchers
(
- Jaeles-signature importer (offline): the third format compiler,
alongside the nuclei and BCheck importers. It compiles a Jaeles
detection-signature YAML (
id, aninfoname/risk, optionalvariables, and arequestslist) 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-levelorigin: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 theoresponse/oresHeaderssearch 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. Avariablesblock is resolved, so{{.name}}in a url/body/header/detection substitutes before compiling: literal name/value pairs substitute their text, and theRandomString(n)/RandomNumbergenerators 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 inskipped: 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. Thedetectionsexpressions compile to response tests: theStatusCode()andContentLength()helpers as numeric comparisons,StringSearch(component, "text")as a case-insensitive contains, andRegexSearch(component, "regex"), over the componentscomponent.response/component.body/component.header, combined with&&/||/!. Atype: passivesignature (or a top-leveldetections: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 theskippedfield (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 sendsX-Forwarded-Forrather than- X-Forwarded-For. Also exposed asPOST /api/jaelesand the MCP tooljaeles_import; run the emitted check viaPOST /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 MCPauth_checktool, andfissure 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 MCPparamjarandparamjar_optools, a Parameters tab in the browser dashboard, and the CLI flags--param name=valuewith--param-in query|body,--param-trackand--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 MCPcookiejartool; persisted to<config>/cookiejar.jsonso 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_cookiesonPOST /api/proxy/startand the MCPproxy_starttool, persisted in settings) it folds what it sees into the shared cookie jar: every in-scope response'sSet-Cookie, and every request'sCookieheader, 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-pkceand the MCPoauth_pkcetool 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_browserlogindrives 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/browserloginand the MCPbrowserlogintool. - 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/curlimportand the MCPcurlimporttool return the same parts for an agent to feed tosend_request, the Intruder or any check. It reads what the browsers emit (-X,-H,-bfolded into a Cookie header, the-dfamily,--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 absolutescheme://hostURL 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 scanpicks 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 (aCookie: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 withimported: N), and the MCPcookiejartool takes the samecookieargument. It accepts the shapes a browser actually produces: a barename=value; name2=value2(whatdocument.cookiereturns and what the Cookie request header carries), the same with a leadingCookie:orSet-Cookie:header name (aSet-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 anhttpsURL 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_containsmarker 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 tosessrules.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 therecord_loginMCP 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
defaultenvironment (host, base_url, token, cookie slots), with a "Restore defaults" button and aresetop onPOST /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_storespins 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, opremove_member), and the MCPteam/team_optools. 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 listauthis preferred wherever it appears,auth-intonly whenauthis 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-spaCLI flag, thespaoption onPOST /api/scansand MCPstart_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/MCPclear_findingsresets 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_scalerecomputed 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 toTHIRD_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/fontsand 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 inresources/fonts/LICENSES. Pure table + clamping infissure_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.jsonand 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).
fissurewith 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 serveruns 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|installlists the OSS-tool plugins and installs the external tools they wrap, headless (the equivalent of the GUI Plugins view's "Install all").fissure --helpprints the authoritative options andfissure --versionthe build version. - Headless plugin management:
fissure plugins listshows each bundled plugin's id, category, and whether its tool is present;fissure plugins install --allinstalls every missing tool andfissure plugins install <id>...installs named plugins (by plugin id or dependency id), both with--dry-runto 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--loginreplay, so credentials never enter the store) and reports the per-technique tally when it finishes, andfissure purple status|import <file>|reconcile|findings|baseline|diff| clear|markerdrives the rest.fissure purple diffexits 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/requestto send one request through the engine,POST /api/scansynchronous, and an async scan job APIPOST /api/scans+GET /api/scans/{id}status/progress +/findings+/cancel, wherePOST /api/scanstakes an optionalloginlogin-config object for an authenticated scan. On-demand checks also run as async cancellable jobs:POST /api/jobsruns 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/jobsis the unified monitor of all jobs (scans + checks: id, kind, name, target, status, elapsed, running/queued/total counts), withGET /api/jobs/{id}[/findings]andPOST /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 (thecontrol_api_max_jobssetting, default 4) bounds how many jobs run at once; the rest queue and are promoted as slots free (GET /api/jobsreportsrunning/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+ thejobs_clearMCP 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-processGET /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 asGET /api/events/ MCPevents({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), andGET /api/report?format=(markdown/html/json/csv/sarif/burp, with optionalmin_severity/host/sourcefilters and a risk score/band), PwnDoc exportPOST /api/report/pwndocand PDF renderingPOST /api/report/pdf, the GraphQL argument workshopPOST /api/graphql, the signed-cookie workshopPOST /api/cookie, the SAML workshopPOST /api/saml(decode/inspect/edit/strip/ wrap/genkey/sign/verify), the request InspectorPOST /api/inspect, scope-text importPOST /api/scopeimport, a user-JS transformPOST /api/jstransform, a.bcheckcompilerPOST /api/bcheck, and a nuclei-template compilerPOST /api/nuclei; plus the IntruderPOST /api/intruder(sniper/battering-ram/pitchfork/clusterbomb with grep;payloadstakes 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 discoveryPOST /api/discover, parameter miningPOST /api/paramminer, API-definition importPOST /api/apispec(OpenAPI/Swagger/Postman, JSON or YAML) and live spec auto-fetchPOST /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 bridgePOST /api/recon(route recon-tool host/URL output into the inventory and scope), the recon asset diffGET/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 crawlPOST /api/headlesscrawl(katana -headless routed into the inventory), the JavaScript endpoint/secret minerPOST /api/jsmine, the HTTP request-smuggling desync probePOST /api/smuggle, group sendPOST /api/groupsend(sequential/parallel/HTTP-2 single-packet race), the WebSocket RepeaterPOST /api/wsrepeater, a scriptable check runnerPOST /api/jscheck(fetch + QuickJS check -> findings), authorization testing (the auth matrixPOST /api/authmatrix, the Autorize-style replayPOST /api/authz, and the offline role diffPOST /api/rolediff), the OSS-tool plugin host (listGET /api/plugins, runPOST /api/plugins/run-> findings, and build a dependency install commandPOST /api/plugins/install, which the API never executes), the extension SDK registry (list installed bundlesGET /api/extensions, enable/disable/reload themPOST /api/extensions), the out-of-band (OAST) collector for blind vulnerabilities (startPOST /api/oast/start, mint a canaryPOST /api/oast/mint, poll itGET /api/oast/poll, and read interactionsGET /api/oast/history), the workspace data stores that drive the same on-disk files as the GUI (projectsGET/POST /api/projects- activating one also re-points the per-project stores the control engine holds in memory, re-resolving the extension state directory behindfs.storeand 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 libraryGET/POST /api/env+POST /api/env/expand, the inline transform tagsGET/POST /api/tags+POST /api/tags/eval, the saved-request organizer/collectionsGET/POST /api/organizer+/remove, session save/loadPOST /api/session/save/load, and the shared-project team collaborationGET/POST /api/team(members, presence, advisory locks, assignments, activity)), and scope managementGET/POST /api/scopeapplied to scans, intruder, discover, and the param miner; and a control-driven live intercepting proxyPOST /api/proxy/start/stop,GET /api/proxy/status,GET /api/proxy/history[/{index}], andGET/POST /api/proxy/intercept(+/resolveto forward/drop a held request), the generic non-HTTP raw TCP/UDP relayPOST /api/relay/start/stop,GET /api/relay/status,GET /api/relay/historyandGET/POST /api/relay/intercept(+/resolveto 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 viafissure serve(--host/--port/--api-key). Loopback only; token asX-API-KeyorAuthorization: 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 thefissure_bug_bountyskill / 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-httpat/mcporsseat/sse, optionalFISSURE_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'ssessionStorage) and every data call it makes carriesX-API-Key. The token field is masked with a Show/Hide toggle (masked via CSS text-security, not atype=passwordinput, so the browser's password-manager / breach-detection behaviour never freezes the page on paste; Ctrl+V works). An optional operator-name field (held inlocalStorage) 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. Openhttp://127.0.0.1:<port>/afterfissure serveor 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_bountyskill (.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-shotplus 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, sotests/test_guigeomturns "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-opensays 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/runreturnsexit_codeandran. - 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/checksis 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.txtis 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/spiderroute returnsscript_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.
- 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
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:testscompiles 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 withmake SAN=tsanand run the headless--selftest-*flags withTSAN_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.mdto.htmland 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/binlauncher, 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-versionandbump-version(print and change the stored version, see the next entry;deb-pkg/appimage-pkgare the names CI and the release scripts use fordeb/appimage),clean. Runpackaging/fetch-chromium.shbeforeappimage/debto bundle the Fissure Browser (see below).
- bundled libs under
- Stored version, changed by hand:
FISSURE_VERSIONlives insrc/fissure_version.h(shown byfissure --version, the/api/statusversion, and report metadata) and changes only withmake bump-version, which raises the last number by one (a plain increment with no rollover,5.3.9becomes5.3.10) and printsold -> new;make bump-version VERSION=x.y.zstores that exact value instead and refuses anything that is not three numbers.make show-versionprints the stored version alone. No other target writes it:make deb,make appimage,make docker-build,make installer-windows,make windows-installerandmake releasepackage 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 explicitVERSION=todocker-build.shnames 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-crossinstaller-windowsbuilds 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 (runmake bump-versionand commit first). It produces the local.deband AppImage (deb-pkg,appimage-pkg), the Docker release.deband AppImage (docker-build.shgiven the version explicitly; codename-tagged as usual), the cross-built Windows binary staged with its DLLs indist/windows/(make windows), and the Windows installerdist/fissure-<version>-setup.exe(make windows-installer). A preflight (release-preflight: docker, dpkg-deb, the mingw-w64 cross compiler, makensis, themake windows-depssysroot, andosslsigncodewith the pinned signing key, because the Windows steps of a release run withWIN_SIGN=1) runs before anything is built, so a release refused for a missing tool builds nothing.BASE_IMAGE,FETCH_CHROMIUM,DOCKERandNILOREA_DIRreach the Docker step as withmake docker-build. - Reproducible Debian release build in Docker
(
make docker-build,packaging/Dockerfile+packaging/docker-build.sh): build the.deband 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 siblingnilorea-libraryread-only, compiles a clean copy inside the container (Fissure builds nilorea from source via the MakefileNILOREApath), runsmake deb appimage, and copies the artifacts back to the host. This is the RELEASE path, so unlike a localmake deb/make appimagetesting build it bundles the Fissure Browser (Chromium) by default (so the.debships 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.debanddist/fissure-<version>-<codename>-x86_64.AppImage(release) versusdist/fissure_<version>_amd64.debanddist/fissure-<version>-x86_64.AppImage(local testing). The container base fixes which Debian release the.debtargets, because a native.deb's computedDependsare release-specific (thet64package names differ per release): the defaultdebian:trixie-slimtargets current Debian 13 stable, so the release artifacts run on Debian 13+ and equivalent-or-newer distros withDependsmatching a fresh trixie install; to target an OLDER release for wider reach, override the base withBASE_IMAGE=debian:bookworm-slim(Debian 12) orBASE_IMAGE=debian:bullseye-slim(Debian 11, glibc 2.31, the widest, binary needs only GLIBC_2.29);FETCH_CHROMIUM=0skips bundling the browser;NILOREA_DIR,IMAGE, andDOCKERare also overridable. Requires docker. - Packaging dependencies and the bundled browser: both
appimageanddeboptionally bundle a pinned Chromium (the Fissure Browser) fetched bypackaging/fetch-chromium.shintochromium/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-testcovers the app's self-containment. The.debinstead DECLARES its runtime dependencies:packaging/deb-depends.shruns 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, soapt install ./fissure.debpulls the host desktop stack AND Chromium's runtime libraries automatically (the control file'sDependsis computed, not hand-maintained). A native.debtargets the Debian release it is built on: the computed package names (e.g. thet64set) 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
.debcarry 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.debadds 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) andlab/lfi/(an LFI-to-RCE configuration for the log-poisoning chain). Every target binds to127.0.0.1only and is intentionally vulnerable; see eachlab/<id>/README.mdanddocs/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: aformmode replays a cookie login config (DVWA), aheader_cmdmode runs a per-targetauth.shthat prints the auth header line(s) (a JWTAuthorization: Bearer, a token cookie, an API key) which the runner injects into every scan request (Juice Shop, VAmPI), and anonemode scans an unauthenticated surface (DVGA). For the--drive apipath the runner pushes the target'sscope.jsoninto the control-API session (POST /api/scope) before scanning, so a scan is not refused as out-of-scope, and it drives the ASYNCPOST /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 syncPOST /api/scanhonors only a cookie). A target may also declare asecure_twin(a hardened instance): the runner scans it after the vulnerable one and scores it against an empty-expectedground truth, so any finding there is a false positive - the clean FP measurement (VAmPI). It reads a machine-readable descriptorlab/<id>/target.yaml(id, category, setup, base URL, healthcheck, bootstrap, auth variants, reset, teardown, expected findings) via the tinylab/labdesc.pyhelper, and confines work to the target'slab/<id>/scope.json. Drive modes:--drive cli(the directfissure scanpath, the default) and--drive api(the control API,fissure serve+ the asyncPOST /api/scans); the agent/skill path (fissure_bug_bountyover 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'sexpected_findings.jsonand reports recall and precision, per target and per vulnerability class, writingscore.json+score.mdinto the timestamped run directory underreports/<id>_<DATE_TIME>/. Ground truth is split intoexpected(what recall is measured over) andallowed(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 bymake lab-selftest(lab/score.py --selftest) against a committed fixture. - DVWA runs through this generic runner with no behaviour change:
lab/dvwa/run.shis a thin wrapper overlab/run-target.sh dvwa, preserving theDVWA_URL/DVWA_LEVELS/FISSURE/OUT/DVWA_STOPoverrides 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 setsHOMEinside its own installation: a$HOME-derived directory put all of that underC:\msys64\home\<user>, and a launch from Explorer, the Start Menu or a plain cmd - whereHOMEis 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_HOMEstill 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
renamerefuses 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
recvwhen 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/reconchaincontrol-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.exeis 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 tofissure.exe. Windows does not make a shell wait for a GUI-subsystem process, sofissure.exe scan ...returns the prompt immediately;fissure-cli.exeruns 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 :failedArguments 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-clifrom scripts andfissurefor the GUI; on Linux the singlefissurebinary 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
pandocis 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