FISSURE - The RF Framework

Frequency Independent SDR-based Signal Understanding and Reverse Engineering

Tactical Workflow Demo (GRCon26)

GRCon26 Presentation

Operational Overview

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.

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.

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.

• 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.}

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.

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.

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.

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

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

• View Interactive Roadmap

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

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

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

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

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

• FISSURE Info Sheet
• AIS FISSURE Page

• FISSURE Documentation

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:

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

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

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

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.

The following operating systems are still being tested and may have missing functionality, installer conflicts, or unsupported third-party tools.

Some third-party tools are not available on every operating system. Refer to Known Conflicts and Third-Party Software for details.

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.

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.

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

• Run the installer and FISSURE from a user-owned directory such as your home directory. Do not run ./install or fissure with sudo.
• The installer will automatically detect the operating system when possible and select the closest supported configuration.
• Choose the installation mode that matches the intended role:
  • Full for the broadest installation
  • Base for a complete standalone workstation
  • Dashboard, HIPRFISR, or Sensor Node for role-specific systems
  • Custom for a user-defined selection
• Radio drivers, out-of-tree modules, and optional third-party tools can be installed as needed for the desired hardware and workflows.
• Some installer items are unchecked by default because they may be unsupported, conflict with other software, or require additional setup.
• Items with a Verify step are checked after installation and highlighted based on whether the verification command succeeds.
• GNU Radio flow graphs may need to be recompiled when moving between GNU Radio versions.
• Third-party software is generally downloaded to and installed from ~/Installed_by_FISSURE.
• Make sure the system clock is correct before installing to avoid package repository errors.

_{Select the operating system and installation mode.}

_{Select software, hardware support, optional components, and review the installation commands.}

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.

Configure the remote Sensor Node in:

./YAML/Sensor_Node_Config/default.yaml

Update the following fields:

• nickname - Use a unique name other than Local Sensor Node
• hiprfisr_ip_address - IP address of the HIPRFISR / Hub
• hardware - Configure the hardware available on the node
• autorun - Set to true to automatically launch the default Autorun playlist when the Sensor Node starts

Autorun provides unattended execution of saved plugin Action sequences without requiring the Dashboard to remain connected. Playlists can include per-Action timing and optional detector gating.

Remote Sensor Nodes use certificates generated during installation to authenticate with the client.

The Sensor Node requires:

• server.key_secret
• client.key

The client requires:

• client.key_secret
• server.key

If the certificate directory was generated on the Sensor Node, copy the required client files to the Dashboard system before connecting.

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>

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

Launch the hub with:

fissure-hiprfisr

The hub will start its configured services, connect to TAK when enabled, and accept connections from remote Sensor Nodes without requiring the Dashboard to remain open.

After configuring the Sensor Node, launch it from a terminal with:

fissure-sensor-node

The Sensor Node will connect to the configured HIPRFISR / Hub and remain active until Ctrl+C is applied.

Once connected, the node will appear in FISSURE and can be selected and tasked through the Dashboard and supported workflows. Multiple remote Sensor Nodes can be connected simultaneously, with individual workflows determining whether operations run on a single node or coordinate across multiple nodes.

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

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

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

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

FISSURE is structured to work well with AI-assisted development because capabilities are increasingly separated into plugins, Actions, Operations, UI components, and reusable framework services.

For larger changes, the easiest approach is usually to zip the relevant project directories and upload the archive directly to the AI tool. This gives it enough context to understand the surrounding structure, follow existing patterns, and make changes that fit the rest of the codebase.

Useful directories to include are:

• fissure/ - Core application code, services, callbacks, and shared framework logic
• Plugins/ - Plugin Actions, Operations, schemas, setup logic, and examples
• UI/ - Dashboard UI files, widgets, and styling
• YAML/ - Configuration, library data, and supporting definitions

For smaller changes, zip only the affected files and directories plus one or two nearby working examples.

FISSURE is also moving toward richer, structured Artifacts that preserve signal context, parameters, results, provenance, and supporting data. The goal is to make useful outputs easier to copy or provide directly to AI tools for analysis without manually reconstructing the surrounding context.

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

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.

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.

“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

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.

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

See the LICENSE file for the full license terms.

For questions, collaboration, support, or project discussion:

• Discord: Join the FISSURE Discord Server
• 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

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

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