Fissure architecture
Fissure is a Linux desktop web-security toolkit written in C99 on top of the Nilorea library, using the same Allegro 5 + n_gui + n_network stack as the Hook API client. It bundles four capabilities behind one GUI and one data model:
- An intercepting HTTPS proxy (man-in-the-middle, on-the-fly cert minting, request/response edit-and-forward, capture history).
- A full website scanner (crawl -> endpoint inventory -> vulnerability tests, manual or fully automatic).
- A plugin host that wraps external open-source security tools (nuclei, ffuf, sqlmap, nikto, subfinder and more) as detached subprocesses.
- A synthetic report generator that aggregates every finding of a scan session.
The unifying idea: everything produces or consumes the same data model. The proxy populates the endpoint inventory, the scanner and plugins attach findings to those endpoints, and the report renders the whole session. This document is the top-level map. See the cross-links at the end for each subsystem's detail.
Grounding: this design reuses the patterns catalogued in
audits/HOOK_AUDIT.md (GUI, transport, threading) and the
capability/gap inventory in audits/NILOREA_AUDIT.md (what
nilorea provides vs what must be added). Read those two first.
Semantic parity between the surfaces
Surface parity (a capability reachable in the GUI is also a
control-API route and an MCP tool) is enforced by
tests/test_control_routes. SEMANTIC parity, that those
surfaces do the same WORK, is enforced by
tests/test_surface_parity.
The distinction matters because it is where this project has actually broken: a scan started from the CLI or the control API used to set fewer config fields than the same scan from the GUI, so it quietly did less and still reported clean. The route existed and the MCP tool existed, so every surface check passed.
tests/test_surface_parity is a source lint rather than a
runtime test, because the GUI modules are not linked into any test
binary; reading them is the only way to compare the GUI path against the
others. It asserts that the three scan paths assign the same
FISSURE_SCAN_CONFIG fields, that between them they cover
every field the struct declares, that the GUI and control proxies call
the same fissure_proxy_set_* setters and cover every one
the header declares, and that the OAST collector is wired on each scan
path.
The practical consequence: adding a field to
FISSURE_SCAN_CONFIG, or a setter to
fissure_proxy.h, fails the build until every surface wires
it. That is the intended pressure, so a headless path cannot silently
fall behind the GUI again.
1. High-level component diagram
+--------------------------------------------------------------------------+
| GUI layer (Allegro 5 + n_gui) |
| toolbar | nav | main view | statusbar (4 frameless windows) |
| views: Dashboard, Repeater, Proxy, Target (scan), Findings, Report, |
| Intruder |
| popups: plugins, multitool, scan options, settings, confirm and more |
| fissure_gui_main / _proxy / _sitemap / _findings / _report / _plugins |
+----------------------------------+---------------------------------------+
| calls (GUI thread)
v per-store locks, trylock in ticks
+--------------------------------------------------------------------------+
| Core engine (transport) |
| fissure_request + fissure_engine (native n_network engine) |
| fissure_response / httpauth / cookiejar / js (QuickJS) |
| ported from Hook, see section 3 |
+------+----------------+-----------------+------------------+-------------+
| | | |
v v v v
+-------------+ +-------------+ +----------------+ +----------------+
| Proxy | | Scanner | | Plugin host | | Report |
| module | | module | | (subprocess) | | generator |
| listen/ | | crawl + | | manifests + | | aggregate + |
| accept + | | inventory + | | arg templates +| | render HTML/ |
| MITM TLS + | | vuln tests | | output parsers | | MD/JSON/SARIF/ |
| intercept | | (n_thr_pool)| | (execvp) | | CSV/XML/PDF |
+------+------+ +------+------+ +-------+--------+ +--------+-------+
| | | |
| capture | endpoints + | findings | reads
| -> endpoints | findings | |
v v v |
+--------------------------------------------------------------------------+
| Findings / inventory / capture stores |
| FISSURE_FINDINGS (fissure_findings) | FISSURE_INVENTORY of |
| FISSURE_ENDPOINT (fissure_inventory)| FISSURE_CAPTURES (fissure_capture)|
| persisted per project: fissure_session (NDJSON findings + .captures) |
| and fissure_inventory_save |
+----------------------------------+---------------------------------------+
^
| loads/saves
+--------------------------------------------------------------------------+
| Config / resources / paths |
| fissure_settings (JSON via cJSON) | fissure_paths | resources/ |
| resources/dependencies.json | plugins/*.json | ca/ (minted root CA) |
+--------------------------------------------------------------------------+
Scanning has no view of its own: a scan is launched and watched from
the Target view (fissure_gui_sitemap) with its Scan options
popup (fissure_gui_scanopts). Plugins and the Multitool
were views once; their view ids (5 and 7) are retired in
src/fissure_app.h and both are popups now.
fissure_auth is not a request-auth module: it verifies a
target's configured authentication without running a scan.
The four modules never talk to each other directly. They all read and write the findings, inventory and capture stores, which are the single integration point. The GUI observes the stores and the per-worker state through lock-guarded reads, taking the store lock with a trylock in per-frame ticks (section 7).
2. Source layout (as built)
This table is the as-built map of src/, not a plan:
every row is a file that exists and its purpose is that file's own
@brief. It was a design-time proposal for a long time and
drifted badly (seven files it listed were never written, and most of the
real tree was missing), so it is now generated from the sources when it
changes.
244 modules.
Core / app (94)
| File | Purpose |
|---|---|
fissure_ai.c/.h |
Optional LLM assistant: explain a request, triage a finding, draft a PoC |
fissure_aichat.c/.h |
FISSURE_AICHAT: an agentic AI chat that drives Fissure over its control API |
fissure_app.c/.h |
Top-level application state shared across the GUI views |
fissure_attackcfg.c/.h |
A saved Intruder attack configuration and its JSON persistence |
fissure_auth.c/.h |
Verify a target's configured authentication without running a scan |
fissure_authmatrix.c/.h |
Authorization matrix: run a request under N identities, with parameter |
fissure_authz.c/.h |
First-run authorization acknowledgement (persisted under the config dir) |
fissure_authz_replay.c/.h |
Access-control / IDOR replay check (Autorize style) |
fissure_autorepeater.c/.h |
Auto-replay rules: condition-matched request mutation for a diff log |
fissure_browser.c/.h |
Launch the "Fissure Browser": a pre-configured Chromium for one-click proxying |
fissure_browserlogin.c/.h |
Log in through a real browser over CDP and harvest the session it establishes |
fissure_cdp.c/.h |
Chrome DevTools Protocol (CDP) client over a headless Chromium |
fissure_cmdline.c/.h |
Raw command-line helpers (Windows GetCommandLine style splitting) |
fissure_compat.h |
Portable fallbacks for libc functions the Windows CRT lacks |
fissure_constants.h |
Application-wide numeric constants (window sizing, fonts, paths, ui scale) |
fissure_cspt.c/.h |
Static heuristic for Client-Side Path Traversal (CSPT) leads |
fissure_csrf.c/.h |
Generate a CSRF proof-of-concept HTML page from a captured request |
fissure_curlimport.c/.h |
Turn a browser's Copy as cURL command into a request (method, URL, headers, body) |
fissure_deserchain.c/.h |
Generate BENIGN, OAST-confirmed deserialization test payloads (blind-deser confirmation) |
fissure_diff.c/.h |
Line-based text diff for comparing two captured responses |
fissure_dominvader.c/.h |
Live in-browser DOM-Invader session over an attached CDP browser |
fissure_domprobe.c/.h |
Headless DOM security probe (DOM Invader-class) over the CDP client |
fissure_domxss.c/.h |
Static heuristic for DOM-based XSS (client-side source-to-sink flows) |
fissure_endpoint.c/.h |
FISSURE_ENDPOINT model: one entry in the scanner endpoint inventory |
fissure_env.c/.h |
FISSURE_ENV: reusable {{variable}} environments shared across the tools |
fissure_eventlog.c/.h |
In-memory event/activity log: a chronological record of engine events |
fissure_extstate.c/.h |
Per-extension key/value state that survives a restart |
fissure_graphql.c/.h |
Minimal GraphQL query helpers for the active GraphQL check |
fissure_groupsend.c/.h |
FISSURE_GROUPSEND: send a group of requests together for race testing |
fissure_hae.c/.h |
Highlighter and Extractor (HaE): passive regex rules over captured flows |
fissure_headless.c/.h |
Run a headless (JS-rendering) crawl and capture its discovered URLs |
fissure_hostedoast.c/.h |
Client for a hosted OAST / interaction server (interactsh protocol): zero-setup DNS/HTTP OAST |
fissure_inspect.c/.h |
Structured decomposition of an HTTP request (the "Inspector" model) |
fissure_intruder.c/.h |
Intruder-style fuzzing: payload positions, attack modes, threaded runs |
fissure_inventory.c/.h |
FISSURE_INVENTORY: deduplicated endpoint store keyed by method + canonical URL |
fissure_log.c/.h |
Thin wrapper over the Nilorea n_log logging facility |
fissure_login.c/.h |
FISSURE_LOGIN: a recorded login sequence that establishes a session |
fissure_loginrec.c/.h |
Record a login / macro from captured traffic into a replayable login config |
fissure_macro.c/.h |
Session-handling macros: substitute captured tokens into a request |
fissure_matchrep_cfg.c/.h |
JSON persistence for a FISSURE_MATCHREP ruleset |
fissure_multitool.c/.h |
Encoding / JWT / hash multitool: pure, GUI-free transforms |
fissure_net.h |
Socket portability glue for Fissure's raw-socket call sites |
fissure_oast.c/.h |
FISSURE_OAST: an out-of-band (OAST) HTTP callback listener |
fissure_organizer.c/.h |
FISSURE_ORGANIZER: a save-for-later queue of stashed requests |
fissure_organizer_cfg.c/.h |
JSON persistence for a FISSURE_ORGANIZER queue |
fissure_originip.c/.h |
Origin-IP discovery: confirm which candidate IPs are the real origin behind a CDN/WAF |
fissure_paramjar.c/.h |
Request-parameter jar: operator-supplied GET/POST parameters carried by the tools |
fissure_paramminer.c/.h |
Hidden-parameter discovery by response diff against a control |
fissure_paths.c/.h |
Resolve filesystem paths relative to the running executable |
fissure_pdf.c/.h |
Produce a PDF from a rendered HTML report via a user-configured external |
fissure_platform.h |
Platform abstractions: path separator and small portability helpers |
fissure_pkce.c/.h |
OAuth2 authorization-code flow with PKCE: the parts around the browser |
fissure_presets.c/.h |
Shared seam for shipping useful default configurations to modules that |
fissure_prettify.c/.h |
Beautify (pretty-print / re-indent) JSON, XML/HTML, and JS/CSS for readable viewing |
fissure_proc.c/.h |
Portable subprocess helpers (POSIX fork/exec, Windows spawn/ShellExecute) |
fissure_project.c/.h |
Named projects (workspaces): per-project data directories |
fissure_protobuf.c/.h |
Decode protobuf / gRPC wire-format bytes into a readable field tree |
fissure_query.c/.h |
The universal traffic-query dialect: a shared HTTP field vocabulary over n_query, |
fissure_race.c/.h |
Automated race-condition (limit-overrun) probe over the single-packet primitive |
fissure_rawedit.c/.h |
Escape syntax for hand-authoring a byte-exact HTTP message as text |
fissure_reauth.c/.h |
FISSURE_REAUTH: a mid-run session re-authentication handler |
fissure_remediation.c/.h |
Curated per-issue remediation and reference library, keyed by CWE/category |
fissure_repeater_tabs.c/.h |
FISSURE_REPEATER_TABS: the Repeater's multiple request workspaces |
fissure_repeater_tabs_cfg.c/.h |
JSON load/save for FISSURE_REPEATER_TABS (per-project Repeater collections) |
fissure_rolediff.c/.h |
Site-map comparison across roles (a compare-site-maps analysis for access control) |
fissure_saml.c/.h |
SAML assertion workshop: decode/inspect/edit/strip/wrap/re-sign SAML messages |
fissure_schedule.c/.h |
FISSURE_SCHEDULES: saved scans that recur on an interval, with a per-run diff |
fissure_scope.c/.h |
Target scope: an allow/deny host-pattern set deciding what is in scope |
fissure_scopeimport.c/.h |
Import a bug-bounty program scope file into Fissure scope patterns |
fissure_scopeset.c/.h |
Named scope profiles: several {allow, deny} scopes with one active |
fissure_screenshot.c/.h |
Recon screenshots: capture a page image with a headless browser over CDP |
fissure_sequencer.c/.h |
Session-token randomness: live capture plus a per-position and per-bit verdict |
fissure_sessaction.c/.h |
Run an extension "session action" login script and capture the session |
fissure_sessrule.c/.h |
Session-handling rule engine: scope-gated header injection and re-auth |
fissure_settings.c/.h |
Persisted application settings (theme, interface size, transport TLS) |
fissure_shadowrepeater.c/.h |
AI-assisted variation testing (Shadow Repeater): fuzz an operator's request in the |
fissure_sitemap.c/.h |
Host/path tree model built from the endpoint inventory |
fissure_smuggle.c/.h |
HTTP request-smuggling (desync) detection by timing |
fissure_tags.c/.h |
Inline transform-tag engine (Hackvertor-style), pure and GUI-free |
fissure_team.c/.h |
Multi-operator team-collaboration state for a shared Fissure project |
fissure_token.c/.h |
Signed-token workshop core (JWT/JWS): build, verify, re-sign, forge |
fissure_ui_scale.c/.h |
DPI-aware interface scale: one multiplier driving fonts and metrics |
fissure_upload.c/.h |
File-upload bypass-variant generation for the upload security check |
fissure_useragent.c/.h |
Named User-Agent presets (a saved library) and the active selection |
fissure_userscripts.c/.h |
Run user JavaScript checks over observed exchanges (passive hooks) |
fissure_version.h |
Application version string, changed only by
make bump-version (no build or packaging target writes
it) |
fissure_wafbypass.c/.h |
Input-filter (WAF/CDN) bypass encoders for authorized vulnerability demonstration |
fissure_wafdetect.c/.h |
WAF/CDN fingerprinting (wafw00f-class): identify the protection in front of a target |
fissure_workflow.c/.h |
FISSURE_WORKFLOW: a composable pipeline over Fissure's scriptable primitives |
fissure_wscap.c/.h |
Per-connection WebSocket frame capture for the proxy |
fissure_wsrepeater.c/.h |
Replay a WebSocket message to a captured endpoint and collect replies |
fissure_xpath.c/.h |
XPath evaluation over an HTML/XML document (libxml2-backed) |
fissure_yaml.c/.h |
Convert a YAML document to cJSON (for YAML OpenAPI/Swagger import) |
main.c |
Fissure entry point: Allegro 5 + n_gui window, event loop, and CLI flags |
Transport core (18)
| File | Purpose |
|---|---|
fissure_cancel.c/.h |
Cooperative request cancellation via socket shutdown |
fissure_config.c/.h |
Transport configuration consumed by the request engine |
fissure_cookie.c/.h |
Framework signed-cookie workshop core: detect, verify, forge, crack |
fissure_cookiejar.c/.h |
The suite-wide shared cookie jar |
fissure_dns.c/.h |
Minimal DNS resolver client (CNAME lookups), Fissure-owned |
fissure_engine.c/.h |
Native HTTP(S) transport engine over Nilorea n_network |
fissure_hostgov.c/.h |
Per-host adaptive concurrency: back off when the target stops answering |
fissure_hostroute.c/.h |
Per-host connection routing: DNS rewrites and per-host upstream proxies |
fissure_http2.c/.h |
Single-exchange HTTP/2 client over a connected stream (RFC 7540/7541) |
fissure_http3.c/.h |
HTTP/3 (over QUIC) fetch: a thin Fissure wrapper over Nilorea n_http3 |
fissure_httpauth.c/.h |
Network-layer HTTP authentication: answer a WWW-Authenticate challenge |
fissure_matchrep.c/.h |
FISSURE_MATCHREP: in-flight match-and-replace rules for proxy traffic |
fissure_ratelimit.c/.h |
Per-host request-rate governor for scans (a shared token bucket, burst 1) |
fissure_request.c/.h |
HTTP request model (method, URL, headers, params, body, TLS, auth) |
fissure_response.c/.h |
HTTP response model and the backend-agnostic timing breakdown |
fissure_respool.c/.h |
Named resource pools: concurrency and rate budgets shared across the tools |
fissure_tls.c/.h |
System CA bundle detection for outbound TLS verification |
fissure_trafficlog.c/.h |
Cross-tool HTTP traffic log (a Logger++-style unified request log) |
Proxy (9)
| File | Purpose |
|---|---|
fissure_ca.c/.h |
Local MITM certificate authority: persistence and per-host leaf cache |
fissure_capture.c/.h |
FISSURE_CAPTURE: the exact request/response that backs a finding |
fissure_h3proxy.c/.h |
HTTP/3 (QUIC) MITM interception listener |
fissure_intercept.c/.h |
Interception queue: pause proxied requests and responses for edit-and-forward |
fissure_interceptrules.c/.h |
Ordered conditional rules deciding which messages the proxy holds |
fissure_proxy.c/.h |
Intercepting HTTP(S) proxy: listening socket, accept loop, capture |
fissure_pwnfox.c/.h |
PwnFox-style multi-identity proxy tagging: read and strip the identity |
fissure_rawrelay.c/.h |
Generic non-HTTP interception relay for raw TCP and UDP streams |
fissure_trust.c/.h |
Install and remove the Fissure CA in the platform's own certificate store |
Scanner and recon (17)
| File | Purpose |
|---|---|
fissure_apispec.c/.h |
Import endpoints from an API definition (OpenAPI / Swagger / Postman) |
fissure_assets.c/.h |
FISSURE_ASSETS: a host-level recon asset inventory with a new-since-last-run diff |
fissure_checks.c/.h |
Native vulnerability checks that produce FISSURE_FINDING records |
fissure_crawler.c/.h |
Breadth-first website crawler that feeds the endpoint inventory |
fissure_dirlist.c/.h |
Directory-listing (auto-index) exposure probe |
fissure_discover.c/.h |
Built-in content discovery: brute-force paths under a base URL |
fissure_liveaudit.c/.h |
Live active auditing of endpoints seen in proxy traffic |
fissure_logpoison.c/.h |
Log-file poisoning through a file-inclusion point (the LFI-to-RCE chain) |
fissure_recon.c/.h |
Route external recon-tool output into the endpoint inventory and scope |
fissure_recon_chain.c/.h |
One-action recon chain: run every installed recon-category plugin |
fissure_reconf.c/.h |
Recognise the parts of a target that change the target's OWN configuration |
fissure_scan.c/.h |
Scan orchestration: crawl a target, audit its endpoints, collect findings |
fissure_scanfamily.c |
Name <-> bit-mask translation for scan check families and insertion points |
fissure_scanprofile.c/.h |
Named scan-configuration profiles (a saved library of scan settings) |
fissure_spider.c/.h |
Native SPA / JS-rendered interaction crawler over the CDP client |
fissure_surface.c/.h |
Attack-surface analyzer: a rollup over the endpoint inventory (and the findings store) |
fissure_wafrequest.c/.h |
Request-shaped input-filter (WAF/CDN) bypass transforms for authorized testing |
Plugin host and scripting (13)
| File | Purpose |
|---|---|
fissure_bcheck.c/.h |
Import BCheck (.bcheck) definitions into Fissure's check engine |
fissure_depmgr.c/.h |
Plugin dependency status and install-command construction |
fissure_extensions.c/.h |
Packaged, versioned extension bundles (the extension SDK registry) |
fissure_jaeles.c/.h |
Import Jaeles signature YAML into Fissure's check engine |
fissure_js.c/.h |
QuickJS engine for user-authored scriptable passive checks |
fissure_jslib.c/.h |
Passive detection of vulnerable front-end JavaScript libraries (retire.js-style) |
fissure_jsmine.c/.h |
Source-map unpacking for the JavaScript endpoint miner |
fissure_marketplace.c/.h |
Offline, signed extension marketplace (browse / install / remove bundles) |
fissure_nuclei.c/.h |
Import nuclei-style YAML templates into Fissure's check engine |
fissure_plugin.c/.h |
Plugin manifest model and loader for wrapped external OSS tools |
fissure_plugin_host.c/.h |
Run a plugin against a target and collect its findings |
fissure_plugin_parse.c/.h |
Parse a plugin's captured output into FISSURE_FINDING records |
fissure_plugin_run.c/.h |
Expand a plugin's argument template and run it as a detached subprocess |
Findings and reporting (9)
| File | Purpose |
|---|---|
fissure_finding.c/.h |
FISSURE_FINDING: one vulnerability/observation produced by a check |
fissure_findings.c/.h |
FISSURE_FINDINGS: deduplicated store of findings keyed by dedup_key |
fissure_purple.c/.h |
Purple-team mode: record what each probe put on the wire, reconcile it against the target's own logging and alerting |
fissure_purple_report.c |
Where a purple run meets the workspace: its project store path and its detection-coverage findings |
fissure_pwndoc.c/.h |
PwnDoc connector: authenticate to a PwnDoc instance and (later) push |
fissure_pwndoc_cfg.c/.h |
Persisted PwnDoc connector configuration (no secrets) |
fissure_pwndoc_job.c/.h |
Background PwnDoc operations (push / report) for the GUI |
fissure_report.c/.h |
Aggregate a findings store into a report model and render it |
fissure_session.c/.h |
Persist and reload a findings store as an NDJSON session file |
Headless surfaces (control API, web UI, CLI) (5)
| File | Purpose |
|---|---|
fissure_cli.c/.h |
Headless command-line entry points (scan + report + serve) for CI/automation |
fissure_clickjack.c/.h |
Generate a clickjacking proof-of-concept HTML page for a target URL |
fissure_control.c/.h |
Engine-facing context and lifecycle for the optional local control API |
fissure_server.c/.h |
Minimal headless control server: a small JSON HTTP API over loopback |
fissure_webui.c/.h |
The browser-served control dashboard: a self-contained HTML page for the control API |
GUI (79)
| File | Purpose |
|---|---|
fissure_font.c/.h |
The bundled UI font choices: names, files and fallback order |
fissure_graphcols.c/.h |
Per-depth column widths for the Target-view site-map node graph |
fissure_gui_about.c/.h |
The About box: version, author and licensing, shown from the Home menu |
fissure_gui_ai.c/.h |
AI assistant popup: explain a request, triage a finding, draft a PoC |
fissure_gui_aichat.c/.h |
Agentic AI chat popup: converse with the assistant while it drives Fissure |
fissure_gui_authmatrix.c/.h |
Authorization-matrix popup: identities editor + per-identity verdicts |
fissure_gui_autorepeater.c/.h |
Auto-replay rules editor + diff-log popup |
fissure_gui_clickjack.c/.h |
Clickjacking PoC popup: show and save a generated framing page |
fissure_gui_collect.c/.h |
"Add to collection / tag" popup: stash right-clicked request(s) into the organizer |
fissure_gui_columns.c/.h |
Datagrid column-customization popup and per-grid apply/persist glue |
fissure_gui_comparer.c/.h |
Comparer popup: diff any two values at line, word, or byte granularity |
fissure_gui_confirm.c/.h |
Shared modal confirm / banner dialog (a single reusable POPUP) |
fissure_gui_cookiejar.c/.h |
Cookie-jar popup: view, set, and clear the suite-wide shared cookie jar |
fissure_gui_csrf.c/.h |
CSRF PoC popup: show and save a generated proof-of-concept page |
fissure_gui_ctxmenu.c/.h |
Shared right-click context menu for the grids (cross-tool actions) |
fissure_gui_dashboard.c/.h |
The Dashboard view: a recon overview of the current scan/session |
fissure_gui_dominvader.c/.h |
Live DOM-Invader popup: launch the headful Fissure Browser and instrument the |
fissure_gui_editor.c/.h |
Extension message-editor popup: an interactive decode/edit/encode round-trip |
fissure_gui_env.c/.h |
Environments popup: edit the reusable {{variable}} environments |
fissure_gui_eventlog.c/.h |
Event-log popup: a chronological panel of engine events and errors |
fissure_gui_extensions.c/.h |
Extensions manager popup: list installed extension bundles and toggle them |
fissure_gui_extpanel.c/.h |
Host window for an extension-contributed GUI panel (owner-draw) |
fissure_gui_find.c/.h |
In-message find: search the text of a syntax view, select and reveal the hit |
fissure_gui_findings.c/.h |
The Findings view: a severity grid over the current scan's findings |
fissure_gui_geom.c/.h |
Layout self-audit: report widgets a window clips, or a neighbour covers |
fissure_gui_graphql.c/.h |
GraphQL argument workshop popup: list and mutate a query's injectable |
fissure_gui_h3proxy.c/.h |
HTTP/3 MITM interception listener control popup |
fissure_gui_hae.c/.h |
Highlighter/Extractor rules editor popup |
fissure_gui_help.c/.h |
In-app help popup: a scrollable reference of views, actions, and keys |
fissure_gui_http3.c/.h |
HTTP/3 fetch popup: send one request to an https URL over HTTP/3 and show the response |
fissure_gui_import.c/.h |
Import checks popup: compile a BCheck, nuclei or Jaeles template into a |
fissure_gui_inspector.c/.h |
Structured request editor (Inspector) popup |
fissure_gui_intruder.c/.h |
The Intruder view: payload positions, attack modes, threaded results |
fissure_gui_intrules.c/.h |
Popup editor for the ordered conditional interception rules |
fissure_gui_jobs.c/.h |
Jobs monitor popup: a live grid of control-API jobs (scans + checks) |
fissure_gui_logger.c/.h |
Logger popup: the cross-tool traffic log (a Logger++-style view) |
fissure_gui_main.c/.h |
The four frameless layout windows and the scaled GUI metrics |
fissure_gui_matchrep.c/.h |
Match-and-replace rule editor popup |
fissure_gui_mdfonts.c/.h |
Shared faces and helpers for the rendered-Markdown panes (n_gui markdownview) |
fissure_gui_multitool.c/.h |
The Multitool view: encoding / JWT / hash workbench |
fissure_gui_nav.c/.h |
The Targets navigation pane: a live list of scanned hosts |
fissure_gui_oast.c/.h |
OAST popup: control the out-of-band callback listener and view hits |
fissure_gui_organizer.c/.h |
Organizer popup: browse, annotate, and reuse stashed requests |
fissure_gui_palette.c/.h |
Command palette: a Ctrl+K launcher to search and run any action |
fissure_gui_paramjar.c/.h |
"Parameters" popup: edit the request-parameter jar a crawl carries |
fissure_gui_plugins.c/.h |
The Plugins view: list wrapped OSS tools, show status, run, install |
fissure_gui_pp.c/.h |
Intruder payload-processing pipeline editor (popup) |
fissure_gui_probes.c/.h |
Probes popup: host-level probes and page-capture evidence for one target |
fissure_gui_project.c/.h |
Projects popup: create, switch, and delete named workspaces |
fissure_gui_prompt.c/.h |
Shared modal single-line text-input dialog (a reusable POPUP) |
fissure_gui_proxy.c/.h |
The Proxy view: start/stop the intercepting proxy and browse captured flows |
fissure_gui_purple.c/.h |
Purple-team popup: recorded probes, imported defender telemetry, detection coverage |
fissure_gui_rawedit.c/.h |
Raw request editor: hand-author a byte-exact HTTP message and send it |
fissure_gui_rawrelay.c/.h |
Raw TCP/UDP interception relay popup (drives the control /api/relay routes) |
fissure_gui_repeater.c/.h |
The Repeater view: edit a request, send it, and see the response |
fissure_gui_report.c/.h |
The Report view: render the findings store and export it to a file |
fissure_gui_respool.c/.h |
Resource pools popup: the shared concurrency and rate budgets, with live counters |
fissure_gui_saml.c/.h |
SAML assertion workshop popup: decode, inspect, edit, strip, wrap, re-sign |
fissure_gui_scanopts.c/.h |
Custom scan-options popup: hand-pick check families and insertion points |
fissure_gui_schedule.c/.h |
Recurring scan schedules popup: create and manage scheduled scans |
fissure_gui_scope.c/.h |
Target-scope editor popup: edit the in-scope / out-of-scope pattern lists |
fissure_gui_search.c/.h |
Global Search popup: query captured traffic and findings |
fissure_gui_sequencer.c/.h |
Sequencer popup: randomness analysis of a token sample |
fissure_gui_sessrule.c/.h |
Session-handling rules editor popup |
fissure_gui_settings.c/.h |
Settings editor popup: theme, interface size, and request TLS default |
fissure_gui_shortcuts.c/.h |
Keyboard-shortcut editor popup: view and remap the bound actions |
fissure_gui_sitemap.c/.h |
The Target view: launch a scan and watch endpoints and findings fill |
fissure_gui_surface.c/.h |
Attack-surface popup: a Target-view rollup of the discovered endpoint inventory |
fissure_gui_tags.c/.h |
Inline transform-tag manager popup: custom (JavaScript) tags + variables |
fissure_gui_team.c/.h |
Team-collaboration popup (drives the control /api/team route) |
fissure_gui_theme.c/.h |
Runtime theme palettes, semantic colors, and base GUI layout metrics |
fissure_gui_token.c/.h |
Signed-token workshop popup: decode, edit, sign, verify, and forge JWTs |
fissure_gui_toolbaredit.c/.h |
Toolbar customizer popup: edit the collapsible category-group layout |
fissure_gui_useragent.c/.h |
User Agents manager popup: pick, add, edit and delete User-Agent presets |
fissure_gui_workflow.c/.h |
Visual workflow builder popup: compose and run a node pipeline |
fissure_htmlview.c/.h |
Render a full HTTP response to readable text for the Repeater view |
fissure_shortcuts.c/.h |
Remappable keyboard-shortcut model: named actions bound to keycodes |
fissure_spinner.c/.h |
Time-driven activity indicators and rates for long-running operations |
fissure_toolbar.c/.h |
Serializable toolbar layout: rows of categories, each grouping modules |
Makefile approach (NILOREA_SRC, like Hook)
Nilorea is NOT linked as a library. The Makefile compiles a curated
list of nilorea .c files directly into the Fissure binary,
exactly as Hook does. This avoids ABI / sanitizer mismatches and pulls
in only what is needed.
The curated list is NILOREA_MODULES (excerpt from the
Makefile, abridged):
NILOREA = ../../nilorea-library
NILOREA_MODULES = n_log n_str n_list n_hash n_common n_time n_gui n_wrap n_gui_md n_markdown \
n_network n_network_msg n_base64 n_pcre \
n_reactor n_zlib n_lz4 n_x509 n_html n_thread_pool \
n_hex n_digest n_random n_cookies n_json n_query n_entropy n_http2 n_http2_server n_dns n_http3 n_clipboard n_files
NIL_SRC = $(addprefix $(NILOREA)/src/,$(addsuffix .c,$(NILOREA_MODULES)))
LZ4_SRC = $(NILOREA)/external/lz4/lib/lz4.c
CJSON_SRC = $(NILOREA)/external/cJSON/cJSON.c
FIS_SRC = $(wildcard src/*.c)
QUICKJS_SRC = quickjs/quickjs.c quickjs/libregexp.c quickjs/libunicode.c quickjs/dtoa.c
WARN = -Wall -Wextra -Wformat=2 -Wshadow
CFLAGS = $(WARN) -g -std=c99 $(SANITIZE) -D_GNU_SOURCE -DHAVE_OPENSSL \
-DHAVE_QUICKJS -DHAVE_CJSON \
-I$(NILOREA)/include -I$(NILOREA)/external/lz4/lib \
-I$(NILOREA)/external/cJSON -Iquickjs -Isrc
LDLIBS = -lssl -lcrypto -lz -lpcre2-8 $(PLATFORM_LIBS) -lyaml -lpthread -lm \
$(XMLSEC_LIBS) $(ALLEGRO_LIBS)
SANITIZE defaults to -O3 (the asan/tsan
targets swap in the sanitizers). PLATFORM_LIBS is
-lresolv -lX11 on Linux (the X11 clipboard and the DNS
client); the Windows build swaps in Winsock and friends. libxml2/xmlsec1
flags are added only to the two units that need them
(fissure_saml.c, fissure_xpath.c). HTTP/3 is
opt-in: when pkg-config finds ngtcp2 + ngtcp2_crypto_ossl + nghttp3 the
build adds -DHAVE_HTTP3 and links them, otherwise
n_http3 compiles as a stub that reports the feature
unavailable.
Main targets: all (the default goal), tests
(build and run the regression suite under tests/),
checks
(cppcheck --enable=all --error-exitcode=1, zero findings),
docs / doc (doxygen), docs-html
(the HTML documentation set), format (clang-format over
src/ and tests/), appimage,
deb, installer-windows, asan /
tsan (and their -tests variants),
fuzz, marketplace, windows /
windows-check (mingw cross-build), clean and
distclean. No build or packaging target changes the
version: it is stored in src/fissure_version.h, printed by
show-version and changed only by bump-version.
Header-dependency tracking uses -MMD -MP in the object
rules with -include $(DEPS) at the end of the Makefile so
the default goal stays all. QuickJS is compiled from the
bundled quickjs/ subdirectory with warnings relaxed, as in
Hook.
3. Transport core: what to reuse from Hook
Per audits/HOOK_AUDIT.md section 5, roughly 70% of
Hook's non-GUI code is directly reusable. Fissure forks Hook's transport
modules into fissure_* rather than depending on Hook (the
two are separate apps). Concretely:
- Request engine (native only): port
hook_request.c. It usesnetw_connect_to,netw_ssl_connect_client_to,netw_ssl_do_handshake,netw_send_data/netw_recv_data, read-until-stall with timeout detection,N_URLparsing, and then_proxy_*tunnel helpers. Hook's optional curl shell-out backend is intentionally not ported, Fissure uses the native engine exclusively. - Response model + timing: port
hook_response.hHOOK_RESPONSE/HOOK_TIMINGtoFISSURE_RESPONSE/FISSURE_TIMING(backend-agnostic prepare/dns/tcp/ssl/wait/download/process microsecond breakdown). - Auth: the request model carries
FISSURE_AUTH_NONE/_BASIC/_BEARER/_APIKEY(src/fissure_request.h); auth fields expand templates at send time. Challenge-driven auth is separate:fissure_httpauthanswers aWWW-Authenticatechallenge with Basic or Digest (RFC 7616 with the RFC 2069 fallback; MD5, MD5-sess, SHA-256), so a target behind HTTP auth works across the tools. - Cookie jar: the suite-wide jar is Nilorea's
N_COOKIE_JAR(n_cookies), wrapped byfissure_cookiejaras one process-global jar shared by every tool. - History: there is no separate history module. Proxy captures live in
the
FISSURE_CAPTURESstore (fissure_capture), and the cross-tool request log isfissure_trafficlog. - Scripting (QuickJS):
fissure_jshosts user-authored checks over thefs.*API (passive by default,fs.sendwhen the scan is active). It also backs extension checks, session actions, transform tags and the userscript hooks, so it is load-bearing, not optional. - Cancellation:
fissure_cancelportshook_cancel.cfor the foreground request worker (manual replay/edit-and-send). The proxy and scanner use their own shutdown-based interruption (section 7).
Hook's request-authoring features have since been rebuilt on
Fissure's own models rather than ported: environments
(fissure_env), GraphQL (fissure_graphql),
API-definition import (fissure_apispec, OpenAPI / Swagger /
Postman) and the Repeater's multiple request tabs and per-project
collections (fissure_repeater_tabs,
fissure_repeater_tabs_cfg).
4. Plugin system design
The plugin host wraps existing OSS security tools without linking
them. Each tool is described by a JSON manifest under
plugins/. The host validates the manifest, checks the
binary is installed (via resources/dependencies.json),
expands an argument template against the current target, runs the tool
as a detached subprocess, captures stdout/stderr, parses the output into
FISSURE_FINDING records, and merges them into the shared findings
store.
Subprocess model
Plugins run through fissure_proc_capture
(src/fissure_proc.c), called from
fissure_plugin_run. There is no shell:
fissure_plugin_build_argv builds an argv array (optional
interpreter, then binary, then each expanded
args entry) and the child execvps it directly.
The child calls setsid() so it leads its own process group
and survives the launching terminal closing; its stdout/stderr come back
through a pipe, and an optional stdin payload is written to it.
Cancellation sends SIGTERM to the process group then the pid
(fissure_proc_signal_pid), escalating to SIGKILL, and an
optional timeout kills the child after a set time. Several plugins can
run at once, so fissure_plugin_run.c keeps a mutex-guarded
table of live pid slots (FISSURE_PLUGIN_MAX_JOBS) that
fissure_plugin_cancel_all walks; each job also publishes
its own pid slot so it can be cancelled alone. Plugin execution is
compiled out on Windows (FISSURE_HAS_PLUGINS).
Manifest schema
| Field | Type | Meaning |
|---|---|---|
id |
string | Stable unique id (e.g. nuclei), used as the finding
source_tool |
name |
string | Display name |
category |
string | One of recon, fuzzing,
vuln_scan, sqli, discovery, and
so on |
binary |
string | Executable name resolved on PATH, the user install dirs, or a git_clone checkout |
interpreter |
string | Optional; runs a script binary as
<interpreter> <binary> ... (e.g.
python3 for git_clone'd sqlmap.py) |
version_args |
array | Args to print version (presence + version probe) |
dependency |
string | Key into resources/dependencies.json for
install/download |
args |
array | Argument template, tokens expanded per run (see below) |
stdin |
string | Optional template, expanded with the same tokens, written to the child's stdin (e.g. dnsx reads its hosts there) |
output |
object | `{ "format": "json" |
map |
object | How parsed fields map onto FISSURE_FINDING |
default_severity |
string | Fallback severity when the tool gives none |
confidence |
string | Default confidence for this tool's findings |
Argument template tokens: {{target_url}},
{{target_host}}, {{scope_file}} (a temp file
of in-scope hosts/URLs the host writes per run),
{{out_file}} (temp output path the host creates and reads
back), {{wordlist}}, {{threads}}, and
{{extra}} (user-supplied free args from the GUI). Expansion
is expand_tokens in src/fissure_plugin_run.c,
a plain substitution inside each argv element. An args
entry that is exactly {{extra}} is split on spaces into
separate argv elements. Because nothing passes through a shell, a token
value cannot break out of its argument and no quoting helper is
needed.
Output parsing:
json/jsonl: parse with cJSON;mapnames JSON paths for each finding field.jsonlparses one finding per line (nuclei, httpx, katana). Forjson, a top-level array is each record and a top-level object is a single record; when the tool wraps its findings in an envelope,output.recordsgives the dotted path to the records array (e.g. dalfox{"findings":[...]}uses"records": "findings").regex: an n_pcre pattern with numbered capture groups;mapnames which group (by number, "0".."9") fills which finding field (nikto, sqlmap text output).lines: one finding per non-empty output line (the default whenformatis absent; plain URL/host listers such as subfinder, gau, waybackurls).text: store the raw output as a single informational finding (last resort).sslyze: sslyze's JSON report, read by a dedicated parser that walksserver_scan_results.
An unknown format value is logged as a manifest error
and read as lines.
Example manifest (nuclei)
{
"id": "nuclei",
"name": "Nuclei template scanner",
"category": "vuln_scan",
"binary": "nuclei",
"version_args": ["-version"],
"dependency": "nuclei",
"args": ["-u", "{{target_url}}", "-jsonl", "-o", "{{out_file}}",
"-severity", "low,medium,high,critical", "-rate-limit", "150",
"-timeout", "10", "-retries", "1", "-disable-update-check",
"-silent", "{{extra}}"],
"output": { "format": "jsonl", "source": "{{out_file}}" },
"map": {
"title": "info.name",
"severity": "info.severity",
"category": "info.tags",
"cwe": "info.classification.cwe-id",
"evidence": "matched-at",
"remediation": "info.remediation",
"url": "host"
},
"default_severity": "info",
"confidence": "firm"
}Mapping into the unified model: for each parsed record the host
builds a FISSURE_FINDING, fills mapped fields, sets
source_tool = manifest.id and
source = FISSURE_SRC_PLUGIN, normalizes severity to the
FISSURE_SEV_* enum, sets location from the mapped
url, and computes the dedup key (host + category + title +
normalized location). The finding joins the shared store like any other;
the views relate it to an endpoint by its location URL.
resources/dependencies.json keys each tool to an install
method. fissure_depmgr builds a shell install command for
go_install, pip, gem,
apt, git_clone, github_release
(download the asset matching asset_pattern from the release
API, extract it, and place the binary under the install root's
bin/), and script (fetch a single executable
into bin/).
The pip method walks three routes, in order, none of
them needing root, because a PEP 668 externally-managed Python (modern
Debian/Ubuntu/Fedora) refuses a plain pip install --user
outright with externally-managed-environment:
pipx install first (what such a Python expects for a
command-line tool: an isolated venv with the script in
~/.local/bin), then pip install --user retried
with --break-system-packages, then a private venv under
<install_root>/venv/<tool> whose console script
is symlinked into <install_root>/bin, where detection
already looks. An optional url on a pip install object (a
git+https spec) replaces the package name as what is
installed, for a tool whose usable version is not the one published on
PyPI (paramspider: the PyPI name is a reserved placeholder
package that installs successfully and ships no tool). The
gem method installs a Ruby tool with
gem install --user-install --no-document and symlinks the
executable out of the user gem dir into
<install_root>/bin, again without root: it is how
wpscan is installed, since no distribution packages it. A
gem with native parts needs a compiler and the Ruby headers to build,
which the appended apt_deps step cannot supply (by then the
build has already failed), so a gem install object takes
build_deps instead: that package list is installed as root
ONLY after a failed build, and the install is retried once. A machine
that already has the headers never sees a password prompt it did not
need (wpscan declares
ruby-dev build-essential, without which its
yajl-ruby dependency fails to compile).
A step that genuinely needs root (apt,
apt_deps) does not call sudo directly. Install
commands run from a background job with no controlling terminal, where
sudo can only fail with "a terminal is required to read the password".
They call a fissure_sudo shell function that the command
carries (defined once, and only when the command uses it), which tries
running as root already, a passwordless sudo, an askpass helper
($SUDO_ASKPASS or a known ssh-askpass/ksshaskpass binary,
driving sudo's graphical prompt), then pkexec (the desktop
polkit prompt), and when nothing can ask, prints the exact command to
paste into a terminal, so the refusal is actionable instead of
opaque.
When a method cannot be built it falls back to the manifest's
fallback; when it builds but a fallback
exists, the two are chained (( primary ) || { fallback; })
so a primary that fails at run time, such as a git_clone
with no git on PATH, degrades to the fallback (for example
nikto falls back to an apt install). A
git_clone checkout always lands in
<install_root>/<tool id>, which is what a data
set's path field names (relative to the install root); a
test holds the two together, because the field spent a long time
advertising a data/ layout the installer never used. An
optional apt_deps string on the install object (a
space-separated package list) appends a system-package install so a tool
that needs system packages at run time gets them, for example
nikto (a git_clone) needs the Perl modules XML::Writer /
JSON for its report plugins
(libxml-writer-perl libjson-perl), without which it aborts
at startup. The install root is $HOME/.local/share/fissure
(fissure_depmgr_install_root). Detection
(fissure_depmgr_which) searches PATH plus the directories
installs write to, the install root's bin,
~/go/bin (go_install), ~/.local/bin (pip
--user), and recurses a few levels into the install root for git_clone
checkouts, accepting a readable (not only executable) script, so an
interpreted tool left without the execute bit or nested a directory down
(nikto's program/nikto.pl) is still found; the runner
resolves the binary the same way before exec. An install job re-runs
that detection when its command exits: a command can succeed and still
leave nothing runnable (a package that ships no executable, a script
that landed off PATH), so the Plugins view reports "still not installed"
with a popup naming the tool instead of a green exit code the operator
only sees through later when the tool refuses to run. Install/download
is always an explicit user action, never automatic. See
01_SECURITY_TOOLS_CATALOG.md for the full catalogued tool
set and recommended manifests.
Status: implemented. fissure_plugin loads/validates
manifests, fissure_plugin_run expands the arg template and
runs the tool detached (execvp, no shell),
fissure_plugin_parse maps
JSONL/JSON/regex/lines/text/sslyze output onto findings,
fissure_plugin_host orchestrates a run (temp out_file, run,
parse), and fissure_depmgr reports PATH status and builds
the install command. The Plugins GUI view
(fissure_gui_plugins) lists tools with their status and
runs or installs the selected one. Jobs run on a pool of worker threads
(up to PLUG_MAX_JOBS), so several plugins/installs run concurrently; a
"Running: N" toggle opens a panel of active jobs (target, options,
elapsed) with a per-job Cancel and Cancel all (cancellation kills the
job's process group via the child pid published by fissure_plugin_run
for runs, or by the view's run_shell helper for install
commands). Finished jobs are reaped on the GUI thread, merging plugin
findings into the shared findings store. The view is split: the plugin
list and controls on top, a tabbed Output pane below; "Add to report"
turns the shown output tab into an Info finding in the shared store so
the raw tool output is included in the generated report. Each run or
install opens a tab: a run tab lists the findings produced, an install
tab shows the captured install log (so a failure such as a missing Go
toolchain or a wrong release asset is visible). The tab strip is a
sliding window over the stored outputs (kept in memory, oldest evicted
past a cap, discarded at exit) with Prev/Next paging and an "n-m/total"
count. "Install all" installs every not-yet-present tool in sequence.
The view also has a "Wordlist" path field, supplied to tools whose
argument template uses {{wordlist}} (ffuf, gobuster,
feroxbuster). At launch the runner resolves the tool binary to a full
path via fissure_depmgr_which (PATH plus the user install
dirs and git_clone checkouts), so a tool installed off PATH still runs.
38 manifests ship under plugins/ (recon, discovery,
fuzzing, vuln scanning, SAST/SCA and secret scanning: nuclei and its
CVE/exposure variants, ffuf, httpx, katana, dalfox, subfinder, amass,
sqlmap, nikto, zap, sslyze, testssl, semgrep, trivy and more; see
plugins/README.md), which the AppImage bundles next to the
executable alongside resources/.
5. Unified data model
One model serves the GUI and the report. The excerpts below are copied from the headers (doxygen trimmed); the headers are authoritative.
/* src/fissure_finding.h */
typedef enum {
FISSURE_SEV_INFO = 0, FISSURE_SEV_LOW, FISSURE_SEV_MEDIUM,
FISSURE_SEV_HIGH, FISSURE_SEV_CRITICAL
} FISSURE_SEVERITY;
typedef enum {
FISSURE_SRC_PROXY = 0, /* observed in MITM traffic */
FISSURE_SRC_SCANNER, /* built-in native check */
FISSURE_SRC_PLUGIN, /* external tool */
FISSURE_SRC_MANUAL /* analyst-entered */
} FISSURE_SOURCE;
typedef enum {
FISSURE_CONF_TENTATIVE = 0, FISSURE_CONF_FIRM, FISSURE_CONF_CERTAIN
} FISSURE_CONFIDENCE;
typedef enum {
FISSURE_TRIAGE_OPEN = 0, FISSURE_TRIAGE_CONFIRMED,
FISSURE_TRIAGE_FALSE_POSITIVE, FISSURE_TRIAGE_IGNORED
} FISSURE_TRIAGE;
typedef struct FISSURE_FINDING {
FISSURE_SEVERITY severity;
char* category; /* free text, e.g. "Injection" */
char* cwe; /* "CWE-89" */
char* owasp; /* "A03:2021-Injection" */
char* title;
char* description;
char* evidence; /* matched payload / response snippet */
char* location; /* URL or position the finding applies to */
char* remediation;
FISSURE_CONFIDENCE confidence;
FISSURE_SOURCE source;
char* source_tool; /* manifest id when source == PLUGIN */
char* endpoint_id; /* owning endpoint reference, or NULL */
char* request_ref; /* capture id whose request reproduces it */
char* response_ref; /* capture id whose response is the evidence */
char* dedup_key; /* host|category|title|location */
int host_scoped; /* site-wide: dedup_key omits the location */
int64_t created_us;
FISSURE_TRIAGE triage; /* analyst triage state (default open) */
char* notes; /* free-text analyst notes */
char* tags; /* comma-separated analyst tags */
} FISSURE_FINDING;
/* src/fissure_findings.h: the deduplicated store */
typedef struct FISSURE_FINDINGS {
LIST* items; /* FISSURE_FINDING* (owns the storage) */
HASH_TABLE* by_dedup; /* dedup_key -> FISSURE_FINDING* */
FISSURE_REDACTOR redactor; /* applied to free-text fields on add */
void* redactor_ctx;
} FISSURE_FINDINGS;
/* src/fissure_endpoint.h */
typedef struct FISSURE_ENDPOINT {
char* method; /* upper-cased, e.g. "GET" */
char* url; /* canonical URL (n_url_canonicalize_string) */
LIST* params; /* N_STR* parameter names, deduped */
int from_proxy; /* seen in the proxy history */
int from_crawl; /* found by the crawler */
int from_import; /* imported from an API definition */
int from_discover; /* found by content discovery */
int from_recon; /* seeded from an external recon tool */
char* content_type; /* last observed Content-Type */
int last_status; /* last observed status, 0 if never seen */
char* request_body; /* last observed request body (body fuzzing) */
char* request_headers; /* last observed header block (header/cookie fuzzing) */
char* highlight; /* manual row-highlight color name */
} FISSURE_ENDPOINT;
/* src/fissure_inventory.h: the deduplicated endpoint store */
typedef struct FISSURE_INVENTORY {
LIST* endpoints; /* FISSURE_ENDPOINT* (owns the storage) */
HASH_TABLE* by_key; /* "METHOD canon_url" -> FISSURE_ENDPOINT* */
} FISSURE_INVENTORY;There is no target or scan-session record and no single store object.
A scan (FISSURE_SCAN, fissure_scan.c) owns its
three stores, reached through fissure_scan_findings,
fissure_scan_inventory and
fissure_scan_captures, and guards them with one store lock
(fissure_scan_lock / _trylock /
_unlock). Findings are not linked to endpoints by id: a
finding carries its location, and the views join the two by
URL. Hosts are derived from the inventory on demand
(fissure_inventory_hosts).
A FISSURE_CAPTURE (defined in fissure_capture.h) holds a
request/response pair plus timestamps; request_ref /
response_ref on a finding point at one. Persistence is per
store, all under the active project's directory:
fissure_session_save writes the findings as NDJSON (one
finding per line, every field, so the store round-trips),
fissure_session_save_captures writes the backing captures
to a sibling <session>.captures file through
fissure_captures_save, and
fissure_inventory_save writes the endpoint inventory. A
findings file stays valid alone: a report still renders (without
resolvable evidence) when the captures sibling is absent.
Status (capture model + store): implemented in
fissure_capture.c/.h. A FISSURE_CAPTURE records the method,
URL, request headers/body, response status/headers/body, the
FISSURE_TIMING breakdown, and a creation timestamp, identified by a
stable id (c<N>). A FISSURE_CAPTURES store keeps the
captures in a LIST and an id -> capture hash for O(1) lookup;
fissure_captures_add assigns an id when one is absent (and
advances the generator past any numeric id loaded from disk so ids stay
unique). The store serializes to base64-framed NDJSON, one capture per
line, the same codec the proxy uses for its flow history
(fissure_proxy.c, n_base64 over binary-safe
bodies, cJSON), via fissure_captures_save /
fissure_captures_load, so bodies containing NULs round-trip
byte-for-byte. Wiring findings to captures (request_ref /
response_ref), persisting the store alongside the findings
session (fissure_session_save_captures /
fissure_session_load_captures), and resolving evidence from
captures at render time (fissure_report_finding_evidence)
all shipped. The GUI report view attaches a live capture store too
(fissure_report_model_set_captures with
fissure_gui_sitemap_captures), and a project's captures
persist with its findings and reload on reopen
(fissure_session_save_captures /
_load_captures + fissure_captures_merge in
fissure_gui_sitemap), so evidence excerpts resolve for a reopened
project the same as for the CLI and report --session.
Capture-store wiring is complete.
6. How everything is linked (data flow)
One scan's stores tie the four modules together.
- The analyst sets the browser/OS proxy to Fissure and installs the minted root CA. The proxy listens, accepts, mints a per-host leaf cert on first SNI, and forwards traffic. Every exchange becomes a flow in the proxy's history.
fissure_proxy_seed_inventoryrecords each flow into the endpoint inventory (fissure_inventory_recordwith the proxy source flag: canonical URL, method, status, content type), deduping by method + canonical URL. Proxy browsing thus seeds the inventory passively.- The scanner can also populate the inventory actively: the crawler
BFS-walks from a seed target, extracts links and forms, and adds
endpoints flagged
from_crawl. API-definition import, content discovery and recon seeding add theirs with their own flags. All converge on the same dedup'd endpoint set. - The scanner runs built-in checks against inventory endpoints
(n_thread_pool fan-out). Each positive result becomes a FISSURE_FINDING
with
source = SCANNERand the exchange that proves it is stored as a capture referenced byrequest_ref/response_ref. - The plugin host runs selected external tools against the same
target/scope. Parsed results become FISSURE_FINDINGs with
source = PLUGIN,source_tool = <id>, merged into the shared findings store on the GUI thread. The dedup hash collapses duplicates that several tools report. - The Findings view reads the store live (sortable grid, filter by
severity/triage/source/text) and the detail pane resolves
request_ref/response_refback to the capture for evidence. - The report generator takes the finished (or in-progress) findings
store and aggregates: counts by severity, findings grouped by category,
evidence excerpts resolved from the captures, remediation, and a risk
score. It renders HTML (from a template), Markdown, JSON, CSV, SARIF and
an issue-XML export, and the GUI also produces a PDF through an external
converter. Nothing in the report comes from outside the stores, so the
report is reproducible from the saved NDJSON session
(
fissure report --session).
The invariant: modules write findings/endpoints/captures into the store and never reach into each other. Adding a new finding source (a new plugin, a new built-in check) means producing FISSURE_FINDING records, no GUI or report change required because both consume the model, not the producer.
7. Threading model
Fissure reuses Hook's worker + mutex + atomic discipline (cited from
audits/HOOK_AUDIT.md section 4: a mutex around shared model
fields, atomic version counters for lock-free GUI polling, worker-exit
handshake with shutdown(SHUT_RDWR) to break blocking recv,
and "wait then leak rather than risk a UAF" at teardown).
State ownership:
FISSURE_APP(src/fissure_app.h) is plain GUI-thread state with no mutex of its own: it owns the long-lived subsystems (settings, proxy, live audit, HaE, and so on) and each subsystem carries its own lock. The scan's findings, inventory and captures share the scan store lock described in section 5.fissure_logis a thin wrapper over Nilorean_log(init and destroy only). The on-screen event panel is a separate module,fissure_eventlog, a process-wide in-memory list of engine events that the Event-log popup reads.- The GUI's per-frame view ticks never block on a store lock: they
take it with
fissure_gui_sitemap_trylock(which wrapsfissure_scan_trylock) and retry on the next frame, because a running scan can hold the lock across multi-second probes.
Proxy threading (see 04_NETWORK_AND_PROXY.md):
- A listen/accept loop runs on its own thread
(
accept_thr) usingnetw_make_listening+netw_accept_from. Each accepted connection gets a detached per-connection worker thread (pthread_create+pthread_detach) that does the MITM handshake, reads the client request, optionally blocks on the intercept queue (analyst forward/drop/edit), forwards upstream via the transport core, and streams the response back. There is no reactor mode. - The flow history and WebSocket captures are guarded by the proxy's
flows_lock; live worker sockets byworkers_lock; appends to the on-disk history byhistory_lock. The intercept queue (fissure_intercept) is a mutex- condvar holding pending messages; the GUI signals forward/drop, which wakes the worker.
- Stopping the proxy
shutdown()s the listen socket and each live worker socket to unblock accept/recv promptly (the same shutdown-to-interrupt trick Hook uses for SSE/WS).
Scanner threading (see 05_WEBSITE_SCANNER.md):
- The audit fans out over
n_thread_pool(new_thread_pool+add_threaded_process+wait_for_threaded_pool), one job per endpoint. All network I/O runs without the scan lock; workers build findings locally and only the brief merges into the shared stores (and the dedup hash insert) happen under it. - Progress counters such as
pages_audited, and the pause flag, are accessed with__atomic_*so the GUI progress bar reads them without contending the store lock every frame.
Plugin host threading:
- The Plugins popup (
fissure_gui_plugins.c) runs jobs on a fixed pool of worker threads (PLUG_MAX_JOBS, 8 slots). Each worker runs one plugin (or an install) throughfissure_proc_capture, which drains the child's pipe itself, and fills a worker-owned findings store and output buffer, then sets itsdoneflag atomically. fissure_gui_plugins_tickreaps finished jobs on the GUI thread: it joins the worker, takes the scan store withfissure_gui_sitemap_trylock(skipping to the next frame if busy), merges the job's findings into the shared store, and opens the output tab. The live pid table used for cancellation is mutex-guarded infissure_plugin_run.c.
Lock order (ASan/TSan validated): the scan store lock is the outermost model lock and is never held across network I/O; subsystem locks (proxy flows, intercept queue, plugin pid table) are taken briefly and are innermost. Never take a store lock while holding one of those. As in Hook, atomic flags and counters let the GUI fast-path avoid the locks entirely.
8. Cross-links
00_MASTER_PLAN.md- phased build plan and milestones.01_SECURITY_TOOLS_CATALOG.md- catalogued OSS tools and recommended plugin manifests (feeds section 4).03_GUI_DESIGN.md- window layout, popups, findings grid, theme (expands the GUI layer; seeaudits/HOOK_AUDIT.mdsections 1-2 for the patterns).04_NETWORK_AND_PROXY.md- MITM proxy internals, cert minting, intercept queue (expands sections 1 proxy box, 6 step 1, 7 proxy threading; needs the nilorea additions inaudits/NILOREA_AUDIT.mdsection 5A).05_WEBSITE_SCANNER.md- crawler, inventory, checks, automation (expands sections 1 scanner box, 6 steps 3-4, 7 scanner threading; needs then_html/ canonicalization additions inaudits/NILOREA_AUDIT.md5B).06_REPORTING.md- report templates and rendering (expands section 6 step 7).audits/HOOK_AUDIT.md- reusable GUI/transport/threading patterns.audits/NILOREA_AUDIT.md- library capability inventory and the gap list of functions to add upstream (n_x509, n_html, n_digest, n_hex, GUI widgets).audits/SKETCHR_AUDIT.md- DPI/font-scaling recipe to improve on Hook's fixed font limitation.