Monitoring BLE with an Ubertooth
- Why this matters
- What the hardware actually is
- The three advertising channels
- Sniffing advertisements
- Getting the capture into Wireshark
- Following connections
- Where the Ubertooth stops, and what to use instead
- Option: Nordic’s nRF Sniffer on an nRF52840
- The rest of the toolkit
- Scope and legality
- Addendum: Classic Bluetooth (BR/EDR) with the Ubertooth
- Key takeaways
- References
Why this matters
Bluetooth Low Energy is how most consumer IoT devices talk to a phone. Locks, scales, thermometers, trackers, toothbrushes, insulin pumps — if it has an app and no Wi-Fi credentials, it is almost certainly BLE. So being able to watch BLE traffic is the single most useful radio skill for this course.
The Ubertooth One is the cheap way in. It is not the best BLE sniffer you can buy, and this page is as much about where it stops working as about how to drive it — because knowing the limits of your instrument is the difference between “the device is secure” and “my sniffer missed it.”
The protocol itself — GATT, pairing, the LE security modes, and attacks like KNOB and BIAS — is on the Bluetooth page. This one is about the hardware and the capture.
What the hardware actually is
An Ubertooth One is an NXP LPC175x (ARM Cortex-M3, full-speed USB) driving a Texas Instruments CC2400 transceiver behind a CC2591 front end, with an RP-SMA antenna connector. It is a 2.4 GHz radio with Bluetooth-ish framing support in hardware, not a general-purpose SDR — you cannot ask it for raw samples the way you can a HackRF.
That single radio is the root of nearly every limitation below. It listens to one channel at a time.
$ ubertooth-util -v
Firmware version: 2020-12-R1 (API:1.07)
$ ubertooth-util -V
ubertooth 2020-12-R1 (mikeryan@steel) Fri Dec 25 13:55:05 PST 2020
The host tools and the firmware must be the same release. 2020-12-R1 is
the current one and has been for years. If the versions disagree the tools
refuse to run, and the fix is to flash the matching firmware rather than to
argue with it:
$ ubertooth-dfu -d bluetooth_rxtx.dfu -r
Be careful with that command: -d downloads to the device — it writes
firmware. -u is the one that reads firmware out. Getting them backwards
overwrites a working board.
The three advertising channels
BLE advertises on three fixed channels, deliberately placed in the gaps between the common Wi-Fi channels:
| advertising channel | frequency | sits between |
|---|---|---|
| 37 | 2402 MHz | below Wi-Fi channel 1 |
| 38 | 2426 MHz | Wi-Fi channels 6 and 7 |
| 39 | 2480 MHz | above Wi-Fi channel 13 |
The remaining 37 channels (0–36) carry connection data and are hopped across pseudorandomly.
ubertooth-btle watches one advertising channel, 37 by default:
$ ubertooth-btle -n # channel 37
$ ubertooth-btle -n -A 38 # channel 38
$ ubertooth-btle -n -A 39 # channel 39
A device rotates through all three, so you will see most things on any one of them — but a connection request you need to catch may land on a channel you are not listening to. This is the main reason connection following is flaky, and the reason modern sniffers watch all three at once.
Sniffing advertisements
The simplest useful mode. -n means “don’t try to follow connections, just
print advertisements”:
$ ubertooth-btle -n
systime=1793645854 freq=2402 addr=8e89bed6 delta_t=18.974 ms rssi=-88
02 22 49 e6 01 09 b4 b8 1b ff 75 00 42 04 01 80 ...
Advertising / AA 8e89bed6 (valid)/ 34 bytes
Channel Index: 37
Type: ADV_NONCONN_IND
AdvA: b8:b4:09:01:e6:49 (public)
AdvData: 1b ff 75 00 42 04 01 80 66 ...
Type ff (Manufacturer Specific Data)
Company: Samsung Electronics Co. Ltd.
Data: 42 04 01 80 66 ...
Data: 49 e6 01 09 b4 b8 1b ff 75 00 ...
CRC: 88 97 47
(Device addresses in the examples on this page are from a real capture with the identifying bytes altered.)
Reading the header line: freq confirms which channel you are on, addr is
the access address — 8e89bed6 is the fixed value every BLE device uses on
the advertising channels, so seeing anything else there means you are looking
at connection data. delta_t is the gap since the previous packet and rssi
is in dBm.
The parsed body is the useful part. AdvA is the advertiser’s address and
whether it is public or random; Type is the PDU type, most commonly:
| type | meaning |
|---|---|
ADV_IND |
connectable, undirected — “anyone may connect” |
ADV_NONCONN_IND |
broadcast only — beacons, sensors, trackers |
ADV_SCAN_IND |
scannable but not connectable |
SCAN_REQ / SCAN_RSP |
a scanner asking for more data, and the reply |
CONNECT_IND |
a connection being set up — the one you want to catch |
What a few seconds of this tells you
From a single ten-second capture on one channel in a university building:
$ ubertooth-btle -n -r ble.pcapng
$ tshark -r ble.pcapng -T fields -e btle.advertising_address | sort -u | wc -l
355
Three hundred and fifty-five distinct advertising addresses, from one antenna, on one of three channels, in ten seconds. A second run a few minutes later, at a busier moment, saw 588. Nothing was paired with anything; no security was defeated. Every one of those devices is announcing its presence, and many are announcing their manufacturer and model in the clear in the manufacturer-specific data field.
This is the privacy story of BLE in one command, and it is why resolvable
private addresses exist: a compliant device rotates its random address
roughly every fifteen minutes so it cannot be tracked. Plenty of devices in
that capture advertise a public address that never changes, and others leak
a stable identifier in their payload that defeats the rotation entirely.
Getting the capture into Wireshark
ubertooth-btle writes three formats, and the flags are easy to mix up:
| flag | format |
|---|---|
-r <file> |
pcapng — the one to use |
-q <file> |
pcap, DLT_BLUETOOTH_LE_LL_WITH_PHDR |
-c <file> |
pcap, DLT_PPI + DLT_BLUETOOTH_LE_LL |
$ ubertooth-btle -n -r ble.pcapng
$ tshark -r ble.pcapng -c 5
1 0.000000000 SamsungElect_47:b4:26 → Broadcast LE LL 53 ADV_NONCONN_IND
2 0.000786900 6d:ff:82:7a:67:07 → Broadcast LE LL 44 ADV_IND
3 0.013960700 41:f2:2c:f8:8d:40 → Broadcast LE LL 56 ADV_SCAN_IND
4 0.030967800 0c:42:12:bf:d1:29 → Broadcast LE LL 56 ADV_NONCONN_IND
5 0.032901700 77:82:61:8a:a7:ca → Broadcast LE LL 42 ADV_NONCONN_IND
For live capture into the Wireshark GUI, the official route is a named pipe:
$ mkfifo /tmp/pipe
$ ubertooth-btle -f -c /tmp/pipe
then add /tmp/pipe as a pipe interface. If Wireshark complains about
DLT=147, add a DLT_USER encapsulation entry with the payload protocol set to
btle.
Roughly a fifth of what you capture is corrupt
This is worth measuring rather than assuming, because it changes how you read a capture:
$ tshark -r ble.pcapng -T fields -e frame.number | wc -l
1748
$ tshark -r ble.pcapng -Y 'btle.crc.incorrect' -T fields -e frame.number | wc -l
313
Eighteen per cent of frames failed CRC. A second capture gave 593 of 2683,
which is twenty-two per cent. That is normal for a single-antenna sniffer in a
busy band — and the band is busy; check it with
wifi24_scan.py and you will usually find Wi-Fi sitting on top
of the advertising channels.
Two practical notes:
- The filter is
btle.crc.incorrect, bare.btle.crc.incorrect == 1matches nothing, because it is an expert-info flag rather than a numeric field. Easy way to fool yourself into thinking a capture is clean. -v1does not fix it. The device has a CRC verification setting, default off, which persists across invocations:
$ ubertooth-btle -v
CRC: DO NOT verify
$ ubertooth-btle -v1
CRC: verify
Turning it on did not reduce the proportion of CRC-invalid frames in the output here (22% with it on, 18% with it off, on comparable captures). Filter in analysis; do not rely on the knob.
The same symptom shows up as PDU types that should not exist — 23 frames in
that capture carried advertising PDU type values above 0x07, which are
reserved. Those are bit errors, not exotic devices.
Following connections
This is where the Ubertooth earns its reputation for being fiddly.
Advertisements are easy because the channel and access address are fixed.
A connection is not: when a central sends CONNECT_IND it specifies an
access address, a hop increment, a connection interval, and a channel map, and
both ends then hop across the 37 data channels. To follow the connection, your
sniffer must catch that CONNECT_IND — on whichever of the three advertising
channels it happened to use — and then hop in step.
$ ubertooth-btle -f # follow any connection
$ ubertooth-btle -f -t 22:44:66:88:aa:cc # follow one device
$ ubertooth-btle -t none # clear the target
In follow mode with no target, a ten-second run here printed nothing at all: no new connection was established on channel 37 during the window. That is the normal experience. The official documentation puts it plainly — you may need to attempt connecting several times before the Ubertooth follows successfully. The reliable procedure is: start the sniffer first, then make the device connect, and repeat until it catches.
Promiscuous mode
-p tries to pick up connections that were already established before you
started listening, by watching for data packets and inferring their
parameters:
$ ubertooth-btle -p
systime=1793645963 freq=2440 addr=e473ec85 delta_t=67.348 ms rssi=-91
09 00 4a bb 45
Data / AA e473ec85 (valid) / 0 bytes
Channel Index: 17
LLID: 1 / LL Data PDU / empty or L2CAP continuation
NESN: 0 SN: 1 MD: 0
Note what is different: freq=2440 and Channel Index: 17 — this is a data
channel, not an advertising one — and the access address is a connection’s
own, shown as (valid) once the tool is confident in it. Addresses marked
(invalid) are candidates it has not confirmed.
-x<n> controls how many access-address “offenses” are tolerated before the
tool gives up on a candidate (default 32). Raising it keeps marginal
connections alive longer at the cost of noise.
Interfering
-i and -I actively jam a followed connection — once, or continuously.
That is a denial of service against a live radio link, not a passive measurement. On a device that is not yours it is an attack, and on a medical or safety device it could do real harm. Use it only on hardware you own, and understand that it is the fastest way to turn a lab exercise into an incident report.
Where the Ubertooth stops, and what to use instead
The CC2400 was designed before BLE existed. It handles the original 1 Msym/s GFSK physical layer, which is all BLE 4.x ever used — but Bluetooth 5 added a 2 Msym/s PHY and a long-range coded PHY, and a radio that cannot demodulate those cannot see traffic that uses them. It also watches one advertising channel where three are in play.
Sniffle is the current answer. It runs on TI CC1352/CC26x2 hardware — a SONOFF CC2652P dongle costs about the same as a takeaway — and its README claims support for all three BT5 PHY modes (1M, 2M, and coded), extended advertising, and Channel Selection Algorithms #1 and #2. It also watches all three primary advertising channels at once, which its authors describe as making connection detection nearly three times more reliable than single-channel sniffers.
Practical advice: keep the Ubertooth for advertising surveys, for teaching (its output shows you the structure in a way a cleaner tool hides), and for Bluetooth Classic work where it is still the usual answer. Reach for Sniffle the moment you need to actually follow a modern connection.
Option: Nordic’s nRF Sniffer on an nRF52840
Sniffle is still the tool to reach for, but Nordic’s own nRF Sniffer for
Bluetooth LE
deserves a place here: it is free, first-party, and plugs into Wireshark as an
extcap interface, so there is no named pipe and no DLT to correct. It just
appears in the interface list. An nRF52840 Dongle is about the cheapest BLE 5
capable sniffer you can buy.
What it does better than the Ubertooth is simply that it understands BLE 5. You do not have to take that on faith — ask the firmware what it supports:
$ ~/.local/lib/wireshark/extcap/nrfutil-ble-sniffer-shim \
--extcap-interface /dev/ttyACM1 --extcap-config
arg {number=3}{call=--scan-follow-aux}{display=Find auxiliary pointer data}...
arg {number=4}{call=--scan-follow-aux-chain}{display=Find auxiliary pointer data chain}...
arg {number=6}{call=--coded}{display=Scan and follow devices on LE Coded PHY}...
Auxiliary pointers are extended advertising — that is the mechanism BLE 5
uses to push an advertisement off the primary channels onto a secondary one —
and --coded is the long-range PHY. Both are invisible to a CC2400.
What it does not fix is the structural limit. Nordic state that the
sniffer observes a single RF channel at a time and cannot follow more than one
connection at a time. That is the same reason catching a CONNECT_IND is a
retry game on the Ubertooth. You gain the BLE 5 PHYs and extended
advertising; you do not gain three-channel coverage, which is exactly what
Sniffle offers and this does not.
Officially the firmware targets the nRF52840 DK, nRF52840 Dongle, nRF52833 DK,
and nRF52 DK. If you have a dongle, use it: put it in DFU mode and let
nrfutil device program do the work.
Running it on a bare nRF52840 board
A plain nRF52840 breakout works too, and this is worth documenting because the obvious way to do it destroys the board.
Boards like the SparkFun nRF52840 Mini Breakout ship with the Adafruit UF2
bootloader: double-tap reset and a NRF52BOOT drive appears, so the tempting
move is to drag a sniffer image onto it. Do not use the dongle image. The
two firmware images have different shapes, and only one of them can boot on
such a board:
| image | flash extent | boots on a UF2-bootloader board? |
|---|---|---|
sniffer_nrf52840dongle_* |
0x1000–0x11ff4 |
No — expects an MBR in front of it |
sniffer_nrf52840dk_* |
0x0–0x14ffc |
Yes — standalone, own vector table |
The dongle image is built to sit behind Nordic’s master boot record, in the
region the SoftDevice normally occupies. Drop it on a board whose bootloader
expects an application at 0x26000 and you get a device that no longer
enumerates at all — no serial port, and not even the bootloader. Recovering it
needs SWD. The DK image, by contrast, is self-contained: its vector table is
at 0x0, so the chip boots it directly with no bootloader, no MBR and no
SoftDevice involved.
So the route that works is SWD, not drag-and-drop. With a CMSIS-DAP probe
wired to SWDIO/SWCLK/GND — a Raspberry Pi Pico running debugprobe is fine:
$ openocd -f interface/cmsis-dap.cfg -c "transport select swd" \
-c "adapter speed 1000" -f target/nrf52.cfg \
-c init -c halt \
-c "program ~/.nrfutil/share/nrfutil-ble-sniffer/firmware/sniffer_nrf52840dk_nrf52840_5.0.0.hex verify" \
-c "reset run" -c exit
Info : SWD DPIDR 0x2ba01477
Info : [nrf52.cpu] Cortex-M4 r0p1 processor detected
Info : nRF52840-xxAA(build code: C0) 1024kB Flash, 256kB RAM
** Programming Finished **
** Verified OK **
Use program ... verify, not nrf5 mass_erase. A mass erase clears the UICR,
and on hardened nRF52840 revisions an erased UICR.APPROTECT comes back
access-port protected — you would lose the SWD access you just used. Since
the chip boots from 0x0, the old bootloader higher up in flash is simply
dead space; there is no need to erase it.
The board then reappears on its own USB as a sniffer rather than a breakout:
$ lsusb | grep Nordic
Bus 007 Device 013: ID 1915:522a Nordic Semiconductor ASA nRF Sniffer for Bluetooth LE
$ nrfutil ble-sniffer bootstrap # installs the Wireshark extcap shims
$ tshark -D | grep Sniffer
13. /dev/ttyACM1 (nRF Sniffer for Bluetooth LE)
That it shows up on native USB is the point: the DK image drives the nRF52840’s own USB peripheral, which is why Nordic tell DK users to plug into the nRF USB port rather than the interface-MCU port. A breakout has only the native port, so it is the right image for the job.
A fifteen-second sanity capture, for comparison with the Ubertooth numbers earlier on this page:
$ tshark -i /dev/ttyACM1 -a duration:15 -w ble.pcapng
Capturing on 'nRF Sniffer for Bluetooth LE: /dev/ttyACM1'
10075 packets captured
$ tshark -r ble.pcapng -q -z io,phs
nordic_ble frames:10075 bytes:541085
btle frames:10075 bytes:541085
_ws.malformed frames:415 bytes:27680
Note the nordic_ble layer wrapping every frame — that is the sniffer’s own
metadata header, carrying RSSI and channel, and it is where nordic_ble.rssi
comes from. Roughly four percent malformed here against the Ubertooth’s
fifth, which is what a radio designed for BLE buys you.
Two cautions. The firmware and the Wireshark plugin are versioned together:
5.x firmware wants the nrfutil-managed extcap shims, while the older
standalone nrf_sniffer_ble.py pairs with 4.1.x firmware, and mixing them
gives you either no interface or a duplicate one. And nrfutil ble-sniffer
bootstrap writes a config naming /usr/bin/nrfutil; if your nrfutil lives
somewhere else the shim fails silently — exit status 0, no output, and no
interface in tshark -D. If the sniffer simply never appears, run the shim by
hand and see whether it prints anything at all.
The rest of the toolkit
The package installs more than ubertooth-btle:
$ ls /usr/bin/ubertooth-*
ubertooth-afh ubertooth-dfu ubertooth-ego ubertooth-specan-ui
ubertooth-btbr ubertooth-dump ubertooth-rx ubertooth-tx
ubertooth-btle ubertooth-ducky ubertooth-specan ubertooth-util
Worth knowing:
ubertooth-specan-ui— a live 2.4 GHz spectrum display. The Ubertooth is a poor spectrum analyser compared with a HackRF, but it is a second opinion on whether the band is congested, and it needs no extra hardware.ubertooth-specan -l 2402 -u 2480gives the same data as text.ubertooth-btbr— Bluetooth Classic (BR) sniffing. It needs its own firmware and it transmits; see the addendum below before running it.ubertooth-afh— recovers the adaptive frequency hopping map of a Classic connection, which tells you which channels the devices are avoiding.ubertooth-rx— Classic packet reception and piconet survey.
Note that ubertooth-scan and ubertooth-follow, which appear in many older
tutorials, are not in this build. Check what you actually have with
ls /usr/bin/ubertooth-* before following a guide.
Scope and legality
Receiving is passive and the Ubertooth transmits nothing in the modes above —
with the explicit exception of -i/-I and -s (faux slave), which do
transmit. Monitoring radio traffic that is not yours sits in genuinely
contested legal territory, and actively interfering with it does not: that is
unambiguously an attack.
Sniff your own devices, the course lab devices, or devices you have written permission to test. “It was broadcasting in the clear” has not historically been a successful defence.
Addendum: Classic Bluetooth (BR/EDR) with the Ubertooth
Everything above is BLE, because that is what you will mostly meet in IoT. But the Ubertooth was built for Classic Bluetooth — the CC2400 predates BLE entirely — and Classic has not gone away: headsets, speakers, car head units, OBD-II dongles, barcode scanners and most of the industrial serial-cable replacements in the world are BR/EDR, not BLE.
Classic is also much harder to sniff than BLE, and the reasons are structural rather than a matter of using the right flag.
Why Classic is harder
Three things make it hard, and they compound.
There is no advertising channel. BLE hands you three fixed frequencies where every device announces itself in the clear. Classic has nothing equivalent. It uses 79 channels at 1 MHz spacing and hops between them 1600 times a second, and the hop sequence is derived from the master’s address and clock. If you do not already know the piconet, you do not know where to listen.
One radio, one channel. The limitation from the top of this page bites much harder here. On a fixed channel you catch roughly the fraction of hops that happen to land on you, and you are reconstructing a conversation from every seventy-ninth word.
You cannot see the whole address. A Classic BD_ADDR is 48 bits in three
parts:
| part | bits | name | passively recoverable? |
|---|---|---|---|
| NAP | 16 | non-significant address part | No — only from an FHS packet |
| UAP | 8 | upper address part | Partly, by inference |
| LAP | 24 | lower address part | Yes, immediately |
The access code at the start of every packet is built from the LAP alone, so the LAP is simply there to be read — Nordic’s equivalent would be handing you a third of the MAC address for free. The UAP is not in the access code, so it has to be inferred: you accumulate candidate values and eliminate the ones whose header-error-check and CRC do not work out. Upstream describes the job as “Post-processing necessary to recover UAP per LAP, and CLK per LAP/UAP”. The NAP is never recoverable this way at all. It appears in the clear only inside the FHS packet exchanged during connection setup, which means you have to be listening at the moment two devices pair or reconnect.
This is why Classic sniffing output is full of ??. It is not a bug.
And the Ubertooth cannot demodulate EDR. Upstream is blunt about it: “the current ubertooth can recover BR and LE packets, but not EDR payloads.” BR is 1 Mbps GFSK, which the CC2400 handles. EDR switches the payload to π/4-DQPSK or 8DPSK at 2 or 3 Mbps, which it does not. A phone streaming to a speaker will negotiate EDR, so you get access codes and headers and no audio. Plan your lab exercises around that: use the tools to map piconets, not to expect readable payloads.
ubertooth-rx: LAP discovery, survey, and following
This is the Classic workhorse, and it has three distinct modes hiding behind two flags:
$ ubertooth-rx -h
ubertooth-rx - passive Classic Bluetooth discovery/decode
Example usage:
ubertooth-rx -- sniff for all LAPs
ubertooth-rx -l <lap> -- calculate UAP for a given LAP
ubertooth-rx -l <lap> -u <uap> -- calculate clock and follow piconet
ubertooth-rx -z -t 20 -- survey mode: discover all LAPs+UAPs for 20 seconds
Start with survey mode, which is the Classic analogue of the advertising sweep earlier on this page:
$ ubertooth-rx -z -t 30
It discovers LAPs, works on the UAPs in the background, and prints a summary when the timeout expires or you interrupt it. The shape of that summary is the part to learn:
Survey Results
??:??:22:1f:3a:b0
??:??:??:7c:2e:91
Read those carefully, because the ??s are load-bearing. The first line is a
piconet whose UAP has been determined — four of the six bytes are known. The
second is one where it has not, so only the LAP is filled in. The leading
??:?? is the NAP, and it will stay unknown unless you catch an FHS packet.
Four known bytes is normally enough to identify a device in a lab, and it is
exactly what ubertooth-afh needs next.
Live, each decoded packet is one line, in this shape:
systime=1763082000 ch=39 LAP=1f3ab0 err=0 clk100ns=2894512 clk1=1456 s=-42 n=-85 snr=43
ch— the Bluetooth channel you were parked on, 39 by defaultLAP— the recovered lower address parterr— how many bit errors were tolerated in the access codeclk100ns,clk1— the Ubertooth’s own 100 ns counter, and the piconet clock. The label readsclk1, but the value printed is CLKN, the 312.5 µs Bluetooth clock, which is what the piconet-following logic is really afters,n,snr— signal, noise, and the difference, all in dB
The flag that most changes your results is -e, the maximum access-code bit
errors, default 2 and range 0–4. Turn it up and you detect weaker packets at
the cost of false LAPs — the sync word is only 64 bits, so a generous error
budget will start matching noise. Turn it down for a clean list you can trust. If a
survey gives you implausibly many piconets, that is the first dial to touch,
not the antenna.
-c parks the radio on one channel. There is no point sweeping manually; as
of this release sweeping is the default and the old -s flag is deprecated
and warns.
Getting BR/EDR captures into Wireshark
ubertooth-rx writes capture files with the same flag confusion as
ubertooth-btle, except -q here means pcap:
| flag | format |
|---|---|
-r <file> |
pcapng — the one to use |
-q <file> |
pcap, DLT_BLUETOOTH_BREDR_BB (link type 255) |
-d <file> |
raw binary symbol dump, Ubertooth-specific |
$ ubertooth-rx -z -t 60 -r classic.pcapng
$ tshark -r classic.pcapng -c 5
This no longer needs a plugin. Older guides — and the Ubertooth docs
themselves — tell you to build the Wireshark dissectors that ship with
libbtbb and drop them in ~/.local/lib/wireshark/plugins. Current Wireshark
understands BR/EDR baseband natively:
$ editcap -T | grep -i bredr
bluetooth-bredr-bb-rf - Bluetooth BR/EDR Baseband RF
$ tshark -G dissectors | grep -i btbredr
btbredr_fhs BT BR/EDR FHS
btbredr_rf BT BR/EDR RF
That is Wireshark 4.7.4 with no plugins installed at all. Note the second
dissector: btbredr_fhs is the FHS packet, the one carrying the UAP and NAP
in the clear — so if you do win the race and capture one, Wireshark will hand
you the full address. The -d binary dump is a raw symbol capture intended for
replay through ubertooth-rx -i, not for Wireshark.
ubertooth-rx has no PPI option at all, unlike ubertooth-btle’s -c. If a
guide tells you to set up a DLT_PPI encapsulation for Classic captures, it is
describing a format upstream itself now calls deprecated.
ubertooth-afh: reading the hop map
Once you have a LAP and a UAP, ubertooth-afh recovers the adaptive frequency
hopping map — which of the 79 channels the piconet is actually using:
$ ubertooth-afh -l 1f3ab0 -u 22
Both arguments are required, which is why the survey comes first. -m sets
how many consecutive misses mark a channel as unused (default 5) and -r
prints the map once a second instead of only on change.
This is more interesting than it first sounds. AFH exists so Bluetooth can
dodge interference, so the map is a Bluetooth device’s own opinion about
which parts of the 2.4 GHz band are busy. Read it along with the spectrum view from
ubertooth-specan-ui, or the Wi-Fi survey in
Watching the 2.4 GHz Band, and you can usually see the dodged
channels line up with a Wi-Fi channel. It is also a privacy leak of a kind
students do not expect: the map tells you something about the radio
environment the other device is sitting in, not yours.
ubertooth-btbr: different firmware, and it transmits
ubertooth-btbr gets a one-line mention above and deserves a warning, because
it is not like the other tools in three separate ways.
It needs its own firmware. The tool drives UBTBR, a separate BR/EDR
baseband implementation living in firmware/btbr/ in the source tree. The
release’s prebuilt images are only bluetooth_rxtx, bluetooth_rx_only, and
assembly_test — there is no prebuilt UBTBR image, so you have to build it
and flash it yourself, and doing so replaces the firmware every other tool
on this page needs. Budget a flash back afterwards.
It will not tell you the firmware is wrong. The C tools call an API
version check on connect and refuse to run against mismatched firmware. This
one does not: it is a Python script over the ubtbr module, and its device
discovery matches on USB vendor and product ID only. Point it at stock
firmware and it opens the device happily, then does nothing useful. The clean
error you get with no board at all is the best case:
$ ubertooth-btbr
Exception: Ubertooth device not found
It is an active tool. Read the legality section above again. Where
ubertooth-rx and ubertooth-afh are purely passive, ubertooth-btbr drops
you into an interactive shell whose commands include inquiry, page,
inquiry_scan, page_scan, discoverable, and l2ping. Those transmit.
page establishes a connection to a device as master; discoverable makes
your Ubertooth visible and connectable to anyone nearby. Do not run them in a
shared space, and do not run them against hardware you do not own.
Its interesting mode is monitor:
$ ubertooth-btbr
> monitor 11:22:33:44:55:66
That targets a race condition in connection setup: the Ubertooth tries to receive the FHS packet before the legitimate slave does, and if it wins it is synchronised to the piconet before either real participant and can record what follows. Early LMP traffic — capability exchange and encryption negotiation — is not encrypted, so you see it. Upstream is honest about the limits: you have to win the race or retry, and it “does not break encryption”. Once the link encrypts, packets show up as raw.
UBTBR only does BR, only ACL, and only the packet types ID, NULL, POLL,
FHS, DM*, and DH*. It is a research tool, not a product.
What is missing from this build, and why
The page above notes that ubertooth-scan and ubertooth-follow are not
installed. The reason is a build-time decision, not a bug: both are only
compiled when CMake finds libbluetooth, because they talk to the local
BlueZ stack to combine host-side scanning with Ubertooth capture.
$ pacman -Qi ubertooth | grep Depends
Depends On : libbtbb libusb libpcap python python-libusb1 python-qtpy
$ pacman -Q bluez-libs
bluez-libs 5.87-2.1
BlueZ is present; the package simply was not built against it. If you want
those two tools, build the host code yourself with libbluetooth development
headers installed. Nothing else on this page changes.
Finally, be aware that upstream documentation does not cover any of these
Classic tools — ubertooth-rx, ubertooth-afh, and ubertooth-btbr all have
no page in the official docs. The -h output and the source are the
documentation. That is a reasonable thing for students to see: at this level
of the stack, reading the tool is a normal part of using it.
Where this leaves you
For Classic work the Ubertooth is a good mapping instrument and a poor capture instrument. It will give you LAPs in seconds, UAPs with patience, AFH maps, and BR headers. It will not give you EDR payloads, reliable following of a hopping link, or anything from an encrypted connection. If the exercise needs those, you are looking at a commercial protocol analyser, and the honest lesson is that Classic sniffing never got the cheap, easy tooling BLE did.
Key takeaways
- The Ubertooth One is one radio on one channel. Nearly every limitation — missed connections, flaky following, no BLE 5 PHYs — follows from that.
- Advertising is trivial to capture and enormously revealing: 355 distinct devices in ten seconds on one of three channels, many with stable identifiers, with no attack involved at all.
- Host tools and firmware must match versions;
ubertooth-dfu -dwrites firmware and-ureads it. - Expect a fifth of your frames to fail CRC, filter them with
btle.crc.incorrect(not== 1), and do not trust-v1to do it for you. - Following a connection means catching its
CONNECT_IND. Start the sniffer, then connect, and expect to retry. - For modern BLE 5 work, use Sniffle. Keep the Ubertooth for advertising surveys, Classic, and for seeing the protocol’s structure plainly.
- Nordic’s nRF Sniffer is the cheap first-party middle ground: BLE 5 PHYs and extended advertising, but still one channel and one connection at a time. On a bare nRF52840 breakout flash the DK image over SWD; the dongle image will not boot and takes the board with it.
- Classic Bluetooth is the Ubertooth’s original job and still the harder problem: 79 channels at 1600 hops a second, no advertising channel, and an access code that reveals only the LAP. The UAP has to be inferred and the NAP shows up only in an FHS packet.
- The Ubertooth demodulates BR but not EDR payloads, so treat it as a piconet
mapper rather than a capture tool.
ubertooth-btbris the exception to “passive”: it needs its own firmware and it transmits.
References
- Ubertooth project and its documentation
- Ubertooth One hardware — LPC175x, CC2400 and CC2591
- Capturing BLE in Wireshark
— the named-pipe workflow and the
DLT=147fix - Sniffle — BT5 PHYs, extended advertising, CSA #1 and #2, three-channel advertising capture
- nRF Sniffer for Bluetooth LE
— Nordic’s first-party sniffer: the Wireshark extcap, the
nrfutil ble-sniffercommand, and the supported DKs and dongles - nRF Sniffer product page — the link the extcap plugin itself reports as its help URL
- Adafruit nRF52 Bootloader
— the UF2 bootloader these breakouts ship with;
src/usb/uf2/uf2cfg.hholds the family IDs that decide whether an image is an app or a bootloader update - OpenOCD documentation
—
program ... verify, the nRF52 flash driver and CMSIS-DAP transport - Bluetooth Captures in PCAP — upstream’s own account of what can be recovered: the LAP from the sync word, the UAP by post-processing, and “BR and LE packets, but not EDR payloads”
- pcap link-type registry
—
LINKTYPE_BLUETOOTH_BREDR_BBis 255; the LE link layer with pseudo-header is 256 - Wireshark
btbredr_rfdisplay filter reference — the BR/EDR baseband fields, dissected natively with no plugin - libbtbb — the baseband library behind every Classic tool here, and the Wireshark plugins you no longer need to build
- UBTBR firmware
— the separate BR/EDR firmware
ubertooth-btbrdrives, its monitor-mode FHS race, and its stated limitations - Mike Ryan, Bluetooth: With Low Energy Comes Low Security — WOOT ‘13; the work that put BLE sniffing on the Ubertooth
- crackle — cracking BLE legacy pairing from a capture
- Wireshark
btledisplay filter reference - Bluetooth Core Specification — advertising PDU types and channel selection are in Vol 6, Part B
- Bluetooth — the protocol, GATT, pairing, and the attack classes
- Watching the 2.4 GHz Band — what else is in this band and how to see it