Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain LoRaWAN session keys or compromise application server
-
DeliveryCraft short AppTimeAns frame missing 5-byte payload
-
ExploitTransmit frame on clock-sync port
-
ExecutionFrame passes MAC integrity and decryption
-
PersistOOB read of 5 adjacent bytes in static buffer
-
ImpactGarbage time-correction silently applied to device clock offset
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK
1 technique across 1 tactic: Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The LoRaWAN clock synchronization service (CONFIG_LORAWAN_APP_CLOCK_SYNC or equivalent) must be compiled and active on the target Zephyr device. The attacker must be able to deliver a LoRaWAN downlink that passes the stack's MAC integrity check (MIC verification) and FRMPayload decryption - this requires either operating the legitimate LoRaWAN network or application server for the device, or independently possessing the current NwkSKey and AppSKey session keys. Arbitrary LoRaWAN radio observers cannot forge valid frames without these keys. Limiting factors: attacker position is highly constrained (server control or key possession required); impact is bounded to device-local clock offset corruption; no user interaction or privilege escalation path exists. |
| Impact | The provided CVSS 3.1 base score of 3.1 (AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:N) accurately reflects the constrained real-world risk. Adjacent attack vector is correct because exploitation requires delivering a valid LoRaWAN downlink that survives MAC integrity verification and FRMPayload decryption - an arbitrary radio listener cannot forge such a frame. High attack complexity is appropriate because the attacker must either operate the legitimate LoRaWAN application server for the targeted device or independently possess the current session keys. The sole impact is a transient, device-local time-offset corruption (I:L), with no confidentiality or availability consequence confirmed. No EPSS score was provided in source data; given the niche attacker position (server-side control or key possession), opportunistic mass exploitation is implausible. No KEV listing and no public exploit exist. Despite the technical OOB read classification, this is a genuine low-priority item: the bounded buffer prevents crashes, the over-read values are never exfiltrated, and the practical attacker already occupies a highly privileged network position. The sibling unguarded one-byte reads noted in the periodicity and force-resync handlers carry equivalent negligible impact. |
| Exploit ScenarioDerived | An attacker who operates or has compromised the LoRaWAN application server for a target Zephyr device crafts a short AppTimeAns downlink - omitting the required 5-byte payload - and transmits it on the clock-sync port. The frame passes MAC integrity verification using the current session keys, is decrypted, and delivered to clock_sync_package_callback(); the handler then reads 5 bytes past the valid payload into adjacent static buffer memory, potentially applying a garbage time-correction to the device's ctx.time_offset. No public exploit code exists; exploitation requires server-side access or session key compromise. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 26, 2026
Out-of-bounds read in Zephyr RTOS's LoRaWAN clock synchronization service allows a malicious or compromised LoRaWAN application server to corrupt the target device's internal time offset by sending a crafted short AppTimeAns frame. The over-read is bounded by a 255-byte static backing buffer so no crash occurs, and the stray bytes are never transmitted back to the attacker, eliminating any information disclosure. Impact is confined to a minor, device-local clock integrity issue - the device's time estimate may silently diverge if a garbage time-correction value happens to match the pending token. No public exploit identified at time of analysis, and no CISA KEV listing.
RemediationAI
Apply the upstream fix available in Zephyr commit 3d578067652b12993bca13fb8e07dc45d062d4a5 (https://github.com/zephyrproject-rtos/zephyr/commit/3d578067652b12993bca13fb8e07dc45d062d4a5), which adds an explicit guard - if ((len - rx_pos) < (sizeof(int32_t) + sizeof(uint8_t))) return; - before AppTimeAns field reads. A released tagged version containing this fix was not independently confirmed from the available data; integrators should cherry-pick the commit or await a Zephyr release that includes it. As a compensating control, projects that do not require LoRaWAN application-layer time synchronization should disable the clock-sync service at build time (remove CONFIG_LORAWAN_APP_CLOCK_SYNC or equivalent Kconfig option) to eliminate the attack surface entirely with no functional trade-off. Note that sibling handlers for periodicity and force-resync commands contain analogous unguarded one-byte reads that the fix commit does not address; these carry equivalent low impact but may warrant follow-on patches.
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 flaw resides in subsys/lorawan/services/clock_sync.c within clock_sync_package_callback(), the registered downlink handler for the LoRaWAN Application Layer Clock Synchronization v1.0 service. The command dispatch loop validates only that the one-byte command identifier is within the receive buffer (rx_pos < len) but does not subsequently verify that the remaining bytes (len - rx_pos) are sufficient before calling sys_get_le32() to read a 4-byte int32_t time_correction and then a 1-byte token - a total of 5 bytes that may not be present. CWE-125 (Out-of-Bounds Read) applies: the handler reads past the end of the decrypted FRMPayload buffer delivered via mcps_indication->Buffer/BufferSize. Because the backing store is a statically allocated 255-byte array the stray reads do not trigger a fault; they simply capture adjacent stack/static memory values as ctx.time_offset and token. Affected product: cpe:2.3:a:zephyrproject:zephyr:*:*:*:*:*:*:*:* - all Zephyr versions with the LoRaWAN clock-sync service compiled in.
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:A/AC:L/PR:N/UI:N/S:U/C:N/I:L/A:N
Adjacent vector and high complexity reflect LoRaWAN server control or session-key possession requirement; no confidentiality or availability impact confirmed from description.
Primary rating from Vendor (zephyr).
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
The LoRaWAN application-layer clock-synchronization service parses downlinks in clock_sync_package_callback() (subsys/lorawan/services/clock_sync.c). Its command loop only guarantees that the one-byte command id is in bounds; for the CLOCK_SYNC_CMD_APP_TIME (AppTimeAns) command the handler then reads a 4-byte time correction via sys_get_le32() plus a 1-byte token without checking that 5 bytes remain in the receive buffer (len - rx_pos). A short or crafted AppTimeAns therefore reads up to 5 bytes past the end of the decrypted payload.
The payload (rx_buf/len) is the decrypted application frame delivered to the registered downlink callback (mcps_indication->Buffer/BufferSize). Reaching the handler requires a frame on the clock-sync port that passes LoRaWAN's MAC integrity check and FRMPayload decryption, so the practical attacker is a malicious or compromised network/application server (the designated sender of AppTimeAns) or a party holding the session keys, rather than an arbitrary radio listener.
The over-read is bounded: the backing store is a fixed 255-byte static buffer, so the few stray bytes do not fault, and the read values (time_correction, token) are used only internally and never transmitted, so there is no disclosure to the attacker and no crash. The sole effect is that a stale token matching ctx.req_token can apply a garbage time_correction to the device's own clock offset (ctx.time_offset), a minor integrity impact confined to the victim's time estimate. The fix adds an explicit length check that drops a too-short AppTimeAns. Note the sibling one-byte reads in the periodicity and force-resync handlers remain unguarded with the same negligible impact.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
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-66555
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB