Engineer working on a laptop connected to a device test rig, surrounded by wiring harnesses and test hardware

Firmware vulnerabilities & fixes

Thread protocol security: what the mesh actually protects, and where commissioning breaks

Last updated:

The Thread Group says Thread uses the same kinds of security technologies that keep "your banking transactions" secure — a shared network-wide key plus DTLS-protected commissioning — but a peer-reviewed 2022 study of real OpenThread-based networks showed that same commissioning step could be jammed and password-guessed, and a joiner with a known password hijacked, and Thread 1.4's 2024 fix, certificate-based TCAT, remains optional rather than mandatory. For device makers shipping Thread hardware, or integrators building on Matter (which runs over Thread alongside Wi-Fi and Bluetooth Low Energy), the gap between "Thread has strong security" and "this specific device's commissioning flow is strong" is exactly where implementation choices live.

Key takeaways

  • Thread is a low-power, IPv6-based mesh networking protocol maintained by the Thread Group, designed from the outset for home and commercial IoT and now one of the three transports the Matter smart-home standard supports.
  • Thread uses MeshCoP (Mesh Commissioning Protocol) to admit new devices.
  • Energy depletion.
  • A worked example (synthetic product, numbers derived from the sources above) shows why the PSKd's entropy and its uniqueness matter more than its length on the label.

What does Thread actually build into the protocol?

Thread is a low-power, IPv6-based mesh networking protocol maintained by the Thread Group, designed from the outset for home and commercial IoT and now one of the three transports the Matter smart-home standard supports. Security is a first-class design element rather than an add-on: every device on a given Thread network shares a 16-byte network-wide key, used at the IEEE 802.15.4 MAC layer to encrypt and authenticate mesh traffic between nodes, and Thread layers DTLS (Datagram TLS) on top of that for the commissioning exchange that admits a new device to the network in the first place.

The Thread Group's security architecture white paper gives the specifics. Link-layer protection is AES-CCM* with a 128-bit key and a 32-bit MIC on every hop; neighbours keep frame-counter tables to reject replayed frames; the key sequence rotates by default every 28 days; and a network-wide key change can lock out a removed or compromised device. Two limits are stated in the same paper. Every Mesh Extender decrypts and re-encrypts each frame it forwards, so true end-to-end confidentiality needs TLS, DTLS, OSCORE or Matter's CASE sessions on top. And Thread certification "does not mandate specific storage methods" for keys, leaving secure key storage to the chip and device vendor.

Since Thread 1.3.0 (July 2022), Border Routers also provide bidirectional IPv6 reachability and DNS-based service discovery (SRP, Advertising Proxy, Discovery Proxy) between the mesh and the home or building network. That makes the Border Router a full IP router with an attack surface on its Wi-Fi or Ethernet side, which the CVE table below reflects.

How does a device actually receive the network key, and why is that step sensitive?

Thread uses MeshCoP (Mesh Commissioning Protocol) to admit new devices. A joining device (the Joiner) authenticates to a Commissioner using a Pre-Shared Key (PSKd) — typically a short code printed on the device or its box — inside a DTLS session authenticated with EC-JPAKE, a password-authenticated key exchange. Unauthenticated joiner traffic is relayed by an on-mesh Joiner Router over UDP port 1000; once authenticated, the Commissioner transfers the Thread network credentials, including the network key. Vendor documentation is explicit about why this step carries so much weight: the network key "cannot be transmitted without encryption, as it could be obtained by an attacker."

OpenThread's PSKd validation code fixes the format: 6 to 32 characters, digits and upper-case letters only, with I, O, Q and Z excluded, which leaves an alphabet of 32 symbols. EC-JPAKE stops offline dictionary attacks on a captured handshake, so an attacker has to guess online, one handshake at a time — which is exactly what independent research went on to test.

What did independent testing actually find in that commissioning step?

The ACM WiSec 2022 paper "On the Security of Thread Networks: Experimentation with OpenThread-Enabled Devices" (Akestoridis, Sekar and Tague, Carnegie Mellon University) built real Thread networks on development boards running OpenThread and attacked them over the air. It reported energy-depletion attacks and two online password-guessing attacks:

  • Energy depletion. An outside attacker could stop an OpenThread Sleepy End Device from returning to sleep, draining its battery.
  • Impersonating the joiner. By selectively jamming the legitimate joiner's first 6LoWPAN fragment and spoofing the MAC acknowledgment, the attacker kept the real device from finishing its DTLS handshake and used the window to try passwords itself: 13 wrong guesses in one commissioning period of about two minutes, OpenThread's default.
  • Impersonating the commissioner. By jamming the legitimate network's beacons and Discovery Responses, the attacker made the joining device start its handshake with a fake commissioner, even with a matching PAN ID. With a known or hard-coded password, the same technique hijacks the joiner onto the attacker's network.

The authors rate the guessing risk as low "as long as the end user does not accept new Thread devices for long periods of time and does not use an easily guessable password." Their recommendations are practical rather than protocol changes: count failed authentications, warn on repeated wrong guesses and on PAN ID conflicts, show a distinct error when commissioning fails because of a wrong password, and let users change device passwords out of band. They disclosed the findings to the Thread Group in January 2022.

How many guesses does a short PSKd really allow?

A worked example (synthetic product, numbers derived from the sources above) shows why the PSKd's entropy and its uniqueness matter more than its length on the label.

  1. Search spaceA 6-character PSKd over OpenThread's 32-symbol alphabet has 32^6, about 1.07 billion, possible values. An 8-character code has about 1.1 trillion.
  2. Guess rateAt the paper's measured 13 guesses per two-minute commissioning window, an attacker who forced the user to restart commissioning 1,000 times would test about 13,000 codes, roughly 0.001 % of the 6-character space.
  3. Where the arithmetic collapsesIf every unit ships with the same code, or the code is derived from the serial number or MAC address printed next to it, the search space is one value. That is what CVE-2026-19741 describes: Zephyr's OpenThread integration defaulted the joiner PSKd to the documentation example "J01NME", so builds with joiner autostart that never overrode it shipped a public credential.
  4. Result for the exampleA random, per-device PSKd of 8 or more characters, a short join window and a failed-attempt counter keep online guessing impractical; a shared or derived code does not, whatever its length.

Does Thread 1.4's TCAT fix this, and is it required?

Partially, and no. Thread 1.4, released by the Thread Group in September 2024, introduces TCAT (Thread Commissioning over Authenticated TLS) to replace the low-entropy PSKd model with mutual, certificate-based authentication. A TCAT session runs over TLS between the TCAT Commissioner (TLS client, which must support TLS 1.2 and 1.3) and the TCAT Device (TLS server, either version), carried over Bluetooth Low Energy in Thread 1.4. The device certificate may be an IEEE 802.1AR IDevID and "must be provisioned immutably into the TCAT device at manufacturing time," and the device maker controls the CA that issues commissioner certificates. The Thread Group frames the use case around professional installers onboarding devices "pre-installed in difficult-to-reach places, such as inside a ceiling or embedded in a wall."

The limitation: TCAT is explicitly optional. The white paper expects commercial (B2B) Thread products to support it, while consumer-only (B2C) products "would not necessarily support it." Most consumer Thread devices can therefore still rely on the PSKd/MeshCoP join flow the 2022 research tested.

Mechanism Secret that gates it Who can extract credentials Limits in OpenThread
MeshCoP joiner (all Thread versions) PSKd, 6–32 chars, 32-symbol alphabet Anyone who completes the DTLS/EC-JPAKE handshake Commissioning window, about 2 minutes by default
TCAT (Thread 1.4, optional) X.509 certificates from the device maker's CA Commissioners whose certificate carries the "extraction" capability Authorization classes encoded in the certificate
Credentials Sharing on a Border Router (Thread 1.4) ePSKc derived from a 9-digit one-time passcode shown after vendor-specific user authentication The app that enters the passcode ePSKc: 2-minute default, 10-minute maximum, stops after 10 failed DTLS attempts

Both 1.4 recovery paths are deliberate "forgot my password" features, so the extraction-capable commissioner certificates and the Border Router's user-authentication step become part of the security model.

How does Matter over Thread change the commissioning picture?

A Matter device on Thread is usually not admitted through MeshCoP's PSKd at all. The Matter commissioner opens a passcode-authenticated session over Bluetooth LE and then writes the Thread operational dataset, network key included, to the device. The Matter SDK's CHIP Tool guide shows the shape: pairing ble-thread <node_id> hex:<operational_dataset> <pin_code> <discriminator>. For those products the gate is the Matter setup passcode, a 27-bit value that the SDK rejects when it is 11111111 through 88888888, 12345678 or 87654321. The SDK's example apps print 20202021, the same class of public default as J01NME.

The Connectivity Standards Alliance's security white paper states that Matter security "does not rely on the security of the communication technologies on top of which Matter runs," and adds device attestation before a device can join a fabric. Matter commands therefore stay protected even if the Thread key leaks. IPv6 access to the mesh, the Border Router and any non-Matter service on the device does not.

Which real vulnerabilities have hit OpenThread and Thread border routers?

Most published Thread CVEs are implementation bugs in stacks and Border Routers, not protocol breaks. Scores are as listed by NVD on 2026-11-12; the Silicon Labs advisory figures are as of 2026-11-19.

CVE Component Issue Score (source)
CVE-2019-20791 OpenThread before 2019-12-13 Stack buffer overflow in MeshCoP::Commissioner::GeneratePskc, found by OSS-Fuzz CVSS 3.1 9.8 (NVD)
CVE-2023-2626 OpenThread border router implementations Frames using Key ID Mode 2, a static key, bypassed security checks and let arbitrary IPv6 into the Thread network and on to the LAN; affected devices were mitigated by automatic update CVSS 3.1 7.5 (Google), 8.8 (NVD)
CVE-2023-41095 Silicon Labs OpenThread SDK 1.2.0 to 2.3.1 (Silicon Labs advisory A-00000482); NVD lists 2.3.1 and earlier Network credentials stored in flash without encryption on SecureVault High parts CVSS 3.1 7.6 (Silicon Labs advisory A-00000482, 6.8 in its CVE record), 9.1 (NVD)
CVE-2025-36939 OpenThread MLE handling Assertion failures and a stack overflow triggerable by an authenticated node on the same network CVSS 4.0 10.0 (Google), CVSS 3.1 5.7 (NVD)
CVE-2026-8369 OpenThread NAT64 translator before commit 26a882d Crafted IPv4 packets with options inject corrupted IPv6 into the mesh CVSS 4.0 6.0 (Google)
CVE-2026-19741 Zephyr OpenThread integration Default joiner PSKd "J01NME" compiled in with joiner autostart CVSS 3.1 7.5 (Zephyr)
CVE-2026-113782 (advisory) ESP-IDF 5.2.0 onward with CONFIG_OPENTHREAD_BORDER_ROUTER=y ICMPv6 Router Advertisement option length overflows a stack buffer in the Border Router's Neighbor Discovery handler; fixed in 5.2.8, 5.3.6, 5.5.5 and 6.0.3, with the 5.4 fix scheduled for 5.4.5, which had no release as of 2026-11-22 CVSS 3.1 7.1 (GitHub)

Two patterns stand out. Two of the seven arrive from the Border Router's IP side, the surface Thread 1.3 widened, and a third (CVE-2023-2626) let mesh-side frames through the Border Router to the LAN. And two are about credentials at rest or by default rather than cryptography: a shared PSKd and an unencrypted key in flash.

What should device makers and integrators check before shipping?

  1. Identify which commissioning method your firmware actually implements— MeshCoP joiner, Matter-over-BLE, or Thread 1.4 TCAT — rather than assuming a "Thread certified" or "Thread 1.4" label answers this.
  2. Provision a random, per-device PSKd or Matter passcode from factory data, never a build-time constant, and keep it out of anything derivable from the label.
  3. Prefer TCAT with a manufacturing-time IEEE 802.1AR IDevID certificate for commercial/professional-install products, where the jamming and password-guessing attack surface the WiSec 2022 research documented matters most.
  4. If your device supports TCAT credential extraction, decide which partners may receive extraction-capable commissioner certificates and how you revoke them.
  5. Store the network key in protected storageCertification does not require it, and CVE-2023-41095 shows what a plain-flash key looks like.
  6. Keep the underlying Thread stack current and know its versionFor OpenThread, that is a commit or release tag; for vendor SDKs, the SDK release.
  7. Treat the Border Router as an internet-facing IP router: patch it on its own cadence and test its Wi-Fi/Ethernet side, not only the mesh.
  8. Add end-to-end security above Thread(Matter CASE, DTLS, CoAP with OSCORE) for anything that must stay confidential from other mesh nodes.

What are the common Thread security pitfalls?

  • Leaving an SDK example credential (J01NME, 20202021) in a production build.
  • Keeping the commissioner open for long periods, which gives an online guesser more windows.
  • Ignoring repeated commissioning failures instead of surfacing them to the user.
  • Assuming Matter's security covers Border Router CVEs; those are IP-stack bugs on a separate device.
  • Never rotating the network key after a device is removed or returned.
  • Tracking the Thread stack only as "vendor SDK" with no version, so advisories cannot be matched.

Where does SoftWSP fit in a Thread device review?

SoftWSP's firmware analysis extracts a component list from a firmware image as a CycloneDX 1.6 SBOM and matches it against NVD, CISA KEV, FIRST EPSS and CISA CSAF ICS advisories, then drafts a cited report for an engineer to review. On a Linux-based Border Router with package metadata, that covers components such as the TLS library and network daemons; a statically linked OpenThread inside a microcontroller image may not appear as a package and needs to be listed by hand. It does not parse MeshCoP or detect which commissioning path is compiled in. See firmware SBOM for how such an inventory is built and mbedTLS and wolfSSL vulnerabilities for the TLS libraries most Thread stacks depend on.

This guide draws on the Thread Group's white papers and FAQ, the peer-reviewed ACM WiSec 2022 paper on OpenThread commissioning, OpenThread and Matter SDK source code, and NVD and vendor advisories, read on 2026-11-12. It is general information, not a substitute for a review of a specific product's commissioning implementation.

Put this guide to work

Frequently asked questions

What does Thread's security model actually cover?

Thread, the low-power IPv6 mesh networking protocol maintained by the Thread Group (and one of the three transports, alongside Wi-Fi and Bluetooth Low Energy, that the Matter smart-home standard runs over), builds encryption and device authentication into the base specification rather than treating them as optional. Every device on a Thread network shares a 16-byte network-wide master key used at the IEEE 802.15.4 MAC layer to encrypt and authenticate mesh traffic between nodes, and Thread additionally layers DTLS (Datagram TLS) on top for internet-grade end-to-end security of specific exchanges, most importantly the commissioning process that admits a new device in the first place. Applications running over Thread can further use standards-based IP security (DTLS at the application layer) to protect payloads beyond what the mesh layer already covers. This is a materially stronger starting point than legacy protocols with no security design goals at all — but, as with any mesh relying on one shared network key, the security of the whole network reduces to the security of how that one key is issued and protected, which is exactly what the commissioning step does.

How does a new Thread device actually get the network key, and is that step itself protected?

Through MeshCoP (Mesh Commissioning Protocol), Thread's dedicated commissioning procedure. A joining device (the Joiner) first authenticates to a Commissioner using a Pre-Shared Key (PSKd) — typically a short code printed on the device or its packaging — over a DTLS-protected session; once that handshake succeeds, the Commissioner (via a Joiner Router acting as a relay) transfers the actual Thread network credentials, including the network master key, to the newly joined device. Vendor documentation on why this specific step needs its own protocol is direct: the key "cannot be transmitted without encryption, as it could be obtained by an attacker," which is why Thread uses a Password-Authenticated Key Exchange (PAKE) as part of that DTLS handshake rather than sending the key in the clear at any point. The design intent is sound — but a peer-reviewed study of this exact mechanism, discussed below, found concrete ways to attack it in practice, not just in theory.

What did independent research actually find wrong with Thread's commissioning process?

A paper presented at ACM WiSec 2022, 'On the Security of Thread Networks: Experimentation with OpenThread-Enabled Devices,' built real Thread networks using development boards flashed with OpenThread (the widely deployed open-source Thread stack used across the commercial smart-home ecosystem) and tested the protocol directly rather than analyzing the specification on paper. On commissioning, the researchers showed that an attacker could selectively jam a legitimate joiner's first DTLS fragments and impersonate the joiner to try passwords (13 wrong guesses fit into one roughly two-minute commissioning window), and could jam a Thread network's beacons and Discovery Responses so that a joining device starts its handshake with an impersonating commissioner instead; if the joiner's password is already known, for example because it is hard-coded, the same technique can hijack the joiner during commissioning. Critically, a completed commissioning exchange hands the joining device the network credentials, including the network key — so a correct password guess by an impersonating joiner, not an attack on the mesh's day-to-day AES traffic, is what would expose the key the rest of the network depends on. The paper rates the guessing risk as low when the password is not easily guessable and the network does not accept new devices for long periods, and recommends a false-authentication counter, warnings on repeated wrong guesses and on PAN ID conflicts, a distinct indication when commissioning fails because of a wrong password, and a way to change device passwords out of band; none of these is a universal, protocol-mandated fix.

What is TCAT, and does Thread 1.4 fix the commissioning weaknesses the research found?

TCAT (Thread Commissioning over Authenticated TLS), introduced in the Thread 1.4 specification (released by the Thread Group in September 2024), replaces the low-entropy PSKd model with mutual, certificate-based authentication: the commissioning session runs over an authenticated TLS connection (TLS 1.2 or 1.3) between the TCAT Commissioner and the joining device, carried over Bluetooth Low Energy, with device identity optionally anchored in an IEEE 802.1AR IDevID certificate provisioned immutably at manufacturing time. The Thread Group's own description of the motivation is specific to the professional-installation case the password-guessing research targeted: TCAT lets installers wirelessly onboard Thread devices 'pre-installed in difficult-to-reach places, such as inside a ceiling or embedded in a wall' using certificates instead of scanning a physical install code, closing off the short-printed-code attack surface for those deployments. The caveat: TCAT is explicitly optional, not mandatory for all Thread devices — the Thread Group's own guidance expects commercial (B2B) products to support it while ordinary consumer (B2C) Thread products are not required to, meaning the specific commissioning weaknesses the WiSec 2022 research documented remain live on any Thread device, including most consumer smart-home hardware, that doesn't implement TCAT and still relies on the legacy PSKd join flow.

Does TCAT itself introduce any new credential-exposure risk?

Yes, in a way worth flagging rather than treating TCAT as a strictly stronger replacement with no new considerations. The Thread Group's own Thread 1.4 documentation notes that TCAT's design explicitly enables extracting the Thread network credentials back out of a commissioned TCAT device when the TCAT Commissioner holds a certificate with the 'extraction' capability, which the device vendor grants only in exceptional circumstances to a well-known business partner — a deliberate feature, intended to let an authorized installer recover lost network credentials from an already-joined device, not an unintended flaw. (A separate Thread 1.4 feature, Credentials Sharing, lets an app obtain the credentials from a Border Router using a short-lived ephemeral key, the ePSKc.) The security implication is the same one that applies to any credential-recovery feature: whoever controls or can obtain an extraction-capable certificate and its private key can extract the live network key from a device already on the network, which means protecting those certificates (and controlling which apps/tools are trusted to hold them) becomes part of the operational security model for any TCAT-enabled deployment, not something TCAT retires by virtue of using certificates instead of a printed code.

What should a device maker or smart-home integrator building on Thread actually verify?

Treat Thread's mesh-layer AES encryption as solid and already handled by the specification, and focus scrutiny on the commissioning step, since that's where the documented research and the protocol's own design both point. Concretely: confirm which commissioning method your device firmware actually implements — legacy PSKd/MeshCoP, or Thread 1.4's TCAT — since only TCAT closes the low-entropy-password and beacon-jamming attack surface the WiSec 2022 research demonstrated; if shipping a device for commercial or professional installation, prefer TCAT with a manufacturing-time IEEE 802.1AR IDevID certificate over a printed PSKd code; if TCAT's credential-recovery feature is implemented, treat the extraction-capable commissioner certificates that unlock it as security-sensitive material with their own access control, not an afterthought; and verify your OpenThread (or other Thread stack) build is current, since the WiSec 2022 findings were demonstrated against real, deployed-class OpenThread firmware rather than a theoretical protocol reading. None of this is visible from a product's "Thread certified" label alone — it requires checking which commissioning path is actually compiled into the shipped firmware and which Thread stack version it carries; SoftWSP's device firmware analysis covers the second question by extracting a component list from the image and matching it against published vulnerability data for an engineer to review.

Sources

  1. Thread Group: Thread's 2024 Enhancements and What They'll Mean to You (TCAT, Credential Sharing)
  2. Thread Group: Thread 1.4 Features White Paper (September 2024, PDF)
  3. ACM WiSec 2022: On the Security of Thread Networks — Experimentation with OpenThread-Enabled Devices (author-hosted PDF)
  4. Thread Group: Thread 1.4 for Smart Buildings White Paper
  5. Thread Group: Thread Security Architecture and Features (white paper, PDF)
  6. Thread Group: Thread 1.3.0 Features White Paper (July 2022, PDF)
  7. Thread Group: FAQ (Thread 1.4, security, Matter)
  8. OpenThread source: MeshCoP PSKd validation (meshcop.cpp)
  9. OpenThread API: Border Agent ephemeral key (ePSKc) limits
  10. Connectivity Standards Alliance: Matter Security and Privacy Fundamentals (March 2022, PDF)
  11. Project CHIP (Matter SDK): CHIP Tool guide, commissioning into a Thread network over Bluetooth LE
  12. NVD: CVE-2019-20791 (OpenThread MeshCoP Commissioner stack overflow)
  13. NVD: CVE-2023-2626 (OpenThread border router Key ID Mode 2 authentication bypass)
  14. NVD: CVE-2025-36939 (OpenThread MLE packet handling)
  15. NVD: CVE-2026-8369 (OpenThread NAT64 translator input validation)
  16. Zephyr Project security advisory GHSA-6j2r-xrm4-3v7f (CVE-2026-19741, default joiner PSKd)
  17. Espressif ESP-IDF security advisory GHSA-c26h-gm53-qg83 (CVE-2026-113782, OpenThread Border Router ND handler)
  18. Silicon Labs security advisory A-00000482: OpenThread and EmberZNet keys stored in plaintext on Secure Vault High devices (CVE-2023-41095)
Was this guide helpful?

In this cluster

Thread protocol security: what the mesh actually protects, and where commissioning breaks