Fissuredocumentation v5.3.1
On this page

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_bounty skill, 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:

  1. 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>.

  2. 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"
  3. 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/; done
  4. Use 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.