Volume I - Foundations and Core Fissure
This volume builds the mental model and the core manual workflow. By the end you can capture a clean request, understand its structure, replay and modify it in the Repeater, analyze it with the workshops, run a disciplined scan, and keep evidence that becomes a report.
Chapter 1 - The Modern Web
A single click in a modern web application can load JavaScript, call REST endpoints, query GraphQL, refresh tokens, contact a CDN, and update the page without reloading it. Security testing needs visibility into that traffic. Fissure, like any interception tool, places the tester in the communication path. Requests can be intercepted, modified, replayed, fuzzed, compared, and logged before they reach the server.
The central idea is simple: if you can understand and control the traffic, you can understand and test the application.
1.1 HTTP from first principles
HTTP is a request-response protocol. The client asks for something; the server answers. Fissure captures both sides.
GET /products HTTP/1.1
Host: shop.example.test
User-Agent: Firefox
Accept: text/html
HTTP/1.1 200 OK
Content-Type: text/html
Content-Length: 15420
<html>...</html>
A browser makes this look effortless, but the request is structured. Fissure exposes the structure so you can reason about it: a request line (method, path, version), headers (identity, origin, content type, caching), an optional body (most user input and business data), and cookies (state, and often authentication).
1.2 Methods, status codes, and why they matter
Changing only the method can expose unexpected server behavior: a blocked GET does not mean PUT, PATCH, or DELETE are blocked. Reading applications through status codes, response lengths, and timing is faster than staring at rendered pages. A 2xx where access should have been denied, a 403 that is a bypass target, a 500 that shows fragile code reached by your input: the metadata tells you where to look. Fissure's Proxy grid surfaces method, URL, status, type, length, and timing for exactly this reason.
1.3 HTTPS and Fissure as a trusted intermediary
HTTPS encrypts traffic between browser and server. Fissure intercepts it by acting as a certificate authority your browser trusts. Fissure generates one CA per install, mints a per-host leaf certificate on demand (cached per host), and serves it with SNI-aware per-connection certificates. You install that CA in a dedicated testing browser profile; the CA is never shared, and you should never install it into a browser you use for anything other than testing.
Authentication answers who you are. Authorization answers what you are allowed to do. Many severe vulnerabilities appear when authentication is correct but authorization is incomplete. Test them separately (Volume IV).
1.4 APIs, GraphQL, and WebSockets
Modern applications expose REST endpoints, GraphQL operations, and
WebSocket frames. Fissure treats all of them as inspectable traffic:
REST requests appear in the Proxy and Repeater like any other; a GraphQL
request (a /graphql URL or a body with a top-level
query) gets its own scanner check; WebSocket flows (a 101
upgrade) capture each frame and can be replayed and intercepted.
1.5 The transport underneath: HTTP/1.1, HTTP/2, and HTTP/3
The same application is often reachable over more than one HTTP version, and the versions do not always parse a request identically. Fissure speaks all three: HTTP/1.1 and HTTP/2 through the proxy and engine (with h2 offered transparently on https), and HTTP/3 over QUIC through the "HTTP/3 fetch" tool, the Repeater "Send over HTTP/3" action, and the "HTTP/3 proxy" MITM listener. Why care: a disagreement between versions (a request accepted over h2 but rejected over h1, an endpoint only reachable over h3, a cache keyed differently) is itself a finding. Volume VI, Chapter 3 turns that into the HTTP-version differential playbook; for now, just know the transport is not fixed and that Fissure lets you drive each version deliberately.
Chapter 2 - Inside Fissure
2.1 An interception platform, not a single scanner
Fissure is a platform where many tools share the same HTTP exchanges. The same request moves from the Proxy to the Repeater, the Intruder, the analysis workshops, and the findings store without being rebuilt. The unit of work is one captured flow: a request and its response, which the Proxy records, the Repeater duplicates, the Intruder mutates, the checks analyze, the Comparer compares, and the report aggregates.
2.2 The views
The toolbar is a row of collapsible category dropdowns (Home, Organize & collaborate, Auth & session, Recon & infra, Capture, Test & attack, Results, Analysis & inspection, Power-ups, Config); click a category to show its buttons. The primary work-area views, and the two most-used popups, have a function key:
| Name | Key | Kind | Purpose |
|---|---|---|---|
| Dashboard | F2 | view | Recon overview: endpoints, hosts, scope split, throughput, severity chart. |
| Repeater | F3 | view | Edit and resend one request; inspect the response. |
| Proxy | F4 | view | Intercepting proxy and the captured-flow browser. |
| Target | F5 | view | Crawl a seed URL and audit its endpoints; scope and aggressive toggle. |
| Findings | F6 | view | The findings grid and detail; triage, filter, Send to Repeater. |
| Plugins | F7 | popup | Run wrapped OSS tools; their output becomes findings. |
| Report | F8 | view | Preview and export the consolidated report. |
| Multitool | F9 | popup | Encode/decode, JWT, and hash tools. |
| Intruder | F10 | view | Payload-position fuzzing over the transport core. |
Help is F1 and sits in the Home category (with Dashboard, About, and the Fissure entry that opens the command palette); Settings sits in the Config category (with Plugins and Pools). There is no separate keyboard-shortcuts toolbar button: open the shortcut editor from Settings > Appearance > Edit keyboard shortcuts, or from the palette entry "Open Keyboard shortcuts". Ctrl+K opens the command palette, which can switch to any view or open any tool popup by name. Escape closes the topmost popup.
2.3 The tool popups
Beyond the primary views, the toolbar and command palette open utility popups. The map, by toolbar category:
- Home: Help, About (version, author, license).
- Organize & collaborate: Organizer, Tags, Workflows (a request pipeline builder), Team (shared-project collaboration), Schedules (recurring scans), Project.
- Auth & session: Session (session-handling rules), Tokens, Auto-replay, SAML (a SAML-Raider-style workshop), Cookie jar (the shared session jar).
- Recon & infra: OAST (the out-of-band collector), Probes (origin IP, WAF fingerprint, directory listing, log poisoning, page capture), Raw proxy (a generic TCP/UDP intercept relay for non-HTTP protocols), Rules (match-replace), User Agents (presets and the active User-Agent), Env (environments).
- Capture: Scope (the scope editor), Intercept rules, Browser (the bundled Fissure Browser: a Chromium pre-pointed at the proxy with the CA trusted in its own profile), DOM Invader (live DOM taint tracking), HTTP/3 fetch, HTTP/3 proxy.
- Test & attack: GraphQL (the GraphQL workshop).
- Results: Jobs (the live jobs monitor), Purple team (probe recording and detection coverage).
- Analysis & inspection: Multitool, Logger (the cross-tool traffic log), Event log, Attack surface, Search (the global traffic/finding query), Comparer, Raw edit (a byte-exact request editor), Sequencer, HaE.
- Power-ups: Extensions (the extension-bundle manager, which also shows the selected bundle's inline tabs), Import checks (compile BCheck, nuclei, or Jaeles templates into checks), AI chat (the agentic assistant).
- Config: Plugins, Pools (shared concurrency and rate budgets), Settings.
The palette also opens popups that are not toolbar modules (several also have a button in a view, such as Scan options and Parameters in the Target view): Scan options, Parameters, the Intruder payload pipeline, the grid-column and toolbar customizers, the extension message editor, the Authorization matrix, Keyboard shortcuts, and the Inspector. The CSRF/Clickjack PoC generators and the AI assistant are request-contextual and open from the request context menu.
Each popup is taught with the workflow that uses it, so this section is only the map. In this volume: the analysis workshops (the Multitool, Comparer, and Sequencer), the Logger, the query Search, the Scope editor and named scopes, the Scan options, the Probes, the shared Cookie jar, and the Jobs and Event-log monitors. With Volume III (automation): Rules (match-replace), Tags, HaE, Session, Auto-replay, the Workflows pipeline builder, and the Schedules panel (recurring scans). With Volume IV (authentication and access control): Tokens, SAML, and the Auth-matrix. With Volume V (extending Fissure): Plugins, Extensions, Import checks, AI chat, and the AI assistant. The OAST out-of-band collector is used in Volumes III and VI, and the request-contextual CSRF/Clickjack PoC generators in Volume VI. Organizer, Env, Project, Team, Raw proxy, the shortcut editor, Help, and Settings are covered in this volume.
2.4 Scope: the safety and organization boundary
Scope defines what Fissure treats as part of the engagement. Without it, histories are noisy and active tools waste effort on third-party systems. In Fissure, scope is more than a filter: with a scope set, the proxy blind-tunnels out-of-scope hosts (no interception, no capture), an out-of-scope scan seed is refused with an on-screen reason, and active checks stay inside the allowlist. Define scope before heavy browsing or scanning (Chapter 4).
Chapter 3 - Installation and Configuration
3.1 Building and running
Fissure builds from source with the project Makefile. The common
targets are all (build), tests (the regression
suite), checks (static analysis), docs,
format, and appimage (a distributable bundle).
Nilorea, the library Fissure is built on, is compiled from source
alongside it, not linked separately. Run the resulting
fissure binary to open the GUI, or use the headless CLI
(Chapter 8 and Volume V).
3.2 A dedicated testing browser
Do not use your everyday browser for testing. A browser profile used with a proxy accumulates special settings, a trusted CA, cookies, and cached state.
The quickest path is the built-in Fissure Browser: click Browser on the toolbar (or the Proxy view). It launches a Chromium in an isolated profile already pointed at the proxy, with the Fissure CA trusted in that profile's own store (never your real trust store), and it starts the proxy first if needed. This does everything in section 3.3 for you in one click, so for most work you can skip the manual setup below entirely.
If you prefer your own browser, keep a separate profile (name it
obviously, such as firefox-fissure-lab) and install the
Fissure CA only there, following section 3.3.
3.3 Manual proxy configuration and the CA certificate
Only needed if you are not using the Fissure Browser:
- Open Settings and note the proxy port (the Proxy binds
127.0.0.1). - Point your testing browser at
127.0.0.1on that port for HTTP and HTTPS. Addlocalhost, 127.0.0.1, ::1to the browser's no-proxy list. - In the Proxy view, start the proxy.
- In Settings, export the CA certificate.
- Import that CA into the testing browser profile as a trusted authority for identifying websites.
- Visit an HTTPS site and confirm the flow appears in the Proxy grid with no certificate warning.
For clients that cannot set a proxy, Transparent mode (Settings) also
routes non-proxy-style requests (a plain GET /path with a
Host header).
3.4 Project and evidence hygiene
Keep engagements apart. Fissure's Projects (Chapter 8) isolate traffic history, match-and-replace rules, the Organizer queue, environments, Repeater collections, findings, the endpoint inventory, and saved attack configs, each under its own directory. Keep a notes and evidence directory per engagement outside the tool as well, and define scope before browsing.
3.5 Connectivity checks
Before testing a real target, confirm the setup with harmless checks: open an HTTP site and see it in the grid; open an HTTPS site with no warning; turn Intercept on and verify a request pauses; Forward it and see the page render; send it to the Repeater and resend it; then disable the browser proxy and confirm normal browsing returns.
Chapter 4 - First Interception and Project Organization
4.1 The first useful request
The first goal is not to find a bug. It is to capture a clean,
understandable request. Open the target in the testing browser, confirm
traffic appears in the Proxy grid, find a simple request such as
GET / or GET /login, select it to inspect the
request and response, and send it to the Repeater unchanged.
4.2 Reading the Proxy grid
The Proxy grid columns are your first-pass triage: # is the capture order, Method reveals state-changing actions, Status gives a quick behavioral signal, URL shows the host (first-party versus third-party), route structure, and identifiers, Client is the protocol the browser spoke to the proxy, TLS shows the flow's TLS details, Note holds your per-flow comment, and Body flags a body the proxy captured only up to its hold limit. The Ident column shows a multi-identity tag when PwnFox-style tagging is in use (Volume IV), and the Highlight and Extracted columns show HaE results and manual row colors (Volume III). Columns can be reordered, resized, and hidden with the grid-column customizer.
4.3 Filtering noise
Modern pages load analytics, fonts, CDNs, images, and telemetry. The
filter bar over the grid narrows what is shown: type to match method,
URL, status, or MIME (toggle re for a regex), and cycle
Status (2xx to 5xx) and Scope (in/out) to filter the list. When in doubt
during an engagement, filter traffic rather than delete it; deletion can
remove evidence you later need.
4.4 Defining scope carefully
Press Edit scope in the Target view (or Scope in the Capture
category) to open the Scope editor popup. Its In scope and Out of scope
tabs each hold a list, one pattern per row (add a row with +, remove one
with x); Save persists both. Patterns are case-insensitive: an exact
host, a .suffix (a domain plus its subdomains),
re:<regex>, or * for all, with an
optional :port to pin one port (a bare host covers every
port); a deny rule wins over an allow. The picker at the top switches
the active named scope, and New, Rename, and Del manage them, so one
project can keep several scope sets. With a scope set, a crawl or scan
can span several authorized hosts while the proxy blind-tunnels the
rest.
To adopt a bug-bounty program's scope, use Import scope (in the Target view or the Scope editor): it loads a HackerOne/Bugcrowd scope JSON, a target-scope JSON exported by a mainstream web-security tool, or a plain host list (offline, no live API) and appends the hosts to the allow/deny lists.
4.5 The site map as a recon artifact
The Target view builds a structured map of the application. The View button cycles three displays: the flat endpoint grid, a host/path tree (origins, then nested path segments; click a node to seed its URL), and a node graph (a visual bird's-eye map of hosts and paths as dots joined by edges, hosts in the accent color and endpoints colored by HTTP status). The map tells you which areas exist, which APIs are present, and which parts deserve deeper attention.
4.6 Annotation, baselines, and safe modifications
Preserve reasoning as you go. Select a flow in the Proxy grid and press Comment to annotate it with free text (shown in the Note column) or Highlight to cycle a manual row color (shown in the Highlight column); both persist with the proxy history, so a tired you at 2 a.m. can still find the request that mattered. Beyond per-flow annotation, Fissure's knowledge management is the Organizer (a save-for-later queue with per-item collection, notes, and tags), finding notes and tags (Chapter 8), and HaE colors that mark flows matching a pattern automatically (Volume III). Stash an interesting request with To Organizer from the Proxy or Findings context menu.
Before changing anything, capture normal behavior as a baseline: browse unauthenticated, log in as a normal user and repeat key flows, log out, and save representative requests to Repeater tabs. Then make early modifications that are safe and reversible: change a harmless query value, remove an optional header, remove a cookie from a non-sensitive request, change Accept or Content-Type, or repeat a request twice to detect one-time tokens. Your objective at this stage is to learn how the application reacts.
Chapter 5 - Repeater Mastery
The Repeater is where most serious manual testing happens. Instead of asking "what can I throw at this endpoint?", you ask "what exact assumption am I testing?"
5.1 Baseline first
Before modifying a request, resend it unchanged. This confirms it is replayable and gives you a baseline for status, length, timing, and body. If a request cannot be replayed unchanged, solve that first: you may be dealing with CSRF tokens, one-time nonces, timestamps, or session rotation (Run macro and the session cookie jar, below, handle most of these).
Workflow: pick a method, set the URL, headers, and body, then Send. Every To Repeater (Proxy) or Send to Repeater (Findings, or a request context menu) opens a new tab carrying the exact exchange that produced it.
5.2 Organizing tabs
The left pane lists request tabs grouped by collection. Click one to
edit it; New, Dup, and Del manage them; the name and collection fields
rename and group the active tab. Name tabs for the action and account
context (for example GET profile - user A,
PATCH email - user A,
GET invoice 1001 - user B). Organized tabs preserve your
reasoning; hundreds of unnamed tabs guarantee repeated work.
5.3 The message editor and the Inspector
The response view selector switches Highlighted, Raw, Hex, and Rendered. Highlighted is HTTP syntax colouring; Rendered shows an HTML body as readable text (tags dropped, entities decoded, script and style omitted); a non-HTML response says to use another view. The Prettify button re-indents the body itself (JSON, XML, or JS) and leaves the headers intact.
Inspector opens a structured editor over the request: pick a section (headers, query params, cookies, or body params), edit name/value rows with Add, Update, and Remove, then Apply to write the rebuilt request back. Query and body values are shown decoded and re-encoded on Apply; cookies parse out of the Cookie header. This is the structured, parse-aware alternative to editing raw bytes.
5.4 One-variable testing
The strongest manual method is changing one variable at a time. If you change the method, object ID, role field, and cookie at once, you cannot tell which change caused the result.
| Hypothesis | Single change |
|---|---|
| Object ownership is not enforced | Change only the object ID. |
| Method-level authorization differs | Change only GET to PUT or PATCH. |
| Role is trusted from client input | Change only role=user to admin. |
| Content type changes parser | Change only Content-Type. |
| Session is optional | Remove only the session cookie. |
5.5 Authentication versus authorization in the Repeater
The Repeater is ideal for separating the two. First prove who the server thinks you are; then prove what that identity may do. Send the same request three ways: with the owner session, with an attacker session, and with no session. Compare status, length, business fields, error messages, and data visibility. A 200 is not automatically a vulnerability, and a 403 is not automatically safe; the content matters.
5.6 Sessions, cookies, and macros
A session cookie jar persists across sends: cookies set by a login response are replayed on later requests (skipped if you set your own Cookie header). The "Session: N cookies" indicator shows the jar size, and Clear cookies empties it.
Run macro replays the Settings Login config (a request sequence) to
refresh the session and capture its tokens (a fresh CSRF token, a bearer
value), then substitutes them into the current request: a known
{{name}} becomes the captured value, an unknown
{{name}} is left for environment expansion (Volume
III).
5.7 Multipart and protocol notes
For multipart form bodies, MP inspect lists the parts and MP repack rebuilds the body with clean framing. HTTPS requests use HTTP/2 automatically when the server negotiates it via ALPN, and fall back to HTTP/1.1 otherwise. Send group (Volume II) sends a group of tabs together for race testing.
5.8 Repeater checklist
- Resend unchanged first.
- Rename tabs immediately.
- Change one variable at a time.
- Keep separate tabs for separate accounts.
- Compare status, length, headers, body, and timing.
- Move to the Intruder only after the manual hypothesis is clear.
Chapter 6 - Multitool, Comparer, and Sequencer
These workshops rarely find a bug by themselves. They sharpen understanding: the Multitool explains what data means, the Comparer shows what changed, and the Sequencer evaluates whether a token is unpredictable.
6.1 The Multitool (encoding, hashing, JWT)
Type or paste into the input, pick a transform, and press Apply. It covers base64, base64url, URL, hex, and zlib encode/decode, and MD5/SHA digests. Output to input chains transforms. When a value looks opaque, decode it in layers; Smart decode auto-detects and recursively peels an encoding chain (zlib, URL, hex, base64), stopping at plain text, and the status line shows the detected chain.
For tokens, Inspect JWT splits and pretty-prints a token and flags
alg:none and HMAC algorithms; Crack JWT (HS256) recovers
the secret from a wordlist offline; Identify hash guesses a hash type
from its length and charset. The full signed-token workshop (JWT plus
framework cookies) lives in the Tokens popup (Volume IV). Expand tags
evaluates inline transform tags in the input (Volume III).
6.2 The Comparer
Open Comparer, paste any two values into A and B, pick a granularity (Line, Word, or Byte), and press Compare. Word ignores whitespace runs (good for a changed token in a line); Byte hex-dumps the differing bytes (good for binary or near-identical values). Swap exchanges A and B; Clear empties both. It compares arbitrary pasted values, so it is the tool for role-versus-role and baseline-versus-payload comparisons.
The goal is meaningful differences. Timestamps, request IDs, CSRF tokens, and tracking values change constantly and are noise. Role fields, account identifiers, authorization errors, and hidden admin fields are signal.
The Proxy view also has an in-place variant: Pin for diff snapshots a flow's response, and Diff line-diffs another flow against it directly in the response pane (a quick boolean/IDOR signal without leaving the Proxy).
6.3 The Sequencer
Open Sequencer and paste a sample of tokens (one per line). Analyze reports Shannon entropy (bits per byte), the monobit bit balance, a chi-square byte-uniformity statistic, the effective bits per token, and a verdict. Use it on session IDs, CSRF tokens, and password-reset tokens. A token does not need to look random to be safe, and a token that looks random is not automatically safe; the Sequencer gives statistical evidence, not visual intuition. Understand what a token is (it may wrap server-side state or encrypted data) before making a claim.
Chapter 7 - The Scanner, Passive and Active
Use the Scanner as a disciplined assistant, not a substitute for manual testing. Its findings are hypotheses to verify, reproduce, and report in context.
7.1 Passive versus active
Passive checks read traffic that already exists; active checks create
new traffic. In the Target view, enter a seed URL and start a scan.
Passive checks flag missing security headers, weak cookie flags, server
banners, exposed secrets, permissive CORS, and a suspected DOM-based XSS
heuristic (a client-side sink such as innerHTML,
document.write, or eval reading a URL,
referrer, or window.name source in the same statement;
reported tentatively). Passive scanning is safe almost everywhere.
Active scanning needs authorization, scope discipline, and rate
control.
7.2 Feeding the endpoint grid
Populate the grid three ways: Scan crawls from the seed URL; Seed from Proxy folds in browsed proxy history; Import API loads an OpenAPI 3, Swagger 2, or Postman v2.1 definition (JSON), turning each operation into an endpoint (path templates filled, query params and a sample body added). For a definition with relative paths, put the target base URL in the URL field first. Then Ctrl or Shift select rows and right-click Scan this to audit just those endpoints.
Discover brute-forces common paths under the URL-field base
(authorized targets only); found paths join the inventory tagged
discover. It calibrates the not-found response so soft-404
sites are handled, runs in the background, and the button doubles as
Stop disc.
A few more Target-view buttons feed or shape the inventory:
- Fetch spec probes the target for a well-known API spec location and imports what it finds, like Import API without hunting for the file.
- Seed recon loads a recon tool's output file (subfinder or amass hosts, a URL list) and routes its hosts and URLs into the site map.
- Parameters opens the GET/POST values the crawl and its audit carry (a session token, an API key, login fields), refreshed from responses, plus the login URLs POSTed before a crawl.
- DOM probe loads the URL in a headless browser and taint-tracks DOM XSS, client-side prototype pollution, and postMessage sinks (authorized targets only).
7.3 Active checks and insertion points
Active checks are safe by default (reflection probes only). Tick the
Target-view checkbox Aggressive (SQLi/LFI) (mirrored by Aggressive
(SQLi/LFI/cmdi) on the Scan options Scope & crawl tab) to also send
the intrusive probes: error-based, boolean-based, and time-based SQL
injection, time-based OS command injection, and path traversal / LFI
(CLI: fissure scan --aggressive). The time-based probes
make a vulnerable target pause a few seconds.
Probes target a unified set of insertion points: query parameters,
id-like path segments (for example the 1234 in
/api/orders/1234), multipart form fields, JSON body fields
(captured from the proxy and fuzzed leaf by leaf), and request headers
and cookies (X-Forwarded-For, Referer,
User-Agent, and each cookie value). A GraphQL request also
gets a GraphQL check: introspection detection, per-argument fuzzing, and
(aggressive) an unbounded-query-batching probe.
The best results come from choosing insertion points intentionally. When testing a suspected JSON injection, auditing only JSON values is more productive than attacking every header and cookie.
7.4 Scan options
The Scan options button in the Target view opens a popup that tunes the next scan across four tabs. In a group of boxes, leaving every box ticked (or clearing all of them) runs all of it. Apply keeps the choices; Close leaves.
- Scope & crawl: the Active checks and Aggressive (SQLi/LFI/cmdi) switches, crawling client-side (SPA) routes with a headless browser, exercising the target's own settings forms and switch links (off by default, so a crawl does not reconfigure the target), Crawl depth and Crawl pages, Exclude paths, and extra Seed URLs.
- Rate & timing: Rate (req/s/host), Time budget (s), Threads, Host backoff, Delay (ms), and Timing probes/host, plus the detection-timing block for the time-based and out-of-band oracles (Sleep, Timeout pad, Reconfirm needed and max, OAST wait, Retry backoff; blank means default, and Reset timing to defaults restores them).
- WAF bypass: the WAF-bypass encoders list and the body variants (JSON operators, XML for XXE, XML as UTF-16), plus Extra request headers sent with every scan request. Input-filter bypass is for authorized, in-scope targets only.
- Checks: the check families and insertion points the scan runs, with All and None to tick or clear the whole set at once.
The scan-profile picker beside it applies a saved selection, and Save stores the current options as a named profile.
7.5 Running a scan safely
The scan runs in the background across your CPU cores, so the UI stays responsive; the Scan button becomes Stop scan while it runs. A live status line and progress bar show activity (endpoint and audit counts when known, an animated spinner during the crawl when no count is). A Pause button holds progress and becomes Resume; already-running requests finish, and Stop scan still works while paused.
Quick scan runs the low-hanging-fruit profile (a shallow crawl plus
the passive and safe active checks), fast and low-noise for a first pass
(CLI: fissure scan --quick).
State changes matter even when the payload is harmless. A POST to
/transfer, /send-email, or
/delete-account remains dangerous even if the payload is
only a quote character. Exclude or manually handle destructive
endpoints.
7.6 Authenticated scanning
Most valuable vulnerabilities live behind authentication. Set a Login
config (a JSON login sequence) in Settings; before each scan Fissure
replays it to establish a session (including a CSRF-token login: GET the
page, extract the token, POST the credentials), then sends every scan
request with that session. A failed login pops up a notice. See
resources/login/README.md for the format. For long runs,
session-handling rules (Volume III) keep the session valid.
7.7 The Dashboard and reading findings
The Dashboard is the recon overview: endpoints, hosts, the scope split, scan throughput, and a severity chart. Review it in cycles: look at new findings, open the evidence, send the original request to the Repeater, reproduce manually, and adjust scope or checks if noise is high.
Each finding carries a severity and a confidence. Severity estimates impact; confidence estimates how strongly the evidence supports the issue. A low-confidence issue can still be real; a high-confidence issue can still be irrelevant if the endpoint is out of scope or protected by other controls. Always inspect the evidence before reporting.
Chapter 8 - Professional Workflow, Findings, and Evidence
Tools are only useful when they support a method. The Fissure operating loop: define scope and accounts, build a clean browser profile, explore manually, organize traffic, test hypotheses, collect evidence, write report-shaped notes, and retest the fix.
8.1 Projects
Open Project from the toolbar to keep engagements apart. Each project stores its own traffic history, match-and-replace rules, Organizer queue, environments, Repeater collections, findings, endpoint inventory, and attack configs, all reloaded on switch and at startup. Settings, layout, shortcuts, inline tags, HaE rules, and the proxy CA stay global. Create names and switches to a new project; Switch changes the active one live; Duplicate makes a backup you can Switch to; Delete removes a non-active project. Do not mix unrelated engagements in one project: old traffic pollutes search, findings, and mental context.
8.2 Findings triage
Select a finding and use the triage bar: the Triage button cycles its state (open, confirmed, false-positive, ignored), and the notes and tags fields annotate it; all three are saved with the session. Highlight cycles a manual row color that paints the row. The filter bar narrows the grid by a text search (title, location, category, tags, notes), a triage-state cycle (Status), a minimum-severity cycle (Min sev), and a scope cycle (Scope: all, in, or out); the status line shows how many of the total findings are shown.
8.3 Group actions
Build a selection by clicking in the grid: a plain click selects one
row, Ctrl-click toggles a row, and Shift-click selects a range; selected
rows are highlighted and marked [x] in the leading column.
Sel toggles the focused row, All selects everything matching the filter,
and None clears it. Then act on the group: Triage sel applies the
focused finding's triage to all selected, Highlight cycles the color
over the whole selection, Tag sel appends a tag to each, Note sel
appends the Notes-box text as a new line to each, Send to Repeater opens
each selected finding as its own tab, To Organizer stashes them, and
Push to PwnDoc pushes the selection. Right-clicking inside the selection
raises the request actions over every selected finding at once. Delete
sel and Clear all both confirm first and persist, so a restart keeps the
cleared state.
With several findings selected, the
< Prev | k / N | Next > row above the detail pane
steps the detail view through them one at a time; the current one is
marked [>] in the grid.
8.4 Evidence discipline
Good evidence is reproducible. A screenshot without the request and response is weak; a clear request, response, timestamp, account context, and reproduction steps are strong. Fissure links findings to the captured request/response pair that produced them, persisted with the session and resolved at render time, so Send to Repeater always brings back the exact exchange. Do not overcollect secrets: evidence is redacted by default in the report (Volume VI).
Write report-shaped notes while testing, not after. A useful finding note records the title, affected endpoint, role used, preconditions, original and modified requests, observed versus expected behavior, impact, evidence, and reproduction steps.
8.5 The report
The Report view previews and exports the consolidated report, which
aggregates, deduplicates, and groups findings. Export as Markdown, HTML,
JSON, CSV, SARIF (CI code-scanning), or issue XML compatible with a
mainstream web-security suite (which imports findings back into that
suite). PDF export runs an external generator you name in Settings (for
example wkhtmltopdf {{in}} {{out}}); it is disabled when no
command is set. Each finding's triage state, notes, and tags are
included, and the FP/ignored toggle (CLI:
--exclude-triaged) drops false-positive and ignored
findings. The Show: Source / Show: Rendered toggle switches the preview
between the raw report text and its rendering: Markdown renders in the
view, while HTML and PDF open in your web browser exactly as they will
be delivered.
Headless, fissure scan and fissure report
run the same pipeline for CI (Volume V and VI).
Chapter 9 - The Universal Query Language
By the time an engagement warms up you have thousands of flows and
dozens of findings. Scrolling is not triage. Fissure gives you one
boolean query dialect (an HTTPQL-style filter language) that reads the
same everywhere: the filter box over the Proxy, Logger, Findings, and
Target grids, the Global Search popup, and the headless
/api/query route. Learn it once and every grid becomes
searchable.
9.1 One dialect, many grids
The filter box over each grid doubles as a query box. Type a plain
word and it matches loosely (a substring across the visible columns);
type a valid query and the box switches to query mode, and the grid's
status line appends (query) so you know it parsed. An empty
box matches everything. If a query fails to compile it simply falls back
to substring matching, so you cannot break the grid by typing.
The engine underneath is the shared boolean parser; this module only
supplies the HTTP field names, so status >= 400 or
method = POST means the same thing in the Logger, the
Findings grid, the Global Search popup, and over the control API.
9.2 Fields and operators
A query is a set of FIELD OP VALUE comparisons joined by
AND, OR, and NOT
(case-insensitive keywords), with parentheses for grouping. A VALUE is a
bareword (a run of non-space characters) or a double-quoted string.
The operators:
| Operator | Meaning |
|---|---|
= |
case-insensitive string equals |
!= |
case-insensitive string not-equals |
~ |
case-insensitive contains (substring) |
!~ |
does not contain |
=~ |
regex match (PCRE) |
> < >= <= |
numeric comparison (both sides parsed as numbers) |
The fields depend on the record being filtered:
- Traffic (Proxy, Logger, Target, Global Search):
tool,method,url,host,path,mime,status,length(response bytes),time(elapsed ms), andscope(inoroutof the active scope). - Findings (Findings grid, Global Search):
title,severity,location,category,host,cwe,owasp,confidence,source,triage,tags, andscope. - WebSocket frames (the WebSocket view, StreamQL):
dir(c2s/s2c),opcode(text/binary/ping/pong/close/cont/other),fin,length,seq,payload,url,host, andscope.
Numeric fields are stored as text but the numeric operators parse
both sides as numbers, so status >= 400 and
length > 100000 work as you expect. The
scope field is evaluated against whichever named scope is
active (Chapter 10), so scope = in follows a scope switch
automatically.
9.3 Writing a query
Some queries you will reach for constantly:
status >= 400 AND scope = in in-scope errors only
method = POST AND mime ~ json JSON-bodied POSTs (state changes)
host ~ api AND NOT path ~ /health API traffic, minus health checks
url =~ /admin/.*\.(php|jsp)$ admin scripts by regex
severity = high OR severity = critical the findings worth reading first
category ~ xss AND triage = open open XSS findings, not yet triaged
tags ~ interesting AND scope = in HaE-tagged flows in scope
Build them incrementally: start with one comparison, confirm the
count on the status line, then add AND/NOT
clauses to carve away noise. The plain grid filters (the Status and
Scope cycle buttons, the Logger's tool selector) still apply on top of
the query, so a query and the cycle buttons combine with AND.
9.4 The per-grid query box
Every grid that has a filter bar accepts a query. The placeholder
tells you so (for example the Logger shows
substring, or a query: status >= 500 AND scope = in).
Use the per-grid box to narrow the grid you are already in: filter the
Proxy history to one host's JSON POSTs, filter the Findings grid to open
highs, or filter the Target endpoint grid to a route family. Because it
is the same language on each grid, a query you wrote on the Proxy pastes
straight into the Findings box and keeps meaning.
9.5 The Global Search popup
Where a per-grid box searches one grid, Global Search runs one query
across captured traffic AND findings at once. Open it from the Analysis
& inspection toolbar category (the Search entry) or the command
palette. Type a query into the box (the placeholder lists the fields you
can use:
host, method, path, url, status, mime, body (mentioning body searches response bodies), e.g. body contains "api_key"),
press Search, and the results grid fills with the matching flows and
findings together. Results are capped; when you hit the cap the status
line says so and you refine the query to narrow it. Use Global Search
when you remember a detail but not where you saw it: a status code, a
header value, a CWE.
9.6 Saved filters
A query you will run again is worth naming. In the Global Search
popup, press Save and give the current query a name; it is stored in
queries.json and survives a restart. Load cycles the saved
filters back into the query box one at a time (the status line shows
which one and how many there are), so you press Load until your filter
appears, then Search. Saved filters are shared over the control API
(/api/queries), so an agent driving Fissure headless reuses
the same named filters you built in the GUI. Keep a small library of
engagement queries: in-scope errors, unauthenticated 200s, open highs.
Triage becomes a click instead of a retype.
You do not start from nothing: on first run the store is seeded with
a shipped starter library (in scope, the 3xx/4xx/5xx status classes,
state-changing requests, JSON responses, JavaScript, admin/debug and API
paths, large responses), so pressing Load cycles through useful filters
immediately. Editing or deleting them never brings the defaults back;
when you want them again, press Reset to defaults (or send
{"op":"reset"} to POST /api/queries /
saved_queries_op("reset") headless) to restore the shipped
set. A default only appears when you have no queries.json
yet, so it never overwrites the filters you have saved.
9.7 Query checklist
- Confirm the box is in query mode (the status line shows
(query)). - Start with one comparison, watch the count, then add clauses.
- Use
scope = into drop third-party noise in one clause. - Use
=~for regex only when~(contains) is not selective enough. - Save the queries you retype; they carry to Global Search and to agents.
Chapter 10 - Named Scopes and the Shared Cookie Jar
Chapter 2.4 and section 4.4 defined the base scope: one in/out allowlist that every active tool obeys. Two related stores extend that idea: named scopes let one project hold several whole scopes and flip between them, and the suite-wide Cookie jar is the single session store every tool shares. Both live in popups and both persist per project.
10.1 Why named scopes
A real engagement often spans segmented targets: a production origin,
a staging origin, an API-only host set. You do not want to retype in/out
patterns each time you move between them, and you do not want staging
patterns leaking into a production scan. A named scope is a complete
saved in/out pattern list with a name (for example Production, Staging,
API only). Exactly one named scope is active at a time, and the active
one drives the single enforced scope everywhere: scanning, fuzzing, MITM
interception, and the scope field in the query language.
Switching the active scope re-points the whole app at once.
10.2 Managing named scopes in the Scope popup
Open the Scope editor from the Capture toolbar category (the Scope entry), the Proxy capture-list Edit scope button, the Target view, or the command palette. The top row is the named-scope selector: a dropdown of your scopes flanked by New, Rename, and Del.
- New prompts for a name, creates an empty scope, and makes it active.
- Selecting a different scope in the dropdown saves your current edits into the scope you are leaving, then loads the chosen scope into the editor and enforces it immediately.
- Rename renames the active scope.
- Del deletes the active scope after a confirmation that names it; the next scope becomes active. At least one scope is always kept (a Default is recreated if you delete the last one).
Below the selector, the In-scope and Out-of-scope tabs edit the
active scope's pattern rows (one pattern per row, a plus to add and an x
to delete, the same patterns as section 4.4: an exact host, a
.suffix, re:<regex>, *,
each with an optional :port). Save writes both lists into
the active named scope and enforces them. The set persists to
<project>/scopes.json; an older single scope migrates
into a Default named scope the first time.
Worked example: create a Production scope with
.example.com in scope and the payment CDN out of scope;
create a Staging scope with .staging.example.com; then flip
the dropdown between them before each pass. A scan launched under
Staging can never reach production, because the one enforced scope
followed the switch.
10.3 The suite-wide Cookie jar
Fissure keeps one shared cookie store that the Repeater, the scanner, and manual sends all consult. A cookie captured by one tool is reused by the others, and the engine sends matching cookies and absorbs Set-Cookie automatically, domain, path, and secure aware. This is the same jar the Repeater's "Session: N cookies" indicator and Clear button act on (section 5.6); the Cookie jar popup is its editable, persistent face.
Open the Cookie jar popup from the Auth & session toolbar
category or the command palette. The grid lists the cookies currently in
the jar (what a scan or a chained request will send). To add or replace
one, fill name, value, and domain (path defaults to /) and
press Set. Refresh reloads the list, which also updates as the engine
sends and receives cookies during work. Clear empties the whole jar
behind a confirmation, because every tool loses the current session
cookies when you do. The jar persists to
<config>/cookiejar.json, so a session survives a
restart.
Reach for the Cookie jar popup to pre-seed a session cookie you
obtained out of band (paste it in before a scan so the crawl runs
authenticated), to inspect exactly what a chained request will carry, or
to drop a stale session that is causing 401s. The same store is driven
headless over /api/cookiejar and the cookiejar
MCP tool, so an agent shares the session you set here.
Chapter 11 - JavaScript-Rendered Discovery
The static crawler of Chapter 7 follows hrefs and mines JavaScript text for URL tokens. That misses what a single-page application only builds at runtime: routes assembled in the browser, and the XHR/fetch endpoints the app calls after it loads. The Target view offers two JS-rendering discovery passes that drive a real browser and feed whatever they find into the same site map. Run them after the static Scan and Seed from Proxy, to catch the surface the static pass could not see.
11.1 SPA crawl (native, no external tool)
The SPA crawl button drives a headless Chromium over the Chrome DevTools Protocol to interact with the page the way a user would: it follows client-side router links, clicks buttons, submits forms, and captures the XHR and fetch endpoints the app calls at runtime, feeding them into the site map. It needs no external tool, only a Chromium or Chrome (the bundled Fissure Browser satisfies this). It runs on a worker thread; the button relabels to Stop SPA crawl and cancels in process. The crawl de-duplicates by application state and is bounded by state, interaction, and time caps so it cannot run forever. It is scope-gated like every active tool.
Use SPA crawl for a modern framework app (React, Vue, Angular) where
the interesting endpoints are all fetch calls that never
appear as an href.
11.2 Headless crawl (katana)
The Headless crawl button runs the external katana crawler with a system Chromium so JS-rendered routes enter the site map. It runs on a worker thread and is capped at depth 2 and a 180-second duration so it cannot run indefinitely; the button reads Stop crawling while it runs and clicking it stops early, killing the katana and Chromium process group and keeping whatever it found so far. It is scope-gated and is skipped with an on-screen notice when katana is not installed. An outcome popup reports what was added.
Use Headless crawl when katana is installed and you want its link-following headless coverage as a second opinion alongside the native SPA crawl.
11.3 Which to use
Both feed the same site map, so running one does not preclude the other.
- SPA crawl is native (no install), interaction-driven (it clicks and submits), and best at capturing the runtime XHR/fetch calls of a heavy SPA.
- Headless crawl (katana) is an external, link-following headless crawl, useful when you already run katana and want its breadth.
A good sequence: Scan (static) to get the obvious surface, Seed from Proxy to fold in what you browsed, then SPA crawl (and Headless crawl if katana is present) to add the runtime-only endpoints. Review the new rows in the endpoint grid, then scan the ones worth auditing with Scan this.
Chapter 12 - WAF and CDN Basics
Most real targets sit behind a WAF or CDN. Three foundational capabilities help you understand that layer and, when a genuine authorized bug is blocked, show it is still exploitable. Two of them (the fingerprint and origin-IP discovery) are pure recon, run from the Probes popup or headless; the third (the input-filter bypass encoders) is a GUI transform and carries an enforced code-of-conduct notice. Scan-time WAF-bypass options belong to Volume VI; here you learn the manual building blocks.
12.1 WAF/CDN fingerprint
Before you plan anything, learn what is in front of the application.
The WAF/CDN fingerprint (a wafw00f-class check) matches a target's
response headers, cookies, and block-page body against a signature table
covering Cloudflare, Akamai, AWS CloudFront and WAF, Imperva Incapsula,
F5 BIG-IP ASM, ModSecurity, Sucuri, Fastly, Citrix NetScaler, Fortinet
FortiWeb, Barracuda, and others. It is pure recon: it inspects a
response, it does not attack or evade. In the GUI, open Probes (Recon
& infra category), enter the Target URL, and press Detect WAF; the
result shows in the output pane. Headless, it is reached over the
control API (POST /api/wafdetect, either fetching a URL or
scanning a supplied header block), the wafdetect MCP tool,
and the bug-bounty skill. Its result informs the next two sections:
which product you are up against, whether reaching the origin directly
is worth trying, and which encoders a filter is likely to miss.
12.2 Origin-IP discovery
A CDN or WAF only protects the traffic that goes through it. If the
origin server is reachable directly, you can test it without the CDN's
filtering, rate limiting, and caching in the way. Origin-IP discovery
confirms which candidate IPs are the real origin: for each candidate
(produced by recon such as historical DNS, an ASN/CIDR sweep, or
resolved subdomains) Fissure connects straight to the IP while sending
the target's Host header (a per-host connect rewrite), and flags a
candidate that serves the site (a 2xx with a substantial body) as a
likely origin reachable behind the CDN. Candidate generation is the
recon side; Fissure does the confirmation. In the GUI, open Probes,
enter the Target URL and the Candidate addresses (comma or space
separated), and press Find origin IP. Headless, it is driven over
POST /api/originip and the originip MCP tool
(CWE-200). Feed it the candidates your recon produced; a confirmed
origin lets you point the Repeater and scanner at the real server.
12.3 Input-filter bypass transforms in the Multitool
A WAF is a mitigation, not a fix. When a real, authorized, in-scope vulnerability exists but the canonical payload is blocked, you must demonstrate the underlying bug is still exploitable, and that is exactly (and only) what these transforms are for. Fissure adds nothing to conceal, delay, or misattribute your activity; the encoders defeat a blocking input filter to prove a bug, nothing more.
In the Multitool, four WAF-bypass encoders sit in the transform selector like any other encoder:
- WAF bypass: alternating case (defeats keyword filters that match a fixed case).
- WAF bypass: space to comment (replaces spaces with an empty inline comment).
- WAF bypass: double URL-encode (percent-encodes twice).
- WAF bypass: JSON body padding (a nowafpls-style padding key that pushes the real payload past a WAF's body-inspection window).
Type or paste the payload, pick one of these transforms, and press Apply. Because these bypass a protective control, applying one first shows the shared OK-only code-of-conduct dialog (the authorized-use-only notice) and records the use in the Event log, then performs the transform. The notice is acknowledged, not blocking: it informs, it does not stop you. Chain encoders with Output to input to stack, for example, alternating case then double URL-encode.
Headless, the same encoders (and a larger set) are available as a
comma-separated chain over POST /api/wafbypass and the
wafbypass MCP tool: case,
space2comment, space2plus,
space2tab, space2hash,
space2dash, space2randomblank,
multiplespaces, randomcomment,
commentbeforeparentheses, percentage,
apostrophemask, overlongutf8,
url, urlall, url2x,
jsonpad, jsonunicode, xmlbypass,
utf16, versionedkeywords,
nonrecursivereplacement, symboliclogical,
equaltolike, and charunicodeurlencode. The
same code-of-conduct notice is returned by the route.
12.4 One-click WAF-bypass retry
To test the encoding against the live target instead of by hand,
right-click a request in the Proxy, Findings, or Target grid and choose
WAF-bypass retry. It resends the request as-is, then again with the
encoder chain applied to its query string and body, and shows the
original-versus-bypassed status and length so you can see whether the
block lifted. It needs aggressive mode and an in-scope URL, runs off the
UI thread, and surfaces the same code-of-conduct notice first. Headless
parity is POST /api/wafbypass/resend and the
wafbypass_resend MCP tool (returning original, bypassed,
changed, and the notice).
Worked example: the fingerprint reports Cloudflare; your
' OR 1=1-- - payload returns 403; WAF-bypass retry resends
it alternating-cased and double-encoded and the response becomes a 200
with the injected result. You have shown the SQL injection is
exploitable behind the WAF, which is the finding, not the WAF
itself.
Chapter 13 - Structural Decoders in the Multitool
Chapter 6 covered the Multitool's encoders, hashes, and JWT tools. Two more transforms reveal structure rather than change an encoding: they turn opaque or minified bytes into something you can read.
13.1 Protobuf and gRPC decode
Protocol Buffers and gRPC carry their payloads as compact binary that
looks like noise in a hex view. The Protobuf/gRPC decode transform
parses the wire bytes into a readable field tree (field numbers, wire
types, and values) with no .proto schema required. It is
one-way (a decode; there is no re-encode), which is exactly what you
want for reading a captured body.
Because the transform expects raw bytes, decode any transport
encoding first and chain: if a gRPC-Web body arrives base64, run Base64
decode, press Output to input, then Protobuf/gRPC decode. The field tree
shows you which field numbers carry the identifiers and values you might
want to tamper with when you move the request to the Repeater. Headless,
the same decode is POST /api/protobuf.
13.2 Prettify (JSON, XML, JS, CSS)
Minified JSON, single-line XML, and packed JavaScript or CSS are hard
to reason about. The Prettify transform beautifies and re-indents them:
it auto-detects JSON (re-indented structurally), XML/HTML, and JS/CSS,
and passes text it does not recognize through unchanged, so it is safe
to run on anything. Paste a minified body, press Apply, and read the
result. This is the same beautifier the Repeater's Prettify button uses
(section 5.3), which re-indents only the body and leaves the headers
intact; the Multitool transform is the standalone form for any pasted
text. Headless, it is POST /api/prettify.
Reach for Prettify whenever a response body is one long line: a minified API response, a compacted config, an inlined script you want to skim for a client-side sink before sending it to the DOM tools of Volume VI.
Chapter 14 - Observability: the Event Log and Jobs Monitor
As work moves into the background (concurrent scans, on-demand checks, agent-driven runs over the control API), you need to see what Fissure is doing. Two panels give you that visibility: a chronological Event log of what happened, and a live Jobs monitor of what is running. (Running work on a timer is the Schedules panel, an automation feature taught in Volume III, Chapter 9.)
14.1 The Event log
The Event log is a chronological, in-memory panel of engine events and errors: the app starting, out-of-scope refusals, every message surfaced to you through the shared info/error dialog, and each job's lifecycle (started, queued, done with its finding count, cancelled, error). Entries are newest first and tagged with a source and a level (info, notice, warn, error). It is distinct from the traffic Logger, which records HTTP exchanges; the Event log records what the tool did, so a blockage is not lost when its popup is dismissed. Open it from the Event log entry in the Analysis & inspection toolbar category or the command palette; Refresh reloads and Clear empties it. This is where out-of-scope refusals and the WAF-bypass code-of-conduct notice are recorded, so it is the place to confirm why an action was blocked or what a warning said.
14.2 The Jobs monitor
The Jobs monitor is a self-refreshing grid of every job Fissure is
running, scans and on-demand checks alike: kind, name, target, status,
and elapsed time, with running/queued/total counts. Open it from the
Jobs entry in the Results toolbar category or the command palette; it
refreshes itself every few seconds. Each row has Cancel, and the bar has
Cancel all and Clear done (which drops finished done/error/cancelled
jobs while keeping live work). Your own Target-view scans register here
as jobs, alongside any scan or check an agent starts over the control
API or MCP, so the operator and the agent watch and cancel from one
list. A concurrency cap (the control_api_max_jobs setting,
default 4) bounds how many run at once; the rest queue and are promoted
as slots free. Use the monitor to watch progress, to cancel a stalled
job, and to prune the list between passes.
14.3 Recurring scans (the Schedules panel)
To run a scan on a timer instead of by hand, Fissure has a Schedules panel: a saved scan (target, optional profile, active/aggressive flags) that recurs on an interval, fired by a scheduler thread in the control server. Because recurring scans are an automation feature, they are taught in full in Volume III, Chapter 9 (defining a schedule, Run now, and the control-API-enabled requirement). The one thing to know here: schedules only fire while the control API is enabled in Settings.
14.4 Observability checklist
- When an action is refused or a warning flashes, open the Event log to read why.
- Watch the Jobs monitor during a scan; cancel a stalled job from there.
- Clear done between passes so the Jobs grid shows only live work.
- For scans on a cadence, use the Schedules panel (Volume III, Chapter 9) and enable the control API first.
Chapter 15 - Volume I Capstone Lab
Use a legal training application. This capstone exercises the whole volume: the core manual workflow of Chapters 1 to 8 and the foundational subsystems of Chapters 9 to 14.
- Build a clean browser profile, install the Fissure CA, and confirm HTTPS interception.
- Create a fresh project, then in the Scope popup create two named scopes (for example App and Staging) and make the app scope active, excluding third-party hosts.
- Browse anonymously and map public endpoints in the Target view.
- Run an SPA crawl (and a Headless crawl if katana is installed) and confirm new runtime-only endpoints entered the site map.
- Use two accounts and browse authenticated areas; pre-seed one session in the Cookie jar popup and confirm the jar count.
- In the Proxy grid, write a query such as
method = POST AND scope = into isolate in-scope state changes, then save it as a named filter. - Send three interesting requests to the Repeater and name the tabs.
- Use the Multitool to decode any encoded value you find; if a body is minified or binary, Prettify it or run Protobuf/gRPC decode.
- Use the Comparer to compare two role-based responses.
- Run a Quick scan; watch it in the Jobs monitor and review the Dashboard and Findings.
- Run one narrow active audit with Scan this against a non-destructive endpoint.
- In Global Search, run
severity = high OR severity = criticalacross traffic and findings, and check the Event log for any out-of-scope refusals. - Write one report-shaped finding note, even if the issue is a false positive.