Fissuredocumentation v5.3.1
On this page

Extending Fissure

Fissure is extensible without recompiling. There are three extension surfaces, all loaded from disk at startup and all optional:

  1. Scriptable checks - JavaScript (QuickJS) run against captured or scanned responses, with a small fs.* API for reading the exchange, sending follow-up requests, and reporting findings. This is the scripted analogue of a native extension API.
  2. Transform and generator scripts - short JavaScript snippets that turn one string into another (payload processing, Multitool convert) or generate a list of payloads (the Intruder Script payload source).
  3. OSS-tool plugins - JSON manifests that wrap an external command-line security tool, expand an argument template per run, parse its output, and map the parsed records onto Fissure findings.

Three more paths reuse surface 1 by compiling a foreign check format to an equivalent scripted check: BCheck import (a .bcheck file), nuclei-template import (a .yaml template), and Jaeles-signature import (a .yaml signature). See sections 4, 4a, 4b.

These surfaces can also be packaged into a versioned, self-describing bundle (the extension SDK) that Fissure lists, validates, and enables or disables as a unit, the analogue of an extension API plus an extension marketplace. See section 5 below and docs/14_EXTENSION_SDK.md.

Everything here is offline and file-based. No network, no account, no build step.

Ethics reminder: scripted checks and plugins that send requests are active. They run only when active scanning is permitted (see fs.active below) and only against authorized, in-scope targets. Do not add detection-evasion behaviour.


1. Scriptable checks (the fs.* API)

Where they live and when they run

Drop a *.js file under resources/checks/. Fissure loads every script in that directory at startup into three places:

  • the Proxy passive node - each newly captured response is run through the scripts (a passive check; fs.send() is disabled unless the scan context permits it);
  • the Findings view "run user scripts" action - runs the scripts on demand against the stored exchanges;
  • the scanner - the scripts run alongside the built-in active checks.

The same directory also holds .bcheck files (see section 4) and a README.md (ignored).

The fs object

A check is a plain script; there is no required entry function. It executes with a global fs object bound to the current exchange:

Read-only getters (the request that was captured or scanned, and its response):

  • fs.url - the request URL (string).
  • fs.method - the request method (string).
  • fs.status - the response status code (number).
  • fs.body - the response body (string).
  • fs.time - elapsed time in milliseconds (number).
  • fs.active - 1 when request-mutating fs.send() is permitted (an active scan), 0 in a passive scan. Guard active probes on this.
  • fs.params - an object of caller-supplied inputs for this run (an empty {} unless the caller injected any). Read credentials, a marker, or a wordlist entry from it instead of hardcoding them. A session_actions login flow reads its username/password and the form field names from fs.params, so one bundle logs into any form. The control API passes params on POST /api/session-action; the GUI passes a params JSON field; the MCP session_action tool takes a params dict.

Methods:

  • fs.header(name) - one response header value, or undefined.
  • fs.headers() - all response headers as an object.
  • fs.json() - the response body parsed as JSON, or null if it is not JSON.
  • fs.log(msg) - append one line to the application log (also console.log, console.warn, console.error).
  • fs.send(req) - send a follow-up request through the transport and return {status, body, time, headers}. req is {url, method, headers, body}; url defaults to fs.url, method defaults to GET, headers is an object, body is a string. Only available when fs.active is true; there is a per-run call limit. The most recent fs.send() exchange is remembered so the next fs.report() can attach it as evidence.
  • fs.sendraw(raw) - send a hand-built raw HTTP request string byte-for-byte to the target's host/port and return the same parsed {status, body, time, headers}, or null. Unlike fs.send it does not normalize framing, so it carries exact bytes (a custom method, a deliberately malformed header, an explicit Content-Length). Only when fs.active; shares the per-run call limit. Backs imported nuclei raw: templates.
  • fs.xpath(xml, expr) - evaluate an XPath expression over an HTML/XML string and return an array of matched node/attribute string values (empty when nothing matches; empty too when the build has no XPath engine). Backs imported nuclei xpath matchers/extractors.
  • fs.bodyhex() - the raw response body as byte-exact lowercase hex, including bytes after an embedded NUL that the fs.body string would drop. Backs nuclei binary matchers (a byte-aligned hex search).
  • fs.headers() returns the response headers as an object. A name that appears more than once, which Set-Cookie almost always does, has its values joined by a newline rather than reduced to the last one: a response setting a session cookie and then a preference cookie otherwise shows a check only the preference one. The same holds for the object fs.send() returns.
  • fs.hash(alg, s) - the hex digest of s under alg (md5, sha1, sha256, sha384, sha512), for recognizing a known artefact by its fingerprint. "" for an unknown algorithm.
  • fs.b64enc(s) / fs.b64dec(s) - base64 encode/decode a string.
  • fs.b64body() - the RAW response body, base64-encoded. fs.body is a UTF-8 string, so it cannot carry a binary body faithfully; this encodes the bytes as received, which is what hashing a binary asset needs (an imported nuclei favicon template computing mmh3(base64_py(body)) is exactly that case).
  • fs.oast([channel]) - mint an out-of-band (OAST) canary and return an object {token, url, host}, or null when no OAST listener is configured or the run is not active. channel is optional ("http", "dns", "smtp"); a DNS or LDAP payload uses the bare host, an HTTP sink the url. Inject it where a blind sink might fetch it. fs.oast_seen(token) returns true once that canary has been hit, confirming a blind SSRF/RCE/XXE out of band. Together they let a scripted check prove a blind bug the direct response never reveals (they back imported nuclei interactsh matchers).
  • fs.oast_wait(token, channel, timeout_ms) - wait up to timeout_ms for the canary token to be hit on channel ("http"/"dns"/"smtp", or omitted for any), returning true as soon as it is. A callback is not synchronous with the request that caused it, so polling once immediately would report a real finding as clean; and a negative assertion (no callback for a deliberately broken variant) is only evidence if it waited at least as long as the positive one did.
  • fs.setvar(name, value) - publish a named value the host reads back after the run (a session token, a user id, an account number a later request needs). The host returns them as a JSON object, the same shape a login config's extracts produce, so a session-handling rule's {{name}} substitution resolves either way. A session_actions token login uses this.
  • fs.request() - the OBSERVED request as {method, target, headers, header_block, body}, or null when there is none. In a proxy passive run this is the request the proxy saw (its real authorization header, its real multipart boundary); in an active scan there is no observed request, so it returns null and a check built on it does nothing. header_block is the raw Name: value lines, for a regex over the whole block.
  • fs.inject(payload) - an array of absolute target URLs for ONE payload, with that payload placed into each of the URL's own query parameters in turn (the original values kept everywhere else). A URL with no parameters falls back to appending one. Use it to test the target's real insertion points rather than a parameter of the check's own invention; imported BChecks use it.
  • fs.store.get(key) / fs.store.set(key, value) / fs.store.remove(key) / fs.store.keys() - per-extension key/value state that persists across runs and restarts, stored per project. get returns a string or null; set and remove return a boolean (a refused write, such as a key-count or value-size cap breach, returns false rather than being dropped silently); keys returns an array of strings. With no store installed (a bare unit test) they answer null/false/[] instead of throwing.
  • fs.report(finding) - record a finding. finding is an object; category and title are required. Recognized fields: severity (info/low/medium/ high/critical), confidence (tentative/firm/certain), category, cwe (e.g. "CWE-79"), owasp (e.g. "A03:2021-Injection"), title, description, evidence, remediation.

Findings are de-duplicated by host|category|title|location, so a scripted check and a native check that describe the same issue do not double-report.

Example: an active reflected-input probe

// resources/checks/active-reflection.js
if (fs.active) {
  var marker = "fzz" + (fs.status || 0) + "rfl";
  var sep = fs.url.indexOf("?") < 0 ? "?" : "&";
  var r = fs.send({ url: fs.url + sep + "fzprobe=" + marker });
  if (r && r.status === 200 && (r.body || "").indexOf(marker) >= 0) {
    fs.report({
      severity: "medium",
      category: "Cross-Site Scripting",
      cwe: "CWE-79",
      owasp: "A03:2021-Injection",
      title: "Reflected probe marker in response",
      description: "A unique marker supplied in a query parameter was reflected " +
                   "back in the response body unencoded.",
      evidence: marker + " reflected in the response body",
      confidence: "firm",
      remediation: "Context-encode all user input on output and apply a CSP."
    });
  }
}

A passive-only check simply omits fs.send() and reads fs.body / fs.headers() directly. See the other files in resources/checks/ for more patterns (directory-listing.js, error-disclosure.js, graphql-introspection.js, oauth-flow.js).


2. Transform and generator scripts

These are shorter than a check: they receive a string and produce a string (or, for the Intruder Script payload source, a newline-separated list of payloads). They are used by:

  • the Multitool "convert" transform step,
  • the Intruder payload-processing pipeline "Script" step (one transform per payload), and
  • the Intruder "Script" payload source (a generator: its return value is split on newlines into one payload per line).

The contract (implemented by fissure_js_transform):

  • The input is exposed as the global input (a string).
  • The script may either return a value directly (an expression that uses input) or define a function transform(input) that returns the value. If both are present, transform(input) wins.
  • The returned value is coerced to a string. Returning undefined/null yields an empty string.
  • Scripts run under a time budget; long-running scripts are aborted.

The fs.* response API and fs.send()/fs.report() are not meaningful in a transform - a transform has no exchange or scan context. Use console.log for debugging.

Transform example (per-payload processing step):

// uppercase and URL-encode each payload
transform(encodeURIComponent(input.toUpperCase()))

Generator example (Intruder "Script" payload source, produces user0..user99):

Array.from({length: 100}, (_, i) => "user" + i).join("\n")

3. OSS-tool plugins (JSON manifests)

A plugin wraps an external tool. Drop a manifest under plugins/ (id foo -> plugins/foo.json). The tool itself is optional: the plugin is present if the tool is installed and gracefully skipped if not. Install methods live in resources/dependencies.json (see below).

Manifest schema

{
  "id": "dalfox",
  "name": "dalfox XSS scanner",
  "category": "xss",
  "binary": "dalfox",
  "interpreter": "python3",
  "version_args": ["version"],
  "dependency": "dalfox",
  "args": ["url", "-u", "{{target_url}}", "--format", "json", "--silence"],
  "output": { "format": "json", "source": "stdout", "records": "findings" },
  "map": {
    "title": "message_str",
    "severity": "severity",
    "evidence": "evidence",
    "url": "data",
    "cwe": "cwe"
  },
  "default_severity": "medium",
  "confidence": "firm"
}

Fields:

  • id - stable identifier; becomes the finding source_tool. Must match the filename.
  • name - human-readable label shown in the Plugins view.
  • category - a grouping tag (e.g. xss, injection, recon).
  • binary - the executable to run (looked up on PATH).
  • interpreter - optional; runs binary as an argument to this interpreter, e.g. "python3" for a git_clone'd sqlmap.py. Omit for a native binary.
  • dependency - optional key into resources/dependencies.json for auto-install.
  • version_args - arguments that print the tool version (used to detect presence).
  • args - the argument template, one token per array element. Tokens are expanded per run (see placeholders below).
  • output.format - how to parse the tool output: lines (one finding per line), regex (a per-line regex with capture groups; see output.regex), json (a JSON document; output.records is a dotted path to the array of records), jsonl (one JSON object per line, the shape most of the ProjectDiscovery tools emit; no output.records needed), or text (a single blob). A records path may contain a * segment to fan out across a NESTED array: "records": "Results.*.Vulnerabilities" descends into each element of Results and adds every element of that element's Vulnerabilities, which is how trivy yields one finding per vulnerability rather than one per scanned target. Prefer a structured format over text whenever the tool can produce one: text collapses the whole run into a single finding. A format name can also select a DEDICATED parser written in code, which is what a tool needs when it does not report a list of findings at all. sslyze is the one that ships: its JSON is a tree of check results per scanned server, where being a finding is a judgement about the values (a protocol version that still accepts cipher suites, a path validation that failed, a suite whose name carries RC4) rather than a field to copy, and no field map can express that. Such a manifest carries no map. Add a dedicated parser only when a field map genuinely cannot reach the finding: the generic formats stay the default.
  • output.source - "stdout" or "{{out_file}}" (a temp file the tool writes).
  • stdin - optional. A template (placeholders expanded per run) written to the tool's standard input, then closed. Use it for a stdin-driven tool that reads its target from stdin rather than a flag (for example dnsx, {"stdin": "{{target_host}}"}). POSIX only.
  • output.records - for json, the dotted path to the record array.
  • map - maps a finding field to a source field. For json and jsonl, the value is a source key and MAY be a dotted path into nested objects (info.severity, as plugins/nuclei.json uses); for regex, the value is a capture-group reference. Recognized finding fields: title, severity, confidence, category, cwe, owasp, evidence, url, description, remediation. An unmapped field falls back to the manifest default.
  • default_severity / confidence - fallbacks when the tool does not supply them.

Argument-template placeholders

Expanded in args (and in dependencies.json install steps) per run:

  • {{target_url}} - the full target URL.
  • {{target_host}} - the target host only.
  • {{out_file}} - a temporary output file path (pair with output.source: "{{out_file}}").
  • {{wordlist}} - the configured wordlist path.
  • {{threads}} - the configured concurrency.
  • {{scope_file}} - a temporary file listing the in-scope hosts.
  • {{extra}} - free-form extra arguments the user supplies for this run.

There is no {{token}} placeholder in a plugin manifest. The docs used to list one for an out-of-band canary, but the runner never expanded it, so a manifest using it passed the literal five characters to the tool. Nothing shipped needs it (an out-of-band tool takes its collector address through {{extra}}), and wiring the plugin runner to the OAST subsystem to mint one per run is a real dependency for no current caller. The seam if that changes is FISSURE_PLUGIN_VARS plus the token table in expand_tokens (src/fissure_plugin_run.c). Note that {{token}} DOES exist, and does work, in a LOGIN config's replay body (resources/login/dvwa.json), where it means the captured CSRF token; that is a different template with a different expander.

Dependencies

resources/dependencies.json lists how to install each tool. Supported method values: github_release, go_install, pip, gem, apt, git_clone, script. The dependency manager offers a one-click install for a missing tool referenced by a plugin's dependency key.

pip and gem install without root: pip tries pipx, then pip install --user (retried with --break-system-packages for a PEP 668 externally-managed Python), then a private venv under <install_root>/venv/<tool> whose script is linked into <install_root>/bin; gem uses --user-install and links the executable the same way, and takes an optional build_deps package list, installed as root only after a failed native build before the install is retried once. A pip entry may add "url" (a git+https spec) to install from a repository instead of the PyPI name, which is what a tool whose PyPI name is a placeholder needs. An apt entry (and the optional apt_deps list) needs root: the built command asks for the password through an askpass helper or pkexec, and when neither can prompt it prints the command to run in a terminal rather than failing with sudo's "a terminal is required to read the password".


4. BCheck import

Fissure understands the .bcheck DSL. Drop a .bcheck file under resources/checks/ alongside your JavaScript checks; Fissure parses its metadata / given / send / if / report blocks and compiles it to an equivalent scripted check (surface 1). This lets you reuse community BCheck rules without rewriting them. The compiler handles response conditions combined by and / or, the contains / matches / is / starts with / ends with operators (with does not and is not negation) on the body, headers, or status, and a for each loop over an inline payload list (each payload becomes an iteration of the probe). Constructs outside that shape (a second send request, a for each over a defined variable, a condition referencing a variable the compiler cannot resolve) are recorded and skipped rather than failing the import; the skipped list is logged on load and returned in the skipped field of POST /api/bcheck / the bcheck MCP tool. Port a BCheck that leans on those constructs to a fs.* check instead.

4a. Nuclei template import

Fissure also imports nuclei templates. Drop a .yaml (or .yml) template under resources/checks/; Fissure parses its http block(s), one or more requests, each with a method, one or more {{BaseURL}} paths, and matchers, and compiles it to an equivalent scripted check that runs once per host. A multi-request template emits one probe block per request (the requests run independently, not chained). See resources/checks/example-nuclei.yaml. Supported now:

  • matchers: word / regex / status / size; dsl expressions, compiled by a parser for nuclei's expression language rather than matched against a fixed set of shapes: grouping parentheses, the full operator set, and the helper-function library (contains / contains_all / contains_any / icontains / startswith / endswith / regex / len / to_lower / to_upper / trim* / replace / split / join / concat / substr / compare_versions / md5 / sha1 / sha256 / base64 / base64_decode / base64_py / hex_encode / hex_decode / url_encode / url_decode / mmh3 / word_count / line_count and the rest), over the response variables status_code, body, header / all_headers, all, content_length, content_type, duration (seconds), host, any response header under its snake_case name (set_cookie, location, server), and the suffixed forms naming an earlier request's response (body_2, status_code_1, duration_2); a matcher's part: reads the same vocabulary, so besides body, header, all / response and raw (the whole response, status line included) it accepts a single response header by name (part: location, part: set_cookie) and an earlier request's response (part: body_2); xpath matchers (an XPath selecting a node in the HTML/XML body, via the built-in fs.xpath engine); binary matchers (a hex byte sequence in the raw response body, byte-aligned, via fs.bodyhex); and interactsh out-of-band matchers (part: interactsh_protocol + the {{interactsh-url}} placeholder, confirmed by an OAST canary hit via fs.oast / fs.oast_seen), all combined by matchers-condition;
  • extractors: regex / kval (response-header) / json (dotted path) / xpath / dsl (the value of an expression) (each captured value is added to the finding evidence; an internal: true extractor becomes a chaining variable that this request's own dsl matchers read by bare name and that a later request references as {{name}});
  • a variables: block, whose named values any path, matcher value or dsl expression can reference as {{name}} or by bare name;
  • raw: templates: the verbatim request block (request line, headers, body) is reconstructed and sent byte-for-byte via fs.sendraw, with {{Hostname}} / {{Host}} / {{Port}} resolved from the target origin;
  • payloads, in both shapes. With a fuzzing: block the template is a DAST one and each rule is compiled: part (query, path, header, cookie), type (replace / prefix / postfix), mode (single / multiple) and keys all take effect, and the payload goes into the LIVE request being audited. Without a fuzzing: block the sets fill the {{name}} placeholders in the template's own path, raw request or body, combined the way attack: says (batteringram, pitchfork, clusterbomb) - which is the shape a default-credential template has, and compiling it as a query injection instead would test something the template never asked for. Every payload run carries a send budget so a combinatorial attack stays a check. A set may name a wordlist instead of listing its values; those resolve relative to the directory the templates came from, and never outside it.

Workflows

A nuclei WORKFLOW document (a workflows: block instead of http:) carries no requests of its own: it names a detection template and the tags that become relevant once it matches. Fissure imports and runs all of those templates anyway, so what a workflow buys is not coverage but restraint. Drop one in the checks directory and it becomes a GATE: every check carrying a gated tag is held back until that detector has reported for a host, which is what keeps a scan from sending hundreds of WordPress requests at something that does not run WordPress. Detection is per host, so one host's result never releases another's. Two safeguards: a gate whose detector template is not loaded is ignored rather than honoured (a missing file must not silently become missing coverage), and a scan that held checks back reports it as a "Scan coverage" finding, so a quiet run reads as "we did not look there" rather than "nothing was found". Remove the workflow document to run everything unconditionally again.

A template with extractors and no matchers compiles too, but only when it is a SINGLE-request template: for a harvester (emails, tokens, invite links) capturing something IS the finding, while a request inside a chain extracts to feed the steps after it and must not report on its own.

A matcher marked internal: true is a CONDITION for the rest of the chain, not a finding. A request whose matchers are all internal is a step: it records whether it held and reports nothing, and every reporting request additionally requires that record. Without this, a chain template's last step, often no more than status_code == 200, reports against any live server. A request that gets no response leaves the chain unproven for the same reason.

When a matcher cannot be compiled, what happens to the rest of the request depends on how they combine. In an AND set the survivors would fire on LESS than the template asked for (pair "the response carries this SQL error" with "and not this false-positive marker", lose the first, and the request reports on every host), so the request is refused and the reason recorded. In an OR set the condition only got narrower, which is the safe direction, so what compiled is kept. A self-contained template, one whose paths name a fixed external host of its own instead of the target, is refused on purpose rather than compiled, since running it would send traffic somewhere the operator never targeted.

Features still outside the shape (the target's resolved IP and the text of an out-of-band interaction) are recorded and skipped; workflows are not skipped but parsed into scan gates, as described above, so you can drop a folder of exposure/misconfiguration templates in and the supported ones light up offline; a template with no compilable request is refused. The skipped features are logged on load and returned in the skipped field. Both importers are also exposed over the control API (POST /api/bcheck, POST /api/nuclei) and the MCP bridge (bcheck, nuclei_import). For the full template library and active fuzzing, drive the bundled nuclei plugin instead (plugins/nuclei*.json).

4b. Jaeles signature import

The third format compiler imports Jaeles detection-signature YAML. A signature is an id, an info block (name/risk), optional variables, and a requests list; Fissure compiles it into a scripted check, no jaeles binary required. Supported now:

  • requests: EVERY request in the list is compiled (not just the first). Each has a method, url (with {{.BaseURL}} resolved to the target origin), headers, and body; the requests are sent in order and their detections are ANDed (a chained detection), stopping early once one fails;
  • variables: a variables block is resolved, so {{.name}} in a url, body, header, or detection is substituted before compiling. Literal name: value pairs substitute their text; the RandomString(n) and RandomNumber generators become a fresh value computed per run (emitted as a JS variable and spliced into the string literals), so a signature that injects a random marker and checks for its reflection works as intended;
  • detections (a list, ANDed per request): the StatusCode() and ContentLength() helpers in numeric comparisons (==, !=, >, <, >=, <=), StringSearch( component, "text") (case-insensitive contains), and RegexSearch(component, "regex"), over the components component.response / component.body / component.header, combined with && / || / !;
  • passive signatures: a type: passive (or a top-level detections: block) compiles to a PASSIVE check that evaluates the detections against the current response without sending anything.

A detection that uses an unsupported helper is dropped and recorded; generator-function variables, request middlewares/chaining, and non-scalar variables are noted in the skipped field (a signature with no compilable detection is refused). Exposed over the control API (POST /api/jaeles) and the MCP bridge (jaeles_import); run the emitted js via POST /api/jscheck.


5. Packaging as an extension bundle (the extension SDK)

The surfaces above are loose files. An extension bundle wraps them in a self-describing, versioned package that Fissure discovers, lists, and enables or disables without editing the filesystem, the parity answer to an extension API plus an extension marketplace.

A bundle is a directory under resources/extensions/<id>/ with an extension.json manifest:

{
  "id": "web-hardening",
  "name": "Web hardening auditor",
  "version": "1.0.0",
  "author": "you",
  "description": "What it does, in one line.",
  "sdk_version": 1,
  "enabled": true,
  "checks": ["checks/csp-audit.js", "checks/isolation-headers.js"],
  "panels": [{ "title": "Hardening reference", "render": "panels/reference.js" }]
}
  • id (required) matches the directory name and keys the enabled/disabled state.
  • sdk_version (required) is the SDK ABI the bundle targets (currently 1). A bundle that needs a newer host than the running build is listed but not loaded (marked incompatible), never half-applied.
  • enabled is the default on first sight; the user's later choice persists to <config>/extensions_state.json and wins.
  • checks lists the bundle's fs.* scripted checks (surface 1), relative to the bundle directory. They run wherever user checks run: the scanner, the proxy passive node, and the Findings "run user scripts" action.
  • panels (optional) lists GUI panels the extension contributes. Each is {"title": ..., "render": <script>}; the render script is a transform-style script (like surface 2: it returns a string, with no fs.* exchange context) whose text is shown in an owner-draw panel opened from the Extensions manager's "Open panel". Use it for a reference sheet, a computed summary, or any read-only view the extension wants to surface.
  • tabs (optional) lists top-level views the extension owns. Each is {"title": ..., "render": <script>} with the same render-script model as a panel. Tabs are shown inline in the Extensions manager: select the extension in the bundle list and its tabs appear in an "Extension tabs" picker below, the chosen tab's content shown as scrollable, selectable text that follows the list selection. A panel is a popup opened on demand; a tab is always-visible content for the selected extension. Bundled example: web-hardening's "Hardening checklist".
  • actions (optional) lists on-demand, request-contextual scripts. Each is {"title": ..., "run": <script>}; the run script uses the same fs.* API (active fs.send permitted) but runs only when triggered on one selected request, never during a scan. In the GUI it is the right-click "Extension actions"; over the API it is GET /api/ext-actions + POST /api/ext-action (and the ext_actions/ext_action MCP tools). Bundled example: param-tools.
  • session_actions (optional) lists on-demand login flows. Each is {"title": ..., "run": <script>}; the run script drives a login with fs.send, reading credentials/field names from fs.params, and Fissure captures the resulting session cookie so a later scan runs authenticated. In the GUI it is the Session popup's "Session actions" launcher; over the API it is GET /api/session-actions + POST /api/session-action (and the session_actions/session_action MCP tools). Bundled example: form-login (a CSRF-token-aware HTML form login).
  • editors (optional) lists interactive custom message editors. Each is {"title": ..., "decode": <script>, "encode": <script>}; the decode script transforms the raw message text into an editable representation and the encode script transforms the edited representation back into raw text (both transform-style, the global input holds the text). The operator edits in a standard text area (the host provides the editing), so the extension owns only the two-way transform. Reachable from a request's context menu ("Open in editor") or the command palette; over the API it is GET /api/editors + POST /api/editor {ext, editor, op, text} (and the editors/editor MCP tools). Bundled example: json-tools (a JSON pretty-print/minify editor).
  • request_hooks (optional) lists request-mutation scripts that rewrite every request the proxy forwards, on its way out (stamp a header, re-sign a body, refresh a token). Each is {"title": ..., "run": <script>}; the script receives the raw request as the global request and returns its replacement, or defines mutate(request) and returns from that; returning nothing, null, or the input unchanged leaves the request alone. Hooks from all enabled bundles are chained in registry order, each seeing the previous one's output. A hook that throws is logged and leaves the request untouched. Because a hook rewrites all forwarded traffic, attaching one logs a NOTICE naming how many are active. Bundled example: request-stamp (ships disabled).

Every contribution type in the SDK is now shipped; there is no further roadmap slice.

Manage bundles in the GUI (the Extensions popup, from the command palette's "Open Extensions"), over the control API (GET/POST /api/extensions), or via the MCP tools (extensions, extensions_op). The bundled extensions under resources/extensions/ are the reference to copy from: web-hardening (checks, a panel, and a tab), secret-radar, jwt-exposure, api-leaks and statedemo (checks; statedemo exercises fs.store), param-tools and active-probes (actions), form-login and session-logins (session actions), json-tools and codec-tools (editors), and request-stamp (a request hook). See docs/14_EXTENSION_SDK.md for the full design.

Testing your extension

  • Scripted check: put it under resources/checks/, capture or scan a target that should trigger it, and confirm the finding appears in the Findings view. fs.log output goes to the application log.
  • Transform/generator: use the Multitool convert step or the Intruder Script payload source / payload-processing Script step, which show the result inline.
  • Plugin: install the tool, open the Plugins view (the plugin appears when its binary is found), run it against an authorized target, and confirm its output is parsed into findings.

The reference implementations to copy from live in resources/checks/ (scripts), plugins/ (manifests), and resources/dependencies.json (install steps).