Fissuredocumentation v5.3.1
On this page

05 - Full Website Scanner

This document designs Fissure's full website scanner: the subsystem that collects every reachable endpoint of a target, enumerates the parameter and input surface, runs a catalog of vulnerability tests (built-in and plugin), and emits FISSURE_FINDING records into the unified findings store. It is built for bug-bounty recon and CTF use.

Read alongside the sibling docs:

  • 00_MASTER_PLAN.md - phasing and scope of the project.
  • 01_SECURITY_TOOLS_CATALOG.md - the external OSS tools (nuclei, sqlmap, ffuf, dalfox, subfinder, ...) the plugin host shells out to.
  • 02_ARCHITECTURE.md - the data model (FISSURE_ENDPOINT / FISSURE_FINDING / FISSURE_CAPTURE) and the store.
  • 03_GUI_DESIGN.md - the scanner panels, profile editor, and recon dashboard widgets.
  • 04_NETWORK_AND_PROXY.md - the intercepting proxy whose history seeds passive discovery, and the transport core.
  • 06_REPORTING.md - how findings become a report.
  • resources/dependencies.json - downloadable wordlists, payload sets, and external tool versions.
  • audits/NILOREA_AUDIT.md and audits/HOOK_AUDIT.md - what the library already provides and what Fissure must add.

Grounding: the scanner reuses Hook's request engine, response model, cookie jar, and QuickJS scripting wholesale (HOOK_AUDIT section 5), and depends on the nilorea additions in NILOREA_AUDIT section 5B (n_html_extract_links / n_html_extract_forms / n_sitemap_extract_urls / n_url_canonicalize) and 5C (n_hex, n_digest, secure random). The active testing engine leans on n_pcre for signature matching, n_thread_pool for fan-out, and n_time for blind time-delta measurement.

1. Pipeline overview

The scanner is a staged pipeline. Each stage consumes the output of the previous one and writes into the scan's stores (the endpoint inventory and the findings store, owned by a FISSURE_SCAN), so a stage can be re-run or resumed without re-running the whole chain.

                FISSURE_SCAN (FISSURE_INVENTORY + FISSURE_FINDINGS)
                                       ^
   +-----------+   +-----------------+ | +------------------+
   |  1. SEED  |-->| 2. DISCOVERY    |-+-| 3. ENDPOINT      |
   |  targets  |   |  passive+active |   |    INVENTORY     |
   |  + scope  |   |  crawl/bruteforce|  |  FISSURE_ENDPOINT|
   +-----------+   +-----------------+   +------------------+
        ^                  ^                      |
        |                  |                      v
   profile/UI       proxy history,        +------------------+
   wordlists        robots/sitemap,       | 4. PARAM /INPUT  |
   (resources/)     JS+HTML extract       |    SURFACE       |
                                          |  injectable pos. |
                                          +------------------+
                                                   |
                                                   v
   +------------------+   +------------------+   +------------------+
   | 7. REPORT        |<--| 6. FINDINGS      |<--| 5. ACTIVE TESTS  |
   | (06_REPORTING)   |   |  FISSURE_FINDING |   |  builtin+plugin  |
   |  HTML/MD/JSON    |   |  dedup, sev, cwe |   |  mutate+send+eval|
   +------------------+   +------------------+   +------------------+

Stage boundaries map onto modules from 02_ARCHITECTURE.md:

Stage Module(s) Output
1 Seed fissure_scan (seed URL, FISSURE_SCAN_CONFIG, scope via fissure_scan_set_scope) seed URL(s) + scope
2 Discovery fissure_crawler, fissure_capture, plugin host candidate URLs
3 Inventory fissure_inventory (owned by fissure_scan) FISSURE_ENDPOINT set (dedup'd)
4 Param analysis fissure_scan (surface extractor) injectable positions
5 Active tests fissure_checks (built-in), plugin host raw results
6 Findings fissure_finding + fissure_findings store dedup FISSURE_FINDING records
7 Report fissure_report rendered document

The store is the only shared state. Stages never call each other directly; they read endpoints/captures and write endpoints/findings, exactly the invariant from 02_ARCHITECTURE section 6.

Evidence captures. The scan owns a FISSURE_CAPTURES store (fissure_capture) alongside the findings store. Auditing an endpoint archives the baseline request/response exchange as a FISSURE_CAPTURE (fissure_capture_from_exchange) before running the checks, then links every passive finding raised against that response, the native passive checks and the scriptable checks, back to the capture by id (request_ref and response_ref on FISSURE_FINDING). A report can therefore rebuild each finding's evidence and reproduction from the archived exchange rather than a pre-rendered string. fissure_scan_captures() borrows the store. The active checks (fissure_checks_active / fissure_checks_files / fissure_dirlist_probe) record their own attack exchange too: the request/response that triggered each finding is archived and linked (request_ref / response_ref), so a finding's capture is the exact probe that proved it. Plugin findings come from external tools that do not run through Fissure's transport, so they carry no capture ref.

Safe vs aggressive: fissure_checks_active takes an aggressive flag. The benign reflection probes (reflected-XSS marker, open-redirect sentinel) always run; the intrusive injection probes run only when aggressive is set. Those are: error-based SQLi (a quote yielding a DB error signature, confirmed by a balanced two-quote control that must NOT error, so a generic/validation/concurrency DB error that does not track quote parity is not reported, and by a re-sent single-quote probe that must REPRODUCE the same error, so a transient one-off DB error is not reported either), path traversal / LFI, boolean-based blind SQLi (a TRUE condition matching the baseline while the matching FALSE condition differs, on a stable page, scored with fissure_diff_similarity, and confirmed by an independent second observation of the same split so a stateful endpoint whose response flips once by itself - a registration that answers "registered" once then "already exists" - is not mistaken for an injectable query), and the two time-based blind checks, SQL injection (SLEEP / pg_sleep / WAITFOR) and OS command injection (shell sleep), which inject a delay and confirm the measured delay tracks the requested sleep across a long and a shorter probe, each with its own zero-delay control, so ambient load cannot forge a hit (see "Blind injection" below). The flag flows from FISSURE_SCAN_CONFIG.aggressive, which the Target view reads from the persisted FISSURE_SETTINGS.scan_aggressive (the "Aggressive (SQLi/LFI)" toggle in the Target view, off by default) and the CLI from fissure scan --aggressive (which implies --active). This is the CLAUDE.md safe/aggressive toggle; test_checks_active asserts that safe mode skips every injection probe while still firing XSS and open-redirect.

Insertion points: each check above runs against one insertion point at a time through a shared probe context (CHK_PROBE_CTX), so the same probe logic covers every surface. fissure_checks_active fuzzes (a) each query parameter and (b) each id-like path segment, numeric, UUID, or long-hex token, identified by chk_is_id_segment so route names like "users" are skipped, which catches IDOR/ SQLi/traversal on REST paths like /api/orders/1234 even when there is no query string. fissure_checks_active_multipart fuzzes each multipart field, and fissure_checks_active_json fuzzes each scalar leaf of a JSON request body (strings and numbers, with nested objects and arrays recursed and the count capped at FISSURE_CHK_JSON_MAX_LEAVES): every probe re-parses the original body, swaps that one leaf for the payload as a JSON string (cJSON), and re-sends with the observed method (POST/PUT/PATCH) and Content-Type application/json. fissure_checks_active_headers fuzzes the request headers and cookies: each header whose name is in a built-in client-settable allowlist (User-Agent, Referer, X-Forwarded-For, X-Forwarded-Host, X-Real-IP, X-Client-IP, True-Client-IP, Origin, Forwarded) is mutated one at a time, and each cookie value parsed out of the Cookie header is fuzzed separately (the other cookies and headers replayed verbatim, capped at FISSURE_CHK_HEADER_MAX_COOKIES). Each probe replays the observed request (method, headers, body) with that one value mutated, dropping the headers the transport engine sets itself (such as Host, Content-Length, and Connection) so they are not duplicated on the wire. Every insertion point runs the SAME probe list, which is the whole point of having one: reflected XSS, server-side template injection, CRLF / header injection, and (aggressive) error-based and boolean/time-blind SQLi, path traversal / LFI, in-band and time-based command injection, out-of-band interaction and in-band SSRF. The only surface-specific omission is open redirect, a query-link phenomenon rather than a body, path, or header one. One sink that is reachable both through a query parameter and through a JSON leaf therefore yields the same findings either way; a check that ran on one surface and not another would report a bug through a parameter and miss the identical bug through a body field. The insertion-point mask narrows the surfaces themselves, not the probe list: --points query runs the query and id-path points only, --points body the form/multipart/JSON points, --points headers the header and cookie points. The finding title names the surface: "parameter", "path segment", "multipart field", "JSON field 'user.id'", "header 'X-Forwarded-For'" or "cookie 'session'", and the JSON path is dotted/bracketed (e.g. user.id, items[0].sku). For the proxy to feed JSON and header endpoints, the seed step records each captured request's Content-Type, body, and header block on the endpoint (fissure_endpoint request_body / request_headers), and the audit dispatches POST/PUT/PATCH JSON bodies to fissure_checks_active_json by that Content-Type and the recorded header block to fissure_checks_active_headers for every method (crawled endpoints carry no observed headers and are skipped). The query and id-in-path insertion points are tested on body-bearing methods too, not just GET: fissure_checks_active_urlpoints fuzzes them while replaying the observed method and body (so the injection is exercised in the real request context), and fissure_checks_active (GET-only) covers the GET surface. test_checks_active covers path segments with the /item/ route, JSON fields with the /jsonprobe route, headers/cookies with the /hdrprobe and /ckprobe routes, and query/path on a POST with the /ctxprobe route (which reflects only when the observed method and body are preserved), and asserts a non-id segment (a route name) is not fuzzed.

Blind injection (aggressive): because a blind flaw shows no direct evidence in the response body, these probes compare responses rather than match a signature. They run on every insertion surface, query parameters and id-like path segments on GET (fissure_checks_active) and on body-bearing methods (fissure_checks_active_urlpoints, replaying the method + body), multipart form fields (fissure_checks_active_multipart), urlencoded and GET form fields (fissure_checks_active_form), JSON body fields (fissure_checks_active_json), and request headers / cookies (fissure_checks_active_headers), through a shared probe context (CHK_PROBE_CTX) so the logic below is identical for each; only how the probe value is placed (one parameter, one path segment, one field of a rebuilt body, one mutated JSON leaf, one replayed header, or one rewritten cookie) differs.

  • Boolean-based SQLi appends a TRUE and an equivalent FALSE SQL condition to the input (numeric, single- and double-quoted forms). It first fetches the unchanged value twice and requires the two to be near-identical (FISSURE_CHK_BOOL_STABLE_RATIO) so only deterministic pages are tested; it then reports when the TRUE response stays close to the baseline (FISSURE_CHK_BOOL_SAME_RATIO) while the FALSE response is clearly different (FISSURE_CHK_BOOL_DIFF_RATIO), with a minimum gap (FISSURE_CHK_BOOL_MARGIN). The reflected-input case scores low similarity and is intentionally not reported.
  • Time-based SQLi and command injection inject a FISSURE_CHK_TIME_DELAY_SECS-second delay. The delaying probe is sent first (with a request timeout raised past the sleep); only if its time-to-first-byte exceeds the baseline by FISSURE_CHK_TIME_FLOOR_US is a zero-delay control of the same shape sent, and only if the probe-minus-control delta also clears the floor (which rules out a merely slow endpoint) does the check proceed. A single differential is still forgeable: a slow probe paired with a coincidentally fast control (ambient load, or another aggressive scan hammering the same host) can look injectable. So the finding is raised only after a second, SHORTER FISSURE_CHK_TIME_CONFIRM_SECS-second probe (with its own control) confirms the measured delay TRACKS the requested sleep: the long-sleep excess must beat the short-sleep excess by at least FISSURE_CHK_TIME_TRACK_FLOOR_US, and the short probe must itself delay by FISSURE_CHK_TIME_CONFIRM_FLOOR_US. Ambient latency does not scale with the sleep we ask for, so this rejects the contention false positives a single-sample differential would report. The decision is the pure fissure_checks_time_confirmed, unit-tested over true-positive and contention vectors in test_checks_time. These thresholds live in fissure_constants.h. test_checks_active exercises all three across surfaces: query parameters (/bool, /timesql, /cmdtime), multipart fields (/mpbool, /mptime), and JSON body fields (/jsonprobe), and asserts a stable, encode-on-output page raises none of them.
  • The detection-timing values trade scan speed for reliability and are configurable per scan profile (not just compile-time constants): the injected sleep seconds (time_delay_secs, default FISSURE_CHK_TIME_DELAY_SECS = 5, clamped to [FISSURE_CHK_TIME_DELAY_MIN_SECS, FISSURE_CHK_TIME_DELAY_MAX_SECS] = [3, 30]; the shorter confirm probe is derived as half of it), the request-timeout headroom over that sleep (time_timeout_pad_ms, default 5000), the independent clean re-measures that confirm a hit and the cap on rounds (time_reconfirm_needed / time_reconfirm_max, default 2/2, with max held at or above needed), the out-of-band callback poll window the blind SSRF/XXE/RCE/DNS-rebind checks wait (oast_wait_ms, default FISSURE_CHK_OAST_POLL_MS = 600), and the request-retry backoff (retry_backoff_ms, default 250). Each 0 = the built-in default. They live on FISSURE_CONFIG (the engine config the checks read) and FISSURE_SCAN_CONFIG, defaulted in fissure_config_init, and are surfaced on every surface: the Target-view Scan-options popup's "Detection timing" section (two columns, with a per-field double-click-the-label reset and a "Reset timing to defaults" button), the persisted settings (scan_time_delay_secs and the rest), the scan-profile store, the control API (/api/scans raw knobs and /api/scanprofiles), the MCP bridge (start_scan / scanprofiles_op), and the web dashboard. Raise the sleep on a slow or jittery target so a true positive clears the floor; raise reconfirm-needed on a shared host to drop contention false positives; raise the OAST wait for a slow callback path.
  • A time-based probe injects a REAL server-side sleep, which holds a target worker (a PHP-FPM/thread + a DB connection) for its full duration. Run in parallel across the audit thread pool against one host, these injected sleeps can exhaust the target's worker pool and wedge the whole scan (a self-inflicted DoS) - an aggressive full-site scan then crawls very slowly and effectively stalls. A process-global, per-host governor (fissure_checks_time_governor_*, keyed by host, reset at the start of every scan) bounds this two ways: a CONCURRENCY GATE caps how many sleep-injecting probes run at once per host (FISSURE_CHK_TIME_HOST_CONCURRENCY, default 6; the operator knob is the Scan-options "Timing probes/host" field, persisted setting scan_time_host_concurrency, CLI --time-probe-concurrency, control-API / MCP time_host_concurrency, and the scan-profile field of the same name; 0 = default, a positive value raises the cap, a negative value disables the gate), and a WATCHDOG (circuit breaker) that, after a host accumulates FISSURE_CHK_TIME_BREAKER_TRIP saturation signals (a timed-out probe, or a slow probe whose zero-delay control was equally slow), drops that host from time-based probing for the rest of the run so an overloaded target does not stall overall progress. The loop also early-aborts an insertion point once a probe times out instead of trying every remaining payload against an unresponsive host. The cap (default 6) keeps scans fast and stays well below the per-CPU-core audit thread count; on a small or fragile target lower it (to 1 = fully serialized) to also remove the timing NOISE that concurrent sleeps create: with several in flight, a fast non-injectable field's probe can be queued behind another sleep and look delayed while its control runs clear, forging a false positive; one-at-a-time, a probe and its control see the same clean base latency. The gate and watchdog decisions are unit-tested in test_checks_time.
  • Exclusive re-confirmation of a time-based hit (the shared-session contention guard). Even at the default concurrency, a non-injectable field's sleep probe can block behind ANOTHER field's REAL injected sleep when both requests share one session: PHP serializes same-session requests on the session-file lock, so an authenticated scan funnels every probe through one lock, and the innocent field's delay then tracks the requested sleep by coincidence (measured on DVWA: time-based false positives on xss_d / xss_r / csrf while only exec / sqli / sqli_blind are really injectable). Lowering the gate to 1 removes this but halves throughput, so instead a confirmed hit must survive INDEPENDENT re-measurement before it is emitted: the four legs are measured again, with the host held EXCLUSIVELY when it can be drained (fissure_checks_time_host_acquire_exclusive: no other time-probe to the host in flight, which blocks new probes and waits for in-flight ones within FISSURE_CHK_TIME_EXCL_WAIT_MS) else non-exclusively. One re-measure is not enough on its own, because a single contention spike can itself track by chance: the re-measurement repeats until FISSURE_CHK_TIME_RECONFIRM_NEEDED (default 2) independent CLEAN re-measures have tracked, over at most FISSURE_CHK_TIME_RECONFIRM_MAX rounds, so a shared-session coincidence would have to recur across several exclusive rounds. A CLEAN re-measure that does not track DROPS the hit at once (the contention coincidence did not repeat); CLEAN tracking re-measures accumulate toward the required count and emit with the last clean numbers; an INCONCLUSIVE re-measure (a leg timed out, e.g. a genuine slow-base sink under load) neither confirms nor drops, so a hit with at least one clean track still emits and a hit whose every re-measure is inconclusive emits on first-pass evidence, rather than lose a real injection that sleeps on every measurement. test_checks_active's /timeflaky route (delayed only on its first probe) and /timeflaky2 route (delayed on the first probe AND the first re-measure, the rare double-coincidence a single re-confirmation cannot catch) both assert the hit is dropped while the always-delaying routes still fire; the exclusive-acquire gate is unit-tested in test_checks_time.
  • Adaptive timeout for a slow base command. An injected command runs AFTER the field's own value (a command-injection payload on a ping $ip field runs ping <value> first), so if that base command is itself slow, base + sleep can exceed the probe's request timeout, the probe times out, and the injection is scored a miss. When the standard-timeout sleep probe times out, the check re-measures the zero-delay control at a generous FISSURE_CHK_TIME_BASE_TIMEOUT_MS to learn the base latency, then re-sends the sleep probe (and the confirmation legs) with a timeout adapted to it (base + delay + pad), so a slow-base sink (DVWA's ping -c 4 1 takes ~14s, which blew the fixed 10s timeout) is still detected. A base command slower than the generous timeout is treated as a saturation signal (fed to the watchdog), not an injection.

2. Endpoint discovery (collect ALL possible endpoints)

Goal: maximize coverage of the attack surface. Discovery has a passive arm (no traffic generated by the scanner; data already collected) and an active arm (the scanner itself sends requests). Both converge on one dedup'd endpoint set.

2.1 Passive discovery

Passive sources cost nothing and never touch the target beyond what the operator already did:

  • Proxy history ingest. The intercepting proxy (04_NETWORK_AND_PROXY.md) records every request/response as a FISSURE_CAPTURE. fissure_capture already derives a FISSURE_ENDPOINT from each capture (canonical URL, method, observed params). The scanner simply reads the session's existing endpoints flagged from_proxy. Browsing the site through Fissure thus seeds the inventory for free.
  • robots.txt. Fetch <base>/robots.txt, parse Disallow: / Allow: / Sitemap: lines. Disallowed paths are high-value (operators hide admin and backup paths there). Sitemap lines feed the sitemap parser. The scan seeds this automatically at the start of every crawl (scan_seed_discovery -> fissure_crawler_seed_robots on the seed URL's origin); it is not a manual step.
  • sitemap.xml. Fetch the sitemap(s) (from robots or the default location) and call n_sitemap_extract_urls(xml, len) (NILOREA_AUDIT 5B) to pull every <loc> URL, including nested sitemap indexes (followed one level). The scan also seeds the conventional <origin>/sitemap.xml at crawl start (fissure_crawler_seed_sitemap), so a sitemap not referenced from robots is still discovered. Both seed fetches are safe GETs and run in passive mode too.
  • HTML extraction. For every HTML response (from proxy captures or crawl), n_html_extract_links(html, len) returns N_STR URLs from a/href, form/action, img/src, script/src, link/href, iframe/src. Forms are pulled separately with n_html_extract_forms(html, len) into N_FORM_FIELD records (name, type, value, required) grouped per form with method + action - these feed both the inventory and the parameter surface (section 3).
  • JavaScript URL mining. Inline <script> bodies and fetched external .js bundles are mined for URL/route tokens by n_html_extract_js_urls (nilorea): quoted string literals that look like an absolute http(s) URL, a protocol-relative //host URL, or a / / ./ / ../ path, including fetch(...) / axios / XMLHttpRequest.open targets and templated API roots (a ${...} template is truncated to its static prefix; regex and non-URL literals are rejected). Inline scripts are pulled out with n_html_extract_scripts; an external script is detected by a javascript content-type or a .js/.mjs path. Each token is resolved against the page base and canonicalized, then recorded in the inventory and followed in scope exactly like an href, so SPA/XHR endpoints that never appear as a link become audit targets. Secrets in JavaScript are covered by the passive audit (fissure_checks_secrets), which runs over every fetched .js body and the inline-script text in each HTML page. The same mining is exposed headless as POST /api/jsmine and the MCP tool jsmine (mine a JS blob for endpoints and secrets), and on demand from any request's right-click menu via "Mine JS" (fissure_gui_findings_check_jsmine): it fetches the URL as a bundle on a worker thread, seeds the mined endpoints into the site map (fissure_gui_sitemap_seed_recon_ex), scans the body for secrets, and reports the counts in a popup - so an operator can mine one specific bundle on demand instead of waiting for a crawl. The headless equivalent is jsmine on the fetched body then recon to seed the endpoints. Tested by tests/test_crawler (test_js_mining), the /api/jsmine route in tests/test_control, and the nilorea ex_html regression; the GUI action is driven headlessly by --selftest-jsmine URL.
  • Source-map unpacking (fissure_jsmine). A minified bundle hides most of its endpoint surface, but a linked source map (//# sourceMappingURL=...) carries the original, unminified sources where fetch targets, route tables, and API roots appear as readable string literals. fissure_jsmine_from_inline_map decodes an inline (base64 or plain data-URI) source map and mines its sourcesContent with the same n_html_extract_js_urls extractor; fissure_jsmine_map_url resolves an external .map reference so a fetch-capable caller retrieves it, and fissure_jsmine_from_map_json mines a fetched map. All three paths are wired in: the crawler mines an inline map and enqueues an external .map (then mines it when a .map response is fetched - crawl_url_is_map / crawl_extract_map); POST /api/jsmine (and the MCP jsmine tool) mine an inline map into the endpoints and return an external map URL as sourcemap; and the GUI "Mine JS" worker fetches and mines the external .map too. The three helpers are pure and unit-tested (tests/test_jsmine), and the route path is covered by tests/test_control. An inline map is read in place rather than copied into a buffer, so its size is not a limit: a bundler writes the WHOLE source map into that one sourceMappingURL= directive, routinely tens of kilobytes, and a size cap there would silently mine nothing on every real bundle. fissure_jsmine_from_map_json is length-bounded (it parses exactly the bytes it is given), so a caller may hand it a slice of a response body that is not NUL-terminated.

2.2 Active discovery (recursive crawler)

fissure_crawler is a breadth-first crawler over the transport core:

  • Frontier: a queue of (url, depth) seeded from the target base plus all passive URLs in scope. A worklist dispatched to n_thread_pool (section 10).
  • Scope rules: the seed hosts by default; extra hosts added with fissure_crawler_add_scope_host, or a borrowed target scope (fissure_scope, attached with fissure_crawler_set_scope), widen or narrow it. A URL is fetched only if it is in scope, under the depth cap, and under the per-host rate limit. Out-of-scope links are still recorded as endpoints (flagged out-of-scope) but never fetched.
  • Session-safe: logout-like URLs (via fissure_is_logout_url) are never crawled or audited. A logout is recognized three ways: a path containing logout/logoff/signout; a param whose KEY is a logout verb (?logout, ?logout=1); and a command-dispatch key (do/action/cmd/op/task) whose VALUE is a logout verb (Mutillidae's ?do=logout). The value is inspected only on a command key, so an ordinary redirect-target param such as ?next=/logout or ?return_url=/account/logout still does NOT trip it. Fetching a logout link during an authenticated scan destroys the session, and because the engine folds each redirect hop's Set-Cookie into the shared session jar, that downgrade cascades so every later request runs unauthenticated and the injection checks find nothing. Skipping these keeps an authenticated crawl and audit logged in.
  • Redirect following is scheme-safe: the engine does NOT follow a redirect that only upgrades the scheme to https on the SAME host and effective port (an http->https Location to the identical authority). A single TCP port serves one protocol, so an https handshake to the plaintext port the response just came over always fails with "wrong version number"; some apps emit exactly this self-referential upgrade (an "enforce SSL" redirect that ignores the real https port). Following it would turn a reachable endpoint into a transport failure that the audit counts toward its consecutive-failure give-up breaker, so enough such endpoints would abandon the whole run and silently lose coverage. The engine keeps the redirect response instead (the endpoint is reachable); a genuine http->https upgrade to a DIFFERENT port (the standard 443) is unaffected and still followed. Surfaced by the Mutillidae lab target and regression-tested in tests/test_engine.c (test_redirect_no_self_scheme_upgrade).
  • Operator exclude list: an explicit path-substring exclude list (Settings "Exclude paths" / CLI --exclude / the exclude field on /api/scans / MCP start_scan, comma/space/newline separated) generalizes the logout skip. A URL whose path contains any pattern is neither followed by the crawl nor audited (fissure_url_excluded, matched case-insensitively on the path only, so a ?next=/admin redirect param does not trip it). Use it to keep a scan off a destructive admin action, a sign-out, or a large irrelevant section (e.g. /logout,/admin/delete,.pdf). Extra scan-wide request headers (the Target Scan-options "Extra request headers" / CLI --header / the headers field) are appended to every scan request for the auth/forwarding/marker headers a target needs.
  • Limits: max depth, max pages, a per-request delay (rate throttle), a thread cap, max body size, an optional wall-clock time budget (implemented: the run stops early once the budget is reached), and a per-host requests/sec token-bucket governor (scan_rps, implemented: sends to one host are spaced at least 1/rps apart). These come from the scan profile and the Settings scan-policy fields. The page cap is an operator knob on every surface: the Target view's Scan-options "Crawl pages" field (persisted as scan_max_pages, blank or 0 = unlimited), CLI --max-pages, and max_pages on /api/scans and MCP start_scan. It was a fixed 200 in the GUI with no way to change it, which was worse than it sounds: see "What a spent budget costs" below. The depth cap gates link-following only: forms on a fetched HTML page are extracted and recorded as audit targets at any depth (a form does not deepen the crawl), so a form on the deepest crawled page, for example a DVWA GET form whose field is the injectable parameter, still becomes an audited endpoint. This is what avoids the silent under-coverage where a shallow crawl reached a form page but never turned its field into a probe.
  • Dedup: every URL is canonicalized with n_url_canonicalize (lowercase scheme/host, drop default port, decode unreserved, collapse ./ and ../, normalize the query) and looked up in a HASH_TABLE of seen canonical URLs (key = method + canonical URL). A hit is skipped. This is the single source of truth that keeps passive + active from duplicating endpoints. When a fetch follows a directory-slash redirect (/dir?q -> /dir/?q, a case canonicalization cannot know a priori), the crawler records the endpoint under the engine's post-redirect final URL (FISSURE_RESPONSE.final_url) and drops the pre-redirect no-slash duplicate, so that endpoint is audited once; a genuine redirect (a login wall, /old -> /new) keeps its own endpoint.
  • Form-aware: discovered forms become candidate POST/GET endpoints with their field set attached, so the crawler does not need to submit them to record them. A form's enctype is captured (n_html), so a multipart/form-data form is tagged (Content-Type "multipart/form-data") and, in active mode, the audit fuzzes its fields via fissure_checks_active_multipart (a reflected-XSS marker always; error-based, boolean-based and time-based SQLi, time-based OS command injection, and path-traversal/LFI when aggressive), building each POST body with n_http_build_multipart. A urlencoded (default-enctype) POST form and a GET form are fuzzed the same way through fissure_checks_active_form: the fuzzed field rides in a rebuilt application/x-www-form-urlencoded body (POST) or the query string (GET), with the same probe set. These are distinguished from URL-query keys the inventory records (a form endpoint has its fields in ep->params with no URL query and, for a crawled form, no observed request body), so a plain /search?q=1 link is fuzzed once via the query surface, not twice.
  • Audit coverage: alongside the audited/total counters, the scan tracks pages_with_surface (fissure_scan_pages_with_surface) - audited endpoints that actually had a fuzzable insertion point (a query/form parameter, a request body, or a captured request header). When an active scan finishes having discovered endpoints but covered none of them, it records one informational "Scan coverage" finding ("Active scan found no fuzzable insertion points") so an empty active result is not mistaken for a clean target, and the control-API scan status surfaces covered and a low_coverage flag (docs/11). It also counts what the target did with the run's requests: how many were sent, how many came back, and how many got NO response at all, split by cause (timed out, refused, connected but answered nothing, certificate rejected). A request that gets no response cannot produce a finding, so every check it carried reports nothing, which in the output is indistinguishable from a check that ran and found the endpoint clean; a target that drops requests under load therefore deletes part of the scan while the run still reads as complete. So the counts are reported everywhere the run is: the CLI prints them when the scan ends, the Target view shows the dropped count live in its status line and raises a popup at the end, the control-API scan status carries a sends object, and a run that lost a non-trivial share records a second informational "Scan coverage" finding naming the numbers and what to do (re-run with fewer threads, a per-host rate cap, or a delay; steady refusals point at a proxy, firewall or rate limiter instead). Requests the operator cancelled are counted separately and are never reported as target drops.
  • The CLI audits in parallel, like the GUI and the control API: fissure scan drives the threaded runner, so --threads sets how many endpoints are probed at once (0 = one worker per CPU core). It used to drive the stepped loop, which audits one endpoint at a time, making the flag inert on that surface: it parsed, the help advertised it, and four runs of the same DVWA scan at --threads default and --threads 32 came back within a second of each other with identical send and drop counts. Ctrl+C now asks a running scan to stop (breaking in-flight connects rather than waiting out their timeouts) and still writes the report for what was audited, saying on stderr that it stopped; a second Ctrl+C forces the process down.
  • Adaptive per-host concurrency (--host-backoff, on by default): counting the losses says what went wrong, this is the run doing something about it. When a host produces several dropped sends in a row the run halves how many requests it will have in flight to that host, down to a floor of one; a run of answered sends earns a slot back, and once the allowance climbs past the ceiling the cap is lifted entirely. It is the same additive-increase / multiplicative-decrease shape TCP uses, for the same reason, and it is the general-purpose sibling of the time-based-probe governor (which caps concurrent injected sleeps because each one holds a target worker; ordinary probes turn out not to need sleeps to saturate a small target). A healthy target is never capped and pays nothing for the mechanism. --host-backoff -1 turns it off for an operator who would rather keep the pressure up and read the dropped count; a positive value sets the floor it may never cut below. Which hosts are currently held back, and by how much, is on GET /api/respools (host_backoff) and in the Resource pools popup. An authenticated scan carries its login session (the login-config replay fills the shared cookie jar) through both the crawl and the active-audit phase, so login-gated forms are reached and probed.
  • Body capture for JSON APIs: HTML forms never carry JSON, so JSON endpoints come from the proxy. fissure_proxy_seed_inventory parses each captured flow's raw request for its request Content-Type and body and records them on the endpoint; the audit then dispatches POST/PUT/PATCH JSON bodies (Content-Type application/json) to fissure_checks_active_json. So a JSON API simply exercised through the intercepting proxy is fuzzed field by field with no form to crawl.

What a spent budget costs, and how the run reports it

A crawl budget is a good default and a bad silence. Every URL the crawl finds is recorded in the inventory as an endpoint whether or not it is ever fetched, so the endpoint count keeps climbing from discovery after the fetching has stopped. A capped run and a complete one therefore look identical from the outside: same growing endpoint list, same "done", same audit over whatever happened to be in hand. On a site larger than the cap that reads as full coverage of the target when it is coverage of its first few hundred pages.

The crawler keeps the three numbers that tell them apart, and the scan reports them:

  • fissure_crawler_frontier_left - in-scope URLs queued and never crawled. A scan still fetches each one for its baseline, so they are tested; what was skipped is EXPANDING them, so their own links were never extracted and anything reachable only through them was never discovered. Non-zero at the end means that surface is missing from the run.
  • fissure_crawler_page_cap_hit - the page budget, rather than the site, ended the crawl.
  • fissure_crawler_depth_capped - pages fetched at the depth limit, whose own links were never followed. A crawl that runs out of depth and one that reached the end of the site both finish with an empty frontier; this is what separates them.

scan_note_crawl_budget turns them into a "Scan coverage" informational finding naming the budget that ran out and what was left, alongside the existing coverage notes, and the same figures ride on the scan status as crawl.pages / crawl.page_cap / crawl.left / crawl.depth_capped / crawl.capped (GET /api/scans/{id}, MCP get_scan_status), so an agent driving Fissure headless can tell a bounded run from a finished one without reading findings. Covered by tests/test_crawler (test_budget_accounting).

2.3 Content / directory brute force

Paths that are not linked anywhere (admin panels, backups, API versions) are found by guessing:

  • Built-in light brute force: the Sitemap "Discover" tool iterates a wordlist against the base, GETs each candidate, and records any non-404 (configurable status filter, with soft-404 detection via a random-path baseline length comparison). Throttled by the same governor. The wordlist is the shipped resources/wordlists/paths.txt (a curated content-discovery list of admin panels, API docs, VCS metadata, config/secret files, backups, and framework/management endpoints, drawn from the nuclei-templates exposure matchers, MIT); if that file is missing it falls back to a small built-in list. A companion resources/wordlists/params.txt supplies candidate parameter names for the Intruder "Mine params" tool. See resources/wordlists/README.md.
  • Heavy fuzzing delegated to plugins: ffuf / feroxbuster (01_SECURITY_TOOLS_CATALOG.md) for large wordlists, recursion, and extension permutations. Their output is parsed into endpoints by the plugin host.

2.3.1 API-definition import (DONE)

When the target ships an API definition, the endpoints are imported instead of crawled. fissure_apispec (src/fissure_apispec.{c,h}, test_apispec) parses a JSON definition and seeds the inventory, detecting three formats: OpenAPI 3.x, Swagger 2.0, and Postman collection v2.1. Each operation becomes a FISSURE_ENDPOINT tagged FISSURE_EP_SRC_IMPORT (shown as "import" in the Target grid's Source column):

  • the URL is made absolute and concrete: the server/host comes from the spec (OpenAPI servers[0].url, Swagger scheme+host+basePath, Postman request URLs) or from a base-URL override (the Target URL field) for relative specs; path templates like /pets/{petId} are filled with a sample id (/pets/1, so the path-segment audit sees an id); in:query parameters are appended as name=1 sample pairs (the audit then fuzzes them).
  • body operations record the request Content-Type and a synthesized sample body: the schema (resolving local $ref against the document, bounded depth) is walked into a JSON object of the named fields with type-appropriate placeholders, so the JSON-body audit has real field names to fuzz; an explicit schema example is used when present.

The Target view's "Import API" button reads a file (any of the three formats), seeds the scan inventory, and refreshes the grid (fissure_gui_sitemap_import_file; headless self-test --selftest-import-api). The operator then multi-selects the imported rows and "Scan this" (a no-crawl targeted audit, section 2.3 / the Target context menu), or runs a full scan. A YAML OpenAPI/Swagger definition is accepted too: when the body is not JSON, the importer converts the YAML to JSON first with fissure_yaml (a libyaml event-parser wrapper the app installs at startup) and imports the result, so a .yaml/.yml spec works identically to a .json one.

Beyond an API spec, a fully-described request CORPUS can be scanned directly over the automation surfaces: CLI --endpoints-file <path>, control-API POST /api/scans endpoints, and MCP start_scan(endpoints=[...]). Each entry is a request object {method, url, content_type, body, headers, params:[...]}; the scan runs in targeted mode (no crawl, fissure_scan_start_targets_full) and audits each request across its query, form-body and cookie insertion points (and its allowlisted request headers), with no prior proxy capture. headers is a Name: value\r\n block (a Cookie line carries cookie insertion points) and a urlencoded form field is given as a params entry with no body (the body is synthesized from the field names), matching the crawled-form audit. This is how a request set exported elsewhere is scanned as-is: an OWASP Benchmark crawler file (lab/benchmark/gen-requests.py emits the corpus), a HAR/Postman-style export, or an engagement's known deep requests. Request headers are fuzzed only for the fuzzable-header allowlist (User-Agent, Referer, X-Forwarded-For, ...), so a corpus whose taint rides an arbitrarily-named custom header is not covered at the header point. The GUI reaches the same no-crawl targeted audit through "Import API" + "Scan this" over the inventory rows.

2.3.2 Live API-spec auto-fetch (DONE)

The import above needs a definition in hand. When a live target serves its own definition, Fissure fetches it automatically: fissure_apispec_autofetch (src/fissure_apispec.{c,h}, test_apispec) probes the origin's well-known JSON spec paths through an injected fetch callback (so the core is unit-tested offline; fissure_apispec_engine_fetch wires it to the native transport for real use). The probed paths are /openapi.json, /swagger.json, /swagger/v1/swagger.json, /v2/api-docs, /v3/api-docs, /api-docs, /api/swagger.json, and /api/openapi.json (the framework defaults for OpenAPI 3 and Swagger 2). A path that returns HTTP 200 with a body that parses as a known spec with at least one operation is imported via fissure_apispec_import; a 200 that is not JSON (an SPA catch-all page) or is not a recognized spec seeds nothing. Each hit is pinned to the live origin: the scheme/host/port come from the target actually reached, and only the spec's own API path prefix (an OpenAPI servers[0].url path or a Swagger basePath) is kept, so a spec that names a placeholder or relative host cannot send the audit off-target.

The probe is surfaced three ways, all scope-gated:

  • during a scan, in active mode, once after the crawl and before the audit-list build (fissure_scan.c scan_probe_apispec), so a served API is audited even when nothing on the site links to it;
  • from the Target view's "Fetch spec" button, which runs the probe on a worker thread (relabelled "Fetching..." and guarded against re-trigger while it runs, mutually exclusive with a scan and content discovery), folds the discovered operations into the live inventory preserving each imported body and parameter surface, and reports the outcome in an OK-only popup;
  • over the control API as POST /api/apispecfetch and the MCP tool apispec_fetch (docs/11), for the agent-driven path.

The auto-fetch also probes the YAML well-known paths (/openapi.yaml, /swagger.yaml, /v3/api-docs.yaml) and imports a YAML definition by converting it to JSON first (fissure_yaml, linked -lyaml), so a target that serves its spec as YAML is handled identically to one serving JSON.

2.4 Recon-to-inventory bridge (subdomain enumeration and URL sourcing)

Run before crawl to widen the target set. A recon-category plugin (subfinder, gau, waybackurls, katana, httpx; category "recon" in its manifest) is run from the Plugins view; its output is routed by fissure_recon (fissure_recon.c) into the site map, not just the findings list:

  • a bare-host line (subfinder/amass/assetfinder/findomain) is added to the in-scope allowlist and seeded into the inventory as a https://host/ crawlable origin;
  • a URL line (gau/waybackurls) is merged into the inventory as a crawl-frontier endpoint (dropped when a scope filter is active and the URL host is outside a non-empty scope);
  • a JSON-object line (katana -jsonl, httpx -json, which wrap the endpoint in JSON rather than emitting a bare URL) has its endpoint URL extracted (fissure_recon_json_url reads katana's request.endpoint, then httpx's url, then a top-level endpoint/input) and merged like any other URL, so these two common tools also widen the crawl frontier rather than only the findings list. A JSON line with no usable endpoint is skipped, never stored as an opaque blob.

Every seeded endpoint carries the FISSURE_EP_SRC_RECON provenance, so a later crawl and active audit cover the widened surface. The same routing is exposed headless as the control-API route POST /api/recon and the MCP tool recon (both take the raw tool output as text with scheme / add_scope / scope_filter options), so an agent can run its own recon toolchain and feed the loop. This closes the recon -> crawl -> scan loop that the plugin host otherwise leaves as informational findings only.

The fissure_recon classifier and router are unit-tested (tests/test_recon) and the control route is covered by tests/test_control.

One-action recon chain. Running the recon tools one at a time is tedious, so the Plugins view has a Recon all button and the control API a POST /api/reconchain route (MCP tool reconchain) that run the whole installed recon toolset in one action. fissure_recon_chain (fissure_recon_chain.c) iterates the loaded plugins and, for each whose category is "recon", runs it against the seed host and concatenates its output; that combined blob is then routed through the same fissure_recon path above (site map in the GUI, ctl_recon_route_into over the control scope headless). Tools whose binary is not installed are skipped and counted; the outcome (tools_total / tools_ran / tools_absent / tools_failed and how many hosts/URLs were seeded) is reported on screen (a popup in the GUI, the JSON tally over the API). The seed is scope-checked before any tool runs. The orchestration core drives an injectable runner, so it is unit-tested without external tools (tests/test_recon_chain), and the control route is covered by tests/test_control.

Headless (JS-rendering) crawl. A static link crawl misses URLs that only appear after JavaScript renders a single-page app. A bundled rendering engine is a non-goal (docs/12), but an external headless crawler recovers those URLs without shipping a browser: fissure_headless (fissure_headless.c) runs katana with a system Chromium (-headless, via the katana-headless plugin manifest, which emits plain URLs rather than the JSONL the recon katana plugin uses) and hands back the rendered URLs, which are then routed through the same fissure_recon path above (the site map in the GUI, ctl_recon_route_into over the control scope headless). It is surfaced three ways, all scope-gated: the Target view's Headless crawl button (a worker thread that relabels to Stop crawling while it runs and is mutually exclusive with a scan, content discovery, and the spec fetch; the manifest caps katana at crawl depth 2 and a 180-second crawl duration (-ct 180) so a large or slow site cannot run indefinitely, and clicking Stop crawling signals the child's process group - fissure_proc_signal_pid, which kill(-pid)s the katana + Chromium group since the child leads its own session - to abort a slow or hung crawl before the cap, keeping whatever it captured so far), the control-API route POST /api/headlesscrawl, and the MCP tool headless_crawl (each taking the seed url with scheme / add_scope / scope_filter, and returning tool_present / failed alongside the recon routing tally). The crawler is optional: when katana is not installed, tool_present is false and nothing is seeded (an install hint is shown). The orchestration core drives an injectable runner, so it is unit-tested without a browser (tests/test_headless), and the control route is covered by tests/test_control.

Native SPA interaction crawl. The katana headless crawl above delegates to an external tool and recovers rendered URLs; it does not exercise the app. fissure_spider (fissure_spider.c) is a native, no-external-tool interaction crawler that drives a headless Chromium over the same CDP client as the DOM probe (fissure_cdp), so Fissure spiders a single-page app the way the static crawler cannot. Per visited app state it evaluates an in-page enumeration script (resources/spider/enumerate.js) that returns the router links, buttons, and forms; the crawler follows the addressable client-side routes (hash/history routes that are URLs), exercises the in-place buttons, submits the forms (with benign values), and captures every request the app issues at runtime through Network.requestWillBeSent - the XHR/fetch API surface a static link crawl never sees. Only app-endpoint resource types (Document/XHR/Fetch/EventSource) are kept; static assets (Image/Stylesheet/Script/Font) are dropped. States are de-duplicated by an app-state signature (fissure_spider_state_sig: the URL plus a hash of the interactable elements), off-origin links are captured-but-not-followed, and the work is bounded by max_states (routes, default FISSURE_SPIDER_MAX_STATES = 40), max_actions (in-place interactions, default 120), and settle_ms (per-step network settle, default 700). The discovered endpoints route through the same fissure_recon path as everything else (the site map / ctl_recon_route_into over the control scope). It is surfaced three ways, all scope-gated and requiring a Chromium/Chrome (the bundled Fissure Browser or a system one): the Target view's SPA crawl button (a worker thread that relabels to Stop SPA crawl while it runs, is mutually exclusive with a scan, headless crawl, content discovery, and the spec fetch, and stops in-process via a cancel flag the CDP loop checks between states), the control-API route POST /api/spider (with max_states / max_actions / settle_ms / cookie / scheme / add_scope / scope_filter, returning states / actions / requests alongside the recon routing tally), and the MCP tool spider. The pure parsers (request-array to endpoints, state signature, endpoint serialization) and the CDP orchestration (through the injected-session stub) are unit-tested without a browser (tests/test_spider), and the control route + refusal path are covered by tests/test_control and tests/mcp_bridge_smoke.py. Use it (no external tool) to widen a JS-heavy / SPA target's surface before scanning; a cookie crawls authenticated.

2.5 Recon asset view and new-since-last-run diff

Recon feeds the endpoint inventory, but a bug hunter works at the level of the host (the asset), and works from the delta between runs, a newly live subdomain or a technology change, not the whole surface every time. fissure_assets (fissure_assets.c) is the asset layer on top of the endpoint inventory: it rolls endpoints up to distinct hosts (FISSURE_ASSET) and records, per host, its representative origin, a live/dead status, the detected technology, and the endpoint count. Assets come from two sources, merged by host:

  • fissure_assets_from_inventory folds the endpoint inventory in, taking the per-host endpoint count and raising each host's liveness from its endpoints' last observed HTTP status (any status means the host answered);
  • fissure_assets_from_recon_text parses raw recon output. An httpx -json line is the technology and liveness source: its status_code sets the asset live and its webserver + tech array become the technology string; a katana -jsonl line or a bare host/URL seeds the host with no status.

fissure_assets_diff loads a persisted baseline snapshot (newline-delimited JSON under the config dir, recon_assets.jsonl) and marks each current asset new (absent from the baseline) or changed (its status/liveness moved), and lists the hosts that are gone (in the baseline, absent now). A missing baseline is treated as empty, so the first run marks everything new. The Dashboard shows the asset table (host, status, tech, and a NEW / CHANGED tag, actionable ones first) with a summary line, and a Snapshot baseline button re-bases the diff by saving the current assets as the new baseline (reported on screen).

The same capability is exposed headless as GET /api/assets (the asset inventory + diff) and POST /api/assets (which optionally merges recon text into the assets before the diff and/or saves a new baseline with snapshot=true), and as the MCP tool assets, so an agent drives its recon diff exactly like the GUI operator. In the control session the asset inventory is fed automatically by every /api/recon, /api/reconchain, and /api/headlesscrawl pass. The module is unit-tested (tests/test_assets) and the route is covered by tests/test_control.

2.6 What gets stored

Every discovered endpoint is a FISSURE_ENDPOINT (src/fissure_endpoint.h), held in a FISSURE_INVENTORY keyed by method + canonical URL:

FISSURE_ENDPOINT { method; url /*canonical*/; params; from_proxy; from_crawl;
                   from_import; from_discover; from_recon; content_type;
                   last_status; request_body; request_headers; highlight; }

The from_* flags record provenance (proxy history, crawler, API-definition import, content discovery, external recon tool); params is the deduped list of parameter names seen for that endpoint. request_body and request_headers keep the last observed body and header block so body, header and cookie insertion points can be fuzzed. highlight is the manual row color shown in the Target view. The endpoint carries no id and no finding list: findings reference their location (and optionally an endpoint_id string) instead.

3. Parameter and input-surface analysis

For each endpoint the scanner enumerates every position an attacker controls. A "position" is (location, name, current value, type). Locations:

Location Source Notes
Query param URL query string (n_url_parse) each key=value
Form field n_html_extract_forms / observed POST body text, hidden, select, file
JSON body field parsed request body (cJSON) recurse into nested keys + array elements; path like a.b[0].c
Path segment URL path components numeric/UUID-looking segments flagged for IDOR
HTTP header observed request header block fuzzed by allowlist (User-Agent, Referer, X-Forwarded-For/-Host, X-Real-IP, X-Client-IP, True-Client-IP, Origin, Forwarded); fissure_checks_active_headers
Cookie observed Cookie header per-cookie value, others replayed intact; fissure_checks_active_headers

Each position is classified as likely injectable based on heuristics: numeric or id-shaped values (IDOR/BOLA candidates), values reflected in the response (XSS/redirect candidates), values that look like file paths or URLs (traversal/SSRF candidates), and values used in apparent queries. The output is a list of test targets: (endpoint, position, payload-class). Stage 5 mutates exactly these positions, one at a time, leaving the rest at baseline so a behavior change is attributable.

The parameter miner (section 11) augments this by probing for hidden parameters the site accepts but never advertised.

4. Vulnerability test catalog

Each vulnerability class lists its OWASP Top 10 (2021) / CWE mapping, the detection technique, and whether Fissure tests it with a native C check or delegates to a plugin (01_SECURITY_TOOLS_CATALOG.md). "Both" means a fast native check runs first and a plugin can be queued for depth.

Vulnerability OWASP CWE Detection technique Engine
Reflected XSS A03 CWE-79 inject unique marker + HTML/JS metachars, check unencoded reflection in response context Built-in (reflection); plugin (dalfox) for context/DOM
Stored XSS A03 CWE-79 write a unique executable canary (a correlation nonce wrapped in an <svg/onload=...> payload) through a write endpoint - one urlencoded form field or JSON string leaf at a time - then issue a SEPARATE GET of the read URL (the write URL with the query stripped by default, or an explicit read URL) and flag stored XSS when the canary comes back UNENCODED in that different response; a HTML-encoded canary is not flagged (stored but escaped). Finding it in a response that did not carry the payload proves persistent storage + missing output-encoding, which reflected-XSS probing never reaches (fissure_checks_active_storedxss, aggressive, firm, run on form/JSON write endpoints in the scan; also POST /api/storedxss / MCP storedxss and the "Stored XSS" context-menu action) Built-in (write-then-read canary correlation)
DOM XSS A03 CWE-79 static source/sink co-occurrence in one JS statement (fissure_domxss, passive, tentative; see section 5); deeper context-aware analysis in dalfox, and live DOM probing in the embedded browser (fissure_domprobe) Built-in (static heuristic); plugin (dalfox) for depth
SQLi error-based A03 CWE-89 inject ', n_pcre match DB error signatures (ORA-, SQL syntax, PG, MySQL, SQLite, Java/JDBC); then confirm with a balanced two-quote ('') control that must NOT error, so the match is a quote-syntax break and not a generic/validation/concurrency DB error that fires regardless of quote parity; then re-send ' and require the same DB-error to REPRODUCE, so a transient one-off DB error is not reported Built-in (n_pcre + balanced-control + reproduce confirm)
SQLi boolean-based A03 CWE-89 append AND 1=1 vs AND 1=2 (also quoted forms); on a stable page require TRUE ~ baseline while FALSE differs (fissure_diff_similarity), then re-confirm the split with an independent second observation so a one-shot stateful flip is not scored as injection Built-in (similarity); plugin (sqlmap) deep
SQLi time-based A03 CWE-89 inject SLEEP/pg_sleep/WAITFOR delay, confirm the delay tracks the requested sleep across a long and a shorter probe (each vs its own zero-delay control) so ambient load / a concurrent scan cannot forge a hit Built-in (time-delta, two-probe tracking); plugin (sqlmap)
Command injection A03 CWE-78 inject ;sleep N / | / $(...) / backticks, confirm delay vs a zero-delay control; out-of-band optional Built-in (time-delta)
Path traversal / LFI A05/A01 CWE-22/CWE-98 inject ../etc/passwd (and encodings), an absolute /etc/passwd, a file:// URL, and a php://filter/convert.base64-encode wrapper; n_pcre match root:.*:0:0: and platform markers on the raw body, and on the base64-decoded body for the filter wrapper (source disclosure) Built-in (n_pcre)
SSRF A10 CWE-918 in-band: inject the cloud instance-metadata URL (AWS IMDSv1 169.254.169.254 and a decimal-IP bypass, AWS IAM credentials, GCP metadata.google.internal, Azure IMDS) and n_pcre-match that service's distinctive metadata in the response (chk_ssrf, aggressive, follow-redirect off so an open redirect is not mistaken for SSRF); blind: the OAST HTTP/DNS canary plus gopher://<canary>:6379/ and dict://<canary>:11211/ alternate-scheme canaries (chk_oast, DNS-channel confirmed) that reach non-HTTP internal services (Redis/memcached) an http canary cannot - the classic gopher-to-Redis pivot - and a DNS-rebinding canary (chk_oast_rebind_probe) whose host the OAST DNS answers with a benign IP on the first lookup and 169.254.169.254 on the next (low TTL), so a target that resolves-then-connects (TOCTOU) is flagged when it re-resolves the name (>= 2 lookups): an allowlist that approved the benign first answer would connect to the metadata service on the second lookup; and the OAST-canary header injection; plus plugin (interactsh/nuclei). Also POST /api/ssrf / MCP ssrf for an on-demand out-of-band probe of a URL's query parameters (fissure_checks_active_ssrf, needs the OAST listener). file:// SSRF is covered by the LFI check Built-in (in-band metadata + OAST + alternate schemes) + plugin
Open redirect A01 CWE-601 set redirect param to a sentinel host, check 3xx Location / meta-refresh points to it Built-in
HTTP request smuggling (desync) A03 CWE-444 send length-ambiguous requests over a raw-bytes path (fissure_engine_raw_exchange) and flag a desync when one hangs the server (timeout) while an unambiguous request returns promptly: TE.CL, CL.TE, then CL.CL (duplicate/conflicting Content-Length headers, where a front-end and back-end pick different values). A timing hit is then confirmed with the differential-response method (fissure_engine_raw_exchange_pipeline): on one keep-alive connection a smuggling request that leaves a "GET /" prefix poisons the following request, whose response differs from a benign control - a confirmed hit is a FIRM finding, an unconfirmed one a TENTATIVE candidate. Every probe keeps the URL's QUERY STRING ("/app?id=1" and "/app" are different resources to a routing, caching, body-parsing chain), and the pipelined response stream is split by walking each response's declared body length (Content-Length, or the chunked terminator), 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 and the victim's own slice is the one compared. The HTTP/2 downgrade variants run wherever the endpoint actually speaks HTTP/2: over TLS that is ALPN (the probe stops unless the handshake selects h2), and on cleartext only when the origin has just answered 101 Switching Protocols to an h2c Upgrade, since the cleartext probe speaks h2 with prior knowledge and would otherwise send HTTP/2 frames at a plain HTTP/1.1 origin and read any stall as a desync. The variants are: H2.TE (fissure_engine_h2_downgrade_probe) sends an HTTP/2 request carrying a Transfer-Encoding header (forbidden in HTTP/2) with an unterminated chunked body over ALPN "h2", and a front-end that downgrades to HTTP/1.1 and forwards the header hangs the back-end; H2.CRLF (fissure_engine_h2_crlf_probe) hides the same Transfer-Encoding inside a benign header's value behind a CRLF (HPACK carries the CRLF verbatim as a length-prefixed literal), catching a stricter front-end that strips illegal HTTP/2 headers but not CRLF when it downgrades; and H2.SPLIT (fissure_engine_h2_split_probe) CRLF-injects a WHOLE second request line ("GET /fzsplit HTTP/1.1" + Host + a Content-Length promising body bytes that never arrive) into that 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, which hangs waiting for the missing body - full request splitting, the primitive behind HTTP/2 response-queue poisoning and a strict superset of H2.CRLF. All are timing-confirmed by a repeat. The probe checks H2C first (smuggle_h2c_upgrades): an HTTP/1.1 request offering a cleartext HTTP/2 (h2c) Upgrade; an origin answering 101 Switching Protocols with an h2c token is the precondition for tunnelling HTTP/2 past an HTTP/1.1 front-end that forwards the Upgrade (h2c smuggling), and it is also what opens the downgrade family on a cleartext endpoint. Gated behind aggressive + scope (fissure_smuggle.c, once per host in the scan; also POST /api/smuggle / MCP smuggle, verdict none/tecl/clte/clcl/h2te/h2crlf/h2split/h2c) Built-in (timing + differential + H2 downgrade/CRLF/split + h2c upgrade)
Race condition (limit overrun) A04 CWE-362 an on-demand probe (fissure_race.c) in three phases: a SEQUENTIAL baseline of FISSURE_RACE_BASELINE_COUNT requests sent one at a time (how often is the action accepted when the requests cannot overlap?), then N identical state-changing requests fired concurrently over the single-packet / HTTP-1 last-byte-synchronized primitive (fissure_groupsend PARALLEL, the classic race primitive), then a settle request. Flag a limit overrun 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. The baseline is the verdict: an endpoint that atomically allows N > 1 grants the same N serialized or concurrent, so its burst can only take what the baseline left and it reports clean (without that comparison, "3 concurrent grants" from an atomic limit of 3 was reported as CWE-362). Responses are classified on their BODY alone (the status decides acceptance), so a rotating Date / Set-Cookie / request-id header cannot make two identical grants look like different outcomes. Self-skips when the baseline gets no response at all, when there are fewer than two concurrent successes, when the concurrent count does not exceed the sequential one, or when the settle also succeeds (a repeatable, unlimited action), so a non-idempotent-but-unlimited endpoint does not false-positive. The baseline spends part of the allowance it measures, so a strictly SINGLE-use action is consumed by it and the probe reports nothing rather than guessing; the check bites where the allowance is larger than the baseline (a quota, a rate limit, a multi-use token). TENTATIVE (confirm each concurrent success produced a real separate state change). Aggressive + scope gated; on-demand (not in the per-endpoint scan, since firing a burst at every endpoint would be too intrusive). Also POST /api/race / MCP race Built-in (concurrent-burst + settle)
XXE (XML external entity) A05 CWE-611 on an XML-accepting endpoint (an XML Content-Type or a body that opens with an XML declaration), submit crafted XML declaring an external entity: in-band, an entity that reads file:///etc/passwd / file:///c:/windows/win.ini confirmed by an n_pcre file-content signature in the response (certain); out-of-band, an external parameter entity (fetched during DTD parsing, so even a blind parser calls out) plus a general entity, both pointing at a minted OAST canary, confirmed by a callback (blind XXE); and nested-parameter-entity OOB, where the document's internal subset only loads an attacker external DTD (%remote) that the OAST listener serves with the nested %eval/%exfil entities, defeating a parser that blocks parameter entities in the internal subset yet still processes an external DTD, and exfiltrating the read file's contents out-of-band (reported with the leaked bytes). Reuses the observed root element so the payload matches the endpoint's shape (fissure_checks_active_xxe, aggressive, once per XML endpoint in the scan) Built-in (in-band file read + OOB canary + nested-PE external DTD)
Web cache poisoning A05 CWE-349 for each unkeyed request header (X-Forwarded-Host, X-Host, X-Forwarded-Server, X-HTTP-Host-Override, Forwarded), inject a unique random host marker on a cache-busted copy of the URL (POISON), then re-fetch the same cache-busted URL WITHOUT the header (CLEAN); if the unheadered response carries the marker, the header's effect was cached and is served to every visitor - a definitive signal since the marker is random. Only ever writes a cache-busted probe entry, never the target's real cache key (chk_cache_poison, firm) Built-in (poison/clean differential)
Web cache deception A05 CWE-525 append a static-file suffix (/<token>.css) to the page; if the suffix is ignored and the same page returns with a response a shared cache may STORE, a CDN may cache the (possibly authenticated) page under the static URL (chk_cache_deception, tentative - confirm the page is authenticated/sensitive). Storable means an explicit public, a positive max-age/s-maxage, or NO Cache-Control header at all (heuristically cacheable, and a CDN keyed on the URL suffix caches it regardless), and never no-store, private, no-cache or max-age=0; demanding a literal public skipped the two configurations that make up most of the real web. The finding is HOST-scoped: static-suffix path confusion is a property of the front end, so a catch-all site raises it once and not once per crawled page. Both run once per GET endpoint in the scan; also POST /api/cache / MCP cache and the "Test cache poisoning" context-menu action Built-in (suffix-confusion + cacheable)
Insecure deserialization A08 CWE-502 recognize native serialized-object signatures in attacker-influenceable values - a Java serialized stream (base64 rO0AB or the raw aced0005 magic), a PHP serialized object (O:len:"Class":n:{), an ASP.NET __VIEWSTATE field, a Python protocol-4 pickle (base64 gASV) - and report each as a tentative lead (a deserialization sink to confirm, not a proven RCE). Passive: the response body and each Set-Cookie value (chk_deser in fissure_checks_passive, on proxy + scan traffic); scan: the captured request body and request headers/cookies. Also POST /api/deser / MCP deser for a targeted value (fissure_checks_deser, pure analysis, no traffic) Built-in (signature leads)
Server-side prototype pollution A08 CWE-1321 on a JSON-accepting endpoint, send a body carrying a __proto__ gadget ({"__proto__":{"<uniq>":"<uniq>"}}), then the constructor.prototype variant, injecting a unique property into Object.prototype; then issue a second, payload-free {} request and check whether that property comes back in the response. On a GET endpoint (no body to pollute) the query-string vector is used instead: ?__proto__[<uniq>]=<uniq> then ?constructor[prototype][<uniq>]=<uniq>, the bracket gadgets a qs-style query parser (Express) expands into a polluting object, then re-GET the gadget-free URL and check for the leak. Because the probe carried no such key, its only source is an object that inherited it from the polluted prototype (a conservative but high-signal confirmation). A hit means application objects inherit attacker-controlled members, which can force logic bypasses, denial of service, or - with a gadget - RCE (fissure_checks_active_protopollution, aggressive, once per JSON endpoint and once per surface-bearing GET endpoint in the scan; also POST /api/protopollution / MCP protopollution with method GET/POST, and the "Prototype pollution" context-menu action) Built-in (proto-gadget reflection, JSON + query-string)
Broken access control / IDOR A01 CWE-639/CWE-862/CWE-285 replay an authenticated request under a second identity and with credentials stripped, diff each response against the authenticated baseline; same content served = access control missing Built-in (fissure_authz_check, see below)
Object-ID enumeration (IDOR/BOLA) A01 CWE-639 for each id-like path segment (numeric, UUID, long hex) and numeric query param, fetch the baseline, a control id unlikely to exist (to confirm the endpoint is object-scoped, not ignoring the id), and neighbor ids (value +/-1, sibling UUID) under the current session; flag when a neighbor returns a distinct 200 whose body is structurally similar to the baseline but not identical (fissure_diff_similarity in [0.5, 0.98), computed after linearizing both bodies at JSON/HTML delimiters so a minified single-line JSON API response compares correctly, not just multi-line HTML) - the same resource type carrying another subject's data. GET-only (idempotent, never mutates), aggressive-gated, tentative. fissure_checks_active_idor, run on every GET endpoint in the scan; also POST /api/idor / MCP idor and the "Test for IDOR" context-menu action Built-in (neighbor-id diff)
Reverse-proxy / auth-header authentication bypass A07 CWE-290 on an endpoint that DENIES an anonymous request (401/403 or a login redirect), forge each trusted identity/forwarding header a misconfigured reverse-proxy setup honors (X-WEBAUTH-USER, X-Remote-User, Remote-User, X-Forwarded-User, X-Authenticated-User, X-Auth-Request-User, X-User, X-Forwarded-Preferred-Username, X-SSL-Client-CN set to admin; X-Forwarded-For, X-Real-IP, X-Originating-IP, X-Client-IP set to 127.0.0.1; plus a malformed traversal Authorization token) one at a time and flag any that flip the deny to an authorized 2xx. A low-false-positive control fires first: an untrusted header (X-Fissure-Auth-Probe) must stay denied, else the endpoint reacts to any extra header and is skipped. GET-only, aggressive-gated, FIRM (confirm the returned content is the privileged resource). Unauthenticated is ENFORCED, not assumed: the probe derives a credential-free config (no session cookie jar, no session rules or re-auth hook, and Cookie / Authorization / Proxy-Authorization stripped from any extra headers) and sends baseline, control and every forged probe through it, so an authenticated scan still sees the anonymous deny instead of being served the baseline and abandoning the endpoint. Critical for an identity header that impersonates a user, high for a trusted-address / malformed-token bypass. fissure_checks_active_authbypass, run on every GET endpoint in the scan; also POST /api/authbypass / MCP authbypass and the "Test auth bypass" context-menu action Built-in (deny-vs-forged-header flip)
Business logic (numeric/price tampering) A04 CWE-840 for a price-, quantity-, or amount-like numeric field (a JSON body leaf or a query parameter whose name matches amount/price/qty/total/cost/balance/credit/discount/...), set it to a NEGATIVE value and flag it when the state-changing request still succeeds the same way as the legitimate one (the endpoint does not validate the field). A negative price/quantity/amount commonly inverts business logic (a negative quantity or price credits the buyer, a negative amount reverses a transfer). The field-name targeting keeps false positives low; TENTATIVE (confirm the negative produced a real inverted effect - a credit, refund, increased balance - not just an accepted request). An ASSIST, not a general business-logic oracle: pair it with the race check (double-spend / limit overrun) and the workflow/step-order bypass probe. GET/body, aggressive. fissure_checks_active_bizlogic, run on body + query endpoints in the scan (the bizlogic family); also POST /api/bizlogic / MCP bizlogic Built-in (negative-value acceptance on a money-named field)
Business logic (workflow / step-order bypass) A04 CWE-840 replay a recorded multi-step flow in order through a fresh cookie jar (so the final protected step succeeds with all its prerequisites, carrying session/workflow state via Set-Cookie), then replay ONLY the final step in a second fresh jar seeded with the same persistent auth cookie; flag it when the final step still succeeds the same way without its intermediate prerequisite steps, meaning the server does not enforce the workflow order (a user can skip payment/approval/verification and reach the protected action). An ASSIST (TENTATIVE): it only observes that the final step works standalone after the in-order baseline also succeeded, so the caller supplies a genuinely ordered flow (independent steps would false-positive) and confirms the out-of-order call produced the protected effect. On-demand (needs a recorded flow), aggressive. fissure_checks_bizlogic_workflow, POST /api/workflow-bypass / MCP workflow_bypass Built-in (out-of-order final-step success)
Reflected File Download (RFD) A03 CWE-79 on an endpoint whose baseline is reachable, non-HTML, and carries no pinned attachment filename, inject a command-shaped marker into each query parameter (and a JSONP callback) and request it under a ...;/name.bat path segment; flag when the marker is reflected unescaped in the served (2xx) non-HTML response with no Content-Disposition filename. Such an endpoint lets a link on the trusted origin download an executable batch/command file named from the URL whose content the attacker controls, so a victim running the "file from a trusted site" executes commands (OWASP RFD). Skips an HTML (rendered) response and one with a pinned attachment; filename= (which fixes the download name). TENTATIVE (confirm the download name and content per target browser). GET-only, aggressive. fissure_checks_active_rfd, run on GET endpoints in the scan (the rfd family); also POST /api/rfd / MCP rfd Built-in (reflection + ;/name.bat path + missing disposition)
URL-level access-control bypass (401/403 bypass) A01 CWE-284/CWE-288 distinct from the auth-header bypass above (which forges WHO you are); this forges WHICH url the back-end authorizes. On an endpoint that DENIES an anonymous request (with an untrusted control header first, so a header-reactive endpoint is skipped): (1) URL-override headers (X-Original-URL, X-Rewrite-URL, X-Override-URL, X-Original-URI) sent to the origin root naming the denied path - a served 2xx whose body differs from a plain root fetch means the front-end re-routed to the protected resource; (2) path-normalization variants of the denied path (a trailing /, //, /., %2f, a trailing %20/%09, a ..;/ path-parameter segment) - a served 2xx on a variant the server normalizes to the same resource. Each deny-to-2xx flip is flagged (FIRM; confirm the returned content is the protected resource). Offensive access-control testing (reach the resource), never detection-evasion. GET-only, aggressive, and unauthenticated in the same enforced sense as the auth-header bypass above (every send goes through the credential-free config). fissure_checks_active_aclbypass, run on every GET endpoint in the scan (the aclbypass family); also POST /api/aclbypass / MCP aclbypass Built-in (deny-vs-variant flip)
Mass assignment A04 CWE-915 on a JSON or urlencoded body endpoint, first send a CONTROL probe adding a random-named field; if the server echoes it, the endpoint just reflects input, so stop (no false positive on echo endpoints). Otherwise add each privileged field name (role, is_admin, account_type, is_active, ...) not already present, one at a time, carrying a unique nonce; flag the first whose nonce comes back while the control's did not - the server selectively BOUND a privilege-related attribute from client input, not a blanket echo (chk_massassign_json / chk_massassign_form, aggressive, tentative HIGH - confirm with a real privileged value). fissure_checks_active_massassign, run on body endpoints in the scan; also POST /api/massassign / MCP massassign and the "Mass assignment / HPP" context-menu action Built-in (control-vs-privileged nonce)
HTTP parameter pollution A04 CWE-235 for each reflected query parameter, set it to a nonce (single occurrence) then send it DUPLICATED with a second nonce; if the response reflects the last value (last-wins) or both (array/concat), duplicate-parameter handling can bypass a control that validates the first occurrence (chk_hpp, aggressive, tentative LOW; a first-wins endpoint is not flagged). Runs on any URL with a query (GET or POST) in the scan, alongside the mass-assignment probe Built-in (duplicate-param last-wins)
NoSQL injection A03 CWE-943 on a JSON body endpoint (Mongo/Couch-class document store), for each scalar field replace the value with a match-all query operator {"$ne":<nonce>} and a match-none operator {"$eq":<nonce>}; a server that EVALUATES the operator responds differently to the two (the match-all bypasses an auth check or returns rows while match-none is denied), which flags operator injection an attacker can use to bypass authentication or extract data. A literal-only server returns the same response for both, so an echo/reflection endpoint produces no differential and is not flagged (low false positive). The differential arm only runs on a page that answers the SAME request identically: the baseline is sent twice and must repeat itself (FISSURE_CHK_BOOL_STABLE_RATIO, the gate the boolean-blind SQLi probe already applies), and both bodies are linearized at JSON/HTML delimiters before they are compared, so a minified reply carrying a request id, a timestamp or any rotating token is not read as two different pages and does not make every field of every dynamic endpoint look injectable. The error-based arm is signature-driven and runs either way. An error-based {"$regex":"("} probe additionally flags a driver error signature (MongoError, CastError, BSONError, E11000) the baseline lacked. fissure_checks_active_nosqli, aggressive, FIRM, run on JSON body endpoints in the scan (the nosqli family); also POST /api/nosqli / MCP nosqli Built-in (ne/ne/eq boolean differential + error-based)
Auth / session issues A07 CWE-287/CWE-384 weak session cookie flags, predictable tokens, no logout invalidation, login brute (manual) Built-in (cookie/flag checks)
CSRF A01 CWE-352 passive: a state-changing form/endpoint lacking an anti-CSRF token or SameSite cookie; active (chk_csrf_active, aggressive): 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 token field removed - and flag it when the state change still succeeds identically (only when a token field is present and the baseline succeeds, so a stale token cannot false-positive); for a JSON body, the JSON-CSRF probe (chk_csrf_json) resends the same body as text/plain and flags it if the endpoint accepts it (no content-type guard means a cross-site enctype=text/plain form can forge the JSON request with no CORS preflight). "Succeeded the same way" is judged on the response's SHAPE, not its bytes: both bodies have their server-generated identifiers masked (decimal runs and hex/UUID tokens) and are linearized at JSON/HTML delimiters before the similarity comparison, so a create endpoint that echoes a fresh id, a timestamp, or a rotating token still compares equal to its own baseline. A raw line-based comparison reads 0.0 on a minified single-line JSON body, which silently turned every one of these differentials (the token tamper, the JSON-CSRF probe, the method-override and SameSite-Lax depth probes, the cross-identity differential, and the business-logic negative-value probe) into a no-op on exactly the JSON APIs they exist for. Two depth probes run in the same active check: a method-override bypass (chk_csrf_method_override) for a PUT/PATCH/DELETE request, where the real method succeeds, a plain cross-site POST is rejected, but a POST carrying _method / X-HTTP-Method-Override / X-Method-Override succeeds, so a form can forge the CSRF-safe verb; and a SameSite-Lax bypass (chk_csrf_samesite) for a form body, where the state change also succeeds as a top-level GET while a Set-Cookie does not pin the session cookie to SameSite=Strict (a cross-site top-level navigation then carries the Lax/default cookie). A cross-identity token-reuse differential (chk_csrf_crossid, on-demand only, needs two sessions) flags an anti-CSRF token that is validated but not session-bound: A's token succeeds under A, a garbage token is rejected under B, and A's real token is then accepted under B. The whole active check is exposed on demand at POST /api/csrf-active / MCP csrf_active ({url,body,method?,cookie?,cookie_a?,cookie_b?}). Plus the PoC generator (fissure_csrf_poc, also POST /api/csrf-poc / MCP csrf_poc): an auto-submitting form or credentialed fetch, and for a JSON object body a text/plain form-trick PoC and for a PUT/PATCH/DELETE a _method method-override form Built-in (passive + active token-tamper + JSON-CSRF + method-override + SameSite-Lax + cross-identity + PoC)
Security headers / misconfig (Nikto-style) A05 CWE-16/CWE-693 absence/weakness of CSP, HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy; server banner; dangerous methods (TRACE/PUT) Built-in; plugin (nikto/nuclei)
Exposed .git/.env/backup A05 CWE-538/CWE-540 probe /.git/HEAD, /.env, .bak/~/.swp, /.DS_Store, /config.php.bak; confirm by content signature. The set also covers the WordPress leftovers and always-on endpoints: wp-config.php.bak and wp-config.php~ (database credentials + auth salts, critical), a reachable wp-admin/install.php installer form (site takeover, critical - the already-installed page carries no form fields, so it is not flagged), wp-content/debug.log, xmlrpc.php, wp-json/wp/v2/users (user enumeration) and readme.html (version pinning). Each is signature-confirmed, so a non-WordPress host 404s through the block (fissure_checks_files, the files family) Built-in (sensitive-file probes)
Directory listing enabled A05 CWE-548 a server with automatic directory indexing left on serves a generated file list for any directory with no index page, which maps everything stored there including files nothing links to. 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, tmp, logs, data, includes, 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 anchored to the title/heading that emits it so a page merely quoting the phrase is not reported. MEDIUM when the directory holds uploads, backups, logs, configuration or version-control data, LOW otherwise; the evidence names the server flavor and the first listed entries. The entry summary is read relative to the directory probed, because IIS directory browsing writes every listed file as an ABSOLUTE path (/uploads/dump.bak inside the listing of /uploads/): an absolute link counts as a listed entry when it names something strictly below that directory, while the parent link, a link to another branch, and the column-sort links (the directory itself under a sort order) stay navigation. Capped at 128 directories per host, with the well-known set queued ahead of the crawl-derived list so a large site cannot crowd it out and anything past the cap logged (fissure_dirlist_probe, the files family; also POST /api/dirlist / MCP dirlist and the Probes popup "Directory listing" button) Built-in (generated-index signatures)
CORS misconfig A05 CWE-942 passive: flag Access-Control-Allow-Origin: * / null (+ credentials); active (chk_cors_active, aggressive, once per endpoint): send an arbitrary, a null, a look-alike sibling, and a target-subdomain Origin and flag a reflected Access-Control-Allow-Origin (high when Access-Control-Allow-Credentials: true) Built-in (passive + active reflection)
Subdomain takeover A05 CWE-350 fetch each in-scope inventory host (the subdomains recon seeds) on https then http and match the body against a set of distinctive "unclaimed resource" fingerprints for cloud/SaaS providers (GitHub Pages, S3, Heroku, Fastly, Shopify, Ghost, Pantheon, Tumblr, Surge, ...); a match means a dangling CNAME likely points to a claimable resource. On a match, the host's CNAME chain is followed hop by hop (fissure_dns, a res_query wrapper over the system resolver, thread-safe; up to FISSURE_CHK_TAKEOVER_CNAME_MAX_HOPS, so a record that CNAMEs through intermediates is still resolved) and each hop checked against the provider's DNS suffix: any hop matching CONFIRMS the dangling record (raised certain, with the deepest CNAME in the evidence), a mismatch or no-CNAME stays firm and tells the operator to verify (fissure_checks_active_takeover, run once per host in the aggressive scan; also POST /api/takeover / MCP takeover and the "Subdomain takeover" context-menu action) Built-in (fingerprint + CNAME confirmation) + plugin (subjack/nuclei)
Unrestricted file upload A05 CWE-434 submit a set of malicious upload variants to a multipart upload endpoint - executable / double / alternate / mixed-case extension, content-type spoof, magic-byte GIF+PHP polyglot, null-byte truncation, path-traversal filename, SVG/HTML stored XSS - each carrying the common submit-trigger fields so the handler actually processes it. EVERY variant carries its own marker (the run marker plus a per-technique suffix) in BOTH its filename and its body, so no two techniques share a stored name: they used to collapse onto one <marker>.php and the file stored by the first technique confirmed the others, reporting bypasses that never happened. A 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 nothing and is only reported when its file is actually fetched back. Confirmation fetches the likely served locations (the endpoint directory, the common upload directories, the web root, and - for a ../ filename - each of their ancestors, one level per leading ../, which is where a successful traversal really lands the file) and looks for that variant's marker: found = CERTAIN (CRITICAL when the payload executed), otherwise TENTATIVE/HIGH (fissure_upload + fissure_checks_upload; also POST /api/upload / MCP upload and the "Test file upload" context-menu action) Built-in (per-technique markers + benign-control differential + served-file confirmation)
Origin IP reachable behind a CDN/WAF A05 CWE-200 connect directly to each candidate IP (recon supplies them) while sending the target Host header, on http AND https (an explicit :443/:8443 tries TLS first; the second scheme only when the first got no HTTP answer), and count 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 alone is NOT confirmation, since any box running a stock web server answers any Host: the candidate must also pass a CONTROL (the same address asked again with a Host it cannot know must not return the same page) and a REFERENCE comparison (its body must match the site fetched through its own name). Both hold: FIRM. No reference fetchable: TENTATIVE, with the evidence saying so. Body does not match the reference, or no reference and the control got the same page: not reported (fissure_originip; also POST /api/originip / MCP originip and the Probes popup "Find origin IP") Built-in (reference + bogus-Host differentials)
Outdated components A06 CWE-1104 front-end JS libraries: fingerprint the library and version from the body or script URL and compare against a curated advisory table (fissure_jslib, passive, see section 5); server frameworks: fingerprint and map to known CVEs Built-in (JS libraries); plugin (nuclei templates) for the rest
TLS / cert issues A02 CWE-326/CWE-295 weak protocol/cipher, expired/self-signed/host-mismatch cert, missing OCSP Built-in (cert inspect via n_network TLS) + plugin (testssl.sh)
Sensitive data exposure A02 CWE-200 n_pcre scan responses for emails, API keys, JWTs, private keys, AWS keys, stack traces Built-in (n_pcre patterns)

Each positive result becomes a FISSURE_FINDING with its category, cwe, owasp, evidence (the request/response excerpt), and confidence (section 9).

4.1 Access-control / IDOR replay (DONE)

fissure_authz_replay (src/fissure_authz_replay.{c,h}, test_authz_replay) is the access-control replay check, triggered from the Proxy/Findings right-click "Check access control". Given a captured authenticated request it re-fetches the authenticated baseline, then replays the request twice: once under a second identity (the original credential headers, Cookie / Authorization / X-Api-Key / X-Auth-Token and similar, dropped and replaced by the low-privilege identity configured in Settings) and once with all credentials stripped. Each replay's response body is diffed against the baseline with fissure_diff_similarity and classified:

  • BYPASSED: the replay returned a 2xx whose body matches the baseline (>= FISSURE_AUTHZ_SAME_RATIO). The resource is served to the other / no identity: a broken-access-control / IDOR finding (CWE-639, second identity) or a missing- authentication finding (CWE-862, stripped) is raised, OWASP A01.
  • ENFORCED: the replay returned 401/403, a redirect (to a login page), or 2xx with different content. Access control holds; nothing is reported.
  • INCONCLUSIVE: the baseline was not a 2xx, or a replay failed, or there was nothing to test (no second identity configured / the request had no credential).

Redirects are not followed (a redirect to login is a sign of enforcement). The check runs on a Findings-view worker thread so the UI stays responsive (fissure_gui_findings_check_authz), shows a spinner while running, and reports the verdict as a popup; the findings land in the Findings store. The low-privilege identity is a persisted Settings field (authz_identity); recorded-login automation to capture such a session shipped as the login recorder (fissure_loginrec), which records a login exchange and replays it to obtain a fresh authenticated session.

5. Built-in vs plugin tests

The dividing line: Fissure implements natively the checks that are fast, deterministic, and need tight request/response control; it delegates the checks that need large rule sets, deep state machines, or specialized engines.

Built-in native C checks (fissure_checks):

  • All HTTP security-header and misconfiguration checks (header presence, cookie flags, dangerous methods, server banner) - pure response inspection.
  • DOM-based XSS heuristic (fissure_domxss, passive) - a static scan of the HTML/JS body for a dangerous client-side sink (document.write, innerHTML, outerHTML, insertAdjacentHTML, eval, new Function, setTimeout/setInterval with a string, jQuery .html()/.append()/..., location.href/replace/assign) whose enclosing statement reads an attacker-controllable source (location.hash/ search/href/pathname, document.URL/documentURI/baseURI/referrer, window.name). It flags a source and a sink in the same statement, the common DOM-XSS shape; a static approximation (not a taint tracer), so findings are TENTATIVE and should be confirmed. Each hit becomes a MEDIUM "Potential DOM-based XSS: flows into " finding (CWE-79). Deeper context-aware DOM analysis is delegated to dalfox.
  • Vulnerable JavaScript library detection (fissure_jslib, passive, retire.js-style) - fissure_jslib_scan(body, url) fingerprints a known front-end library and its version from the response body or the script URL (for example "jQuery v1.8.3", "jquery-1.8.3.min.js", "Bootstrap v3.3.7") and, when the version is strictly below the first fixed release of an advisory in its small curated, offline table (jQuery, Bootstrap, AngularJS, lodash, Moment.js, Handlebars, DOMPurify), reports that library once with the highest- severity matching advisory: library, detected version, fixed-in version, CVE and a short detail. Each hit becomes a host-level "Vulnerable JavaScript library: " finding (Vulnerable Component, CWE-1104, A06:2021, FIRM) at the advisory's severity. No traffic is generated. It is also reachable on its own as POST /api/jslib (MCP jslib) over a supplied body and/or URL.
  • Client-side prototype-pollution heuristic (chk_dom_protopollution, passive, runs on HTML inline scripts and standalone .js/.mjs bodies) - flags a script that BOTH reads an attacker-controllable URL source (location.hash/search/href, document.URL/location, window.name, document.referrer) AND uses a recursive merge / deep-set gadget ($.extend(true, ...), deepmerge, mergeDeep, deepExtend, lodash _.merge/_.mergeWith/_.set/_.setWith, object-path). Both together are the ingredients of a DOM prototype-pollution chain (a fragment parsed into an object with a __proto__ key, then merged) - CWE-1321. A static co-occurrence heuristic (not a taint tracer), so findings are TENTATIVE; confirm the source reaches the sink and keys are unsanitized.
  • Client-Side Path Traversal (CSPT) heuristic (fissure_cspt, passive, runs on HTML/JS bodies) - flags a client-side request sink (fetch, an XHR .open(), axios, jQuery.ajax/get/post) whose request URL is built, in the same statement, from a URL-derived source the attacker controls (location.pathname/search/hash/ href, document.URL, window.location, a router param such as useParams/router.query/ router.asPath/route match, URLSearchParams.get, getParameterByName). When such a value is concatenated into a request path without canonicalization, a ../ (or ..%2f, ..%5c, %252e%252e) can retarget the request to a different API endpoint - the CSPT primitive that escalates to CSPT-to-CSRF (retarget a state-changing call) or CSPT-to-XSS (a spoofed API response into a DOM sink), CWE-22. The source may sit before or after the sink in that statement (the whole statement is examined, not only what follows the sink), and a .open( call counts only when its receiver names an XHR object (xhr, req, httpRequest, ajax), so window.open(), dialog.open(), db.open() and modal.open() are not request sinks. A static co-occurrence heuristic (not a taint tracer), so findings are TENTATIVE; confirm at runtime with the active CSPT probe (below) or by hand (load the page and check a ../ in the source changes which endpoint the request hits). Also POST /api/cspt / MCP cspt.
  • Client-Side Path Traversal runtime confirmation (fissure_domprobe_cspt_run, active, needs a headless Chromium) - upgrades a CSPT lead from a static guess to a runtime-verified finding. Loads the page in a headless browser with a unique ../ marker injected into a client-side URL source (the location fragment by default, or a path segment / a query parameter), and watches Network.requestWillBeSent: when the page's own client-side request (fetch/XHR) is retargeted to a URL carrying the marker, the traversal is confirmed (CWE-22, HIGH, FIRM), excluding the top-level document navigation. On a hit it also returns the crafted navigation URL and a CSPT PoC page (fissure_domprobe_cspt_poc) that top-level-navigates a victim there (CSPT-to-CSRF / CSPT-to-XSS). POST /api/cspt-confirm / MCP cspt_confirm; the CDP orchestration is unit-tested offline through the stub-session seam, the live confirmation is a nearest-target validation.
  • Reflected-XSS reflection check - marker injection + unencoded reflection.
  • Server-side template injection (SSTI) - an arithmetic expression is injected wrapped in ten engine delimiter styles ({{}}, ${}, <%= %>, #{}, [[ ]], *{}, @( ), and so on). If the engine evaluates it, the product of two per-run random operands appears in the response; a second operand pair must also evaluate before it reports, so a coincidental number cannot false-positive. Runs in both modes (arithmetic only, non-destructive). CWE-1336.
  • In-band OS command injection - a shell metacharacter followed by id; the command's uid/gid output in the response confirms execution (reflection-safe: a verbatim echo never contains "uid=...gid=..."). Complements the blind time-based command-injection probe with certain in-band proof. Aggressive only (executes a read-only command). CWE-78.
  • CRLF / HTTP header injection - an encoded CRLF plus a marker header is injected; if the target decodes it into the response header stream the marker header comes back, proving response splitting / header injection / cache-poisoning exposure. Runs in both modes (a benign marker header, not a Set-Cookie). CWE-113.
  • Error-based SQLi - n_pcre against DB error signatures, then a balanced two-quote control that must NOT error (so a DB error that does not track quote parity is dropped), then a re-sent single-quote probe that must REPRODUCE the same error (so a transient one-off DB error is dropped).
  • Boolean-based blind SQLi - stable-baseline TRUE/FALSE response comparison via fissure_diff_similarity (aggressive, query parameters).
  • Path traversal / LFI - n_pcre against file-content markers.
  • Open redirect - Location/meta-refresh sentinel check.
  • CORS misconfig - Origin reflection check.
  • Sensitive-file probes - a curated path list (40 entries) probed once per host and confirmed by a content signature (caseless regex on the body). Covers VCS metadata (.git/config, .git/HEAD, .git-credentials, .gitmodules, .hg/hgrc, .svn/entries), credential and cloud config (.htpasswd, .netrc, .npmrc, .pgpass, .s3cfg, .aws/credentials, .aws/config, .ssh/id_rsa, .ssh/authorized_keys, .dockercfg, docker-compose.yml, Dockerfile, service-account-credentials.json, Rails database.yml/secrets.yml), logs and management endpoints (Laravel log, Symfony profiler, Spring Boot actuator/env and actuator/heapdump, Go /debug/pprof, Prometheus /metrics, Apache server-status/server-info), source maps and API docs (*.js.map, swagger.json), shell history, and source backups served as text (config.php.bak, database.sql). The list is harvested from the ProjectDiscovery nuclei-templates exposure/misconfiguration matchers (MIT).
  • Sensitive-data exposure - n_pcre secret patterns over responses.
  • TLS/cert inspection - via the n_network TLS client (peer cert, protocol).
  • Time-delta blind checks (SQLi time-based, OS command injection) - delay probe versus zero-delay control, measured from the transport timing breakdown.
  • GraphQL active check (fissure_checks_active_graphql) - runs for a request the scan recognizes as GraphQL (fissure_checks_is_graphql: a URL containing "graphql" or a JSON body with a top-level "query" string). Four GraphQL-aware probes: (1) introspection detection (POST an __schema query; a schema response raises a MEDIUM "GraphQL introspection enabled" finding). When the plain query is refused, it then probes two introspection-filter bypasses (chk_graphql_ introspection_bypass): a newline before the selection set that defeats a naive "__schema{" string/regex filter, and the same query over GET when only POST is blocked; either that returns a schema raises a MEDIUM "introspection filter bypassed" / "reachable over GET" finding (CWE-200), a broken defense that fails open. (2) per-argument fuzzing, where each inline literal argument of the query document is enumerated and rewritten by fissure_graphql (a pragmatic argument extractor, not a full parser) and run through a CHK_POINT_GRAPHQL insertion point with the same XSS/SQLi/LFI/time-based/OAST-canary probes as other points (the "variables" object scalars are still covered by the JSON check); (3) CSRF detection (chk_graphql_csrf): a benign read-only {__typename} is replayed over the two cross-site-forgeable transports, a GET query string and a form-encoded POST (application/x-www-form-urlencoded, a CORS simple request that does not preflight); if either executes, a state-changing mutation sent the same way is a CSRF, raising a MEDIUM "operations execute over GET / a form-encoded POST (CSRF)" finding (CWE-352); (4) field-suggestion schema disclosure (chk_graphql_suggestions, read-only): a query for a deliberately misspelled field ({__typenam}); a "did you mean" suggestion in the error leaks real field names one guess at a time and recovers the schema even when introspection is off, raising a LOW "field-suggestion disclosure" finding (CWE-200); and, aggressive only, three intrusive cost probes: (5) a bounded query-batching probe that flags unbounded operation batching (CWE-770: DoS amplification / rate-limit bypass); (6) alias-based rate-limit bypass (chk_graphql_alias_bruteforce): one operation that aliases a trivial field eight times; when every alias executes in a single request, per-request rate limits and brute-force protections are defeated (many login / one-time-password attempts in one HTTP request), distinct from array batching, raising a MEDIUM "alias-based rate-limit bypass" finding (CWE-799); and (7) missing query-depth / complexity guards (chk_graphql_depth_dos, whose proof of a guard is a depth/complexity/cost marker inside an entry of the response's errors array, never anywhere in the document, so a schema that merely has a field named cost does not count as a guard): a deeply nested query that executes with no depth or complexity error, and a self-referential (circular) fragment spread that is accepted instead of rejected, are denial-of-service levers, raising a MEDIUM "no query-depth or complexity limit" / "accepts circular fragment spreads" finding (CWE-770 / CWE-674). Deeper engine fingerprinting and schema recovery are delegated to the graphw00f / clairvoyance plugins, and a no-C introspection check ships as resources/checks/graphql-introspection.js. The same fissure_graphql argument extractor also backs an interactive GraphQL argument workshop for manual testing: a "GraphQL" popup (the Test & attack toolbar category and the command palette) where an operator pastes a query, lists its injectable inline literal arguments (index: field.arg), and mutates one at a chosen index with a probe value to get a rewritten, ready-to-send query. The same three operations (count, name, mutate) are exposed over the control API (POST /api/graphql) and the MCP graphql tool, so the manual workshop and the automated argument-fuzzing check share one code path across all surfaces.
  • Cross-role site-map comparison (fissure_rolediff, offline) - access-control analysis in the spirit of a "compare site maps" workflow. Scan a target while authenticated as a higher-privilege role (an admin session) and click "Snapshot role" in the Site map view to save that inventory as the baseline; then switch to a lower-privilege identity (change or clear the Login config in Settings), rescan the same target, and click "Compare roles". Each (method, canonical URL) is matched across the two inventories and its observed status classified per role (reached 2xx, denied 401/403 or any 3xx, absent 0/404, other). A redirect is classed as denied rather than reached: it did not serve the resource, and in practice it is a redirect to a login page, so counting it as reached made every protected page of an ordinary login-redirect application read as reachable-by-both and buried the real differences. A resource the baseline reached but the test role could not is access control holding; a resource BOTH roles reached is a potential broken-access- control signal and raises a MEDIUM, TENTATIVE Broken Access Control finding (CWE-284, A01) into the scan findings store. Public pages legitimately appear as reachable-by-both, so the operator confirms each. No traffic is generated by the comparison itself; it diffs two already collected inventories.

The response-only native passive checks (headers, cookies, banner, CORS, sensitive-data exposure, DOM-XSS) do not only run inside a scan. The Proxy view runs them live on each newly captured in-scope flow (run_passive_on_flow in fissure_gui_proxy.c): it parses the captured raw response with fissure_engine_parse_response and calls fissure_checks_passive (alongside the user JS/BCheck passive scripts), merging findings into the shared store under its lock. This is the "live passive audit" of proxy traffic, so passive-first browsing surfaces the native checks without an explicit scan; findings are deduplicated (host|category|title|location) against a later scan. Out-of-scope hosts are never captured (they blind-tunnel), so the live audit is inherently scope-limited.

Delegated to OSS tools via the plugin host (01_SECURITY_TOOLS_CATALOG.md):

Need Tool Why not native
Templated CVE / nuclei checks nuclei thousands of community templates
Deep SQLi (extraction, WAF bypass) sqlmap full DBMS state machine
Large wordlist fuzzing ffuf / feroxbuster tuned high-throughput fuzzer
Advanced/DOM XSS dalfox context-aware payload generation
GraphQL engine fingerprint graphw00f large engine-signature database
GraphQL schema recovery (introspection off) clairvoyance field-suggestion brute force
Subdomain enum subfinder / amass data-source breadth
Subdomain takeover subjack / nuclei provider fingerprint DB
TLS deep audit testssl.sh exhaustive cipher matrix

The plugin host runs a tool against the target/scope, parses its output with a manifest mapping (02_ARCHITECTURE.md section on plugins), and emits FISSURE_FINDINGs with source = PLUGIN and source_tool = <id>. The store's dedup hash collapses a finding that both a native check and a plugin report. Adding a tool is a manifest change, not a code change.

6. The testing engine

fissure_checks turns a (endpoint, position, payload-class) tuple into one or more concrete tests. A test is: take the baseline request, mutate one position, send it through the transport core, evaluate the response.

6.1 Payload sets

Payloads and wordlists ship as JSON under resources/ and are auto-downloadable per resources/dependencies.json (a manifest of name, url, sha256, target path). On first use the scanner verifies the sha256 (n_digest_sha256_hex, NILOREA_AUDIT 5C) before loading. Example layout:

resources/
  payloads/
    xss.json            { "markers": [...], "vectors": [...] }
    sqli_error.json     { "probes": ["'","\")","-- -"], "signatures": [...] }
    sqli_time.json      { "vectors": ["' AND SLEEP({d})-- -", ...], "delay": 5 }
    traversal.json      { "vectors": ["../../../../etc/passwd", ...], "markers": [...] }
    redirect.json       { "params": [...], "sentinel": "fissure.example" }
    cmdi.json           { "vectors": ["; sleep {d}", "`sleep {d}`"], "delay": 5 }
    secrets.json        { "patterns": [ {"name":"AWS key","re":"AKIA[0-9A-Z]{16}"} ] }
  wordlists/
    common-paths.txt
    sensitive-files.txt

Signature lists compile once into n_pcre handles (thread-safe capture, NILOREA_AUDIT) and are shared across worker threads.

6.2 Mutate -> send -> evaluate

   baseline FISSURE_REQUEST (from endpoint/capture)
            |
            v   mutate exactly ONE position with one payload
   +------------------------------------------------+
   | location switch:                               |
   |  query  -> rebuild query (n_url encode)        |
   |  form   -> rebuild body field                  |
   |  json   -> set value at json path (cJSON)      |
   |  path   -> substitute segment                  |
   |  header -> set header value                    |
   |  cookie -> set cookie in jar                   |
   +------------------------------------------------+
            |
            v   transport core (Hook engine, native or curl backend)
   send  -> FISSURE_RESPONSE (+ FISSURE_TIMING; capture stored)
            |
            v   evaluator chooses by payload-class:
   reflection : marker appears unencoded in body         -> XSS
   signature  : n_pcre match against response body       -> SQLi err / LFI / secret
   time-delta : elapsed - baseline >= delay threshold    -> blind SQLi / cmdi
   diff       : status/length/content delta vs baseline  -> boolean SQLi / IDOR
   header     : header present/absent/weak                -> misconfig
   location   : 3xx Location host == sentinel             -> open redirect
            |
            v
   on hit: build FISSURE_FINDING (evidence = request+response refs)

Each test records its request/response as a FISSURE_CAPTURE so the finding's request_ref / response_ref resolve to real evidence. Blind checks send a no-delay control first to establish the baseline latency and avoid false positives from a slow but non-vulnerable endpoint (require N consecutive delayed hits with a clean control between).

6.3 Operating modes

Mode Trigger Behavior
Manual operator selects an endpoint/position and clicks "Test this" runs one check, shows request/response diff inline
Semi-auto operator picks checks, reviews the generated test list, then runs full preview before any traffic; good for sensitive targets
Fully-automatic a scan profile (low-hanging-fruit, full, custom) runs the whole pipeline governed by scope + rate + safe/aggressive toggle

A scan profile is JSON: which discovery sources, which checks, which plugins, rate limits, depth, and the safe/aggressive flag. Profiles live next to scan sessions and are editable in the GUI (03_GUI_DESIGN.md).

6.4 Authenticated scanning (login automation, DONE)

To scan behind a login, the operator points the Target view at a login config (Settings -> "Login config", a JSON file; resources/login/README.md documents the format and ships an example). fissure_login (src/fissure_login.{c,h}, test_login) is a recorded login sequence: an ordered list of requests replayed through one cookie jar (so each step's Set-Cookie carries to the next), with per-step extraction (a regex capture, a response header, or a JSON path) into named variables that later steps reference as {{name}} in their URL/headers/body. This handles a CSRF-token login: GET the login page, extract its token, POST the credentials with that token. An optional verify request confirms the session was established.

Before each scan the worker replays the login (fissure_login_run) into a session jar; the scan transport's FISSURE_CONFIG.cookie_jar points at that jar, and the engine sends it on every request that has no jar of its own (the config-level cookie-jar fallback in fissure_engine), so the whole crawl and audit run authenticated. A failed login is surfaced (a popup) and the scan proceeds unauthenticated rather than silently. The same session jar mechanism can feed the access-control replay check's identities (section 4.1).

Mid-scan re-authentication keeps a long scan authenticated when the session expires part-way through. Two triggers, both applied by the request engine and retried exactly once: a session rule that marks a response status (the scan enables a re-auth-on-401 rule automatically for an authenticated run), and a content trigger, the login config's optional reauth_on_contains substring. The content trigger matters because the common logout is a redirect to the login page (a 200 login form), not a 401, which a status rule would miss: set reauth_on_contains to a string unique to the logged-out/login page (for example a marker in the login form) and a scanned response containing it re-runs the login into the same jar and retries. The re-auth handler (fissure_reauth) serializes concurrent workers so they do not replay the login at once. It is wired identically across the surfaces that run an authenticated scan: the GUI sitemap scan, the CLI (fissure scan --login), and the control-API / MCP scan job (the login object rides in the request, so its reauth_on_contains field travels with it). Without a marker the status trigger still applies; with neither, the scan behaves as before (no re-auth).

7. Scriptable checks (QuickJS)

For checks Fissure does not ship, the operator writes a JavaScript check that runs on the bundled QuickJS engine (src/fissure_js.{c,h}, the QuickJS sources reused from Hook under quickjs/). The engine is implemented and tested (tests/test_checks_js).

A scriptable check inspects one already-obtained HTTP response and reports findings. By default it sends nothing of its own, so it runs in the same response-only stage as the native passive checks and is safe to run against any captured traffic. In an active scan it may additionally probe with fs.send() (below). The script sees the fs.* API:

Member Meaning
fs.url, fs.method request line of the observed exchange
fs.status response status code (int)
fs.body decoded response body (string)
fs.time elapsed time in milliseconds
fs.header(name) one response header value, or undefined
fs.headers() all response headers as an object
fs.json() the body parsed as JSON, or null
fs.active true when fs.send() is permitted (active scan)
fs.send({...}) send a request and return its response (active scan only)
fs.log(msg) write a line to the application log
fs.report({...}) emit a FISSURE_FINDING
console.log/warn/error write to the application log

fs.report(obj) accepts: severity ("info".."critical", default info), category (required), title (required), description, evidence, location (defaults to fs.url), cwe, owasp, remediation, and confidence ("tentative"/"firm"/"certain", default tentative). Each reported finding is deduplicated into the shared findings store with source scanner. A report missing category or title is logged and ignored; a syntax or runtime error aborts that one script and is logged.

// check: a debug token leaked in a response header
if (fs.status === 200 && fs.header("X-Debug-Token")) {
  fs.report({
    severity: "high",
    category: "Information Disclosure",
    cwe: "CWE-200",
    title: "Debug token header exposed",
    evidence: "X-Debug-Token: " + fs.header("X-Debug-Token"),
    confidence: "firm"
  });
}

During a scan, every *.js file under resources/checks/ is loaded and run against each audited response, in the same stage as the native passive checks; findings are deduplicated into the one store. All three scan entry points load that directory through fissure_scan_load_checks, which pulls in four stores at once: the *.js scripts, any .bcheck files, any imported nuclei templates, and the checks contributed by enabled extension bundles. The Target view loads it on the first scan, the control-API scan job loads it when the job is built, and the CLI fissure scan loads it right after the scan is created; a CLI run that cannot locate resources/checks says so on stderr and continues with the built-in native checks only. The engine can also take a check from memory (fissure_scan_add_check). Example checks ship in resources/checks/: auto directory-listing detection, verbose error / stack trace disclosure, and a passive OAuth/OIDC authorization-request analysis (oauth-flow.js, which parses the authorization request out of the URL and flags a missing state/nonce, the implicit flow, a code flow without PKCE, and a cleartext redirect_uri), alongside a README of the fs.* API.

Active scripts (fs.send)

In an active scan a script can issue its own requests with fs.send(req) to implement a probe-and-evaluate check like the native active checks. fs.send() is gated: it fires only when the scan runs active checks (the script sees fs.active === true); in a passive scan it throws, so guard it with if (fs.active) { ... }. req is an object with optional url (defaults to fs.url), method (defaults to GET), headers (an object of name to value), and body (a string). The call sends through the transport core (the same TLS, timeout, and proxy settings as the rest of the scan) and returns a response object { status, body, time, headers }, or null on a transport error. Each script is capped at FISSURE_JS_MAX_SENDS sends per run as a runaway guard.

A finding reported after a send is automatically linked to that send's request/response capture (request_ref / response_ref), so its report evidence and "Send to Repeater" reproduce the exact probe (section 6 of 06_REPORTING.md). The engine entry points are fissure_js_run_check_active / fissure_js_checks_run_active; the scan calls them with its capture store, transport config, and the active flag. active-reflection.js in resources/checks/ is a shipped example.

Active scripts send attack traffic and run only against authorized scope, under the same authorization banner and safe/aggressive gating as the native active checks.

8. Safety

A scanner that sends attack traffic is dangerous to operate. Safety is enforced, not advisory.

  • Authorization warning. On first run Fissure shows a one-time authorization banner the operator must accept (persisted under the config dir by fissure_authz); declining quits. Implemented via the shared confirm dialog (fissure_gui_confirm). Pressing Scan with Active checks enabled then opens a per-scan confirmation that names the target host and warns that attack traffic will be sent; the active scan starts only on confirmation. Passive-only scans start without the prompt. The docs and banner repeat: "Only scan systems you own or are explicitly authorized to test. Unauthorized scanning is illegal in most jurisdictions."

  • The target's own configuration is left alone. Two guards, both on by default, keep a scan from retuning the application it is testing:

    • its settings FORMS are not fuzzed (a payload in a security, debug, safe_mode or difficulty field, or any form whose action is the settings surface, changes how the application behaves), and a payload in a do/action/cmd dispatch value that is itself a state-change verb is caught the same way, and
    • its switch LINKS are recorded but never requested. A link carries a state change three ways, all refused: a setting name with a value (DVWA's <a href="?phpids=on">); a command-dispatch parameter whose value is the verb (Mutillidae's ?do=toggle-security, ?do=toggle-enforce-ssl, ?action=clear_log), checked only on a do/action/cmd/op/task key so a content link like ?page=ssl-misconfiguration.php whose value is a page noun stays crawlable; and a bare valueless toggle flag (?enforce-ssl, ?toggle-hints) whose key is itself a verb, while a valueless page noun (?settings) stays crawlable. Both halves of the scan enforce this: the crawl does not follow such a link, and the audit does not probe it either. The audit half is not redundant, because the crawl still RECORDS the link so the operator can see the surface exists, and the audit would otherwise fetch it straight out of the inventory.

    This is a correctness guard as much as a safety one. Exercising either one reconfigures the target in the middle of the scan, so every check that runs afterwards tests a differently-configured application, and a vulnerability that was really there when the scan started is simply absent by the time the scanner reaches it. The scan then reports clean, and nothing in the output says why. Measured on DVWA: letting the crawl follow that one ?phpids=on link turns the application's input filter on and takes the same scan from 14 high findings and 4 SQL injections to 5 high and none.

    A held-back form or link is still recorded in the inventory, and the scan raises a "Scan coverage" finding counting both, so the gap is visible rather than silent. Test that surface by hand, or opt back in with --fuzz-settings-forms (CLI), fuzz_settings_forms: true on POST /api/scans, or fuzz_settings_forms=True on the start_scan MCP tool, against a target you can reset.

  • Scope enforcement. Every outgoing test request is checked against the target's scope (same-origin / allowlist / scope_pattern) right before send, not just at discovery. An out-of-scope request is dropped and logged. SSRF payloads to internal ranges are gated behind the aggressive toggle.

  • Rate limiting and budget. Four controls bound scan load: a per-audited-endpoint request delay (scan_delay_ms, Settings or a profile), an audit concurrency cap (scan_max_threads, 0 = one worker per CPU core), a wall-clock time budget (scan_max_time_sec / --max-time / a profile's max_time_sec, 0 = unlimited), and a per-host request-rate governor (scan_rps / --rps / a profile's scan_rps, 0 = unlimited). The delay throttles request rate, the thread cap bounds concurrency, and the time budget stops the whole run early (crawl and audit) once exceeded, recording a "Scan stopped: time budget exceeded" finding so a truncated run reads as partial. The governor is a per-host token bucket (burst 1) in the engine send path shared by the crawl, the audit, and the active checks: each send blocks until the target host's next slot is due (sends spaced at least 1/rps apart per host, plus a small jitter), so raising the thread count never raises per-host request pressure past the configured requests/sec, and different hosts proceed independently. The wait is cancellation-aware, so a scan stop is not delayed by a pending token (fissure_ratelimit, borrowed by the transport config for the run).

  • TLS trust, resolved the same way as every other tool. The scan detects the system CA bundle and honours the "Verify TLS certificates" setting, exactly as the Repeater and the single-request tools do: it is not stricter than the rest of the suite. That setting is OFF by default, because the hosts this scanner is aimed at (staging, self-signed labs, appliances, anything behind the operator's own interception proxy) routinely serve certificates no store trusts, and a verification failure there yields no finding at all: it stops the request before it is sent, which reads as an unreachable target. Turn it back on with --verify-tls, the Settings toggle, or tls_verify: true. With verification on and a target whose certificate the system does not trust (a private CA, an internal PKI, a self-signed staging host), a trusted CA file reaches it without loosening anything else, via Settings -> "Trusted CA file", --ca-file <pem>, or the ca_file field on POST /api/scans and start_scan; prefer that over turning verification off wholesale, which accepts any certificate from any host the scan touches. A certificate that cannot be verified is reported with the real reason from the verify result ("self signed certificate", "certificate has expired"), and it is not retried: unlike a connection blip, a certificate does not become valid on the second attempt.

  • Giving up on an unreachable target. When a permanent transport failure occurs, or FISSURE_SCAN_MAX_CONSEC_FAIL endpoints fail in a row, the run latches a give-up flag that every loop (crawl, audit dispatch, audit worker) checks at its next unit, so it stops instead of repeating one failure across the whole queue. It records a "Scan stopped: the target could not be reached" finding and the reason reaches the operator: a popup in the GUI, a stderr block from the CLI, and stopped_early + stop_reason on GET /api/scans/{id} and get_scan_status (fissure_scan_stop_reason). An aborted run has partial coverage and must never be read as a clean result.

  • Safe / aggressive toggle. Safe mode (default): no payloads that can write, delete, or denial-of-service; time-based delays capped low; brute-force wordlists small; destructive plugins disabled. Aggressive mode: full payload sets, longer blind delays, large wordlists, all plugins - shown with a clear warning and never the default.

  • Scan-time WAF-bypass. An optional encoder chain (scan_waf_encoders / the Scan-options "WAF-bypass encoders" field / --waf-bypass / the waf_encoders field on POST /api/scans and start_scan) makes the active scanner encode every injected payload before it goes on the wire, so a blocking input filter (WAF/CDN) does not match the raw attack string. The chain is a comma-separated list of the shared encoders (case, space2comment, space2plus, space2tab, space2hash, space2dash, space2randomblank, multiplespaces, randomcomment, commentbeforeparentheses, percentage, apostrophemask, overlongutf8, url, urlall, url2x, charunicodeurlencode, versionedkeywords, nonrecursivereplacement, symboliclogical, equaltolike; e.g. case,versionedkeywords), the same ones the one-click WAF-bypass retry uses. Two of the shared encoders are deliberately NOT part of a scan chain, because the scan seam encodes a payload VALUE and neither of them transforms one: jsonpad pads a JSON OBJECT body (it returns anything else unchanged, so naming it here does nothing; the scan's JSON-body option is waf_body, below), and utf16 produces NUL-bearing bytes that only the XXE body path can carry (waf_xml_utf16, below). versionedkeywords wraps each SQL keyword in a MySQL conditional comment (/*!SELECT*/, which MySQL still executes but a WAF sees as a comment); symboliclogical turns AND/OR into &&/||; equaltolike turns = into LIKE; nonrecursivereplacement doubles a keyword so a WAF that STRIPS it once leaves it behind (a sanitizing-WAF class, distinct from a blocking one); charunicodeurlencode percent-u encodes (%uXXXX, an IIS/ASP.NET decoding form). The whitespace and comment family covers the shapes a rule written around a literal separator misses: space2hash/space2dash turn a space into a comment that runs to a newline, space2randomblank turns consecutive spaces into DIFFERENT whitespace bytes (cycled, not randomised, so the same payload always produces the same request and a finding reproduces byte for byte), multiplespaces turns one space into several, randomcomment puts an empty inline comment inside each SQL keyword and commentbeforeparentheses puts one before each call. The per-engine quirks are percentage (each letter percent-prefixed, which IIS/ASP strips before the application sees it), apostrophemask (the fullwidth apostrophe, which a backend that normalises fullwidth forms still reads as a quote) and overlongutf8 (the illegal overlong two-byte form of the metacharacters, which a lenient decoder folds back). The transform happens at the single active-check insertion seam (chk_probe_send, borrowed via FISSURE_CONFIG.waf_encoders), so it applies to the query, path, form, multipart, JSON, GraphQL, header, and cookie insertion points of the core injection engine in one place. These behave like sqlmap's tamper scripts: the operator picks a chain that survives the target's own decoding, so effectiveness is encoder- and context- dependent. 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 itself, which keeps every result printable and valid UTF-8 so it survives a JSON control-API field. The query, path and form points percent-encode the value for you, so the chain output is decoded once there before insertion; without that the escape reaches the application as literal text (space2tab would deliver the three characters %09, not a tab) and the transform does nothing at all. An escape an encoder means to reach the application intact is not a valid one and no decoder consumes it, which is how percentage (%S) passes through unharmed.

    The keyword-mangling encoders (case, space2comment/space2plus/space2tab) are the broadly useful ones for a keyword-based filter on the aggressive injection checks (SQLi, LFI, command injection), whose oracle is behavioral (a boolean/time/error difference or reflected file/command output) and so still fires after the target decodes the payload. The seam is The REQUEST-shaped companion is --waf-request (waf_request over the control API), which changes how the request CARRIES the payload rather than the payload itself: the shapes a payload encoder cannot express, because the transport URL-encodes what it is handed into one literal parameter value. pollute sends the parameter twice with the benign value first, for a filter that inspects the FIRST occurrence and an application that takes the last; pollutelast is the same pair reversed; bracket sends the name as name[]; dotnotation sends name.x; charset declares a character set the filter and the application disagree about; mpboundary quotes and pads the multipart boundary; mpduplicate emits a second Content-Disposition name on the fuzzed part (built on the upstream N_HTTP_MULTIPART_PART.disposition_extra option rather than string surgery on a built body). The seam is the request-building layer (chk_mutate_param and chk_build_form route the FUZZED pair through fissure_wafrequest_pair; the form and multipart senders ask fissure_wafrequest_content_type what to declare), and the filler fields are left alone so the form still validates. An unknown shape name is refused at every entry point rather than silently ignored. The JSON point speaks the same shapes in its own notation (chk_json_mutated_shaped): pollute and pollutelast emit the same KEY twice in the object holding the target scalar, and bracket sends the scalar as a one-element array; a target that is an array element has no key to duplicate, so the plain mutation is used unchanged. See src/fissure_wafrequest.h.

    A finding produced while a chain is active says WHICH transform carried it, and whether the filter had anything to do with it. Naming the chain alone would be a claim about the scan's own configuration rather than about the target: on a host with no filter the untransformed payload works just as well. So when an encoded probe produces a finding, the canonical payload is sent once more and the two outcomes go into the evidence. When the canonical form is refused (403/406/419/429/501, the codes a filter returns INSTEAD of passing the request on) and the transformed one is not, the evidence reads as an input-filter bypass and names the chain, which is a finding about the filter the owner can act on: the rule can be defeated without changing what the payload does to the application. When the canonical form is NOT refused, the evidence says so plainly and states that the transform is not what made the bug reachable. That costs one request per finding, never per probe.

    The seam is context-aware so an operator cannot silently mis-configure it: (1) at the query/path/form insertion points, which the transport already URL-encodes, the url-family encoders (url, urlall, url2x) are automatically stripped from the effective chain (applying them there would double-encode the value so the app decodes it to the still-encoded bytes and the injection never fires); the keyword-mangling encoders still apply. The url-family encoders remain in effect at the points the transport does not URL-encode (headers, cookies, raw bodies). (2) Every check whose oracle is the payload's own LITERAL bytes sends the payload raw (via chk_probe_send_raw, never through the WAF wrapper), because an encoder that alters those bytes defeats the detection outright and reports nothing rather than reporting that the bypass failed. That is the reflected-XSS and open-redirect marker echo, the CRLF marker header, the traversal PATH the target has to open, the id COMMAND the shell has to resolve, and the cloud-metadata URL the server has to fetch. (--waf-bypass case alone rewrites ../../../../etc/passwd into ../../../../EtC/pAsSwD, ;id into ;Id and X-Fissure-CRLF: fzcrlf7 into X-fIsSuRe-CrLf: FzCrLf7, so those four classes would report zero findings with no indication why.) WAF-bypass therefore targets the checks whose verdict comes from the target's BEHAVIOR after it decodes the payload (error-based and blind SQLi, the time-based probes, SSTI), where a transformed payload still triggers the same bug, and it never turns a would-be hit into a false negative. An unknown encoder name is rejected up front (an on-screen error in the GUI, a 400 / non-zero exit over the API/CLI). Because it defeats a protective control it carries the enforced code-of-conduct contract: a scan with WAF-bypass active shows the non-blocking code-of-conduct notice (GUI popup) and records the use in the event log before any traffic goes out. Blank = off (the default); authorized in-scope targets only.

  • Scan-time WAF-bypass for request bodies. The encoder-chain option above covers the string payloads at the query/path/form/header insertion points, but the specialized checks that build their own JSON request bodies (NoSQL operator injection $ne/$where, prototype-pollution __proto__, JSON-embedded injection) insert structural payloads a generic tamper encoder would corrupt (JSON operators/keys are case-sensitive and are keys, not URL-decoded values). A separate opt-in toggle (scan_waf_body / the Scan-options "WAF-bypass request bodies (JSON operators)" checkbox / --waf-body / the waf_body flag on POST /api/scans and start_scan) passes every JSON request body sent by the scanner (chk_send_json_ex, gated on FISSURE_CONFIG.waf_body) through the jsonunicode encoder. It unicode-escapes (\uXXXX) only the string-only signature characters $ _ < > ' ( ) (none of which appear in JSON structure or number tokens, so escaping them across the whole body is transparent), so a WAF signature on a NoSQL operator or a prototype-pollution key does not match while any conformant JSON parser decodes the body back to the identical object. Off by default; carries the same code-of-conduct contract.

  • Scan-time WAF-bypass for XML/XXE bodies. The XML analogue of the JSON body option, a separate opt-in toggle (scan_waf_xml / the Scan-options "WAF-bypass XML bodies (XXE)" checkbox / --waf-xml / the waf_xml flag on POST /api/scans and start_scan). XML markup keywords (<!ENTITY, SYSTEM, <!DOCTYPE) cannot be char-reference-encoded (they are markup, not text content), so the XXE check's XML body (chk_send_xml, gated on FISSURE_CONFIG.waf_xml) is passed through the xmlbypass encoder. It rewrites the DTD with two byte-safe, parser-transparent transforms: the SYSTEM keyword becomes a PUBLIC external id (an external identifier declared PUBLIC carries a public id plus the same system URI, which the parser fetches the same way, so a WAF keyed on SYSTEM is evaded), and the space after the DTD keywords (<!ENTITY/<!DOCTYPE/<!ELEMENT) becomes a tab (still valid XML whitespace, evading a signature keyed on the keyword plus a literal space). The entity resolves identically, so the in-band and out-of-band XXE oracles still fire. Off by default; carries the same code-of-conduct contract.

  • Scan-time UTF-16 WAF-bypass for XML/XXE bodies. The second classic XXE WAF-bypass, now available because the request-body path is binary-safe (fissure_request_set_body_n + the engine appends raw body bytes rather than a NUL-truncated string). A separate opt-in toggle (scan_waf_xml_utf16 / the Scan-options "WAF-bypass XML as UTF-16 (XXE)" checkbox / --waf-xml-utf16 / the waf_xml_utf16 flag on POST /api/scans and start_scan). When set, chk_send_xml re-encodes its XML body through the utf16 encoder (fissure_wafbypass): a UTF-16LE byte-order mark (FF FE) followed by each ASCII byte interleaved with a NUL, with a UTF-8 encoding declaration rewritten to UTF-16 so it agrees with the bytes. A WAF that signature-matches the ASCII markup (<!DOCTYPE/<!ENTITY/SYSTEM) sees UTF-16 bytes and no contiguous keyword, so it misses; an XML parser detects UTF-16 from the BOM and resolves the entity identically. It layers on waf_xml (the DTD is rewritten first, then the whole document UTF-16-encoded) and is sent length-aware (fissure_request_set_body_n, since the body carries NUL bytes). The utf16 encoder is also part of the general wafbypass encoder set (it must be the last encoder in a chain, as its NUL-carrying output cannot feed another C-string encoder), so wafbypass_resend / send_request(body_b64=...) can UTF-16-encode any crafted XML body. Off by default; same code-of-conduct contract.

  • Dry-run. Produces the full list of requests the scan would send (method, URL, mutated position, payload) without sending any. Used to review a profile against a sensitive target before committing.

  • Per-check opt-out. State-changing checks (form CSRF probes, command injection) can be individually disabled in the profile. The check-family mask (--families / profile / Scan-options popup) is complete: alongside the specialized families (deser, graphql, idor, xxe, cache, ...), the core injection engine is the maskable injection family (reflected XSS, open redirect, SSTI, CRLF, CORS, and aggressive SQLi/LFI/command injection and in-band/blind SSRF on every insertion point), and ssrf is a standalone out-of-band (OAST) blind-SSRF pass. Selecting only a specialized family (e.g. idor) therefore runs only that family; the injection engine no longer runs unconditionally. The ssrf pass is skipped when injection is also selected, since the injection engine already runs the SSRF probes.

9. Findings output

Every positive test produces a FISSURE_FINDING (02_ARCHITECTURE.md) and inserts it through the store, which dedups by dedup_key (host|category|title|location):

FISSURE_FINDING {             // src/fissure_finding.h
  severity;                   // info/low/medium/high/critical
  category; cwe; owasp;       // e.g. "Injection", "CWE-89", "A03:2021-Injection"
  title; description;
  evidence;                   // matched payload / snippet
  location;                   // URL or position the finding applies to
  remediation;                // fix guidance, or NULL
  confidence;                 // tentative / firm / certain
  source;                     // PROXY, SCANNER, PLUGIN or MANUAL
  source_tool;                // manifest id when PLUGIN
  endpoint_id;                // optional endpoint reference (persisted, not set by the checks)
  request_ref; response_ref;  // into the capture store (the exact test traffic)
  dedup_key;                  // host|category|title|location (or host|category|title)
  host_scoped;                // 1 = site-wide, the key omits the location
  created_us;
  triage; notes; tags;        // analyst triage state, notes, tags
}

Confidence reflects evidence strength: certain = unambiguous proof (file content returned, marker reflected unencoded, consistent time-delta over N trials); firm = strong signal with small false-positive risk (single signature match); tentative = heuristic only (missing header, id-shaped param). When a check sets no remediation, the report fills it from the built-in remediation library keyed by CWE / category (fissure_remediation_lookup), so every finding ships actionable guidance.

Findings live in the flat findings store (FISSURE_FINDINGS); they are linked to an endpoint by their location, not by an id list on the endpoint. The findings grid and the report (06_REPORTING.md) consume the model directly; the report is reproducible from the saved NDJSON session alone.

10. Concurrency

Throughput comes from n_thread_pool (NILOREA_AUDIT section 1); correctness and politeness come from a rate-limit governor in front of it.

  • Worklist model. Discovery (crawl frontier) and testing (the endpoint x position x check matrix) are both expressed as independent work items submitted with add_threaded_process; the main thread waits with wait_for_threaded_pool. Pool size is a profile setting (default modest).
  • Shared state. The seen-URLs HASH_TABLE, the session store, and the n_pcre signature handles are shared. The store's insert path takes a mutex (Hook's state_mutex pattern, HOOK_AUDIT section 4); the seen-set uses a rwlock (init_lock/read_lock/write_lock). n_pcre capture is thread-safe by design.
  • Audit off the lock. An endpoint's active-check traffic (the fuzzing requests, including the multi-second time-based probes) runs against per-endpoint local findings/capture stores with no scan lock held; the results are then merged into the shared stores under the lock (fissure_findings_merge / fissure_captures_merge). Only those brief merges are serialized, so workers do not contend on the mutex across their traffic and the GUI's trylock-based counters keep updating during long bursts. Capture ids are drawn from a process-global counter, so ids never collide across the local and shared stores and the merge keeps each finding's capture link valid without remapping.
  • Rate limiting and a per-host token-bucket governor (both implemented). Four controls bound load: a per-audited-endpoint delay (scan_delay_ms), the audit thread cap (scan_max_threads), the wall-clock budget (scan_max_time_sec), and a per-host token-bucket governor (scan_rps). The governor (fissure_ratelimit) acquires a per-host slot before each send in the engine's execute_once, spacing sends to one host at least 1/rps apart (burst 1, plus a small jitter), so raising the thread count never raises per-host request pressure past the configured requests/sec; the crawl, the audit, and the active checks share one governor (it is borrowed by the run's transport config), and the wait polls the same cancel gate so a stop is not delayed by a pending token.
  • Cancellation. Four cooperating layers keep a stop responsive at every phase, including against a host that is not responding (a hung TCP connect) or lagging (a slow read):
    1. A per-run stop flag (const volatile int*) threaded through the crawl loop, the audit dispatch loop, each audit task, and into scan_audit_endpoint, which checks it between individual checks. Setting the flag makes a worker abandon the rest of an endpoint's check suite at the next check boundary.
    2. An engine-level gate. The same per-run flag is also handed to the request engine through the transport config (FISSURE_CONFIG.cancel_flag), and the engine checks it (engine_should_abort) at the top of every connection attempt and between redirect hops (in fissure_request_execute, the raw-bytes smuggling exchanges, and the H2 downgrade probe). This closes the gap layer 1 left: a single check can fire dozens of engine requests, and layer 1 only polls the flag between checks, so without this gate every one of those queued requests would still open a fresh connection and wait out its connect/read timeout (default 10 s connect, 30 s read) against a dead host - the pile-up that made a scan feel impossible to stop. With the gate, once the flag is set no new connection is opened; each queued request returns at once.
    3. A broadcast cancel over the armed sockets, which breaks the requests already blocked on the wire (layers 1 and 2 only stop new work). Hook's original token is process-global with a single armed socket, which fits the one-at-a-time Repeater but not the audit thread pool, where several engine requests are armed at once and clobber a single global. fissure_cancel keeps a per-thread registry of armed sockets; fissure_cancel_broadcast_trigger() shuts down every one so blocking reads return immediately across the whole pool, and latches so any request armed afterwards is shut down at once until fissure_cancel_broadcast_reset() (called at the start of each threaded scan) clears it. fissure_cancel_broadcast_shutdown_now() is a non-latching variant for an async cancel with no join+reset to follow (see below).
    4. An interruptible TCP connect. A socket is armed (registered for the layer-3 shutdown) only after connect() returns, so a request blocked in connect() to an unresponsive host (a dropped SYN) is invisible to layer 3 and would wait out the whole connect timeout - the dominant delay when a scan is stopped during the crawl (one request at a time, each a fresh connect). The engine registers an n_network connect-abort callback (netw_set_connect_abort_cb): while a connect is in progress n_network wakes every NETW_CONNECT_ABORT_POLL_MS and polls it, and the callback returns engine_should_abort() for the request connecting on this thread (its transport config is stashed in a thread-local set before each connect). A Stop therefore aborts an in-flight connect within one poll interval instead of after the connect timeout, so a crawl against a dead host stops promptly. The GUI's single scan worker sets cancel_flag to its worker-stop flag and, on Stop or quit, triggers the latching broadcast (a join+reset follows in cleanup). The control API's async scan jobs set cancel_flag to the job's stop flag (per-job, so cancelling one job's new work never affects a sibling), and the cancel route (POST /api/scans/{id}/cancel) uses the non-latching shutdown_now: a persistent broadcast latch there would wrongly shut down later, unrelated requests in the same process because an async cancel has no join to reset it. The job teardown (ctl_job_free) does join, so it uses the latching trigger + join + reset for the fastest possible wind-down. Quitting the app while a scan runs signals cancellation the moment the quit confirmation is accepted (fissure_gui_sitemap_request_stop), so the scan unwinds while the app tears down rather than the cleanup join waiting cold. The interruptible connect (layer 4) is the upstream n_network primitive netw_set_connect_abort_cb; DNS resolution (getaddrinfo) is still uninterruptible, but for an unresponsive host that resolves normally the blocking wait is the connect, which is now cut short.
  • Pause/resume. Separate from cancellation, a running scan can be paused and resumed (fissure_scan_set_paused / fissure_scan_is_paused). The pause flag is atomic and set from the GUI thread; the crawl loop, the audit dispatch loop, and each in-flight audit unit hold at their next poll point instead of starting new work (already running fetches finish), so pause freezes progress without losing what was discovered. The cancel flag still takes effect while paused, so a paused scan can be stopped. In the Site map view the Scan button doubles as Stop scan and a Pause button (shown only during a scan) doubles as Resume.
  • Timing. Per-test FISSURE_TIMING (promoted from HOOK_TIMING) feeds both the blind time-delta evaluator and the recon dashboard's throughput view.

11. Bug-bounty / CTF helper features

Beyond the core scanner, these utilities make Fissure useful for hunting and CTFs. Most are thin wrappers over nilorea additions (NILOREA_AUDIT 5C) surfaced in the GUI (03_GUI_DESIGN.md).

  • Recon dashboard. DONE (the Dashboard view, fissure_gui_dashboard). One screen for the current target/session: scan state, distinct hosts, endpoint count by source (crawl vs proxy), the in-/out-of-scope endpoint split, captured exchanges, and findings by severity, with a custom-drawn (content-draw callback) severity bar chart in Hook's overlay style. Reads the live inventory/findings/captures stores under the scan lock and refreshes only when a count changes. It also shows a scan-throughput row: the rate of work (endpoints discovered + endpoints audited) per second while a scan is active, computed between successive samples with fissure_rate_per_sec, and "idle" otherwise.
  • JWT decoder / cracker. DONE. fissure_jwt_decode splits header.payload.signature, base64url-decodes and pretty-prints the JSON (cJSON), and flags alg: none and the HMAC algorithms; fissure_jwt_crack_hs256 recovers an HS256 secret from a wordlist offline (n_hmac_sha256). Surfaced in the Multitool view (Decode JWT / Crack JWT (HS256), the latter reading a chosen wordlist file).
  • Hash identification. DONE. fissure_hash_identify returns likely types by length and charset (MD5/SHA-1/SHA-256/SHA-512 hex, and crypt(3)-prefixed bcrypt/ sha256crypt/sha512crypt/Argon2/...); the n_digest hex transforms let the user recompute and compare. Surfaced in the Multitool view (Identify hash).
  • Encoding / decoding multitool. DONE. fissure_multitool_apply does base64 and base64url, URL (n_url_encode / n_url_decode), hex (n_hex), and zlib (n_zlib) encode/decode plus MD5/SHA-1/SHA-256/SHA-512 hex digests; "Output to input" chains transforms - a CyberChef-lite pane (the Multitool view, default F9).
  • Parameter miner. DONE (fissure_paramminer). Brute-force hidden parameter names from a wordlist against an endpoint, detecting accepted params by response diff vs a control (reflected marker, status change, or body-length change beyond a threshold); the probing fans out across an n_thread_pool. Surfaced as the "Mine params" button in the Intruder view (the payload list is reused as the candidate-name wordlist, the URL template's markers are stripped to form the base URL, and hits land in the results grid with their reason).
  • Response diffing. DONE (fissure_diff). A prefix/suffix-anchored line diff of two captured responses: it trims the common leading/trailing lines (isolating the change behind boolean/IDOR/auth checks) and shows the differing middle as removed/added lines with context. Because the proxy stores the full request/response text, the diff covers status, headers, and body at once. Surfaced in the Proxy view: "Pin for diff" snapshots the selected flow's response as the baseline and "Diff" renders the line diff of another flow against it in the response pane.
  • Low-hanging-fruit quick scan. DONE (fissure_scan_config_quick). A built-in profile for a first pass at a new target: a shallow crawl (FISSURE_SCAN_QUICK_DEPTH / FISSURE_SCAN_QUICK_MAX_PAGES), the passive checks (security headers, cookie flags, secret/CORS/banner exposure), the safe active probes (reflected XSS, open redirect), and the sensitive-file probes. Fast, low-noise, safe-mode only, the intrusive SQLi/LFI injection stays off (run a full active/aggressive scan for those). Exposed as fissure scan --quick and the Target view's "Quick scan" button (which routes through the same active authorization confirmation, since it sends traffic).
  • Out-of-band (OAST) callback listener. DONE (fissure_oast). A loopback HTTP callback server that mints unique per-probe payload URLs (http://addr:port/) and records every request that reaches it, correlated by the token in the path. Pasting a minted URL into an SSRF / XXE / command-injection probe and then seeing an interaction for its token is positive, out-of-band proof the target reached back, the kind of blind vulnerability the direct response cannot reveal. Surfaced as the toolbar "OAST" popup (fissure_gui_oast): Start/Stop, Mint, and a live interaction list; each new interaction becomes a high-severity, certain "Out-of-Band Interaction" finding (deduped per token+path). When the listener is running, an aggressive scan borrows it (fissure_gui_oast_handle -> cfg->oast) so the active checks run an automatic out-of-band canary probe (chk_oast): each injectable point gets a minted OAST URL, and a callback raises a certain Server-Side Request Forgery finding (CWE-918) naming the parameter, confirming blind SSRF/XXE/RCE without a manual paste. Each interaction also captures its query string as a structured beacon detail, which is the reusable, in-scope half of IAST (interactive application security testing): an out-of-band instrumentation agent beacons the canary token with the sink it reached, per the open protocol in 08_IAST_BEACON.md; the provided (reference agents for Node/Python/Ruby/PHP/Java/.NET ship under agents/, the Java one with fully-automatic ASM bytecode instrumentation). Callbacks arrive over three channels: HTTP (loopback, no delegation), DNS (<token>.<domain>, via Nilorea n_dns), and SMTP (<token>@<domain>); DNS and SMTP need a delegated domain and their privileged ports. Authorized targets only.
  • Headless control server + control API. DONE (fissure_server, fissure serve). Alongside the one-shot fissure scan/fissure report commands, fissure serve [--host <addr>] [--port <n>] [--api-key <key>] runs a long-running instance that exposes a small JSON HTTP API so a remote client or automation can drive it over a client/server control interface. fissure_server binds a loopback socket and serves, one request per connection on a worker thread: GET /api/status (open, a health check returning the name/version), GET /api/findings (the accumulated findings as a JSON report), and POST /api/scan with a JSON body {"url","active","aggressive"} (runs a scan, merges it into the server's store, and returns that scan's JSON report). Every endpoint except /api/status requires the configured key in an X-API-Key header; binding to 127.0.0.1 plus a key keeps the surface closed by default (serving without --api-key warns). The data endpoints are caller hooks, so the core server is decoupled from the scan/ findings machinery and unit-tested (test_server). Active scanning through the API still targets only authorized scope.

These helpers read and write the same findings store, so anything found manually (a mined parameter, a cracked JWT) can be promoted into a FISSURE_FINDING and flows into the report (06_REPORTING.md) like any scanner result.

How do I authenticate this target?

Three steps, and the middle one is what makes the first one cheap.

1. Configure the route that most likely fits. Use the reference below. You do not have to be right: getting it wrong costs one round trip, not a scan.

2. Verify it. Test authentication in the Parameters popup, fissure scan --auth-check <url>, POST /api/auth/check, or the auth_check MCP tool. Point it at a page that REQUIRES login. It runs the configured route once, fetches that URL with and without the resulting session, and compares them.

3. Read the verdict and act on it.

Verdict What it means What to do
ok The session demonstrably changes the response Scan
failed A route ran and the session was not established The detail names the cause: a login that did not take, a priming URL that answered 4xx, a page still returning a login form
inconclusive The page answers the same either way Almost always the verification URL, not the session. Pick a page that requires login and re-run
none Nothing is configured A scan would run anonymous. Configure a route first
error The target could not be reached at all Not a verdict about the session: check the URL, scope and TLS

Only step 3's ok should be followed by a scan. This matters more than it sounds: a scan that never authenticated reports the handful of findings an anonymous visitor can see, and that is indistinguishable from a clean target unless you knew to check.

Reference: which route fits which target

Consult this once, when configuring. Stop at the first row that matches; they compose, but you rarely need more than one.

The session lives in Use Where
A cookie you already have Paste it The Cookie-jar popup's import box, fissure scan --cookie, cookie on a scan, POST /api/cookiejar {"op":"import"}, the dashboard's Session tab
A browser you can drive yourself Proxy capture "Capture cookies" in the Proxy view, or capture_cookies on /api/proxy/start: browse the target logged in and the session lands in the jar by itself
A cookie, behind a simple login form A login config Settings login config, --login, or login on a scan
A cookie, behind a form or API a script CAN drive A session action Twelve ship: an HTML form, a JSON API, the OAuth2 password / client-credentials / refresh grants, HTTP Basic, a bearer token you hold, a two-step form, a form plus an OTP code, an SPA CSRF-cookie login, a GraphQL mutation, WordPress. Session popup, /api/session-action, session_action
A login a script CANNOT drive The browser login A page-computed nonce, a captcha or hardware key, an SSO hand-off across origins: "Browser login" in the Session popup, /api/browserlogin, browserlogin
An OAuth2 authorization code (consent screen) The PKCE flow /api/oauth-pkce and the oauth_pkce tool: mints the verifier, drives consent in a browser, exchanges the code
A request parameter (a token, an API key) The parameter jar Parameters popup, --param, /api/paramjar
A parameter, behind a login FORM The jar plus crawl priming Parameters popup, --crawl-post-url
An Authorization header you can compute A session rule Session popup, injects a header before matching sends
HTTP Basic or Digest The network-auth fields Settings, or http_auth_user / http_auth_pass

Every cookie route above ends in the same place, the suite-wide shared jar, which the scanner, the Repeater, the CLI and each manual send all read. So the route only decides how the session gets there; once it is there nothing needs to be passed along, and a scan started with no cookie argument at all is authenticated. A token route (the OAuth2 grants, a JSON API, GraphQL) has no cookie to install and hands back its token instead, to send as an Authorization header or resolve as {{name}} in a session rule.

One warning the DVWA lab taught: cookies coming back do NOT mean the credentials were accepted. Plenty of applications, DVWA among them, hand an anonymous visitor a session cookie too, so a FAILED login still returns one. That is why step 2 above is not optional, and why the browser login reports a verified flag of its own.

The Digest answer (fissure_httpauth) reads the challenge as the challenge LIST it is: auth-param names are tokens, so Digest Realm=..., Nonce=..., Qop=... is the same challenge as the lowercase spelling and is answered as Digest rather than falling through to Basic (which would put the password base64-in-the-clear on the wire); a parameter name written inside a quoted value stays part of that value; and each scheme's parameters stop at the next scheme name, so a header offering both never answers Digest with Basic's realm. Of the qop list, auth is preferred wherever it appears and auth-int is used only when auth is not offered. The Authorization value is sized from the fields it carries, so a long query string is answered in full: a header that cannot be built is refused with a logged error rather than sent truncated, because a truncated one carries no response= and authenticates nothing.

Three more are authoring aids rather than routes of their own: the login recorder (fissure_loginrec) watches you log in through the proxy and writes the login config, Tokens forges a signed cookie or JWT you can then paste into the jar, and the copy-as-cURL import (curlimport, "From cURL" in the Repeater) turns a request copied out of a browser's network tab into method, URL, headers and body, which is the fastest way to reproduce one authenticated request exactly rather than reconstructing it.

Every one of these entry points works exactly as it always has. They are listed here as a reference rather than a menu you must choose from correctly up front, because the check above turned picking the right one from a diagnosis into an experiment.

What happens when two are configured

They are additive, and the order is fixed: an HTTP-auth header goes on every request; a login config is replayed first and populates the cookie jar; the parameter jar's priming POSTs run next; then the crawl starts, with session rules injecting headers and the jar filling in parameters on every send. Configuring both a login config and crawl priming is legal and sometimes right (a login that sets a cookie AND a form that mints a token), but it does mean two logins per run; the Parameters popup says so on screen when both are set.

A jar row SHADOWS a login variable of the same name. That is deliberate and explicit: predictable beats correct-in-the-common-case when the alternative is debugging which of two values won by reading traffic.

When a scan was already run

The check is the fast path, but a finished scan still tells you things:

  • Findings only from headers, cookies and banners, and no endpoint deeper than the landing page: the crawl never authenticated. Nothing there is a target problem.
  • Authenticated at first, then not: the session expired mid-run. A login config with an on-status session rule re-authenticates and retries, and so does crawl priming (a 401 re-runs the priming POSTs).
  • paramjar() shows a tracked row whose live value is still empty: the value is not where the jar looks (a hidden form field, a JSON member, a redirect Location). If it is minted by one specific page, give that row a refresh URL.

Carrying parameters through a crawl

A crawl is GET-only and sends nothing of its own, so a target whose session lives in a request PARAMETER rather than a cookie cannot be crawled authenticated without help. The request-parameter jar (fissure_paramjar, edited in the Target view's Parameters popup) supplies that: rows of name/value with per-row behaviour, installed on the scan transport as cfg.paramjar and applied by the engine on every send.

Two seams, mirroring the cookie jar's. On request build the jar FILLS IN what the request does not already set, so an active check fuzzing id always beats a jar row named id and the two can never fight; injection happens at the transport seam, below the crawler's URL bookkeeping, because the canonical URL the inventory dedups on must not carry a rotating token or every page would look new. On response the jar absorbs a superseded value from a hidden form field, a JSON member, or a redirect Location query. HTTP/1.1 and HTTP/2 share one request builder so one seam covers both; HTTP/3 has its own client and so its own call into the same helpers.

The per-row toggles are On, Query, Body, Track, No fuzz and Required, plus an optional refresh URL for a token bound to one form rather than to the session. Two of them exist for reasons that are not obvious:

  • No fuzz keeps the audit from using a session parameter as an insertion point. Without it the checks mutate the token, every request after the mutation is unauthenticated, and the run both loses coverage and manufactures findings.
  • Track plus Required marks a single-use token. Thread-safety is not enough there: the audit fans out across a thread pool, so one worker consumes the token and the others are left holding a stale one. The jar serializes exactly those sends while such a row exists, which visibly slows a scan and is therefore stated on screen rather than applied silently.

A priming-authenticated crawl keeps its session. When a response comes back 401, or a session rule marks its status, or a configured logout marker appears, the scan re-runs the priming POSTs and the engine retries the request once. Without that the session simply dies part-way and every request after it is anonymous, so the run finishes reporting the handful of findings an anonymous visitor can see, which reads like a clean target rather than a failed scan; the login-config route has always recovered this way, and this makes the two equivalent. A bare 401 is the trigger because priming brings no session-rule store of its own; 403 deliberately is NOT, since it means authenticated-but-forbidden and re-authenticating on it would replay the login against every legitimately forbidden resource. Re-primes are serialized (overlapping audit workers do not all re-login at once), counted (fissure_scan_reprimes), and capped at FISSURE_SCAN_MAX_REPRIMES per run so a target that 401s for genuinely anonymous resources cannot turn the crawl into a login flood. A login config takes precedence when both are configured: it is the richer route, with its own extractors and marker.

Crawl priming (fissure_scan_start -> scan_prime_session) optionally POSTs a declared list of URLs once before the crawl proper, in order, so a session behind a login form is established before any page is fetched. The pass only supplies the URL and that URL's own optional raw body; the credential fields come from the jar's Body rows, merged by the engine like any other send. It is off by default because a POST WRITES to the target, and enabling it raises a warning naming that. fissure_scan_prime_counts reports the outcome: a priming failure means the whole crawl ran unauthenticated, which the operator has to be able to see rather than read as a merely unproductive scan.

Submitting discovered forms is the second, separate crawl-write option (fissure_crawler_set_submit_forms, wired from fissure_scan only when the jar asks for it AND the run is aggressive, so a safe-mode scan writes nothing whatever the jar says). It reaches pages that exist only after a submission. Four guards stand in front of it: a logout form is refused for the same reason the crawl already refuses to follow a logout link; a file-upload (multipart) form is refused, since submitting one means uploading something; a form whose action or any control matches a destructive word list (delete, remove, destroy, drop, purge, reset, revoke, cancel, deactivate, unsubscribe, wipe, truncate, erase) is refused; and each action is submitted at most once however many pages render it. The body comes from the form's own field defaults, with the jar's Body rows merged in by the engine, which is how a discovered login form gets credentials the crawler never holds. Refusals are counted separately from submissions (fissure_scan_form_counts) so an operator can see the crawl held back rather than assume everything found was sent. The word list is deliberately broad: a false positive costs one unsubmitted form, a false negative costs the operator their target's data.

Scope and secrecy are enforced, not offered: a jar value is never sent to an out-of-scope host (a token in a query string would otherwise leak to any third party the crawl wandered onto), and the findings store scrubs jar values out of evidence as a finding is created, so a report cannot publish one. The traffic log deliberately keeps the real wire bytes, because showing what actually went out is its purpose and it is local.

Everything is saved per project in <project>/paramjar.json, so switching engagement never inherits the previous target's session values or credentials.