Volume II - Intruder and Scripted Attacks
The Intruder is controlled automation: the bridge between careful manual testing and larger-scale experimentation. It lets you define exactly where payloads go, how they are transformed, and how responses are organized. Intruder is not about sending many requests; it is about sending planned variations and extracting meaning from the responses.
Open the Intruder with F10. Only fuzz authorized targets; the scope allowlist and the authorization banner apply.
Chapter 1 - Positions and the Attack Loop
1.1 The workflow
Select a representative request, mark payload positions, choose an attack mode, load or generate payloads, tune the rate, run, classify responses, and rebuild interesting cases in the Repeater. A good source request has stable authentication, a predictable baseline, non-destructive behavior, and a clear testing goal.
The usual starting point is a request captured in the Proxy or refined in the Repeater. Right-click a row and choose Send to Intruder, or build the request in the Intruder view directly.
1.2 Marking payload positions
Fissure marks payload positions in the URL template with backticks: wrap the part you want to vary in a pair of backticks. Only the marked section is replaced with payload values during the attack. A focused position produces clearer results than attacking every parameter, so mark exactly what your hypothesis needs and nothing else.
https://app.example.test/api/search?q=`test`&category=books&limit=10
Here only the q value is being tested. Precision reduces
noise.
1.3 One position, one hypothesis
Before running, write one sentence of the form "I am testing whether this input changes server-side behavior under a given condition". Map the position to that hypothesis.
| Hypothesis | Position to mark | Payload family |
|---|---|---|
| Search input may be reflected | query value | XSS probes, delimiters |
| Object ID may be predictable | path or numeric ID | neighboring IDs, UUID swaps |
| Role check may be missing | user or account ID | IDs from another account |
| File path may be trusted | filename or path param | traversal payloads |
| Validation may be weak | type field or boolean | true/false, role, enum |
1.4 Baselines
Before a large attack, send a few baselines: the original request (expect a normal response), one harmless change, and one invalid value. This shows how the target behaves when the input is normal, changed, and broken, so later anomalies are meaningful. If you do not know normal behavior, you cannot identify an anomaly confidently.
Chapter 2 - Attack Modes
Fissure implements the same four classic Intruder modes. The mode decides how payloads combine with positions.
| Mode | How it works | Best for |
|---|---|---|
| sniper | one payload set; vary one position at a time | testing individual parameters |
| battering ram | one payload set; the same payload everywhere | mirrored values, duplicated tokens |
| pitchfork | one set per position, advanced in lockstep | paired data (user/pass, id/hash) |
| clusterbomb | one set per position, the cartesian product | exhaustive combinations |
2.1 Sniper
Sniper is the safest default. With several marked positions it tests one at a time, leaving the others unchanged, which makes causality easy to read. Use it during early exploration to learn which parameter controls behavior. Sniper and battering ram both draw from a single shared payload set.
2.2 Battering ram
Battering ram inserts the same payload into every marked position at once. Use it when a value must appear consistently in several places, such as an email and its confirmation field in a password-reset body.
2.3 Pitchfork
Pitchfork uses one payload set per position, advanced in lockstep: line 1 of set A pairs with line 1 of set B, and so on. The request count is the length of the shortest set. It is ideal for paired data: usernames and passwords, IDs and checksums, accounts and CSRF tokens.
2.4 Clusterbomb
Clusterbomb tries every combination. If set A has 100 values and set B has 100 values, that is 10,000 requests. Estimate the count before launching by multiplying the set sizes. Fissure guards against a runaway clusterbomb with a hard cap on the number of requests one attack may generate, but you should still plan the volume yourself.
2.5 Per-position sets
For pitchfork and clusterbomb, the Position selector gives each marked position its own payload set and type. The first set is shared and is the fallback for any position left empty.
Chapter 3 - Payloads and Payload Types
3.1 Payload types
Payload type sets how the input is read. The status line shows the chosen format.
| Type | Input format | Use |
|---|---|---|
| List | one payload per line | common words, IDs, usernames |
| Numbers | start stop step | object IDs, pagination, ranges |
| Null | a count | repeat the base request N times |
| Wordlist file | a path | large controlled wordlists |
| Dates | start count step [fmt] | invoices, bookings, archives, logs |
| Charset | set minlen maxlen | boundary and length testing |
| Case-mod | a base word | case-normalization and comparison bugs |
| Script | a QuickJS generator | programmatic payloads (Chapter 6) |
| Recursive grep | regex; seed; count | chain a value from each response (3.2) |
| Username | a person's name | username guesses from a real name |
| Bit flipper | an encoded token | signed-token / padding-oracle probing |
| ECB shuffle | ciphertext blocksize | ECB cut-and-paste block manipulation |
Choose the source to match the shape of the target parameter. Numbers on a write endpoint can create destructive requests; date formats create noise if the timezone is wrong; large runtime files grow traffic quickly.
3.2 Chained and cryptographic payload types
Four of the types go beyond a static list: one chains requests together, one builds identities, and two manipulate a token or ciphertext at the byte and block level. They share the type selector with the sources above, but each reads its input box differently.
Recursive grep turns the attack into a chain. Instead of drawing from
a fixed set, each request's payload is the value grepped out of the
previous response. Mark exactly one position, then put an extract regex
on line 1 of the payload box, an optional seed for the first request on
line 2, and an optional request count on line 3. The first request uses
the seed; after every response the regex (capture group 1, or the whole
match when there is no group) pulls the value carried into the next
request. The chain stops when the regex finds nothing, on a transport
error, or when the count is reached. Use it to walk anything where each
step's input comes from the last step's output: a rotating anti-CSRF
token, a pagination cursor, a "next" link, a multi-step wizard. Example:
a form returns <input name="csrf" value="a1b2c3"> and
expects that exact token on the follow-up request. Set the extract regex
to name="csrf" value="([^"]+)" and seed the first token by
hand; Fissure then follows the rotating token request by request without
you re-copying it each time. Headless, this is the control-API and MCP
mode="recursive" run with extract,
seed, and count.
Username turns a person's name into the account names a login or
enumeration endpoint is likely to accept. Type a name (for example
Jane Doe) on the first line; Fissure lowercases it, treats
the first whitespace token as the first name and the last token as the
surname, and emits the common permutations: jane,
doe, jane.doe, jane_doe,
janedoe, jane-doe, jdoe,
j.doe, doej, doe.jane, and
janed. Duplicates are dropped, and a single-word name
yields just that word. Use it to build a candidate username list for
login, password reset, or profile-lookup enumeration when you know a
real name (a report author, a support ticket, a leaked document) but not
the account handle. Feed the result into a sniper attack over the
username field and grep for the "user exists" against "unknown user"
difference.
Bit flipper emits one variant of the base value for every single bit
of every byte, that byte XOR-ed with one bit at a time. A flip that
would produce a NUL byte is skipped, so every variant keeps the base
length. Put the base value (usually an encoded token) on the first line.
Use it against a token whose integrity is not properly checked: an
unauthenticated-cipher session cookie, a CBC ciphertext feeding a
padding oracle, an unsigned or weakly-signed identifier. Watch for the
flip that changes application meaning (a role byte, a user-id digit)
while the server still accepts the token: that is the tell that the
value is malleable. Example: a role=user field is AES-CBC
encrypted into a hex cookie with no MAC; bit-flipping the ciphertext
block that precedes the role bytes and replaying each variant surfaces
the flip that decrypts to role=admin without ever knowing
the key.
ECB shuffle rearranges the base value a block at a time. Give it
base blocksize (the ciphertext as the first token, the
block size in bytes as the second, for example
<hex> 16; the default block size is 16). It treats
the value as a run of fixed-size blocks and emits the adjacent-block
swaps and single-block duplications; a trailing partial block is carried
along unchanged, and it needs at least two whole blocks to have anything
to reorder. Use it against ECB-mode ciphertext, where identical
plaintext blocks encrypt to identical ciphertext blocks, so reordering
or duplicating ciphertext blocks reorders or duplicates the underlying
plaintext. Example: a token encrypts
user=jane&role=user in ECB; swapping the block that
holds role=user for a block you have arranged to hold
role=admin is a cut-and-paste forgery, and the shuffle
enumerates the block rearrangements to try.
Because these four are still payload sources, they flow through the processing pipeline (next section) and the response grid like any other type: bit-flip and ECB variants usually need a Transform step to re-encode them for the parameter, and every recursive-grep step records its extracted value in the Grep column so you can watch the chain advance.
3.3 The processing pipeline
Process pipeline opens an ordered list of steps applied to every payload before it is inserted. This is where the Intruder becomes more than a wordlist runner.
| Step | What it does |
|---|---|
| Prefix | prepend a fixed string |
| Suffix | append a fixed string |
| Match-replace | literal find and replace |
| Transform | encode, decode, or hash (base64, URL, hex, zlib, MD5/SHA) |
| Skip-if regex | drop a payload when a regex matches |
| Regex-replace | regex find and replace ($1, $2 capture-group references) |
| Script | a JavaScript transform per payload |
Steps run in order. Add, reorder, remove, and test them. A typical
chain URL-encodes characters that would otherwise break the request,
base64-encodes a JSON fragment before insertion, or adds a required
prefix or suffix. For a Script step, input is the payload;
return a value or define transform(input).
3.4 Evidence-friendly payloads
Payloads should help prove what happened. Unique markers make
correlation easier: fissure_probe_2026_001 is easier to
find in logs and responses than test. Use unique, legal,
non-destructive markers, and never use payloads that modify real user
data or create offensive content.
Chapter 4 - Response Analysis
Large attacks are useless if you cannot interpret their results. The objective is to turn hundreds of responses into a small number of meaningful buckets.
4.1 Beyond status and length
The grid shows status, length, and time for every request, which is a good start but not enough: many important bugs return the same status and a similar length as normal responses. Sort by these columns to surface outliers, then apply application-specific markers.
4.2 Grep
The Grep row adds two result columns. Grep flags responses containing a string in a Hit column (a yes/no marker for a known message, role, or error), and extracts a regex capture into an Extract column (a title, an error, a JSON field, an account name). A Hit column answers a question ("did authorization fail?"); an Extract column reveals a value that changes even when status and length do not (for example a role that changes from user to admin while every response stays 200 OK).
Configure the markers from the baseline response before running: identify a normal success string, a normal failure string, and any stable field, then set a Grep needle and an Extract regex. Run a short smoke test of five to ten requests before the full attack.
A third column, Refl, needs no configuration: it marks any response that echoes that request's own payload value back, a reflection lead for XSS or template echo. Reflection is a lead, not exploitation; confirm the context, encoding, and execution before treating it as a finding.
4.3 Building buckets
Classify rather than read every response:
| Bucket | Indicators | Next action |
|---|---|---|
| Normal success | known success marker, expected length | sample-check |
| Normal failure | known error marker | ignore unless unexpected |
| Auth/session failure | login page, redirect, invalid CSRF | fix session handling first |
| Backend error | 500, stack trace, parser error | rebuild in Repeater, reduce payload |
| Authorization anomaly | data visible across roles, missing denial | compare accounts, verify impact |
| Unknown rare state | no known marker, unusual length or time | investigate first |
For every interesting result, rebuild the request in the Repeater (the Request column holds it as sent), reduce the payload to the minimal reproduction, and confirm manually before treating it as a finding.
Chapter 5 - Sessions and Cookbooks
5.1 Keeping sessions valid
Some applications require a fresh token on every request (an anti-CSRF token, a one-time form ID). For attacks that need this, the request engine's session-handling rules (Volume III) inject or refresh a token before each send, and a fresh login can be re-run on a chosen status. Validate token handling with a tiny smoke test first: a failed token loop makes every result meaningless.
5.2 Rate and throttling
The Rate row tunes the attack. Threads sets concurrency (blank uses
the scan Threads setting on the Rate & timing tab of the Target
view's Scan options); Delay ms pauses between requests to respect rate
limits; Retries re-sends on a transport error or a 429/503 (the retry
count shows in the Status cell, for example 200 (r2)).
Speed is not a virtue: a slower attack with clean evidence beats a fast
one that breaks sessions, triggers lockouts, or floods logs. Estimate
the request count and duration before launching, and use the slowest
speed that answers the question.
5.3 Cookbook patterns
Each pattern is a hypothesis, a position, a payload family, response markers, and the evidence worth keeping.
- Authorization matrix: mark an object ID; payload neighboring IDs and IDs from lower-privileged accounts; grep for "access denied", "forbidden", a login page; extract the owner name or a visible balance. Verify every hit manually.
- Method confusion: mark the method; payload GET, POST, PUT, PATCH, DELETE, OPTIONS, HEAD; watch status, Allow headers, and any state change.
- File and backup discovery: mark an extension; payload bak, old, backup, txt, zip, sql, log against a known path; keep it scoped and rate-limited.
- Error-based mapping: payload quotes, long strings, Unicode, traversal probes, and template syntax to map parser and validation behavior.
- Rate-limit exploration: send a small benign sequence and watch for 429, Retry-After, captcha, or lockout messages.
- Business-logic enumeration: build payloads from the application itself (coupon states, quantity bounds, plan names, workflow statuses, feature flags).
5.4 Saving attacks
The Config row saves the whole attack (template, positions, payloads, pipeline, grep, and rate) under a name: type a name and Save, or pick a saved config and Load or Delete. Configs are stored per project, so a reusable attack survives a restart and a project switch.
5.5 Mining parameters
Mine params reuses the payload list as candidate parameter names and
probes the URL for hidden parameters (by reflection, status, or length
change). It is the quick way to discover an accepted-but-undocumented
debug, admin, or format parameter
before testing it in the Repeater.
Chapter 6 - The Scriptable Generator
For attacks that exceed a static wordlist, the Script payload type is a programmable engine: a QuickJS generator whose return value is split by newlines into payloads. This is Fissure's equivalent of a Turbo-Intruder-style driver.
6.1 When to script
Use a scripted generator when you need custom logic (dependent values, computed tokens, structured combinations) or filtering that a plain list cannot express. For small or exploratory work, a List or the Repeater is clearer. Keep scripted generators small and readable; a script longer than the test it drives produces untrustworthy results.
6.2 Combining with the pipeline and tags
A scripted generator composes with the processing pipeline (each
generated payload still flows through Prefix, Transform, Skip-if regex,
and the rest) and with inline transform tags (Volume III): each request
is expanded after payload substitution, so encoders and generators are
fresh per request. Wrap a position in
<@base64>...<@/base64> to fuzz an encoded
parameter without pre-generating an encoded wordlist, or use
<@oast/> to inject a fresh out-of-band canary per
request (Volume VI).
6.3 Filtering by response
Response filtering happens in the grid and the Grep columns: sort by status, length, and time; set a Grep Hit for a known error or role marker; set an Extract regex for a changing field. Keep anything outside the baseline set, anything slower than baseline plus a threshold, and anything that reflects the payload or shows a stack trace, a parser error, or another user's identifier.
Chapter 7 - Group Send and Race Conditions
Some vulnerabilities appear only when several requests hit the backend at nearly the same time: double spend, duplicate redemption, skipped validation. Fissure coordinates this from the Repeater, not the Intruder.
7.1 Building a group
A group is several Repeater tabs that share a collection. Set the same collection name on two or more tabs, select one of them, then press Send group.
7.2 The send modes
- Separate connections: a baseline, one connection each.
- Single connection: warms the path over one connection.
- Parallel with HTTP/1 last-byte synchronization: hold the last byte of each request and release together.
- H2 single-packet: the stronger HTTP/2 attack, one connection with all streams released in one packet (needs an HTTP/2 target).
Each tab's history records its result, and a summary reports how many responded.
7.3 Reading a race result
Evidence for a race condition is not a single response; it is a before/after state comparison showing that the application allowed an impossible state. Confirm the outcome (an extra credit, a duplicated record) out of band, not just from the response codes. Run race tests only against explicitly authorized targets and safe test objects.
Chapter 8 - Intruder Lab
Use a legal training application.
- Capture a safe search or filter request and Send to Intruder.
- Mark exactly one position with backticks; remove any others.
- Send three baselines: original, a harmless change, an invalid value.
- Load a 10-line List with unique markers, and add a Transform step that URL-encodes each payload.
- Set a Grep Hit for a success marker and an Extract regex for the response title or a JSON error.
- Set Threads low and a small Delay, then Start (it doubles as Stop).
- Sort by status, length, and time; rebuild one anomaly in the Repeater and reproduce it.
- Save the attack as a named config.
- As a stretch, rebuild the same test with the Script payload type and one pipeline step, then run a group send of two Repeater tabs to feel the race modes.