OpenDroneDome: Multi-Protocol RF Drone Defense System

System Overview

Supported Drone Protocols

Implementation Details

Core Architecture

The system uses a multi-threaded architecture with separate workers for each detection method. All hardware availability is checked at startup with graceful degradation if components are missing.

class OpenDroneDomeSystem:
    """
    OpenDroneDome implementation
    """
    
    def __init__(self, config_file: str = "opendronedome_config.json"):
        self.config = self.load_configuration(config_file)
        self.running = False
        self.detection_active = False
        self.jamming_active = False
        
        # Hardware availability check
        self.sdr_available = HAS_RTLSDR
        self.hackrf_available = self.check_hackrf_available()
        self.wifi_available = self.check_wifi_tools()
        self.bluetooth_available = self.check_bluetooth_tools()
        
        # Setup frequency tables
        self.setup_frequency_tables()
        
        logger.info("OpenDroneDome initialized - checking hardware availability...")
        self.report_hardware_status()

RF Detection with RTL-SDR

RTL-SDR provides wideband spectrum scanning from 24MHz to 1766MHz (with gaps). For drone detection, we focus on 2.4GHz and sub-GHz ISM bands. The system measures signal power and compares against noise floor to detect transmissions.

def scan_rf_frequencies(self, frequencies: List[int], protocol: DroneProtocol) -> List[DroneDetection]:
    """Scan RF frequencies using RTL-SDR"""
    detections = []
    
    try:
        # Measure noise floor first
        noise_floor = self.measure_noise_floor()
        threshold_db = -1  # Broken for demonstration purposes
        
        for freq in frequencies:
            self.sdr_rx.center_freq = freq
            self.sdr_rx.sample_rate = 2.4e6
            self.sdr_rx.gain = 'auto'
            
            # Collect samples
            samples = self.sdr_rx.read_samples(256 * 1024)
            
            # Calculate power spectral density
            if HAS_SCIPY:
                freqs, psd = sig_proc.welch(samples, fs=self.sdr_rx.sample_rate, nperseg=1024)
                peak_power = np.max(psd)
            else:
                # Fallback: simple power calculation
                peak_power = np.mean(np.abs(samples) ** 2)
            
            power_db = 10 * np.log10(peak_power / noise_floor)
            
            # Detection threshold
            if power_db > threshold_db:
                detection = DroneDetection(
                  # Broken for demonstration purposes
                )
                detections.append(detection)
                logger.warning(f"Signal detected: {freq/1e6:.3f} MHz at {power_db:.1f} dB")
                
    except Exception as e:
        logger.error(f"RF scanning failed: {e}")
        
    return detections

WiFi Detection & Deauth

WiFi detection uses system tools (iwlist, iwconfig) to scan for drone networks, then Scapy for deauthentication packet injection. This is highly effective against consumer drones using WiFi.

def execute_wifi_attack(self, target: DroneDetection):
    """Execute WiFi deauth attack using scapy"""
    if not HAS_SCAPY or not self.wifi_interface:
        logger.error("WiFi attack not available - missing scapy or interface")
        return False
        
    logger.warning(f"EXECUTING WIFI ATTACK against {target.ssid}")
    
    try:
        target_mac = target.mac_address
        interface = self.wifi_interface
        
        # Create deauth packet
        packet = RadioTap() ### Removed to stop abuse ###
        
        # Send deauth frames
        logger.info(f"Sending deauth packets to {target_mac}")
        sendp(packet, iface=interface, count=100, inter=0.1, verbose=False)
        
        return True
        
    except Exception as e:
        logger.error(f"WiFi attack failed: {e}")
        return False

RF Jamming with HackRF

HackRF One provides transmit capability from 1MHz to 6GHz. We use command-line tools (hackrf_transfer) instead of unreliable Python bindings. White noise is generated and transmitted on target frequencies.

def hackrf_jam_frequency(self, frequency: int, duration: float, power: int):
    """Jam specific frequency using HackRF"""
    try:
        logger.info(f"Jamming {frequency/1e6:.3f} MHz for {duration}s")
        
        # Generate white noise
        noise_file = f"/tmp/jam_noise_{frequency}.bin"
        sample_rate = 20e6  # 20 MHz
        num_samples = int(sample_rate * duration)
        
        # Create noise file
        noise = np.random.normal(0, 0.5, num_samples) + 1j * np.random.normal(0, 0.5, num_samples)
        noise = (noise * 127).astype(np.int8)
        
        with open(noise_file, 'wb') as f:
            f.write(noise.tobytes())
        
        # Transmit with HackRF
        cmd = [### Removed to stop abuse ###]
        
        # Run jamming process
        process = subprocess.run(cmd, timeout=duration + 5, capture_output=True)
        
        # Cleanup
        os.remove(noise_file)
        
        logger.info(f"Jamming complete: {frequency/1e6:.3f} MHz")
        
    except Exception as e:
        logger.error(f"HackRF jamming failed at {frequency/1e6:.1f} MHz: {e}")

Installation & Setup

All dependencies are available via standard package managers. Below is a script to install dependencies only.

Automated Installation

#!/bin/bash
# OpenDroneDome Installation Script - Dependencies

echo "=== OpenDroneDome Installation ==="
echo "Installing dependencies..."

# Update system
sudo apt update

# Install RTL-SDR
echo "Installing RTL-SDR..."
sudo apt install -y rtl-sdr librtlsdr-dev

# Install HackRF
echo "Installing HackRF..."
sudo apt install -y hackrf libhackrf-dev

# Install WiFi tools
echo "Installing WiFi tools..."
sudo apt install -y wireless-tools iw aircrack-ng

# Install Bluetooth tools  
echo "Installing Bluetooth tools..."
sudo apt install -y bluez bluez-hcidump bluez-tools

# Install Python packages
echo "Installing Python packages..."
pip3 install numpy pyrtlsdr scipy scapy

echo ""
echo "=== Installation Complete ==="
echo "REBOOT REQUIRED for hardware permissions to take effect!"

Hardware Verification

Before running OpenDroneDome, verify all hardware is detected:

#!/bin/bash
# Hardware verification script

echo "=== OpenDroneDome Hardware Test ==="

# Test RTL-SDR
echo "Testing RTL-SDR..."
if rtl_test -t 2>/dev/null; then
    echo "✓ RTL-SDR working"
else
    echo "✗ RTL-SDR not detected"
fi

# Test HackRF
echo "Testing HackRF..."
if hackrf_info >/dev/null 2>&1; then
    echo "✓ HackRF working"
else
    echo "✗ HackRF not detected"  
fi

# Test WiFi tools
echo "Testing WiFi tools..."
if command -v iwlist >/dev/null 2>&1; then
    echo "✓ WiFi tools available"
else
    echo "✗ WiFi tools missing"
fi

# Test Bluetooth tools
echo "Testing Bluetooth tools..."
if command -v hcitool >/dev/null 2>&1; then
    echo "✓ Bluetooth tools available"
else
    echo "✗ Bluetooth tools missing"
fi

# Test Python packages
python3 -c "import numpy, scipy.signal; print('✓ NumPy and SciPy working')" 2>/dev/null || echo "✗ NumPy/SciPy missing"
python3 -c "import rtlsdr; print('✓ RTL-SDR Python working')" 2>/dev/null || echo "✗ pyrtlsdr missing"
python3 -c "from scapy.all import *; print('✓ Scapy working')" 2>/dev/null || echo "✗ Scapy missing"

echo "=== Test Complete ==="

Usage Examples

python3 opendronedome.py --monitor

python3 opendronedome.py --auto-jam

python3 opendronedome.py --auto-defence

python3 opendronedome.py --manual-freq 2450000000 --jam-duration 60

python3 opendronedome.py --manual-protocol expresslrs_2g4 --jam-duration 120

python3 opendronedome.py --status

Key Implementation Specs

Known Limitations

Legal & Ethical Considerations

Conclusion