Volume VI - Professional Bug Hunting
Professional bug hunting is not random clicking with tools. It is an evidence-driven process for reducing uncertainty about a target until a security boundary breaks or the test area is reasonably exhausted. The workflow is not tool-centric; it is evidence-centric. Every test should either reduce uncertainty or produce reproducible proof.
Chapter 1 - Methodology
1.1 The core loop
Define scope, map the application, form a hypothesis, test minimally, record evidence, escalate or discard, and report or continue. Assume the UI is incomplete and the API is the source of truth. Treat every role, object, method, and state transition as a boundary. Prefer small controlled tests before large fuzzing, record evidence while testing rather than after memory fades, and stop destructive paths early.
1.2 Fissure as an operating system
| Phase | Fissure role |
|---|---|
| Recon | Proxy history, Target site map, Discover, HaE, live scripts. |
| Understanding | Repeater, Comparer, Multitool, Sequencer, notes. |
| Hypothesis testing | Repeater, Intruder, scripted checks. |
| Automation | BChecks, Auto-replay, session rules, passive scripts. |
| Evidence | Findings store, Organizer, capture-backed exchanges, exports. |
| Reporting | Report view, multi-format export, triage. |
1.3 High-signal targets
Role changes and tenant boundaries; object IDs and predictable references; state-changing endpoints; import/export features; file upload and retrieval; billing, invitations, password reset, email change, SSO, and OAuth; and admin-only API routes visible in JavaScript or source maps.
Chapter 2 - Reconnaissance and Scope
Reconnaissance builds an accurate map of what exists and what matters. Inside Fissure, recon means turning traffic into structure: hosts, routes, parameters, roles, objects, technologies, and trust relationships.
2.1 Scope discipline
Translate the authorization language into technical rules first. In
the Target view, set In-scope and Out-of-scope hosts (an exact host, a
.suffix, re:<regex>, or *;
deny wins). Use Import scope to load a program's HackerOne, Bugcrowd, or
mainstream-tool scope JSON, or a plain host list. Scope is both a legal
boundary and an operational filter: with it set, the proxy blind-tunnels
out-of-scope hosts and an out-of-scope seed is refused. A host can be in
scope while a feature (payment, a destructive workflow, a production
admin panel) is out of scope; record those exclusions in your notes.
2.2 Building the map
Browse as an anonymous user and as each role with the proxy on. Populate the Target grid three ways (Scan crawls the seed, Seed from Proxy folds in browsed history, Import API loads an OpenAPI, Swagger, or Postman definition). Run Discover to brute-force common paths under the base. Cycle the View button (Grid, Tree, Graph) to read the host/path structure as a tree. Client-side code often reveals routes, feature flags, and admin paths; use HaE rules to surface source-map and endpoint hints as you browse.
2.3 Parameter inventory
Group discovered parameters by testing angle: identity
(user_id, accountId, org,
tenant) for IDOR and tenant escape; state
(status, role, enabled) for mass
assignment and workflow bypass; redirect (next,
returnUrl, redirect_uri) for open redirect and
OAuth impact; file (path, name,
key) for traversal; and query (search,
filter, sort) for injection. Pick the
highest-value parameters for the playbooks below.
2.4 JavaScript mining and source-map unpacking
Most of a modern application's real attack surface never appears as
an href. It lives in client-side JavaScript:
fetch/axios/XHR targets,
templated API roots, and router paths that only a running SPA assembles.
Fissure mines them so they become audit targets like any crawled link.
During a crawl it mines inline <script> bodies and
fetched external .js bundles for URL and route tokens,
resolves them against the page base, and records them in the inventory.
On demand, the "Mine JS" request context action (Recon & tools
group) fetches one specific bundle on a worker thread, seeds the mined
endpoints into the site map, and scans the body for secrets, reporting
the counts in a popup; the headless equivalent is
POST /api/jsmine / the MCP jsmine tool (pass
the JavaScript body and a base_url), which returns
{count, endpoints, secrets, sourcemap?}.
A minified bundle hides most of its endpoints, but a linked source
map recovers the original unminified sources where those strings are
readable. The miner decodes an inline (data-URI)
//# sourceMappingURL= map and mines its original sources,
and it follows an external .map reference: the crawl and
the "Mine JS" action fetch and mine the .map automatically,
and jsmine returns an external map URL as
sourcemap for you to fetch and mine in a second call
(send_request the map URL, then jsmine the map
JSON). Worked example:
jsmine(app_bundle_js, base_url="https://target/") returns a
handful of endpoints and a sourcemap; you
send_request that .map, jsmine
its JSON, and recover a dozen more API routes the minified bundle
concealed. Seed them into scope, then scan the widened inventory. The
payoff is the pre-minification endpoint surface a static crawl
misses.
2.5 Visual triage and attack-surface analysis
A large recon sweep leaves you with more hosts than you can browse.
Two tools size the surface fast. Recon screenshots drive a headless
browser (the bundled Fissure Browser or a system Chromium/Chrome) over
CDP to capture a PNG of a discovered host or endpoint, saved under
<config>/screenshots/, so you eyeball the surface and
spot login pages, admin panels, default installs, and parked hosts at a
glance. It is a passive capture: it loads the page, it does not attack
it. In the GUI, open Probes (Recon & infra category), enter the
Target URL, and press Screenshot; List captures shows the gallery and
Open shows the most recent capture in your image viewer. Headless, it is
exposed as POST /api/screenshot (one URL) and
GET /api/screenshots (the gallery index), and the MCP tools
screenshot / screenshots; a capture returns
501 when no browser is available.
The attack-surface analyzer is a rollup over the discovered endpoint
inventory, shown in the "Attack surface" popup (Analysis &
inspection toolbar category and the command palette). It tallies total
endpoints and distinct hosts, total query parameters, the
query-versus-body split, the static-versus-dynamic split, the
auth-required split (from each endpoint's captured Authorization/Cookie
headers), and the discovery-source, HTTP-method, and response-status
breakdowns, plus the findings count, so you can prioritize a target
instead of wandering it. A Refresh button recomputes; the headless form
is GET /api/surface / the MCP surface tool.
Read the dynamic count and the auth-required split first: dynamic
endpoints take input (the injection surface), and the authenticated
endpoints are where the access-control bugs concentrate.
Chapter 3 - Vulnerability Playbooks
A playbook is a repeatable procedure for one vulnerability class, connecting Fissure tools to a common web-vulnerability family. Playbooks are not payload lists; they are controlled procedures that connect observations to proof.
3.1 XSS
Find reflected or stored inputs in the Proxy history (HaE and the DOM-XSS passive heuristic surface candidates). Send one request to the Repeater. Test harmless context markers first, identify the context (HTML, attribute, JavaScript, JSON, URL), then use context-appropriate payloads. The Intruder with a Grep Hit on the marker sweeps many inputs. Confirm execution safely, and document source, sink, payload, and impact.
3.2 SQL injection
Identify parameters reaching data operations. Baseline in the Repeater, then test syntax changes and boolean conditions. Enable Aggressive active checks to run error-based, boolean-based, and time-based SQLi automatically across the insertion points; treat scanner hits as leads. Compare status, length, timing, and error messages in the Comparer, avoid data extraction beyond authorization, and report the query context and business impact.
3.3 SSRF
Find URL, webhook, import, fetch, avatar, PDF, or callback features. Start the OAST listener, mint a canary, and inject it (Chapter 4). Test scheme, host, redirect, DNS, and IP-representation changes. Look for blind callbacks and response-based differences. Never scan internal networks without explicit approval. Report the reachable impact: metadata, internal services, or callback proof.
3.4 File upload
Map the upload and retrieval endpoints. Test extension, MIME type, magic bytes, filename, path, and content handling. Check whether uploaded files execute, render, or download, test access controls on retrieval, and verify storage and overwrite behavior.
3.5 SSTI
Identify reflected server-rendered input. Start with harmless arithmetic or marker payloads and compare the response transformation in the Comparer. Fingerprint the template engine cautiously, avoid command execution except in approved labs, and report the injection context and the maximum safe demonstrated impact.
3.6 DOM-based and client-side testing (DOM Invader)
Server-side scanning cannot see bugs that live in the browser.
Fissure drives a headless Chromium and instruments the page before any
script runs, then reports which dangerous DOM sinks a marked value
reached at runtime. Open the DOM Invader popup (or, headless, the
domprobe / dominvader MCP tools), point it at
a URL, and it confirms DOM-based XSS (a location, URL, or
postMessage value flowing unsanitized into
innerHTML/eval/document.write and
friends), client-side prototype pollution (a __proto__ key
from the URL polluting Object.prototype), cross-origin
message listeners, and DOM-clobbering gadgets.
Runtime-verified evidence beats the static body heuristic: you get the
exact source, the exact sink, and the marked value that bridged them.
Run it aggressive to mark the query, hash, and a prototype-pollution
payload; pass a session cookie to test an authenticated page; and use
overlay (GUI) to see the sinks light up as you browse.
Report the source-to-sink flow and the demonstrated impact.
3.7 HTTP-version differential (h1 vs h2 vs h3)
A front-end proxy, a CDN, and an origin do not always agree on how to
parse a request across protocol versions, and a disagreement is a
routing, cache, or access-control bug. Fissure speaks HTTP/1.1, HTTP/2,
and HTTP/3 (QUIC). Take a request and send the SAME bytes over all three
with the "Diff h1/h2/h3" button in the HTTP/3 fetch tool (or the
http3_diff MCP tool); Fissure reports where the status,
length, or key headers diverge (CWE-436, request-interpretation
mismatch). A response that changes with the protocol version is a lead:
an endpoint reachable only over one version, a cache that keys on the
wrong thing, or an auth check applied on one leg but not another. No
mainstream web-security tool fully ships HTTP/3, so this is a genuinely
differentiating check. Fissure can also terminate inbound HTTP/3 as a
MITM listener (the "HTTP/3 proxy", h3proxy) to capture and
intercept h3 traffic the classic proxy cannot.
3.8 The one-click test menu (request context actions)
Every playbook below stops at an evidence-grade confirmation you drive by hand, but Fissure also offers a targeted one-shot of each check straight from a request. Right-click any request (a Proxy flow, a Findings row, a Target endpoint, or any node in the site-map graph) and the context menu groups the checks into dropdowns: Injection & data (Test SSRF, Test XXE, Stored XSS, Mass assignment / HPP, Prototype pollution, Test NoSQL injection, Reflected file download, Business-logic probe), Access control (Check access control, Test for IDOR, Test auth bypass, Test 401/403 bypass, Test CSRF (deep), Auth matrix), Server & infra (Request smuggling, Test cache poisoning, Subdomain takeover, Race probe), and Recon & tools (Mine JS, Host probes, Test file upload, Confirm CSPT, Shadow Repeater, WAF-bypass retry, Send over HTTP/3, and more).
Each entry runs that one check on a worker thread against the selected request, with a busy status and a result popup, so it never freezes the UI. It is the targeted counterpart to letting the aggressive scan reach an endpoint: use it when you already have a specific request in hand and want a single class probed now. The menu respects the same rules as the scanner: intrusive checks need aggressive mode enabled, the target host must be in scope, and body-fuzzers (NoSQL, prototype pollution, stored XSS, mass assignment, deep CSRF) are only offered when the request carries a body. Because Fissure keeps the GUI, the loopback control API, the MCP bridge, and the bug-bounty skill in parity, every action here is also a control-API route and an MCP tool, so an agent driving Fissure headless probes exactly what the GUI operator does. The playbooks below name the context action, the MCP tool, the control-API route, and the scan family for each class.
3.9 HTTP request smuggling and desync
A front-end (CDN, load balancer, reverse proxy) and a back-end do not always agree on where one request ends and the next begins. When they disagree, a smuggled request prefix left on a keep-alive connection is prepended to the next visitor's request: web-cache poisoning, request hijacking, credential capture, or an auth bypass. The classic HTTP/1.1 forms are TE.CL and CL.TE (the two ends disagree on whether Content-Length or Transfer-Encoding wins) and CL.CL (duplicate or conflicting Content-Length). The HTTP/2 downgrade forms arise when a front-end speaks HTTP/2 to you but HTTP/1.1 to the origin: H2.TE (an HTTP/2 request carrying a Transfer-Encoding header, forbidden in HTTP/2, that hangs a downgrading front-end), H2.CRLF (the same Transfer-Encoding hidden inside a benign header's value behind a CRLF, which HPACK carries verbatim, catching a stricter front-end that strips illegal HTTP/2 headers but not CRLF on downgrade), and H2.SPLIT (a whole second request line CRLF-injected into a header value, so a front-end that writes the value verbatim on downgrade splices a full smuggled request into the HTTP/1.1 stream, the request-splitting primitive behind response-queue poisoning and a strict superset of H2.CRLF). Two more preconditions matter: h2c (an origin that accepts a cleartext HTTP/2 Upgrade over HTTP/1.1 with 101 Switching Protocols, the precondition for tunnelling HTTP/2 past an HTTP/1.1 front-end) and the HTTP/3 downgrade smuggle (h3.TE).
Fissure probes all of this. The "Request smuggling" context action,
POST /api/smuggle / the MCP smuggle tool, and
one per-host pass inside an aggressive scan send length-ambiguous
requests over a raw-bytes transport and time them: a variant that hangs
the server while a normal, unambiguous request returns promptly is the
timing signal. The verdict is none,
tecl, clte, clcl,
h2te, h2crlf, h2split, or
h2c (the three HTTP/2 variants are probed on TLS targets).
Crucially, on a timing hit Fissure runs the differential-response
confirmation automatically: on one keep-alive connection it sends a
smuggling request that leaves a GET /<marker> prefix,
then a normal request, and checks whether the follow-up's response was
poisoned; a confirmed desync sets confirmed: true (a firm
finding), while an unconfirmed timing hit stays a tentative candidate.
For a target that advertises HTTP/3 (an alt-svc: h3
header), also run http3_smuggle(url) /
POST /api/http3-smuggle: it sends a clean HTTP/3 request
and the same request carrying a transfer-encoding header
that RFC 9114 forbids, and reports safe (the endpoint
rejected the illegal framing, compliant), candidate (it
answered the illegal-framing request, so it or a downgrading front-end
does not validate framing, a MEDIUM finding), or
unreachable. In the GUI, the HTTP/3 fetch popup (Capture
category) runs the same probe from its Smuggle probe button on the URL
field. Worked example: smuggle("https://target") returns
{"verdict":"clte","confirmed":true}; capture the poisoning
request and the poisoned follow-up as the two-response evidence, then
report the concrete impact you can demonstrate (cache poisoning, request
hijack, auth bypass), never the timing alone. These probes deliberately
induce server-side timeouts, so they are intrusive and scope-checked:
authorized targets only, and never a shared production front-end without
explicit approval.
3.10 NoSQL injection
Where the store is a document database (a Mongo or Couch-class
backend), a JSON login or query API that builds its filter from the
request body can be steered with query operators instead of literal
values. The "Test NoSQL injection" context action (offered when the
request has a JSON body), POST /api/nosqli / the MCP
nosqli tool, and the nosqli scan family (run
automatically on JSON body endpoints in an aggressive scan) replace each
scalar field with a match-all operator
{"$ne":<nonce>} and a match-none operator
{"$eq":<nonce>}, plus an error-based
{"$regex":"("} probe. A server that evaluates the operator
answers the two differently (the match-all authenticates or returns rows
while match-none is denied), confirming an operator-injectable field
(CWE-943, firm HIGH); a literal-only server produces no differential, so
echo endpoints do not false-positive. The error probe surfaces a
document-store driver signature (MongoError, CastError, BSONError,
E11000). Worked example:
nosqli(url, body='{"user":"admin","pass":"x"}') flags the
pass field; confirm by hand with the classic
{"user":"admin","pass":{"$ne":1}} for the auth bypass, or a
$regex charset walk to extract a value. Report the
authentication bypass or data extraction the operator injection enables,
not the differential alone.
3.11 Authentication-header trust bypass
Reverse-proxy header authentication (Gitea, oauth2-proxy, mod_auth,
nginx auth_request) authenticates the user at the proxy and forwards the
identity in a header the backend trusts. When the backend is reachable
directly, or the trusted-proxy list is a wildcard, an unauthenticated
attacker can forge that header and be treated as the named user. The
sibling failure is an IP allowlist that trusts a client-supplied
X-Forwarded-For or X-Real-IP to grant local or
admin access. The "Test auth bypass" context action,
POST /api/authbypass / the MCP authbypass
tool, and the authbypass scan family work only on an
endpoint that first denies an anonymous request (a 401/403 or a login
redirect, so there is a control to bypass). They re-confirm the deny,
send an untrusted control header to rule out an endpoint that reacts to
any header, then forge each trusted header in turn (X-WEBAUTH-USER,
X-Remote-User, X-Forwarded-User, X-Auth-Request-User, X-SSL-Client-CN
set to admin; X-Forwarded-For / X-Real-IP / X-Client-IP set
to 127.0.0.1; plus a malformed traversal Authorization token) and flag
any that flip the deny to an authorized 2xx (CWE-290, critical for an
identity impersonation, high for a trusted-address or malformed-token
bypass). Confirm impact by re-sending with the winning header and
showing the response is the privileged resource, not an error page that
merely returns 200; note the exact header and value; and recommend
stripping the header at the trust boundary plus pinning the
trusted-proxy list to the proxy's real address.
3.12 Access-control (401/403) bypass
This is distinct from the auth-header bypass above: it forges WHICH
url the back-end authorizes, not WHO you are. The "Test 401/403 bypass"
context action, POST /api/aclbypass / the MCP
aclbypass tool, and the aclbypass scan family
work on an endpoint that denies an anonymous request (again with an
untrusted control header first, so a header-reactive endpoint is
skipped). They try two arms: URL-override headers (X-Original-URL,
X-Rewrite-URL, X-Override-URL, X-Original-URI) sent to the origin root
naming the denied path, where a served 2xx whose body differs from a
plain root fetch means the front-end re-routed to the protected resource
(CWE-284); and path-normalization variants of the denied path (a
trailing slash, //, /., %2f, a
trailing %20/%09, a ..;/
path-parameter segment), where a served 2xx on a variant the server
normalizes to the same resource is a normalization bypass (CWE-288).
Each deny-to-2xx flip is a firm finding. This is offensive
access-control testing, reaching the protected resource, not
detection-evasion. Confirm the returned content is the protected
resource before reporting.
3.13 Reflected File Download
An endpoint that reflects a caller-controlled value into a
downloadable, non-HTML response with no Content-Disposition filename,
and accepts an arbitrary trailing ;/name.bat path segment,
lets an attacker craft a link on the trusted origin that downloads an
attacker-named batch or command file whose content begins with the
reflected value. A victim who runs "a file from a trusted site" executes
the commands (CWE-79, OWASP RFD). The "Reflected file download" context
action, POST /api/rfd / the MCP rfd tool, and
the rfd scan family confirm the three conditions: a
command-shaped marker reflected unescaped, the served
;/name.bat path (a 2xx), and the missing disposition
header. It is classic on JSONP endpoints and APIs that echo a
callback or q value (for example an
/api;/setup.bat?callback=||calc|| link). The lead is
tentative MEDIUM; confirm the download name and content behave as an
executable download in the target browser before reporting, and
recommend a Content-Disposition filename plus encoding the reflected
value.
3.14 Web cache poisoning and deception
Where a shared cache or CDN sits in front of the app, an unkeyed
input that changes a cached response reaches every visitor. The "Test
cache poisoning" context action, POST /api/cache / the MCP
cache tool, and the aggressive scan (every GET endpoint)
run two probes. Poisoning: for each unkeyed request header
(X-Forwarded-Host, X-Host, X-Forwarded-Server, X-HTTP-Host-Override,
Forwarded) it injects a random host marker on a cache-busted copy of the
URL, then re-fetches the same URL WITHOUT the header; if the unheadered
response still carries the marker, the header's effect was cached and is
served to everyone (a definitive signal, since the marker is random). It
only ever writes a cache-busted probe entry, never the real cache key,
so it does not poison production. Deception: a static-suffix path
(/x.css) that returns the same page with a cacheable
Cache-Control, so a CDN may cache a sensitive page under a static URL. A
poisoning hit is high impact but you must confirm reach: turn the
reflected host into a concrete exploit (a poisoned script or import for
stored XSS, a redirect, or a cache-key-scoped denial of service) and
confirm which query params and headers are keyed so you know who
receives the poisoned response. For deception, confirm the page carries
authenticated or sensitive data and that a real CDN caches the suffixed
URL.
3.15 Subdomain takeover
After recon widens the inventory with subdomains, hunt for dangling
DNS: a CNAME still pointing at a de-provisioned cloud or SaaS resource
an attacker can reclaim. The "Subdomain takeover" context action,
POST /api/takeover / the MCP takeover tool,
and one automatic pass over every in-scope inventory host in an
aggressive scan fetch the host (https then http) and match the body
against distinctive provider "unclaimed resource" fingerprints (GitHub
Pages, S3, Heroku, Fastly, Shopify, Ghost, Pantheon, Tumblr, Surge). On
a match Fissure resolves the host's CNAME chain, following intermediate
hops, and checks it against the provider's DNS suffix: a match raises a
CERTAIN finding with the CNAME chain in the evidence (the dangling
record is confirmed), while a mismatch or an unresolved CNAME stays FIRM
and asks you to verify. So a certain finding here is already
CNAME-confirmed, and you only need to check the resource is actually
claimable (some providers now block re-registration). Impact is high:
full control of the subdomain enables phishing, cookie theft on the
parent domain, and OAuth/CSP bypass, so report it accordingly.
3.16 Server-side prototype pollution
A JSON API on a JavaScript/Node back-end that deep-merges untrusted
input into objects can have attacker keys land on
Object.prototype, from where every object inherits them: a
lever for logic bypasses, denial of service, or (with a gadget) RCE. The
"Prototype pollution" context action (POST/PUT/PATCH bodies),
POST /api/protopollution / the MCP
protopollution tool (method GET or POST), and
the aggressive scan (the JSON vector on JSON endpoints, the query vector
on surface-bearing GET endpoints) send a __proto__ gadget
({"__proto__":{"<uniq>":"<uniq>"}}) then the
constructor.prototype variant, injecting a unique property,
and then a second, payload-free {} request. Because that
probe body carried no such key, its only source is an object that
inherited it from the polluted prototype: a conservative but high-signal
confirmation (CWE-1321). For a GET endpoint the query vector uses the
bracket gadgets ?__proto__[<uniq>]=<uniq> and
?constructor[prototype][<uniq>]=<uniq> that a
qs-style parser (Express) expands into a polluting object. Because the
pollution mutates a server global that can affect other users and
requests, treat it as intrusive: only run it in scope, and note that a
restart clears Object.prototype. To escalate, pair the
confirmed reflection with a known gadget for the target stack (Express
"json spaces" or status overrides, EJS/Pug template options leading to
RCE) and report the gadget's concrete impact, not the reflection
alone.
3.17 Stored and second-order XSS
Reflected-XSS probing never catches a payload that is saved on one
request and rendered on a different page (a comment, a profile field, a
guestbook), because the value surfaces elsewhere. The "Stored XSS"
context action (offered on a request with a write body),
POST /api/storedxss / the MCP storedxss tool,
and the aggressive scan (form and JSON writes) write a unique executable
canary (a nonce wrapped in an executable <svg onload>
payload) through one write field or JSON leaf at a time, send it, then
issue a SEPARATE GET of the read page and flag stored XSS only when the
canary comes back UNENCODED there. Finding it in a response that did not
carry it is proof of persistent storage plus missing output-encoding
(CWE-79); an HTML-encoded canary is not flagged. Pass the write
request's body; read_url defaults to the write
URL with the query stripped (the common comment/guestbook/profile case),
so override it when the value is displayed on a different page than you
post to. Because it persists a payload on the target, run it only in
scope. Report the source (the write field), the sink (the display page),
the payload, and the impact.
3.18 Race conditions
Some bugs appear only when several requests hit the backend inside
its check-then-act window: double spend, duplicate coupon or gift-card
redemption, a one-time token or one-per-account resource claimed twice.
The "Race probe" context action, POST /api/race / the MCP
race tool fire count (default 8) identical
copies of the captured state-changing request concurrently using the
single-packet / HTTP-1 last-byte-synchronized primitive (the classic
race primitive that lands the requests inside the server's window), then
send one settle request. They flag a limit overrun (CWE-362) when two or
more of the burst were accepted with the same success response while the
settle was then rejected, so the action is single-use but the limit is
not enforced atomically. The probe self-skips when fewer than two
concurrent successes or when the settle also succeeds (a repeatable,
unlimited action), so it does not false-positive on a merely
non-idempotent endpoint. Capture a fresh, valid request through the
proxy first, then run the probe; for manual coordination the
groupsend modes parallel (HTTP/1 last-byte
sync) and h2_single_packet (the strongest, needs an HTTP/2
target) fire a group together. Confirm by hand that each concurrent
success produced a REAL separate effect (two coupon redemptions
credited, two withdrawals posted, two accounts created): the count alone
is not proof. It is intrusive and scope-checked; prefer a test account,
and report the concrete over-limit effect and its value.
3.19 Mass assignment and parameter pollution
Two "extra parameter" abuses share one tool: the "Mass assignment /
HPP" context action, POST /api/massassign / the MCP
massassign tool, run automatically by the aggressive scan
on body and query endpoints. Mass assignment (autobinding, CWE-915)
applies to create/update endpoints that map a request body straight onto
a model, letting the client set attributes the UI never exposes (role,
is_admin, ownership, balances). The check first sends a control probe
adding a random-named field; if the server echoes it, the endpoint just
reflects input and the check stops, so a blanket-echo API does not
false-positive. Otherwise it adds each privileged field name (role,
is_admin, account_type, is_active) with a nonce and flags the first
whose nonce comes back while the control's did not, meaning the server
SELECTIVELY bound the privileged attribute. That is a lead, not proof:
confirm by setting the field to a real value (role=admin,
is_admin=true) and checking the effect. HTTP parameter
pollution (CWE-235) applies wherever a duplicated query parameter is
parsed inconsistently across the stack: the check sets a reflected
parameter to one nonce, then sends it duplicated with a second nonce,
and flags last-wins or concat handling, because a control validating the
first occurrence can be bypassed by appending a duplicate
(?id=allowed&id=victim). Report the observed semantics
plus the concrete control it bypasses.
3.20 XXE (XML external entity)
Any endpoint that parses XML (an application/xml,
text/xml, SOAP application/soap+xml, or
+xml content type, or a body opening with an XML
declaration) can be steered with external entities. The "Test XXE"
context action, POST /api/xxe / the MCP xxe
tool, and the aggressive scan (once per captured XML endpoint) run three
techniques, all reusing the endpoint's own root element so the payload
matches. In-band file read: the DOCTYPE declares an external entity
reading file:///etc/passwd (and a Windows
file:///c:/windows/win.ini), confirmed when the file
content comes back in the response (CWE-611, certain, the clearest
evidence). Out-of-band (blind) XXE: with the OAST listener running
(oast_start), it declares an external parameter entity
(fetched during DTD parsing, so even a parser that never expands a
general entity still calls out) plus a general entity, both pointing at
a minted canary; a callback proves blind XXE even when the direct
response reveals nothing. Nested parameter entities (external-DTD
exfiltration): the internal subset only loads an attacker external DTD
(%remote) that the OAST listener itself serves with the
nested %eval/%exfil entities, which defeats a
hardened parser that blocks parameter entities in the internal subset
but still fetches and processes an external DTD, and it exfiltrates the
read file's bytes out-of-band (they come back in the canary's query
string, surfaced in the finding evidence). When the plain OOB probe is
blocked but this one fires, you have both a bypass and file disclosure.
XXE often chains to SSRF (the entity URL can target an internal host or
the cloud metadata service) and to denial of service (billion laughs);
escalate accordingly and report the concrete impact you can demonstrate.
When a WAF blocks the XML markup, section 3.23 covers the DTD-rewrite
and UTF-16 bypasses.
3.21 Client-side path traversal (CSPT)
A client-side request whose URL is built, in the same statement, from
a URL-derived source the attacker controls can be retargeted with a
../ to a different API endpoint. The sinks are
fetch, an XHR .open() on an XHR-ish receiver,
axios, and jQuery.ajax/get/post (a bare
.open() on anything else, such as window.open,
is not a sink, and the source may sit before or after the sink in the
statement); the sources are
location.pathname/search/hash/href,
document.URL, a router param (useParams,
router.query), and URLSearchParams.get.
Retargeting a state-changing call is CSPT-to-CSRF; feeding a spoofed
response into a DOM sink is CSPT-to-XSS (CWE-22). Fissure detects it two
ways. Passive: the scan and the live proxy audit flag the source-to-sink
pattern, and POST /api/cspt / the MCP cspt
tool scan a supplied HTML/JS body (or fetch a URL, one scope-checked
passive GET) for the same lead. Runtime confirmation: the "Confirm CSPT"
context action, POST /api/cspt-confirm / the MCP
cspt_confirm tool drive a headless Chromium, inject a
unique ../ marker into a client-side URL source
(source is "hash", the default, or "path", or a
query-parameter name), watch Network.requestWillBeSent, and
confirm when the page's own fetch/XHR is retargeted to a different
endpoint by that source-controlled value, upgrading the static MEDIUM
lead to a HIGH/FIRM finding. On a hit it returns nav_url
(the crafted URL that reproduces it), request_url (the
retargeted request), and poc (an HTML page that navigates a
victim there). Worked example: cspt(url=spa_page) flags a
fetch built from location.hash;
cspt_confirm(url, source="hash") returns
nav_url and a poc, runtime proof you attach to
the report. It needs a Chromium/Chrome (503 if none).
3.22 Shadow Repeater (AI-assisted parameter variation)
When you are working one interesting request but do not yet know
which parameter is worth a full Intruder run, Shadow Repeater sweeps the
neighbourhood for you. The "Shadow Repeater" context action,
POST /api/shadow / the MCP shadow_repeater
tool take the request you are on, auto-detect its insertion points
(query parameters and a form-encoded body), and generate variations of
each value: a fixed injection battery, bit-flip and case-modified
variants of the current value via the Intruder generators, and, with
use_ai and a configured AI provider, model-proposed values.
It replays them in the background and flags the responses whose status,
length, timing, or reflection differ from the baseline as tentative
candidate findings (merged into the shared store). Use
focus="param" to fuzz only the value you just changed.
Sending variations is active traffic, so it needs aggressive mode
(active=true) or nothing is sent and the note
field explains the gate; the run is scope-gated and
max_variations caps it (default 24). It is the quickest way
to find which parameter deserves a deeper Intruder pass; treat every hit
as a lead to confirm by hand, not a finding.
3.23 Testing through a WAF (scan-time input-filter bypass)
A WAF is a mitigation, not a fix, and a program generally requires
the underlying bug be shown exploitable, so when a real, in-scope
vulnerability's canonical payload is blocked, Fissure can encode the
scan's payloads past the input filter. This is a control-bypass
capability: it is gated behind scope, the aggressive toggle, and an
enforced, non-blocking code-of-conduct notice, and it adds nothing to
conceal, delay, or misattribute your activity to evade the target
owner's own logging or monitoring. In the Target-view Scan options
popup, on its WAF bypass tab, the "WAF-bypass encoders" field (CLI
--waf-bypass <chain>, the waf_encoders
field on the scan job) takes a comma-separated encoder chain
(case, the whitespace and comment family
space2comment / space2plus /
space2tab / space2hash /
space2dash / space2randomblank /
multiplespaces / randomcomment /
commentbeforeparentheses, the per-engine quirks
percentage / apostrophemask /
overlongutf8, url, urlall,
url2x, charunicodeurlencode,
versionedkeywords, nonrecursivereplacement,
symboliclogical, equaltolike,
jsonpad): every active-check payload is encoded through the
chain so a blocking filter does not match the raw attack, while staying
server-transparent so the app still decodes it. A finding found that way
names the transform that carried it and re-sends the canonical payload
once, so the report can say whether the filter was involved at all
rather than claiming a bypass that never happened. Pick a chain that
survives the target's decoding, the same discipline as sqlmap tamper
scripts:
case/space2*/versionedkeywords/symboliclogical/equaltolike
suit SQL keyword/operator filters, nonrecursivereplacement
suits a WAF that strips keywords, and
url*/charunicodeurlencode suit headers,
cookies, and raw bodies.
Three separate opt-ins cover the checks that build their own
structured bodies, where a generic encoder would corrupt the payload.
--waf-body (the waf_body scan field)
unicode-escapes (\uXXXX) the JSON bodies of the direct-body
checks (the NoSQL operators $ne/$where, the
prototype-pollution __proto__ keys, JSON-embedded
metacharacters), transparent to the JSON parser but invisible to a
signature WAF. --waf-xml (waf_xml) rewrites
the XXE check's DTD so a WAF signature on the external-entity markup
misses (the SYSTEM keyword becomes a PUBLIC
external id, and the space after each DTD keyword becomes a tab) while
an XML parser resolves the entity identically.
--waf-xml-utf16 (waf_xml_utf16) additionally
re-encodes the XXE body as UTF-16 with a BOM, so an ASCII-signature WAF
misses the markup entirely while an XML parser detects UTF-16 from the
BOM: layer it on --waf-xml when the DTD rewrite alone is
still blocked (this is UTF-16 XXE). Because these bypass a protective
control, enabling any of them records the enforced code-of-conduct
notice: the GUI shows the shared confirm-info popup and writes an
event-log entry before the scan starts, and the headless routes return
and log the same notice. There is also a one-click "WAF-bypass retry"
request context action (POST /api/wafbypass/resend / the
MCP wafbypass_resend tool) that resends a blocked request
as-is, then again with the encoder chain applied, and shows the
original-versus-bypassed status and length so you can see whether the
block lifted. First fingerprint the WAF (wafdetect),
confirm the endpoint is in scope, then encode.
Chapter 4 - Out-of-Band and IAST Testing
Some vulnerabilities are blind: the direct response cannot show them. Fissure's OAST (out-of-band application security testing) is the equivalent of a hosted out-of-band interaction collector.
4.1 OAST
Open OAST from the toolbar, Start the listener, then Mint a canary
and paste it into an SSRF, XXE, or command-injection probe. When the
target calls back, the request is listed and recorded as a high-severity
Out-of-Band Interaction finding, proof of a blind vulnerability. While
the listener runs, an aggressive scan also injects a canary at every
insertion point automatically and raises a certain SSRF finding on a
callback (no manual paste). Set a delegated Domain to enable the DNS
(<token>.domain) and SMTP
(<token>@domain) channels alongside HTTP; the grid's
Chan column shows which channel each callback arrived on. Inject a fresh
canary inline with the <@oast/> tag (Volume III).
Settings has an opt-in "Inject OAST canary headers into in-scope requests" toggle (OAST canary injection): with the listener running, the proxy seeds forwarded in-scope requests with canary forwarding headers (Referer, X-Forwarded-For, and similar), and any pingback becomes a blind-SSRF finding.
4.2 DNS-rebinding SSRF canaries
An SSRF allowlist that resolves a host, approves the benign first
answer, then re-resolves and connects on a second lookup is vulnerable
to DNS rebinding: a resolve-then-connect TOCTOU where the second answer
points somewhere the allowlist would never have approved. With the OAST
DNS channel up (start the listener with a delegated
domain), the aggressive SSRF pass and
ssrf(url) inject a rebinding canary whose host resolves to
a benign IP first and to 169.254.169.254 on re-resolution,
so an allowlist that approved the benign first answer connects to the
metadata service on the second lookup. Drive it by hand with
oast_rebind(benign_ip, internal_ip, ttl, flip_after):
inject the returned url into the sink, then
oast_poll(token), where
rebind_reresolved: true (rebind_queries at
least 2) proves the target resolved-then-connected. Two knobs tune the
timing to the target's resolver: ttl sets the served record
TTL (the rebind timing profile, default 1 second; set 0 to forbid
caching and force the fastest re-query), and flip_after
keeps answering benign for that many lookups before the flip (default 1;
raise it when the target's resolver pins or pre-fetches the first
answer, so the flip lands on the connect lookup rather than a caching
lookup). The poll result reports rebind_window_ms, the
observed interval from the first lookup to the flip, which is the
per-target rebind window: read it to tune
ttl/flip_after on the next mint. Report it as
an allowlist-bypass SSRF and recommend pinning the resolved IP for the
life of the request.
4.3 IAST beacons
An out-of-band instrumentation agent can beacon the canary token with
the sink it reached, so a finding names which sink (command exec,
filesystem, outbound HTTP, code eval, deserialization, SQL query) the
canary hit, plus the exact code line (stack) and the
tainted source (src). Reference observe-only agents ship
for Node.js, Python, Ruby, PHP, Java, and .NET under
agents/. You opt in by loading the matching agent into an
application you are authorized to test, with
FISSURE_OAST_URL pointing at the listener; Fissure itself
never instruments a target. Read the beacon back from
oast_history() / oast_poll(), and the
correlated OAST finding names the sink and line, turning a blind
injection into certain evidence. See docs/08_IAST_BEACON.md
for the beacon protocol (a plain HTTP GET to the canary URL with the
sink details as query parameters).
4.4 Automatic sink instrumentation (JVM bytecode and .NET)
The Java agent is fully automatic and needs no application change.
Build the agent jar with agents/java/build.sh (it needs a
JDK and the ASM core library) and attach it with
java -javaagent:fissure-iast.jar -jar yourapp.jar, setting
FISSURE_OAST_URL to arm beaconing.
FissureIastAgent installs an ASM
ClassFileTransformer that rewrites the app's own bytecode
at load time, injecting a
FissureIast.autoSink(value, category) call before every
call site of a known sink (Runtime.exec, JDBC
Statement.execute*, Class.forName,
Context.lookup/JNDI, ScriptEngine.eval) whose
tainted value is the argument, so you do not add manual hooks. The
beacon carries a Class.method(File.java:line) stack frame,
the exact vulnerable line, and the optional
FissureIastFilter (a jakarta.servlet.Filter,
or javax.servlet for the older namespace) tags the tainted
request parameter or header as the beacon src. A manual
mode still exists for when ASM is unavailable: compile
FissureIast.java with the app and call
FissureIast.sink("sql", query) at a sink.
The .NET reference agent (agents/dotnet/FissureIast.cs)
ships a manual Sink("sql", query) call and a process-wide
startup hook that arms it with no app change: compile it to a DLL and
set DOTNET_STARTUP_HOOKS so the runtime arms the agent
before Main. Fully-automatic IL instrumentation (injecting
FissureIast.AutoSink at sink call sites, the .NET analogue
of the JVM ASM agent, via the native CLR Profiling API or a
MonoMod/Harmony/Fody IL weaver) is gated on the .NET SDK to build, the
same way the automatic JVM agent needs a JDK plus ASM; the sink
signatures and beacon wire format are identical to the JVM agent, so an
IL weaver is a mechanical port. Both agents are observe-only (they never
change the target's behaviour) and inert unless
FISSURE_OAST_URL is set. Use automatic instrumentation on a
lab, a CTF harness, or a cooperative test app you are authorized to
instrument, when you want zero-app-change coverage of every sink rather
than a hand-placed hook.
Chapter 5 - Reporting
Reporting turns a technical discovery into an actionable security improvement. A weak report buries a real vulnerability; a strong report makes remediation obvious.
5.1 Evidence and structure
Fissure links each finding to the request/response pair that produced it, so Send to Repeater reproduces the exact exchange and the report can embed it. A finding report reads: title, summary, affected asset, severity and rationale, preconditions, steps to reproduce, expected behavior, actual behavior, impact, evidence, and remediation. Keep reusable templates for common classes and fill them with precise evidence.
Severity rationale should be specific: not "this is critical" but "an unauthenticated attacker can reset another user's password, leading to account takeover". Recommend server-side enforcement, avoid blaming developers, and do not prescribe only input validation when the issue is authorization.
5.2 Export
The Report view aggregates and deduplicates findings, redacts
evidence by default, and exports as Markdown, HTML, JSON, CSV, SARIF
(for CI code-scanning), or issue XML compatible with a mainstream
web-security suite (which imports back into that suite). PDF export runs
an external generator you name in Settings. The PwnDoc connector pushes
findings and generates a report to a PwnDoc instance. The FP/ignored
toggle (CLI: --exclude-triaged) drops false-positive and
ignored findings. Before exporting, flip the Show: Source / Show:
Rendered toggle to read the report as delivered: Markdown renders in the
view, HTML and PDF open in your web browser.
The HTML report (and the PDF, which is printed from it) is rendered
through a template you can replace. Copy the bundled
resources/report/report.html.tmpl to
report.html.tmpl in your Fissure config folder
($XDG_CONFIG_HOME/fissure, else
~/.config/fissure; on Windows
%APPDATA%\Fissure) and edit it: the file is read on every
preview and export, so an edit shows on the next render with no restart.
The substitution variables are {{report_title}},
{{generated_at}}, {{fissure_version}},
{{risk_score}}, {{sev_critical}} through
{{sev_info}}, {{total}},
{{tools_html}} and {{findings_html}}. The
template must keep {{findings_html}}; one that is missing
it, empty, or unreadable is rejected (a report silently missing its
findings would read as a clean result) and Fissure falls back to the
bundled template, telling you why in a popup. Over the control API and
MCP the report response names which template rendered it
(template: custom, bundled or
builtin) and carries a template_error when a
custom one was rejected.
Chapter 6 - Triage, Severity, and Disclosure
Finding a bug is half the job. The professional tester triages it accurately, ranks its severity, communicates responsibly, and handles remediation without losing evidence.
6.1 Severity and confidence
Fissure records both on every finding. Severity: informational (hardening signal), low (limited impact or strong preconditions), medium (meaningful exposure or limited unauthorized action), high (sensitive data, privilege escalation, broad tenant impact), critical (account takeover, RCE, systemic compromise). Confidence: tentative (a suspicious signal), firm (a repeated pattern), certain (a controlled proof). A low-confidence issue can still be real; a high-confidence issue can still be irrelevant if the endpoint is out of scope. Triage in the Findings view cycles open, confirmed, false-positive, and ignored, all saved with the session.
6.2 Disclosure and retest
Confirm authorization, minimize testing impact, prepare a reproducible report, submit through the approved channel, answer triage questions, and retest the fix. Demonstrate enough to prove risk without exfiltrating unnecessary data or disrupting services. On retest, use the original request as the baseline (Fissure still holds it with the finding), confirm the vulnerable path is denied, test peer objects and alternate methods, and check that the fix did not only hide the UI.
Chapter 7 - CI and DevSecOps Integration
Fissure is not only a manual workstation. Findings become part of a feedback loop that helps teams prevent regressions.
7.1 Headless runs
fissure scan <URL> [--active] [--aggressive] [--quick]
runs the engine without the GUI, and
fissure report --session <file> renders a saved
session. Add --login <config.json> to authenticate
first (the CLI equivalent of the Settings Login config; it aborts with
exit 2 if the login fails), so a scan can reach pages behind a login.
Report options (--format html|markdown|json|sarif|csv|burp,
--min-severity, --source, --host,
--exclude-triaged, --tool-versions, and
--fail-on <sev>, which exits non-zero on a finding at
or above a severity) make it a release gate. A nightly scan against
staging with --format sarif feeds a code-scanning
dashboard.
For a repeatable practice and regression target, the repository ships
a local, loopback-only DVWA lab under lab/dvwa/ (Docker
compose plus a per-level regression runner) with a ready-made DVWA login
config and an audit of the integration against Fissure's features in
docs/12_DVWA_LAB.md. It is a training target and a
self-test of the proxy, scanner, repeater, intruder, and reporting, not
a production scanning target.
7.2 The control plane
For a long-lived service, fissure serve (or the Settings
Control API) exposes the async scan job API so a CI job or an agent
starts a scan, polls its status, and reads the findings over HTTP, or
drives it through the MCP bridge (Volume V). Good automation candidates
are known-regression checks, passive header review, endpoint discovery,
and BChecks for known patterns; poor candidates are novel business-logic
flaws, destructive account actions, and unapproved production
scanning.
7.3 Manual-to-automated conversion
Start from a manually reproduced finding, extract the smallest reliable signal, encode it as a scripted check or a BCheck, run it only against appropriate environments, tune out false positives, and attach it to a regression test or a release gate.
Chapter 8 - Capstone
You are testing a fictional multi-tenant project-management application: organizations, projects, users, invoices, invitations, file uploads, webhooks, OAuth login, and an admin panel. The goal is professional coverage, not every possible issue.
Deliverables: a scoped site map grouped by feature; a role matrix for anonymous, member, manager, owner, and admin; a parameter inventory; at least five manual Repeater hypotheses; at least one Intruder result with Grep columns; at least one passive automation finding; at least one authorization replay (Auth matrix or Check access control); and one complete report or a clear no-finding summary.
Suggested flow: browse as anonymous and record public routes; browse as a member and map project and object IDs; browse as owner and admin and capture privileged routes; Compare roles; test object swaps in the Repeater; test role and mass-assignment parameters; review JavaScript for hidden endpoints; use HaE and passive scripts to surface errors and sensitive paths; use the Intruder for controlled enumeration where allowed; and prepare the final report.
A no-finding report is professional work too. A strong one explains the scope tested, the accounts and roles used, the workflows reviewed, the automation performed, the manual hypotheses tested, notable hardening observations, limitations, and recommended next steps.
Final principles
- Fissure is a microscope, not a magic exploit machine.
- A finding is only as good as its evidence.
- Automation should amplify judgment, not replace it.
- Authorization must be tested with multiple identities.
- Reports should make remediation obvious.
- Stay inside authorization and minimize harm.