Skip to main content

Zephyr hawkBit CVE-2026-10849

| EUVDEUVD-2026-52447 HIGH
Heap-based Buffer Overflow (CWE-122)
2026-08-03 zephyr
7.5
CVSS 3.1 · NVD
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Position as MitM or compromise hawkBit update server
  2. Delivery
    Craft HTTP response body sized to match device heap allocation
  3. Exploit
    Device's response_json_cb() writes NUL past heap boundary
  4. Execution
    Adjacent allocator metadata corrupted
  5. Persist
    Subsequent heap operation triggers fault
  6. Impact
    Device crashes and reboots (DoS)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Heap buffer bounds checking
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

The hawkBit OTA management client must be compiled into the Zephyr firmware image (CONFIG_HAWKBIT=y) and actively polling a hawkBit update server. The attacker must be able to control what the device receives as the HTTP response body from the update server - either by directly operating a malicious hawkBit server the device is configured to contact, by compromising the legitimate update server, or by performing a man-in-the-middle attack on the HTTP channel (TLS is optional and not mandatory for hawkBit deployments). Even with TLS enabled, a hostile server (e.g., a compromised update server) can trigger the flaw because TLS authenticates the channel but not the server's intent. No special device-side privilege or user interaction is required once the device initiates an update poll. Exploitation is limited to denial of service in typical configurations because the attacker-controlled payload is only a single NUL byte; arbitrary code execution would require additional heap-layout conditions specific to the allocator and firmware.

Impact

The provided CVSS 7.5 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H) accurately reflects network reachability and no device-side authentication requirement, with impact limited to availability - the single NUL byte write corrupts allocator metadata rather than injecting attacker-controlled bytes, constraining impact to heap corruption and DoS. The EPSS score of 0.27% at the 18th percentile is markedly low despite the high CVSS score, consistent with the niche deployment footprint of Zephyr hawkBit in IoT firmware. SSVC reports Exploitation: none and Technical Impact: partial, confirming no observed active exploitation and bounded impact. The vulnerability is not listed in CISA KEV. The key real-world constraint is that the attacker must control or MitM the hawkBit update server the device communicates with - this is a meaningful barrier above a pure unauthenticated network attack, though TLS being optional and not protecting against a hostile server is a significant gap. For devices using hawkBit OTA over untrusted network paths without certificate pinning, this is a genuine priority; for deployments on air-gapped or fully controlled update infrastructure, risk is substantially reduced.

Exploit ScenarioDerived

An attacker who has compromised a hawkBit update server, or who performs a man-in-the-middle attack on a device communicating with the update server over plain HTTP, crafts an HTTP response body whose length equals or exceeds the current heap allocation in the device's hawkBit client. When the Zephyr device processes the response, response_json_cb() writes a NUL terminator one byte past the heap object, overwriting adjacent allocator metadata or the next heap chunk header. On the next allocation or free operation, the corrupted metadata causes a fault, crashing the device and triggering a reboot - achieving denial of service against embedded IoT devices relying on this OTA mechanism.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv2 – Aug 09, 2026

Heap-based out-of-bounds write in the Zephyr RTOS hawkBit OTA update client (versions 2.4.0 through <4.5.0) allows a malicious or compromised hawkBit update server to corrupt device heap memory by sending a crafted HTTP response body. The off-by-one flaw in response_json_cb() allocates exactly the response body length with no room for the NUL terminator, writing one byte past the heap object and corrupting adjacent allocator metadata. No public exploit identified at time of analysis, but the SSVC framework rates this as automatable and the trigger is deterministic in Zephyr v4.0.0 and later for any response body exceeding 1100 bytes - a size normal for hawkBit deployment metadata.

Earlier versions of this analysis (1)
v1 Aug 03, 2026 - 22:08 CVSS 8.2

Heap-based out-of-bounds write in the Zephyr RTOS hawkBit OTA update client allows a remote update server to corrupt heap allocator metadata and crash the device. The vulnerability exists in response_json_cb() across all Zephyr versions with hawkBit enabled - on v4.0.0+ any normal hawkBit metadata response body exceeding 1100 bytes triggers the write deterministically, while pre-v4.0.0 requires an exact-length server response. A malicious, compromised, or man-in-the-middle hawkBit server can exploit this with no authentication of response content required, as TLS protects transport integrity but not against a hostile server itself. No public exploit is identified at time of analysis; upstream fix is confirmed via commit 59d7ab5.

RemediationAI

The upstream patch is available as commit 59d7ab58d853489e6134081cadb11733730264ac (https://github.com/zephyrproject-rtos/zephyr/commit/59d7ab58d853489e6134081cadb11733730264ac); upgrade to Zephyr 4.5.0 or cherry-pick this commit into downstream firmware builds. The fix adds +1 to the allocation size and replaces strncpy with memcpy, eliminating both the v4.0.0+ deterministic variant and the pre-v4.0.0 equality-skips-realloc variant. If upgrading is not immediately possible, disable the hawkBit client (unset CONFIG_HAWKBIT) as a compensating control - this removes the attack surface entirely but also disables OTA updates. Alternatively, restrict network access from devices to only trusted, TLS-authenticated update server endpoints and enforce certificate pinning to prevent MitM; this does not eliminate the flaw but removes the remote attack path for non-insider threat scenarios. Advisory: https://github.com/zephyrproject-rtos/zephyr/security/advisories/GHSA-39h3-7phx-pwhv.

Affected VersionsENISA

Zephyr 2.4.0 <4.5.0

Affected Packages

euvd zephyr fix: 4.5.0

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The Zephyr RTOS hawkBit management client (subsys/mgmt/hawkbit/hawkbit.c) accumulates HTTP response bodies chunk-by-chunk into a dynamically reallocated heap buffer in response_json_cb(). CWE-122 (Heap-Based Buffer Overflow) is the root cause: the reallocation sizing logic omitted +1 for the NUL terminator appended after the final fragment. In Zephyr v4.0.0+, the buffer is grown to exactly downloaded_size + body_len, so any response body larger than the 1100-byte default initial buffer makes the out-of-bounds write deterministic. Prior to v4.0.0, a doubling-growth scheme contained an off-by-one in the growth check - a response body whose length exactly equals the current allocation (1100 bytes at default) bypasses reallocation entirely, and the terminator lands at response_data[1100] of a 1100-byte object. The HTTP declared-length check does not protect against this because declared and received lengths agree. The fix, visible in commit 59d7ab58d853, resizes to downloaded_size + body_len + 1 and replaces strncpy with memcpy, eliminating both variants. CPE: cpe:2.3:a:zephyrproject:zephyr.

Know when Zephyr gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (zephyr) PRIMARY HIGH
NVD 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
vuln.today AI 7.5 HIGH

Update server controls HTTP response over network with no device-side auth; impact is heap corruption causing DoS only, no confidentiality or integrity loss.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (zephyr).

CVSS VectorNVD

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
None
Availability
High

Lifecycle Timeline

3
Analysis Updated
Aug 09, 2026 - 14:58 vuln.today
v2 - CVSS changed
CVSS changed
Aug 09, 2026 - 14:52 NVD
8.2 (HIGH) 7.5 (HIGH)
CVE Published
Aug 03, 2026 - 21:21 cve.org
HIGH 8.2

DescriptionNVD

The hawkBit device management client in subsys/mgmt/hawkbit accumulates the body of an HTTP response from the update server into a heap buffer in response_json_cb() (subsys/mgmt/hawkbit/hawkbit.c). The buffer is sized to hold the received body bytes but reserves no space for a terminating NUL. When the full response has arrived, the code writes response_data[downloaded_size] = '\0' - and whenever the accumulated body length equals the allocation, that terminator lands one byte past the end of the heap object (a heap-based out-of-bounds write, CWE-122 / CWE-787).

The body length and fragmentation are taken directly from the parsed HTTP response (rsp->body_frag_start / rsp->body_frag_len) and are fully controlled by the remote hawkBit server, which chooses its own response length. The precise trigger depends on how the buffer grows, and both forms are remotely reachable. Since v4.0.0 the reallocation is sized to exactly downloaded_size + body_len, so any response body larger than the 1100-byte initial buffer makes the out-of-bounds write deterministic; such response sizes are normal for hawkBit deployment metadata. Before v4.0.0 the buffer grew by doubling and the growth check ((downloaded_size + body_len) > response_buffer_size) is false at equality, so a response body whose length is exactly the current allocation - 1100 bytes with the default initial buffer - skips the reallocation entirely and writes the terminator at response_data[1100] of an 1100-byte object. The HTTP length-mismatch check does not catch this, because the declared and received lengths genuinely agree. Either form is reachable by a malicious, compromised, or man-in-the-middle update server (TLS is optional and, when enabled, does not protect against a hostile server), with no authentication of response content and no client-side length cap protecting the write.

The out-of-bounds write is a fixed single NUL byte immediately following the allocation, corrupting adjacent allocator metadata or the next allocation. The practical impact is heap corruption leading to denial of service (fault on a subsequent allocation or free), with the bounded, allocator-dependent possibility of further corruption. The fix sizes the buffer to the body length plus one and copies with memcpy, ensuring the terminator always lands within the allocation.

Executive ViewAI

Why It Matters

The Zephyr RTOS hawkBit OTA update client (versions 2.4.0-4.4.x) contains a heap memory corruption vulnerability allowing a malicious or compromised update server to corrupt device memory during routine OTA updates, affecting embedded systems that depend on this mechanism. Organizations deploying Zephyr-based IoT or embedded devices must upgrade immediately to close this update-channel attack vector.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.3%
Top 82% exploitable
Prevalence
Low
embedded IoT RTOS with hawkBit OTA rarely enabled in production
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

38
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +38
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

A heap overflow occurs when a program writes data beyond the bounds of a buffer allocated in the heap memory region.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

More in Zephyr

View all
CVE-2023-4260 CRITICAL POC
10.0 Sep 27

Potential off-by-one buffer overflow vulnerability in the Zephyr fuse file system. Rated critical severity (CVSS 10.0),

CVE-2026-1678 CRITICAL POC
9.8 Mar 05

An out-of-bounds write in the Zephyr RTOS DNS resolver (dns_unpack_name()) lets a crafted DNS response corrupt memory on

CVE-2023-5055 CRITICAL POC
9.8 Nov 21

Possible variant of CVE-2021-3434 in function le_ecred_reconf_req. Rated critical severity (CVSS 9.8), this vulnerabilit

CVE-2023-4257 CRITICAL POC
9.8 Oct 13

Unchecked user input length in /subsys/net/l2/wifi/wifi_shell.c can cause buffer overflows. Rated critical severity (CVS

CVE-2023-3725 CRITICAL POC
9.8 Oct 06

Potential buffer overflow vulnerability in the Zephyr CAN bus subsystem. Rated critical severity (CVSS 9.8), this vulner

CVE-2021-3323 CRITICAL POC
9.8 Oct 12

Integer Underflow in 6LoWPAN IPHC Header Uncompression in Zephyr. Rated critical severity (CVSS 9.8), this vulnerability

CVE-2021-3625 CRITICAL POC
9.8 Oct 05

Buffer overflow in Zephyr USB DFU DNLOAD. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable

CVE-2021-3319 CRITICAL POC
9.8 Oct 05

DOS: Incorrect 802154 Frame Validation for Omitted Source / Dest Addresses. Rated critical severity (CVSS 9.8), this vul

CVE-2018-1000800 CRITICAL POC
9.8 Sep 06

zephyr-rtos version 1.12.0 contains a NULL base pointer reference vulnerability in sys_ring_buf_put(), sys_ring_buf_get(

CVE-2023-4264 CRITICAL POC
9.6 Sep 27

Potential buffer overflow vulnerabilities n the Zephyr Bluetooth subsystem. Rated critical severity (CVSS 9.6), this vul

CVE-2024-1638 CRITICAL POC
9.1 Feb 19

The documentation specifies that the BT_GATT_PERM_READ_LESC and BT_GATT_PERM_WRITE_LESC defines for a Bluetooth characte

CVE-2023-5753 HIGH POC
8.8 Oct 25

Potential buffer overflows in the Bluetooth subsystem due to asserts being disabled in /subsys/bluetooth/host/hci_core.c

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy