Extending Fissure
Fissure is extensible without recompiling. There are three extension surfaces, all loaded from disk at startup and all optional:
- 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. - 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).
- 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-1when request-mutatingfs.send()is permitted (an active scan),0in 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. Asession_actionslogin flow reads its username/password and the form field names fromfs.params, so one bundle logs into any form. The control API passesparamsonPOST /api/session-action; the GUI passes a params JSON field; the MCPsession_actiontool takes aparamsdict.
Methods:
fs.header(name)- one response header value, orundefined.fs.headers()- all response headers as an object.fs.json()- the response body parsed as JSON, ornullif it is not JSON.fs.log(msg)- append one line to the application log (alsoconsole.log,console.warn,console.error).fs.send(req)- send a follow-up request through the transport and return{status, body, time, headers}.reqis{url, method, headers, body};urldefaults tofs.url,methoddefaults toGET,headersis an object,bodyis a string. Only available whenfs.activeis true; there is a per-run call limit. The most recentfs.send()exchange is remembered so the nextfs.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}, ornull. Unlikefs.sendit does not normalize framing, so it carries exact bytes (a custom method, a deliberately malformed header, an explicit Content-Length). Only whenfs.active; shares the per-run call limit. Backs imported nucleiraw: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 nucleixpathmatchers/extractors.fs.bodyhex()- the raw response body as byte-exact lowercase hex, including bytes after an embedded NUL that thefs.bodystring would drop. Backs nucleibinarymatchers (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 objectfs.send()returns.fs.hash(alg, s)- the hex digest ofsunderalg(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.bodyis 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 computingmmh3(base64_py(body))is exactly that case).fs.oast([channel])- mint an out-of-band (OAST) canary and return an object{token, url, host}, ornullwhen no OAST listener is configured or the run is not active.channelis optional ("http","dns","smtp"); a DNS or LDAP payload uses the barehost, an HTTP sink theurl. Inject it where a blind sink might fetch it.fs.oast_seen(token)returnstrueonce 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 nucleiinteractshmatchers).fs.oast_wait(token, channel, timeout_ms)- wait up totimeout_msfor the canarytokento be hit onchannel("http"/"dns"/"smtp", or omitted for any), returningtrueas 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. Asession_actionstoken login uses this.fs.request()- the OBSERVED request as{method, target, headers, header_block, body}, ornullwhen 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 returnsnulland a check built on it does nothing.header_blockis the rawName: valuelines, 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.getreturns a string ornull;setandremovereturn a boolean (a refused write, such as a key-count or value-size cap breach, returnsfalserather than being dropped silently);keysreturns an array of strings. With no store installed (a bare unit test) they answernull/false/[]instead of throwing.fs.report(finding)- record a finding.findingis an object;categoryandtitleare 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 functiontransform(input)that returns the value. If both are present,transform(input)wins. - The returned value is coerced to a string. Returning
undefined/nullyields 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 findingsource_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 onPATH).interpreter- optional; runsbinaryas an argument to this interpreter, e.g."python3"for agit_clone'dsqlmap.py. Omit for a native binary.dependency- optional key intoresources/dependencies.jsonfor 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; seeoutput.regex),json(a JSON document;output.recordsis a dotted path to the array of records),jsonl(one JSON object per line, the shape most of the ProjectDiscovery tools emit; nooutput.recordsneeded), ortext(a single blob). Arecordspath may contain a*segment to fan out across a NESTED array:"records": "Results.*.Vulnerabilities"descends into each element ofResultsand adds every element of that element'sVulnerabilities, which is how trivy yields one finding per vulnerability rather than one per scanned target. Prefer a structured format overtextwhenever the tool can produce one:textcollapses 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.sslyzeis 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 nomap. 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 examplednsx,{"stdin": "{{target_host}}"}). POSIX only.output.records- forjson, the dotted path to the record array.map- maps a finding field to a source field. Forjsonandjsonl, the value is a source key and MAY be a dotted path into nested objects (info.severity, as plugins/nuclei.json uses); forregex, 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 withoutput.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;dslexpressions, 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_countand the rest), over the response variablesstatus_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'spart:reads the same vocabulary, so besidesbody,header,all/responseandraw(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);xpathmatchers (an XPath selecting a node in the HTML/XML body, via the built-infs.xpathengine);binarymatchers (a hex byte sequence in the raw response body, byte-aligned, viafs.bodyhex); andinteractshout-of-band matchers (part: interactsh_protocol+ the{{interactsh-url}}placeholder, confirmed by an OAST canary hit viafs.oast/fs.oast_seen), all combined bymatchers-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; aninternal: trueextractor 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 viafs.sendraw, with{{Hostname}}/{{Host}}/{{Port}}resolved from the target origin;payloads, in both shapes. With afuzzing:block the template is a DAST one and each rule is compiled:part(query,path,header,cookie),type(replace/prefix/postfix),mode(single/multiple) andkeysall take effect, and the payload goes into the LIVE request being audited. Without afuzzing:block the sets fill the{{name}}placeholders in the template's own path, raw request or body, combined the wayattack: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, andbody; the requests are sent in order and their detections are ANDed (a chained detection), stopping early once one fails; - variables: a
variablesblock is resolved, so{{.name}}in a url, body, header, or detection is substituted before compiling. Literalname: valuepairs substitute their text; theRandomString(n)andRandomNumbergenerators 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()andContentLength()helpers in numeric comparisons (==,!=,>,<,>=,<=),StringSearch( component, "text")(case-insensitive contains), andRegexSearch(component, "regex"), over the componentscomponent.response/component.body/component.header, combined with&&/||/!; - passive signatures: a
type: passive(or a top-leveldetections: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.enabledis the default on first sight; the user's later choice persists to<config>/extensions_state.jsonand wins.checkslists the bundle'sfs.*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 nofs.*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 samefs.*API (activefs.sendpermitted) 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 isGET /api/ext-actions+POST /api/ext-action(and theext_actions/ext_actionMCP tools). Bundled example:param-tools.session_actions(optional) lists on-demand login flows. Each is{"title": ..., "run": <script>}; the run script drives a login withfs.send, reading credentials/field names fromfs.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 isGET /api/session-actions+POST /api/session-action(and thesession_actions/session_actionMCP 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 globalinputholds 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 isGET /api/editors+POST /api/editor {ext, editor, op, text}(and theeditors/editorMCP 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 globalrequestand returns its replacement, or definesmutate(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.logoutput 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
binaryis 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).