Fissuredocumentation v5.3.1
On this page

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:

  1. An intercepting HTTPS proxy (man-in-the-middle, on-the-fly cert minting, request/response edit-and-forward, capture history).
  2. A full website scanner (crawl -> endpoint inventory -> vulnerability tests, manual or fully automatic).
  3. A plugin host that wraps external open-source security tools (nuclei, ffuf, sqlmap, nikto, subfinder and more) as detached subprocesses.
  4. 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 uses netw_connect_to, netw_ssl_connect_client_to, netw_ssl_do_handshake, netw_send_data / netw_recv_data, read-until-stall with timeout detection, N_URL parsing, and the n_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.h HOOK_RESPONSE / HOOK_TIMING to FISSURE_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_httpauth answers a WWW-Authenticate challenge 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 by fissure_cookiejar as one process-global jar shared by every tool.
  • History: there is no separate history module. Proxy captures live in the FISSURE_CAPTURES store (fissure_capture), and the cross-tool request log is fissure_trafficlog.
  • Scripting (QuickJS): fissure_js hosts user-authored checks over the fs.* API (passive by default, fs.send when 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_cancel ports hook_cancel.c for 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; map names JSON paths for each finding field. jsonl parses one finding per line (nuclei, httpx, katana). For json, 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.records gives the dotted path to the records array (e.g. dalfox {"findings":[...]} uses "records": "findings").
  • regex: an n_pcre pattern with numbered capture groups; map names which group (by number, "0".."9") fills which finding field (nikto, sqlmap text output).
  • lines: one finding per non-empty output line (the default when format is 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 walks server_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.

  1. 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.
  2. fissure_proxy_seed_inventory records each flow into the endpoint inventory (fissure_inventory_record with the proxy source flag: canonical URL, method, status, content type), deduping by method + canonical URL. Proxy browsing thus seeds the inventory passively.
  3. 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.
  4. The scanner runs built-in checks against inventory endpoints (n_thread_pool fan-out). Each positive result becomes a FISSURE_FINDING with source = SCANNER and the exchange that proves it is stored as a capture referenced by request_ref / response_ref.
  5. 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.
  6. The Findings view reads the store live (sortable grid, filter by severity/triage/source/text) and the detail pane resolves request_ref / response_ref back to the capture for evidence.
  7. 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_log is a thin wrapper over Nilorea n_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 wraps fissure_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) using netw_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 by workers_lock; appends to the on-disk history by history_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) through fissure_proc_capture, which drains the child's pipe itself, and fills a worker-owned findings store and output buffer, then sets its done flag atomically.
  • fissure_gui_plugins_tick reaps finished jobs on the GUI thread: it joins the worker, takes the scan store with fissure_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 in fissure_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.

  • 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; see audits/HOOK_AUDIT.md sections 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 in audits/NILOREA_AUDIT.md section 5A).
  • 05_WEBSITE_SCANNER.md - crawler, inventory, checks, automation (expands sections 1 scanner box, 6 steps 3-4, 7 scanner threading; needs the n_html / canonicalization additions in audits/NILOREA_AUDIT.md 5B).
  • 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.