InternalBlue - Bluetooth Binary Patching and Experimentation Framework

TL;DR

InternalBlue is a comprehensive framework for reverse engineering, modifying, and testing Bluetooth chipsets, enabling security research, vulnerability discovery, and firmware customization on a wide range of devices.

Contribution

The paper introduces InternalBlue, a novel open-source framework for deep Bluetooth chipset analysis and modification, surpassing existing tools by enabling hardware-level experimentation and security testing.

Findings

Discovered a critical security vulnerability in Broadcom Bluetooth chipsets.

Developed a versatile framework capable of patching and enhancing Bluetooth firmware.

Demonstrated practical applications including vulnerability testing and firmware fixing.

Abstract

Bluetooth is one of the most established technologies for short range digital wireless data transmission. With the advent of wearables and the Internet of Things (IoT), Bluetooth has again gained importance, which makes security research and protocol optimizations imperative. Surprisingly, there is a lack of openly available tools and experimental platforms to scrutinize Bluetooth. In particular, system aspects and close to hardware protocol layers are mostly uncovered. We reverse engineer multiple Broadcom Bluetooth chipsets that are widespread in off-the-shelf devices. Thus, we offer deep insights into the internal architecture of a popular commercial family of Bluetooth controllers used in smartphones, wearables, and IoT platforms. Reverse engineered functions can then be altered with our InternalBlue Python framework---outperforming evaluation kits, which are limited to documented and vendor-defined functions. The modified Bluetooth stack remains fully functional and high-performance. Hence, it provides a portable low-cost research platform. InternalBlue is a versatile framework and we demonstrate its abilities by implementing tests and demos for known Bluetooth vulnerabilities. Moreover, we discover a novel critical security issue affecting a large selection of Broadcom chipsets that allows executing code within the attacked Bluetooth firmware. We further show how to use our framework to fix bugs in chipsets out of vendor support and how to add new security features to Bluetooth firmware.

Figures

Tables

Table 1. Table 1 . Memory Map of the Firmware’s Address Space.

Start	End	Size	Type	Description
0x000000	0x090000	576 kB	ROM	Firmware
0x0D0000	0x0D8000	32 kB	RAM	Patchram
0x200000	0x228000	160 kB	RAM	Stack & Heap
0x260000	0x268000	32 kB	ROM	Data & Jumptables
0x310000	0x310400	1 kB	IO	Patchram Control

Table 2. Table 2 . Currently Supported Chips by InternalBlue , * refers to the diagnostic protocol  ( wisec_diag, ) .

Chip	Patchram	LMP	Tracepoint	Device
BCM4339	✓	✓	✓	Nexus 5 / Xperia Z3
BCM4358	✓	✓	$\times$	Nexus 6P / Samsung Galaxy S6 [edge]
BCM4343	✓	*	$\times$	Raspberry Pi 3
BCM4345	✓	*	$\times$	Raspberry Pi 3+
CYW20735	✓	*	✓	Evaluation Kit

Table 3. Table 3 . Known Vulnerable Devices.

Device Name	Chip	Version	SubVersion
MacBook Pro 13” mid 2012	BCM4331	6	8859
iPhone 5	BCM4334	7	16653
iPhone 5s	BCM4334	7	8707
Xperia Z5	BCM43xx	7	8975
Nexus 5, Xperia Z3, Samsung Galaxy Note 3	BCM4339	7	24841
Raspberry Pi 3	BCM43430A1	7	8713
Huawei Honor 8	BCM4345	8	24857
iPhone 6	BCM4345	8	16649
MacBook Pro 13” early 2015	BCM2070x	8	8609
MacBook Pro 13” early 2015 #2	BCM20703A1	8	8614
MacBook Pro 2016 A1707	BCM20703A2	8	8752
MacBook Pro 2016	BCM20703A2	8	8774

Full text

We reverse engineer multiple Broadcom Bluetooth chipsets that are widespread in off-the-shelf devices. Thus, we offer deep insights into the internal architecture of a popular commercial family of Bluetooth controllers used in smartphones, wearables, and IoT platforms. Reverse engineered functions can then be altered with our InternalBlue Python framework—outperforming evaluation kits, which are limited to documented and vendor-defined functions. The modified Bluetooth stack remains fully functional and high-performance. Hence, it provides a portable low-cost research platform.

InternalBlue is a versatile framework and we demonstrate its abilities by implementing tests and demos for known Bluetooth vulnerabilities. Moreover, we discover a novel critical security issue affecting a large selection of Broadcom chipsets that allows executing code within the attacked Bluetooth firmware. We further show how to use our framework to fix bugs in chipsets out of vendor support and how to add new security features to Bluetooth firmware.

††ccs: Security and privacy Mobile and wireless security††ccs: Networks Link-layer protocols††journalyear: 2019††copyright: acmlicensed††conference: The 17th Annual International Conference on Mobile Systems, Applications, and Services; June 17–21, 2019; Seoul, Republic of Korea††booktitle: The 17th Annual International Conference on Mobile Systems, Applications, and Services (MobiSys ’19), June 17–21, 2019, Seoul, Republic of Korea††price: 15.00††doi: 10.1145/3307334.3326089††isbn: 978-1-4503-6661-8/19/06

1. Introduction

color=green!20]InternalBlue has the potential to spark greater engagement with Bluetooth.

this paper does add to our understanding of the Bluetooth ecosystem.

Adapt some of this positive feedback into the motivation.

Bluetooth, the standard for wireless short range communication, has been around for almost 25 years since Ericsson developed it in 1994. In the early days it was mainly applied to wireless headphones, hands-free speakerphones, and replacement of infrared data links between devices (bluetooth-history, ). Today, Bluetooth experiences a comeback with the use of wearables and the IoT, often using Bluetooth Low Energy (BLE) introduced in version 4.0. Its latest specifications, Bluetooth 5.0 and 5.1, provide new interesting features such as mesh networking and localization (2017:SIG, ; 2019:SIG, ), and indicate that Bluetooth will play an important role in the future of wireless communication.

Bluetooth security and performance have only been studied selectively, which is a stark contrast to the extensive analysis of the Wi-Fi standard over the same period of time. This can be partially attributed to the availability of powerful, open-source tools which allow easy experiments on raw Wi-Fi frames with low-cost, off-the-shelf hardware. When the first patches for Wi-Fi drivers enabled the so-called monitor mode and frame injection capabilities, researchers soon implemented practical attacks on low-level parts of the Wi-Fi stack and the currently deprecated Wired Equivalent Privacy (WEP) standard (2001:fms, ; 2006:bittau, ) in short order. Only recently (2017:googleprojectzero, ; 2017:artenstein, ; quarkslab, ), the firmware running on Wi-Fi cards has been shown to contain severe over-the-air vulnerabilities. Publicly available tools allow to alter off-the-shelf Broadcom Wi-Fi cards (nexmon:project, ), along with easy to understand open source Wi-Fi SDR implementations (warp:project, ; gr-ieee802-11:project, ).

Blueborne is a state-of-the-art collection of weaknesses uncovered in most of the major Bluetooth stacks, and has raised awareness of different issues concerning Bluetooth security. However, Blueborne targets host-side Bluetooth drivers in opposition to the lower layers of the protocol, below the Host Controller Interface (HCI), which are handled in firmware and are still difficult to audit. A recent Bluetooth attack concerns Elliptic Curve Diffie-Hellman (ECDH) key exchange used during device pairing, where the attacker replaces public key coordinates during transmission, which were not checked in most implementations (2018:biham, ).

Unfortunately, compared to Wi-Fi there is no similarly easy way to monitor and manipulate the behavior of lower Bluetooth layers depicted in Figure 1. On the one hand, professional equipment targeted at hardware developers exists, but is very expensive. On the other hand, modifiable open-source platforms still struggle with fundamental problems such as frequency-hopping characteristics of the Bluetooth Physical Layer (PHY).

This paper is the groundwork for a platform focused on Bluetooth low layer protocol modifications and security. It targets the firmware of the Broadcom Bluetooth chipset named BCM4339, which resides inside the Nexus 5. We tested and extended parts of the functionality to Nexus 6P, Samsung Galaxy S6/S6 edge, Raspberry Pi 3/3+ and a Bluetooth 5.0 IoT evaluation kit.

On top of reverse engineering results, the outcome of this work is the research and analysis framework InternalBlue which enables direct interaction with Broadcom firmware internals at runtime. The framework consists of a flexible Python library which acts as an interface to the firmware over the Android Debug Bridge (ADB). It is supplemented with an interactive front-end which supports live analysis of the firmware and low-level Bluetooth activities. The most important capabilities of InternalBlue are:

• •

modifying arbitrary memory regions including Read Only Memory (ROM),

• •

run arbitrary code in the context of the running firmware,

• •

send arbitrary HCI commands to the chip,

• •

establish connections to non-visible devices, and

• •

enable monitor mode and injection for the Link Manager Protocol (LMP).

Access to LMP stands out for transforming an off-the-shelf low-cost smartphone into an LMP monitor and injection device, while enabling security testing. To the best of our knowledge, there exists no openly available solution to monitor and craft LMP messages in the context of Bluetooth connections. Such a tool is especially useful for researching and testing other Bluetooth devices on the Link Manager (LM) layer, which controls important features such as security parameters and frequency settings.

To demonstrate the capabilities of InternalBlue, we use it to test for known Bluetooth bugs. On top of this, we detect a new severe vulnerability inside the firmware, which affected a huge fraction of Broadcom Bluetooth chips in use in December 2018. We perform the following security demos and contributions with InternalBlue:

• •

test for user interaction behavior of pairing devices without input and output capabilities (hypponen2007nino, ),

• •

test for a known ECDH pairing vulnerability (2018:biham, ),

• •

Media Access Control (MAC) address filter within LMP to improve security,

• •

emulation framework to fuzz malicious payloads and trace their call graph, and

• •

discovery of a severe security vulnerability (CVE-2018-19860) that allows to crash various Broadcom Bluetooth firmwares and execute a subset of functions within them.

InternalBlue is publicly available including various demos111https://github.com/seemoo-lab/internalblue. We disclosed all issues reported before handing in this paper to Broadcom, who has acknowledged them and has already provided fixes to vendors.

This work is structured as follows. Section 2 describes relevant Broadcom specifications and how to reverse engineer the firmware. Based on this knowledge, the implementation of InternalBlue is explained in Section 3, including the application of an LMP toolkit. InternalBlue is then used to check for multiple known issues in the Bluetooth standard in Section 4. Further investigation in Section 5 leads to Broadcom specific issues that allow code execution within Bluetooth firmware. Section 4 and Section 5 contain the main contributions of this paper—readers who are not interested in the efforts required to open a closed source firmware and do not want to reproduce results can skip Section 2 and Section 3. Related work is listed in Section 6. Results are discussed in Section 7. Section 8 concludes this paper.

2. Firmware Reverse Engineering

This section summarizes the information on the internal structure and functioning of the Broadcom BCM4339 Bluetooth controller. The information has been gathered through reverse engineering the controller’s firmware according to the Bluetooth specifications (2016:SIG, ), and also from the datasheet in (2016:cypress, ). Some functions can be clearly mapped to standardized Bluetooth procedures, because they use uniquely specified values. However, going from machine code to assembly and data sections and then naming functions is a tedious process and nobody publicly did this for Broadcom Bluetooth chips before. The normal procedure for experimenting with lower layer Bluetooth would be signing a non-disclosure agreement with a vendor. However, in that case, results would not be openly publishable to the community. Reverse engineering techniques presented in this section apply to all Broadcom Bluetooth chips and might also be helpful in similar projects.

Readers who do not want to add their own functions to InternalBlue but at least use already existing functions themselves can directly proceed to Section 3. Readers who are only interested in applications and outcomes can proceed to Section 4.

2.1. Hardware Architecture

The BCM4339 combines a Wi-Fi IEEE 802.11ac and Bluetooth 4.1 transceiver on a single chip. A simplified architecture overview is depicted in Figure 2. Inside the chip, Wi-Fi and Bluetooth units operate on separated processor cores. The Bluetooth processor is an ARM Cortex-M3, which has $196\text{\,}\mathrm{kB}$ Random Access Memory (RAM) and $608\text{\,}\mathrm{kB}$ ROM. Both, RAM and ROM, are split up into two sections respectively as seen in Table 1. In addition, the chip contains a Bluetooth modem controlled by the Bluetooth Baseband Core. This component handles the lower layers of the Bluetooth protocol stack, while the higher layers such as the link and device manager are implemented in the Cortex-M3. Components are interconnected by an ARM Advanced High-performance Bus (AHB).

Communication with the host system is done via HCI over a Universal Asynchronous Receiver-Transmitter (UART) interface or Universal Serial Bus (USB). Host communication includes a Pulse-code Modulation (PCM) connector for transferring audio data.

2.2. Reading, Writing, and Executing RAM

HCI provides a uniform method for the host to access controller capabilities and send or receive data from underlying Bluetooth links. The protocol is based on commands the host sends to the controller, and events the controller sends to the host. Accessing HCI on the host requires superuser rights, the concrete implementation depends on the operating system. HCI is never directly sent over the air.

Apart from the standardized HCI commands (2016:SIG, ), the BCM4339 implements many vendor specific commands partially listed in the datasheet (2016:cypress2, ). The Write_RAM, Read_RAM, Download_Minidriver and Launch_RAM commands are relevant in order to understand firmware patching and debugging, as described in Section 3.1.

Read_RAM reads memory chunks from the chip’s RAM and ROM address space and sends them back to the host in the HCI command complete event. Reading unmapped addresses causes the chip to crash.

Write_RAM can be used to write memory chunks to RAM regions of the chip’s memory. If attempting to write to a ROM section, the command has no effect.

Download_Minidriver will put the device into a special mode in which it is safe to receive patches, normal Bluetooth activity is disabled. Only a very reduced subset of HCI commands is interpreted in download mode, including Read_RAM, Write_RAM and Launch_RAM. Launch_RAM is being used to exit download mode and reboot into the normal Bluetooth firmware. Any downloaded ROM patches are applied at an early stage during this reboot.

Launch_RAM continues code execution on the chip at a specified address using Thumb mode. One of the intended use cases is to exit Download_Minidriver mode by passing the pseudo-address 0xFFFFFFFF to Launch_RAM. This applies the downloaded patches, quits download Download_Minidriver, and goes back into Bluetooth mode. Another use case is to jump to the entry point of a so-called Minidriver which was previously loaded into RAM using the Download_Minidriver and Write_RAM commands.

Support of Write_RAM, Read_RAM, and Launch_RAM is essential for InternalBlue. These HCI commands can be considered security critical, as the installed patches are not checked for a signature or similar from the vendor; hence, allowing malicious code installation. They exist throughout all chip versions—including one of the most recent chips CYW20735. Technically, this means InternalBlue can be ported to all current Broadcom and Cypress Bluetooth chips.

2.3. Updating Firmware and ROM

The Android Bluetooth driver includes an HCD file with firmware updates and patches in its initialization procedure. By first reading the name of the chip via an HCI command it is able to search for a matching HCD file inside the /system/vendor/firmware directory. It applies the HCD file and then continues with normal chip initialization.

An HCD file contains multiple Write_RAM commands adding new functions and data to the RAM sections of the chip. The HCD file terminates with a Launch_RAM command with 0xFFFFFFFF as argument in order to reboot into Bluetooth mode and apply the patches.

Patches to ROM cannot be applied with Write_RAM, but with a special Patchram mechanism. Although this mechanism is mentioned in the BCM4339 datasheet (2016:cypress, ), it is not publicly documented and therefore had to be reverse engineered. All ROM patches are collected in a list and written to a custom RAM address. The list is formatted as a chain of Type-Length-Value (TLV) objects. Each entry starts with a one-byte type field followed by a two-byte length of the payload. Finally, Launch_RAM will exit the Download_Minidriver state, apply patches to ROM and enter normal Bluetooth mode.

The TLV type 0x08 is used for single $32\text{\,}\mathrm{b}\mathrm{i}\mathrm{t}$ patches to the ROM (called Patchram). The length of the value is fixed to 15 bytes with the following semantic:

[TABLE]

The final effect of this Patchram object is: the new value virtually overwrites four bytes of memory inside the ROM, which are located at the target address. Patchram patches only last until the next reset. Internally this is done by writing the value into a table at address 0xD0000 (RAM) and the target address into another table at address 0x310000 (hardware register). For both tables the index is given by the slot number and the tables are capable of holding up to 128 entries which correspond to slot numbers 0 to 127.

Overwriting 128 values of 4 bytes in ROM is not much, but this is sufficient to inject branch commands into the beginnings of functions and then redefining them inside the RAM. The Nexus 5 HCD file in Android 6 already uses 113 Patchram slots—therefore not only limiting the amount of modifications InternalBlue can install but also future vendor bugfixes. Broadcom has realized that this issue reduces patching abilities, and thus provides more Patchram slots on newer chips, for instance, the Nexus 6P has now 192 slots. Yet, newer chips are also shipped with more code, raising the probability of erroneous code that requires fixes.

To overcome this shortage of Patchram slots, meta patches being responsible for multiple patches could be inserted in popular parts of the program flow. However, such meta patches require more code and free RAM is also a very limited resource.

2.4. Link Manager Functions

The LM communicates with the LMs of other controllers via the LMP in order to establish and control links between devices. Its tasks include to set-up and control logical transports and links, synchronize clocks between Bluetooth master and slaves, control frequency hopping sequence, and set-up authentication and encryption. Relevant information exchanged on the LM is then passed by the firmware via HCI to the host.

At the core of the LM in the BCM4339 firmware is a handler table for each LMP opcode. The table starts at the address 0x261610 in the second half of the ROM. Each table entry has a length of 8 bytes and contains the following values:

[TABLE]

A thread periodically checks for incoming LMP packets and calls the function LMP_dispatcher if new packets arrive. A global data structure lm_curCmd at address 0x200478 holds information about the received packet currently being processed. The LMP dispatcher reads the opcode from lm_curCmd, retrieves the corresponding entry from the LMP function table and finally calls the handler function from the retrieved entry.

Handler functions take a pointer to a structure representing the respective connection as their only argument. They get the payload for the received packet from lm_curCmd. If the received packet requires a response, the handler crafts a new LMP packet and calls send_LMP_packet. This function puts the packet into a transmit buffer for the respective connection.

2.5. Reversing Evaluation Kits

Evaluation boards such as CYW920735Q60EVB-01 for the CYW20735 Bluetooth 5.0 chipset are supported by WICED Studio (cypress_cyw20735, ). They do not only run a basic Bluetooth firmware—which has only minor changes compared to other versions—but also an application like a temperature sensor providing readings. Simple applications not requiring their own processor make this type of chips suitable for IoT implementations. WICED applications are tightly coupled to firmware, for example they use the same thread initialization function. Investigating similarities we found a binary file patch.elf which defines almost all symbols, a total of 11813 function and 2818 object names. Note that access to firmware definitions usually requires a non-disclosure agreement with the vendor, and the binary format of patch.elf abstracts them in a way that is hard to search for. When finding this source of information, we already had invested months of reverse engineering Nexus 5 firmware—all LM functions were located by searching for opcodes defined in the standard.

Locating functions in CYW20735 also helps to reverse engineer other Broadcom chips. Binary diffing tools can apply heuristics to locate similar functions. Yet, when using IDA Pro BinDiff (bindiff, ) only 6% of the named objects and functions are found in the Nexus 5 firmware, more than half of them being false positives, despite only selecting matches with at least 90% similarity. The good news is that a non-automated search shows way more correct similarities including complete libraries that did not change over 6 years of development. Low variation in the code and missing obfuscation due to performance and space requirements makes porting InternalBlue firmware patches comparably easy. However, there are also new features introduced over those 6 years, updated libraries and architectural changes, as well as variances in compilation that make BinDiff giving bad results. Thus, previous reversing of the Nexus 5 smartphone still provides interesting insights.

Despite knowing many original function names from WICED Studio, we continue using our own comprehensible names throughout this paper. For the curious reverser, the most relevant functions LMP_dispatcher and send_LMP_packet are originally called lm_HandleLmpReceivedPdu and DHM_LMPTx.

3. Basic InternalBlue Functions

Knowledge gathered in the previous section is used to create InternalBlue, an open and extendable Bluetooth research framework based on BCM4339 and other Broadcom chips. The aim is to repurpose off-the-shelf consumer devices as analysis tools for experimenting with the lower layers of Bluetooth connections. This is done by patching the controller’s firmware and writing additional software for the host side which communicates with the firmware over HCI.

The first basic firmware tweaks focus on integrating LMP functionality into InternalBlue. As shown in Figure 1, LMP resides below HCI, with the latter already being accessible on Android. Monitoring and modification of layers below allows for more fine-grained observations and changes, and details on LMP inside the firmware give insights where to integrate own functions. Therefore, we implement an LMP monitor and then extend it with injection capabilities.

An overview of currently supported chips and tested features is given in Table 2. Reading and writing RAM worked on any Broadcom chip we encountered so far; thus, we only list the special Patchram, LMP and tracepoint debugging features. Patches for those features depend solely on the chip, but we list the device used for testing. An alternate way to implement LMP without patches is a proprietary diagnostic protocol (wisec_diag, ). Check out the current repositories to get an up to date list.

3.1. Architecture

The architecture of the framework allows for close inspection and manipulation of the Bluetooth controller while being actively used by Android. Figure 4 shows an overview of the system which consists of an Android device with an embedded Broadcom Bluetooth controller, and a Linux host running the InternalBlue framework, which is written in Python. The Android device is connected to the host via ADB.

The framework relies on debug functionality in the Android Bluetooth stack such as the HCI Snoop Log feature. This feature writes a capture file of all HCI packets which were transferred between the Android host and the Bluetooth controller. Despite LMP resides below HCI, adjusted LMP traffic can be forwarded over this interface to the host. Once HCI Snoop Log has been enabled through the Android developer settings, a capture file is written to the internal memory of the Android device. It uses the Snoop Packet Capture format which is specified in RFC 1761 (RFC1761, ). Each HCI packet is encapsulated in a Snoop Record which also stores length and time information in a Record Header.

If the Android Bluetooth stack is compiled with debugging features enabled (BT_NET_DEBUG), networking features in aosp/platform/system/bt/+/master/hci/src/btsnoop_net.c are activated and Android opens two TCP ports listening on localhost (android_bt2, ):

**127.0.0.1:8872: **

outputs every HCI packet exchanged between the Android Bluetooth stack and the Bluetooth controller using the Snoop file format.

**127.0.0.1:8873: **

accepts HCI commands in the format of Snoop Records, which the Android Bluetooth stack will send the Bluetooth controller.

Compilation with BT_NET_DEBUG enabled was tested and confirmed to be working on Android Open Source Project (AOSP) Android 6.0.1 and 7.1.2, and LineageOS 14.1.

If the host system in which the Bluetooth controller resides is not Android but Linux with BlueZ, sending HCI commands works out of the box without further changes using AF_BLUETOOTH sockets.

3.2. Command Line Interface

The InternalBlue Command Line Interface (CLI) offers a multicolored User Interface (UI) shown in Figure 3. It implements various commands to conveniently access the firmware on any Broadcom or Cypress Bluetooth chip:

• •

read and present memory in various different representations including disassembly,

• •

write data to memory in different representations,

• •

search for data in the memory of the firmware,

• •

execute custom code snippets in the firmware,

• •

activate monitor mode for HCI and forward the received packets to Wireshark (wireshark, ),

• •

inject arbitrary HCI packets, and

• •

establish connections by MAC address.

Moreover, the following extensions are available as assembly patches for BCM4339 on the Nexus 5:

• •

activate monitor mode for LMP over HCI,

• •

inject arbitrary—also invalid—LMP packets, and

• •

set tracepoints.

Executed commands are saved in a history file and it is possible to browse to an earlier command by pressing the arrow-up key as it is known from similar CLIs.

HCI and LMP monitoring modes directly open Wireshark with correct connection parameters, while the latter also applies the required patches to the firmware. To use InternalBlue simply as an HCI live monitor and injector on any Android device—no matter if the device has a Broadcom chipset or not—it is sufficient to recompile the Android Bluetooth stack with debug features. To the best of our knowledge, InternalBlue is the only project providing Python bindings to access HCI on remote Android devices.

3.3. LMP Monitor and Injection Mode

The LM is responsible for pairing, managing connections, as well as many other interesting processes which can now be monitored and modified with the feature developed in this section. In contrast to HCI, its contents are sent over the air between devices. As LMP operates exclusively beneath the HCI protocol layer, it is usually impossible to monitor or directly manipulate it from the host. By using the knowledge gained in Section 2.4 and the patching capabilities of InternalBlue, BCM4339 firmware can be modified to relay LMP packets to the host and provide an interface for injecting arbitrary LMP packets into an established connection.

The receive path of the monitor mode patch is illustrated in Figure 6. It starts at the LMP_dispatcher function that processes incoming packets by invoking the responsible handler function for the specific LMP opcode. By hooking the dispatcher function, the received packet can be copied and transferred to the host via a custom HCI event packet. In addition, the function send_LMP_packet responsible for sending LMP packets to a remote device is also hooked in order to have access to those packets on the host. At the host side, the monitor feature installs an HCI receiver callback, which listens for the custom HCI events, processes them and passes the LMP packets to a Wireshark instance. As Wireshark is not able to dissect LMP packets by default, it is necessary to install a custom dissector plugin for this protocol. Fortunately, the Ubertooth project (ubertooth:project, ) includes such a plugin that, after minor modifications and functional bugfixes, can be used for this purpose. The InternalBlue command monitor lmp start automatically installs hooks for monitoring LMP traffic inside the firmware and starts a Wireshark instance as seen in Figure 5.

Injection of arbitrary LMP packets into an established Bluetooth connection works by invoking the send_LMP_packet function inside the firmware, which in turn will enqueue the packet into the queue for outgoing LMP packets. To this end, the payload and a small assembly code stub are written to the RAM and invoked with the Launch_RAM HCI command. The stub copies the payload into a freshly allocated buffer and calls the send_LMP_packet function with a pointer to the corresponding connection structure. It also makes sure that the Transaction ID (TID) bit in the LMP header is set correctly based on whether the device is master or slave in the connection. If the fuzzing feature is enabled over the command line, an additional patch skips opcode and packet length checks.

4. Testing for Known Security Issues

Inside the InternalBlue CLI we implement the feature to connect to any device by its MAC address even without prior pairing, as described in Section 4.1. As a demonstration of security research, we implement device testing for the so-called Niño attack—pairing devices without input and output—in Section 4.2 as well as an attack on ECDH device pairing key exchange in Section 4.3.

Implementations of the ECDH and Niño tests are not contained as InternalBlue commands but as example files222https://github.com/seemoo-lab/internalblue/tree/master/examples that use functions of InternalBlue as library. Since the connecting smartphone itself performs the attacks and there is no such thing as Man-In-The-Middle (MITM), then these implementations are only suitable for testing how other Bluetooth stacks react to ECDH and Niño attacks—we do not provide active attacks on a victim’s established connections.

4.1. Establishing Connections to “Invisible” Devices

Bluetooth devices can be invisible to scanning but still accept connections. This is the default behavior for a setup with a smartphone and a headset, with the headset connecting to the smartphone when turned on knowing its MAC address from previous communication. Surprisingly to most users, initiating a connection request to a device does not require previous pairing. Everything that needs to be known is a valid MAC address (2009:ossmann, ). InternalBlue can list the array of all current connections and initiate new connections with the command syntax connect de:ad:be:ef:00:00.

Existence of a connection inside the firmware’s list is required to send LMP packets. This list differs from the list of known devices on the host, it is just meant to manage connection statuses of ongoing connections. A connection is not required to be established to appear in this list, it is sufficient to initiate a connection. If a connection establishment is not successful, it will stay half a minute inside the firmware’s list until it is deleted. This allows to send arbitrary LMP commands to arbitrary devices without successful pairing.

4.2. No Input No Output

Bluetooth provides pairing based on ECDH key exchange with Secure Simple Pairing (SSP) to be secure against passive and active MITM attacks. Security against active MITM is provided by visual number comparison or entering a number shown on one device with a keyboard on the other device. This protection requires both devices to have Input and Output (IO) capabilities, which is often not the case for IoT gadgets and headsets. The fallback option in case of missing IO capabilities is to perform key exchange without active MITM protection, the so-called “Just Works” mode. The Bluetooth 5.0 standard explicitly marks this as being insecure, but does not suggest to show any warnings to the user.

Exchange of IO capabilities supported by the devices takes place before pairing. Since there is no established root of trust between them at this stage, IO capabilities are prone to active attacks themselves—an active MITM can replace capabilities by no input no output, also known as the Niño attack (hypponen2007nino, ).

We patch the SSP state machine and claim our Nexus 5 has no display and no keyboard. Our question is if vendors accept a “Just Works” pairing with asking a “yes/no” message or warn the user to check if the device they are pairing to really has no IO capabilities. Even though certificate warnings in browser have been there for years to warn users, warning from potentially insecure Bluetooth pairings seems to be uncommon. Neither Android nor iOS warn users about this.

Figure 7 shows a modified Nexus 5 pairing with an iPhone 6. The only modification in the SSP state machine function located at 0x303D4 is to always set the IO capabilities to 0x03 in variable 0x20387D, with 0x03 resembling no input and no output according to the Bluetooth 5.0 specification (2016:SIG, ). Algorithms within Nexus 5 are not coded to consider the case of no longer having a display with such a change, and continue passing a code to Android, which actually works because keys are derived similarly either way. iPhone 6 simply displays a “yes/no” message and pairing is achieved. Yet, operating systems seem to cache some of these information locally, making tampering with IO capabilities hard if not applied within each pairing. To ensure a Niño attack works, an attacker should be present during the first pairing. Users will not be displayed any warnings if a Niño attack fails due to detection of inconsistent IO capabilities, but pairing will be aborted.

4.3. ECDH Device Pairing Vulnerability Scan

Another application of InternalBlue is a security test for the fixed coordinate invalid curve attack (CVE-2018-5383) (2018:biham, ). This attack affects device pairing based on ECDH, both SSP used in classic Bluetooth and LE Secure Connections (LE SC) used in BLE. The underlying protocol vulnerability exists if a Bluetooth implementation does not check for invalid curve parameters in the key. Since the Bluetooth standard does not consider countermeasures against this type of attack mandatory, vulnerable implementations are widespread. Testing for this attack is not straightforward, though, as the authors did not release any tools and the attack requires special hardware.

We implement the semi-passive fixed coordinate invalid curve attack, which zeroes the y-coordinates of both public keys, belonging to the InternalBlue smartphone and the device under test. If the device under test does not perform an invalid curve parameter check, this semi-passive attack would be successful in 25% of all device pairing attempts under the original attack’s assumptions (2018:biham, ). In contrast, the InternalBlue success rate is raised to 50% by setting an even smartphone private key, which is possible since the attack model is not a wireless link under control but the actual smartphone initiating a connection. Although not performing this attack as MITM, testing other smartphones is fast and portable with our solution.

InternalBlue could also help to fix this vulnerability in older Broadcom Bluetooth chips. Applying security patches this way is feasible if a vendor is no longer supporting old chips or reacts slowly in publishing updates.

5. Discovering and Fighting New Vulnerabilities

While exploring command handlers we have found a severe vulnerability affecting a variety of devices, as described in Section 5.1. To analyze the vulnerability’s impact, we implement runtime testing and emulation solutions, as detailed in Section 5.2, which can also be used to detect further bugs or simply to locate and dissect more functions and realize more features. In Section 5.3 we come up with a solution that can help against even more attacks.

5.1. Remote Code Execution Vulnerability

In the following we explain how we discovered CVE-2018-19860, a vulnerability allowing to execute a subset of functions within a large set of Broadcom firmwares. The vulnerability only requires the device under attack to have Bluetooth enabled, no previous pairing or visibility to the attacker are required.

5.1.1. Vulnerability

While dissecting the LMP dispatcher and analyzing its functions, we found vendor specific commands. The Bluetooth standard only defines vendor specific commands on HCI layer which can be locally executed on the host as superuser, but Broadcom uses LMP opcode 0x00 for Broadcom Proprietary Control Signaling (BPCS) mapped by lm_BPCS_getLmpInfoType. Exploring this unusual LMP handler we discovered that it accepts 256 input values in the field following opcode 0x00. Broadcom only intended to implement BPCS commands 0x0000–0x0005. Each of these commands is defined in the same handler table syntax as the standard LMP handler described in Section 2.4, but because of a missing range check commands 0x0006–0x00ff interpret memory located after the intended BPCS handler table similarly.

Compilers tend to put similar library functions close to each other. Even though compiling is hard to predict and contents are different for each Broadcom chip, it is very likely that handler tables are put after each other. On Nexus 5 other handler tables are indeed put after the BPCS handler table and include an interesting selection of HCI commands shown in Figure 8 that never should be launched from a remote host, such as Launch_RAM. Function arguments are passed in different only partially controllable registers when called over this path, for example, Launch_RAM is executed but always launches an invalid address. Execution of invalid commands or accessing invalid memory just crashes the Bluetooth firmware and has no further side effects. On some operating systems, the driver restarts Bluetooth automatically within a minute, but even in this case ongoing connections are interrupted. In general, chances to simply crash the Broadcom firmware are high.

Interpreting out of bounds commands in Figure 8 also results in extremely long LMP packets, i.e. the handler for command 0x0095 has a length of 219 bytes. When trying to use InternalBlue’s sendlmp 00 95, the packet seems to be sent according to the monitoring hooks but is never actually sent because the LMP packet buffer is limited to 32 bytes. When attacking other smartphones with a Nexus 5, the attacker first needs to patch the vulnerable BPCS handler locally and can then change length and option fields. A Nexus 5 under attack will not wait to receive all 219 bytes and just interprets the LMP packet with the wrong length.

BCM4339 on Nexus 5 is a combo chip using a shared antenna for Bluetooth and Wi-Fi. Further investigating crashes on Nexus 5 shows that crashes result in 2–5 s interrupts on 2.4 GHz Wi-Fi only. 5 GHz Wi-Fi is not affected. Similar Wi-Fi interrupts also happen during normal Bluetooth pairing. However, they do not seem to happen when regularly exchanging data. Default configuration of many systems is to restart Bluetooth after a crash, an attacker can reduce Wi-Fi performance multiple times by attacking again when the Bluetooth of the victim reappears. Analyzing possible causes for this behavior is complicated—it could range from incorrect sharing of the antenna up to Android specific issues.

5.1.2. Affected Devices

Vulnerable devices are easy to detect as they do not answer BPCS commands with LMP_not_accepted. Very old Broadcom chips do not implement these commands at all and are not vulnerable. Broadcom did not share a list of vulnerable devices after we reported the issues, but we found an interesting selection listed in Table 3 by testing devices we had access to. A major version number of 5 or lower seems to be secure against our attack, but corresponds to the outdated Bluetooth 3.0 standard (linkmgrassignednums, ). Only some of the chips with major version 8 were vulnerable, which corresponds to Bluetooth 4.2.

Prior to pairing, devices need to exchange their version number within a LMP_version_req and LMP_version_resp to know which version of the Bluetooth standard is supported by each other. This request also includes a subversion that further specifies the firmware version running on the chip. This gives the attacker hints which payload could execute meaningful functions.

We extracted firmware from various vulnerable and non-vulnerable devices to further trace down when the function lm_BPCS_getLmpInfoType was fixed and if handlers located behind are indeed HCI or similar interesting functions. Firmware internals of those versions that give most insights about patching are listed below.

**Raspberry Pi 3 / BCM43430A1: **

is vulnerable and its build date is June 2 2014. It has a few callback function tables located in the vulnerable memory region, but most of the memory is filled with encryption constants.

**Raspberry Pi 3+ / BCM4345C0: **

is not vulnerable and its build date is August 19 2014.

**MacBook Pro 2016 / BCM20703A2: **

is vulnerable and its build date is October 22 2015. Various callback and HCI function tables are located in the vulnerable memory region.

We assume that Broadcom internally discovered this bug in summer 2014, but was not aware of its criticality at all when adding the missing BPCS opcode check. Moreover, a newer build date does not necessarily mean that a firmware has the newest library versions, as the BCM20703A2 example shows.

As firmware development cycles are quite long—even the evaluation board is shipped with a one year old firmware—devices released in 2016 are still vulnerable. We estimate around half of the devices with Broadcom Bluetooth chips actively used in December 2018 to be vulnerable.

5.2. Firmware Emulation and Fuzzing

Exploring abilities gained with the BPCS vulnerability is hard. In order to analyze crash causes and impact of non-crashing functions we develop a toolchain that does not only allow hunting exploits but actually exploring flow of information throughout the firmware.

5.2.1. Tracepoints

Functions are reached over long call graphs with parameters depending on many dynamic inputs. The InternalBlue command tp add 0x3f3f4 adds a tracepoint to LMP_dispatcher. Each tracepoint is realized as Patchram hook. Once a tracepoint is called, it is deleted from Patchram to prevent the firmware from being stuck in tracepoints while debugging. A tracepoint imitates the behavior of the original Broadcom fault handler contained in the firmware and dumps all register contents as well as stack and heap but continues operation afterward. Multiple tracepoints can be observed in a row, i.e. to check behavior of multiple functions called for a given input.

An example output for LMP_dispatcher is shown in 1. The link register points to a function Broadcom named lm_handleLmpMsg, r0 points to lm_curCmd.

5.2.2. Emulation with Unicorn and Radare2

To investigate the LMP handler remote code execution, we use registers from a tracepoint of LMP_dispatcher but install a second tracepoint in the handler for BPCS itself to dump the according stack and heap contents of a BPCS payload. With a combination of Unicorn and Radare2 we modify a Python script that emulates LMP_dispatcher (radare2, ; unicorn, ; hugo, ). BPCS commands are passed by changing the according blocks in the stack and heap memory region. Emulation of an LMP command stops if the end of LMP_dispatcher is reached or a timeout is exceeded.

A call trace for LMP_dispatcher is given in 2. In this case, the function is passed the LMP packet 0x000a. Following handler tables as in Figure 8, position 0x0a in the misinterpreted BPCS handler table simply calls a NULL pointer that is then interpreted as a function address, and ROM contents at 0x00000 are executed. This trace is still very short because it crashes immediately, however traces can become very complex and hard to analyze.

5.2.3. Call Trace and Memory Interpretation

The emulator recognizes branches and extracts addresses when entering a new block after a branch to generate a detailed call trace. Moreover it dumps memory after finishing execution, which can later be compared to the original state. BPCS commands that depend on arguments passed to the handler can be located by emulating the same commands multiple times with different inputs and then searching for traces with different execution paths or by memory differences.

5.2.4. Crafting Exploits: Turn Remote Devices Into Jammers

One function standing out in memory analysis changes the content of a very high memory section, which turns out to be responsible for test mode configuration. Further investigation reveals that the LMP payload 0x0095 calls the HCI handler function enabling device under test mode. Without being embedded into HCI logic the function gets executed but never appears in HCI Snoop Log on the host. Therefore, a host under attack will not be able to filter or observe this event.

After enabling test mode with the malicious payload, LMP_test_activate and LMP_test_control can be used to run tests. The master controls test mode and the slave is the device under test. Each test is performed for multiple seconds. During a test, master and slave usually hop over all channels defined in their Adaptive Frequency Hopping (AFH) configuration. In conjunction with LMP_set_AFH, AFH can be disabled on the attacked device; thus, causing it to jam a selected frequency, which could be pilots of a Wi-Fi signal the attacker wants to block. To enable jamming of a single frequency, the LMP_set_AFH payload must contain a valid Bluetooth clock, which requires writing an assembly patch. A sequence of frames successfully turning a Nexus 5 and Xperia Z3 into a remote jammer is given in 3. Note that LMP_set_AFH is not under perfect control of the attacker without passing a proper Bluetooth clock. AFH is not stopped on the attacking device but the device under attack nevertheless temporarily accepts the AFH configuration. With the presented payloads, the device under attack keeps hopping on all Bluetooth channels most of the time as shown in Figure 9.

5.3. MAC Address Filter

As a basic defense against devices injecting malicious frames, a MAC address filter can be used. Typically, users only use a few devices they trust such as a headset. We implement a whitelist inside LMP_dispatcher. Untrusted devices are rejected within LMP—an attacker not imitating a valid MAC address cannot establish connections and not even tamper with any of the LMP handlers or protocols above. To successfully imitate a MAC address, attackers need to analyze traffic with a Software-Defined Radio (SDR) for a while to calculate the target address from demodulated signal chunks (2009:ossmann, ). In contrast to Wi-Fi, Bluetooth chunks do not contain full MAC addresses, therefore guessing these is harder than in Wi-Fi.

Currently, the MAC address filter is implemented as a simple Python proof of concept executed at runtime by using InternalBlue as a library. It can be integrated into more user friendly solutions, such as an Android app that automatically generates a permanent HCD file allowing only connections from devices that were successfully paired at the time of its generation.

A MAC address filter is not required to defend against CVE-2018-19860 by now, as most vendors rolled out patches. Broadcom did not include us in the feedback loop after informing vendors in December 2018, but we tested previously affected devices and can confirm that our vulnerability was fixed in iOS 12.1.3. The macOS update fixing the vulnerability increases the LMP subversion by one.

6. Related Work

To the best of our knowledge, InternalBlue is the only framework that allows Bluetooth lower layer functionality to be patched on off-the-shelf devices. InternalBlue was inspired by Nexmon, a similar project from our group, which realizes modifications on the Wi-Fi part of BCM4339 (2018:schulz, ). Despite residing in the same chip, Wi-Fi patching is realized very differently.

External tools for Bluetooth analysis always use an MITM setup. No changes are required on the devices to be sniffed. However, the MITM must successfully follow frequency hopping and overhear initial pairing to break encryption. Older variants of classic Bluetooth and BLE have a weak encryption and passive MITM is sufficient. If appropriate encryption is used, the MITM must actively inject traffic during key exchange. Depending on the physical setup and tool implementation, breaking pairing might take multiple tries—in either case the setup is rather artificial and users will be most likely aware of sniffing. InternalBlue does not have any of these issues in a sniffing setup and supports classic Bluetooth as well as BLE, since it is part of the communication, but due to serving a similar purpose we briefly introduce other Bluetooth sniffing tools in the following.

The most popular open-source solution Ubertooth (ubertooth:project, ) is an SDR extended with Bluetooth capabilities, therefore providing PHY access if frequency hopping succeeds. BLE sniffing support is quite good as its PHY is rather simple, but classic Bluetooth sniffing is very limited and not even attacks on bad encryption techniques are implemented (spill2007bluesniff, ). At a cost of 120$ it is comparably cheap (ubertooth_attify, ). It might be possible that InternalBlue can also modify PHY behavior. The Nexmon project altered the Wi-Fi part of BCM4339 and actually found a re-programmable real-time D11 core (2018:schulz, ).

Due to the simplicity of BLE, there exist a lot of low-price sniffers, such as the BLE 4.0 Bluefruit LE Sniffer for $25 (bluefruit, ).

The BLE 4.2 CY5677 platform (cy5677, ), which was used to implement the ECDH device pairing attack (2018:biham, ), only costs $20 and comes with CySmart to re-program the USB dongle’s behavior (cysmart, ). For lower layers, it only allows to set some variables, which includes scan, connection, and security parameters. Advanced protocol support is only provided for layers above HCI, such as Generic Attribute Profile (GATT) and Logical Link Control and Adaption Protocol (L2CAP).

Ellisys offers the best available Bluetooth tools in their Tracker, Explorer and Vanguard series (ellisys-bv1, ), but at the highest price (around $10k-$20k). According to the Vanguard documentation, live views and logs of all layers are displayed, and injections on HCI layer are possible. Though, there is no interface to implement custom lower-layer functions.

7. Discussion

After describing the implementation InternalBlue and demonstrating that it is possible to develop capable tools with the framework, we discuss its strengths, limitations, and impact.

Portability to Other Platforms

An ongoing task is porting InternalBlue to other members of the Broadcom and Cypress Bluetooth-Wi-Fi chip series. We already ported some of the features to the BCM4358 chip, which is part of the Nexus 6P, Samsung Galaxy S6 and Samsung Galaxy S6 edge. We verified that reading and writing RAM works on very old chips, such as the BCM2070 with a firmware from 2008. Moreover, instead of requiring a rooted Android device with a recompiled kernel module, we developed more a user-friendly solution based on BlueZ sockets on Linux to support the cheaper Raspberry Pi 3/3+ (BCM4343/BCM4345). Another work in progress is firmware analysis of the Bluetooth 5.0 (2016:SIG, ) compatible chips such as CYW20735, which still provide Broadcom commands for firmware modification. Since newer Bluetooth standards are backward compatible, recent Broadcom firmware still contains many functions from older versions. Nevertheless, changes in the underlying operating system and data structures exist; hence, porting still requires reverse engineering efforts.

To port InternalBlue to non-Broadcom platforms, their firmware update mechanisms have to be reverse engineered. Significant functions and data structures have to be located similar to our description in Section 2. Doing so is very time consuming and Broadcom Bluetooth chips have a market share in the range of 20%–30%. Thus, we did not make any efforts to support other vendors so far.

Early Bluetooth 5.1 Adaptation

InternalBlue can also help to implement features from the new standard before they are available on the market. The newest Bluetooth 5.1 (2019:SIG, ) was just released and as of now no hardware is available. Bluetooth 5.1 adds Angle of Arrival (AoA) and Angle of Departure (AoD) localization. As these require PHY adjustments, successful reverse engineering down to a level where Broadcom chips can be used as SDR is required. However, Bluetooth 5.1 also introduces new advertisement and power saving mechanisms for the link layer, which are probably easy to implement as binary patches.

Stability

When experimenting with Ubertooth, getting a setup that actually sniffs a complete connection is challenging. This problem class does not apply to InternalBlue—one of the bigger advantages of being able to modify a stable and well-maintained firmware while it is part of a fully functional Android Bluetooth stack. Yet, any crash due to firmware modifications will cause the Android system to reset the chip; therefore it is recommended to carefully test all InternalBlue patches to keep the same level of stability as in the original firmware. Stability depends on finding a memory region that is not used by other threads, which is very challenging on the Nexus 5 but easy on the Bluetooth 5.0 evaluation kit. We are currently improving stability by reverse engineering how memory management and message queues work.

Wi-Fi and Bluetooth Coexistence

Most Broadcom chips support Bluetooth and Wi-Fi. They run on different ARM cores but share some components such as the 2.4 GHz antenna. We found that Broadcom supports interesting features such as a Received Signal Strength Indicator (RSSI) sweep over all Bluetooth channels on the local interface to figure out how they interfere with Wi-Fi and select channels properly. Artifacts in the evaluation kit firmware even indicate that LTE coexistence management exists. How well-separated Bluetooth, Wi-Fi and LTE components are in terms of performance and security remains an open research topic.

Wireless Firmware Security

Patching the vulnerable LMP handler requires only 14 Bytes of machine code on Nexus 5. This appears to be a simple fix, but installing it to all vulnerable devices is not. Smartphones in a non-rooted standard configuration cannot use InternalBlue and need to be provided with operating system updates that include new HCD files. Older vulnerable devices might not be updated—Broadcom confirmed us in December 2018 that they will provide patches, but they did not mention which devices will be fixed specifically.

Publishing patches as HCD files is generally risky, as they are neither encrypted nor signed by Broadcom. Therefore, patches are easy to reverse engineer and releasing a patch will disclose the vulnerability. Moreover, information leaks such as a full list of function and object names in patch.elf of WICED Studio are dangerous for Broadcom’s security by obscurity approach.

After first reverse engineering results of Broadcom Wi-Fi chips were published (nexmon:project, ) it did not take long until security researchers found severe security bugs in its implementation (2017:googleprojectzero, ). They further analyzed these bugs to ultimately obtain privilege escalation in the operating system with the Bluetooth driver’s superuser rights on Apple devices. Even proprietary protocol extensions such as Apple Wireless Direct Link (AWDL) based on Wi-Fi and Bluetooth had major security issues in the past (milan, ). Reverse engineering shows that security in today’s wireless chips depends a lot on obscurity, which is not a sufficient measure.

In general, security-concerned users should turn off their device’s Wi-Fi and Bluetooth whenever they are not needed. Modern smartphones sometimes require to disable Wi-Fi and Bluetooth in the system settings to not just have them in a standby mode. On the one hand, this also increases battery lifetime and avoids tracking of users. On the other hand, a modern smartphone without wireless services is severely impaired in its abilities.

Bluetooth Security Evaluation Toolkit

InternalBlue and its applications are filling the gap in the inventory of security-related Bluetooth tools. Not only important and novel features such as LMP monitoring and injection are added, but also the ECDH device pairing vulnerability scan demonstrates its usage as testing toolkit for advanced attacks. InternalBlue is limited to run on Broadcom and Cypress chips due to its code modification mechanisms, but devices under test can be of any kind.

Indeed, InternalBlue is powerful for LMP analysis. By leveraging LMP injection capabilities it is possible to audit other Bluetooth devices by enumerating proposed pairing and encryption capabilities.

Analyzing the extracted firmware enables emulation for fuzzing as well as static code analysis. This paper only analyzed LMP but there are more Bluetooth subprotocols that can contain bugs or are of interest for developing and testing optimizations.

8. Conclusion

In the motivation we pointed out the shortage of openly available research tools that allow for efficient experimenting on Bluetooth protocol layers beneath the HCI. This work documents the development of InternalBlue, a novel analysis and research platform for lower Bluetooth protocol layers. The framework is based on multiple Broadcom Bluetooth chipsets, whose firmware has been reverse engineered and documented in the process. Undocumented patching mechanisms to even change ROM contents could be dissected from the firmware update procedure and therefore InternalBlue benefits from the ability to reuse and modify the existing Bluetooth stack implemented in the controller. These patching mechanisms exist at least throughout firmware versions from 2008 to 2018. We found that newly released off-the-shelf devices typically are shipped with two year old wireless chips, so even if Broadcom decided to secure their patching mechanisms today, InternalBlue will continue to work on hardware released over the next few years.

Eventually, the framework has proven itself as a powerful tool for LMP monitoring and injection, as well as a security testing toolkit. With this paper, we lay the groundwork for the community to further contribute to advanced Bluetooth research. Even though InternalBlue is based on Broadcom chips, it can be used to probe other, non-Broadcom Bluetooth devices.

Overall, the addition of a new tool to the inventory of researchers advances the state of Bluetooth security and facilitates integration of new protocol features. Furthermore, reverse engineering the firmware of a commercial Bluetooth controller paves the way for open reviews by the security community and may reveal vulnerabilities that have been hidden up to this point.

Acknowledgments

We thank Broadcom for providing CVE-2018-19860 patches to vendors. We also thank Oliver Pöllny for proofreading and feedback.

This work has been funded by the dfg as part of project S1 within sfb 1119 crossing, as part of project C.1 within the rtg 2050 “Privacy and Trust for Mobile Users”, sfb 1053 maki; and the bmbf and the State of Hesse within crisp-da.