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.
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 (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/scansendpoints, 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:
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
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.
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
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
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
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)
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)
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)
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
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
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
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)
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)
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
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.
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).
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.
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:
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).
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 headerif (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):
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.
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.
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).
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.