Fissure
Fissure is a Linux desktop web-security toolkit written in C99 on top of the Nilorea library (Allegro 5 + the n_gui widget toolkit for the GUI, n_network for networking) - the same stack as the Hook API client and the Sketchr drawing app.
It combines, in one native GUI application:
- An intercepting HTTPS proxy (MITM with on-the-fly per-host certs), with keep-alive, WebSocket pass-through, request interception/editing, and an optional upstream-proxy chain (HTTP/HTTPS CONNECT or SOCKS5).
- A full website scanner: crawl and collect all endpoints, list possible vulnerabilities, and test them passively or with active checks. A safe default (reflection probes) vs an opt-in aggressive mode (SQLi / path-traversal payloads), plus per-endpoint rate limiting and a CPU-pool parallel audit.
- A target-scope allow/deny host model (exact, .suffix, regex, *) that the proxy (blind-tunnelling out-of-scope hosts) and the scanner (multi-host crawl/audit) both honor, keeping testing within authorized targets.
- A plugin host that wraps best-of-breed OSS security tools (nuclei, ffuf, httpx, subfinder, sqlmap, katana, nikto, dalfox, and more) with automatic download driven by a JSON resource file.
- A synthetic report generator (HTML / Markdown / JSON / SARIF / CSV) that aggregates every finding from the proxy, the scanner, and the plugins, plus a PwnDoc connector that pushes findings (idempotently) and pulls the Docx report.
- Bug-bounty / CTF helpers: an encoding/JWT/hash Multitool (CyberChef-lite: base64/base64url/URL/hex/zlib, MD5/SHA digests, JWT decode + HS256 wordlist crack, hash identification), an Intruder-style payload fuzzer (marker positions, sniper/battering-ram/pitchfork/clusterbomb, threaded over the engine), and a recon Dashboard summarizing the live session.
- A headless CLI (
fissure scan/fissure report) for CI pipelines. - A loopback, token-gated control API + MCP bridge so an AI agent
(Claude Code) can drive the whole engine through the shipped
fissure_bug_bountyskill, which carries the methodology for both bug-bounty engagements and CTF flag-hunting. See Drive it with an AI agent below.
Built for authorized security testing, bug bounties, and CTFs.
Status
Implemented and working: the design's Phases 0-6 are complete
(intercepting proxy, scanner, plugin host, reporting, CLI) and the app
is in the polish phase (Settings/persistence, scope enforcement,
safe/aggressive, upstream-proxy chain, PwnDoc connector). Build with
make, run the regression suite with
make tests. See docs/00_MASTER_PLAN.md ("State of this repo
right now") and docs/TODO.md for the current status and remaining
polish.
Authorization
Fissure performs active, intrusive testing and TLS interception. Use it ONLY against systems you own or are explicitly authorized to test. It enforces a scope allowlist, rate limits, a safe/aggressive toggle, and a first-run authorization banner, but you remain responsible for staying within your authorized scope and the law.
Drive it with an AI agent (MCP)
Fissure exposes its whole engine over a loopback, token-gated control
API, and a Model Context Protocol (MCP) bridge lets an AI agent (Claude
Code) drive it: scope a target, scan, replay and confirm findings, run
the workshops, and write the report, all through the shipped
fissure_bug_bounty skill, which carries the methodology for
both bug-bounty engagements and CTF flag-hunting. Four steps:
Enable the control API. In the GUI: Settings, Control API, enable it (loopback
127.0.0.1:8777) and copy the token. Or run the engine headless:fissure serve --port 8777 --api-key <token>.Set up the MCP bridge. Install the SDK into a virtualenv and register the bridge with Claude Code (full detail and a verification step are in bridge/README.md). The command below runs from a checkout; an installed package ships the bridge too (
.deb:/opt/fissure/bridge/, AppImage and Windows: see step 1b of docs/13_MCP_AND_SKILL_SETUP.md), so use that path instead:python3 -m venv ~/.venvs/fissure-mcp ~/.venvs/fissure-mcp/bin/pip install "mcp>=1.27,<2" claude mcp add fissure-control \ --env SUITE_API_URL=http://127.0.0.1:8777 \ --env SUITE_API_TOKEN=<token-from-settings> \ -- ~/.venvs/fissure-mcp/bin/python "$PWD/bridge/fissure_mcp_bridge.py"Make the skills available to Claude Code. Fissure's skills (currently
fissure_bug_bounty) live in this repo under.claude/skills/, and the packages ship them too (.deb:/opt/fissure/skills/). Claude Code auto-discovers skills in the.claude/skills/of your working directory, so they are available whenever you run Claude Code inside this repo. To use them from anywhere (for example while working in your target's own repo), copy or symlink every skill folder into your personal skills directory:mkdir -p ~/.claude/skills cp -r .claude/skills/* ~/.claude/skills/ # or /opt/fissure/skills/* from the .deb # or, to track this repo: for s in "$PWD"/.claude/skills/*; do ln -sfn "$s" ~/.claude/skills/; doneUse it. With Fissure built (see Build) and the control API running, ask Claude in plain language:
- Bug bounty / pentest: "test https://app.example.com for vulnerabilities" (the skill confirms authorization and sets scope before any active traffic).
- CTF / lab: "solve this CTF at http://10.10.10.5" or "capture the flag on this box" (the challenge is the authorization; the skill switches to flag-hunting mode and exploits to the flag).
A safe practice target ships in the repo under lab/dvwa/
(see docs/12_DVWA_LAB.md). The
skill's methodology and the CTF playbook live in
.claude/skills/fissure_bug_bounty/ (SKILL.md
and references/ctf.md); the control API and every tool it
exposes are documented in docs/11_CONTROL_API.md and bridge/README.md.
No agent? The control API is plain HTTP, so curl, a
Python script (bridge/fissure_control_client.py, no MCP SDK
needed), or CI can drive the same tools; fissure serve runs
the engine without the GUI.
Documentation
| Document | Contents |
|---|---|
| docs/17_STARTING_AND_USING.md | Start here: every launch mode (GUI, headless scan/report, engine daemon, web portal, one-shot API, MCP) |
| docs/FEATURES.md | Canonical inventory of every supported feature |
| docs/00_MASTER_PLAN.md | Roadmap, phases, build, testing, ethics |
| docs/01_SECURITY_TOOLS_CATALOG.md | OSS tools hosted as plugins |
| docs/02_ARCHITECTURE.md | Components, source layout, plugin system, data model |
| docs/03_GUI_DESIGN.md | GUI design + Hook/Sketchr/n_gui audits + responsive/DPI |
| docs/04_NETWORK_AND_PROXY.md | Transport core + MITM proxy + network audits |
| docs/05_WEBSITE_SCANNER.md | Crawler, endpoint discovery, vuln tests |
| docs/06_REPORTING.md | Findings aggregation + reporting |
| docs/07_PAWNDOC.md | PwnDoc connector (push findings, pull Docx) |
| docs/08_IAST_BEACON.md | Out-of-band IAST beacon protocol + reference agents |
| docs/09_YESWEHACK_WORKFLOWS_AND_GAPS.md | Bug-bounty workflow parity and gaps |
| docs/10_TOKENS.md | JWT and framework signed-cookie workshops |
| docs/11_CONTROL_API.md | Loopback control API + MCP + agent automation |
| docs/12_DVWA_LAB.md | Local DVWA practice + regression lab |
| docs/14_EXTENSION_SDK.md | Extension SDK (checks, panels, actions, editors) |
| docs/EXTENDING.md | Writing scripted checks, BChecks, and plugins |
| docs/PORTABILITY.md | Windows / MSYS2 port status |
| bridge/README.md | MCP bridge setup, verification, and tool reference |
| .claude/skills/fissure_bug_bounty/ | The AI agent skill: methodology, vuln playbooks, CTF mode |
| docs/TODO.md | Backlog and as-built status of each feature |
| docs/audits/ | Hook/Sketchr/Nilorea audits, the competing-tool references, and the competitive gap audit |
| resources/dependencies.json | OSS download URLs for auto-install |
Build
make # build Fissure, optimized -O3 (compiles selected Nilorea sources directly)
make tests # build and run the regression suite under tests/
make checks # cppcheck + scan-build (zero findings required)
make docs # Doxygen + HTML
make format # clang-format over src/ and tests/
make DEBUG=1 # AddressSanitizer + UBSan build
make appimage # build the distributable AppImage (dist/fissure-<version>-x86_64.AppImage)
make deb # build a Debian package (dist/fissure_<version>_amd64.deb)
make docs-html # convert the docs + tutorials to HTML (dist/docs-html/, needs pandoc)
make appimage-test # verify the AppImage is self-contained on a clean host (needs docker)
make docker-build # build the .deb + AppImage in a Debian-stable container (needs docker)
make installer-windows # (MSYS2/mingw64) build the Windows setup.exe with NSIS (dist/fissure-<version>-setup.exe)
make release # every artifact at the stored version: local + Docker .deb/AppImage, Windows build, Windows installer
make show-version # print the version stored in src/fissure_version.h
make bump-version # raise it by one (VERSION=x.y.z sets it); the only target that changes it
On Windows (MSYS2 mingw64), make installer-windows
bundles the MinGW/Allegro runtime DLLs (via collect-dlls),
generates the HTML docs, and compiles
packaging/installer.nsi with makensis into a
dist/fissure-<version>-setup.exe. The installer lays
down fissure.exe, its DLLs, resources/ and
plugins/, the MCP bridge under bridge/ and the
Claude skills under skills/, an uninstaller, and Start Menu
shortcuts including a "Fissure Documentation" link. Unlike the
.deb/AppImage it does not bundle the Fissure Browser
(Chromium); Fissure uses a system-installed Chrome/Chromium. Both
Windows outputs (the loose dist/windows/ folder and the
installer) are stripped of their debug sections and, when
osslsigncode and the publisher's key are on the build
machine, signed by NiloreaStudio (make release refuses to
build them unsigned); see "Windows: the signature" below and
docs/PORTABILITY.md, "Signing the Windows build".
make appimage-test runs the built AppImage in a fresh
debian:trixie-slim container that has only the host desktop
libraries and none of the app-specific bundled ones (libyaml,
libxml2/libxslt, xmlsec1, OpenSSL, PCRE2, Allegro, ...), so a missing
bundled library fails loudly; it also exercises the bundled libyaml (a
YAML import) and the xmlsec1-backed SAML route. Re-run it after adding
any linked dependency.
make deb produces a self-contained .deb
(the binary, its resources, plugins, and bundled libraries install under
/opt/fissure, with a launcher in
/usr/bin/fissure and a desktop menu entry + icon under the
Internet category, so Fissure appears in the application menu after
sudo dpkg -i dist/fissure_<version>_amd64.deb). Every
package (the .deb, the AppImage and the Windows installer)
also ships the MCP bridge and the Claude skills next to the binary
(bridge/ and skills/<name>/, staged by
packaging/stage-agent.sh; .deb:
/opt/fissure/bridge, /opt/fissure/skills), so
an installed Fissure can be connected to Claude without a source
checkout (see docs/13_MCP_AND_SKILL_SETUP.md).
Both the .deb and the AppImage also bundle the Fissure user
documentation (the design/ reference docs and the Fissure tutorials, not
the internal roadmap/backlog/parity plans or third-party tutorials) as
HTML under docs/ next to the binary (generated by
packaging/make-docs-html.sh, requires pandoc). The HTML set
mirrors the source layout and the links between pages are rewritten from
.md to .html; a link to a file that is not
shipped (a source file, a maintainer-only doc) keeps its text but is not
a link, and the build fails on any dead link. The pages use the Fissure
theme (the presentation palette, dark by default with a light toggle): a
page list on the left, the page's contents on the right, an offline
search box over page titles and section headings, text that reflows to
the window width, code blocks that wrap long lines (ASCII diagrams keep
their columns; each block has Copy and Wrap / No wrap buttons), and
previous/next links. Open dist/docs-html/index.html in a
browser. The .deb adds a "Fissure Documentation" menu
entry, and the in-app Help view (the Help entry in the toolbar's Home
category dropdown) has a Documentation button that
opens the bundled docs in your browser.
make docker-build produces the release .deb
and AppImage inside a Debian container
(packaging/Dockerfile +
packaging/docker-build.sh), so you get a Debian-stable
build without installing the toolchain on your host and without
host-built objects (linked against a different glibc) leaking into the
artifacts. It mounts this repo and the sibling
nilorea-library read-only, builds in a clean copy, and
drops the artifacts back on the host. This is the RELEASE path, so
unlike a local make deb/make appimage testing
build it bundles the Fissure Browser (Chromium) by default and tags the
artifacts with the Debian codename, so they are easy to tell apart from
the generically named local builds:
release : dist/fissure_<version>-<codename>_amd64.deb
dist/fissure-<version>-<codename>-x86_64.AppImage
testing : dist/fissure_<version>_amd64.deb (make deb)
dist/fissure-<version>-x86_64.AppImage (make appimage)
Because a native .deb's computed Depends
are release-specific (the t64 library package names differ
per release), the container's base fixes which Debian release the
.deb targets. Requires docker.
Docker build overrides
All of these are environment variables passed to
make docker-build (or straight to
packaging/docker-build.sh), except the version, which is a
positional argument to the script:
| Override | Default | What it does |
|---|---|---|
BASE_IMAGE |
debian:trixie-slim |
Which Debian release the .deb targets and which glibc
the AppImage needs. debian:bookworm-slim (12) or
debian:bullseye-slim (11, widest reach) build against an
older release. |
FETCH_CHROMIUM |
1 |
0 omits the bundled Fissure Browser (Chromium); the app
then falls back to a system Chromium at run time. Also avoids
redistributing Google's Chrome for Testing binary in your artifact. |
NILOREA_DIR |
<repo>/../../nilorea-library |
Path to the sibling nilorea-library checkout that gets mounted read-only and compiled in. Set it when your checkout is elsewhere. |
IMAGE |
fissure-build:<base> |
Tag for the build image, so several base images can coexist. |
DOCKER |
docker |
The container CLI. Accepts a multi-word prefix, e.g.
DOCKER="sudo docker" or DOCKER=podman. |
(positional) VERSION |
from src/fissure_version.h |
packaging/docker-build.sh 1.2.3 names the release
yourself. The Debian codename is always appended, so you get
1.2.3-trixie. |
Examples:
make docker-build BASE_IMAGE=debian:bullseye-slim FETCH_CHROMIUM=0
DOCKER=podman NILOREA_DIR=/src/nilorea-library sh packaging/docker-build.sh
sh packaging/docker-build.sh 1.2.3 # name the release explicitly
Note on versioning: the version is stored in
src/fissure_version.h and changes only with
make bump-version, which raises the last number by one
(make bump-version VERSION=x.y.z stores that exact value);
make show-version prints it. No build changes it:
make deb, make appimage,
make docker-build, make installer-windows and
make release all package the stored version, so building
twice gives the same file names. A release is: bump, commit, build.
Passing an explicit VERSION to docker-build.sh
names that one build and writes nothing.
One release, one version
(make release)
make release builds everything at the version the tree
carries (bump and commit first):
dist/fissure_<version>_amd64.deb local .deb
dist/fissure-<version>-x86_64.AppImage local AppImage
dist/fissure_<version>-<codename>_amd64.deb Docker release .deb
dist/fissure-<version>-<codename>-x86_64.AppImage Docker release AppImage
dist/windows/ cross-built fissure.exe + runtime DLLs
dist/fissure-<version>-setup.exe Windows installer
It runs on Linux and needs docker, dpkg-deb, the mingw-w64 cross
compiler, makensis, the Windows dependency sysroot
(make windows-deps, once), and osslsigncode
with the NiloreaStudio signing key: the Windows artifacts of a release
are always signed. All of that is checked before anything is built. The
Docker step honours BASE_IMAGE,
FETCH_CHROMIUM, DOCKER and
NILOREA_DIR as make docker-build does.
Dependencies: OpenSSL, zlib, PCRE2, Allegro 5 (+ addons), QuickJS (bundled).
The application icon lives at packaging/fissure.svg
(master) and is rasterized to packaging/fissure-256.png.
That PNG is the window/taskbar icon (loaded at startup from
resources/fissure-icon.png via
al_set_display_icon), the AppImage icon, and the source of
the committed packaging/fissure.ico embedded into the
Windows executable.
Windows: the signature
The Windows program (fissure.exe,
fissure-cli.exe), the DLLs beside it, the installer and the
uninstaller are signed by NiloreaStudio. The certificate is self-signed:
no authority vouches for it, so Windows shows the signature as not
trusted, and SmartScreen still warns, until the certificate is installed
on the machine. That is optional. The program runs the same without
it.
The certificate is NiloreaStudio.cer, in the program's
folder. It is the public half only and cannot sign anything. Check that
it is the right one before trusting it:
certutil -hashfile NiloreaStudio.cer SHA256
must print
b9976986aebbfa925b019ee453d9834549b03581fd6ffa28c68f88e6df4a6acd
Then, in a console run as administrator, from the program's folder:
certutil -addstore Root NiloreaStudio.cer
certutil -addstore TrustedPublisher NiloreaStudio.cer
To undo it:
certutil -delstore Root NiloreaStudio
certutil -delstore TrustedPublisher NiloreaStudio
Installing it makes the machine accept every program signed with that
key, so it is the administrator's decision on a machine that has one.
The certificate is limited to signing code and cannot issue other
certificates. It is the same certificate for every NiloreaStudio
program, and it has nothing to do with the proxy CA Fissure generates
for HTTPS interception, which is made per install and never shared. A
build made from the sources on a machine without the key is not signed,
and one made with another key stops unless told to accept it, in which
case it has another fingerprint (docs/PORTABILITY.md,
"Signing the Windows build").
License
Freeware. Copyright (c) 2026 Castagnier Mickael (gullradriel). All rights reserved.
Fissure is free of charge: anyone may install and use it, in the binary form published by the author, for any lawful purpose, private or professional. It is not for sale, and it may not be modified or redistributed, in source or binary form, except under a separate written agreement. See LICENSE for the full notice.
Fissure builds on third-party components that keep their own licenses. Every one is listed, with its license text, in THIRD_PARTY_LICENSES. Read that file before distributing a build: it records which components are compiled into the binary, which are bundled into the AppImage/.deb/installer, and which are expected from the host system, and it flags the components under copyleft licenses that constrain closed-source distribution.