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 "
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; see05_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.mdsection 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.
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_argslist (see02_ARCHITECTURE.mdsection 4);fissure scan/fissure report --tool-versionsprobes 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 /toolsarray; CSV, SARIF and Issue XML omit them.Executive summary: the risk score with its band, and a severity-count table (Critical, High, Medium, Low, Info, Total).
Tools: emitted only when tool versions were probed (
--tool-versions).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) |
| 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:
- The per-finding blocks are generated in C, not by a sub-template:
for each finding in
model->sortedit appends a<section class="finding sev-<severity>">(the severity slug isfissure_severity_str, so the classes aresev-critical,sev-high,sev-medium,sev-low,sev-info) holding an<h3>title, abadgespan, the confidence / source / triage line, a<dl>with category, CWE / OWASP and location, the description, and optionaltags,evidence,remed,refsandnotesdivs. Every finding field passes through the file-localhtml_escape(which also strips characters invalid in XML) before it is inserted. The concatenation becomes the{{findings_html}}value. - The scalars and that block are substituted into the template with
one
n_str_template_expandpass (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:
- the operator's custom template,
<config>/report.html.tmpl, where<config>is$XDG_CONFIG_HOME/fissurewhen 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; - the bundled template,
resources/report/report.html.tmplbeside the executable; - 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-redactor the control-APIredact=0query 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, infissure_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 adefault-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, see03_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 viafissure_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 reporton the archived session reproduces a byte-stable report (modulo the generation timestamp), which is the audit guarantee stated in02_ARCHITECTURE.mdsection 6 step 7.
10. Cross-links
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 aversion_argslist used to probe its version for the report metadata when--tool-versionsis 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.