# Brake Check: Hijacking Trailer Brakes Over Bluetooth

Source: https://elementdigital.com.au/blog/brake-check-trailer-brakes-over-bluetooth/
Published: 2026-11-19

> Any phone in Bluetooth range could apply an Elecbrakes trailer brake controller at any force, with no pairing. How we found it, the fix, and the six-month disclosure.

*By Patrick Forck and Jeremy McCarthy, Element Digital*

> **Disclosure status:** This vulnerability was reported to Elecbrakes under coordinated disclosure on 18 May 2026. Elecbrakes shipped a firmware fix for the EB2 and VM1 on 6 July 2026, seven weeks later. If you own one, **open the app and install the firmware update** before reading on. The update doesn't install itself: you have to open the app and start it. You want **EB2 firmware 3.0.4.4.3 or later, or VM1 firmware 1.3.4.2.1 or later**. Go on, we'll wait.
>
> If you own the older **ELBC 2000**, there is no fix yet. Elecbrakes has confirmed it has the same vulnerability, so every Elecbrakes controller - both models on sale today and the one before them - was affected. See [the ELBC 2000 section](#the-elbc-2000-the-model-without-a-fix) below.
>
> This write-up follows the disclosure date agreed with Elecbrakes (15 November 2026), four months after the fix reached the field. Elecbrakes tells us it is not aware of any reported incidents of damage or injury caused by these vulnerabilities. CISA's advisory covers three CVEs and publishes on 19 November - **CVE-2026-96805** (CVSS 9.6, Critical), **CVE-2026-125273** and **CVE-2026-124281**. The coordination process took considerably longer than the research did, which is itself covered [further down](#the-other-half-of-the-work-getting-a-cve).

---

## The one-sentence version

Any phone or laptop within Bluetooth range of an Elecbrakes trailer brake controller could apply that trailer's brakes - at any force, at highway speed - without pairing, a PIN, or any authentication whatsoever. Four bytes. No handshake. No "are you sure?"

The longer version has drive tests, a fuzzing session that lit up like a Christmas tree, an over-the-air (OTA) firmware channel with the security posture of a screen door, a small Australian manufacturer that engineered a genuinely good fix at impressive speed, and a coordination process afterwards that turned out to be harder and slower than any of the technical work.

Let's get into it.

---

## How this started: my brakes were talking to strangers

This research didn't begin with a threat model or a scope document. It began with me driving down the highway and noticing that my [Elecbrakes In-Car Remote](https://www.elecbrakes.com/products/remote) had connected to *someone else's trailer*. I didn't have my trailer on my car but I did have the remote powered on in the centre console.

It had connected mid-drive, without pairing or a prompt, to a brake controller that wasn't mine, on a trailer I'd never seen, belonging to a driver who had no idea.

The trailers this happened with most often are operated by Sensys Gatso for the Tasmanian Government, and look *very* similar to this:

![A white mobile speed camera trailer with its camera raised on a mast, parked at the kerb beside a busy road](./brake-check-speed-camera-trailer.jpg)

*Photo: Richard J. Ho, [Minch Media](https://www.minchmedia.com)*

[For the non-Tasmanians that may not recognise the trailer](https://www.speedcameras.tas.gov.au/who_operates_mobile_speed_cameras)

If you do security work, you know the feeling. That little cold prickle at the back of your neck that says *hang on, that shouldn't be possible - and it would be very bad if it were.* If a device I don't own will happily talk to my in-car remote driving past with zero friction… what exactly is stopping my phone or any other Bluetooth device from talking back?

Turns out: nothing. It was very happy to accept our 'requests'.

I own the trailer. I own the in-car remote. I have a professional interest in devices that will do dangerous things for anyone who asks, with no friction in the way. So my colleague Jeremy and I decided to find out how deep it went.

*(For the record, and for the lawyers: every single test in this post was performed on our own hardware, on private property or a closed setup. We never touched another person's vehicle. The "connecting to strangers" bit was the in-car remote doing that by itself, which is rather the point.)*

---

## A quick primer: what an Elecbrakes controller actually does

If you don't tow things, here's the deal. Trailers over a certain weight need their own brakes, and those brakes need a controller that applies them in proportion to how hard the tow vehicle is braking. Historically this was a box bolted under your dashboard.

Elecbrakes' clever idea was to move that box onto the trailer itself and control it over Bluetooth from an app or a little remote. Mount it once, tow with any vehicle, no re-wiring. It's a nice bit of kit, which is partly why it's so popular on Australian caravans, boat trailers, and horse floats.

Elecbrakes currently sells two models - the EB2 (the device I own) and the VM1. We have confirmed with Elecbrakes that these operate the same Bluetooth stack, so both were susceptible to this vulnerability. There's also an older model, the ELBC 2000, which hasn't been sold for a number of years but is still out there on trailers. Elecbrakes has since confirmed it has the same vulnerability, and it has no fix yet. More on that [further down](#the-elbc-2000-the-model-without-a-fix).

The important word here is **proportional**. This device decides how much braking force your trailer applies. It is, unambiguously, a safety-critical component. When it does the right thing, towing is smoother and safer. When it does the wrong thing, you are having a very bad day on a highway with several tonnes of trailer behind you.

Keep that framing in mind, because everything below is a story about a safety-critical device that trusted anyone who said hello.

---

## Step 1: We knew where to look - we just couldn't read the map

Here's the honest bit that's relevant to the whole story. Jeremy and I work in infrastructure, cloud and security. Between us we've spent a couple of decades deciding what "good" looks like and developing a nose for what "bad" smells like. What we are *not* is Android developers, and neither of us can sit down and read 5,000 lines of decompiled Smali bytecode.

So we didn't. We used AI - Claude in this case - to do the heavy lifting on the reverse engineering. We pulled the Elecbrakes Android app (`com.ElecBrake.Remote`), decompiled it, and fed it to Claude with a simple set of questions: *What Bluetooth characteristics does this thing talk to? What's the command format? Where's the authentication?*

The app itself is a perfectly respectable modern Android build - Kotlin, Jetpack Compose, a Nordic-style Bluetooth Low Energy (BLE) stack. What came back from the analysis was a map of the device's entire Bluetooth GATT profile: **47 characteristics across four services**, commands sent as plain unencrypted byte arrays, no checksums, no sequence numbers.

And that last question - *where's the authentication?* - came back with the most ominous possible answer for a brake controller: it couldn't find any on the control path. Not weak auth. Not broken auth. No auth code at all on the characteristic that mattered.

We also noticed the app only *shows* itself 42 of the 47 characteristics. It carries a UUID allow-list and quietly ignores the other five. Hiding characteristics from your own app's UI is a "note to self" at best. But it did tell us there was more surface here than the official app admitted to. Naturally, we wanted to see all of it.

There's a broader point here worth sitting with. This kind of research used to require a fairly rare and specific skill set. It now requires curiosity, a device you own, and an AI that can read bytecode faster than any human. The barrier to finding this class of bug just dropped through the floor, which is a lesson for every vendor shipping a connected product.

---

## Step 2: building a tool that could see everything

To talk to the *whole* device, including the parts the official app hid, we needed our own tool.

Jeremy built one with Claude on the first night swarm mode was available in Australia, in between Forza races. What it produced from a single prompt was a **Web Bluetooth research tool that runs in Chrome** and an Android app for the same purpose. While the Android app was built, we didn't end up using it as the Chrome tool had more than enough capabilities for what we needed. This required no specialised hardware, no BLE sniffer, no software-defined radio. A browser tab on my Windows 11 laptop. The single most alarming fact in this entire write-up is that the complete attacker toolkit is *a device with Chrome and Bluetooth* - the same laptop you'd use to check your email, order a pizza, or, in our case, lose repeatedly at Forza.

The best part of building it this way was the iteration speed. Every time the device did something surprising, we'd describe the new capability we wanted - an opcode fuzzer, a persistent-register reader, a state-change listener - and have it a few minutes later. The tooling kept pace with our curiosity. If the device did something odd at 10am, we had a tool to probe it before 11. We were essentially building the instrument and running the experiment in the same breath.

With my newly built tool on my laptop I headed down to our family shack for the day, which has a few acres of land and some private gravel roads to test on, and where my trailer lives most of its life. I tethered my phone, launched our app and got testing. Everything that follows was found in the next four hours. This wasn't a multi-day attack.

Using Web Bluetooth's `optionalServices` to bypass the app's UUID allow-list, we connected and dumped the full unfiltered GATT profile. And there it was, in black and white:

```
Service: b49c1e5f-...   (EB2 primary service)
  R W N  User Commands     18315e96-...   <-- BRAKE CONTROL
  R W N  State/Warnings    2f4d4806-...   <-- BRAKE STATE
  R W N  Program 1-5, System Params, Comms...

Service: 2f413b1e-...   (OTA / pairing-gated service)
  R N    Central Command   799b1b62-...   <-- PAIRING REQUIRED
  R W N  Central Response  c0244a8a-...   <-- PAIRING REQUIRED
```

The device has two tiers. Some things require Bluetooth pairing. Some things don't.

Guess which tier brake control was in.

---

## Step 3: the money shot

We tried to subscribe to everything, without pairing. The device's response is almost poetic in how precisely it protects the wrong things. *(Timestamps in these logs are UTC, so 23:40 was 9:40am local time.)*

```
[23:40:24.739] Failed to subscribe Bonding:          GATT Error: Not paired.
[23:40:25.217] Subscribed: User Commands              <-- brake control, NO PAIRING
[23:40:25.877] Subscribed: State/Warnings             <-- brake state, NO PAIRING
[23:40:26.702] Failed to subscribe Central Command:   GATT Error: Not paired.
[23:40:26.972] Failed to subscribe Central Response:  GATT Error: Not paired.
```

Look at that. The device is *perfectly capable* of saying "Not paired." It says it four times! It checks ID at the door for the bonding characteristic. It checks ID for the firmware update channel. And then, for brake control - the one function that can put a caravan through a guardrail - it waves you straight through without so much as a glance. The bouncer is meticulous about everything except the thing worth guarding.

So we wrote four bytes to the brake control characteristic. No pairing, no PIN, no prior anything:

```
[23:40:39.841] WRITE  User Commands:   14 00 00 00
[23:40:39.977] WRITE  User Commands:   OK
[23:40:40.008] NOTIFY State/Warnings:  03 00 00 20 ...
                                       ^^ 0x03 = brakes ENERGISED
```

The electromagnetic hum at the brake drums was immediate and, frankly, a little sickening. That `OK` is the sound of a safety-critical device with no survival instinct - it said yes to four bytes from a total stranger then energised several tonnes' worth of brakes and reported back that it had done so, pleased with itself.

Release is exactly as easy:

```
[23:53:00.312] WRITE  User Commands:   00 00 00 00
[23:53:00.472] NOTIFY State/Warnings:  00 00 00 20 ...
                                       ^^ 0x00 = brakes RELEASED
```

And here's the thing that turns this from "spooky demo" into "genuine attacker capability": the `State/Warnings` characteristic *notifies you back* on every state change. `0x00 → 0x03` when the brakes engage, `0x03 → 0x00` when they release. The device gives an attacker a real-time read receipt confirming their command worked. You don't even have to guess.

The command format decodes as:

```
14        00        00 00
^opcode   ^force    ^ignored
0x14      0x00-0xFF
```

Byte 0 is the opcode. Byte 1 scales electromagnetic force from a gentle nudge to *maximum*. Which brings us to the drive test.

---

## Step 4: yes, the force byte is real

You could reasonably ask whether that force byte does anything meaningful, or whether "maximum" is a rounding error. So we took it to a road (ours, closed, researcher-owned, etc.) and found out.

```
[00:56:31.248] WRITE User Commands: 14 00 00 00   <-- minimum force
[00:56:46.171] WRITE User Commands: 14 FF 00 00   <-- maximum force
```

`14 FF 00 00` produced dramatically stronger deceleration than `14 00 00 00` at the same speed. The force byte is a linear scale from "polite tap" to "slamming the brakes", and any Bluetooth device in range gets the full dial.

Sit with the highway version of that for a second. Your trailer's brakes slamming to maximum while your tow vehicle keeps going is the exact recipe for a jackknife - one of the more reliably fatal things a vehicle combination can do. And the attacker needs to know precisely nothing about you.

---

## Step 5: the fuzzing session

At this point an optimist might hope that `0x14` is a magic number - that an attacker would at least need to *know* the right opcode. So we fuzzed the whole first byte, `0x00` through `0xFF`, and listened.

It lit up everywhere.

```
0x01-0x13   Low power    (very quiet - ear-to-the-wheel quiet)
0x14        Standard     (the "official" opcode)
0x15-0x19   Standard     (adjacent cluster)
0x4A-0x4B   ABS / pulse  (higher pitch)
0x4C-0x51   Standard
0x52-0x64+  ABS / pulse
```
We haven't confirmed the ABS, standard and low-power modes with Elecbrakes. They're our assumptions, based on the real-world effects and the sound of the electromagnets while we tested.

Practically **every non-zero value for that first byte activates the brakes** at some force, in some mode. There is no secret handshake to reverse. An attacker doesn't need our research, doesn't need the app, doesn't need the protocol docs. They can write *approximately any garbage* to that characteristic and the trailer will brake. We found ABS-style pulse modes by accident, just by sweeping the range and noticing the pitch change.

When the naive attack and the sophisticated attack are the same attack, you don't have an authentication weakness. You have an authentication *absence*.

A few other findings rounded out the picture:

- **No replay protection.** Raw GATT writes, no nonces, no timestamps, no session tokens. Capture a legitimate command once, replay it forever.
- **A persistent command register.** The control characteristic remembers the last value written to it, across reconnects, with no timeout. Reconnect later, read it back, and you can see the last command the device received - a quiet little intelligence leak.
- **Connection-dependent release.** The one accidental mercy: when the attacker's Bluetooth connection drops, the brakes release after 2–5 seconds. This limits a pure drive-by, but does nothing to stop a stationary attacker who simply stays in range - think a boat trailer on a ramp, or a caravan parked on a hill.

---

## Step 6: the OTA channel, which is a different kind of scary

Everything so far is transient - hold the connection, hold the brakes; drop it, they let go. The firmware update channel is where it stops being transient.

The OTA service *is* behind pairing, which sounds reassuring right up until you learn what kind of pairing. We paired using Windows' bog-standard "Add a device" dialog. It used **Just Works** mode - no PIN, no passkey, no numeric comparison, no user friction of any kind. Just Works is the Bluetooth pairing mode that provides encryption against a passive eavesdropper and essentially nothing against an active attacker who's actually trying.

Once paired, the OTA channel accepted arbitrary writes to its 255-byte buffer without complaint:

```
[03:04:26.639] WRITE Central Response: 14 FF 00 00
[03:04:26.768] WRITE Central Response: OK
```

We stopped there deliberately - we did **not** attempt to flash modified firmware to a live device, because I didn't want to brick a brake controller worth about $800 that I own and we had already found plenty of issues that day. But we did the static analysis back in the office on the firmware image the app itself distributes, and that told us plenty.

The image is "encrypted," but the decryption key ships inside every copy of the app. It's a lock with the key taped to the front, mailed to everyone who downloads the app from the Play Store or the App Store. Once decrypted, the integrity story is the real problem: the entire update pipeline is protected by **CRC32 checksums and nothing else**. We confirmed this three independent ways - the firmware descriptor carries only CRCs, the device-side DFU protocol transmits only CRCs, and the decrypted image itself contains zero cryptographic signature material (no signature block, no verification strings, nothing). The "start firmware update" handshake is a fixed 16-byte constant that's identical for every image, so it works as a static unlock token.

A CRC protects against a cosmic ray flipping a bit in transit. It does absolutely nothing against an attacker, because anyone modifying the firmware just recalculates the CRC. There's a boundary worth calling out - the final "accept or reject" decision lives in the bootloader, which sits in a separate flash region we couldn't pull without physically wiring up the chip. So this is "no signature material exists anywhere we can see in software," not "we flashed evil firmware and it booted." But every layer we *could* inspect points the same direction, and it's the direction that lets a paired attacker theoretically write persistent firmware that disables braking on a speed or GPS trigger, decouples the brake lights from the actual brakes, or quietly logs where a vehicle goes. These devices do have a GPS module and gyroscope sensor, so there are a lot of possibilities if you can get into the firmware.

That's the difference between "hold the connection to hold the brakes" and "the brakes are compromised after you've driven away."

---

## Why this matters more than your average IoT bug

Most of the connected-device bugs we all read about are about data - a leaked database, a hijacked camera, a smart lock that opens. Bad, but bounded.

This one outputs *torque to a wheel on a public road*. The impact isn't measured in records exposed. It's measured in stopping distances, jackknife angles, and boat ramps. A loaded boat trailer is commonly 1.5 to 4 tonnes; a caravan on a mountain descent is relying on those trailer brakes to stay within the tow vehicle's capacity. The attack surface is "anyone within Bluetooth range," the skill required is "can write four bytes," and the victim selection is "optional."

To keep the risk in proportion: Elecbrakes tells us there have been no reported incidents of damage or injury caused by these vulnerabilities, and we haven't seen evidence of exploitation either. A brake application that ends when the connection drops leaves little behind, so that's reassuring rather than conclusive, and it's one more reason to install the update.

There's a regulatory dimension too, which we flagged to Elecbrakes in the disclosure. I am going to also preface this with, I am clearly not a lawyer, and my understanding of Australian law is crude at best. In Australia, trailer braking is governed by ADR 38/05, which requires the brake control to be progressively increased and decreased by means of the 'Control Signal' from the towing vehicle. A stranger applying your brakes from the footpath is rather obviously contrary to that. Layer on the Australian Consumer Law's safety obligations and you have a situation where a Bluetooth bug and a compliance problem are the same problem. We didn't raise that to be threatening; we raised it because a vendor deciding how urgently to act deserves the full picture.

---

## The ELBC 2000: the model without a fix

Partway through the coordination, I came across an older Elecbrakes controller by chance, on a trailer in my local area: an ELBC 2000. There's very little about it online, so in September I asked Elecbrakes whether it was affected too. At the end of October their engineering team confirmed it has the same vulnerability. The ELBC 2000 is the predecessor to the EB2 and VM1. It hasn't been sold for a number of years, but the units already sold are still towing.

The ELBC 2000 was never part of Elecbrakes' remediation. When they assessed our report, they identified the VM1 as affected alongside the EB2, but missed an older model with the same vulnerability that is still on the roads. Elecbrakes should have identified it at the start and included it in their remediation plan. Instead it only came to light because I stumbled across one, four months after our original report. As of publication there is no fix for the ELBC 2000. Elecbrakes says it is working to determine a remediation plan.

If you have an ELBC 2000, the risk is the one described above: anyone within Bluetooth range of the powered controller can apply your trailer brakes. There's no firmware update to install. Elecbrakes' advice is to check the Elecbrakes app from time to time for an ELBC 2000 update, and to contact Elecbrakes directly with any questions.

---

## The formal bit: classification, scoring, and CVE

For the people who need to log this in a spreadsheet, brief a board, or map it against a framework, here's the vulnerability in the standard language.

**CVE IDs:** CISA's advisory covers three CVEs, coordinated through CISA's ICS vulnerability coordination team. See the next section for how much work sat behind those three lines.

| CVE | CWE | What it covers |
|---|---|---|
| **CVE-2026-96805** | **CWE-306** Missing Authentication for Critical Function | The headline. Brake control accepts commands from any Bluetooth device in range, with no pairing, PIN or authentication of any kind. |
| **CVE-2026-125273** | **CWE-284** Improper Access Control | Commands carry no sequence number, nonce or session token, so any command can be replayed - and the last one sent stays readable on the device across sessions. |
| **CVE-2026-124281** | **CWE-749** Exposed Dangerous Method or Function | The firmware update channel, which is only as strong as Just Works pairing, a CRC32 and a decryption key shipped in the app. |

CISA's description of the headline CVE: *"The affected product is missing authentication for critical functions, which may allow an attacker to remotely activate, modulate, and release trailer brakes at arbitrary force levels without any authentication, pairing, PIN, or authorization."*

Our own read of the firmware pipeline also fits **CWE-345** (Insufficient Verification of Data Authenticity): integrity is verified with CRC32 only, with no cryptographic signature. It falls under CVE-2026-124281 and is the root of the update-channel problem described above.

**Affected products:** All three CVEs apply to all three Elecbrakes controllers - the whole range, not just the two models we set out to test.

- **EB2 and VM1:** fixed by the 6 July 2026 firmware update (EB2 3.0.4.4.3, VM1 1.3.4.2.1). Firmware from before that update is affected, including the factory original and 3.0.4.2.0, which is what we tested.
- **ELBC 2000:** affected, confirmed by Elecbrakes, with no fix at the time of writing.

**A note on CVE-2026-124281.** Elecbrakes fixed this one in the controller firmware, so it protects controllers running EB2 3.0.4.4.3 or VM1 1.3.4.2.1 or later. On that firmware, the controller only enters firmware update mode over an authenticated, bonded connection, so someone in Bluetooth range can't start an update. A controller still on older firmware can be paired by anyone in range, with no PIN, and its update mode reached, which is one more reason to install the update. We missed the new gate when we re-checked the fixed firmware before publishing, and Elecbrakes pointed us to it. The firmware image itself is still unsigned and still uses the decryption key shipped in the app. Elecbrakes says its next app release will add signed firmware, rolling encryption keys, app attestation and obfuscation.

**Severity (CVSS v3.1), CVE-2026-96805: 9.6 - CRITICAL**

`CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:C/C:L/I:H/A:H`

| Metric | Value | Reasoning |
|---|---|---|
| Attack Vector | Adjacent (A) | Bluetooth radio range - roughly 10–100 m |
| Attack Complexity | Low (L) | No special conditions; write four bytes |
| Privileges Required | None (N) | No pairing, PIN, or credential of any kind |
| User Interaction | None (N) | The victim does nothing and gets no prompt |
| Scope | Changed (C) | Impact escapes the device into physical control of the vehicle |
| Confidentiality | Low (L) | Minor information exposure (persistent register, state feedback) |
| Integrity | High (H) | The attacker controls braking commands |
| Availability | High (H) | Braking can be forced or the trailer's normal behaviour disrupted |

A quick word on that 9.6. CVSS was built for software, and it struggles with a bug whose real output is *torque on a public road*. The "Scope: Changed" flag is doing most of the work here. It's the framework's way of admitting the blast radius extends past the device, and it lifts this vector from 8.3 (High) to 9.6 (Critical). Even so, there is no CVSS v3.1 metric for "and also a caravan might jackknife." If your organisation uses CVSS v4.0, its Safety (S) supplemental metric is worth applying, because it's designed for exactly this class of cyber-physical impact that v3.1 leaves on the table.

**The other two CVEs.** For CVE-2026-125273 (replay), Elecbrakes asked CISA to raise Attack Complexity to High (AC:H), which would score it 8.2 (High) rather than 9.6. The argument is that a replay needs a captured legitimate command, so the attacker has to be in range while the owner's remote or app is transmitting. We didn't think that precondition held on these devices. The brake control characteristic keeps the last command written to it, across connections and with no timeout, and anyone in range can read it without pairing. On a fresh connection, before we'd written anything, reading it returned the previous session's command. An attacker doesn't have to be there when the owner transmits - they can connect later and read it out. And because commands are four static bytes with nothing device-specific in them, a command taken from the attacker's own controller would work just as well. Elecbrakes reviewed this and agreed, so CVE-2026-125273 stays at 9.6 (Critical). CVE-2026-124281 (the update channel) is scored 6.1 (Medium): `CVSS:3.1/AV:A/AC:L/PR:N/UI:N/S:C/C:N/I:L/A:L`.

---

## The other half of the work: getting a CVE

Here's the part that gets left out of write-ups like this one, and shouldn't.

Finding this vulnerability took about four hours on a gravel road. Getting an identifier attached to it and getting to the point of telling you about it took about six months, and consumed comfortably more of our hours than the research did. If you're a researcher reading this expecting the technical work to be the hard part: the coordination took far longer.

**Why you can't just get a number.** Elecbrakes isn't a CVE Numbering Authority, so there was no vendor process to request an ID from. For cyber-physical kit like this, the route is CISA's ICS vulnerability coordination team, which works through a platform called VINCE (the Vulnerability Information and Coordination Environment, run by CERT/CC). You lodge a case, you get a case number, and you get assigned a coordinator. Ours was excellent throughout - responsive, transparent about exactly what the rules allowed, and patient with a researcher whose opening line in the thread was effectively *"apologies for the lack of understanding, this is my first one of these."*

**The process itself is simple.** It has seven steps:

1. You submit the vulnerability details.
2. The coordinator contacts the vendor.
3. The vendor confirms or refutes the findings.
4. The vendor states its remediation or workaround.
5. The coordinator drafts an advisory.
6. Researcher and vendor both review and approve it.
7. Everyone agrees a publication date, it publishes, CVEs are assigned.

Now count the steps that can't proceed without the vendor. Five of the seven. The process depends on the vendor at most steps. Coordination is only as fast as the least motivated participant, and once a vendor has shipped its fix, its motivation to keep participating drops off a cliff. The bug is closed on their side. The paperwork is entirely someone else's problem.

**And there is almost no lever.** CISA policy prevents publishing an advisory without vendor authorisation unless the vendor has gone silent for 45 days or more. That is a sensible rule: it stops a coordinator being weaponised by an impatient researcher, and it protects vendors who are mid-remediation and acting in good faith. But the practical effect is that a vendor who replies just often enough to reset the clock - a message every few weeks, no commitment to anything - can hold a case open more or less indefinitely, and nobody in the process can do much about it. We asked, directly, what the options were. The honest answer was: keep reaching out and wait.

Our case played out much like that. From mid-August, Elecbrakes went 53 days without a word on the case or by email, which took it past the 45-day mark at the end of September. In that time we followed up by email and on the case, and CISA emailed them too. The silence ended the day after I rang our contact's mobile and emailed one of the company's directors and its general inbox. The reply was an apology and a promise of an update after a management meeting that week. The update arrived three and a half weeks later. We don't think any of that was a tactic. It does show how the rule works in practice: one short reply resets the clock, and nothing in the process requires the open questions to be answered.

To be clear about where we landed on that. There is a review path - if researcher and vendor disagree on whether something even qualifies as a reportable vulnerability, a separate team can assess it and rule. That's a useful backstop for a disputed finding. It doesn't cover disagreements about *timing*, which is what almost every real-world disclosure stalemate actually is.

**The negotiation is its own project.** Separate from VINCE, the direct back-and-forth with Elecbrakes about disclosure timing consumed many hours again on top of the coordination work: drafting positions, re-drafting them, chasing responses, re-explaining why the timeline mattered, following up on messages that didn't get answered, and at one point offering to make our entire correspondence available to the coordinator so everyone could see the same facts. The vendor joined the VINCE case about a month after CISA received the report, and only after repeated prompting from both the coordinator and us. None of that work is technical. All of it is unbillable. Most of it happened after the actual risk to customers had already been fixed.

**The bit that made the delay uncomfortable.** When Elecbrakes shipped the updated app and firmware, the update itself narrowed down where the vulnerability lived and how to reach it in unpatched versions. That's normal - patches leak information, it's a well-understood dynamic - but it inverts the usual argument for a long embargo. Once a fix is public, silence protects only the awkwardness of the conversation. Every week of unexplained delay after that point is a week where anyone motivated enough to diff two versions of an Android app knows more than the owners of the affected devices do. That was the substance of our position, and it's why we proposed a joint disclosure two weeks after the fix landed. We didn't get that date. This post follows the date we eventually agreed, 15 November - which is the right way to do it, and still longer than we would have liked.

Elecbrakes did keep up its own in-app and website messaging about the update. Even so, by late October, three and a half months after the fix shipped, its own figures showed about 60% of daily active EB2 and VM1 users were on the latest firmware. That's real progress. The update is user-initiated - it doesn't install when the controller is next used, so each owner has to open the app and start it - which goes some way to explaining the number. It also means around four in 10 of the people actively using the app still weren't, before counting owners who rarely open it. That gap is why, when we accepted the later date in August, we asked for two interim steps that wouldn't help an attacker: stronger in-app update messaging, and a short plain-English customer advisory covering how urgent the update was, how to check your controller and what to do until it was updated. Elecbrakes didn't respond to either request.

**What we'd tell the next researcher.** Blunt version, since nobody told us:

- **Open the coordination case when you send the report.** We opened ours later than we should have. Everything downstream inherits that delay.
- **Get the vendor onto the coordination platform in your first email.** Do it straight away, while goodwill is at its peak and the fix is still ahead of them.
- **Agree the disclosure date in writing before the fix ships.** This is the single thing we'd change. Your leverage is highest while the vendor still wants something from you - a delay, help reproducing, a review of their patch. After the fix goes out, you have essentially none.
- **Budget the hours honestly.** Assume the coordination and negotiation will cost you more than the research. Then assume it'll be worse than that, because it will.
- **Get a second contact at the vendor early.** For most of this case we had one contact at Elecbrakes, and when he was unavailable the case stalled for weeks. Widening to a director and the general inbox got a reply the next day. Ask for a backup contact in your first email.
- **Keep everything in one auditable place.** When a case stalls, the ability to point a coordinator at a complete, dated record of who said what and when is the only thing you actually control.
- **Re-check the fix before you publish.** We reviewed the fixed firmware again just before publication. It raised a question about one CVE, which we settled with Elecbrakes and CISA before this post went out.

The CVE system works. It's staffed by people who clearly care and it produces good outcomes when everyone stays at the table. It just has no answer for the party who quietly stops showing up.

---

## The part where we credit the vendor - and the part where it got harder

Here's where this write-up departs from the genre. Twice, in opposite directions.

The traditional vulnerability-disclosure blog post has a villain: the vendor who ignored three emails, disputed the severity, threatened the researcher, and shipped a fix six months late with a changelog reading "minor bug fixes." We've all read that post. We were braced to write it.

What happened instead is more useful, and a bit more mixed.

**The engineering response was very good.** Elecbrakes is a relatively small Australian manufacturer with no product security team, no CVE process, and no `security.txt`. Despite that:

- They **read the report, understood it immediately, and didn't get defensive.** They reproduced and validated the findings themselves rather than arguing about severity. For a first-time recipient of an unsolicited vulnerability report about a safety-critical product, that's a better reaction than plenty of organisations with dedicated teams manage.
- They **shipped a proper fix, fast**. Elecbrakes worked with us from the first notification on 18 May, and fixed firmware (EB2 3.0.4.4.3, VM1 1.3.4.2.1) was released on 6 July, seven weeks later. Brake control moved behind an authenticated, encrypted, cryptographically bonded connection, with first-time pairing gated behind a *physical* brake-pedal sequence that can't be injected over Bluetooth. That closes the "attacker just bonds over the air" gap a naive fix would have left wide open. It's a good design, and it landed in the field quickly.
- They **looked after EB2 and VM1 owners.** Existing wireless remotes couldn't support the new pairing model, so rather than telling customers to buy a new one, they're shipping a replacement remote **free of charge**, freight both ways, absorbing the entire cost. Their position, roughly: no customer should be out of pocket for a problem they didn't cause. That's real money spent on the right thing. They also pushed an in-app message to every user asking them to update, and published a blog post and a remote-upgrade page.

On the measure that matters most - are the devices in the field safer than they were - Elecbrakes did the job for the EB2 and VM1, and did it faster than we expected. Credit where it's due, and it's due. The ELBC 2000 is the exception. It should have been part of the fix from the start, and it still has no fix ([see above](#the-elbc-2000-the-model-without-a-fix)).

**The coordination after the patch was harder.** Once the firmware was out, communication slowed, and for a while it stopped. Getting Elecbrakes onto the VINCE case took a month from when CISA received the report, with prompting from the coordinator and from us. Then, from mid-August, we heard nothing for 53 days. Questions that would have taken minutes to answer took weeks, or weren't answered at all:

- **Firmware rollout figures:** asked for in mid-August, received at the end of October (77 days).
- **Whether the ELBC 2000 was affected:** asked in mid-September, confirmed at the end of October (43 days).
- **The wording of the in-app update prompt and any planned customer communications:** asked in August, never answered.
- **An interim plain-English customer advisory:** we proposed one in August and CISA offered to write it in September. Elecbrakes didn't respond to either.

One of the dropped balls was ours. In mid-August I said I'd send Elecbrakes and CISA a draft advisory by 19 August, with nothing to publish until the wording was agreed. I never sent it. By then I'd already put far more time into the case than I'd planned, and it slipped. This post holds Elecbrakes to its follow-through, so it's only fair to own ours.

Negotiating a disclosure timeline turned into a stalemate, and the thing that made it a stalemate was not disagreement about the technical facts - those were settled and accepted - it was that once the fix had shipped, there was no longer any deadline anyone could enforce.

We want to be fair about the reasons, because we can't see inside their business. A small manufacturer is unlikely to have a comms function, a legal team on retainer, or anyone whose job is vulnerability coordination. The engineers who fixed the bug in seven weeks are presumably the same people running the rest of the product. When Elecbrakes did get back to us in October, the explanation was that our contact had been tied up with other urgent work and their management team had been unavailable for several weeks. That matches what we'd guessed: post-patch coordination is exactly the kind of work that falls off the bottom of the list when the actual risk feels handled. We don't think any of it was adversarial. But the effect on the process was the same as if it had been deliberate.

Everyone ships bugs. The lesson we'd like vendors to take is three things:

1. **Respond the way Elecbrakes responded technically.** Read it, believe it, fix it properly, and pay to make your existing customers whole. For the EB2 and VM1, that part they got right.
2. **Check every product you've shipped that shares the flaw.** That includes the ones you no longer sell or support. If they're still in use, they're still exposed, and finding them is your job, not the researcher's.
3. **Then finish the job.** A patch is not the end of a disclosure, it's the middle. The half hour it takes to approve an advisory and agree a date is the cheapest, lowest-risk part of the entire exercise, and it's the part that determines how the story reads. If you go quiet after the fix, the disclosure goes ahead without your voice in it.

---

## What good looks like (for the engineers reading)

If you build Bluetooth-connected anything, the takeaways here are cheap to state and, apparently, easy to get wrong:

1. **Being in Bluetooth range shouldn't let a device send commands.** This was the root cause of the entire thing.
2. **Put safety-critical functions behind your *strongest* gate.** The device already had a pairing tier. Brake control simply wasn't in it. The infrastructure to fix this existed before we ever showed up.
3. **Just Works pairing gives little protection against an active attacker.** If a channel matters, use Passkey Entry or Numeric Comparison.
4. **A CRC only detects accidental corruption.** If unsigned firmware can boot, your OTA channel is a remote-code-execution primitive with extra steps. Sign your images and verify them in the bootloader.
5. **Fuzz your own command space.** If every byte value triggers a safety function, you'll find out in 10 minutes - and you'd much rather find it than we would.
6. **Have a disclosure route before you need one.** A `security.txt`, a monitored security inbox, and one named person who owns coordination. It costs you an afternoon now and saves you the situation described above later - where the technical fix takes seven weeks and the paperwork takes six months. If you're a small manufacturer reading this and that sounds like overhead you can't justify, note that the alternative is an ad-hoc process invented under pressure by whoever happens to open the email.

---

## Timeline

| Date | Event |
|---|---|
| Feb 2026 | Initial reverse engineering and GATT analysis |
| May 2026 | Live device testing - unauthenticated brake activation confirmed |
| May 2026 | Confirmed still present on the then-latest production firmware |
| 18 May 2026 | Coordinated disclosure sent to Elecbrakes |
| 29 May 2026 | Vendor acknowledged the report, then reproduced and validated the findings |
| 3 Jul 2026 | Report lodged with CISA ICS (VU#425218); coordinator begins attempting contact with the vendor |
| 6 Jul 2026 | Fixed app and firmware released to the field (EB2 3.0.4.4.3, VM1 1.3.4.2.1), seven weeks after notification; free replacement-remote program. Joint disclosure proposed for 31 Jul |
| 17 Jul 2026 | Coordinator advises no advisory can publish without vendor authorisation before 25 Aug, under the 45-day policy |
| Late Jul 2026 | Vendor communication slows; disclosure timeline negotiation reaches a stalemate |
| 4 Aug 2026 | Vendor joins the VINCE case, about a month after CISA received the report |
| 6 Aug 2026 | We upload our full original disclosure document to the case |
| 14 Aug 2026 | Vendor uploads the email thread and its corrective action plan to the case |
| 14 Aug 2026 | We accept the vendor's requested disclosure date of 15 Nov, and ask for stronger in-app update messaging and an interim plain-English customer advisory |
| 14 Aug - 6 Oct 2026 | No contact from the vendor for 53 days, despite follow-ups from us and from CISA |
| 17 Sep 2026 | We come across an older model, the ELBC 2000, in use locally and ask the vendor whether it is affected |
| 21 Sep 2026 | CVE-2026-96805 assigned, CVSS 9.6 (Critical). CISA offers to draft an interim advisory if the vendor agrees |
| 5 Oct 2026 | Escalated by phone, and by email to a vendor director and the general inbox; the vendor replies the next day, saying they will get back to us soon |
| 30 Oct 2026 | Vendor confirms the ELBC 2000 is affected with no fix yet, and reports about 60% of daily active EB2/VM1 users on the latest firmware |
| 10 Nov 2026 | CISA circulates its draft advisory (three CVEs) for researcher and vendor approval |
| 12 Nov 2026 | CISA circulates an updated draft advisory with our corrections, and moves its publication to 19 Nov |
| 15 Nov 2026 | Agreed disclosure date |
| 17 Nov 2026 | Our second review finds the fixed firmware image is still unsigned. Elecbrakes confirms that controllers on the fixed firmware only enter update mode over an authenticated, bonded connection, with signing to follow in its next app release. We hold this post while that's settled |
| 19 Nov 2026 | This post, published alongside CISA's advisory |

---

## Credits and closing

Research by **Patrick Forck** and **Jeremy McCarthy** at **Element Digital**. Jeremy built the Web Bluetooth research tooling that made the live testing possible; the reverse engineering and tool-building were substantially AI-assisted, which is a story we think the industry should pay attention to.

Thanks to the Elecbrakes engineering team, who took a report about their own safety-critical product from a stranger, believed it, and had a properly designed fix in the field faster than most organisations manage a triage meeting. Thanks also to the CISA ICS coordination team, who were patient, clear and consistently helpful through a case that a first-time reporter did not make easy.

If you own an EB2 or VM1 and you skipped the intro: open the app, update the firmware on your brake controller (it won't do it by itself) to EB2 3.0.4.4.3 or VM1 1.3.4.2.1 or later, and - if you get the offer - claim your free replacement remote. If you own an ELBC 2000, there's no update yet. Check the Elecbrakes app from time to time and contact Elecbrakes with any questions.

Drive safe. Check your brakes. Ideally the physical ones and the Bluetooth ones.

*Element Digital - [elementdigital.com.au](https://elementdigital.com.au)*
