Nine Things a Microsoft 365 Security Review Finds Almost Every Time
The same findings come up in nearly every tenant we assess. Nine of them, what each one actually costs you, and how to check your own as you read.
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 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.
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.
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 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:

Photo: Richard J. Ho, Minch Media
For the non-Tasmanians that may not recognise the trailer
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.)
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 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.
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.
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.
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.
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.
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:
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.”
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.
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.
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.
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.
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:
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:
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.
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:
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 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:
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:
If you build Bluetooth-connected anything, the takeaways here are cheap to state and, apparently, easy to get wrong:
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.| 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 |
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
Let us talk about what you are trying to achieve, no obligation, just a conversation.