FISSURE - The RF Framework

Frequency Independent SDR-based Signal Understanding and Reverse Engineering

Overview Videos

_{FISSURE Operational Overview}

_{FISSURE Overview (Slides)}

Introduction

FISSURE is an open-source RF framework that supports both operational deployments and research and education.

For operators, it provides a rapidly deployable toolkit for signal detection, classification, protocol discovery, fuzzing, vulnerability analysis, and real-time integration with TAK.
For educators and researchers, it lowers the barrier to entry for SDR and reverse engineering, offering a shared environment for learning, experimentation, and publishing new methods.

FISSURE streamlines complex SDR workflows by centralizing software, libraries, and reference material into one consistent framework that runs on desktops, laptops, single-board computers, and ruggedized systems, or scales to distributed tactical nodes networked in the field.

Key Capabilities

Detect, classify, and analyze RF signals
Collect, replay, and manipulate IQ data
Discover protocols and craft custom packets
Execute fuzzing and vulnerability testing
Archive signals and build playlists for testing
Coordinate distributed sensor nodes
Geolocate RF emitters and targets
Integrate alerts, targets, and artifacts into TAK
Automate workflows with AI and ML integration

FISSURE and Fracture

Fracture is AIS's deployable tactical RF system built on the open-source FISSURE framework.

FISSURE provides the underlying software environment for RF sensing, signal analysis, protocol experimentation, TAK integration, distributed node coordination, and plugin-based capability development. Fracture extends this foundation into deployable hardware configurations designed for operational use.

Fracture focuses on distributed RF sensing, geolocation, RF effects, electronic warfare workflows, and real-time operator control through WinTAK and ATAK. A central hub coordinates edge nodes over IP networks and long-range RF links to support sensing, targeting, and mission execution across distributed environments.

The architecture is designed to support fixed-site, vehicle, manpack, sUAS, and fixed-wing deployments while remaining extensible through FISSURE's plugin framework.

For organizations requiring a supported and integrated tactical RF capability, Fracture provides a productization path that preserves the flexibility, transparency, and extensibility of the underlying FISSURE ecosystem.

Fracture System Architecture

TAK Integration Workflow

Deployment Options

Desktop GUI for visualization and prototyping
Headless nodes for remote sensing and autonomous operations
Containerized services for scalable and repeatable installs
TAK integration for mission relevance and shared situational awareness

Dual-Use Relevance

Operators: Detect, geolocate, and respond to RF activity in the field
Researchers: Test new algorithms, automation, and AI and ML approaches
Educators: Teach SDR, DSP, RF security, real-time processing, and reverse engineering in the classroom
Students and Hobbyists: Explore SDR workflows and learn about technology without steep setup overhead

Roadmap and Development

FISSURE’s roadmap evolves with customer demand and community feedback.

For the most up-to-date view, explore the interactive roadmap (updated every July):

View Interactive Roadmap

Current Priorities

Plugin Ecosystem & Actions: Applying the new plugin and action architecture throughout the FISSURE Dashboard, WinTAK, ATAK, and sensor nodes. Expanding plugin support, converting existing library content into plugins, and simplifying capability deployment while protecting sensitive functionality through the plugin framework.
TAK Integration & Operator Workflows: Expanding WinTAK and ATAK functionality, improving target management, geolocation workflows, alerting, artifact handling, and operator-driven actions. Focus areas include real-world testing, performance optimization, usability improvements, and tighter integration between TAK and distributed sensor nodes.
Installer, Packaging & Deployment: Improving installer reliability, refining Apptainer support, hosting downloadable container images, delivering prebuilt deployment options, and simplifying installation across supported operating systems and hardware platforms.
Tactical Nodes, Sensors & Networking: Expanding support for tactical node deployments, integrating additional sensors and hardware, evaluating new communications pathways including cellular, Starlink, mesh networking, and communications radios, and improving resilience across distributed deployments.
Geolocation, Direction Finding & Electronic Support: Advancing geolocation, direction-finding, and monitoring capabilities through field testing and operational evaluations. Emphasis is placed on practical electronic support workflows, multi-node sensing, performance validation, and the collection of real-world operational feedback.

Videos

White Papers

FISSURE is supported by a series of white papers that explore both technical and operational applications across different domains.

Blog Posts

AIS has published several articles highlighting FISSURE’s applications, updates, and use cases:

See all AIS blog posts

News

Plugin & Action Architecture: FISSURE is transitioning to a unified plugin and action framework that enables capabilities to be packaged, deployed, and executed across the Dashboard, sensor nodes, WinTAK, and ATAK.

WinTAK Integration: WinTAK now supports node management, alerts, targets, detections, artifacts, plugin selection, action execution, and distributed sensor node operations.

ATAK Integration: ATAK integration is actively under development, extending FISSURE and Fracture capabilities to mobile devices and tactical edge operators.

Distributed Tactical Nodes: Sensor nodes support remote operation, distributed sensing workflows, TAK integration, artifact collection, alerting, and plugin execution across IP-connected networks.

Geolocation & Target Management: Development efforts continue on RF geolocation, target management, multi-node coordination, and real-world operational testing.

Apptainer Containerization: FISSURE can be deployed within Apptainer containers to simplify installation, testing, portability, and deployment across supported platforms.

Fracture Architecture & TAK Workflows: New diagrams and documentation have been added to illustrate Fracture system architecture, TAK integration workflows, and distributed tactical operations.

Upcoming/Recent Events

May 5-8, 2025: SOF Week - Assured Information Security, Inc. (AIS) booth

Thu. February 6, 2025: Binghamton University Spring 2025 Job and Internship Fair - 1100-1500 EST

January 20, 2025 (Runs Indefinitely): FISSURE Challenge. Link (Now Live)

Tue. September 17, 2024: GNU Radio Conference 2024 - 1605-1635 EST Description/Slides, Live Recording

Thu. September 5, 2024: Binghamton University STEM Job and Internship Fair - 1100-1530 EST

Sat. August 10, 2024: DEF CON 32 - RF Village - 1400-1500 PST. Prerecorded Video, Live Recording

Documentation

Capabilities

FISSURE Capabilities (Updated: 11Sep24)

Signal Detector	IQ Manipulation	Signal Lookup	Pattern Recognition
Attacks	Fuzzing	Signal Playlists	Image Gallery
Packet Crafting	Scapy Integration	CRC Calculator	Logging
Dataset Builder	Online Archive	Third-Party Tools	Dark and Custom Themes

Hardware

The following is a list of "supported" hardware with varying levels of integration:

USRP: X3xx, B2xx, B20xmini, USRP2, N2xx, X410
HackRF
RTL2832U
802.11 Adapters
LimeSDR
bladeRF, bladeRF 2.0 micro
Open Sniffer
PlutoSDR
SDRplay: RSPduo, RSPdx, RSPdx R2

Getting Started

Supported

There are now two branches within FISSURE: the Python3 branch and the Python2_maint-3.7 branch. The Python3 branch contains the latest code and has support for PyQt5 and GNU Radio versions 3.8 and 3.10. The Python2_maint-3.7 branch has been deprecated and will only be updated if specific third-party tools require GNU Radio version 3.7 or an older operating system. Only the latest minor versions of operating systems will be supported for installs and we will do our best to keep up. Operating systems that have been updated and yet to be fully tested will be listed under "In-Progress."

The GitHub releases provided in this repository are periodic snapshots of the project's state, intended primarily for archival purposes. These releases may not include the latest updates, bug fixes, or features currently under development. To access the most up-to-date version of the software, we strongly recommend using the main Python3 branch, which reflects ongoing development and the current state of the project.

FISSURE is most extensively tested on Ubuntu, making it the most validated platform.

Operating System	FISSURE Branch	Default GNU Radio Version
DragonOS Noble (24.04)	Python3	maint-3.10
Kali	Python3	maint-3.10
Raspberry Pi OS	Python3	maint-3.10
Ubuntu 18.04	Python2_maint-3.7	maint-3.7
Ubuntu 20.04	Python3	maint-3.8
Ubuntu 22.04	Python3	maint-3.10
Ubuntu 24.04 / Ubuntu ARM (Orange Pi) / Ubuntu for Raspberry Pi	Python3	maint-3.10
Windows 11 WSL2	See Supported Linux Version	See Supported Linux Version

In-Progress (beta)

These operating systems are still in beta status. They are under development and several features are known to be missing. Items in the installer might conflict with existing programs or fail to install until the status is removed.

Operating System	FISSURE Branch	Default GNU Radio Version
BackBox Linux	Python3	maint-3.10
KDE neon	Python3	maint-3.10
Parrot Security 6.1	Python3	maint-3.10

Note: Certain software tools do not work for every OS. Refer to Known Conflicts and Third-Party Software

Apptainer Installs

FISSURE supports Apptainer-based deployment on Ubuntu 24.04. The installer can build role-specific environments using the following modes:

full: complete FISSURE installation
base: minimum complete local workstation
Dashboard: Dashboard client without a local database or Sensor Node
HIPRFISR: headless hub and database services
SensorNode: remote radio execution environment
custom: user-defined installer selection

Ubuntu 24.04 hosts with Ubuntu 24.04 containers are the primary tested configuration. Additional host, container, and mode combinations may work but have not been fully validated.

Installation

For adding SSH keys to GitHub and cloning with SSH (needed for contributing):

ssh-keygen -t ed25519
cat ~/.ssh/id_ed25519.pub
Paste text into "Settings" > "SSH and GPG keys" > "New SSH Key"
git clone git@github.com:ainfosec/FISSURE.git

For cloning with https:

git clone https://github.com/ainfosec/FISSURE.git

Preparing the installer:

cd FISSURE
git checkout Python3  # Optional, or Python2_maint-3.7 for select legacy third-party tools
./install

Notes:

The installer will ask to install PyQt software dependencies required to launch the installation GUIs if they are not found.
Select the operating option in the GUI that best matches your operating system (should be detected automatically if your OS matches an option).
Periodically answer prompts regarding third-party software throughout the install. Use your best judgment, the answers will not likely impact FISSURE.
Ensure your system clock is set correctly to avoid errors with apt rejecting repository updates.
After installation, reboot your computer or log out and back in so that user group changes take effect.

It is recommended to install FISSURE on a clean operating system to avoid conflicts with existing software. Further efforts towards virtualization and dependency management will be continued. Notes on the installer:

The items listed under the "Minimum Install" category are what is required to launch the FISSURE Dashboard without errors. The Base mode extends the Minimum Install selection into a complete standalone workstation capable of running the Dashboard, HIPRFISR, and a local Sensor Node.
The radio hardware and out of tree modules are required to perform many actions in FISSURE.
The flow graphs need to be recompiled to avoid errors across GNU Radio minor versions.
Software programs outside the minimum install are optional and can be installed as needed.
Select the installation mode that matches the intended system role. Use Full for the broadest installation, Base for a complete local workstation, or one of the role-specific Dashboard, HIPRFISR, Sensor Node, or Custom modes.
Items unchecked by default may not install properly or could possibly conflict with existing programs (please suggest fixes!).
There will be multiple prompts throughout the installation, mostly asking for elevated permissions and user names. These prompts are primarily tied to third-party tools, refer to installation instructions provided by the maintainer for details.
If an item contains a "Verify" section at the end, the installer will run the command that follows and highlight the checkbox item green or red depending on if any errors are produced by the command. Checked items without a "Verify" section will remain black following the installation.
To avoid installation and permission errors, download FISSURE to a user owned directory such as Home. Run the install script and the fissure command without using sudo. Many of the third-party tools will be downloaded to and installed from the ~/Installed_by_FISSURE directory.

The FISSURE installer is helpful for staging computers or installing select software programs of interest. The code can be quickly modified to allow for custom software installs. The size estimates for the programs are before and after readings from a full install. The sizes for each program are not exact as some dependencies are installed in previously checked items. The sizes may also change over time as programs get updated.

Remote Sensor Node Installation

Install FISSURE per usual on a general purpose computer. Install FISSURE on the remote computer in the same directory location as the local computer (until further notice) to avoid filepath errors with certain actions. To configure the sensor node for remote operation, edit the "default.yaml" file in the ./YAML/Sensor_Node_Config/ directory and edit the following fields:

nickname: (anything but "Local Sensor Node")
hiprfisr_ip_address: (the HIPRFISR/hub IP address the sensor node connects to)
hardware: (fill with your hardware specifics)

Change the "autorun" field from from false to true to run the default autorun playlist file on startup and forgo remote operations. New autorun playlists can be generated and saved from the Dashboard Autorun tab.

The remote sensor node acts as a server and must have a set of valid certificates (generated during install) that match with the client (local computer). The server needs the "server.key_secret" and "client.key" files while the client needs the "client.key_secret" and "server.key" files. If the certificates folder was generated on the server computer, the client files must be manually transferred to the other computer.

Local Dashboard Usage

Open a new terminal after installation and enter:

fissure

The intended method for launching the FISSURE Dashboard is through the terminal without sudo. The terminal provides important status and feedback for some operations. Refer to the FISSURE documentation for more details.

A local sensor node can be launched through the top buttons in the FISSURE Dashboard and helps maintain all pre-existing FISSURE functionality on a standalone workstation. Only one local and four remote sensor nodes (or five remote) are supported at this time.

If any of the programs freeze or hang on close, the following commands can be used to detect a problem or forcibly shut down:

sudo ps -aux | grep fissure
sudo pkill python3
sudo kill -9 <PID of __main__.py>
sudo pkill python3 && sudo pkill -9 -f fissure

Headless Hub

The HIPRFISR can be launched without the Dashboard GUI to make TAK testing and operational deployments more efficient. Open a new terminal after installation and enter:

fissure-hiprfisr

The hub will automatically connect up to the TAK server and remote nodes will be able to join without interaction.

Remote Sensor Node Usage

After configuring the sensor node config file (see above), the sensor node code can be run using this command in a terminal:

fissure-sensor-node

The sensor node code will stay active until ctrl+c is applied. Connecting to the remote sensor node is performed through the top buttons of the FISSURE Dashboard. Right-clicking the top buttons will select an active sensor node to perform operations. Future operations that utilize more than one node at a time will be handled on a case-by-case basis within the individual tabs.

Windows 11 WSL2 Instructions

FISSURE can run in Windows 11 using WSL2 for supported Linux operating systems. The following are instructions to help install WSL2, install a Linux operating system, set up USB passthrough, and install FISSURE in the Linux operating system.

Install WSL2:

Open PowerShell as Administrator
wsl --install
Enable Virtualization in BIOS, check using: Task Manager>Performance>CPU>Virtualization
wsl --set-default-version 2
wsl --list --online
Install a specific version (plain Ubuntu should be the latest version listed): wsl --install -d Ubuntu-22.04
Open the Start Menu, search for Ubuntu and launch it
To uninstall a distribution: wsl --unregister Ubuntu-22.04

Enable USB passthrough in a PowerShell as Administrator:

winget install usbipd
Add usbipd to System PATH: Start Menu>Environment Variables>Edit the system environment variables>System Properties>Environment Variables>System Variables>Path>Edit>New: C:\Program Files\usbipd-win
Close and reopen PowerShell as Administrator
usbipd wsl list
usbipd wsl attach --busid <BUS_ID> or usbipd wsl attach --busid <BUS_ID> --wsl <DistributionName> (replace <BUS_ID> with the actual BUS ID of the device)
To detach: usbipd wsl detach --busid <BUS_ID>

Install FISSURE in Linux Terminal:

sudo apt-get install git
Clone FISSURE and install as detailed above

TAK Setup

To install and run a local TAK server:

Register and download the TAK server docker zip from the website: https://tak.gov/products/tak-server
Create the ~/Installed_by_FISSURE directory if it does not exist
Place the downloaded .zip file in ~/Installed_by_FISSURE
Run the TAK Server item in the FISSURE installer
For local WebTAK, load the ~/Installed_by_FISSURE/taskerver-docker-#.#-RELEASE-##/tak/certs/files/webadmin.p12 file into your browser (settings>certificates)
Set "tak_on_startup" field to True in /FISSURE/YAML/User Configs/default.yaml or select "Start Docker Containers" from the FISSURE Dashboard TAK menu
Open WebTAK from FISSURE TAK menu and verify map loads with internet connection
Set "connect_mode" (auto/manual/disabled) field in /FISSURE/YAML/User Configs/default.yaml. Connect to TAK server in FISSURE Dashboard TAK menu if set to manual.
Run a FISSURE effect that creates a TAK alert (examples coming soon)

To connect to a remote TAK server:

Update the certificate filepaths in /FISSURE/YAML/User Configs/default.yaml
Set "connect_mode" (auto/manual/disabled) field in /FISSURE/YAML/User Configs/default.yaml. Connect to TAK server in FISSURE Dashboard TAK menu if set to manual.
Run a FISSURE effect that creates a TAK alert (examples coming soon)

Apptainer Setup

Apptainer is used to containerize most of the FISSURE installation, making deployment and testing simpler across different systems. While most of FISSURE runs inside the Apptainer environment, several components still require setup on the host:

Docker containers, including the PostgreSQL database and TAK Server, run on the host.
Apptainer, udev rules, hardware drivers, and device permissions must be configured on the host for SDRs, Wi-Fi adapters, and other peripherals.

Pre-built Apptainer containers and ISO images are planned for future releases. These instructions are for users who want to build the Apptainer container from source or customize their installation.

Clone the FISSURE Repository
Configure the Installer
- Open FISSURE/Installer/install_apptainer.sh in a text editor.
- Review the variables near the top of the script.
- Enable or disable the desired hardware and software options.
- Choose the desired FISSURE install mode:
  - full - Complete FISSURE installation with supported SDR software, network tools, and utilities
  - base - Complete standalone workstation capable of running the Dashboard, HIPRFISR, and a local Sensor Node
  - Dashboard - Dashboard client without a local database or Sensor Node
  - HIPRFISR - Headless HIPRFISR hub with database services
  - SensorNode - Remote Sensor Node runtime with supported hardware, GNU Radio modules, and compiled flow graphs
  - custom - User-defined installer selection configured in Installer/Modes/custom.py
Run the Installer
```
cd FISSURE/Installer
./install_apptainer.sh
```
This builds a writable Apptainer sandbox in your home directory and installs the selected software inside the container and on the host where required.
Launch the Container
```
fissure-apptainer
```
This opens a terminal inside the FISSURE container with graphics, audio, udev information, and hardware device access configured by the launcher.
Run FISSURE

Once inside the container, run FISSURE as you would on a normal system:
```
fissure
fissure-sensor-node
```
If you encounter an issue, include the host operating system, Apptainer version, selected install mode, affected hardware, and relevant installer output in the report.

Lessons

FISSURE comes with several helpful guides to become familiar with different technologies and techniques. Many include steps for using various tools that are integrated into FISSURE. We aim to improve the quality and add new content over time.

FISSURE Challenge - Continuous Capture the Flag

The FISSURE Challenge is a continuous capture-the-flag contest built around the FISSURE framework. It is designed as an open learning tool where anyone can practice RF reverse engineering, explore new features, and tackle protocol-focused challenges.

New challenges are added over time as FISSURE evolves.
Solutions and walkthroughs are posted periodically on YouTube. Solutions 1
Community members are encouraged to submit their own challenges for others to solve.

Access the challenges at: FISSURE Challenge

Contributing

Suggestions for improving FISSURE are strongly encouraged. Good contribution areas include new features, installation fixes, RF protocols, hardware/SDR support, third-party tools, GNU Radio flow graphs, Python analysis scripts, plugin actions, lessons, tutorials, and documentation corrections.

The best place to start is the Discussions page, the Discord Server, email, or a focused Issue.

Code contributions are greatly appreciated:

Fork the project
Create your feature branch (git checkout -b feature/AmazingFeature)
Commit your changes (git commit -m 'Add some AmazingFeature')
Push to the branch (git push origin feature/AmazingFeature)
Open a pull request

Need more specific ideas? Check out our roadmap and running list of potential to-do items.

Student Projects and Classroom Use

FISSURE is a good fit for senior projects, undergraduate research, graduate research, RF/cybersecurity courses, and open-source software assignments. Student teams can work on SDR hardware integration, RF protocol analysis, signal detection, IQ analysis, plugins, lessons, visualization, TAK integration, or documentation.

Students, instructors, research groups, and organizations interested in using FISSURE for hands-on RF and reverse engineering projects are encouraged to reach out.

Commercial Support and Collaboration

Contact Assured Information Security, Inc. (AIS) Business Development to discuss FISSURE and Fracture collaboration opportunities. AIS can assist with integrating FISSURE into existing platforms and workflows, developing custom plugins and capabilities, expanding support for new hardware and sensors, and building mission-specific RF solutions.

Organizations interested in deployable Fracture systems can engage AIS to develop and integrate tactical node configurations for fixed-site, vehicle, manpack, sUAS, and fixed-wing applications. AIS can also support TAK integration, distributed sensor architectures, RF sensing and geolocation workflows, custom electronic warfare capabilities, operator training, and long-term system sustainment.

Whether your goal is research, education, prototyping, operational deployment, or integration into a larger system-of-systems architecture, AIS can help accelerate development and deployment while preserving the flexibility of the underlying FISSURE framework.

License

GPL-3.0

For license details, see LICENSE file.

Contact

Join the Discord Server: https://discord.gg/JZDs5sgxcG

Follow on Twitter/X: @FissureRF, @AinfoSec

Follow on Bluesky: @fissurerf.bsky.social

Connect on LinkedIn: FISSURE - The RF Framework

Chris Poore - Assured Information Security, Inc. - poorec@ainfosec.com

Business Development - Assured Information Security, Inc. - bd@ainfosec.com

Testimonials

“FISSURE is a powerful and versatile RF software platform suitable for both education and practical applications. It supports a wide range of commonly used hardware and offers intuitive IQ data analysis tools. These features enable us to visualize, interpret, and directly modify RF signal messages in our project.”
– Dylan R.

“We really enjoyed using FISSURE in our engineering project. This software is an incredibly comprehensive collection of tools to manipulate radio frequencies and was an amazing aid to our studies involving wireless communications.”
– University Senior Project Team

Acknowledgments

Special thanks to Dr. Samuel Mantravadi and Joseph Reith for their contributions to this project.

Assured Information Security

View our other open source projects at: https://ainfosec.dev/

Like working with signals, reverse engineering, or other realms in cybersecurity? Browse our current openings or join our talent community for future consideration.

If you have an interest in hacking, check out our Can You Hack It?® challenge and test your skills! Submit your score to show us what you’ve got. AIS has a national footprint with offices and remote employees across the U.S. We offer competitive pay and outstanding benefits. Join a team that is not only committed to the future of cyberspace, but to our employee’s success as well.

FISSURE