courses

Monitoring BLE with an Ubertooth

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:

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

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

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

References