CVE-2026-129805 in SOES
Summary
by MITRE • 11/21/2026
An object dictionary entry can carry write-access flags and still have a NULL data pointer, for example when a constant value is held in the value field rather than in addressable storage. The CoE SDO download handler checked write access but not whether storage was present, then wrote the master-supplied payload through the NULL pointer.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/21/2026
The vulnerability described constitutes a critical memory corruption flaw within the CANopen Ethernet (CoE) protocol implementation, specifically affecting the Service Data Object (SDO) download mechanism. In industrial automation and embedded systems utilizing CoE, object dictionaries serve as the primary interface for configuration and control. These entries often include access flags that dictate whether data can be read or written by a master device. The core technical flaw arises from an incomplete validation check during write operations. While the implementation correctly verifies if the target entry permits write access based on its metadata attributes, it fails to verify the existence of actual storage space for the payload. This oversight allows a scenario where an object dictionary entry is configured with write permissions but lacks associated addressable memory, typically because the value is hardcoded as a constant rather than stored in volatile or non-volatile RAM.
When a remote master device initiates an SDO download to such an entry, the handler proceeds past the access control check and attempts to write the incoming data payload directly into the memory location specified by the object dictionary pointer. Since this pointer is NULL due to the absence of allocated storage for dynamic values, the operation results in a direct null pointer dereference or, depending on the specific compiler optimizations and hardware architecture, potentially leads to an arbitrary code execution if the NULL page is mapped with write permissions in certain embedded environments. This represents a classic instance of improper input validation combined with unsafe memory access patterns. The attacker does not need authentication beyond what is required for standard SDO communication; they simply send a malformed or specifically targeted download request to any writable constant entry within the object dictionary.
The operational impact of this vulnerability is severe, ranging from denial of service to complete system compromise. In most embedded industrial control systems, writing to address zero triggers an immediate hardware exception, causing the device to crash, reset, or enter a fault state. This results in a reliable remote denial-of-service condition that can disrupt critical production lines or infrastructure operations without requiring physical access. However, if the underlying operating system or runtime environment maps page zero with write permissions for legacy compatibility reasons, this flaw could be exploited for arbitrary code execution. An attacker could potentially overwrite instruction pointers or function return addresses located near address zero, thereby gaining control over the device's firmware logic. This aligns closely with CWE-476 (NULL Pointer Dereference) and CWE-20 (Improper Input Validation), highlighting a failure to ensure that input data is compatible with the expected memory layout before processing.
From an offensive security perspective, this vulnerability maps directly to MITRE ATT&CK techniques involving remote code execution or service disruption via network-based attacks on industrial protocols. Specifically, it relates to T1496 (Resource Hijacking) if used for denial of service, or potentially T1055 (Process Injection) if the null pointer write leads to memory corruption that facilitates further exploitation steps. The vulnerability underscores a common pitfall in embedded software development where developers assume that access control checks are sufficient security boundaries without considering the integrity of data structures and memory management policies.
Mitigation strategies must focus on hardening the SDO download handler logic. Developers should implement explicit null pointer checks before any write operation is attempted against an object dictionary entry. If a value is intended to be constant, it should either be marked as read-only in the access flags or handled through a separate mechanism that does not involve direct memory writes via pointers. Additionally, enabling compiler protections such as stack canaries and address space layout randomization (ASLR), where feasible on the target platform, can mitigate the impact of any resulting memory corruption. Network-level defenses should also be considered; since CoE often runs over TCP/IP or UDP, restricting access to SDO services via firewalls or VLAN segmentation limits exposure to untrusted networks. Regular code audits focusing on pointer arithmetic and object dictionary handling are essential to prevent similar flaws in future iterations of the firmware.