Fissuredocumentation v5.3.1
On this page

Fissure reporting

The reporting subsystem turns a finished (or in-progress) scan session into a single consolidated, human- and machine-readable report. It is the last stage of the pipeline drawn in 02_ARCHITECTURE.md section 6: the proxy, the website scanner, and the OSS-tool plugins all write FISSURE_FINDING records into the session store, and the report renders the whole store. Nothing in a report comes from outside the saved session, so any report is reproducible from the NDJSON session file alone. The exchanges that back the findings (the captures a finding references through request_ref / response_ref) are archived next to the session in a ".captures" sibling file (fissure_session_save_captures / fissure_session_load_captures); it is optional, so the findings file stays standalone-valid and a report still renders, without resolvable evidence excerpts, when the sibling is absent.

This document expands 02_ARCHITECTURE.md step 7. It depends on the finding model (FISSURE_FINDING, fissure_finding.h), the findings store (FISSURE_FINDINGS, fissure_findings.h) and the capture store, and on the nilorea string and JSON primitives catalogued in audits/NILOREA_AUDIT.md (n_str / nstrprintf, n_str_template_expand, vendored cJSON, n_files).

Implementation lives in fissure_report.c/.h (aggregation + renderers), with finding-level helpers in fissure_finding.c/.h, the in-memory store in fissure_findings.c/.h, and session persistence (NDJSON findings + the captures sibling) in fissure_session.c/.h.

1. Purpose

One report aggregates EVERY finding produced during a scan session, regardless of where it came from:

  • FISSURE_SRC_PROXY - passive observations from MITM traffic (missing security headers, secrets in responses, mixed content, insecure cookies).
  • FISSURE_SRC_SCANNER - results from the built-in checks (reflected XSS probe, SQLi error probe, TLS config, directory listing; see 05_WEBSITE_SCANNER.md).
  • FISSURE_SRC_PLUGIN - external OSS tools (nuclei, ffuf, sqlmap, nikto, ...) whose output the plugin host normalized into the unified model (02_ARCHITECTURE.md section 4, 01_SECURITY_TOOLS_CATALOG.md).
  • FISSURE_SRC_MANUAL - analyst-entered findings.

Because all four sources land in the same FISSURE_FINDING shape, the report does not special-case producers. A new finding source needs zero report changes.

2. Aggregation and scoring

Collection

The report operates on one findings store (FISSURE_FINDINGS*), the live one in the GUI and fissure scan, or one reloaded from a saved NDJSON session by fissure_session_load in headless mode. It does not query the proxy or scanner. fissure_report_model_new (or fissure_report_model_new_filtered) snapshots the store into a transient FISSURE_REPORT_MODEL (owned by the caller, freed with fissure_report_model_free after render); a capture store can be attached with fissure_report_model_set_captures to resolve evidence (section 6).

Deduplication

Findings are deduplicated on the key every finding carries from construction (fin_build_dedup_key in fissure_finding.c):

dedup_key = host | category | title | location   (per-URL findings)
dedup_key = host | category | title              (host-level findings)

where host is parsed from the finding's location and location is the raw location string the producer passed (not canonicalized). A producer that wants per-parameter findings puts the parameter into the location or title.

A finding created with fissure_finding_new_host (rather than fissure_finding_new) omits the location from its key, so a site-wide server misconfiguration collapses to one finding per host instead of one per URL crawled. The native passive misconfiguration checks (a disclosed Server / X-Powered-By banner, a missing Content-Security-Policy / X-Frame-Options / X-Content-Type-Options / Referrer-Policy / HSTS header, a cookie-attribute gap) are host-level: they reflect the server or site configuration, identical on every page, so reporting them once per crawled URL is noise. Per-page findings (a reflected XSS on one endpoint, a DOM sink in one script, an exposed phpinfo() page) stay per-URL. The finding still records the first URL where it was seen as its location. Dedup happens once, when a finding enters the store: fissure_findings_add looks the key up in the store's by_dedup HASH_TABLE and, when a finding with that key already exists, keeps the FIRST one and frees the newcomer. There is no merge: the kept finding's severity, confidence, evidence and source_tool are not combined with the duplicate's. The report does not re-dedup; it renders the store as is.

Whether a finding is host-level is part of its identity, not a property of how it was produced, so it is stored on the finding (host_scoped) and persisted in the session file. Rebuilding a finding without it produces a per-URL key that no longer matches the original: merging a just-saved session back into the live store then duplicated every host-level finding instead of collapsing it, and a reloaded host-level finding stopped collapsing across URLs. A session written before the flag existed simply has no host_scoped key; those findings rebuild per-URL, exactly as they always did, so an existing file still loads.

The report model

FISSURE_REPORT_MODEL (fissure_report.h) holds:

Field Meaning
title, generated_iso report title and generation timestamp
sorted, count borrowed findings array in render order, and its length
by_severity[5] count per FISSURE_SEVERITY index
risk_score bounded session risk score in [0, 100]
redact 1 = redact secrets in evidence (default)
captures borrowed capture store backing the findings, or NULL
tool_versions probed external-tool versions (FISSURE_REPORT_TOOL), or NULL

The render order is severity descending, then confidence descending, then title ascending. There are no per-host, per-OWASP or per-tool groupings; every renderer walks sorted once.

Severity model

FISSURE_SEVERITY (defined in 02_ARCHITECTURE.md section 5):

Enum Label Default weight
FISSURE_SEV_CRITICAL Critical 10.0
FISSURE_SEV_HIGH High 7.5
FISSURE_SEV_MEDIUM Medium 5.0
FISSURE_SEV_LOW Low 2.5
FISSURE_SEV_INFO Info 0.0

FISSURE_CONFIDENCE (Tentative / Firm / Certain) scales the contribution so unverified findings do not dominate: 0.5 / 0.8 / 1.0.

Risk score

There is no CVSS input: the score is derived only from each finding's severity weight (sev_weight, the table above) and confidence factor (conf_factor). The per-session risk score is a bounded weighted aggregate, not a raw sum, so a flood of Info findings cannot inflate it. risk_combine in fissure_report.c folds each finding into a saturating residual:

/* per finding: */
impact   = (sev_weight(f->severity) / 10.0) * conf_factor(f->confidence);
residual = residual * (1.0 - 0.5 * impact);
/* after all findings, starting from residual = 1.0: */
score    = (1.0 - residual) * 100.0;

The score approaches 100 as critical/high findings accumulate but never exceeds it. fissure_report_risk_band labels it: 0-19 Minimal, 20-39 Low, 40-59 Moderate, 60-79 High, 80-100 Severe.

Counts and executive summary

The model precomputes the total finding count and the count per severity. These feed the executive-summary table together with the risk score and band.

3. Report sections

The HTML and Markdown reports render the same four sections (Markdown in fissure_report_markdown, HTML in fissure_report_html); JSON carries the same data as keys, and SARIF / CSV / Issue XML are flat per-finding exports.

  1. Header: the report title, the generation timestamp and the Fissure version, and, when requested, the versions of the external tools used. Each manifest carries a version_args list (see 02_ARCHITECTURE.md section 4); fissure scan/fissure report --tool-versions probes each installed tool (fissure_plugin_probe_version, a short-lived subprocess with a bounded timeout) and records {tool, version} on the model (fissure_report_model_add_tool_version). The markdown, JSON, and HTML renderers list them under a Tools section / tools array; CSV, SARIF and Issue XML omit them.

  2. Executive summary: the risk score with its band, and a severity-count table (Critical, High, Medium, Low, Info, Total).

  3. Tools: emitted only when tool versions were probed (--tool-versions).

  4. Findings: one block per finding in model order ("No findings." when empty). In the Markdown renderer consecutive blocks are parted by a --- thematic break, so a long report reads as distinct findings rather than one unbroken run of sections. Each block: title; severity, confidence, source and source tool; triage state; category, CWE and OWASP; location; tags; description; evidence; remediation (the finding's own, else the built-in remediation library entry for its CWE/category, fissure_remediation_lookup); references (from that library entry); analyst notes. Evidence resolution (fissure_report_finding_evidence) prefers the finding's own inline evidence string, the concrete proof of that specific issue (the reflected payload, the disclosed banner value, the exact missing header, the boolean true/false pair, the OAST callback line), which every native check sets. Only when a finding carries no inline evidence does the report fall back to reconstructing its captured request/response excerpt (redacted and truncated per section 6). So evidence is consistently the concise thing a triager needs, not a full response body dumped once per finding; native checks never fall through to the capture dump.

    A captured request is the request Fissure SENT, not the one the client wrote. The proxy rewrites requests on the way out (match/replace rules, the PwnFox identity strip, OAST canary injection, extension request hooks) and on the plain path also rewrites the head to origin form, which is literally what the server received. Recording the client's copy would mean a report could cite a request that was never sent, and the gap widened with every rewriting feature added. Response interception follows the same rule (an edited response is captured as edited), so both directions agree: the history is a log of what crossed the wire, not of what was asked for. The flow keeps the absolute URL as its own field, so re-sending a captured request from the Repeater or the organizer still resolves its target even though the captured head is in origin form. A flow's PwnFox identity is still read from the client's request, since the forwarded copy has that header stripped by design.

There is no scope/methodology section, endpoint inventory or appendix in any format.

4. Output formats

Format Role Generator
HTML primary, self-contained, styled {{var}} template (section 5) + nstrprintf
Markdown bug-bounty / GitHub submissions nstrprintf
JSON canonical machine-readable export cJSON
SARIF optional, CI integration cJSON (SARIF 2.1.0 schema)
CSV optional, triage spreadsheets nstrprintf row builder
Issue XML (the burp format) import findings into an external scanner nstrprintf issue builder (base64 requestresponse)
PDF printable deliverable user-configured external generator over the HTML

Fissure ships no PDF engine of its own. Instead, PDF export renders the self-contained HTML report and hands it to an external generator that the user names in Settings > Reporting > "PDF command": a whitespace-separated command template whose {{in}} and {{out}} placeholders are substituted with the input HTML path and the output PDF path (for example wkhtmltopdf {{in}} {{out}}, weasyprint {{in}} {{out}}, or chromium --headless --print-to-pdf={{out}} {{in}}). The command is run directly (no shell, so nothing in the report is interpreted; first token is the executable, looked up on PATH), and export succeeds only when the generator exits 0 and writes a non-empty file (fissure_pdf.c). The generator runs on a background worker (the Report view shows a "Generating PDF" spinner and refuses a second export until it finishes), so a slow tool never freezes the UI; the outcome is reported on the status line, with a popup on failure. When no command is configured, the PDF option is disabled: choosing it and exporting shows an on-screen note pointing to the setting rather than writing anything. The HTML is also print-styled (@media print), so printing to PDF from a browser stays a zero-config fallback.

HTML (primary)

The HTML report is one file: inline <style>, no scripts, no external assets. fissure_report_html(model, template_text) builds it in two steps:

  1. The per-finding blocks are generated in C, not by a sub-template: for each finding in model->sorted it appends a <section class="finding sev-<severity>"> (the severity slug is fissure_severity_str, so the classes are sev-critical, sev-high, sev-medium, sev-low, sev-info) holding an <h3> title, a badge span, the confidence / source / triage line, a <dl> with category, CWE / OWASP and location, the description, and optional tags, evidence, remed, refs and notes divs. Every finding field passes through the file-local html_escape (which also strips characters invalid in XML) before it is inserted. The concatenation becomes the {{findings_html}} value.
  2. The scalars and that block are substituted into the template with one n_str_template_expand pass (section 5 lists the variables and how the template is chosen).

fissure_report_html_ex does the same with the resolved template and also returns which source was used and why a custom or bundled template was rejected, so a caller can show it.

The bundled template (resources/report/report.html.tmpl, ASCII only, identical to the built-in copy) is a short shell: a <title> and <h1> from {{report_title}}, a "Generated {{generated_at}} by Fissure {{fissure_version}}" line, an Executive summary with {{risk_score}} and the severity-count table ({{sev_critical}} to {{sev_info}} plus {{total}}), then {{tools_html}} and a Findings heading followed by {{findings_html}}. Its stylesheet colours the badge per sev-* class and lifts the evidence height cap under @media print.

Markdown

Pure nstrprintf, no template file (fissure_report_markdown). A # title, a ## per section (Executive summary, Tools, Findings) and a ### per finding, with a bullet list of the finding's metadata, then the description, an Evidence fenced code block (the fence is longer than any backtick run inside the evidence), Remediation, References and Notes. Optimized for pasting into a bug-bounty platform or a GitHub issue.

JSON (canonical)

The JSON export (fissure_report_json) is the canonical machine-readable report. Built with cJSON (vendored, audits/NILOREA_AUDIT.md). Top-level keys: schema_version (1), tool ("Fissure"), tool_version, title, generated, summary (total, risk_score, risk_band, by_severity with critical/high/medium/low/info), tools (only when tool versions were probed) and findings. Each finding carries severity, confidence, source, triage, notes, tags, category, cwe, owasp, title, description, the resolved evidence, location, remediation, references, source_tool, dedup_key, request_ref, response_ref and the redacted request reconstruction. This serializer is the report's own; the saved session (fissure_session.c) writes findings in its own NDJSON form.

SARIF (optional, CI)

SARIF 2.1.0 via cJSON: one run with tool.driver.name = "Fissure", each finding a result (level mapped from severity: critical/high -> error, medium -> warning, low/info -> note), ruleId from CWE, locations[].physicalLocation holding the endpoint URL, and partialFingerprints.dedupKey = dedup_key so CI systems collapse recurrences. Lets GitHub code-scanning / GitLab ingest results.

CSV (optional, triage)

One header row plus one row per finding: severity,confidence,triage,category,cwe,owasp,host,location,title,tags,source_tool,dedup_key. Quoting via a small csv_field helper (double internal quotes, wrap fields containing comma/quote/newline). The triage state and the analyst tag list are included so the spreadsheet doubles as a triage worksheet; there is no evidence column (too large for a spreadsheet).

Issue XML (the burp format, for import into an external scanner)

fissure_report_burp emits a scanner-export XML shape (matching the documented issue-import workflow): an <issues> root of <issue> elements, each with <name> (title), <host> and <path> split from the finding location, <location>, <severity> (Information/Low/Medium/High: Fissure's Critical folds into High since the format has no Critical level), <confidence> (Tentative/Firm/Certain), CDATA <issueBackground> (description), <remediationBackground> (remediation) and <issueDetail> (evidence), and a <requestresponse> with base64 <request>/<response> reconstructed from the finding's captures. Element text is XML-escaped; a literal ]]> inside a CDATA value is split so the document stays well formed. Built with nstrprintf (no XML library) and n_base64_encode. Available in the Report view (Issue XML in the format picker, .xml) and the CLI (--format burp).

5. Templating engine

Reuse, do not invent. The HTML renderer uses n_str_template_expand (the same {{var}} engine Hook uses for URL/header/body/auth expansion, see audits/HOOK_AUDIT.md and audits/NILOREA_AUDIT.md) over a HASH_TABLE of string variables, in one substitution pass. Only the HTML report is templated; the Markdown, JSON, SARIF, CSV and Issue XML renderers are fully code-driven. The PDF is printed from the HTML, so it follows the same template.

Which template is used

The HTML report uses the first usable template of:

  1. the operator's custom template, <config>/report.html.tmpl, where <config> is $XDG_CONFIG_HOME/fissure when that variable is set, else ~/.config/fissure (on Windows, %APPDATA%\Fissure; fissure_paths_config_dir). It is read at every render, so an edit applies on the next preview or export without a restart;
  2. the bundled template, resources/report/report.html.tmpl beside the executable;
  3. the built-in compiled copy (fissure_report_builtin_template), identical to the bundled file.

An absent file is skipped quietly. A template that is present but unreadable, empty, or lacks the {{findings_html}} placeholder (a report without findings would read as a clean result) is rejected and the next source is used (fissure_report_template_resolve). The rejection reason is shown on screen: a popup in the GUI Report view, a template_error field in the control-API report response, and a stderr line from fissure scan / fissure report --format html. The control API GET /api/report?format=html response also carries template = custom, bundled or builtin.

To customise the report, copy resources/report/report.html.tmpl to the config directory as report.html.tmpl and edit it. Keep {{findings_html}} in it.

Template variables

Variable Value
{{report_title}} the model title (default "Fissure scan report")
{{generated_at}} the generation timestamp (ISO-8601), or n/a
{{fissure_version}} FISSURE_VERSION
{{risk_score}} <score> (<band>), for example 62 (High)
{{sev_critical}} {{sev_high}} {{sev_medium}} {{sev_low}} {{sev_info}} finding count per severity
{{total}} total finding count
{{tools_html}} the Tools section as pre-built HTML (empty when no tool versions were probed)
{{findings_html}} every finding block as pre-built HTML (section 4, HTML)

Values are HTML-escaped before substitution, except {{tools_html}} and {{findings_html}}, which are pre-built HTML whose fields were escaped when the block was assembled. There is no per-finding sub-template: the finding markup is generated in C, and a template styles it through the finding, sev-<severity>, badge, evidence, remed, refs, tags and notes classes.

6. Evidence handling

Evidence is the request/response excerpt that proves a finding. A finding stores request_ref / response_ref ids into the session capture store (02_ARCHITECTURE.md section 5); the renderer resolves them to the actual FISSURE_CAPTURE at render time and never duplicates the raw bytes into the finding.

  • Redaction (before any export): a redaction pass scrubs secrets from evidence and request reconstructions, masking values with [REDACTED]. It is on by default; it is turned off only by the CLI --no-redact or the control-API redact=0 query parameter (the GUI always exports redacted). The matcher and its lists are described under "Status" below.
  • Truncation: request and response bodies are capped per excerpt (FISSURE_REPORT_EVIDENCE_MAX, default 8 KB, in fissure_constants.h); the cut point appends [truncated N bytes]. Binary bodies (a non-text Content-Type, or an embedded NUL in a body whose type is absent/text) are summarized as <binary body, N bytes, content-type=...> rather than dumped. The full untruncated capture stays in the session NDJSON for replay.
  • HTML/Markdown escaping happens after redaction and truncation so masked markers cannot break out of the markup.

Status: implemented (fissure_report_process_evidence). Redaction (on by default, toggled by the model's redact flag / the CLI --no-redact) masks the values of sensitive headers (Authorization, Proxy-Authorization, Cookie, Set-Cookie, X-Api-Key), Bearer/Basic credential tokens, and sensitive key=value / "key": "value" pairs (password, passwd, secret, token, api_key, access_token, session, ...) with [REDACTED]; the MD/JSON/HTML renderers process evidence through it (HTML escapes after). Truncation caps each excerpt at FISSURE_REPORT_EVIDENCE_MAX (8 KB) and appends [truncated N bytes]. The matcher is a focused C scanner, extended at startup by resources/report/redaction.json: fissure_report_load_redaction merges that file's headers (header names whose value is masked) and keys (key names masked in key=value / "key": "value") into the built-in lists, so operators add site-specific secrets without code changes (the file never removes a built-in). The CLI and GUI both load it; the names are matched case-insensitively. Binary-body summarization is implemented (capture excerpts only, since inline evidence strings are already text): a non-text Content-Type (or an embedded NUL in an untyped body) renders as <binary body, N bytes, content-type=...>.

Capture-backed resolution: when a capture store is attached to the model (fissure_report_model_set_captures), the renderers resolve a finding's request_ref / response_ref to a FISSURE_CAPTURE. A finding with no inline evidence string shows a response excerpt rebuilt from its capture (status line, response headers, then a body prefix capped at FISSURE_REPORT_CAPTURE_BODY_MAX); an inline evidence string still takes precedence. The JSON export adds the request_ref / response_ref ids and a request field, a redacted reconstruction of the captured request (request line, headers, body), and the SARIF export carries the same reconstruction under the result's properties.request. The redaction + truncation pass above applies to both the resolved excerpt and the request reconstruction. fissure scan attaches the live capture store; fissure report --session loads the captures sibling (fissure_session_load_captures) and attaches it. The GUI report view attaches the scan's live capture store (fissure_report_model_set_captures with fissure_gui_sitemap_captures), so a report generated in the GUI resolves evidence for the findings in memory. A project's persisted findings resolve their evidence too: saving a project writes the captures alongside the findings (fissure_session_save_captures), and reopening it loads that sibling and merges it into the scan's capture store (fissure_session_load_captures + fissure_captures_merge), so evidence excerpts survive a close/reopen rather than being lost with the in-memory scan.

7. GUI integration

The report is one of Fissure's popup/panel views (fissure_gui_report.c, see 03_GUI_DESIGN.md). It follows the Hook popup lifecycle (lazy _ensure_built, _toggle + n_gui_focus_window, _handles_window for ESC dispatch, _close_if_open) cited in audits/HOOK_AUDIT.md section 1.

  • Preview pane: a scrollable text/markup view of the rendered report for the currently selected format. Re-renders when the format selector or the include/exclude set changes.
  • Source / Rendered toggle ("Show: Source" / "Show: Rendered", next to the format selector). Source is the raw report text (the textarea) for every format. Rendered depends on the format: a Markdown report is drawn in place by an n_gui markdownview parsing with N_MARKDOWN_FULL (headings, tables, lists, rules, code; http(s) links open in the desktop browser through fissure_gui_open_external, the helper behind Help > Documentation; text selects by drag, double click, Ctrl+A and copies with Ctrl+C). An HTML or PDF report is written to a temporary .html file and opened in the desktop browser, which renders it exactly as delivered; the preview then shows a short note naming the file. The browser opens only on a click (switching to Rendered, or choosing HTML/PDF while Rendered is on), never on a background re-render, and a fresh copy is opened by switching to Source and back. JSON, SARIF, CSV and issue XML have no rendering: the toggle greys out and the source shows (the choice is kept for when a renderable format is picked again). The markdown faces (bold, italic, mono, headings) are shared with the AI panes through fissure_gui_mdfonts, which re-points every pane when the UI font changes.
  • Web dashboard Report tab: the same toggle (remembered in the browser's localStorage). Markdown renders through FissureMarkdown, an inline copy of DarkChan's portal renderer that builds DOM nodes only (never innerHTML) and keeps links to http(s). Like nilorea's n_markdown, a code fence opened with N >= 3 backticks closes only on a line starting with at least N, so the longer fence the Markdown report puts around evidence holds a line of three backticks as one code block. A fence of N >= 3 tildes (~~~) works the same way and is closed only by a run of at least N tildes, so a backtick line inside a tilde block (or a tilde line inside a backtick block) stays code; a line starting with only two tildes (~~struck~~) is still strikethrough. HTML renders in <iframe sandbox srcdoc> with no allow-scripts and no allow-same-origin, prefixed with a default-src 'none' CSP meta so a report cannot load anything from the network.
  • Format selector: a combobox listing the seven formats HTML / Markdown / JSON / SARIF / CSV / Issue XML / PDF. The preview re-renders when the format changes and when the number of findings in the store changes (polled each frame with a non-blocking lock, so a running scan never freezes the view).
  • Triage exclusion: an "FP/ignored: shown|hidden" toggle drops findings triaged false-positive or ignored from the aggregation model before render (via FISSURE_REPORT_FILTER.exclude_triaged_out); they remain in the session, only the report omits them. Per-finding triage state is set in the Findings view (fissure_gui_findings.c, see 03_GUI_DESIGN.md).
  • Export button: opens the native file chooser via allegro_native_dialog (same as Hook's Save handlers), defaulting the extension to the selected format, then writes the rendered report. The render runs on the GUI thread under the scan lock (taken with a trylock, retried next frame on a miss). PDF export runs the external generator on a background worker (section 4).
  • PwnDoc report: generates the Docx on the configured PwnDoc instance and downloads it through a save dialog (07_PAWNDOC.md).
  • Save session / Open session: write the findings and their captures to a session file, or merge a saved session's findings and captures into the current project.
  • There is no redaction toggle and no separate live counter or risk display in the view: the GUI always exports redacted, and the counts and risk score are part of the rendered preview.

8. CLI / headless

fissure_cli.c (mirroring Hook's hook_cli.c) generates a report from a saved session without the GUI, for CI and automation:

fissure report --session session.ndjson --format html    -o report.html
fissure report --session session.ndjson --format sarif   -o results.sarif
fissure report --session session.ndjson --format json    -o report.json \
               --no-redact --min-severity medium
fissure report --session session.ndjson --format markdown -o report.md
fissure report --session session.ndjson --format html     -o report.html \
               --exclude-triaged

It loads the NDJSON via fissure_session_load, runs the same aggregation (FISSURE_REPORT_MODEL) and the same renderers as the GUI, applies optional filters (--min-severity, --source, --host, --exclude-triaged), and writes the file. Exit code is non-zero if any finding at or above a --fail-on <severity> threshold exists (so CI can gate a pipeline). The same fissure report can be chained after fissure scan / fissure plugin run in a CI job. SARIF output is the intended artifact for code-scanning ingestion.

Status: implemented (fissure_cli). fissure scan <URL> [--active] [--save-session <file>] [--format <fmt>] [-o <file>] [--min-severity <sev>] [--fail-on <sev>] runs the scan and emits a report; --save-session archives the findings store as NDJSON (one finding per line) via fissure_session. fissure report --session <file> [--format <fmt>] [-o <file>] [--min-severity <sev>] [--source <src>] [--host <host>] [--exclude-triaged] [--fail-on <sev>] reloads that session (fissure_session_load) and re-renders a report without re-scanning, so the report is a pure function of the saved findings. The --min-severity, --source (proxy/scanner/plugin/manual), --host, and --exclude-triaged (drop findings triaged false-positive or ignored) filters are applied through the report model (fissure_report_model_new_filtered), and the risk score and counts reflect the filtered set. Every finding's triage state, notes, and tags are surfaced in all formats (Markdown/HTML/JSON/CSV/SARIF). The session persists the findings store and, in a sibling file, the capture store; a finding's evidence is the snippet a check records inline, or, when there is none, a response excerpt resolved from its capture at render time (section 6). Full-request "Send to Repeater" loads the finding's captured request in the GUI (section 9).

9. Reproducibility

Every finding is re-testable from the report:

  • Each finding's evidence resolves to a FISSURE_CAPTURE that holds the exact request that triggered it (method, URL, headers, body). The JSON/SARIF exports embed enough of that request (after redaction policy) to reconstruct it.
  • The GUI report detail offers "Send to Repeater": it loads the finding's captured request into the foreground request editor / Repeater described in 04_NETWORK_AND_PROXY.md, where the analyst can re-issue and mutate it. This reuses Hook's request engine and cancellation (audits/HOOK_AUDIT.md). Status: implemented in the Findings view (fissure_gui_findings). Selecting a finding and pressing "Send to Repeater" resolves its request_ref / response_ref to the scan's capture store (fissure_gui_sitemap_captures) and loads the full captured request, method, URL, headers, and body, into the Repeater via fissure_gui_repeater_set_request, then switches to that view. When no capture backs the finding it falls back to loading the finding's http(s) location as a GET. The GUI report view resolves capture-backed evidence the same way (fissure_report_model_set_captures).
  • Because the report is a pure function of the session NDJSON, re-running fissure report on the archived session reproduces a byte-stable report (modulo the generation timestamp), which is the audit guarantee stated in 02_ARCHITECTURE.md section 6 step 7.
  • 00_MASTER_PLAN.md - phased build plan; reporting is the final pipeline stage.
  • 01_SECURITY_TOOLS_CATALOG.md - tools whose output becomes plugin findings.
  • 02_ARCHITECTURE.md - data model (FISSURE_FINDING), store, and the section 6 data flow this document expands (step 7).
  • 03_GUI_DESIGN.md - findings grid, popup layout, theme; the report panel.
  • 04_NETWORK_AND_PROXY.md - captures, Repeater (reproducibility, section 9).
  • 05_WEBSITE_SCANNER.md - built-in checks and the dedup rule.
  • resources/dependencies.json - external tool registry; each tool manifest carries a version_args list used to probe its version for the report metadata when --tool-versions is passed (fissure_plugin_probe_version).
  • audits/NILOREA_AUDIT.md - n_str / nstrprintf, n_str_template_expand, cJSON, file utils used by the renderers.
  • audits/HOOK_AUDIT.md - template expansion, NDJSON, native file chooser, and the lock-free counter pattern reused by the GUI integration.