Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessPosition as/compromise central system
-
DeliveryOpen or hijack OCPP WebSocket
-
ExploitSend GetConfiguration with >50-byte key
-
ExecutionUnbounded strcpy overflows stack buffer
-
PersistCorrupt reader thread stack
-
ImpactCrash device or execute code
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that the target device runs Zephyr's OCPP 1.6 client and has an active WebSocket session to a central system, and that the attacker occupies the central-system position - either by controlling/compromising the configured central system endpoint, or by man-in-the-middling an unencrypted (non-TLS) OCPP connection. The concrete trigger is a GetConfiguration message whose JSON "key" field exceeds 50 bytes (up to ~2048, bounded by CONFIG_OCPP_RECV_BUFFER_SIZE). Limiting factors: the OCPP client feature must be built in and connected; a TLS-secured, certificate-validated connection to a trusted central system blocks the MITM path and leaves only a malicious/compromised backend as the attack position; and whether the outcome is DoS or RCE depends on build-time stack hardening (canaries, MPU stack guard). No end-user interaction is required. |
| Impact | The raw signals point to high severity: the vendor CVSS 3.1 vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H (9.8), and the flaw is a remotely reachable stack overflow on a network-facing reader thread. However, several caveats temper the practical risk. Exploitation is not fully unauthenticated in the trust sense the vector implies: the attacker must control the configured central system endpoint or MITM an unencrypted (non-TLS) WebSocket connection - a charge point that validates its central system and uses TLS (wss://) substantially narrows the threat to a compromised/rogue backend. Whether the stack smash yields code execution versus only denial of service depends on build-time hardening (stack canaries, MPU/stack-guard configuration) that varies per Zephyr deployment. No KEV listing and no public exploit are known, and no EPSS score was provided, so there is no evidence of active or automated exploitation; the 9.8 reflects worst-case impact rather than demonstrated in-the-wild activity. Any operator running Zephyr-based OCPP charge points should nonetheless treat this as an urgent patch item given the memory-corruption primitive and network exposure. Note the vector's PR:N assumes the malicious server is a valid attacker position - verify against your deployment's trust model. |
| Exploit ScenarioDerived | An attacker who operates or has compromised the central management system a charge point connects to - or who sits as a man-in-the-middle on an unencrypted WebSocket link - sends an OCPP GetConfiguration request whose "key" field is longer than 50 bytes. The oversized key is copied via unbounded strcpy() into the 50-byte stack buffer, overflowing the reader thread's stack and crashing the device or, depending on hardening, executing attacker-controlled code. No public proof-of-concept exploit has been identified at time of analysis, and low complexity (AC:L) means a single crafted message suffices. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 25, 2026
Remote code execution and denial of service in the Zephyr RTOS OCPP 1.6 client (subsys/net/lib/ocpp) allows an attacker who controls or man-in-the-middles the central system endpoint to smash the OCPP reader thread's stack. A malicious GetConfiguration message with an over-long JSON "key" field triggers an unbounded strcpy() into a fixed 50-byte stack buffer, corrupting the reader thread's stack with attacker-chosen bytes. A vendor patch exists and no public exploit has been identified at time of analysis; CVSS is rated 9.8, though real-world reach is bounded by the OCPP-charging-station niche.
RemediationAI
Patch available per vendor advisory: apply the upstream fix in Zephyr commit afbf880b04188ae53451a0ade4ac62b654fdff34 (https://github.com/zephyrproject-rtos/zephyr/commit/afbf880b04188ae53451a0ade4ac62b654fdff34), which replaces the unbounded strcpy() with strncpy(key, payload.key[0], CISTR50 - 1) plus explicit NUL termination; consult GHSA-fqhf-6v24-4px2 for the exact patched release tag, as no specific fixed version number was supplied in the input. Rebuild and reflash affected charge-point firmware. Where immediate patching is not possible, compensating controls include: enforce TLS (wss://) with server-certificate validation on the OCPP WebSocket to block the MITM position (trade-off: requires PKI/cert provisioning on constrained devices); pin/whitelist the central system endpoint so the client will not connect to rogue backends; and enable stack canaries and MPU-based stack guards in the Zephyr build (CONFIG_STACK_CANARIES / CONFIG_MPU_STACK_GUARD) so an overflow degrades to a controlled fault rather than code execution (trade-off: minor code-size and runtime overhead). These controls reduce but do not eliminate the DoS exposure from a compromised legitimate central system.
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 affected component is Zephyr's Open Charge Point Protocol (OCPP) 1.6 client, used by EV charge points to communicate with a central management system over a WebSocket (typically OCPP-J, the JSON-over-WebSocket variant). In parse_getconfig_msg() (subsys/net/lib/ocpp/ocpp_j.c), a parsed JSON "key" value - a pointer directly into the receive buffer ui->recv_buf, whose size is CONFIG_OCPP_RECV_BUFFER_SIZE (default 2048 bytes) - is copied with an unbounded strcpy() into the caller's fixed skey[CISTR50] 50-byte stack buffer declared in ocpp.c. This is a classic CWE-787 out-of-bounds write: the destination bound (50) is smaller than the attacker-controllable source length (up to ~2048), and the copy has no length check. Sibling PDU handlers already used bounded copies, making this handler an outlier.
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:H/I:H/A:H
Network-reachable via WebSocket with a single low-complexity crafted message and no auth in the client's trust model (PR:N); stack overflow yields high DoS and plausible code-execution impact.
Primary rating from Vendor (zephyr).
CVSS VectorVendor: zephyr
DescriptionCVE.org
The OCPP 1.6 client in subsys/net/lib/ocpp/ocpp_j.c contains a stack buffer overflow in parse_getconfig_msg(). When handling a GetConfiguration request from the central system, the handler copied the attacker-controlled JSON "key" string into the caller's fixed 50-byte stack buffer (skey[CISTR50], declared in subsys/net/lib/ocpp/ocpp.c) using an unbounded strcpy(). The parsed key value points directly into the receive buffer, so its length is bounded only by the message size (CONFIG_OCPP_RECV_BUFFER_SIZE, default 2048).
The GetConfiguration message is delivered over the WebSocket connection that the charge point opens to its configured central system. The reader thread ocpp_wsreader() reads the message into ui->recv_buf and dispatches it to parse_getconfig_msg() via the PDU function table. An attacker who controls the central system endpoint, or a man-in-the-middle on an unencrypted connection, can send a GetConfiguration request whose "key" field exceeds 50 bytes and overflow the reader thread's stack with attacker-chosen bytes.
The consequence is a remotely triggerable stack smash on the OCPP reader thread: at minimum a denial of service, and plausibly remote code execution depending on build-time hardening such as stack canaries and MPU configuration. The fix replaces the strcpy() with a bounded strncpy(key, payload.key[0], CISTR50 - 1) followed by explicit NUL termination, matching the bounded copies already used by the sibling handlers.
Executive ViewAI
A critical vulnerability in Zephyr RTOS OCPP 1.6 charging station client (CVSS 9.8) enables remote code execution and denial of service against EV charging infrastructure. Organizations operating Zephyr-based charging stations face immediate risk of service disruption, data compromise, and loss of operational control.
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.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
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-65291
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB