Stay fit: Hack a Jump Rope
Axelle Apvrille (Principal Security Researcher · Fortinet)
TROOPERS23 · Day 1 · Attack & Research · Attack & Research
Overview
In this engaging talk at TROOPERS, Axelle Apvrille, a Principal Security Researcher at Fortinet, demystifies the process of hacking connected Internet of Things (IoT) devices, using a smart jump rope as a practical and accessible example. Apvrille, a specialist in reversing mobile and IoT malware, demonstrates how even seemingly simple and inexpensive devices can expose their communication protocols through surprisingly straightforward methods. The presentation serves a dual purpose: first, to illustrate an efficient methodology for reverse engineering Bluetooth Low Energy (BLE) communication without specialized hardware or invasive techniques, and second, to share insights into creating compelling and robust Capture The Flag (CTF) challenges centered around IoT devices.

Key moments
- 0:00 Introduction and talk overview
- 5:30 Hacking Bluetooth LE from Android system logs
- 7:45 Live demo: Capturing BLE packets via logcat
- 10:30 Live demo: Linking BLE logs to app code
- 17:30 Live demo: Sending custom commands to the jump rope
- 19:30 Designing a CTF challenge for the hacked jump rope
- 21:30 Implementing a 'fake jump rope' for the CTF
- 26:00 Q&A: Challenges of server-side BLE implementation
Stay fit: Hack a Jump Rope
Speakers: Axelle Apvrille, Principal Security Researcher, Fortinet
Conference: TROOPERS
YouTube: https://www.youtube.com/watch?v=f0y8spTTGZQ
Overview
In this engaging talk at TROOPERS, Axelle Apvrille, a Principal Security Researcher at Fortinet, demystifies the process of hacking connected Internet of Things (IoT) devices, using a smart jump rope as a practical and accessible example. Apvrille, a specialist in reversing mobile and IoT malware, demonstrates how even seemingly simple and inexpensive devices can expose their communication protocols through surprisingly straightforward methods. The presentation serves a dual purpose: first, to illustrate an efficient methodology for reverse engineering Bluetooth Low Energy (BLE) communication without specialized hardware or invasive techniques, and second, to share insights into creating compelling and robust Capture The Flag (CTF) challenges centered around IoT devices.
The talk highlights a critical often-overlooked entry point for IoT security research: the companion smartphone application. By leveraging readily available Android system logs and basic reverse engineering tools, Apvrille shows how to uncover the intricate details of a device's communication protocol. This approach not only makes IoT hacking more accessible to a broader audience but also underscores the importance of secure application development practices for connected devices. The insights gained from dissecting the jump rope's protocol are then ingeniously applied to construct a challenging yet solvable CTF scenario, demonstrating the practical application of security research in an educational context.
Background
▶ Watch: Introduction and talk overview (0:00)
The landscape of IoT security often conjures images of complex hardware teardowns, sophisticated radio frequency (RF) sniffing equipment, and deep firmware analysis. Traditionally, researchers might start by physically disassembling a device to identify internal components, extract firmware via JTAG or SPI, or use tools like Ubertooth or Adafruit BLE Sniffer to capture over-the-air Bluetooth Low Energy (BLE) packets. While these methods are powerful, they can be costly, time-consuming, and require specialized skills and equipment. Apvrille's research, initiated during the COVID-19 lockdown, sought a more accessible and less invasive approach, driven by the practical need to analyze a device she still wanted to use.
The target device for this research was an inexpensive smart jump rope, retailing for approximately 20-30 Euros. Such devices, often considered "low-tech" and low-risk, typically feature an LCD screen, a single control button, and basic sensors for counting jumps. Internally, as revealed by FCC filings (a valuable resource like fcc.io for non-invasive hardware reconnaissance), it contains a Beken chip responsible for BLE communication and a separate board housing Hall sensors for jump detection. The modest price point implies a minimal investment in advanced security features, making it a prime candidate for demonstrating accessible hacking techniques. The core problem Apvrille aimed to solve was understanding and manipulating the device's communication protocol without physically altering or breaking it, thereby preserving its functionality. This led her to investigate the attack surface presented by the device's companion smartphone application.
Key Findings
▶ Watch: Live demo: Capturing BLE packets via logcat (7:45)
The central and most significant finding of this research is the remarkable efficacy of using smartphone application analysis as a primary entry point for reverse engineering the communication protocols of BLE-enabled IoT devices. Apvrille convincingly demonstrates that, contrary to common assumptions requiring specialized hardware, one can often fully understand and manipulate a device's BLE communication simply by inspecting the Android system logs and reverse engineering the companion mobile application.
Specifically, the key findings include:
- Direct BLE Packet Visibility in Android Logs: Android's logcat utility can expose the raw BLE packets exchanged between the companion app and the IoT device. By filtering logs based on the application's specific tag, researchers can observe the exact byte sequences being sent and received, effectively bypassing the need for expensive hardware sniffers.
- Protocol Discovery via App Reverse Engineering: Correlating these observed BLE packets with the application's disassembled code (e.g., Dalvik disassembly for Android Java applications) allows for the identification of functions responsible for handling specific commands. This iterative process reveals the structure of the communication protocol, including command bytes, data fields, and checksums.
- Predictable Command Structures: The jump rope's protocol, like many simple IoT devices, utilizes a relatively straightforward command structure. Specific byte sequences correspond to distinct functionalities (e.g.,
81for battery level updates,83for reading offline data). The presence of a simple CRC checksum at the end of each packet was also identified, which, while providing basic integrity, is easily computable and bypassable for an attacker. - Manipulation of Device Functionality: By understanding the protocol, Apvrille was able to craft and send custom BLE packets to the jump rope, effectively controlling its behavior. This included initiating specific modes (e.g., "number countdown mode" for a specified number of jumps, "time countdown mode" for a duration) and toggling features like the device's buzzer.
- Challenges and Solutions for CTF Design: The research also yielded significant insights into designing robust and engaging CTF challenges involving BLE devices. The difficulties encountered with obsolete BLE projects and the need for a reliable "fake" device implementation led to the adoption and adaptation of existing open-source code. Crucially, the discovery of a vulnerability where one team could "inherit" another's flag prompted the implementation of protective measures, such as limiting connections to one at a time and clearing the flag upon disconnect/reconnect.
These findings collectively highlight that many IoT devices, especially those at the lower end of the market, are vulnerable to analysis and manipulation through methods far less complex than commonly perceived. The companion app often serves as an unintentional "documentation" of the device's communication protocol, making it a prime target for security researchers.
Technical Deep Dive
▶ Watch: Live demo: Sending custom commands to the jump rope (17:30)
The technical core of Apvrille's methodology revolves around leveraging the Android operating system's logging capabilities and basic application reverse engineering to unravel the jump rope's Bluetooth Low Energy (BLE) communication protocol. This approach bypasses the need for specialized hardware sniffers, making it remarkably accessible.
The first step involves capturing the BLE traffic. Instead of an Ubertooth or Adafruit BLE Sniffer, Apvrille utilized Android logcat, a command-line tool that dumps system messages and application-specific logs. The key insight here is that many Android applications, particularly those interacting with BLE devices, log the raw BLE packets they send and receive. By connecting the smartphone to a computer and running adb logcat, then filtering for the specific tag used by the jump rope's companion application, all relevant BLE packets become visible. Apvrille demonstrated this live, showing how the logs updated in real-time as she jumped, revealing hex strings representing the communication. For instance, a packet containing 81 was identified as relating to battery status.
Once the raw hex packets are captured, the next phase is to understand their meaning. This is achieved through reverse engineering the Android application. Apvrille used a disassembler to analyze the application's Dalvik bytecode (which can often be represented in a Java-like syntax for readability). The process is iterative:
- Identify a packet in logcat: For example, the packet associated with battery level.
- Copy the hex string: Take a unique portion of the packet.
- Search in the disassembler: Paste the hex string into the disassembler to locate where it appears in the application's code.
- Analyze surrounding code: Observe the function or method that handles this specific hex string. In the battery example, searching for the hex string led directly to a method named
update battery. This confirms the packet's purpose and reveals the logic parsing it.
This technique proved highly effective. By observing different interactions with the jump rope (e.g., connecting, starting modes, checking stats), Apvrille could capture corresponding packets and trace them back to the application's code. She highlighted a "juicy" function called parse command, which, as its name suggests, was central to interpreting incoming data. Inside this function, she found a CRC check (a basic form of error detection) and conditional checks on specific byte values. For instance, packets starting with 81 were routed to update battery, while those starting with 83 were directed to read offline data (for retrieving jump data stored when the rope wasn't connected to the phone). This systematic approach allowed her to map various hex sequences to their corresponding functionalities and understand the overall command structure. Each packet, she noted, concluded with a checksum (represented as cccc in her examples), which is simple to compute and append to custom-crafted packets.
After understanding what to send, the next challenge is where to send it. In BLE, data is organized into Services and Characteristics within the Generic Attribute Profile (GATT). Services group related functionalities, and characteristics are individual data points or control handles. To send a command, one must identify the specific writable characteristic associated with command input. While the talk doesn't detail the discovery of this characteristic, it's typically found by further inspecting the app's code or by enumerating the BLE services and characteristics of the connected device using tools like bluetoothctl or various mobile BLE scanners.
With the protocol understood and the target characteristic identified, custom packets can be crafted. Apvrille used bluetoothctl, a command-line utility available on Linux, to interact with the BLE device. The process involves:
- Connecting to the jump rope via
bluetoothctl. - Identifying the correct characteristic handle for writing.
- Constructing the desired command in hex, including the data payload (e.g.,
1337jumps translates to539in hex) and the calculated checksum. - Using
bluetoothctl'swritecommand to send the crafted hex packet to the characteristic.
This detailed methodology demonstrates a powerful, low-cost, and non-invasive approach to reverse engineering BLE protocols, making it accessible even for researchers without specialized hardware.
Demo / Proof of Concept
▶ Watch: Designing a CTF challenge for the hacked jump rope (19:30)
Axelle Apvrille provided a compelling live demonstration that showcased both the packet sniffing capabilities and the ability to control the jump rope through crafted BLE commands.
The first part of the demo illustrated the ease of capturing BLE packets directly from an Android phone's system logs. With her smartphone connected and running the jump rope's companion application, she initiated a jumping sequence. As she jumped, the logcat output, displayed on the screen, continuously scrolled with a stream of hex packets. She pointed out specific packets, such as one containing 81, which she previously identified as related to the battery level, demonstrating the real-time visibility of the device's communication. This visual proof immediately underscored the core finding: raw BLE data is often readily available without external sniffing hardware.
The second, more impactful part of the demonstration involved sending custom commands to the jump rope. Apvrille connected to the physical jump rope using bluetoothctl on a Linux system. She then demonstrated how to craft specific commands:
- Setting a number countdown mode: She showed the command to instruct the jump rope to initiate a countdown for
1337jumps. Upon sending this packet, the jump rope's LCD screen immediately updated to display1337, confirming that the custom command was successfully received and processed. - Controlling the buzzer: She then showed how to send a command to enable the jump rope's buzzer. After sending this, the device audibly beeped, further validating her control over its functionalities.
- Setting a time countdown mode: To illustrate another mode, she sent a command to set a time countdown for
600seconds. The jump rope's display promptly switched to600, indicating it was ready for a timed exercise. She then cancelled this mode, demonstrating full command-and-control capabilities.
The live demo was crucial in proving the efficacy of her methodology. It moved beyond theoretical explanation to practical, observable manipulation of the physical device, showcasing that the discovered protocol could indeed be used to dictate the jump rope's behavior. This hands-on demonstration cemented the talk's core message about the accessibility and effectiveness of smartphone-centric IoT hacking.
Defensive Implications
▶ Watch: Q&A: Challenges of server-side BLE implementation (26:00)
The insights from hacking the smart jump rope carry significant defensive implications for developers and manufacturers of IoT devices, particularly those relying on Bluetooth Low Energy (BLE) communication. The ease with which Apvrille reverse engineered the device's protocol highlights several common vulnerabilities and best practices that need to be adopted:
- Avoid Logging Sensitive Data (or any data) in Cleartext: The most critical defensive implication is the pervasive logging of raw BLE packets in Android's logcat. While convenient for debugging during development, this practice essentially creates a detailed "spec sheet" of the device's communication protocol for anyone with access to the phone's logs. Developers should ensure that production applications do not log raw communication data or any sensitive information in an easily readable format. Log levels should be carefully managed, and debug logging should be disabled or stripped for release builds.
- Implement Robust Authentication and Authorization: The talk implied that any crafted packet, once correctly formatted, could control the device. This suggests a lack of strong authentication or authorization mechanisms for commands. IoT devices should verify the authenticity of commands and ensure that only authorized entities (e.g., the legitimate paired app, after a secure handshake) can send control commands. Simple checksums (like the CRC found) offer only integrity, not authenticity or confidentiality.
- Encrypt Communication: While BLE offers some native security features, they are often optional or poorly implemented. For any command that alters device state or transmits personal data, the communication should be encrypted end-to-end. This prevents eavesdropping and tampering, even if packets are captured.
- Obfuscate and Protect Companion Applications: The companion mobile application proved to be the primary attack surface. Developers should employ code obfuscation techniques to make reverse engineering more difficult. While not foolproof, it raises the bar for attackers. Additionally, ensure that hardcoded secrets, API keys, or critical logic are not easily extractable from the app's binary.
- Consider Threat Models for Inexpensive Devices: Manufacturers of low-cost IoT devices often assume a low threat model due to the device's limited functionality or price point. This research demonstrates that even a simple jump rope can be manipulated, potentially leading to privacy concerns (e.g., falsifying fitness data) or even safety issues in more critical applications. A comprehensive threat model is essential, regardless of device cost or perceived complexity.
- Secure Over-the-Air (OTA) Updates: Although not directly exploited in this talk, the mention of an OTA service in the CTF challenge context is a reminder of the importance of securing firmware updates. OTA updates must be cryptographically signed and verified to prevent malicious firmware injection.
In essence, the talk serves as a stark reminder that the "Internet of Things" often means the "Internet of Insecure Things." Developers must adopt a security-first mindset, treating companion applications and BLE protocols as critical components of the attack surface, not just functional interfaces.
Key Takeaways
- Smartphone Apps as Primary Attack Surface: For many BLE-enabled IoT devices, the companion smartphone application provides the most accessible and cost-effective entry point for security research, often negating the need for expensive hardware.
- Android Logcat is a Powerful Sniffing Tool: Android's
logcatutility can reveal raw Bluetooth Low Energy (BLE) packets exchanged between an app and a device, effectively acting as a software-based sniffer without requiring specialized hardware. - Reverse Engineering Apps Unlocks Protocols: By correlating observed BLE packets in system logs with the disassembled code of the companion application (e.g., Dalvik bytecode), researchers can systematically reverse engineer and understand proprietary communication protocols.
- Simple Protocols are Easily Manipulated: Many inexpensive IoT devices use straightforward BLE protocols with basic checksums, making them vulnerable to crafted commands that can alter device state or functionality (e.g., initiating specific modes, controlling buzzers).
- CTF Design Requires Robust Security: Creating effective BLE-based CTF challenges necessitates careful design to prevent unintended solutions or flag harvesting, often involving "fake" devices and specific measures like connection limits and flag resets.
- IoT Security is Accessible and Critical: The talk demonstrates that IoT hacking is not exclusively for hardware gurus; accessible software-based techniques can expose significant vulnerabilities, emphasizing the need for robust security practices in even the simplest connected devices.
About the Speaker(s)
Axelle Apvrille is a Principal Security Researcher at Fortinet, a leading cybersecurity company. Her expertise lies in the challenging domain of malware research, with a particular focus on mobile and Internet of Things (IoT) malware. Apvrille is well-regarded in the security community for her practical, hands-on approach to analyzing and understanding complex threats in connected environments. Beyond her research, she is also the organizer of "Ph0wn," a Capture The Flag (CTF) competition specifically dedicated to connected objects, held in the south of France. Her work, as demonstrated in this talk, consistently bridges the gap between theoretical security concepts and their real-world application, often showcasing innovative and accessible methodologies for security analysis.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Axelle Apvrille knows her shit, but this is a 101-level tutorial on BLE reversing disguised as a TROOPERS talk. Dumping logcat to pull hex strings and mapping them back to Dalvik bytecode is a great trick for beginners, but it's nothing new. Solid educational filler that gets the job done without pretending to be a zero-day drop.
Heather Calloway (CISO) — SOLID
This is a deep-technical reverse engineering talk, so it isn't for the risk committee. But the underlying methodology is a wake-up call for any enterprise building mobile companion apps or allowing BYOD fleets. It proves that attackers don't need specialized hardware to compromise BLE devices when developers leave raw protocol data sitting in Android system logs.