Fissuredocumentation v5.3.1
On this page

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:

  1. Open Settings and note the proxy port (the Proxy binds 127.0.0.1).
  2. Point your testing browser at 127.0.0.1 on that port for HTTP and HTTPS. Add localhost, 127.0.0.1, ::1 to the browser's no-proxy list.
  3. In the Proxy view, start the proxy.
  4. In Settings, export the CA certificate.
  5. Import that CA into the testing browser profile as a trusted authority for identifying websites.
  6. 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), and scope (in or out of the active scope).
  • Findings (Findings grid, Global Search): title, severity, location, category, host, cwe, owasp, confidence, source, triage, tags, and scope.
  • WebSocket frames (the WebSocket view, StreamQL): dir (c2s / s2c), opcode (text/binary/ping/pong/close/cont/other), fin, length, seq, payload, url, host, and scope.

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 = in to 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 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.

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.

  1. Build a clean browser profile, install the Fissure CA, and confirm HTTPS interception.
  2. 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.
  3. Browse anonymously and map public endpoints in the Target view.
  4. Run an SPA crawl (and a Headless crawl if katana is installed) and confirm new runtime-only endpoints entered the site map.
  5. Use two accounts and browse authenticated areas; pre-seed one session in the Cookie jar popup and confirm the jar count.
  6. In the Proxy grid, write a query such as method = POST AND scope = in to isolate in-scope state changes, then save it as a named filter.
  7. Send three interesting requests to the Repeater and name the tabs.
  8. Use the Multitool to decode any encoded value you find; if a body is minified or binary, Prettify it or run Protobuf/gRPC decode.
  9. Use the Comparer to compare two role-based responses.
  10. Run a Quick scan; watch it in the Jobs monitor and review the Dashboard and Findings.
  11. Run one narrow active audit with Scan this against a non-destructive endpoint.
  12. In Global Search, run severity = high OR severity = critical across traffic and findings, and check the Event log for any out-of-scope refusals.
  13. Write one report-shaped finding note, even if the issue is a false positive.