FISSURE - The RF Framework

Frequency Independent SDR-based Signal Understanding and Reverse Engineering

Overview

GRCon26 Conference Talk

Tactical Workflow Demo

GRCon26 Presentation Slides

Introduction

FISSURE is an open-source framework for RF analysis, automation, and distributed operations. It connects SDR hardware, signal processing, Sensor Nodes, geolocation, protocol analysis, targeting, and situational awareness within a single extensible environment.

FISSURE can run as a standalone workstation or scale across distributed Sensor Nodes connected over IP networks. GNU Radio and other tools provide the underlying RF processing, while FISSURE coordinates hardware, data, context, plugins, Actions, and operator workflows across local and remote systems.

The framework is designed for experimentation, research, education, capability development, and operational integration without locking users to a single protocol, sensor, platform, or use case.

Workflow Overview

FISSURE organizes RF workflows around connected workspaces that share Sensor Nodes, SOIs, Targets, Detections, Artifacts, Findings, and plugin Actions.

• Tactical: Monitor distributed Sensor Nodes, detections, SOIs, Targets, geolocation results, and other RF activity on a shared operational map.
• Signal Analysis: Move from survey and detection through capture, inspection, conditioning, feature extraction, classification, and protocol discovery.
• Targets & Actions: Manage Targets and execute reusable plugin Actions through focused, sequential, fuzzing, and packet-crafting workflows.
• Sensor Nodes: Configure local and remote nodes, manage hardware, transfer files, automate startup behavior, and monitor node status.
• Library: Maintain reusable protocol information, packet definitions, archived signals, replay content, datasets, and RF reference material.
• Plugins & Actions: Add, deploy, and execute capabilities across supported nodes and interfaces without modifying the FISSURE core.

Core Information Model

FISSURE connects workflows through a shared information model rather than treating each tool or tab as an isolated function. SOIs anchor signal analysis, Targets anchor operational context, Detections capture sensor observations, Artifacts and Findings preserve data and results, and Alerts and Action Recommendations surface information that may require attention or follow-on action.

Key Capabilities

• Detect, classify, capture, and analyze RF signals
• Record, inspect, replay, and manipulate IQ data
• Discover protocols, build packets, and perform RF/cyber experimentation
• Execute fuzzing, vulnerability analysis, and reusable test workflows
• Coordinate local and distributed Sensor Nodes, SDRs, sensors, and tools
• Geolocate emitters and maintain persistent Targets, detections, and observations
• Share RF-derived awareness, alerts, artifacts, and target information through TAK
• Extend capabilities through deployable plugins, Actions, and reusable Operations
• Automate multi-step workflows across local and remote systems
• Integrate custom analysis, external tools, and emerging AI/ML capabilities

_{FISSURE Tactical view connecting distributed Sensor Nodes, detections, SOIs, Targets, and operational context.}

FISSURE and Fracture

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

FISSURE provides the software foundation for RF sensing, signal analysis, distributed Sensor Nodes, geolocation, TAK integration, automation, and plugin-based capability development. Fracture packages that foundation into purpose-built hardware and software configurations designed for operational deployment.

Fracture combines SDRs, compute, networking, plugins, and mission-specific integrations around fixed-site, vehicle, manpack, sUAS, and other distributed deployments while preserving the flexibility and extensibility of FISSURE.

Fracture System Architecture

Deployment Options

FISSURE supports multiple deployment models depending on the intended workflow and operating environment:

• Standalone Workstation: Run the Dashboard, HIPRFISR, and a local Sensor Node on a single system for development, analysis, and experimentation.
• Distributed Sensor Nodes: Run RF and plugin capabilities on remote systems while coordinating tasking, results, and data through a central hub.
• Headless Hub: Run HIPRFISR and supporting services without the Dashboard for remote operations, TAK integration, and distributed deployments.
• Containerized Deployment: Use Apptainer to build repeatable Dashboard, HIPRFISR, Sensor Node, Base, Full, or custom environments.
• TAK-Integrated Operations: Share targets, detections, alerts, geolocation results, artifacts, and other operational information through ATAK, WinTAK, and TAK Server.

What's New

Connected Signal Analysis Workflows: FISSURE now connects survey, detection, capture, inspection, conditioning, feature extraction, classification, and protocol discovery through SOI-centered workflows with associated Artifacts and Findings.

Tactical View & Target Awareness: The Dashboard now provides an operator-focused Tactical view for Sensor Nodes, detections, SOIs, Targets, geolocation results, and other RF activity on a shared map.

Plugin & Action Architecture: Capabilities can be packaged as plugins and exposed through reusable Actions and Operations for local or remote execution without modifying the FISSURE core.

Distributed Geolocation: Multi-node workflows support coordinated RF observations, target tracking, geolocation, and persistent operational context across distributed Sensor Nodes.

TAK Integration: FISSURE supports sharing Sensor Nodes, Targets, detections, geolocation results, alerts, tracks, artifacts, and other RF-derived information through TAK workflows.

Remote RF Workflows: GNU Radio and other graphical capabilities can run on remote Sensor Nodes while their interfaces are streamed back to the operator through Xpra.

Apptainer Deployment: Role-specific Apptainer environments support repeatable Dashboard, HIPRFISR, Sensor Node, Base, Full, and custom deployments.

Who FISSURE Is For

• Operators: Monitor, analyze, geolocate, and respond to RF activity across local and distributed systems.
• Researchers: Develop and evaluate new RF, cyber, automation, AI/ML, and signal-processing techniques.
• Educators: Teach SDR, DSP, wireless security, protocol analysis, reverse engineering, and distributed systems.
• Students and Hobbyists: Explore real RF workflows using accessible hardware, open tools, and reusable examples.

Roadmap

FISSURE continues to evolve through operational testing, research, customer needs, and community feedback.

• View Interactive Roadmap

Current Priorities

• End-to-End Workflows: Connect discovery, signal analysis, targeting, actions, artifacts, findings, and sharing into clearer repeatable workflows.
• Plugins, Actions & Operations: Expand the plugin ecosystem across protocols, hardware, sensors, analysis, automation, and third-party integrations.
• Distributed Deployment & Packaging: Improve installer reliability, Apptainer support, role-specific deployments, remote Sensor Nodes, and repeatable system configuration.
• Geolocation, Targets & TAK: Continue improving multi-node geolocation, target awareness, operator workflows, mapping, and ATAK/WinTAK integration.
• Automation, Provenance & AI/ML: Strengthen traceable execution, structured context, workflow automation, and interfaces between RF data and emerging AI/ML capabilities.

Resources & Publications

Videos

• FISSURE Development YouTube Channel
• FISSURE Video Playlist (AIS)
• FISSURE Operational Overview
• FISSURE Overview (Slides)
• AIS YouTube Channel

White Papers

FISSURE is supported by a series of white papers covering technical architecture, operational use cases, deployment models, and integration topics.

1. FISSURE Overview
2. FISSURE for Counter-UAS
3. FISSURE for UAS Payloads & Aerial Operations
4. FISSURE for Maritime
5. FISSURE for Vehicle & Mobility Systems
6. FISSURE for Perimeter & Infrastructure Defense
7. FISSURE for TAK & Mobile
8. FISSURE for Training & Education
9. FISSURE Technical Details & Architecture

Blog Posts

AIS has published several articles covering FISSURE development, demonstrations, and operational use cases:

• Demonstrating FISSURE as a Drone Payload at Northern Strike 2025
• A Recap of My DEF CON 2024 Presentation on FISSURE Updates
• FISSURE: Navigating the Open-Source Realm
• FISSURE: The RF Framework for Everyone

See all AIS blog posts

Upcoming and Recent Events

September 21-24, 2026: GNU Radio Conference 2026 - Raleigh, NC
FISSURE: Tactical RF Operations and Situational Awareness with GNU Radio - Presentation slides and workflow demonstration video available on the conference page.

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

September 17, 2024: GNU Radio Conference 2024 - Description/Slides, Live Recording

August 10, 2024: DEF CON 32 - RF Village - Prerecorded Video, Live Recording

Additional Resources

• FISSURE Info Sheet
• AIS FISSURE Page

Documentation

• FISSURE Documentation

Hardware

FISSURE has integrated with a wide range of SDRs, wireless adapters, and protocol-specific RF hardware over the life of the project. Hardware support is currently being migrated into the new plugin architecture, so not every legacy integration is available through every current workflow or deployment mode yet.

Existing and previously integrated hardware includes:

Software Defined Radios

• USRP X3xx, B2xx, B20xmini, USRP2, N2xx, X410
• HackRF
• RTL2832U
• LimeSDR
• bladeRF and bladeRF 2.0 micro
• PlutoSDR
• SDRplay RSPduo, RSPdx, RSPdx R2

Wireless Adapters

• 802.11 adapters used for monitoring, discovery, injection, and other Wi-Fi workflows

Protocol-Specific and Specialized Radios

• Open Sniffer
• Additional protocol-oriented radios and interfaces integrated for specific workflows

Support varies by plugin, operating system, driver availability, GNU Radio version, and individual FISSURE capability.

Getting Started

Supported Platforms

The Python3 branch contains the current FISSURE codebase and supports PyQt5 with GNU Radio 3.8 and 3.10 depending on the operating system. The legacy Python2_maint-3.7 branch is deprecated and retained only for select older tools and environments.

GitHub releases are periodic snapshots of the project and may not contain the latest fixes or features. For the most current version of FISSURE, use the Python3 branch.

FISSURE is most extensively tested on Ubuntu and related Ubuntu-based environments.

In-Progress (Beta)

Apptainer Installs

FISSURE supports Apptainer-based deployment on Ubuntu 24.04 for more repeatable installation, testing, and deployment. The installer can build role-specific environments using the following modes:

• full - Complete FISSURE installation
• base - Complete standalone workstation
• Dashboard - Dashboard client without a local database or Sensor Node
• HIPRFISR - Headless hub and database services
• SensorNode - Remote Sensor Node execution environment
• custom - User-defined installer selection

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

See Apptainer Setup below for build and launch instructions.

Installation

Clone FISSURE with HTTPS:

git clone https://github.com/ainfosec/FISSURE.git
cd FISSURE
git checkout Python3
./install

For contributors using SSH:

ssh-keygen -t ed25519
cat ~/.ssh/id_ed25519.pub

Add the public key to GitHub under Settings > SSH and GPG keys, then clone with:

git clone git@github.com:ainfosec/FISSURE.git
cd FISSURE
git checkout Python3
./install

The installer will detect the operating system when possible and prompt for any required PyQt dependencies and optional third-party software.

After installation, reboot or log out and back in so that user group and device permission changes take effect.

Installer Notes

FISSURE is easiest to install on a clean operating system to reduce conflicts with existing packages and third-party software.

Remote Sensor Node Installation

Install FISSURE on the remote system using the normal installation process. For now, install FISSURE in the same directory location on both the local and remote systems to avoid filepath issues with certain Actions.

Local Dashboard Usage

After installation, open a new terminal and launch FISSURE with:

fissure

Run FISSURE as your normal user, not with sudo. Launching from a terminal is recommended because it provides useful status and diagnostic output.

A local Sensor Node can be started from the top controls in the Dashboard, allowing a single workstation to run the Dashboard, HIPRFISR, and Sensor Node together.

FISSURE no longer enforces a fixed Sensor Node count. Deployments can scale to the number of remote Sensor Nodes supported by the available compute, network, and operational workload.

If FISSURE does not close cleanly, the following command will stop the remaining FISSURE processes:

sudo pkill python3 && sudo pkill -9 -f fissure

For troubleshooting or more targeted process control:

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

Headless Hub

FISSURE can run HIPRFISR without the Dashboard GUI for distributed deployments, TAK integration, remote Sensor Node coordination, and other headless workflows.

fissure-hiprfisr

Remote Sensor Node Usage

Remote Sensor Nodes can be launched independently and connect to the configured HIPRFISR / Hub for distributed operation.

fissure-sensor-node

Windows 11 WSL2 Instructions

FISSURE can run in Windows 11 using WSL2 for supported Linux operating systems. Expand the sections below for setup and troubleshooting commands.

wsl --install

wsl --set-default-version 2

wsl --list --online

wsl --install -d Ubuntu-24.04

wsl --unregister Ubuntu-24.04

winget install usbipd

C:\Program Files\usbipd-win

usbipd wsl list

usbipd wsl attach --busid <BUS_ID>

usbipd wsl attach --busid <BUS_ID> --wsl <DistributionName>

usbipd wsl detach --busid <BUS_ID>

sudo apt-get install git

TAK Setup

FISSURE can connect to a local or remote TAK Server for sharing Sensor Nodes, Targets, detections, geolocation results, alerts, tracks, artifacts, data packages, video connections, and other operational information.

TAK settings are configured in:

FISSURE/YAML/User Configs/default.yaml

For current builds, use auto when TAK connectivity is desired or disabled when TAK should remain disconnected.

tak:
  cert: /path/to/takserver.pem
  connect_mode: disabled
  ip_addr: localhost
  external_ip: 192.168.1.128
  key: /path/to/takserver.key
  port: 8089
  tak_on_startup: false
  webadmin_cert: /path/to/webadmin.p12

mkdir -p ~/Installed_by_FISSURE

~/Installed_by_FISSURE

~/Installed_by_FISSURE/takserver-docker-#.#-RELEASE-##/tak/certs/files/webadmin.p12

FISSURE/YAML/User Configs/default.yaml

tak:
  ip_addr: localhost
  external_ip: <FISSURE_TAK_HOST_IP_REACHABLE_BY_CLIENTS>
  port: 8089
  connect_mode: auto
  tak_on_startup: true

tak:
  tak_on_startup: false

TAK > Start Docker Containers

FISSURE/YAML/User Configs/default.yaml

tak:
  ip_addr: <REMOTE_TAK_SERVER_IP_OR_HOSTNAME>
  external_ip: <TAK_SERVER_ADDRESS_REACHABLE_BY_CLIENTS>
  port: 8089
  connect_mode: auto
  tak_on_startup: false

tak:
  cert: /path/to/takserver.pem
  key: /path/to/takserver.key
  webadmin_cert: /path/to/webadmin.p12

tak:
  tak_on_startup: false

Apptainer Setup

Apptainer can be used to containerize most of the FISSURE software environment for more repeatable installation, testing, and deployment.

Several components still remain on the host system:

• Docker containers, including PostgreSQL and TAK Server
• Apptainer itself
• udev rules and device permissions
• Hardware drivers and other host-level interfaces required for SDRs, Wi-Fi adapters, and peripherals

Ubuntu 24.04 hosts with Ubuntu 24.04 containers are the primary tested configuration. Prebuilt Apptainer containers and ISO images are planned for future releases.

FISSURE/Installer/install_apptainer.sh

cd FISSURE/Installer
./install_apptainer.sh

fissure-apptainer

fissure

fissure-sensor-node

Lessons

FISSURE includes hands-on lessons for learning RF, SDR, protocol analysis, supporting tools, and related technologies. Many lessons use software and workflows that are integrated directly into FISSURE.

• Lesson 1: OpenBTS
• Lesson 2: Lua Dissectors
• Lesson 3: Sound eXchange
• Lesson 4: ESP Boards
• Lesson 5: Radiosonde Tracking
• Lesson 6: RFID
• Lesson 7: Data Types
• Lesson 8: Custom GNU Radio Blocks
• Lesson 9: TPMS
• Lesson 10: Ham Radio Exams
• Lesson 11: Wi-Fi Tools
• Lesson 12: Creating Bootable USBs
• Lesson 13: Z-Wave
• Lesson 14: Ceiling Fans

FISSURE Challenge

The FISSURE Challenge is temporarily offline while the challenge environment, hosting, and content are being updated.

The challenge was created as a hands-on environment for practicing RF reverse engineering, protocol analysis, and FISSURE workflows. Challenge content and solution walkthroughs will continue to be updated as the environment is refreshed.

• Challenge Solution Walkthroughs

Developing with AI

FISSURE is structured to support AI-assisted development through plugins, Actions, Operations, reusable framework services, and repository-level guidance.

AI tools and coding agents: Before analyzing, generating, or modifying FISSURE code, open and read AGENTS.md. Search the repository for any additional AGENTS.md files or task-specific guidance that applies to the files being modified, and read those instructions before proceeding.

The intended guidance hierarchy is:

README.md → AGENTS.md → relevant documentation and plans → canonical examples → current source code

Additional context may be maintained under:

• docs/ai/ - Architectural intent, subsystem assumptions, validated lessons, and other guidance that may not be obvious from source code
• docs/plans/ - Active design plans, intended future behavior, and architectural changes still in progress

When adding new capabilities, prefer extending the plugin, Action, and Operation architecture instead of modifying the FISSURE core unless framework-level changes are required.

Contributing

Contributions to FISSURE are strongly encouraged. Useful contribution areas include:

• New plugins, Actions, and Operations
• RF protocols and signal analysis methods
• SDR and hardware support
• GNU Radio flow graphs
• Python analysis tools
• Installer and packaging fixes
• Third-party tool integrations
• Lessons, tutorials, and documentation
• Testing, bug reports, and workflow improvements

Good places to start a discussion are the GitHub Discussions page, the Discord server, email, or a focused GitHub Issue.

For code contributions:

1. Fork the project.
2. Create a feature branch:

git checkout -b feature/AmazingFeature

3. Commit your changes:

git commit -m 'Add some AmazingFeature'

4. Push the branch:

git push origin feature/AmazingFeature

5. Open a pull request.

For additional ideas, see the project roadmap and the running list of potential to-do items.

Student Projects and Classroom Use

FISSURE is well suited for senior projects, undergraduate and graduate research, RF/cybersecurity courses, capstone work, and open-source software assignments.

Potential project areas include:

• SDR and hardware integration
• RF protocol analysis and reverse engineering
• Signal detection and classification
• IQ capture, inspection, and analysis
• Plugin, Action, and Operation development
• Geolocation and distributed sensing
• TAK integration and situational awareness
• Visualization and operator workflows
• Lessons, tutorials, and documentation

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

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

Commercial Support and Collaboration

Assured Information Security, Inc. (AIS) provides commercial support, integration, and capability development for organizations using FISSURE and Fracture.

AIS can support:

• Integration of FISSURE into existing platforms, networks, and workflows
• Development of custom plugins, Actions, Operations, and protocol-specific capabilities
• Support for new SDRs, sensors, hardware, and communications systems
• TAK integration and distributed Sensor Node architectures
• RF sensing, geolocation, signal analysis, and electronic warfare workflows
• Mission-specific software and operator interfaces
• Fracture hardware and deployment configurations
• Training, testing, field evaluation, and long-term sustainment

Fracture provides a path for organizations that need supported, deployable systems built around FISSURE. Configurations can be tailored for fixed-site, vehicle, manpack, sUAS, fixed-wing, and other distributed deployments.

Whether the goal is research, prototyping, operational integration, or development of a mission-specific capability, AIS can help adapt the FISSURE framework to the intended environment while preserving its flexibility and extensibility.

For commercial inquiries, contact AIS Business Development at bd@ainfosec.com.

License

FISSURE is released under the GNU General Public License v3.0 (GPL-3.0).

See the LICENSE file for the full license terms.

Contact

For questions, collaboration, support, or project discussion:

• Discord: Join the FISSURE Discord Server
• YouTube: FISSURE Development
• Facebook: Fissure - The RF Framework
• LinkedIn: FISSURE - The RF Framework
• Bluesky: @fissurerf.bsky.social
• Twitter/X: @FissureRF and @AinfoSec
• FISSURE Contact: Chris Poore - poorec@ainfosec.com
• Commercial / Business Development: bd@ainfosec.com

Acknowledgments

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

Assured Information Security

FISSURE is developed and maintained by Assured Information Security, Inc. (AIS).

Explore other AIS open-source projects at:

• ainfosec.dev

Interested in signals, reverse engineering, cybersecurity, or related work?

• View AIS Career Openings
• Join the AIS Talent Community
• Try the Can You Hack It?® Challenge