Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition as MitM or compromise hawkBit update server
-
DeliveryCraft HTTP response body sized to match device heap allocation
-
ExploitDevice's response_json_cb() writes NUL past heap boundary
-
ExecutionAdjacent allocator metadata corrupted
-
PersistSubsequent heap operation triggers fault
-
ImpactDevice 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – 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)
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
Affected Packages
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
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Update server controls HTTP response over network with no device-side auth; impact is heap corruption causing DoS only, no confidentiality or integrity loss.
Primary rating from Vendor (zephyr).
CVSS VectorNVD
Lifecycle Timeline
3DescriptionNVD
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
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.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
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.
Potential off-by-one buffer overflow vulnerability in the Zephyr fuse file system. Rated critical severity (CVSS 10.0),
An out-of-bounds write in the Zephyr RTOS DNS resolver (dns_unpack_name()) lets a crafted DNS response corrupt memory on
Possible variant of CVE-2021-3434 in function le_ecred_reconf_req. Rated critical severity (CVSS 9.8), this vulnerabilit
Unchecked user input length in /subsys/net/l2/wifi/wifi_shell.c can cause buffer overflows. Rated critical severity (CVS
Potential buffer overflow vulnerability in the Zephyr CAN bus subsystem. Rated critical severity (CVSS 9.8), this vulner
Integer Underflow in 6LoWPAN IPHC Header Uncompression in Zephyr. Rated critical severity (CVSS 9.8), this vulnerability
Buffer overflow in Zephyr USB DFU DNLOAD. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitable
DOS: Incorrect 802154 Frame Validation for Omitted Source / Dest Addresses. Rated critical severity (CVSS 9.8), this vul
zephyr-rtos version 1.12.0 contains a NULL base pointer reference vulnerability in sys_ring_buf_put(), sys_ring_buf_get(
Potential buffer overflow vulnerabilities n the Zephyr Bluetooth subsystem. Rated critical severity (CVSS 9.6), this vul
The documentation specifies that the BT_GATT_PERM_READ_LESC and BT_GATT_PERM_WRITE_LESC defines for a Bluetooth characte
Potential buffer overflows in the Bluetooth subsystem due to asserts being disabled in /subsys/bluetooth/host/hci_core.c
EUVD-2026-52447
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB