# FISSURE: the RF and reverse engineering framework for SDR work

> FISSURE is an open source RF framework from Assured Information Security that bundles SDR tooling, IQ collection, protocol discovery, fuzzing and TAK integration into one environment. It is aimed at operators, researchers and educators, and the README is explicit that the project is dual-use.

**ainfosec/FISSURE** — The RF and reverse engineering framework for everyone. Follow and to show your support!

- Repository: https://github.com/ainfosec/FISSURE
- Website: https://twitter.com/FissureRF
- Stars: 2,053 · Forks: 142
- Language: Python
- License: GPL-3.0
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/ainfosec-fissure

## What FISSURE is for, and who it is aimed at

FISSURE expands to Frequency Independent SDR-based Signal Understanding and Reverse Engineering. That name is a fair description of the scope: it is not a single tool but a framework that centralises software, libraries and reference material for software defined radio work into one environment. The README describes two audiences. Operators get a toolkit for signal detection, classification, protocol discovery, fuzzing, vulnerability analysis and real-time integration with TAK. Educators and researchers get a lower barrier to entry into SDR and reverse engineering, with a shared environment for experimentation and for publishing methods.

The problem it addresses is setup cost. Assembling a working SDR stack normally means matching GNU Radio, device drivers, Python bindings, decoders and a database by hand, and that stack breaks whenever one component moves. FISSURE's answer is to ship the stack as a unit, with an installer and a dashboard on top. The repository layout reflects that ambition: alongside the fissure/ package there are Classifier/, Dissectors/, Flow Graph Library/, Crafted Packets/, IQ Recordings/, Archive/, Plugins/, Tools/ and UI/. Those directories are content as much as code, and they are the reason a first install is measured in gigabytes rather than megabytes.

The README also states plainly that FISSURE is dual-use, listing operators, researchers, educators, students and hobbyists as intended users. That framing is not decoration. It explains why the project ships both a desktop GUI for visualisation and prototyping and headless nodes for remote sensing, and why TAK integration sits in the core rather than in an optional add-on.

## How the framework is put together

The architecture visible in the repository is layered. At the bottom there is a Python package, fissure/, plus a database layer. The docker-compose.yml at the repository root defines two services: a postgres:13 instance that reads POSTGRES_USER, POSTGRES_PASSWORD, POSTGRES_DB and a port pair from environment variables, and a pgadmin service on port 3000 for inspecting that database. An example.env file sits next to it, which is where those variable names are meant to be filled in. So the persistent state of a FISSURE install lives in PostgreSQL, not in flat files, and the compose file is the supported way to bring that state up without installing PostgreSQL on the host.

Above the database sit the processing components. Flow Graph Library/ holds GNU Radio flow graphs, Dissectors/ holds protocol dissectors, Classifier/ holds signal classification material, and Plugins/ holds the plugin content the roadmap says is being expanded across the dashboard, WinTAK, ATAK and sensor nodes. The UI/ directory and the fissure/ package provide the dashboard and the Python entry points. IQ Recordings/, Archive/ and Crafted Packets/ are working directories for captured and generated data.

Deployment is deliberately not single-form. The README lists four options: a desktop GUI for visualisation and prototyping, headless nodes for remote sensing and autonomous operations, containerised services for repeatable installs, and TAK integration for shared situational awareness. The roadmap adds Apptainer support and downloadable container images as current work, which tells you the container path is being treated as the primary answer to install reliability rather than a side channel.

## Installing FISSURE and running a first capture

The repository ships an install script at the root and an Installer/ directory, and the README points at the project documentation rather than reproducing the steps. The release tags give the clearest signal about what to expect: the current release is Python3_20260121, and the two older tags are 1.0.2-Python3_maint-3.8 and 1.0.2-Python3_maint-3.10, so the supported Python branches are named explicitly in the tag names. Check your distribution's Python version against those before starting, because the installer is not documented as handling arbitrary interpreters.

The database is the part you can stand up independently, and doing so first is a reasonable way to confirm Docker and your environment variables are correct. Copy example.env to .env, fill in the POSTGRES_* values, and bring the stack up:

```bash
docker compose up -d db pgadmin
```

After this the postgres container should be running and pgadmin should answer on port 3000, with the credentials from the compose file. If the postgres container exits immediately, the usual cause is an unset or empty POSTGRES_PASSWORD in your .env, because the image refuses to initialise without it.

For the framework itself, run the root install script and then launch the dashboard:

```bash
./install
```

The README does not document a rollback path for the installer, and it does not list the exact packages the script pulls in. Treat the install as a one-way change to the machine, and prefer a container or a dedicated host if you need to undo it cleanly. Once the dashboard is up, the first useful exercise is to open the IQ Recordings directory from the UI, play a recording through a flow graph from Flow Graph Library/, and confirm that the classifier and dissector panels populate. That exercises the database, the flow graph runtime and the UI in one pass, which is a better smoke test than starting with live hardware.

## Where FISSURE gets in the way

The install is the first real limitation. The README's roadmap lists installer reliability, Apptainer refinement, downloadable container images and prebuilt deployment options as current priorities, which is an admission that installation across supported operating systems and hardware is not yet a solved problem. A framework that bundles its own GNU Radio, drivers and content library cannot be lightweight, and the roadmap's own framing treats packaging as ongoing work rather than finished work.

Hardware support is the second. The README talks about desktops, laptops, single-board computers and ruggedised systems without naming specific SDR devices, and the installer's supported device list is the thing that decides whether your radio works. Buying hardware on the strength of the capability list is the wrong order of operations.

The third limitation is scope. FISSURE is a framework with a GUI, a database and a plugin system. If your job is to demodulate one known signal inside an existing Python pipeline, importing FISSURE means importing a PostgreSQL dependency and a content tree you will not use. The same applies to headless automation: the README lists headless nodes as a deployment option, but the dashboard and the plugin architecture are where the roadmap's attention is going, so a pure scripting use case is not what the project is optimising for.

Finally, the roadmap is described as evolving with customer demand and community feedback, with an interactive version updated every July. That is a reasonable cadence for a project of this size, but it means priorities can move between your evaluation and your deployment. The last push to the repository was on 2026-01-21, so the code you are reading is roughly eight months old as of this writing; the roadmap page, not the repository, is where newer direction appears.

## FISSURE compared with a GNU Radio-first workflow

The obvious alternative is to build the same capability directly on GNU Radio, adding the decoders, classifiers and database you need yourself. The difference is not in signal processing capability, since FISSURE's Flow Graph Library is GNU Radio content underneath. The difference is in what is already assembled and what you inherit.

A GNU Radio-first workflow gives you a library and a companion application, and you decide everything above that: which decoders to install, where captures live, how classification results are stored, how nodes talk to each other. It is smaller, it is easier to embed in an existing pipeline, and you control the upgrade schedule. What you do not get is a dashboard, a persistent signal archive, a plugin interface, or TAK integration. You also do not get the reverse engineering side: dissectors, crafted packets and fuzzing are FISSURE features, not GNU Radio features.

FISSURE inverts the trade. You accept a large install, a PostgreSQL dependency and a plugin architecture you have to learn, and in exchange you get signal detection, IQ collection and replay, protocol discovery, packet crafting, fuzzing, distributed node coordination, geolocation and TAK alerting inside one environment with a shared data model. For a team running field sensing with several nodes and a TAK client, that integration is the product. For a researcher who wants to test one demodulator idea, it is overhead.

There is a middle path worth noting. Because the database and pgadmin run under docker compose independently of the framework, you can evaluate the storage and inspection layer before committing to the full install. That is the lowest-risk way to see whether FISSURE's data model suits how your team already stores captures.

## Licence, upgrades and the cost of staying current

FISSURE is licensed under GPL-3.0. For internal use that mostly means keeping the licence text with the source and making the source available to anyone you distribute the software to. If you build a product that links FISSURE code and you ship that product, the GPL-3.0 obligations attach to the combined work; whether your particular integration counts as linking is a question for your own counsel, not something this article can settle. The README's note that Fracture is a commercial productisation path built on FISSURE is a useful signal that the project's authors have thought about this boundary, but it does not change the terms you receive the code under.

Upgrade cost is driven by the tag structure. Releases are tagged by Python branch, with 1.0.2-Python3_maint-3.8 and 1.0.2-Python3_maint-3.10 as separate maintenance lines and Python3_20260121 as the current release. That means a Python version bump is a migration event, not a patch. The CHANGELOG.md at the repository root is where the project records what moved between releases, and it is the file to read before upgrading a working install.

The plugin architecture adds a second upgrade axis. The roadmap states that the plugin and action architecture is being applied throughout the dashboard, WinTAK, ATAK and sensor nodes, and that existing library content is being converted into plugins. Anything you build as a local modification rather than a plugin is likely to need rework as that conversion proceeds. Building against the plugin interface from the start is the cheaper long-term choice, even though the interface is still moving.

## Conclusion

FISSURE is worth adopting if you already work with SDR hardware and want signal detection, IQ collection, protocol discovery and TAK integration inside one environment instead of a pile of separate scripts, or if you teach RF and DSP and need a shared setup for a class. It is the wrong choice if you want a small library to import into an existing Python signal pipeline, if you cannot commit disk space to the bundled library content, or if you need a documented rollback path before installing. Verify first that your SDR hardware appears in the installer's supported device list, that your distribution matches a supported Python 3 branch (the releases are tagged for Python 3.8 and 3.10), and that the GPL-3.0 obligations fit how you plan to redistribute anything you build on top of it.

## FAQ

### What is FISSURE in RF and SDR terms?

FISSURE stands for Frequency Independent SDR-based Signal Understanding and Reverse Engineering. The README describes it as an open source RF framework that supports both operational deployments and research and education, with capabilities covering signal detection and classification, IQ collection and replay, protocol discovery, packet crafting, fuzzing and TAK integration.

### Which operating systems and hardware does FISSURE support?

The README says it runs on desktops, laptops, single-board computers and ruggedised systems, and lists desktop GUI, headless nodes, containerised services and TAK integration as deployment options. It does not name specific SDR devices, and the roadmap lists improving installer reliability and prebuilt deployment options as current priorities, so check the installer's supported device list before buying hardware.

### What licence is FISSURE released under?

The repository lists GPL-3.0. That means distribution of the software carries source-availability obligations, and the README notes that Fracture is a commercial productisation path built on the open source framework.

### Does FISSURE integrate with TAK?

Yes. The README lists TAK integration as a deployment option and as a key capability, covering alerts, targets and artifacts, and the roadmap describes expanding WinTAK and ATAK functionality along with target management and geolocation workflows.

## Sources

- [Official documentation](https://twitter.com/FissureRF)
- [Official README](https://github.com/ainfosec/FISSURE#readme)
- [Project repository](https://github.com/ainfosec/FISSURE)
- [Release notes](https://github.com/ainfosec/FISSURE/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ainfosec-fissure