Fissuredocumentation v5.3.1
On this page

Changelog

Everything Fissure has shipped, newest first, one line per unit of work, in the order the work landed. It starts at the first commit and runs to the current build, grouped into the arcs the work actually took.

Pure bookkeeping (harvesting a finished item into the archive, recording a status, a gitignore entry, a version stamp, a reformat) is not listed on its own line; every change that altered the program or its documentation is. The as-built detail behind each entry is in docs/TODO_DONE.md, the canonical inventory of what Fissure does is docs/FEATURES.md, and the commit history carries the full reasoning.

A version that only moves by hand, and a freeware license

  • The version changes only with make bump-version (last number plus one, or VERSION=x.y.z to set it), and make show-version prints it. make deb, make appimage, make docker-build and make release no longer stamp a new version: they build the one the tree carries. The former make bump is gone, and the 0-9 rollover with it.
  • Fissure is freeware: the license grants free use of the published binaries and keeps sale, modification and redistribution reserved. The README, the About box, the in-app help, the Debian control file, the AppStream metadata and the Windows version resources say so.

Organizer removal and the outline of native popups

  • Removing a stashed request from the Organizer works again. The dialog read the store's answer backwards, so a successful removal was reported as "that request is gone", the grid kept the row and organizer.json was not rewritten.
  • A popup shown as a native OS window draws all four sides of its outline. The stroke is centred on the window rectangle, and a native window fills its own surface from the origin, so the left side (and with it the bottom one) fell outside and was never drawn. Fixed in Nilorea's n_gui, which insets the stroke for a detached window.

Sending a chat message from the keyboard

  • In the AI chat message field Ctrl+Enter or Shift+Enter sends the message, the same as the Send button; a plain Enter still starts a new line. The chord acts only while the field holds the focus and the chat is the topmost window.

Windows files that say what they are

  • The Windows build names and signs its files. fissure.exe and fissure-cli.exe carry a version resource (company NiloreaStudio, product, file name, version); every exe and DLL in dist/windows/ and in the installer is stripped of its debug sections (the installer goes from 37 MB to 13 MB); and with osslsigncode and the publisher's key on the build machine they, the installer and the uninstaller are signed with the self-signed NiloreaStudio certificate, shipped beside the exe as NiloreaStudio.cer. WIN_SIGN=auto|1|0 selects the mode. The CI on the project's server signs when it holds the pair as the secrets WINSIGN_KEY_PEM and WINSIGN_CERT_PEM, never for a pull request, and builds unsigned without them. A build never creates the key and stops on one whose fingerprint is not the pinned one; make release fails rather than build unsigned, and Add/Remove Programs names NiloreaStudio as publisher. The README gives the fingerprint and the certutil commands to trust it.

One release, one version

  • make release stamps the version once and builds every distributable at it: the local and the Docker .deb + AppImage, the cross-built Windows binary and the Windows installer. Its tool and sysroot preflight runs before the stamp, so a refused release leaves the tree untouched.

A dashboard that reaches every route, and proxy, auth-check and HTML-docs fixes

  • The browser dashboard shows and reaches everything the control API does. Status carries a workspace overview (project, scope, proxy, traffic, jobs), every state-bearing tab loads on open and on Connect, proxy flows open their request and response, and Traffic and Projects are new tabs. A declarative view/action engine builds each card from the route's documented body, so 27 views and 72 actions cover the formerly console-only routes (Config, Proxy, Extensions, Plugins, Saved, Relay and additions to the existing tabs), and the API tab still lists every route. A control-bypass action shows the code-of-conduct notice before it runs; project Delete is disabled on the default and active rows with the reason, and deleting the active named scope says which scope becomes enforced.
  • The dashboard's route catalog is generated from docs/11_CONTROL_API.md by packaging/gen-webui-routes.py, and make webui-check fails when it is stale. tests/test_control_routes fails the build on a route that has neither a dashboard view nor a recorded console-only reason, and tests/test_webui_browser drives headless Chrome over CDP through every tab (skipped when no browser is installed).
  • The intercepting proxy strips HTTP/1.1 hop-by-hop headers before an HTTP/2 or HTTP/3 upstream. A client sending Connection: Keep-Alive, TE with a TE coding list had TE relayed verbatim to an h2 origin, which reset the stream and gave the client a 502. TE is now forwarded only as te: trailers, and every header the Connection header nominates is removed (never Host, Content-Length or Transfer-Encoding); tests/test_proxy_h2upstream covers it.
  • auth_check accepts the login config inline, as documented and as start_scan takes it. The /api/auth/check handler used to treat the inline config as a file path, so every inline login returned verdict "failed" with no cookies. The CLI --login and the GUI keep the path form. Covered by tests/test_auth and an MCP bridge smoke case.
  • MCP and skill setup, from a full walkthrough against DVWA from a built .deb: the skill's scripts/preflight.py finds the bridge in the package locations (and honours FISSURE_BRIDGE) once the skill is copied into ~/.claude/skills, the network MCP transport is documented as serving at /mcp and /sse, and the bridge README's manual smoke recipe uses a target that works.
  • The HTML documentation reflows to the window width: the paragraph width caps are gone, code wraps to its block with a Wrap / No wrap toggle next to Copy, long table cells break, ASCII diagrams stay unwrapped behind an always-drawn scrollbar, and table columns no longer collapse to one character per line.
  • A build without plugin support compiles warning free again: the CLI's plugin manifest loader is compiled out with the fissure plugins subcommand that is its only caller.

A customisable report template and the documentation brought current

  • The HTML report template is user-editable: <config>/report.html.tmpl overrides the bundled resources/report/report.html.tmpl (which was shipped but never loaded), with an identical built-in copy as the last resort. It is read at every render, a template missing {{findings_html}} is rejected with the reason on screen (GUI popup, CLI stderr, template_error in the control-API / MCP report), and the report response names the template used.
  • The Markdown set was audited against the code and corrected: the planning-era design docs (architecture, GUI, proxy, scanner, reporting, PwnDoc, IAST) now describe what is built, the control-API, MCP-setup, DVWA, extension-SDK, purple-team and lab docs no longer give instructions that fail, and the tutorials walk the current GUI (Scan options tabs, Edit scope, native Findings multi-select, the full popup map).
  • The MCP bridge's network transport defaults to port 8779 instead of 8778, which the control-driven proxy also uses by default, so both run side by side with defaults.
  • The intercepting proxy no longer reuses an HTTP/2 upstream leg: its h2 exchange is single-shot, so the second request on a kept leg re-sent the connection preface on stream 1, a protocol error the origin rejected and a one-shot reconnect hid (a failed round trip per request and a PROTOCOL_ERROR in the origin's logs). Each request to an h2 origin now gets its own connection; tests/test_proxy_h2upstream covers it.
  • A fresh config no longer logs an error line at startup for the absent shared-budget store (respools.json): it is read through the quiet optional-config loader like the other per-project stores.
  • In-app help: Ctrl+G (not F3) repeats a Find, Plugins is a popup, nuclei workflows are compiled as gates, and the toolbar customizer lives under Settings > Appearance.

Request-corpus scanning, a fully gated layout sweep, and published CI releases

  • The scanner can audit a request CORPUS directly, with no crawl: fissure scan --endpoints-file <json> (control-API POST /api/scans endpoints, MCP start_scan endpoints) takes a JSON array of {method,url,content_type,body,headers,params} and fuzzes each across the query, form-body, cookie and allowlisted-header insertion points. The OWASP Benchmark lab harness uses it to score ~1198 cases (getparam + formparam + cookie) instead of the 334 GET-query cases a crawl reaches.
  • Two Benchmark-surfaced detection gaps closed: a path-traversal reflection oracle (flags a traversal reflected inside a server-built filesystem path, pathtraver 0/30 -> 3/3, no new false positives) and Java/JDBC error-based SQL-injection signatures (Hibernate/HSQLDB/H2 exceptions, Benchmark GET-SQLi recall 32% -> 100%).
  • The UI font picker is now proportional-only: a monospaced UI font set prose labels wider than their fixed boxes, so the two mono faces are kept for the Markdown renderer but dropped from the picker, and Roboto + Liberation Sans join the list (both matching the default's line height). The --selftest-geometry layout sweep now seeds the font and runs EVERY selectable face, and seeds the shared stores so data-driven views are audited populated, not empty.
  • The transient error-based SQLi oracle re-sends its probe and requires the same DB error to reproduce before reporting, removing a false positive seen under load.
  • The self-hosted Forgejo CI now PUBLISHES releases (modelled on AfterAPro on the same server): every push to main refreshes a rolling release carrying the Linux .deb + AppImage and the cross-built Windows installer, and a pushed v* tag cuts a named release.
  • A heap-use-after-free in the control API /api/report/pdf route is fixed: the handler freed the parsed JSON request before reading the output path out of it. Surfaced by the AddressSanitizer test run (make asan-tests), which also gained a missing test_cdp link dependency so the whole suite builds under the sanitizers again.
  • The .deb, the AppImage and the Windows installer now ship the MCP bridge and every Claude skill next to the binary (bridge/, skills/<name>/; /opt/fissure/... in the .deb), so an installed Fissure connects to Claude without a source checkout; docs/13 gives each package's paths and the AppImage extract command.

Rendered Markdown in the report preview and the AI panes

  • The Report view gained a Show: Source / Show: Rendered toggle. A Markdown report is drawn in place by nilorea's markdownview (headings, tables, lists, code, clickable http(s) links, mouse and keyboard selection); an HTML or PDF report opens in the desktop browser, and only on a click. Formats with no rendering grey the toggle out.
  • The web dashboard's Report tab has the same toggle: Markdown goes through a DOM-only renderer adapted from DarkChan's portal, HTML into a sandboxed iframe that can run no script and load nothing.
  • The AI assistant answer and the AI chat transcript render as Markdown, with a Copy button next to Close. The chat shows each speaker in bold and escapes what the operator typed, so a question containing markup cannot break the transcript.
  • A shared face registry (fissure_gui_mdfonts) loads the bold, italic, mono and heading faces at the UI size and re-points every pane when the interface size or font changes.
  • The in-app help no longer shows Markdown backticks around 'burp' and 'input'.

Two subdomain sources the documentation already promised

  • The help text, the methodology and the recon-chain description all named amass as a tool Fissure runs, and plugin_run("amass") named a manifest that did not exist. amass and findomain now ship plugin manifests, both recon-category, so the recon chain queries three subdomain sources (subfinder, amass, findomain) in one action instead of one.
  • findomain prints one name per line and is parsed as lines. amass needed more care: version 5 keeps its results in its own database, -silent prints nothing at all, and a plain run writes a progress bar that the plugin host merges into the same capture as the results. The manifest reads the hostnames out of that merged stream with the regex parser, so the bar, the "Session Scope" heading and the "FQDN:" label are not findings. Both manifests are tested against captured tool output rather than an idealised sample, and the amass test was checked to fail when the pattern is loosened.
  • Driving either one over the MCP bridge then failed on a 30 second client timeout the bridge had always carried: plugin_run runs the tool to completion, so every plugin slower than half a minute (which is most of them, and amass takes minutes) came back as a transport error for a run that was still going and would finish. The wait is now 600 seconds by default and configurable with SUITE_API_TIMEOUT. A control API that is not running refuses the connection immediately, so the longer wait only ever bounds real work. Both plugins were then confirmed through the bridge client itself, not only over the raw control API.

Two recipes that could not have worked, and a path nobody would find

  • Installing the last of the missing OSS tools turned up two more manifest entries that could never have succeeded. amass renamed its release asset, so the pattern amass_Linux_amd64.zip matched nothing and the install ended in "no matching release asset"; it is now amass_linux_amd64.tar.gz. assetfinder was a go_install, which needs a Go toolchain a Fissure install does not otherwise require, and its repository has no releases/latest endpoint at all (that URL is a 404), only a /releases list: it now downloads the released linux-amd64 binary from that list, keeping go_install as the fallback.
  • The four data sets (SecLists, PayloadsAllTheThings, nuclei-templates, fuzzdb) each declared a path of data/<name>, a directory the installer has never used: a git_clone checkout always lands in <install_root>/<tool id>. The field now names the real directory, the git_clone method description says where it clones, and a test asserts the declared path IS the clone destination for every git_clone tool, so the metadata cannot drift away from the installer again.

The install asked for a password where nobody could type one

  • Installing the optional OSS tools from the Plugins view failed three different ways on a current Debian, and each failure told the operator something they could not act on. A tool that is only a system package (masscan, and wpscan through its apt recipe) died on "sudo: a terminal is required to read the password": install commands run from a background job through /bin/sh with no controlling terminal, so sudo has nowhere to prompt. A Python tool died on "externally-managed-environment", because PEP 668 makes a modern distribution Python refuse "pip install --user" outright. And ParamSpider reported a successful install every time while installing nothing usable.
  • A step that needs root now calls a fissure_sudo function the command carries, defined once and only when it is used: run as root already, a passwordless sudo, an askpass helper (SUDO_ASKPASS or a known ssh-askpass/ksshaskpass binary, which is what sudo -A drives), then pkexec and the desktop polkit prompt. When nothing can ask, it prints the exact line to paste into a terminal, so the refusal is actionable instead of opaque.
  • The pip method walks three routes, none of them needing root: pipx (what a PEP 668 Python expects for a command-line tool), then pip --user retried with --break-system-packages, then a private venv under the install root whose console script is symlinked into its bin/, where detection already looks. A pip entry may also name a url (a git+https spec) instead of the PyPI name.
  • ParamSpider was the reason for that url: the PyPI name paramspider is a reserved placeholder package, "No functionality", which installs happily and ships no tool. The manifest now installs the repository version, which does provide the command.
  • wpscan is packaged by no distribution at all, so its apt recipe could never have worked. A gem method installs it with gem install --user-install and links the executable out of the user gem dir into the install root's bin/. Its gems compile, so a gem install object takes build_deps: that package list is installed as root only after a failed build and the install is retried once, so a machine that already has the headers is never asked for a password it does not need.
  • An install that exits successfully without leaving a runnable binary is now reported as such, with the status line and a popup naming the tool, instead of the green exit code that let ParamSpider look installed for as long as it did.

The audit was asking the display a question only a pop-up can answer

  • Every "would a bigger window fix this?" exemption in the layout audit compared the widget's own window against the display. That is right for a pop-up, which can be dragged out to the display, and wrong for one of the four tiled layout panels, whose width can never include the toolbar and nav pane and which the operator cannot resize at all: the sweep runs the main window at the display size, so a tiled panel is already as large as it will ever be. The audit was therefore reporting view grids and view overflow that no window size on that display could have fixed, and the reports were pushing the layouts the wrong way (squeezing Location and Category at every interface size to satisfy the narrowest one).
  • For a tiled panel the question is not "could it be bigger" but "can the operator reach the content", which its own scrollbar decides. Views all carry AUTO_SCROLLBAR, so content past their edge scrolls into reach; the toolbar, nav pane and status bar carry none, so content past THEIR edge really is lost and is still reported. Grids in tiled panels are exempt from the column check for the same reason, with the flex column holding the columns to the pane and the horizontal scroll as the fallback. What that leaves for views is overlap and cut text, which is the right pair: neither is something the operator can scroll around.
  • Verified by forcing each class and watching the sweep report it, not by watching the number drop: a view overlap, a view label cut by its neighbour, a pop-up sized too short for its own buttons, a pop-up grid narrower than its columns, and a clipped widget in the nav pane. An audit trusted to be silent has to be shown to speak.
  • With the ceiling honest, what was left was one class rather than a pile, and it is fixed: five sentences too long for their line (the Target profile summary and scan status, the Intruder status, the Purple team run summary) now wrap to a measured height instead of being cut, the Repeater's body caption is "Body" since its row is three buttons wide inside a pane that cannot grow a line, and the keyboard-shortcut dialog's button row follows its content instead of being pinned over it on a window too short to hold both. The Purple popup counts its wrapping summary in its own height, the way the HTTP/3 one counts its heading.
  • tests/test_guigeom now gates seven configurations: four window sizes from 800x500, the smallest window the program allows, up to 1600x1000, and 1024x700 at each of the four interface sizes. All seven report zero. 800x500 went from 36 defects to 0 and 1024x700 at Huge from 28 to 0, and the backlog item that carried them is closed rather than documented as a known exception.

Interface size: the layouts were only correct at Normal

  • The backlog carried "800x500 still reports 28 defects" as a question about a tiny window. Measuring the other axis answered it differently: what a view lays out in is the window divided by ui_scale, so 800x500 at Normal is the same geometry as 1024x700 at Huge, and both reported 28 with the same windows and the same kinds. Which made the real finding worse than the item it replaced: 1024x700, the size the build had just started gating, was clean at exactly one of the four interface sizes (Small 24 defects, Normal 0, Large 14, Huge 28). Interface size is one click in Settings.
  • Column widths were the last metric in a view still counted in absolute pixels. Every pane around them is multiplied by the scale, so at Small the panes lost fifteen percent and the columns kept every pixel: 21 of those 24 defects were grids opening scrolled sideways, in views nobody had touched (the Nav host list wanted 222 px of columns in a 204 px pane, against 240 at Normal). All 214 column declarations go through fissure_gui_columns_add now, which applies the live scale, and a live interface-size change carries the widths with it through fissure_gui_columns_rescale (it walks the widget tree, so a grid is covered whether or not it registered for customization, and a hand-dragged width moves proportionally instead of snapping back).
  • Action rows wrap. The Target view already had a helper for this; it was static in one file. It is shared now, and the Findings, Intruder and Repeater control rows use it, so a row grows downwards instead of running its tail off the panel or painting a right-anchored group over a left-flowing one. The Repeater's response block also holds its divider high enough for the control rows below it plus a readable view. Two rows were deliberately left unwrapped: the Repeater's body-label row lives inside a pane whose height comes from a ratio, so a second line there eats the editor rather than pushing the pane down.
  • Wrapped headings are measured, not counted. fissure_gui_label_height asks the draw path how tall a justified paragraph has to be at the live width and font, so the HTTP/3 proxy description and the command-palette hint get the line they need at a smaller interface size instead of being clipped mid-sentence. The HTTP/3 popup measures its heading before asking for its minimum height, since the minimum is applied before any layout runs.
  • tests/test_guigeom gates the Small interface size at 1024x700 alongside the three window sizes, seeding ui_size_index in the run's throwaway config dir. Small went from 24 defects to 0 and Normal stayed at 0; Large (3) and Huge (18) are not gated and are written up in docs/TODO.md, because what is left of them is a pixel budget rather than a layout fault: two grids want more columns than a 1024-wide window has room for, and closing that would mean squeezing Location and Category at every interface size to satisfy one.

The small window: sixteen view defects, and an audit that was measuring the wrong size

  • The layout audit was clean at the default window and reported sixteen view-level defects at 1024x700. The first of them was in the audit itself: n_gui_set_display_size was called once with the compiled-in default size and only corrected inside the branch a selftest run skips, so a --selftest-size 1024x700 sweep laid every widget out at 1024x700 and then asked whether it could fit a 1300x845 display. Both of the audit's "would a different size fix this?" exemptions read that stale value, so it answered for neither size. It takes the real display size now, before anything reads it.
  • The Dashboard's nine labels below the fold were recon-asset rows 7 to 14 of a table that was a fixed fourteen rows at every window height, plus the "N more host(s) not shown" line under them: at a short window the tail fell past the fold and took the one line that admits the list is partial down with it. The table takes as many rows as the window has room for now, and the count is computed from the rows actually on screen. The fixed fourteen overflowed at the default size too, by about 120 px; that went unreported because a window whose content cannot fit the display is a legitimate scrolling window, and there it was one. It fits at both sizes now instead of scrolling.
  • The three status labels that ran under their row-mate button (Target's scan summary under Snapshot role, Findings' empty-state line under Push to PwnDoc, Intruder's payload caption under the position picker) each have their own full-width line, the treatment the Target profile summary already had.
  • The four grids narrower than their own columns fit their pane at any width instead of being tuned for one. Each view grid names a flex column (URL in Target, Title in Findings, Request in Intruder, Tab in the Repeater tab list) and its layout calls the new fissure_gui_columns_fit after placing the grid: the metadata columns keep their width, dragged or restored or default, and the content column absorbs the rest, down to a floor below which the grid scrolls sideways as designed. Tighter defaults would have fixed 1024 by leaving a quarter of the pane empty at 1300. Findings needed both, its other six columns claiming 700 px of a 732 px pane even with Title at its floor, so they were resized to their own widest value rather than to a comfortable share of one window.
  • A large screen reported four more, and neither smaller size could see them: two of the audit's checks ask whether a bigger window would fix the defect before reporting it, so a dialog too tall for the screen is a legitimate scrolling window and a grid too wide for any pane scrolls sideways by design. Both were real. Scan options was short by exactly one row (32 px, measured by making the layout print its own sum against where it actually ended): the settings-surface toggle had been added to the layout and never to its hand-summed height, putting Apply and Close 20 px below the client box. The four full-width toggle rows are one array now, walked by the placement loop and counted by the height sum, so a fifth cannot be added to one without the other. The Purple team popup's two record tables stack instead of sitting side by side: each carries a whole record, and at the popup's 960 px minimum their halves are 542 and 392 px while their non-flex columns alone claim 666 and 576, so both overflowed even with the flex column at zero. Side by side would have needed a 2400 px popup; splitting the height gives each the full width, where every column fits.
  • tests/test_guigeom runs the sweep at 1024x700 and 1600x1000 as well as at the default size, with an Xvfb screen to match each, so both ends are a gate rather than something to remember. 1024x700 went from 16 defects to 0, 1600x1000 from 4 to 0, the default stayed at 0, and 800x500 (the program's own minimum, never swept before) went from 36 to 28, recorded as its own backlog item. Also clean at 1152x800, 1366x768, 1440x900, 1920x1080 and 2560x1440.

The layout audit, and the 102 defects it found

  • Dialogs that open with a scrollbar, a button hidden under its neighbour, a description cut off in the middle of a word: reported one at a time, fixed one at a time, and found again somewhere else the next week. --selftest-geometry ends that. It opens every entry the command palette indexes (every view, every popup, from the shared module registry, so a new dialog joins the sweep with no second list to maintain), lets the next frame reflow each at its live size, plus the dialogs the palette deliberately does not index (the PoC generators, AI assist, add-to-collection, the extension panel host, the context menu, and the confirm/prompt/quit modals, each opened with sample content and each required to actually appear, since a dialog that failed to open would otherwise be audited as nothing and called clean), and audits what was laid out: a widget outside the client box, two widgets sharing a rectangle, a label showing less than its text, a data grid narrower than its own columns. It exits non-zero on any of them and tests/test_guigeom is that sweep, so this class of bug now fails the build. A window whose content cannot fit the display, and a grid with more columns than any screen holds, scroll by design and are measured out rather than named in an exempt list. The first run reported 102 defects across 15 windows; 73 entries later the count is zero.
  • What it found, by cause. Three dialogs allocated their flexible panes by ratio and then clamped each share UP to its minimum, so the panes together claimed more height than existed and pushed the bottom row out of the window (Session-handling rules, the Intruder payload pipeline, and Match-and-replace, that last one fixed alongside). Four summed a fixed-row list that had fallen behind the layout below it, each missing a row someone added later (the HTTP/3 proxy's second checkbox, Parameters' toggle row, Probes' fields, the extension message editor's panes, which also reserved 90 px for boxes the layout clamps to 150). Two passed a CONTENT height where the window wanted an OUTER one, laying out a titlebar more than they had (Plugins, the message editor). Two sized a field by a fraction of the row and then clamped it up, walking every field after it off the right edge (Resource pools) or off the panel entirely (the Target view's action row, whose last three buttons - Headless crawl, SPA crawl, DOM probe - were simply not reachable at the default window size; it wraps now). Multitool placed WAF encode at the same coordinates as Smart decode, so one button was drawn on top of the other and only ever one was clickable. Four dialogs were narrower than their own grid columns and opened already scrolled sideways (Event log, Logger, OAST, Organizer), and three grids in the views were the same (the nav host list, the Repeater tab list, the Findings table). Ten labels were shorter than the text in them.
  • The label check needed the library to answer honestly, so n_gui gained n_gui_label_fits: it measures a label the way the draw path does and hands back the size that would show all of it. Writing it turned up a real rendering bug behind the "some words just disappear" reports: a wrapped (N_GUI_ALIGN_JUSTIFIED) label laid its text out against a window-expanded width but CLIPPED it to its own box, so the end of every line was drawn where nobody could see it. Wrapping now happens at the width the reader actually sees, in the draw path and in both hit-tests, which is what makes the paragraph headings in Team, Jobs, Attack surface, DOM Invader, Extensions, Scope, Workflows and the shortcut editor read to the end. Those headings gained the height their text needs; Multitool's and Settings' intro lines, laid out as one endless line, wrap instead of giving their window a horizontal scrollbar to reach the rest.
  • One cookie can be deleted from the shared jar now. "Delete cookie" on the selected row (naming it in a confirmation first), {"op":"remove"} on POST /api/cookiejar, and the remove op of the MCP cookiejar tool: a stale session id, or a cookie the target keeps re-setting, goes away without clearing the jar and losing the login with it.

Two dialogs that opened with scrollbars

  • Probes and Match-and-replace both opened at their own minimum size already overflowing, so the operator met a scrollbar and a clipped bottom row on a dialog nobody had resized. Two different arithmetic faults, one symptom. Probes' fixed_v listed three of the four labelled fields and neither the aggressive checkbox nor a wrapped action row, so the output pane was sized ~122 px too tall at scale 1 and pushed itself past the client box; the row count and the height terms now come from probes_walk_actions and probes_fixed_v, and the walk that measures the wrap is the same one that places the buttons, so the two cannot drift. Match-and-replace reserved min_grid + 2*min_pane for its three flexible panes but then split the flex by ratio and clamped each share UP to its minimum afterwards: at the minimum height the grid took 150 and the two test boxes 75 each, both clamped to 90, and the panes together claimed 30 px more than existed, putting the Close button 16 px below the client box. Minimums are allocated first now and only the surplus is shared, which cannot overshoot. --selftest-geometry had been reporting both all along (102 defects, now 94); it is worth reading before eyeballing a dialog.

The Windows suite, and what the first scheduled fuzz campaign found

  • A pre-release sweep of every follow-up outside the Windows and CI work found two things and confirmed the rest closed. Eight tests that skip on Windows returned 0, so the runner counted them as PASSES: the last Windows run reported three skips when the truth was eleven. They exit 77 now, the same convention the plugin tests use, so the summary says what actually ran. And the full-surface audit's "Remaining drift" list, which is not in docs/TODO.md and so escapes the usual reading, turned out to be entirely stale: all eight of its items had been closed (the MCP tools are all named in FEATURES.md, Ctrl+K is in the Shortcuts pane, the architecture doc's phantom files are gone, EXTENDING.md's {{token}} claim is corrected). It now records that, with how each was checked, because a stale "remaining work" list is worse than none: it sends the next reader hunting for problems that are not there, which is what it did during this sweep. The 03_GUI_DESIGN gap table gained a Status column for the same reason, since five of its six widgets shipped.

  • Doxygen comments had drifted off their functions, and make docs never said so. The target returned success whatever doxygen reported, so 116 warnings had accumulated unread, 84 of them defects by this project's own rules. Nearly all were one mistake repeated: a block whose declaration was moved or deleted does not become an error, it silently attaches to the NEXT declaration. In fissure_js.h that left fissure_js_run_check_active undocumented while fissure_js_set_scope was published carrying ten parameters it does not take. Twelve blocks were reattached, two stale duplicates deleted, 27 prose placeholders (<name>, <port>) that doxygen was reading as HTML and dropping from the page put in backticks, five regex escapes in prose stopped being read as commands, nine missing @param written, and two @param renamed to the arguments they actually describe. make docs is at zero warnings and WARN_AS_ERROR now fails the build on one, so it cannot go quiet again.

  • Fissure could not create its configuration directory on Windows. fissure_paths_mkdirs walks a path component by component from index 1, so for C:/Users/x/AppData/Roaming/Fissure its first step asked the CRT to create C: - not a directory to make but a reference to the current directory on that drive, which _mkdir refuses with EACCES rather than EEXIST. The walk gave up on its first component, fissure_paths_config_dir returned -1, and since every %APPDATA%-derived path carries a drive letter that was every real run. The walk steps over the drive designator now. It had hidden because the tests only ever exercised the location XDG_CONFIG_HOME redirects to, and MSYS2 hands a test a drive-less /tmp/... for that; tests/test_paths now also points the platform's own default variable at a temporary directory and asserts the default branch resolves and creates. Found because the previous change made fissure_paths_config_dir and fissure_paths_mkdirs say why they failed instead of returning -1 in silence: the CI log named the component and the errno outright.

  • The Windows test suite ran for the first time and reported 26 failures and a hang. They came down to seven causes, and the first was a product bug: fissure_paths_write_atomic ended in rename(tmp, path), which the Windows C runtime refuses when the destination exists, so the first write of a fresh file landed and every rewrite after it failed. That is every persisted store, so a Windows operator could set a preference once and never change it. It delegates to nilorea's n_file_write_atomic now, which replaces with MoveFileEx there and flushes to disk before it does, which the hand-written version never did. The other six were test-side: no WSAStartup before a raw socket() (which is also what hung test_control, whose shutdown poke was skipped when socket() failed, leaving a join waiting on an accept() that would never return); a CRLF checkout, which broke the signed extension marketplace and made a signature parser read every wrapped argument as drift; POSIX permission bits asserted on a platform that synthesises st_mode from the read-only attribute; three tests for the OSS-tool plugin subsystem, which is compiled out on Windows and now reports SKIPPED rather than counting as a pass; hardcoded paths, one of which meant test_h3proxy had been passing without ever exercising the on-disk half of the CA; and SO_RCVTIMEO handed a struct timeval in 37 places, where Winsock wants a DWORD of milliseconds and the wrong one sets no timeout at all.

  • The first scheduled fuzz campaign found a hang in the BCheck importer and then threw the reproducer away. bc_subst_defines restarted its search at the head of the buffer after every substitution, so a define written in terms of itself (a = "{a}z") re-found the reference it had just inserted and grew the text by a character per pass, without end: a 129-byte document held the parse for 37 seconds and would have held it forever. bcheck is an MCP tool and a control-API route taking arbitrary text, so that was a remote hang from untrusted input. The search resumes past the inserted value now, a size cap stops a chain of defines that each repeat the one before, and the self-reference is left in place so the check is refused as unresolved rather than sent at a target as a literal {a}. The reproducer went missing because actions/upload-artifact globs with @actions/glob, which does not do brace expansion, and the workflow asked for {crash,leak,timeout,oom}-*: the step matched nothing, said "No files were found" and passed, leaving a red job with nothing to act on. The path is one pattern per line now, and the input is committed as a seed. The same campaign turned out to cover six of the ten targets the build defines, so a wire format, signed XML, YAML and raw HTTP framing had never been campaigned at all; tests/test_fuzz_matrix fails the gate when those two lists disagree.

  • Looking for the same shape elsewhere found it in the marketplace integrity check. gen-marketplace.py --check walked the catalog's entries and verified each against the store, which is one-directional: a bundle added under resources/marketplace/store/ and never regenerated into the catalog was looked at by nothing, so it shipped in the tree, stayed out of the SIGNED catalog and was invisible to the marketplace at runtime, while the check printed "ok" for every entry and exited 0. An empty or renamed entries key did the same thing more completely, printing nothing and still succeeding. The check compares both directions now, reports a catalog entry whose bundle is gone, and treats an empty catalog as a failure rather than a clean result. tests/test_marketplace asserts the store-to-catalog direction on every gate too, because the packaging tool only runs when someone remembers: nothing in CI runs it, or make tests, or make checks, on Linux at all.

  • A doxygen comment could attach itself to the wrong symbol. fissure_report.c listed the markdown metacharacters and wrote a bare backtick among them; doxygen reads a lone backtick as opening a code span and swallows what it crosses looking for the partner. MD_META_ANY disappeared from the generated page, MD_META_LINE_START was rendered carrying MD_META_ANY's description, and raw source leaked into the page. The comment names the backtick now instead of writing it. make docs returns success whatever doxygen reports, which is why nobody had seen it; the other 84 real warnings that run turned up are sized and listed in docs/TODO.md rather than swept in here.

Windows first-run, and the crawl budget nobody could see

  • On Windows the configuration lived inside the MSYS2 installation. fissure_paths_config_dir derived it from $HOME, which an MSYS2 shell sets to its own tree, so the proxy CA, the projects, the scan history and the settings went to C:/msys64/home/<user>/.config/fissure. Launched from Explorer, the Start Menu or a plain cmd, where HOME is not set at all, the function returned -1 and the program came up as a fresh install with no CA and none of the operator's past work, with nothing on screen to explain it. It now resolves %APPDATA%/Fissure, then %USERPROFILE%/.config/fissure, then $HOME, after XDG_CONFIG_HOME, which still overrides everything on both platforms. The Windows variables hold backslash paths, which the mkdir walk would have read as one component, so they are normalized on the way in; an existing MSYS2-shell tree is moved across on the first run instead of being orphaned, and fissure_paths_config_notice() reports on screen what moved, or where the old tree still is when the move could not be made.

  • The browser CA was never trusted on Windows, and the message said the wrong thing. Chromium on Linux reads user certificates from an NSS database the launcher seeds inside the throwaway profile with certutil; Chrome and Edge on Windows read the Windows certificate store and have no per-profile database. The NSS path ran there anyway and failed twice over: the PATH walk splits on ':', a drive separator rather than a list separator on Windows, and the certutil.exe a Windows PATH does resolve is Microsoft's unrelated tool of the same name. The operator got a certificate warning on every intercepted page and a message telling them to apt install libnss3-tools. New fissure_trust.c writes the current user's Trusted Root store through the Win32 certificate API (-lcrypt32, no elevation, machine store untouched), the NSS path is #ifndef _WIN32, and the launch reports a distinct outcome because the grant is genuinely wider than the Linux one: account-wide and outliving the browser profile. Settings gained "Trust CA for this account" / "Remove CA from this account" beside "Export CA certificate", so it can be undone.

  • TLS certificate verification is now OFF by default, on both platforms. The hosts a web-security tool is aimed at are staging environments, self-signed labs, appliances and targets behind the operator's own interception proxy far more often than public sites with a clean chain, and a verification failure there produces no finding at all: it stops the request before it is sent, which reads as an unreachable target rather than as a trust problem. --verify-tls turns it back on for a CLI run (--insecure still exists and now restates the default), as do the Settings toggle and tls_verify over the API and MCP; --ca-file remains the precise option, pinning one certificate rather than accepting any.

  • The crawl page cap was a fixed 200 in the GUI, with no knob and no report. That mattered more than the number: every URL a crawl finds is recorded as an endpoint whether or not it is ever fetched, so the endpoint count keeps climbing from discovery after the fetching has stopped, and a run on a large site looks exactly like a complete one when it has seen its first few hundred pages. "Crawl pages" is now an operator field in the Target view's Scan options (blank or 0 = unlimited, persisted as scan_max_pages, saved per profile), matching the --max-pages and max_pages the CLI and API already had. The crawler tracks what a spent budget cost - URLs queued and never crawled (still baseline-fetched, but never expanded, so whatever they alone link to was never found), and pages left unexpanded at the depth limit - the scan raises them as a "Scan coverage" finding naming which budget ran out, and the same figures ride on the scan status as crawl.pages / crawl.page_cap / crawl.left / crawl.depth_capped / crawl.capped, so an agent can tell a bounded run from a finished one. The skill's methodology now reads that object before it reads findings.

  • DVWA-validated, both driven directly (the fissure CLI) and driven through the fissure_bug_bounty skill over the MCP bridge, with the artifacts under reports/dvwa_20260902_195239/. The crawl budget, on the same authenticated scan: --max-pages 12 gave 12 requests, 40 findings and the coverage finding naming 25 in-scope URLs never crawled, --depth 3 unlimited gave 42 requests and the DEPTH finding instead, and --depth 8 unlimited gave a crawl that finished and raised neither. Over MCP the same capped run reported status: done with audited 68/68, 100% beside crawl: {pages 12, page_cap 12, left 25, capped true} - the first half is what an agent used to see and read as a finished scan, the second is what was invisible. The TLS default, against the lab's self-signed HTTPS gateway: 8 findings with no flags, versus 2 and STOPPED EARLY: the target certificate could not be verified with --verify-tls. --ca-file does not rescue that run and should not: the lab certificate is CN=dvwa.lab.local with no SAN while the scan reaches it at 127.0.0.1, so it fails on the NAME, which is a second independent reason the old default was wrong for this tool's targets. The two Windows fixes have no DVWA surface at all (neither is a property of the target) and stay covered by tests/test_paths, tests/test_trust and a cross-compile of the _WIN32 branches, with the on-target confirmation recorded as P1 in docs/TODO.md.

Authenticating a target: the session now goes somewhere

  • The session-action launcher captured a login and then threw it away. Both callers printed the cookie and freed it, the GUI into an info popup and the control API into a JSON field, and neither wrote to fissure_cookiejar_shared(), which is the jar a Target-view scan with no login config, a control scan, the Repeater and every manual send actually read. So a successful login was a no-op for everything that ran after it, which is what the operator saw as "cookies were not registered". fissure_sessaction_run now takes an install jar and copies the session into it cookie by cookie, keeping domain, path, Secure and expiry instead of the flattened header; the GUI passes the shared jar and persists it, and POST /api/session-action does too and reports installed (opt out with "install": false). The documentation had described this as being "for authenticated scanning" since it shipped.

  • A login whose session is a TOKEN had nowhere to put it, since a cookie jar cannot hold an Authorization header, so the token a script worked to obtain died with the run. fs.setvar(name, value) publishes what a run captured and the host returns it as vars, in the same shape a login config's extracts produce, so a session-handling rule's {{name}} substitution resolves either source. A GUI scan with no login config picks the published values up.

  • The login picker was inert by arithmetic: (s_sa_sel + 1) % s_sa_count with one login installed returns the same index, so clicking it could not change anything. It is a list now, and it has something to list. Eleven login shapes ship beside the HTML form: a JSON API login, the OAuth2 password / client-credentials / refresh grants, HTTP Basic, a bearer token the operator already holds (verified against the target first, so a stale one is caught before a whole scan runs on it), a two-step form login, a form login plus an OTP code, an SPA login that reads a CSRF cookie back into a header, a GraphQL login mutation, and WordPress. Each is driven entirely by fs.params, so none is tied to the product it is named for, and tests/test_logins runs all of them against a server that models each shape.

  • Each login declares the fs.params fields it expects, shown as the params field's placeholder and returned by GET /api/session-actions. A login run with guessed field names posts no credentials, and its empty result is indistinguishable from a target that refused you. For the same reason the params JSON is validated before the run: the script engine substitutes an empty object for a document it cannot parse, so a typo used to run the login with no credentials and report only that nothing was captured.

  • fs.send gained the two things a multi-step login needs: the response carries url, where it actually came from, because a followed redirect leaves no Location on what it returns; and follow: false stops at the 3xx instead.

  • Handing Fissure a cookie the browser already has took retyping it a name/value/domain triple at a time, splitting the string on every ; by hand. fissure_cookiejar_import_header takes what a browser actually gives you: a bare a=b; c=d (document.cookie, a Cookie request header), the same with a leading Cookie: or Set-Cookie: name, several lines at once, and a whole copy-as-cURL command, of which only the cookie option is read so the URL and the Accept header do not become cookies. An https URL marks the cookies Secure. A paste box in the Cookie-jar popup, POST /api/cookiejar {"op":"import"} replying with imported, the cookie argument on the MCP cookiejar tool, and the skill catalog.

  • Browsing the target logged in through Fissure's own proxy did nothing for the tools that ran afterwards: the proxy is a raw relay that never mentioned the cookie jar, so the one component watching the operator's real authenticated session was the one component that did not record it (only the request engine absorbs Set-Cookie). It now offers every in-scope exchange's response Set-Cookie headers and its request Cookie header (the only way a session established BEFORE the proxy was attached ever gets in) to an installed sink, and the GUI and the control server install one that writes into the shared jar. A "Capture cookies" toggle in the Proxy view, persisted, capture_cookies on POST /api/proxy/start and the MCP proxy_start tool. Off by default because it changes what every later tool sends, and scope-gated so unrelated browsing does not fill the jar. This is the shortest authenticated-scan route there is: log in in the browser, then scan.

  • DVWA-validated, both driven directly over the control API and driven through the fissure_bug_bounty skill over the MCP bridge, with the artifacts under reports/dvwa_20260901_220722/. The measurement worth keeping: the same scan with no cookie argument anywhere found 10 findings and 0 high with the jar cleared, and 58 findings, 4 high, 5 reflected XSS and 5 DOM XSS once the session action had installed its cookies. Before this change the second column was the first one, which is the "reads like a clean target" failure the project warns about. The proxy path reached the same place from the other side: 59 findings and 4 high from nothing but browsing DVWA logged in through the proxy with capture on, while with capture off the jar stayed empty. Nine of the eleven added login shapes have no DVWA surface at all (the OAuth2 grants, GraphQL, SPA/CSRF, WordPress, Basic, bearer, two-step, OTP), so they stay covered by tests/test_logins and that is recorded rather than papered over.

  • The CLI could not use a captured session at all, which is the same defect as the one above one level down: fissure_cli.c pointed its config at the shared cookie jar, but fissure_cookiejar_load was called only from the GUI startup and the control-server startup, so the CLI's jar was always empty. A session the proxy captured, the Cookie-jar popup imported or a session action installed sat on disk and was never read. fissure_cli_run now loads it at the start and saves it at the end (the jar is freed at the process boundary in main.c, not inside the run, so a caller running several commands in one process still has it). Measured on DVWA: a control-server proxy with capture on took a browser's login, and fissure scan --auth-check on the same config directory went from "no cookies held. A scan would run anonymous" to ok (existing cookie jar), with no flags at all.

  • fissure scan --cookie "PHPSESSID=abc; security=low" seeds that jar directly for a one-shot run, through the same importer the popup and the route use, so a Cookie: header line and a whole copy-as-cURL command work too. Text with nothing cookie-shaped in it exits 2 naming what was expected, rather than scanning anonymously and reporting the handful of findings an anonymous visitor sees.

  • A session action that captured nothing could not say why, and the three causes need opposite fixes. The result now carries sends, last_status and the script's own fs.log narration, so "no request at all" (a wrong URL), "requests that got no answer" (host, port or scheme) and "a real status back, so the target is reachable and refused you" (credentials or field names) are told apart in the GUI popup, on the route, through MCP and in the skill. Validated on DVWA both ways: a wrong password came back sends=2, last_status=302 with the login's own narration, and the same credentials against a dead port came back sends=2, last_status=0.

  • That DVWA run also caught the converse, which was a representation bug in the success message: DVWA hands a PHPSESSID to an anonymous visitor, so a FAILED login still returns cookies and the popup was claiming it had "established a session". It now reports what was captured, with the counts, and says plainly that cookies are not proof the credentials were accepted, pointing at Test authentication to settle it.

  • The login launcher was reachable only from inside the Session-handling rules popup, which is not where anyone looks for "log in". It now has a Target-view button next to the scan controls and a command-palette entry.

  • A browser's "Copy as cURL" is how a human hands over a REAL, already-authenticated request (its session cookie, its CSRF header, the exact body the application expects), and reproducing one by hand was the neighbouring tedium to retyping cookies. fissure_curlimport parses one into method, URL, header block and body: "From cURL" in the Repeater loads it into the tab, and POST /api/curlimport plus the MCP curlimport tool hand the parts to an agent for send_request, the Intruder or any check. It reads what the browsers actually emit (backslash continuations, single/double/$'...' quoting, -X, -H, -b folded into a Cookie header, the -d family, --url) and ignores the transport switches; POST is inferred from a body as curl does; it parses and sends nothing. It refuses text carrying no absolute scheme://host URL, because the first version happily read the word "not" out of "not a curl command at all" as the target.

  • The last login class that could not be automated at all: a nonce computed by page JavaScript, a captcha or hardware key only a person can answer, and an SSO hand-off across several origins. fs.send reproduces none of them. fissure_browserlogin drives a real Chromium over CDP instead: it opens the login page, fills the CSS selectors it is given through the native property setter plus input and change events (a plain .value assignment is ignored by a framework-managed form), clicks submit, watches for a success marker and harvests the browser's cookies for the TARGET host into the shared jar, never the identity provider's. Attaching to a browser already running is the second mode and the only route past a captcha: the operator logs in by hand and this harvests when they are done. "Browser login" in the Session popup, POST /api/browserlogin, the MCP browserlogin tool and the skill catalog. tests/test_browserlogin drives the whole flow over a stub CDP transport with no browser; against DVWA a real headless Chrome logged in with verified: 1, ended on index.php, and a scan on that session alone found 58 findings and 4 high, matching the scripted path exactly.

  • Given a success marker the browser login reports whether the login SUCCEEDED, not merely that cookies came back, which is the distinction DVWA taught earlier in this arc by handing a session cookie to anonymous visitors.

  • The OAuth2 authorization-code flow with PKCE, the last grant that could not be driven. fissure_pkce mints the verifier and a state, builds the authorize URL with the S256 challenge, reads the code out of the landing URL and builds the exchange body; POST /api/oauth-pkce and the MCP oauth_pkce tool compose that with the browser login, so the credentials go into the provider's own consent form. A code whose state does not match the one sent is REFUSED: a landing URL is attacker-influenceable and exchanging a code bound to another round trip is exactly what the state parameter exists to prevent. tests/test_pkce checks the challenge against RFC 7636's own worked example, and caught a real bug on its first run: n_random_bytes returns 0 on success rather than TRUE, so the inverted check was minting an EMPTY verifier, which a provider answers with a flat 400 and no hint why.

  • The browser dashboard gained a Session tab: the shared cookie jar, a paste box that imports a browser session in the shapes the popup and the route take, and a browser login. Its result says what it PROVED, so a success marker that never appeared reads as a probable failure rather than as success.

No AI typography

  • The style rule said "ASCII ONLY" and forbade -- for an em dash but never said what counts as a legitimate non-ASCII byte, so nothing decided the cases. It does now: every non-ASCII byte must serve a functional purpose (a payload that exercises encoding handling, a fixture that needs the exact bytes, a third-party file reproduced verbatim), decoration never is, the banned set is named, and faking those characters out of ASCII is banned too, with the exceptions listed and a grep that audits each rule.
  • Swept the tree to match: 261 decorative characters out of the two competitor-audit references (em dashes as definition separators, arrows, check and cross marks in capability tables, an ellipsis, and Burp's insertion-point marker, now named by codepoint rather than printed), twelve /* -- section -- */ banners in fissure_saml.c turned into sentences, and twelve prose -- across the docs, a doxygen comment and four test files turned into a comma or a colon. What remains non-ASCII is functional: the vendored QuickJS source, the license texts, the fonts and images, and the fuzz corpus inputs whose whole point is their exact bytes.

The Windows CI, read at last

  • The backlog said to read the CI result rather than rebuild. There was no result: the run it named was CANCELLED at the 2h37m job cap, as were the two after it. Reading the cancelled job's log finally says what is wrong. tests/test_control HANGS: it is test 147 of 192, it printed its last assertion at 12:31:28 and produced nothing for the twenty-one minutes until the cap killed the job. The last thing it reported was test_control.c:558, so the hang is at or after the purple-team save/load block that follows, whose first call writes the run to the project store, which is a file path, and paths are exactly what the previous Windows pass was fixing.
  • A second finding the same log carries: the 146 tests before it took about 2h09m and passed. So removing the hang buys about twenty minutes against a 2h30 cap that ordinary work already nearly fills, and fixing the hang alone will not turn the job green. A per-test timeout is now the P1: without one, a single hang costs the whole budget and the run says nothing about the 45 tests it never reached.

A Windows build break the cross-sweep caught

  • make winsweep found strcasestr used in fissure_cspt.c without nilorea/n_str.h, which is where the portable declaration lives: <strings.h> has it on glibc and mingw does not, so the file had built on Linux since it was last touched and would have failed the moment anyone built on MSYS2. Fixed by including the header its twenty-two fellow callers already include. Sweep clean again: 105 clean, 127 dependency-gated, 0 real errors of 232 files.
  • The Windows CI job now checks the console front end from cmd (not the MSYS2 shell, which does not reproduce what cmd does with a GUI-subsystem child): fissure-cli.exe waits, its output reaches a redirected handle, and a bad subcommand exits non-zero. Those three are the whole reason the launcher exists, and they were on the list of checks that needed a person at a Windows desk. Two still are: no console window when launched from Explorer, and Ctrl+C stopping a running scan.
  • make winsweep gained a WINSWEEP_FILES override, so a change can re-sweep just the files it touched (make winsweep WINSWEEP_FILES="$(git diff --name-only HEAD -- 'src/*.c')") instead of paying for the full tree. The break above is why: the docs said to sweep NEW files, and fissure_cspt.c was not new, it had been passed by three earlier sweeps. Only the call was new. A file's clean result expires when the file changes.
  • The table in docs/PORTABILITY.md now states the limit in its own words rather than leaving it to be inferred: of eight files one recent sequence touched, four were checked and four (fissure_js.c, fissure_checks.c, fissure_control.c, fissure_oast.c) are gated on openssl/err.h and were never compiled for the target at all. A clean sweep means "nothing was found in the half it can see".

BCheck: imported checks over OBSERVED traffic

  • fs.request() returns the request the proxy SAW as {method, target, headers, header_block, body}, or null when there is none, and the control-plane passive audit lends it the recorded bytes (which fissure_proxy_flow_bodies already had and the caller was passing as NULL). A document that names the observed request and sends nothing of its own is compiled as a PASSIVE check: no fs.active gate, because the passive pass is exactly where the observed request exists and there fs.active is false, and no send of its own, because it inspects the recorded exchange. A condition may now put such a value on its LEFT side, which is how these documents are written.
  • That closes the last of the 7: they inspect or mutate an observed request, and resolving those names against a scan would have reported findings about Fissure's own traffic. Validated on real proxied traffic both ways: a request carrying Authorization: Basic ... makes "Use of Basic Auth Scheme" fire (low/firm) reading the recorded header block; the same request without it produces no BCheck finding at all.
  • Two defects running it exposed that reading it did not: the emitted passive branch was spliced into the middle of the send emission and produced JavaScript that would not parse (the check loaded, ran, and died on a SyntaxError, which the corpus measurement cannot see because it counts what compiles to a string); and a define line longer than the pre-pass buffer was skipped silently, leaving the GraphQL introspection document holding an unresolved reference.
  • Corpus: 258 of 265 to 260 (97.4% to 98.1%). Over the whole BCheck sequence: 167 to 260, 63% to 98%.

BCheck: "given insertion point" now means the target's own inputs

  • A document written given insertion point then compiled into a check that appended one bcheck= parameter of its OWN invention rather than placing the payload into the target's real inputs: enough against a sink that reads anything, wrong against an application that reads one specific parameter. fs.inject(payload) now returns one target per query parameter the URL actually has, each carrying the payload in THAT parameter and the original values elsewhere, and such a document loops over them. Every other document keeps the appended probe parameter, so nothing that already worked changes shape; a URL with no parameters falls back to appending one, because testing nothing at all would be worse.
  • One report ends both loops, so a target with several parameters does not raise the same finding once per parameter.
  • Validated both ways round on a sink narrowed to read ONE parameter and ignore every other: with the change SSRFInjection.bcheck fires and the lab log shows the canary fetched; with the behaviour forced back to appending, it does not fire at all.

The Collaborator checks, run against a target that could trigger them

  • Running the imported SSRF/Collaborator BChecks against a real SSRF sink found two defects, both invisible to a measurement that counts what compiles. fs.oast(channel) returned null without a delegated domain: a DNS or SMTP canary needs one, and a collector started with just --oast <port> cannot mint one, so every Collaborator check got an EMPTY canary. It planted nothing, asked whether nothing had been called back, and answered no on every target. It now falls back to the channel-agnostic canary, keeping the token PATH rather than just the authority, because on the HTTP channel the token is what makes a callback attributable: a bare host would have been contacted and then correlated to nothing, which looks exactly like the target not being vulnerable. The channel still decides what counts, so a check needing DNS stays silent rather than accepting an HTTP hit.
  • The insertion-point payload form was not read. A document writing send payload: then an unquoted appending: {ssrfaddress} had its canary minted and never sent. appending: / prepending: and bare values are now read.
  • Validated: blind-ssrf fires (high/firm, with the lab log showing the target fetched the canary and the collector recording it), SSRFInjection fires after the fix, and log4shell correctly reports NOTHING without a DNS channel while the lab log shows its payload did arrive and the target did try to resolve the canary. Both defects sat behind checks that compiled, parsed, loaded and ran: the emitted JavaScript was right, and what was wrong was the value it computed at runtime and whether anything ever received it.

CI workflows, and a backlog file this session corrupted

  • .github/workflows/windows.yml (MSYS2/ucrt64 build + make tests) and .github/workflows/fuzz-campaign.yml (a weekly make fuzz-campaign per target, keeping any crash/leak/timeout artifact) are written and parse. The backlog called this "blocked on CI access", which conflated writing the workflows with running them: only the latter needs the account configured. Neither can supply the ../../nilorea-library sibling the build expects, so each checks for a NILOREA_REPO variable up front and stops with a message naming it rather than failing later inside a compile.
  • docs/TODO.md was the whole file twice over, and two of this session's own commits did it. The same mistake both times: an edit script located a region's end with s.find("\n## ", i), which returns -1 when the marker is last, and s[-1 + 1:] is s[0:], so the edit appended a second copy of the file instead of removing a region. A sibling script had already eaten the "Future / possible enhancements" section outright, taking the Windows CI and fuzz-campaign entries with it. Nothing caught it: the test suite does not read the backlog. The file is rebuilt from the last complete version with the lost sections restored. An edit that locates a region by searching for its END must fail when the end is not found, because deriving an index from -1 silently means "the beginning".

BCheck resolvers, and what a real DVWA run said about them

  • The built-in interpolations BCheck provides rather than the document defining them: {payload} (107 uses), {base.request.url} / {url} / {latest.request.url}, {base.request.url.host} / {target_host}, .port and the .path forms, all derived from the LIVE target so a check written against "the host" works wherever it is pointed. Two parser gaps went with them: a quoted value ended at its first INNER quote, so a define holding JSON was truncated to a couple of characters and the body built from it went out as a fragment (the reader is now escape-aware, and a regex \. or \s still keeps its backslash); and defines were substituted into a step's payload, headers and query but not its path or body. 252 of 265 documents to 258 (95.1% to 97.4%), none carrying an unresolved interpolation into a request.
  • The DVWA run found two things the corpus measurement cannot see. A discovery-shaped BCheck fired for the first time and produced thirteen identical findings for one exposed phpinfo: fs.report always created a URL-scoped finding, so a check probing FIXED paths reported once per page the crawl reached. That is pre-existing and affects every scripted check. fs.report now takes a host flag, and the BCheck emitter sets it for a document that replaces the PATH, because what such a document finds is a property of the host; a document that fuzzes an insertion point stays URL-scoped, since there the URL IS the finding. 13 findings became 1.
  • And the finding's detail arrived unrendered, carrying the document's own backticks and a {check.response.url} this build cannot resolve. Backticks are stripped, defines and built-ins substituted, and anything still unresolved is DROPPED rather than printed: a literal {check.response.url} in a report tells the reader nothing and looks like a bug in the tool. Compiling is not the same as being worth reading, which is the second time the DVWA run has been the thing that noticed.

BCheck: regex_replace, and the gap that was not regex_replace

  • regex_replace(subject, "pattern", replacement) is lowered to a JS expression, innermost call first so a nested one is already a plain variable by the time its parent is read. A subject this build cannot name leaves the call in place and refuses the document, rather than aiming a request somewhere nobody asked for. Then the corpus said the total had not moved: 212, unchanged.
  • The real blocker was that a BCheck condition may WRAP ACROSS LINES. The clause was read from the if line, which contains no then, so the document was refused for having no conditions rather than for anything it said. 63 documents wrap. Gathering the clause until its then took the corpus from 212 to 262. The backlog entry had named regex_replace on the strength of refused PREDICATE counts, but those documents never reached predicate parsing, so they could not appear in that count: the measurement answered a narrower question than the one being asked of it.
  • Compiling 50 more documents is only progress if they DO something, and two shapes did not: the block form of run for each: (its variable stayed unresolved, so a step path went out with a literal {potential_path} in the URL) and the loop variable inside a step field. Both fixed, and there is now a net under that whole class: a document whose request field still holds an unresolved interpolation is REFUSED with a note rather than compiled, because a check that sends a literal {name} matches nothing and reports nothing, which is indistinguishable from a clean result.
  • Measured: 212 of 265 to 252 (80.0% to 95.1%), every emitted script still parsing, and zero of the 252 carry an unresolved interpolation into a request. Over the whole BCheck sequence: 167 to 252, 63% to 95%.

BCheck to_lower, and the multipart part-header shape

  • {to_lower(...)} around a response reference now folds the haystack. It is not decorative: the contains/starts/ends comparisons here are case-SENSITIVE, so dropping the wrapper silently narrowed what the document asked to match. Building it exposed a parser bug that was not about to_lower at all: the clause scanner ended a predicate at the first ), because that is how the grammar groups (A or B) and C, but a function call puts a parenthesis INSIDE the predicate and the reference was cut in half. It now tracks depth, so only a parenthesis opened outside ends the predicate. Documents compiling with NOTHING skipped rose from 189 to 192.
  • The multipart part-header shape (mpduplicate) emits a SECOND Content-Disposition name on the fuzzed part, so a filter that stops at the first attributes the payload to a field it does not guard while a parser that takes the last binds it to the one that reaches the sink. It is built on a new upstream option (N_HTTP_MULTIPART_PART.disposition_extra, committed in nilorea) rather than string surgery on a body the builder had just produced; NULL or empty adds nothing, so every existing caller emits the same bytes as before.
  • And it found a real gap. Three multipart checks (reflected XSS, error-based SQLi, traversal) build their body by calling the plain builder directly rather than going through the insertion seam, so with mpduplicate configured they would have sent unshaped requests: the option would have done nothing for the three most common multipart checks while appearing to work for the others. The test caught it only because it asserted the shape reached the WIRE rather than that the function returned the right string.

BCheck define needles and per-run markers, and a baseline that was not one

  • A {name} on the value side of a condition resolves against the document's own define: block, which is what the marker checks compare against. {random_str(N)} is built on the same mechanism as the collaborator address: each occurrence becomes a per-run value, because fixed text would make one run's marker match a previous run's reflection still sitting in a cache or a log.
  • base was aliased to latest. Both names resolved to the same response, which turns the marker idiom not({answer} in {base.response}) and {answer} in {latest.response} into !X && X, a condition that can never be true. While those documents were refused this was invisible; making the in operator and define needles compile would have turned 16 documents into checks that run, cost requests, and silently never fire, which is worse than refusing them. base is now its own response and is SENT: the target as it is, with no payload in it.
  • Measured: 205 of 265 documents to 212 (77.4% to 80.0%), every emitted script still parsing. Over the whole BCheck sequence: 167 to 212.

Fuzz campaigns, and the two things the first one found

  • make fuzz-campaign FUZZ_TARGET=<t> FUZZ_TIME=<seconds> runs one target against its corpus for a wall-clock budget and writes findings as artifacts; make fuzz-smoke remains the regression half and answers a different question. The backlog entry treated this as blocked on CI, which conflated PROVIDING a campaign with SCHEDULING one: only the latter needs CI.
  • It found two things on its first run. make fuzz did not link: fuzz_apispec was missing fissure_purple.c and had been failing since the purple-team work, so fuzz-smoke was failing too and the regression half of the fuzzing story was quietly broken. And a leak in code written minutes earlier: when a later if clause fails to compile the conditions are refused as a whole, but the tree already built was dropped without being freed. The reproducer is now a permanent corpus seed.

BCheck: the Collaborator interactions, wired to the OAST collector

  • {generate_collaborator_address()} and the http/dns/smtp/any interactions conditions now compile against Fissure's own out-of-band collector. Each address occurrence mints its own canary, defines are resolved so the payload written as x={log4shell} actually carries it, and every nested if ... then is read and ANDed rather than only the first. An else branch makes that reading wrong, so such a document is refused rather than reported on a shape it did not ask for.
  • Supporting additions: fissure_oast_token_seen_chan (the agnostic form answers "did anything call back", which is right for an SSRF canary and wrong for a check that distinguishes a DNS lookup from a link-preview bot fetching the same canary), fissure_oast_token_wait, and fs.oast(channel) returning a bare host (a JNDI or LDAP payload cannot take a URL).
  • The confirmation is real, not vacuous. The Log4Shell idiom sends a valid payload and requires a callback, then a deliberately broken variant and requires none; three ways that could have silently degenerated are all closed. fs.oast_wait watches for a window (8s default, 30s cap) and returns as soon as the interaction arrives, so the positive case is fast while the NEGATIVE case spends the whole window, which is the cost of the assertion meaning anything. A step carries its OWN appended query, so the broken variant is actually sent rather than the first payload repeated. And BCheck's \{ brace escape is removed, without which the probe is one no Log4j lookup ever fires on and the target reads clean.
  • Measured: 191 of 265 documents to 205 (72.1% to 77.4%), every emitted script still parsing. The 26 documents this reaches are log4shell, blind SSRF, three Fastjson deserialization RCEs, Xdebug RCE and xxl-job RCE, which is the high-value slice rather than the tail.

Fingerprint the filter first, then choose

  • wafdetect now returns suggested_encoders and suggested_request: where to START the input-filter bypass for the product it fingerprinted, droppable straight into a scan as waf_encoders / waf_request. The backlog entry asked to "order the transforms to cut the request count", but the scan applies ONE chain rather than trying several, so there was no ordering to do; the cost is actually paid by the operator who guesses a chain and spends a whole run finding out it was wrong. This removes the guess.
  • The table is deliberately coarse and says so everywhere it is surfaced. A product name says what KIND of thing is in front of the application, not which rule fires on this endpoint, and the backend behind it decides as much as the filter does. So the suggestion follows what the filter's class implies (a keyword/regex rule set is defeated by mangling the keyword, which is why those lead almost everywhere; a front end that normalises aggressively is where the fullwidth and overlong forms are worth the requests) rather than claiming vendor-specific efficacy. A suggestion that read as a guarantee would be worse than none, because it would send an operator away from a bypass that would have worked.
  • Every suggestion is asserted to be a chain the build can actually apply, for every product in the table plus the unknown and empty cases: a suggestion naming an encoder that does not exist would be the exact failure these transforms must never have.

Request-shaped bypass: the JSON point speaks it too

  • A JSON body cannot carry a duplicated query parameter, but it has the same disagreements in its own notation, so the request shapes now apply at the JSON insertion point under the same names. pollute/pollutelast emit the same KEY twice in the object holding the target scalar (parsers genuinely differ on which wins, so a filter reading the first sees the benign value while a parser binding the last reaches the sink), and bracket sends the scalar as a one-element ARRAY, which many binders accept for the same field while a rule matching a string value misses. Where the point cannot express a shape (an array element has no key to duplicate) the plain mutation is used unchanged rather than emitting something that means nothing.

BCheck: the "in" operator, which was the whole gap

  • BCheck's in operator puts the NEEDLE first ("root:" in {latest.response.body}) where every other operator in the language reads the other way round. The parser required the response reference to come first, so it refused the form outright, and a document is refused when any of its conditions will not compile. It is the same condition written backwards, so it is now rewritten into the order the parser already reads, splitting at a top-level in with the existing quote-aware scan so an in inside a string literal is not mistaken for an operator. "X" in {loopvar} is the one form whose haystack is not a response at all: inside a run for each block it asks which value the loop is on, and it is redirected onto the loop variable at emit time.
  • {...status_code} matches "40(1|3)" was refused by a guard that modelled only status is N. Reading a regex as a number gives 0, so the condition could never be true; it now emits a regex test against the status text.
  • Measured against the same corpus: 167 of 265 documents to 191 (63.0% to 72.1%), with the documents that compile with NOTHING skipped rising from 174 to 182. The four constructs the backlog entry named as the gap (nested if ... end if, not(...), {to_lower(...)}, {var} in {collection}) turned out to be 1 to 3 predicates each: the importer was instrumented to print the exact predicate it refused, and the real answer was the in operator at 415 uses. That is the second time in this backlog that reading the corpus contradicted a plausible guess about it.

Jaeles: the origin baseline, and the regex escapes that were being eaten

  • A Jaeles origin: request is a BASELINE: a top-level request pointed at a path that should not exist, so a target answering everything with the same page (a soft 404) can be told from a real hit. It is now sent once, before the requests, and the detections that compare against it are translated: Diff(), OriginContentLength(), OriginStatusCode(), ContentLength('body'), CommonError(), Math.abs(...) with the binary -/+ its length comparison needs, and the o-prefixed search targets (oresponse, oresHeaders, oHeaders). Those targets used to map onto the CURRENT response, which quietly turned a comparison against the baseline into a comparison with itself, so "this does not look like the baseline" was always false. Every one of them is refused when the signature declares no origin, because comparing against a request that was never sent is not a weaker check, it is a check that means something else.
  • Found on the way, and worse: the string-argument translator ate backslashes, but those arguments are REGEXES as often as they are plain strings. not\sfound became notsfound, a pattern that cannot match, and \.env became .env, where the dot matches any character (119 occurrences of \. in the corpus). The second form is the dangerous one: those patterns sit inside !RegexSearch(...) guards whose job is to EXCLUDE error pages, so a widened pattern does not merely miss, it stops excluding and the guard passes everything. Only an escape of the delimiter or of a backslash is consumed now.
  • Measured against the same corpus, before and after: 299 of 373 signatures to 316 (80.2% to 84.7%), every emitted script still parsing. The entry's own "33 signatures" was the total refusal count; 17 actually declare an origin. The nuclei and BCheck totals are unchanged.

Jaeles: several requests are alternatives to try, and a step with no detections is still a step

  • A Jaeles signature's several requests are alternatives to TRY, not conditions to AND. Measured over the 373-signature upstream corpus with a real YAML parser: of the 61 multi-request signatures, 21 give every request the SAME detections and change only the headers (the spoofed-IP retry: apache-status-page, haproxy-stat), where the second request exists precisely for the case the first is refused, so requiring both means the signature cannot fire in the case it was written for; 28 give every request different detections and are alternative endpoints or payload variants for one bug, any of which proves it. No sampled signature wanted its requests ANDed. The emitted check now reports when ANY detection-bearing request matched, and quotes the FIRST response that matched rather than whichever send happened last.
  • That measurement found a worse defect. A request with no detections was DROPPED for having nothing to match on, but such a request is not a condition at all: it is a step that exists for its SIDE EFFECT, and the proof is the request after it. terramaster-rce writes a PHP webshell and then reads it back, solr-rce enables the Velocity engine and then uses it, apache-tomcat-put PUTs a JSP and then GETs it. Dropping the setup step left the proof step testing a side effect that had never happened, so those checks were not failing loudly, they were inert. Every request with a URL is now sent, in order; a detection-less one contributes nothing to the verdict, so a failed setup cannot masquerade as a finding. 3 signatures now send a step that used to be dropped, and 47 now OR instead of AND, with compilation unchanged at 299 of 373 and every emitted script still parsing: this changes what the scripts do, not how many compile, which is why the corpus totals alone would have hidden it.

Input-filter bypass: the request-shaped half

  • Some input-filter bypasses cannot be written as a payload encoder at all, because they change the shape of the REQUEST rather than the value in it: the transport URL-encodes what it is handed into ONE literal parameter value, so an encoder returning 1&id=x produces a parameter whose value is the text 1&id=x. fissure_wafrequest is the companion that lives at the request-BUILDING seam instead. Six shapes: pollute sends the parameter twice with the benign value first (for a filter that inspects the FIRST occurrence and an application that takes the last), pollutelast is the same pair reversed, bracket sends the name as name[] (which PHP and Rails map back to the same variable while a rule keyed on the exact name misses), dotnotation sends name.x for a binder framework, charset declares a character set the filter and the application disagree about, and mpboundary quotes and pads the multipart boundary. Each one is a disagreement between two parsers that both claim to read the same request, chosen so the APPLICATION's reading is unchanged: the payload still reaches the same sink, which is what makes the result a demonstration of the underlying bug rather than a different test.
  • An unknown shape is a hard error everywhere it can be asked for (the CLI refuses to start, the control API returns 400, the preview route names it) rather than a silently-ignored option. A bypass that quietly does nothing is the one failure mode these must never have.
  • The "which transform carried this finding" evidence now knows about them, and names whichever half carried the probe. Its canonical re-send drops BOTH halves, the transformed value and the request shape, because a canonical request still carrying a duplicated parameter is not canonical and the comparison would say nothing.
  • Surfaces: --waf-request on the CLI, waf_request on POST /api/scans, a POST /api/wafrequest preview route, and the wafrequest MCP tool.

Input-filter bypass: nine more transforms, and a finding that says which one carried it

  • A finding produced while a WAF-bypass chain is active now says WHICH transform carried it, and whether the filter was involved at all. Naming the chain alone would be a claim about the scan's own configuration: on a host with no filter the untransformed payload works just as well, and a report claiming a bypass there is wrong in the direction that costs a tester their credibility. So the claim is measured. When an encoded probe produces a finding, the canonical payload is sent once more: refused with a filter status (403/406/419/429/501) next to a transformed one that was answered reads as an input-filter bypass, names the chain and quotes both statuses, which is a finding about the FILTER the owner can act on; a canonical payload that was NOT refused says so, and states that the transform is not what made the bug reachable. One request per finding, never per probe.
  • The encoder library is written in WIRE form: an encoder that wants the application to read a particular byte emits its percent-escape, which keeps every result printable and valid UTF-8 so it survives a JSON control-API field. At the query, path and form insertion points the transport percent-encodes the value again, so the escape reached the application as literal text and the transform did nothing: test AND 1=1 under space2tab arrived as test%09AND%091=1 with the %09 as three characters. The chain output is now decoded once at those points, next to the url-family strip that exists for the same reason. That is where the fix belongs rather than in the encoders, because the overlong two-byte form is not valid UTF-8 and would not survive the control API; an escape an encoder means to reach the application intact is not a valid one and no decoder consumes it, which is how percentage passes through unharmed. It fixes space2hash, space2dash, space2randomblank, apostrophemask and overlongutf8, and the pre-existing space2tab.
  • Added nine transforms in the two families a payload-shaped encoder can express. Whitespace and comments: space2hash / space2dash (a space becomes a comment running to a newline, so a rule written around "keyword SPACE keyword" stops matching while the statement still parses), space2randomblank (consecutive spaces become different whitespace bytes), multiplespaces, randomcomment (an empty inline comment inside each SQL keyword), commentbeforeparentheses. Per-engine quirks: percentage (each letter percent-prefixed, which IIS/ASP strips), apostrophemask (the fullwidth apostrophe, which a normalising backend still reads as a quote), overlongutf8 (the illegal overlong two-byte form of the metacharacters, which a lenient decoder folds back). One deliberate departure from the sqlmap tampers they mirror: they are DETERMINISTIC. Consecutive separators still differ, which is what defeats a fixed-separator rule, but the same payload always produces the same request, because a finding that cannot be reproduced byte for byte cannot be handed to the owner.

Jaeles: list variables, and the header name that was never right

  • A Jaeles variable whose value is a multi-line block or an inline sequence is the LIST of values to try, not one value. The importer used to throw it away, which refused 182 of the 373 upstream signatures because their target was left with nothing in it. The request that references such a variable is now sent once per value (a product when it uses several lists) and matches if ANY value does, since a list is values to TRY and requiring all of them inverts what the signature says. The loops stop at the first match, so the finding quotes the response that matched. Capped at 256 values per list and 512 sends per run, with the truncation reported: one upstream signature lists 1240 paths, and a check that walks all of them is content discovery wearing a check's clothes. Measured with the same harness and corpus, before and after: 150 of 373 signatures to 299, every emitted script still parsing in the engine that runs it.
  • Reading those newly-compiling scripts found a defect nothing else would have: headers: is a YAML sequence of one-key maps, and the item marker was being kept as part of the header name, so every imported Jaeles signature had been sending - User-Agent instead of User-Agent. The corpus uses that block to add spoofed-IP headers meant to reach a restricted page; they had never done anything.

Purple-team follow-ups: a CLI half, a baseline to compare against, and less friction

  • Added run-to-run comparison. A run's coverage table can be kept as a baseline and a later run diffed against it, so every technique comes back unchanged, improved, regressed, new, or not-re-tested. A technique whose detection coverage FELL becomes its own finding ("Detection regression: sqli coverage fell from 100% to 0%"), which is the failure a single measurement cannot show: the rule was working when it was last measured, so something changed on the defending side (a rule disabled or narrowed, a sensor that stopped receiving the traffic, a pipeline that dropped the field the rule reads). GUI Baseline/Diff buttons, {"op":"baseline"} / {"op":"diff"}, the same over MCP, and fissure purple diff, which exits 1 on a regression so a scheduled run can gate on it.
  • Added the CLI half: fissure scan --purple <run> records the scan's own requests and reports the per-technique tally, and fissure purple status|import|reconcile|findings|baseline|diff|clear|marker drives the rest against the project's store, the same file the popup and the control API read. Recording starts after the --login replay on purpose, so the login POST's credentials never enter a probe store a report quotes from.
  • Telemetry can be imported from a file the Fissure host reads itself, everywhere: the API's {"file":...}, file= on the MCP tool, Import file in the popup, and a path on the CLI. The control API caps a request body, so a real multi-megabyte export used to have to be split across posts; it is a local file read as the Fissure user on a loopback token-gated API, capped at 32 MB, and the documentation says so rather than leaving the reader to work out what the token now reaches.
  • The Purple team popup keeps itself live while a run records: its panes refresh every couple of seconds, and only when the store has actually grown, so a scan shows its probes arriving without an idle popup rebuilding anything. The two large grids list the newest few hundred rows and say so; the tallies still count the whole run. Opening the popup also reads the project's saved run back, so a later session opens on the last engagement instead of an empty grid.
  • The browser dashboard gained a Purple tab next to Jobs: record under a named run, import telemetry (pasted or by path), reconcile, emit findings, take a baseline and diff against it, with each technique's baseline percentage beside its current one.

Purple-team mode: measuring the defenders instead of evading them

  • Added purple-team mode, the constructive counterpart of the no-evasion rule: Fissure records what every probe looked like on the wire (its tool, its technique, its bytes, its response), the operator imports what the target's own logging and alerting produced over the same window, and the two are reconciled into a per-technique detection-coverage table. Each probe ends unseen (no telemetry mentions it), logged (the target recorded it but raised nothing) or alerted/blocked, and every technique nothing alerted on becomes a finding (CWE-778, OWASP A09), so "did they see us" is reported to the owner instead of guessed. Probes are deliberately identifiable: unless the marker is turned off, each one carries an X-Fissure-Probe: <run>-<id> header so a line in the defender's log names one exact request. Telemetry imports with no configuration from JSON lines, common-log-format access lines or free text. On all four surfaces (the "Purple team" popup, /api/purple and its probe/telemetry listings, four MCP tools, and the skill's methodology), with the whole loop tested offline, over the API and over MCP, plus an engine-level test that the marker really reaches the target.

Fuzzing, and a corpus figure for every importer

  • Fuzzed the parsers that read bytes Fissure did not write: the proxy's own HTTP/1.1 framing (over a socketpair, so the static readers are reached without widening a production API), raw HTTP splitting, the three template importers, YAML, protobuf, SAML, JWT and API specifications. The first campaigns found two memory leaks in the nuclei importer, both reachable from a downloaded template; both reproducers are committed as seeds so the fixes cannot rot. One finding was investigated and dismissed: an apparent memory blow-up was libFuzzer retaining a large corpus, not the parser.
  • Measured the BCheck and Jaeles importers against real signature corpora for the first time, through the same harness the nuclei one now uses. Jaeles was importing two signatures out of 373. It skipped the block the corpus uses to name its target; it read the component argument only in a documented form that appears in zero upstream signatures while the form used a thousand times over was refused; and it transliterated a malformed source expression straight into JavaScript that could not parse, which silently killed the whole script. It also used to emit a request whose target still held an unresolved variable, so the check went out asking for a literal placeholder, never matched, and reported nothing, which reads exactly like a clean result: those are refused now, honestly, which is why the figure is 150 rather than 302.

Sanitizer and corpus sweeps: two axes the audit never covered

  • Put the GUI under ThreadSanitizer for the first time as well, by building the app with make SAN=tsan and driving it through its headless self-test flags against the DVWA lab. Every worker/tick handshake in the GUI is now atomic on both sides, and the run found a race that was not a flag at all: the scanner seeded its crawl frontier (robots.txt, sitemap.xml) into the shared inventory outside the scan lock, while the dashboard tick walked that same inventory every frame. tests/tsan-suppressions.txt keeps the GTK stack Allegro pulls in from burying real reports.
  • Ran the whole regression suite under AddressSanitizer and ThreadSanitizer for the first time. ASan found a use-after-free on a live control-API route; TSan found 27 distinct data races, most of them a stop or progress flag shared between threads and read plainly, several of them declared volatile as though that were synchronization. The proxy also serialized a captured flow with no lock while another thread could free the very strings it was reading, and the extension key-value store had no lock at all and handed out pointers that a concurrent write frees. Details in docs/audits/SANITIZER_SWEEP.md.
  • Re-measured the nuclei importer against the current template corpus, which has grown by about a fifth since the last figures. Two real gaps surfaced, both fixed: a dsl matcher could not read a value its own request's extractor had just captured, which is the standard shape for version-gated CVE detection and refused those templates outright; and a response header could not take the suffix that names an earlier request's response, which is how a default-login template checks the redirect of its login POST. Clean compiles went from 97.8% to 98.5%, and every emitted script still parses in the engine that runs it.

Closing the audit: the last two open items

  • The Global Search jumped to the wrong record on any sorted grid, and the sort indicator on Proxy, Logger, Findings and Target claimed an order the rebuilt rows were no longer in. Both were the same bug in different clothes: a display position is not a record identity, and clearing a grid's rows does not clear its header arrow. Search now asks the owning view to reveal the record by its own key, and each grid reads its sort before a rebuild and re-applies it after.
  • The traffic query API accepted any field name and quietly matched nothing, so a misspelled field returned an empty result that reads exactly like "no traffic matched". Traffic, findings and WebSocket frames each declare their vocabulary now, and a name outside it is an error.
  • The data grid can be driven from the keyboard: it takes focus, and up/down, page up/down, home/end move the selection, fire the same callback a click does, and scroll the row into view, with shift extending a range and left/right scrolling the columns. It was the only list widget in Nilorea without this. Writing its test found a second upstream bug: clearing a grid's selection was unreachable through the API.
  • The proxy no longer buffers a whole body before forwarding a byte. Up to 16 MB is held exactly as before; past that the rest is relayed straight through, so an 18 MB download arrives byte-exact and starts arriving immediately instead of growing a worker's buffer until the process dies. A capped flow is not held for interception, rewritten, or captured in full, and that loss is reported three ways rather than being silent: an operator popup, a warning in the event log, and a marker on the flow itself that the GUI, the control API and the MCP tools all carry.
  • Wired up the proxy's operator-notice channel, which had no consumer anywhere in the tree: the WebSocket-capture-ceiling warning it was written for only ever reached the log, so a session that silently stopped capturing WebSocket frames looked exactly like one that had nothing to capture.

The audit's remaining backlog: the GUI, the control plane, and the tests' own mess

  • Closed the defect backlog the full functionality audit left behind. Every entry it recorded is now fixed and verified against its reproduction; six remained open at the time, and all six have since shipped.
  • The Sequencer's token capture ran up to a thousand blocking requests on the GUI thread, so the whole application froze for as long as it took and the status line it set was never even drawn. It runs on a worker now, with a progress bar, and a Stop that ends after the request in flight and analyses what it collected.
  • The raw request editor's Send blocked for up to ten seconds against an unresponsive host and leaked its transport configuration on every send. Both fixed.
  • Editing or deleting a row in a sorted rule list hit the WRONG record: thirteen popups used the display position as a store index, and sorting physically reorders the rows. They now carry the record's identity in the row itself. Two more of those, in the Environments and inline-tag editors, were found the same way and had never been reported.
  • Destructive actions that had no confirmation now ask first and name what they destroy. The "Restore defaults" buttons were the worst of them: one click deleted every rule or hand-written tag the operator had authored, with no undo.
  • The Global Search results were dead text; a hit is now a link that jumps to the record in the view that owns it, and results filter as you type.
  • The assistant could widen its own authorized scope, which is the boundary every active action is checked against. It can read the scope now, not set it.
  • The control API's saved attack configurations ran as the wrong attack mode and never applied their payload processing, so an attack tuned in the GUI sent different bytes when replayed headlessly. Both fixed, and the MCP bridge now exposes them, which it did not.
  • Added the four-surface parity test that would have caught the whole class: it checks every route against the MCP bridge AND the skill's tool catalog, argument by argument, in both directions. It was validated by injecting each defect it is meant to catch and confirming it fails.
  • A run of the test suite used to leave three hundred directories and 485 MB behind, including browser profiles holding the browsing state of whatever site was probed. Eight tests never cleaned up; one of them called rmdir, which silently does nothing on a directory that is not empty.

Full functionality audit: correctness fixes across the whole tree

  • Audited every functional area of Fissure in parallel (transport, proxy and interception, crawling and scan orchestration, the vulnerability checks, findings and reporting, the plugin and extension hosts, the request workshops, persistent state, OAST and recon, the browser bridge, the GUI, and the control-API/MCP/skill surfaces), reproducing each defect against a purpose-built target or under a sanitizer before changing anything. What was fixed is below; what is still open is listed with its evidence under "Bugs to fix" in docs/TODO.md.
  • Fixed the transport accepting any trusted certificate for any host: verification checked the chain but never the name on it, so a certificate issued for a domain the holder controls was accepted for every target. Every scanner, repeater, intruder, check, CLI and control-API request was affected; the interception proxy already did this correctly.
  • Fixed HTTP/2 responses reporting no elapsed time, which silently blinded the time-based blind-injection oracle on every https target that negotiates h2 (the default).
  • Fixed Transfer-Encoding and Content-Encoding being matched case-sensitively: a response reading Chunked had its chunk framing treated as body content, and against a keep-alive server the read ran to the timeout and the whole response was discarded. The proxy's HTTP/1.1-to-HTTP/2 re-framing had the same bug for a list-form gzip, chunked.
  • Fixed a dangling transport-config pointer left behind after an interrupted connect, which a later connect on the same thread would dereference (a read of a dead stack frame, confirmed under a sanitizer).
  • Fixed a multi-challenge 401 being misread: only the first WWW-Authenticate header was examined, so an IIS-style Negotiate+Digest challenge went unanswered and an Apache-style Basic+Digest challenge was downgraded to Basic, putting the password on the wire.
  • Fixed the crawler submitting a discovered form to whatever host its action named, with no scope check at all, and fixed robots.txt and sitemap seeding escaping the scope entirely, which let the target choose what Fissure attacked next.
  • Fixed relative links after a redirect resolving against the pre-redirect URL, so any site that redirects its entry path into a subdirectory lost its whole link graph.
  • Fixed selecting an injection sub-family (only SQLi, only XSS) running zero active probes and reporting a clean target.
  • Fixed the headless browser's same-origin test being a bare prefix compare, which let a link navigate it to an attacker-chosen domain carrying the injected session cookie.
  • Fixed a heap overflow in the login recorder when a login form carries more parameters than its token map was sized for.
  • Fixed the interception rule set being read by proxy workers while another thread freed it, a use-after-free reachable by one edit in the intercept-rules editor while traffic flowed.
  • Fixed an interim 100 Continue being delivered as the final response, which permanently desynchronised the connection so the next request received the previous one's answer and the flow history attributed it to the wrong request.
  • Fixed Content-Length never being recomputed after a rewrite, so a match-and-replace or an intercept edit that changed the body length silently failed and desynchronised the origin.
  • Fixed a reused keep-alive connection the origin had since closed yielding a 502 with no retry, which made browsing through Fissure randomly fail against any origin with an idle timeout, and fixed upgraded/WebSocket tunnels being torn down after 30 seconds of silence.
  • Fixed the raw relay leaking every capture chunk it evicted, unbounded over a long-running relay.
  • Fixed out-of-band canary tokens being minted with a non-atomic counter while the audit runs one worker per core, so two probes could share a token and one callback confirmed both, fabricating a CERTAIN-confidence blind finding for an insertion point that was never reached. The active-check marker counters had the same defect and the same consequence for the reflection, stored-XSS, mass-assignment, prototype-pollution and cache-poisoning oracles.
  • Fixed report evidence being truncated mid-character, which produced JSON and XML no parser would load, and fixed raw control bytes and invalid encodings reaching the XML export, where one bad byte made the entire file unimportable.
  • Fixed target-controlled finding text being injected raw into the default Markdown report, where an evidence line of backticks closed the fence early and left injected markup rendering live.
  • Fixed a finding's tag list being rebuilt in a fixed buffer, which silently destroyed tags and dropped the highlight while reporting success.
  • Fixed the report connector's idempotency key being truncated, so two findings with long URLs collided and one permanently overwrote the other.
  • Fixed the control API answering HTTP/1.1 422 OK and 502 OK, truncating a configured API token to 127 bytes (locking the operator out with no explanation), comparing that token with a short-circuiting compare, silently truncating a request body just under the size limit and then blaming a missing argument, and serving every connection from a single thread so one slow client wedged the whole API including its health check.
  • Fixed fourteen control-API handlers that discarded the result of a save and answered success, so a profile, schedule, saved query, tag, environment variable, workflow or team change was reported saved and was gone at restart.
  • Fixed an out-of-scope scan seed being refused with a 200 carrying an error object; it is now a 403, so a client that reads only the status cannot record the scan as having run.
  • Fixed the request context menu running a different check from the one clicked whenever any menu entry was filtered out, and three entries being unreachable.
  • Fixed the JavaScript engine deleting a custom inline tag's own content when a transform ran on a worker thread, and fixed extension request hooks entering one shared engine from one thread per connection, which aborted the whole application.
  • Fixed nuclei template variables being emitted before the helpers they call, which killed 429 of the importable templates on their first line.
  • Fixed the DOM-XSS heuristic reporting an ordinary JavaScript redirect as a finding (a sink token that is also a source token matched itself), missing the textbook jQuery selector injection where the source precedes the sink, and never running on standalone JavaScript bundles at all.
  • Fixed a JavaScript plugin package being read as its core library, which attached real CVEs to fully patched sites, and fixed that finding being emitted once per crawled page instead of once per host.
  • Fixed a public page being reported as broken access control (the second-identity replay was not gated on the original carrying credentials), and two empty bodies comparing as identical evidence of a bypass.
  • Fixed a redirect to a login page counting as "the role reached the resource", which put every protected page of an ordinary login-redirect application into the report.
  • Fixed the GraphQL introspection oracle matching the standard refusal message, which reported a correctly hardened endpoint as having introspection enabled.
  • Fixed the missing-X-Frame-Options finding never looking for the CSP directive that supersedes it, while its evidence asserted it had.
  • Fixed the WAF-bypass chain being tokenised differently from the code that applies it, which let the URL encoder through at the points that must not double-encode.
  • Fixed the live-audit dedup key dropping the scheme and port, so an admin panel on a non-standard port was never actively audited.
  • Fixed a request copy truncating a body at its first NUL and dropping the session cookie jar, so an authenticated retry re-sent different bytes without the session.
  • Fixed the raw request record dropping the query string and omitting the body's length, and fixed a resource-pool slot being credited back when it had never been taken.
  • Scoped the single-request cancel token to its owning thread, so pressing Cancel in one tool no longer aborts another tool's in-flight requests or shuts down a socket it never armed.

Authentication routes, the request-parameter jar, and form-submitting crawls

  • Reworked the authentication guidance in the scanner documentation, the in-app help and the bug-bounty skill to lead with a configure-verify-scan procedure instead of a seven-route menu you had to choose from correctly up front; every existing way of authenticating still works unchanged.
  • Added an authentication check that runs the configured login route once and reports whether it actually works, without running a scan; it compares the same URL fetched with and without the session, and deliberately answers "inconclusive" on a public page rather than a false pass. Available as a Test authentication button, a control-API route, an MCP tool and fissure scan --auth-check.
  • A crawl authenticated by the parameter jar's login POSTs now re-establishes its session when it expires mid-run, instead of silently finishing anonymous and reporting a thin result that reads like a clean target.
  • Added an authentication decision tree to the scanner documentation and the in-app help, naming every route a session can take into a scan, what happens when two are configured, and how to tell from a scan's output which one was needed.
  • Wired the three pieces an end-to-end run found inert, so a jar-carrying send, a login-primed crawl and a form submission all take effect on the paths that actually run them.
  • The crawl can now submit the forms it discovers, reaching pages that only exist after a submission; gated behind both its own opt-in and aggressive mode, and refusing a logout form, a file upload, a destructive-looking form, and any form action it has already submitted.
  • Exposed the parameter jar on every surface: the control API, the MCP bridge, the CLI and the web dashboard, alongside the popup.
  • Made the parameter jar process-global, so every tool that sends a request carries the same jar rather than each keeping its own copy.
  • Added the Parameters popup, with per-row On/Query/Body/Track/No-fuzz/Required toggles and an optional per-row refresh URL for a token bound to one form.
  • The crawl can now POST a declared list of URLs before it starts, so a session behind a login form is established before any page is fetched; off by default, and it warns that it writes to the target.
  • Parameter values are never sent to an out-of-scope host, never enter the canonical URL the site map dedups on, and are scrubbed out of finding evidence as a finding is created, so a report cannot publish a session token or a credential.
  • Fixed content discovery escaping the shared resource pools: it sends through the Target view's transport config, which was never tagged as scanner traffic, so a pool scoped to "scanner" never applied to it.
  • Applied the parameter jar on every transport, so a tracked token is carried whichever engine path issues the request.
  • Added a request-parameter jar: GET/POST parameters a crawl carries so a target whose session lives in a request parameter (a rotating anti-CSRF token, an API key, login fields) can be crawled authenticated. Jar-carrying sends serialize while a tracked, required row is set, so two audit workers cannot consume the same single-use token; the status line says when that is in effect, since it slows a scan.
  • Target-view scans now use the suite-wide shared cookie jar when no login config is set, so a session captured by the proxy or the Repeater authenticates the crawl instead of it running logged out. Added a User Agents button to the Target view, next to the scan controls that send the active preset.
  • Moved Auth & session and Recon & infra ahead of Capture in the toolbar, and versioned the saved toolbar layout so a change to the built-in category order reaches an existing install.
  • Added a directory-listing probe that reports every directory serving a browsable file list, and a WordPress path set (config backups, installer, debug log, xmlrpc, user enumeration) to the sensitive-file probes and the discovery wordlist.

The User-Agent preset library

  • Expanded the built-in User-Agent presets into a broad default set of well-known desktop and mobile browsers (Chrome, Firefox, Safari, Edge, Opera, Samsung Internet, and IE 11 across Windows, macOS, Linux, Android, iOS, and iPadOS) alongside the existing crawler and CLI-tool strings.
  • Fixed a use-after-free in the User Agents manager: the popup read the active-preset name after the parsed response was freed, so the status line showed garbage instead of the active preset.
  • Added a User-Agent preset library with an active selection that every scan, repeater, intruder, check and recon request adopts, plus per-request overrides, a manager popup, a Repeater request-bar picker, and matching control-API and MCP surfaces.

The Windows port lands on target

  • Added a test pinning that Repeater, proxy history, findings and Target data persist per project across a switch.
  • Confirmed the Windows hang fix on target: the scan ends on its own, restarts, and stops on demand, with the two runtime-only faults recorded as fixed and the sem_getvalue trap documented.
  • Stopped the control server dying on SIGPIPE, which could take the whole application down when a client hung up.
  • Linked -lbcrypt so Windows gets real randomness, without which control tokens and job ids were NULL.
  • Fixed a scan Stop that could not interrupt requests issued through a copied transport config, using an explicit cancel group.
  • Fixed three Windows build errors (a two-argument mkdir, an unshimmed memmem, a misplaced path constant) and the cross-sweep documentation that let them through.
  • Fixed the scan being the only tool not resolving TLS trust, a give-up verdict every call site discarded, retried certificate rejections, and crawl failures bypassing scan accounting.

Draining the full-surface audit backlog

  • Harvested the TODO from 346 lines to 135, added an intentional-non-goals section, and fixed two stale cross-references.
  • Gave the web dashboard interception, scan and job cancel, and the full scan-options set.
  • Added resource pools, process-global named budgets that bound concurrency and rate across all tools at once.
  • Gave the Sequencer live capture and a per-position, per-bit statistical suite, alphabet-aware so a text token is not scored weak by construction.
  • Added raw request editing, a byte-level editor with linked escaped-text and hex views, plus its headless route and MCP tool.
  • Added an escape syntax module that carries byte-exact messages through text editors.
  • Made a captured flow record which protocol the client spoke, separate from the upstream TLS note.
  • Made the proxy's client leg terminate HTTP/2 via ALPN, re-framing each stream onto the shared HTTP/1.1 pipeline.
  • Made chunked request bodies de-chunk before forwarding over HTTP/2 instead of falling back to HTTP/1.1.
  • Added HTTP Basic and Digest authentication, per-host client certificates on the proxy path, TLS version and cipher control, and TLS for the control server.
  • Made saved Intruder attack configs and Repeater tabs reachable headlessly, closing the last GUI-only stores.
  • Swept eight gaps at once: real bytes in the hex view, seven documentation-drift fixes, structured parsing for seven plugins, nine orphan tools decided, IAST beacons listed separately, reflow for six popups, and an Inspector palette entry.
  • Made an over-large response say how much was cut, turned the cap into a setting, and stopped measuring binary bodies with strlen.
  • Made the nine remaining silent failures report: exec failure, plugin exit 127, a refused job cancel, a broken extension script, and four missing-resource cases.
  • Split the injection family into seven maskable sub-families, made the passive suite maskable, and added scan retry and consecutive-failure handling.
  • Added nested and encoded insertion points, so every check probes inside a base64 or JSON blob unchanged.
  • Added a dashboard regeneration check, and made the external-file openers report failure instead of doing nothing silently.
  • Excluded static assets from the active stage and the coverage denominator, and made form probes fill untested fields with plausible values.
  • Wired the GUI half of live audit as a Proxy-view toggle running on its own worker thread.
  • Added live active auditing over proxy traffic, off by default, auditing each observed endpoint once with a values-collapsed dedup key.
  • The cross-tool Logger now retains request and response bytes, with a two-pane detail view, a "To Repeater" action, and matching control-API and MCP surfaces.

Extensions, interception rules, and semantic parity

  • Added skill playbooks for response tampering and for the extension capabilities.
  • Added a third-party extension publish path, so an extension can be packaged and distributed outside the shipped set.
  • Gave each extension its own QuickJS context and persisted its fs.store state, so two extensions cannot collide and a stored value survives a restart.
  • Made merging captures idempotent, so reloading a session stops multiplying the evidence archive, and carried host_scoped through the session file so a reload deduplicates.
  • Made the proxy intercept IP-addressed HTTPS targets, and kept the port in a captured URL.
  • Enforced semantic parity between the GUI, CLI and control scan paths, so a headless scan runs the same checks with the same options as the GUI one.
  • Replaced the hand-maintained control-API route table with a table-driven registry, and added a build-time check that every capability reaches all four surfaces.
  • Made the proxy capture the request that was sent, not the one that arrived, so a rewritten request is recorded as it went on the wire.
  • Added extension request-mutation hooks, enforced the documented scope check on extensions, and made extension work async.
  • Added ordered conditional intercept rules, and response interception, so the interception UI stops claiming a capability it did not have.
  • Made the intercepting proxy speak HTTP/2 upstream.
  • Added in-message find, and made Global Search read bodies.
  • Added a fissure api passthrough command and one authoritative usage block for the CLI.
  • The Intruder view now drives a full request rather than a URL, and Send-to-Intruder carries the whole request with it.

The full-surface audit: closing the headless gaps

  • Added control-API routes for finding annotations, the clickjack PoC generator and auto-replay.
  • Added explicit Save session and Open session actions to the Report view.
  • Added a Probes popup for origin IP, WAF fingerprint and page capture, and brought the last stranded probes and encoders within reach of the GUI.
  • The Jobs monitor can now show what a job found.
  • Added an Import checks popup and a writable per-user checks directory.
  • Served the proxy CA over the API and retired a route that never existed.
  • Made the control API refuse cross-origin requests, and refuse to publish itself unauthenticated by accident.
  • Made a redirect resolve a relative Location instead of pasting it onto the authority.
  • Gave the control plane a cross-tool traffic log and host-routing rules.
  • Made headless scans accept the transport config the GUI scan applies, and the headless proxy apply the transport knobs the GUI one does.
  • The headless Intruder accepts one payload set per position.
  • Report options and the job cap reach every surface.
  • API-saved sessions carry their evidence, at both ends.
  • Ran the passive audit on the headless proxy with a two-stage opt-out, and made the GUI honour both opt-outs and re-run the audit on demand.
  • Wired the out-of-band collector into every scan path.
  • A failed scope write is reported, never shown as a save.
  • The CLI scan loads the scriptable check sets.
  • Audited every capability surface end to end and turned the result into a tracked backlog.

Windows packaging and the console front end

  • Added fissure-cli.exe, the blocking console front end on Windows, and linked the GUI application with -mwindows so it no longer opens a console window.
  • Bundled the fonts with a font picker, recorded their licensing, and added an About box.
  • Made fissure_surface use a portable strcasestr, and fixed the cross-compile sweep that missed it.
  • Moved the version bump to packaging builds only, so an ordinary build, a test run and a static check leave the version alone.
  • Fixed the mingw64 build of the HTTP/3 MITM listener.

Scan profiles, the time-based oracle, and the OSS-tool roster

  • Codified the universal dialog-reflow rule and fixed a stale Repeater doc.
  • Added five dedicated built-in scan profiles (API, Injection, Access control, Client-side, Gentle).
  • Added three more generic workflow templates (cookie flags, sensitive URL, CORS).
  • Fixed the "Time budget" label truncating in the Scan-options popup, and made it reflow on resize.
  • Renamed the Repeater response view's "Pretty" option to "Highlighted", which is what it does.
  • Made the Scan-options tooltips state what a blank value means and what the default is.
  • Consolidated every scan option into the Target Scan-options popup, per profile.
  • Raised the time-based probe concurrency default to 6 and added 0-value hints to the scan options.
  • Gave the time-based oracle an adaptive timeout and a default-1 gate, and tuned the concurrency and rate presets, so a slow-responding sink stops reading as a hit.
  • Added a per-host time-based-probe governor with two-probe confirmation, fixing an aggressive scan that wedged against the lab target.
  • Wired the Jaeles importer and the new OSS plugins into the dashboard, the tutorial and the in-app help.
  • Taught the Jaeles importer generator-function variables (RandomString, RandomNumber), then variables, multi-request signatures and passive signatures before that.
  • Added a masscan plugin and closed out semgrep and notify, completing the OSS-tool survey.
  • Added stdin support to the plugin host, and a dnsx plugin that needs it.
  • Added the OSS-tool second tranche: wpscan, paramspider, and a Jaeles signature importer.
  • Widened the browser control dashboard toward full route coverage with nine new tabs.
  • Surveyed the OSS-tool landscape and shipped the first tranche: naabu port scanning and arjun parameter discovery.
  • Added predefined workflow templates, with a New-from-template picker and control-API and MCP instantiation.
  • Added a GUI "Restore defaults" button to the three rule modules (highlighter/extractor, session rules, auto-replay).
  • Shipped starter content for an empty install: a saved-queries library, an inline-tags starter set, and a template environment preset, on a shared default-config preset seam.
  • Wrote full tutorial chapters for the gaps the coverage audit found.
  • Wired "Send to Comparer" and removed twelve dead exported symbols.
  • Closed the seven MCP smoke-test coverage gaps, and reconciled the documentation drift the audit found.

Importer depth, desync variants, and IAST agents

  • Added fully-automatic JVM bytecode IAST instrumentation, plus a .NET agent.
  • Added HTTP/3 downgrade request smuggling (an h3.TE desync probe) and HTTP/2 request splitting (an H2.SPLIT downgrade desync).
  • Added out-of-band XXE via nested parameter entities (an external DTD).
  • Added nuclei raw-request template support through fs.sendraw, and binary matchers through fs.bodyhex, closing the nuclei-import documentation gaps.
  • Added a libxml2 XPath engine and fs.xpath, so nuclei XPath matchers and extractors import instead of being skipped.
  • Added a UTF-16 XXE WAF bypass (a utf16 encoder and a waf_xml_utf16 scan option), on a binary-safe request-body path that also enables binary uploads.
  • Added per-step request customization in multi-step imported checks.
  • Added more HTTP/2 desync variants: H2.CRLF header injection and h2c upgrade smuggling.
  • Added tunable DNS-rebind timing profiles and a per-target rebind-window report.
  • Added JS source-map unpacking to the endpoint miner.
  • Added a native SPA interaction crawler driven over CDP.
  • Added a Java IAST reference agent, completing the language-agent slice.
  • Shipped fuller nuclei and BCheck importer engines: kval and JSON extractors, DAST, chaining and interactsh support on one side, multi-step named responses, a variable pipeline and defined foreach on the other.
  • Added nuclei regex extractors and subdomain-takeover CNAME chain following.
  • Ran all context-menu checks as jobs, and added grid column-customization to the Logger, highlighter/extractor and Jobs grids.

WAF bypass, jobs, and the grids

  • Added a horizontal scrollbar to the datagrid (upstream), and preserved its horizontal scroll position across the wide grids' rebuilds.
  • Added five WAF-bypass encoders equivalent to the common sqlmap tampers.
  • Added WAF bypass as a selectable scan option for XML/XXE request bodies and for JSON request bodies, with context-aware encoding.
  • Polished the Jobs monitor, added the scan-profile GUI, and ran context-menu checks as jobs.
  • Registered GUI scans as control-API jobs, so the Jobs monitor unifies what the operator and the agent are running.
  • Fixed the Extensions popup going blank after a confirm dialog.

Row highlight, themes, and the unified job model

  • Added a one-click WAF-bypass retry as a context action, with its control-API route and MCP tool.
  • Removed the competitor-brand references from the code, the documentation and the skill.
  • Documented the MCP endpoint and the skill setup for both Claude and ChatGPT, and added a skill note on using finding and target highlight for triage.
  • Added five more themes (Slate grey, Tokyo Night, Catppuccin, One Dark, GitHub Light).
  • Added manual and rule-driven row highlight to the findings and site-map grids, matching the proxy grid, across all four surfaces.
  • Added job lifecycle events and a GET /api/events feed, so the GUI and an agent watch the same activity stream.
  • Added a GUI Jobs monitor popup with a live job grid and cancel.
  • Added a job concurrency cap with a queue, as a config knob, and a skill methodology for running checks as async jobs.
  • Added async cancellable on-demand check jobs under a unified /api/jobs model.

Technique coverage, context actions, and the site-map graph

  • Added a headless context-action selftest hook and validated the new context actions end to end.
  • Added per-check right-click context actions on a 64-bit action mask.
  • Made the workflow-bypass result a tentative assist rather than a firm finding, which the lab run showed it had to be.
  • Added active runtime confirmation of client-side path traversal over CDP, plus its PoC generator.
  • Added a business-logic workflow and step-order bypass probe.
  • Deepened the active CSRF check with method-override, SameSite-Lax and cross-identity cases.
  • Shipped the technique-coverage backlog: ten new checks and recon actions, and a revamped context menu.
  • Made the site-map graph scroll its own pane instead of the whole view, and stop stealing clicks.
  • Added double-click on a graph leaf to seed it, a current-mode display, and a window title that reflects the view.
  • Consumed the upstream combobox and list border fix.
  • Gave the site-map graph per-depth auto-fit columns so labels stay readable, right-click and hover on every node rather than only endpoints, natural-scale drawing with scrolling, and clipping to its view so a big graph cannot overflow.
  • Added the site-map node-graph overlay as a third Target view mode.
  • Renamed the proxy grid's "Hilite" column to "Highlight".
  • Documented installing and using the AI skill for CTF and bug-bounty work, and gave the skill a CTF mode and more exploitation depth.
  • Preserved scroll position and selection on the remaining action-bearing grids.
  • Added an interactive GraphQL argument workshop.
  • Closed the cross-surface parity and coverage audit gaps.
  • Painted highlighter/extractor and manual highlight colors on the flow row, with four-surface parity.
  • Made -O3 the default build and cleared the format-truncation warnings it surfaced.

The GUI overhaul: resizable, minimisable, native windows, dividers

  • Gave an OS window only to a popup that is actually open.
  • Added draggable dividers in the views, and reconciled the dialog chrome arithmetic.
  • Added an option to give tool popups their own OS windows, and a maximize button on every popup.
  • Made popups reduce to their title bar and come back.
  • Reflowed the last dialogs and added a whole-interface Reset GUI action in Settings.
  • Made the Multitool and Plugins popups resizable, and reflowed the remaining tool popups, fixing the Repeater header and body divider.
  • Added the resizable tool popup infrastructure and the reflow pattern behind it.
  • Launched the DOM Invader browser with an isolated profile.
  • Unified GUI-layout persistence into n_gui, dropping the separate panes and columns files.
  • Stopped logging a first-run error for an absent scopes or cookie-jar file.
  • Made the GUI panes adjustable and persistent, widened the category dropdowns, and added Organizer group-send.

Mid-scan re-authentication and the palette registry

  • Added a rate field to the Scan-options popup and a Scan-with-profile context action.
  • Brought the tutorial and the bug-bounty skill up to date.
  • Derived the command palette from the shared toolbar module registry, so one registry row gives a module both entries.
  • Persisted and reloaded the capture store with a GUI project, so evidence still resolves after a switch.
  • Made the persistent proxy match-and-replace ruleset, regex included, drivable over the control API and MCP.
  • Added mid-scan session re-authentication for authenticated scans, so an expired session is renewed instead of ending the run's coverage.

HTTP/3 end to end

  • Added request-pause interception of HTTP/3 requests, with edit and drop.
  • Added concurrent HTTP/3 connections to the h3 MITM listener.
  • Made the HTTP/3 proxy forward upstream over HTTP/3, for an end-to-end h3 path.
  • Added the HTTP/3 MITM interception listener.
  • Added HTTP/3 to the Repeater and engine send path, with an HTTP-version differential.
  • Added an HTTP/3 fetch tool over native QUIC, on all four surfaces.

DOM Invader over CDP

  • Made DOM Invader follow into new tabs and popups.
  • Added the DOM Invader in-page overlay, a shadow-root sink panel, on all four surfaces.
  • Exposed the live DOM Invader session across all four surfaces.
  • Added the live in-browser DOM Invader session itself, a headful browser launch with a CDP debug port, and attach-to-a-running-browser.

Attack surface, Shadow Repeater, and the workflow shell

  • Added StreamQL queries over WebSocket frames.
  • Added an attack-surface analyzer with a Target-view rollup, an API route and an MCP tool.
  • Deepened GraphQL coverage with alias, depth and suggestion probing.
  • Added the Shadow Repeater, AI-assisted variation testing.
  • Added the workflow shell with first-class JS nodes, gated behind aggressive mode.
  • Added a GUI event and activity log panel.
  • Added exotic Intruder payload generators (username, bit flipper, ECB shuffle) and a recursive-grep run mode.
  • Enforced scope on the async scan seed and on the scheduler.
  • Added multiple named scopes per project, with switching.
  • Added a suite-wide shared cookie jar.
  • Added GraphQL CSRF detection and introspection-filter bypass probing.
  • Added DOM clobbering gadget detection to the DOM probe.
  • Hardened the bug-bounty skill with a client-side DOM playbook and recurring engagements.

Clipboard, grids, and stoppable crawls

  • Added system clipboard support through the Nilorea clipboard backend, fixing paste into Chrome and adding select-to-copy and middle-click paste.
  • Made the Findings detail pane selectable and copyable.
  • Fixed right-click on a sorted list acting on the wrong row.
  • Documented the portability status and made string duplication portable.
  • Capped the headless katana crawl at a 180-second duration.
  • Added per-run cancel-group socket isolation and made the headless crawl stoppable.
  • Added a per-host scan rate governor across all surfaces.

Scope becomes per project

  • Added a visible Scope filter button on every URL list, and a named column in the scope editor.
  • Made packaging builds the only builds that bump the version.
  • Made the target scope per project, saved and restored per engagement.
  • Added an in and out of scope filter to every URL list through a scope query field, with live refresh.
  • Added a dedicated Scope editor popup with multi-row pattern lists.
  • Added Add-to-out-of-scope to the proxy, findings and site-map context menus.
  • Added interruptible connect, so a scan or crawl Stop aborts a hung host.

Reproducible Debian and Docker packaging

  • Pinned the Docker release base for the widest reach and targeted Debian trixie for the .deb and AppImage release.
  • Restored the Debian 11 build with OpenSSL 1.1.1 compatibility in the SAML keygen path.
  • Made the Docker release build bundle the browser and the codename-tag artifacts.
  • Added a reproducible Debian-stable .deb and AppImage build through Docker.

Scan options, extension bundles, and the marketplace catalog

  • Added a reverse-proxy and auth-header authentication-bypass check.
  • Added a crawl and audit path exclude list, so a logout or destructive path can be skipped.
  • Added custom per-scan request headers, for auth, forwarding and marker headers.
  • Populated the signed marketplace catalog and added the signing tool.
  • Shipped three new extension bundles: active probes, codec tools and API leaks.
  • Brought the scan CLI and the control API to parity on the raw knobs, scope, depth, pages, delay and threads.
  • Added a scan wall-clock time budget, and corrected the rate-governor documentation.
  • Wired robots.txt and sitemap.xml discovery seeding into the scan crawl.
  • Completed the scan family mask, making the injection and SSRF families selectable.

The Windows port: sockets, subprocesses, and paths

  • Added Windows platform support for the browser through system Chrome or Edge, disabling plugins while keeping extensions.
  • Fixed the Windows listener-stop hang with a timed accept instead of a shutdown to break out.
  • Added make installer-windows (NSIS) and DLL collection, and fixed the installer warning when the docs are absent.
  • Used the committed icon on Windows rather than regenerating it.
  • Made time, chmod, temp directories, lstat and mkstemps portable, and dropped the hardcoded /tmp.
  • Added a compat header for memmem, gmtime_r, localtime_r and getline.
  • Fixed the Winsock macro clash and the remaining Windows build stragglers.
  • Added a socket-compat layer and ported every raw-socket file onto it.
  • Added portable subprocess helpers and migrated PDF export, the external-file opener, plugin capture and the browser launch onto them.
  • Ported the DNS resolver client to the Win32 resolver.
  • Fixed an unused-function warning in the plugins view on Windows.

Toolbar categories, tooltips, and the parity rules

  • Fixed the web dashboard freezing on paste by masking the token with CSS instead of a password field.
  • Added round cascading menus and a round/square GUI toggle in Settings.
  • Made the toolbar single-row by default, and moved Help to Home, Project to Organize and Config last.
  • Added the collapsible category-group toolbar and its customizer, on a toolbar layout model of rows, categories and modules.
  • Made the Proxy request and response panes copyable.
  • Masked the API token on the web dashboard and exposed more routes there.
  • Brought the skill to MCP-tool parity and made it a mandatory fourth surface.
  • Swept the GUI for tooltips and input hints, and enforced the rule from then on.
  • Added command-palette parity, and the two GUI rules that keep every interface launchable and indexed.
  • Fixed the audit findings on launch controls, help gaps and tutorial staleness.
  • Merged the Add-ons hub into the Extensions manager.
  • Gave the Help topic tabs coverage of every feature, and made the in-app help list every toolbar button.

Security and stability fixes in the GUI and the control plane

  • Fixed a use-after-free of a live WebSocket capture when clearing history.
  • Stopped GUI edits racing the authorization-matrix and auto-replay workers.
  • Made the proxy passive tick and the findings-check reaps use a trylock, so a busy scan cannot freeze the GUI.
  • Fixed two GUI crashes: a null key in AI assist and a Content-Type parse in the Inspector.
  • Fixed a 5 to 10 second GUI freeze when starting the proxy or the browser, by throttling the passive audit.
  • Enforced the control-session scope on the synchronous scan and request hooks and on the scheduler.
  • Rejected path traversal in marketplace ids and extension manifest paths.
  • Fixed a heap overflow in the chunked decoder on a hostile chunk size.

The bundled browser, the CA, and the control dashboard

  • Made popups re-fit to their content on every open, fixing stale and scaled sizing.
  • Gave the control dashboard an operator identity and team attribution, and fixed its token field and findings rendering.
  • Added a Team Remove-member button, and widened the Help and Settings dialogs.
  • Added a Proxy view Clear-results button and moved its status onto its own line.
  • Laid the top toolbar out as one justified flow.
  • Stopped the certificate tool blocking the terminal while seeding the CA, bundled a vendored copy into the AppImage, and auto-installed the CA in the distributed browser.
  • Added a global toolbar launch for the bundled browser.
  • Computed the .deb runtime dependencies so a clean install works, and documented the packaging dependency model.
  • Shipped the bundled browser for one-click proxying.
  • Added a headless DOM security probe over CDP, on a new CDP client foundation.

Team collaboration, raw relay, hosted OAST, and protobuf

  • Added multi-operator team collaboration for a shared project.
  • Added a generic non-HTTP raw TCP and UDP interception relay.
  • Added turnkey hosted OAST through an interactsh client, for zero-setup DNS and HTTP out-of-band testing.
  • Added responsible active-deserialization confirmation using a benign out-of-band marker.
  • Added the browser-served control dashboard.
  • Added a protobuf and gRPC wire-format decoder to the Multitool, the control API and MCP.

Scan schedules and profile masks

  • Added recurring scan schedules: the core, a scheduler thread, the control API and MCP routes, and the GUI.
  • Added per-check-family and insertion-point selection to scan profiles.
  • Added an "Add to collection" right-click on the Proxy and Findings lists, and a host right-click menu on the Targets pane.
  • Relocated the scan-profile picker to the Target view and added the custom scan-options popup.

The workflow builder and agentic AI chat

  • Added the visual workflow builder: the core with its control API and MCP routes, then the GUI.
  • Added agentic AI chat, with in-process control dispatch, and its GUI panel.
  • Added an "Ask a question" custom task to AI assist.
  • Made the right-click menu dismiss on a click-away or ESC.
  • Added JSON, XML and JS prettifying for requests and responses.

The traffic query language and the login recorder

  • Added the login and macro recorder: the core, the control API and MCP routes, a Proxy "Record login" action, and hardened token detection.
  • Added the universal traffic-query dialect with control-API query routes, a filter box on the Proxy and Sitemap grids, and the same dialect on the Logger, Findings and Search grids.
  • Made the scan routes consume a captured session cookie.
  • Set the default window size, reserved the dashboard scrollbar width, and let ESC close the Extensions manager and panel popups.

The extension SDK and the signed marketplace

  • Added interactive extension message editors for decoding and encoding.
  • Added extension top-level tabs, the Add-ons hub, with scrollable selectable content.
  • Added extension session actions with login capture, and fs.params.
  • Added the offline signed extension marketplace, with browse, install and remove.
  • Added extension context actions and headless extension checks.
  • Added extension GUI panels on the owner-draw layer.
  • Shipped the extension SDK's first slice, packaged versioned bundles, with a curated set.

Upload probes, remediation, and the vulnerable-library check

  • Made the upload probe carry a session and the submit-trigger fields, so it stops reporting a false accept.
  • Added a file-upload context-menu action sharing one probe, and made the upload check confirm the served file.
  • Added file-upload restriction-bypass testing.
  • Added named scan-configuration profiles.
  • Added a per-issue remediation and reference library.
  • Added vulnerable-JS-library detection.

Packaging, tooltips, and dialog polish

  • Gave every interface a launch button, and made that a rule.
  • Made popup listboxes click-selectable, dropped the window scrollbar from dialogs and left-justified their headings, and added an Extensions toolbar button.
  • Made popups fixed-size with only the main window resizable, which the later GUI overhaul replaced with resizable, persisted popups.
  • Verified and automated the AppImage clean-environment bundle test.
  • Added broad tooltip coverage with a 1.3 second default delay, on new timed hover tooltips.
  • Bundled the HTML docs and tutorials in the AppImage and the .deb, with an in-app link, and gave the .deb the Internet category.
  • Added the Debian package build with a desktop menu entry.
  • Added persisted dialog geometry, a Blue Team theme, a reset button and wider Settings.

Modern vulnerability classes and the recon loop

  • Added the first fuller nuclei and BCheck import engines.
  • Added a recon asset view with a new-since-last-run diff.
  • Added HTTP/2-downgrade request smuggling, a CL.CL variant, and differential-response confirmation.
  • Added an on-demand "Mine JS" context action.
  • Added a prototype-pollution query-string vector and a passive DOM heuristic, alongside the server-side prototype-pollution gadget probe.
  • Added an SSRF DNS-rebind probe with a rebinding responder, and SSRF alternate schemes (gopher and dict out-of-band probes).
  • Seeded the crawl frontier from katana and httpx output, and added a headless JS-rendering crawl as a recon source.
  • Added the SAML assertion workshop.
  • Added YAML OpenAPI import.
  • Added subdomain-takeover detection by dangling-service fingerprint, then CNAME confirmation through a DNS resolver client.
  • Added stored and second-order XSS tracking with a write-then-read canary.
  • Added a mass-assignment and HTTP-parameter-pollution probe.
  • Added live API-spec auto-fetch, probing a target for a served OpenAPI or Swagger spec.
  • Added eight cybersecurity-inspired themes.
  • Deduplicated host-level findings per host and gave the misconfiguration checks concise evidence, so a report stops carrying whole responses.
  • Added a one-action recon chain with its API route and MCP tool.
  • Added web cache poisoning and cache deception probes.
  • Added object-ID enumeration for IDOR and BOLA, with a Test-for-IDOR action, and taught its oracle to read minified single-line JSON.
  • Added insecure-deserialization leads.
  • Fixed a project switch clobbering the incoming project's data, and a GUI freeze during the scan crawl.
  • Added help topic buttons, and moved the keyboard-shortcut editor into Settings.
  • Added control-API report evidence and workspace clearing for hosts and findings.

Out-of-band probes, request smuggling, and the JS miner

  • Added the active XXE probe, in-band file read and out-of-band.
  • Added GUI parity for the standalone tools: a Request-smuggling action and a Seed-recon button.
  • Added active CORS and CSRF probes.
  • Killed two request-smuggling false positives the lab run caught.
  • Added the HTTP request-smuggling desync timing probe.
  • Added the in-band cloud-metadata SSRF probe.
  • Added JavaScript endpoint and secret mining in the crawler.
  • Added the recon-to-inventory bridge, so recon output seeds the inventory and the scope.
  • Cleared the 42 legacy doxygen warnings, so the documentation regenerates clean.

The nuclei-templates integration and the DVWA lab

  • Hardened the lab runner with automatic certificates and a per-scan database reset.
  • Added the native offline nuclei-template importer.
  • Shipped curated discovery and parameter wordlists derived from nuclei-templates.
  • Added SSTI, in-band command-injection and CRLF active checks.
  • Harvested 32 sensitive-file probes into the scanner.
  • Hardened the nuclei plugin manifest and added tag-scoped presets.
  • Made the crawler record directory-slash redirects under the canonical URL.
  • Added absolute and wrapper LFI payloads with base64 decode matching.
  • Made the scanner skip logout URLs, so an authenticated scan stays logged in.
  • Made the scope port-aware and reported scanner audit coverage.

The control API, the MCP bridge, and the bug-bounty skill

  • Wrote the bug-bounty automation guide, extracted the fissure_bug_bounty skill from the tutorials, and harvested the operating lessons of a real run into it.
  • Exposed the whole toolkit over the control API and MCP, one tranche at a time: generic dispatch and the analysis workshops, the Intruder, discovery and scope, live proxy control, the import workshops, group send, the WebSocket repeater and scriptable checks, authorization testing, the plugin host, the out-of-band collector, the workspace data stores, reports including PwnDoc and PDF, and the BCheck compiler.
  • Documented the venv-based MCP bridge configuration.
  • Added authenticated scans over the control API and MCP, and documented the lab over both HTTP and MCP.
  • Added the lab integration itself: an audit, a Docker lab and an authenticated scan.
  • Added the cross-tool traffic log.
  • Added a passive OAuth and OIDC authorization-request check.
  • Added per-flow comments and highlight colors on proxy flows.
  • Ran the native passive checks live on captured proxy flows.
  • Added Intruder payload-reflection detection.
  • Wrote the Fissure tutorial and the gap backlog behind it.
  • Added the MCP bridge over stdio.
  • Hardened the control server with caps, a read timeout and an audit log.
  • Added the async scan job API, the send-one-request route and Bearer authentication.
  • Added the optional local control API, GUI-toggled and persisted.

Out-of-band channels, IAST agents, and PDF export

  • Added reference IAST agents for PHP, Ruby and Python 3, and deepened their sinks with code-eval, deserialization and SQL-query hooks.
  • Added DNS and SMTP out-of-band interaction channels, with structured detail for their hits, and injected a DNS canary in the active out-of-band check.
  • Added PDF report export through a user-configured external generator, on a worker thread with a busy indicator.
  • Added program-scope import.
  • Added an interoperable XML report export.
  • Added out-of-band canary injection in the proxy.

Token workshops, session rules, and the highlighter

  • Added the extension-authoring guide.
  • Added a scriptable Intruder payload generator.
  • Added the BCheck importer, compiling a check into a QuickJS check.
  • Added multi-identity proxy tagging.
  • Added the authorization-matrix engine and its GUI, with an identities editor, a verdict grid and a context action.
  • Added the auto-replay rule engine and its GUI, with a diff log and a context action.
  • Added a multi-provider AI assistant, fixing the Gemini path and adding OpenAI, Mistral, DeepSeek and Ollama, and stopped AI answers truncating in a roomier scrollable pane.
  • Added the session-handling rule engine, applied it in the request engine, and added its editor and scan wiring.
  • Added docs/FEATURES.md as the canonical inventory, with a rule to keep it current.
  • Added the signed-token workshop, JWT build, verify, re-sign and forge, with its GUI and context menu.
  • Added a framework signed-cookie engine (Flask, Django, Rails, generic), Express cookie-session support, and Rails encrypted cookies.
  • Added the highlighter and extractor rule store and matcher, ran it on captured flows to show highlights and extracted values, seeded and persisted the ruleset, and added its editor popup.
  • Added the inline transform-tag engine, evaluated it in the Repeater send path, the Intruder and the Multitool, made custom JavaScript tags work and persist, and added the tag manager popup.
  • Made Send to Repeater open a tab per selected finding.
  • Made findings load at startup, with Clear all and Delete selected on a findings store that supports both.
  • Persisted the scan inventory, cleared the proxy and findings views on a project switch, and reloaded Intruder attack configs with the project.
  • Fit the Target Active-checks and Aggressive labels.

Scan parallelism, GraphQL, and the first control server

  • Probed and recorded external-tool versions in the report.
  • Added a reference Node.js IAST agent for the out-of-band beacon protocol.
  • Fuzzed GET-form and urlencoded-POST-form fields, and query parameters and id path segments on body-bearing methods.
  • Audited active checks off the scan lock, for parallelism.
  • Framed HTTP/1.1 responses by Content-Length or chunked encoding.
  • Fixed a review sweep of correctness, data-loss and leak bugs, proxy shutdown use-after-free, a scan and discovery race, plugin subprocess and JS runtime safety, and GUI correctness bugs, and adopted the user-feedback rule that persistent messages and progress are mandatory.
  • Laid the Target launcher out on four rows and closed its seed-row gap when no scan is running.
  • Reordered the primary toolbar views, persisted, and added layout customization to hide a view.
  • Added datagrid column customization with persistence.
  • Added the native GraphQL active check (introspection, argument fuzzing, batching), a scriptable introspection check, and GraphQL OSS-tool plugins.
  • Added the out-of-band canary check for blind SSRF, XXE and RCE, wired it into scans, and defined the IAST beacon protocol with structured beacon detail.
  • Added the AI assistant for explanation, triage and PoC drafting.
  • Added the headless control server and its JSON control API.
  • Added session-handling macros that capture tokens and substitute them into requests.
  • Added Multitool smart-decode, recursive and auto-detecting.
  • Added the clickjacking PoC generator.
  • Added scan pause and resume.
  • Added cross-role site-map comparison for broken access control.
  • Added the DOM-based XSS heuristic, a passive source-to-sink scan.
  • Added per-host routing with DNS rewrites and per-host upstreams, and transparent proxying.

Projects, WebSocket, HTTP/2, and user scripting

  • Added saved Intruder attack configurations, core and GUI.
  • Added the HTTP/2 single-packet attack, core and Repeater group-send.
  • Added HTTP/2 send-side flow control for large request bodies, and a Settings toggle.
  • Added the HTTP/2 engine path with ALPN, request reframing and h2c, on a single-exchange client core.
  • Added WebSocket frame capture with a live history view, frame replay, and frame interception with hold, forward, drop and edit.
  • Added user scripting passive hooks and context-menu active scripts, and an Intruder payload-preprocessor script step.
  • Added named projects with per-project data, a switcher, per-project findings and collections, backup and hot switching.
  • Added in-app convert-transform scripting in the Multitool.
  • Added built-in content discovery folding into the site map.
  • Added the Target host and path tree view over the inventory.
  • Reused the response views in the Proxy intercept editor.
  • Added per-attack rate, delay and retries for the Intruder.
  • Added the Repeater rendered-HTML response view.
  • Added environment variables across the tools.

The Inspector, API-schema import, and access-control replay

  • Added authenticated-scan login automation through a recorded login.
  • Added the access-control and IDOR replay check.
  • Added API-schema import for OpenAPI, Swagger and Postman.
  • Added Target multi-select with batch context actions and scan-selected-only.
  • Added Repeater request grouping with synchronized send, clearer group send, and deleting a send result.
  • Added header and cookie insertion points for the scanner.
  • Added the structured request editor, the Inspector, and wired it into the Proxy intercept editor.

The Repeater, Intruder, and Organizer take shape

  • Added closing and deleting a plugin output tab, and fixed nikto's launch by installing its report-module dependencies.
  • Added the command palette.
  • Added the CSRF PoC generator.
  • Added the Sequencer for token randomness analysis.
  • Added Pretty, Raw and Hex response views in the Repeater.
  • Added global Search over captured traffic and findings.
  • Applied match-and-replace rules to the scan engine, and added regex matching and replacement to the rules and the Intruder pipeline.
  • Added the Intruder multi-step payload-processing pipeline, payload processing with prefix, suffix and encoding, per-position payload sets, grep-match and grep-extract columns, and wordlist, dates, charset, case-modification, number-range and null generators.
  • Added cross-tool right-click context menus.
  • Added the Comparer popup with line, word and byte diff granularity.
  • Added the in-app match-and-replace rule editor, persisted the rules, and applied them on both proxy legs.
  • Added per-request send history in the Repeater, multiple request tabs with named collections, and a Stash action.
  • Made the toolbar responsive, wrapping to rows at natural width, with a minimum window size and window scrollbars when the window is too small.
  • Added the out-of-band callback listener with findings correlation.
  • Added a filter and search bar over the Proxy flow list, and multi-select group actions on the Findings view.
  • Kept the GUI responsive during a scan and fixed the scan-progress bar.
  • Fixed dependency installation for the pip and git-clone tools.
  • Added the Organizer save-for-later queue: the model and persistence, loading it in the app, the popup for browsing, annotating and reusing, Send-to-Organizer from the Proxy and Findings views, and an editable per-item collection with a grouped list.
  • Made in-progress jobs animate and disabled re-triggering their controls, and swept the remaining handlers for the same feedback.
  • Made refusals and errors surface in a popup rather than a transient label, and adopted the mandatory feedback rules behind that.
  • Purged non-ASCII punctuation from the source and the documentation prose.
  • Added finding triage state, notes and tags with persistence, a filter predicate, triage editing and a filter bar in the Findings view, and a triage-aware report engine with an exclusion option exposed in the CLI and the GUI.
  • Added JSON request-body field fuzzing, audited JSON body endpoints during the scan, and made the proxy record the request Content-Type and body that the endpoint model now carries.
  • Added path-segment insertion points and audited id-like path segments during the scan.
  • Added boolean-based and time-based blind SQL-injection and command-injection checks, extended to multipart form fields.

The plugin catalog, the Multitool, the Intruder, and the Dashboard

  • Added collapsible Settings sections, and grouped Settings under section headers.
  • Made scan activity show immediately when an active scan starts, on a live activity indicator with a Target-view progress bar.
  • Shipped TLS, DAST, secret and dependency scanner manifests, grew the plugin catalog, and implemented the release and script install methods.
  • Fixed the ffuf and dalfox manifests against live tools, ran git-clone script tools through an interpreter prefix, and installed waybackurls without Go.
  • Added plugin output to the report as an informational finding.
  • Ran plugins concurrently with a running-jobs panel and cancel, in tabbed output that pages instead of evicting.
  • Added the Dashboard scan-throughput rate view, and the recon Dashboard with a live session overview and severity chart.
  • Added wordlist input, path-resolved plugin runs and content-discovery tools.
  • Moved scan scope and the aggressive toggle into the Target view and reordered the toolbar.
  • Set the application window icon and wired the Windows executable icon.
  • Added dimmed placeholder hints on every editable input.
  • Added a persistent session cookie jar to the Repeater, on a shared jar the engine sends and absorbs.
  • Added multipart-aware active checks, multipart inspect and repack in the Repeater, and multipart form auditing in the scan.
  • Added response diffing with pin and diff in the Proxy view.
  • Added the parameter miner for hidden-parameter discovery.
  • Added the low-hanging-fruit quick-scan profile.
  • Added the Intruder view and its fuzzing engine, and the Multitool view with its encoding, JWT and hash logic.
  • Adopted the upstream HTTP status classifiers and body decompression in the engine, crawler, checks and proxy.

Scope, the safe/aggressive toggle, and the PwnDoc connector

  • Added the target-scope allow and deny host-pattern model, enforced it in the proxy by blind-tunnelling out-of-scope traffic, persisted it, built it from free text, added a Settings scope editor, and made the proxy apply it on Start.
  • Made the scan refuse an out-of-scope seed host, and let the scan and crawler span a multi-host target scope.
  • Added the safe and aggressive active-check toggle.
  • Added PwnDoc custom-field discovery and an optional custom-field copy of the idempotency key.
  • Applied a theme switch live to every existing widget.
  • Chained the intercepting proxy's upstream leg through a proxy, and routed scan and Repeater traffic through an upstream proxy.
  • Added a TLS client certificate and an extra plugin directory to Settings, and made the Settings body scrollable.
  • Added a configurable proxy listening port, flow-history limit, and CA export from Settings.
  • Added scan policy in Settings, with a request rate limit and a thread cap.
  • Applied the interface-size setting live.
  • Finished the Proxy detail pane with a hint and To Repeater.
  • Made the Targets nav pane a live scanned-host list.
  • Ran the scan on a background worker thread, made the Scan button toggle to Stop scan, and rebuilt the Target grid only on endpoint changes.
  • Fixed a dropped Host header on a forwarded intercepted request.
  • Added the PwnDoc connector: cookie-JWT authentication with a test connection, finding mapping and idempotent push, Docx report generation and download, its Settings section and GUI actions, a password secret-file credential tier, a token tier, and a worker thread for push and report.
  • Added settings persistence and the Settings popup.
  • Added user-extendable redaction patterns, and summarized binary capture bodies in report evidence.
  • Persisted the window and popup layout across sessions.
  • Added the in-app help popup, the keyboard-shortcut editor, and a remappable shortcut model with view-switch hotkeys.

Evidence captures and the report

  • Added active scriptable checks through fs.send(), and made active checks record the attack exchange behind each finding.
  • Added the capture model and its base64-NDJSON store, linked findings to captures, archived baseline exchanges, persisted captures beside the session, resolved evidence from captures at render time, and added GUI capture resolution with full-request Send to Repeater.
  • Added Send to Repeater from the Findings view.
  • Added report evidence redaction and truncation, and source and host filters.
  • Added findings-session persistence and reporting from a session.
  • Added the headless fissure scan CLI with report output.
  • Added the Report GUI view with preview and export.
  • Added the HTML and SARIF renderers, on a report model with Markdown, JSON and CSV.

Foundations

  • Added the plugin host: the manifest model and loader, argument-template expansion with a detached subprocess runner, output parsing into findings, run-and-parse orchestration, dependency status with an install-command builder, and the Plugins GUI view.
  • Added the findings core: the FISSURE_FINDING model with a deduplicating store, native passive checks for security headers, cookies and banners, active checks for reflected XSS, error-based SQLi and open redirect, scan orchestration across crawl, audit and collection, the Findings view end to end, the QuickJS scriptable-check engine with its passive API and its place in the scan pipeline, passive secret-exposure and CORS checks, the active path-traversal and LFI check, and sensitive-file and backup probes.
  • Added the first-run authorization banner, the shared confirm dialog, and a confirmation before an active scan that names the target.
  • Added the crawler: an endpoint type with a deduplicating inventory, a BFS crawler core feeding it, passive robots.txt and sitemap.xml seeding, seeding from proxy capture history, and the Target GUI view.
  • Added the intercepting proxy: the MITM CA lifecycle with a per-host leaf cache, the proxy core, HTTPS CONNECT interception, the Proxy GUI view, a keep-alive relay with proper message framing, WebSocket and Upgrade pass-through, an upstream-TLS trust note per flow, NDJSON flow history that reloads on attach, request interception with edit-and-forward, and the interception controls.
  • Added the transport engine: the data model for config, request and response, and the native HTTP(S) engine.
  • Added the Repeater GUI and the view switcher.
  • Added the build system, the core modules, the GUI skeleton, and the AppImage packaging target.
  • Recorded the design package: the security-tool catalog, the architecture, the GUI design, the network and MITM proxy design, the website scanner, reporting, the reference audits, and the OSS dependency manifest.