Radio Protocols
- Why this matters
- Software-defined radio in one page
- Identifying a modulation by eye
- The protocols
- Key takeaways
- References
Why this matters
Every technique up to this point required touching the device. This one does not.
A radio link is an attack surface that extends as far as the signal does, against a target that has no way to know you are listening. And the constraints that make IoT radios cheap — tiny power budgets, kilobytes of RAM, no real-time clock, no reliable persistent storage — are exactly the constraints that make their security hard to get right.
⚠️ Receiving is not transmitting. Passive reception across most of the spectrum is legal in the US. Transmitting is licensed, and transmitting on bands you are not licensed for is a federal offence. The 915 MHz ISM band this course uses permits unlicensed operation under FCC Part 15 within power and duty-cycle limits. Stay inside them, transmit only with course hardware in lab, and never replay traffic from a device that is not yours.
Software-defined radio in one page
An SDR moves the demodulation into software. The hardware down-converts a slice of spectrum to baseband, digitises it, and hands you complex samples; what those samples mean is your problem, which is precisely why it is useful for protocols nobody has written a receiver for.
IQ data
Samples arrive as pairs — in-phase and quadrature — which together encode both amplitude and phase. A stream of real samples cannot distinguish a signal above the centre frequency from one below it; the quadrature component is what resolves the ambiguity. Practically: a “1 MS/s” SDR capture is one million complex samples per second, and each is two numbers.
The three parameters
Every capture is defined by three numbers, and getting them wrong wastes the capture:
| Parameter | Controls | Failure if wrong |
|---|---|---|
| Centre frequency | Where you are looking | Signal outside your window; you see nothing |
| Sample rate | Observable bandwidth (Nyquist: complex rate = bandwidth) | Signal wider than your window; you capture a fragment |
| Gain | Where the signal sits between noise floor and clipping | Too low: buried. Too high: artifacts everywhere |
Gain is the one beginners get wrong. Turned to maximum, the front end clips, and intermodulation products appear across the whole band as signals that are not there. Students then spend an afternoon chasing transmitters that do not exist. Set gain so the noise floor is visible and the strongest real signal does not saturate.
For a 125 kHz LoRa channel you need at least 125 kS/s by Nyquist, and realistically 250 kS/s or more for margin against filter roll-off at the edges.
Identifying a modulation by eye
Before demodulating anything, classify it. A waterfall and a time-domain amplitude plot get you most of the way:
| Appearance | Likely modulation | Common in |
|---|---|---|
| Single line, blinking on and off | OOK / ASK | Cheap remotes, doorbells, TPMS |
| Two parallel lines alternating | 2-FSK | Sub-GHz sensors, garage doors |
| A band that fills solidly | Wideband FSK / GFSK | BLE, proprietary links |
| Diagonal sweeps, sawtooth | Chirp spread spectrum | LoRa |
| Hopping across a band | FHSS | Bluetooth Classic, some industrial |
The diagonal-sweep signature is diagnostic, and it is why LoRa is such a good teaching target: you can see the modulation in a waterfall, which makes the concept concrete in a way a constellation diagram does not.
Tools
Universal Radio Hacker is the right starting point. It demodulates with automatic parameter detection, lets you assign protocol fields by hand or infer them, handles custom encodings including CC1101 data whitening, and includes fuzzing and a stateful simulator. The USENIX WOOT ‘18 paper describes the design.
GNU Radio is the general signal-processing framework — a dataflow graph of blocks. More work than URH for protocol analysis, and the right answer when you need something URH does not do.
rtl_433 decodes hundreds of sub-GHz sensor protocols out of the box. Try
it before writing anything: many “unknown” devices are already supported.
Choosing a radio
That software needs something to feed it, and the hardware divides into two categories that are easy to confuse and are not interchangeable.
General-purpose SDRs digitise a slice of spectrum and hand you the samples. They know nothing about protocols, which is the entire point: anything inside the tuned bandwidth is visible, including modulations nobody has identified yet. The cost is that you must do all the demodulation yourself, and that the cheap ones sample at 8 bits, which limits dynamic range — a strong signal nearby can bury a weak one you care about. Paying more mostly buys bits, duplex, and an FPGA, in that order.
Tuned transceivers are single-purpose chips. A CC1101 does OOK/ASK, 2-FSK, GFSK, 4-FSK, and MSK, at 0.6–600 kb/s, in three sub-GHz bands, and nothing else — it will never show you a LoRa chirp or a BLE packet, no matter what firmware you flash. In exchange it is cheap, runs from a battery, demodulates in hardware, and transmits a clean signal without you writing a line of DSP.
Everything below is one or the other, and the split is the first decision.
General-purpose SDRs
| Device | Tuning range | Max sample rate | ADC | Duplex | Rough cost |
|---|---|---|---|---|---|
| RTL-SDR | 24 MHz – 1.7 GHz | ~2.4 Msps | 8-bit | Receive only | ~$30 |
| CaribouLite (Pi HAT) | 30 MHz – 6 GHz, two receivers | 4 Msps | 13-bit | Half | ~$119 |
| HackRF One | 1 MHz – 6 GHz | 20 Msps | 8-bit | Half | ~$450 |
| HackRF Pro | 100 kHz – 6 GHz | 20 Msps | 8-bit, 16-bit at low rates | Half | ~$500 |
| LimeSDR USB | 100 kHz – 3.8 GHz | 61.44 Msps | 12-bit | Full, 2×2 | ~$625 |
| bladeRF 2.0 micro xA9 | 47 MHz – 6 GHz (RX from 70 MHz) | 61.44 Msps | 12-bit | Full, 2×2 | ~$860 |
| USRP B210 | 70 MHz – 6 GHz | 61.44 Msps, 56 MHz filtered | 12-bit | Full, 2×2 | ~$2,000 |
Costs are indicative for late 2026. Read the column as an ordering, not a quote.
The CaribouLite sits oddly in that list and is worth a sentence. It reaches 6 GHz for a fraction of a HackRF’s price and is the only entry with two independent receivers, which lets you watch a sub-GHz device and its 2.4 GHz hub at the same time. What it gives up is bandwidth — 4 Msps against the HackRF’s 20 — and independence: it is a Raspberry Pi HAT, not a USB peripheral, so the Pi is part of the radio. Its second receiver also only reaches past 2.5 GHz on the FULL version, and the two share bandwidth when run together. See the CaribouLite page for what that costs in practice.
What the extra money buys is not frequency coverage — everything from the CaribouLite up reaches 6 GHz, give or take a little at the bottom end. It buys four things, roughly in order of how often they matter:
- Four more bits. Twelve-bit samples against eight is about 24 dB more dynamic range. That is the difference between hearing a weak sensor two rooms away and having it buried under the strong transmitter on your bench — which is the single most common reason a capture that “should” work does not.
- Full duplex, two channels of it. 2×2 MIMO means transmitting on one chain while receiving on another, coherently. See the callout below: this changes which attacks are possible at all, not just how convenient they are.
- An FPGA you can program. The xA9’s 301 kLE Cyclone V will hold FFTs, correlators, decimation, and demodulators, so the processing happens on the board instead of across the USB bus. This is the whole difference between the xA9 and the otherwise identical xA4, which has 49 kLE for around $540 — if you are not writing HDL, buy the xA4 and spend the difference on antennas.
- A better clock. A VCTCXO as standard, GPSDO as an option. It matters for anything with tight framing, and for LoRa symbol timing in particular.
For this course, none of that is required: an RTL-SDR does every receive-only exercise, and a HackRF covers the rest. The bigger radios are worth knowing about because published research assumes them — the B210 is the reference platform for UHD and most GNU Radio examples, and is the safe choice if you want someone else’s flowgraph to run unmodified. The bladeRF xA9 gives the most programmable logic per dollar, at the cost of a setup step the others do not have — see Bringing up a bladeRF 2.0 micro below. The LimeSDR sits between them on paper, with the caveat that Lime’s product line was declared end-of-life in 2022 and the USB Type-A board only returned to stock in March 2025 — verify availability before building a lab around one.
Bringing up a bladeRF 2.0 micro
An RTL-SDR is a fixed tuner feeding a fixed ADC: plug it in and it receives. Every FPGA-based board in that table instead needs its gateware put there before it is a radio at all — the LimeSDR and the B210 included — and the one in the course toolkit is a bladeRF 2.0 micro xA9, so it is the worked example here. A bladeRF has no receiver until its FPGA is configured, and the bitstream has to agree with the firmware running on the board’s USB controller. Three pieces of software must match, and two of them live on the board rather than on your machine:
| Piece | Where it lives | Version in release 2025.10 |
|---|---|---|
| FX3 firmware | The board’s USB controller, in flash | 2.6.0 |
| FPGA bitstream | Loaded into the Cyclone V at every power-up | 0.16.0 |
libbladeRF and bladeRF-cli |
The host | 2.6.0 and 1.10.0 |
Nuand ships them as a matched set, so take the whole row or none of it. A board that has sat in a drawer for a few years is running older firmware, and the current bitstream will not initialise against it. The symptom is not a clear error but a warning and an absence:
$ bladeRF-cli -e version
[WARNING] Using legacy message size. Consider upgrading firmware >= v2.5.0 and fpga >= v0.16.0
[WARNING] FPGA bitstream file not found.
[WARNING] Skipping further initialization...
bladeRF-cli version: 1.10.0-git-fcf94233
libbladeRF version: 2.6.0-git-fcf94233
Firmware version: 2.4.0-git-a3d5c55f
FPGA version: Unknown (FPGA not loaded)
The board enumerates on USB and bladeRF-cli -p finds it, and it has no radio
capability whatsoever. “FPGA not loaded” means there is no receiver — read
it as a hard failure, not as a warning to push past. Two independent causes
produce the same line, and they need separating before you start flashing
anything.
The bitstream is on disk but not where libbladeRF looks. The library
searches $BLADERF_SEARCH_DIR, the working directory, the program’s own
directory, then ~/.config/Nuand/bladeRF/, ~/.Nuand/bladeRF/,
/usr/share/Nuand/bladeRF/, and /etc/Nuand/bladeRF/. Distribution packaging
does not always agree with that list — Arch’s bladerf package, for one,
installs to /usr/share/bladerf/fpga/ — which produces “bitstream file not
found” with the file sitting plainly on the disk. Point the search at it rather
than copying files around, so package upgrades still take effect:
$ ln -s /usr/share/bladerf/fpga ~/.config/Nuand/bladeRF
Alternatively, name the bitstream explicitly with -l, or write it to the
board’s own flash once with -L so the firmware loads it at power-up and the
host no longer needs the file at all:
$ bladeRF-cli -l /usr/share/bladerf/fpga/hostedxA9.rbf -e version # this run only
$ bladeRF-cli -L /usr/share/bladerf/fpga/hostedxA9.rbf # persistent
Match the file to the board: hostedxA9.rbf for the 301 kLE part,
hostedxA4.rbf for the 49 kLE one. Flashing the wrong size fails to configure.
bladeRF-cli -L X erases the stored image and returns to host loading, which
Nuand recommends doing before a firmware upgrade.
The firmware is older than the bitstream requires. That is the case above: firmware 2.4.0 against bitstream 0.16.0, which wants 2.6.0. Writing firmware is one command, and then a detail that costs people an hour:
$ bladeRF-cli -f /usr/share/bladerf/firmware/bladeRF_fw_v2.6.0.img
⚠️ A firmware write needs a physical unplug and replug. The FX3 loads its firmware only at power-on, so nothing software-side substitutes — not a USB reset, not re-opening the device. The board will keep reporting the old version until it has actually lost power. In particular, do not reach for
jump_to_boothoping it will do the job: it clears the firmware signature to enter the recovery bootloader, which is a different operation with a different recovery path.
Once firmware and bitstream agree, the same version command says so, and
info confirms which board you have:
$ bladeRF-cli -e version -e info
Firmware version: 2.6.0-git-09c82087
FPGA version: 0.16.0 (configured from SPI flash)
Board: Nuand bladeRF 2.0 (bladerf2)
Serial #: 872876ec…2f57
VCTCXO DAC calibration: 0x1eb7
FPGA size: 301 KLE
FPGA loaded: yes
Flash size: 128 Mbit
USB speed: SuperSpeed
Two fields there are worth reading carefully. configured from SPI flash
means autoload worked; configured by USB host means the host supplied the
bitstream this run and will have to again next time. And USB speed must
read SuperSpeed — on a USB 2.0 link the board still works, but 61.44 Msps of
12-bit complex samples is roughly 1.9 Gb/s of bus traffic, so you will see
overruns long before you reach the top sample rate and blame the radio for a
cable problem.
Prove the data path before you trust a capture. A bladeRF can hand you a file full of plausible-looking samples while quietly dropping some of them, and a dropped sample in the middle of a packet looks exactly like a protocol you have not understood yet. The FPGA can substitute a 32-bit counter for the ADC, which makes the question decidable: every sample should be exactly one more than the last.
$ bladeRF-cli -e "set samplerate rx 61440000; set rx_mux 32BIT_COUNTER; \
rx config file=counter.bin format=bin n=20M; rx start; rx wait"
Then check it — twenty million samples is too many to eyeball:
$ python3 -c "
import numpy as np
a = np.fromfile('counter.bin', dtype='<u4')
d = np.diff(a.astype(np.int64))
print(a.size, 'samples,', np.count_nonzero(d != 1), 'increments != 1')"
20971520 samples, 0 increments != 1
Zero means the USB link, the host buffers and your storage all kept up at the
full 61.44 Msps. Any other number, and reduce the sample rate or write to
/dev/shm before you interpret a single real capture. Run this once on a new
machine, and again whenever captures start producing bit errors that were not
there last week — it separates a radio problem from a host problem in about
thirty seconds. The same rx_mux setting is how you check a flowgraph is
reading samples in the order and format you think it is.
Finally, ask the board for its own limits rather than trusting the single
tuning range quoted in the table above. Every print reports the valid range
alongside the current value:
$ bladeRF-cli -e "print frequency" -e "print samplerate"
RX1 Frequency: 2400000000 Hz (Range: [70000000, 6000000000])
TX1 Frequency: 2400000000 Hz (Range: [47000000, 6000000000])
RX1 sample rate: 30720000 0/1 (Range: [520834, 61440000])
Receive starts at 70 MHz and transmit at 47 MHz. The AD9361’s receive chain is specified from 70 MHz; the extra transmit coverage is the board’s, not the chip’s. To receive below 70 MHz you want an RTL-SDR in direct-sampling mode or a HackRF instead. The minimum sample rate of 520,834 S/s matters too: a 125 kHz LoRa channel is comfortable, but you cannot narrow the window as far as an RTL-SDR will go, so expect to decimate in software rather than in the radio.
💡
bladeRF-cliaborts the rest of an-escript on the first failed command, and still exits 0.set gainfails while AGC is enabled, so a sweep written asset gain …; set frequency …; rx startsilently does nothing past the gain line and looks like a clean pass. Putset agc rx1 offfirst, and note thatset agc rx offaffects RX1 only — RX2 needs its ownset agc rx2 off. Check for the output you expected, not for a zero exit status.
Tuned transceivers
| Device | Radios | Coverage | Transmit | Rough cost |
|---|---|---|---|---|
| Flipper Zero | CC1101 + STM32WB55 BLE | 300–348 / 387–464 / 779–928 MHz | Sub-GHz, region-limited | ~$170 |
| Evil Crow RF v2 | Two CC1101 + one nRF24L01 | The same three bands, plus 2.4 GHz | Yes, on both | ~$60 |
⚠️ Duplex decides which attacks are possible, not merely convenient. Both HackRFs transmit or receive, never both at once. An attack that jams a receiver while simultaneously capturing the legitimate transmitter therefore needs either two radios or one full-duplex radio. That is why the Evil Crow RF v2 carries two independent CC1101s — and why a bladeRF, LimeSDR, or B210 can do the same job in a single box, at ten to thirty times the price. Check the duplex column before assuming an attack you have read about will work with the radio on your desk.
The Flipper Zero deserves a note because students will bring them to class. Its sub-GHz side is a CC1101 — the same chip, the same three bands, the same modulation list as the Evil Crow — wrapped in a usable interface, so it is a genuinely good capture-and-identify tool. Two limits to understand before relying on it: transmission is restricted to frequencies permitted in the provisioned region, and the official firmware deliberately will not save or replay a rolling code. Its 2.4 GHz radio is the STM32WB55’s BLE core, not an nRF24, so the Unifying work needs an external module.
The protocols
Each of these has its own page with the radio layer, the data-security model, and the failure modes worked through in detail. This table is the map.
| Protocol | Band | Hops? | Security model | Page |
|---|---|---|---|---|
| WiFi | 2.4 / 5 / 6 GHz | No | WPA2-PSK or WPA3-SAE | WiFi |
| Bluetooth Classic | 2.4 GHz | 1600/s | Pairing-model dependent | Bluetooth |
| Bluetooth LE | 2.4 GHz | Per connection event | LE Legacy or LE Secure Connections | Bluetooth |
| Zigbee | 2.4 GHz | No | One shared network key | Zigbee |
| Thread | 2.4 GHz | No | Shared network key + PAKE join | Thread and Matter |
| Matter | over Thread/WiFi | — | Per-device certificates | Thread and Matter |
| Z-Wave | Sub-GHz, narrowband | No | S0 (broken bootstrap) or S2 | Z-Wave |
| LoRa | Sub-GHz, CSS | No | None | LoRa and LoRaWAN |
| LoRaWAN | — | — | AES-128 + frame counters | LoRa and LoRaWAN |
| The long tail | 315/433 MHz, 2.4 GHz | Varies | Usually none | Other IoT radios |
How hard is each one to capture?
This is the question that determines what you can actually do in an afternoon, and it has little to do with how secure the protocol is:
| Difficulty | Protocols | Why |
|---|---|---|
| Trivial | Fixed-code remotes, TPMS, Z-Wave, LoRa | Narrowband, no hopping, RTL-SDR territory |
| Easy | Zigbee, Thread, BLE advertising | No hopping; a $20 dongle sees everything on a channel |
| Moderate | BLE connections | Must catch the connection setup to follow the hop sequence |
| Hard | WiFi | 20 MHz OFDM — needs a monitor-mode chipset, not an SDR |
| Hard | Bluetooth Classic | 1600 hops/s across 79 channels |
| Awkward | nRF24 / Unifying | Needs a promiscuous-mode research dongle |
The patterns worth carrying between them
Six protocols designed by six independent groups, and the same handful of mistakes recur. Notice these as you read the detail pages — they are the actual content of the course, and the protocol specifics are the illustrations:
Bootstrapping is where key distribution fails. Zigbee shipped the default
link key ZigBeeAlliance09 in a public specification. Z-Wave S0 wraps the
network key under an all-zeros constant. In both cases the cryptography is
sound and the first handshake gives everything away. The fix, in both, is a
per-device secret delivered out of band — install codes, DSK QR codes — and
that is also what Matter and
WPA3 do.
Unauthenticated negotiation sets security to the weakest supported mode. WPA3 transition mode, Bluetooth’s BIAS downgrade, Z-Wave’s Z-Shave, Zigbee’s legacy joining. Supporting an old device and supporting an attacker are frequently the same code path.
Replay protection is state, and embedded devices are bad at state. Counters must survive power loss, so they live in flash, and flash wears out. Vendors write lazily, skip forward, or reset — and then choose availability over rejecting a rebooted node. This appears identically in LoRaWAN, Zigbee and Z-Wave.
Proximity is not authentication. Zigbee Touchlink enforces “nearby” with transmit power, which an amplifier defeats. Car keys and BLE proximity unlock have the same problem, which is why Channel Sounding had to be invented.
Headers must be plaintext, so metadata always leaks. Routing happens before decryption. Z-Wave HomeIDs, LoRaWAN DevAddrs, BLE addresses, and TPMS sensor IDs are all readable with no key, and all enable tracking. Payload confidentiality is not privacy.
The keys are in a flash chip you can read. The most common real compromise in every one of these protocols is not cryptanalysis — it is recovering the key from unprotected storage. Everything in Dumping flash applies to all of them, and this is why the hardware half of the course is not separate from the radio half.
Key takeaways
- Radio attacks require no physical access, and the constraints that make IoT radios cheap are what make their security hard.
- Three parameters define a capture; gain is the one people get wrong, and saturation artifacts look exactly like real signals.
- Classify modulation from the waterfall before demodulating. LoRa’s diagonal chirps are unmistakable.
- Capture difficulty tracks channel width and hopping, not security: WiFi is the hardest to sniff and Z-Wave among the easiest.
- A general-purpose SDR sees anything but demodulates nothing for you; a tuned transceiver like the CC1101 does one modulation family well and is blind to everything else. Pick against the protocol, not the price.
- Duplex and bit depth matter more than tuning range. Simultaneous jam-and- capture needs two radios or one full-duplex radio; 12-bit samples buy ~24 dB of dynamic range over 8-bit, which is why weak signals vanish on a HackRF.
- Bootstrapping, unauthenticated downgrade, counter persistence, proximity as authentication, and plaintext headers are the five recurring failures. They are protocol-independent.
- Whatever the protocol, the keys are usually recoverable from flash.
References
- Universal Radio Hacker — https://github.com/jopohl/urh
- Universal Radio Hacker, USENIX WOOT ‘18 paper — https://www.usenix.org/system/files/conference/woot18/woot18-paper-pohl.pdf
- GNU Radio — https://www.gnuradio.org/
- rtl-sdr project — https://www.rtl-sdr.com/
- rtl_433 sub-GHz decoder — https://github.com/merbanan/rtl_433
- Great Scott Gadgets, HackRF One — https://greatscottgadgets.com/hackrf/one/
- Great Scott Gadgets, HackRF Pro — https://greatscottgadgets.com/hackrf/pro/
- Nuand bladeRF 2.0 micro — https://www.nuand.com/bladerf-2-0-micro/
- Nuand, upgrading bladeRF FX3 firmware — https://github.com/Nuand/bladeRF/wiki/Upgrading-bladeRF-FX3-Firmware
- Nuand, bladeRF FPGA autoloading and bitstream search path — https://github.com/Nuand/bladeRF/wiki/FPGA-Autoloading
- Nuand bladeRF FPGA images — https://www.nuand.com/fpga/
- Nuand bladeRF FX3 firmware images — https://www.nuand.com/fx3/
- bladeRF release 2025.10, the matched firmware/FPGA/host version set — https://github.com/Nuand/bladeRF/releases/tag/2025.10
- PySDR, the bladeRF chapter — https://pysdr.org/content/bladerf.html
- Ettus Research USRP B210 — https://www.ettus.com/all-products/ub210-kit/
- Lime Microsystems LimeSDR USB — https://limemicro.com/sdr/limesdr-usb/
- Texas Instruments CC1101 low-power sub-1 GHz RF transceiver — https://www.ti.com/product/CC1101
- Flipper Zero sub-GHz documentation — https://docs.flipper.net/sub-ghz
- inspectrum, offline signal analysis — https://github.com/miek/inspectrum
- IEEE 802.15.4 — https://standards.ieee.org/ieee/802.15.4/7029/
- OWASP IoT Security Testing Guide — https://owasp.org/www-project-iot-security-testing-guide/
- FCC Part 15 rules (47 CFR Part 15) — https://www.ecfr.gov/current/title-47/chapter-I/subchapter-A/part-15
Related course pages: WiFi · Bluetooth · Zigbee · Z-Wave · Thread and Matter · LoRa and LoRaWAN · Other IoT radios · Schedule · HW #4 · Lab 3
🛠️ Maintenance note: this page is now a map — the protocol detail, and the version claims that age with it, live on the individual pages, so check their maintenance notes rather than this one. What needs re-verifying here is the SDR tooling (URH and GNU Radio both move) and the capture-difficulty table, which shifts as cheap multiprotocol sniffers appear. The hardware table under Choosing a radio is the fastest-moving content on the page and should be re-checked every offering: the HackRF Pro was announced in mid-2025 and its firmware and price are still settling, every figure in the cost columns needs re-quoting, the bladeRF version set under Bringing up a bladeRF 2.0 micro is release 2025.10 and advances roughly yearly — the procedure outlives the numbers, but the numbers do not — Flipper firmware capabilities change with each release (and differ sharply between official and community builds), and boards in the Evil Crow class appear and disappear quickly. The underlying point — general-purpose SDR versus tuned transceiver, and half-duplex versus two independent radios — outlives any particular product in the table.