Skip to main content

open62541 EUVDEUVD-2026-109272

| CVE-2026-116014 CRITICAL
Integer Overflow or Wraparound (CWE-190)
2026-10-24 VulnCheck GHSA-78c3-xxg6-2pf3
9.2
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Victim client connects to malicious OPC UA server
  2. Delivery
    Client requests remote DataType definitions
  3. Exploit
    Server returns oversized structure definition
  4. Execution
    Integer overflow wraps 16-bit memSize field
  5. Impact
    Heap overflow crashes client or executes code

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
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

Exploitation requires the victim to run an open62541-based OPC UA client (versions 1.5.0 through 1.5.6) that connects to an attacker-controlled or compromised OPC UA server AND actively invokes UA_Client_getRemoteDataTypes() to fetch custom DataType definitions. The malicious server must supply a crafted structure description whose field count exceeds UA_BYTE_MAX or whose cumulative member size exceeds UA_UINT16_MAX, wrapping the 16-bit memSize bitfield in UA_DataType_fromStructureDescription() and triggering the heap overflow in decodeBinaryStructure(). Limiting factors: the client must initiate the remote type request against an untrusted server (reflected by AT:P), so passively deployed clients or clients that never call getRemoteDataTypes or only connect to trusted servers are not exposed; no authentication on the client is required (PR:N).

Impact

CVSS 4.0 rates this 9.2 (Critical) with AV:N/AC:L/PR:N/UI:N and high confidentiality, integrity, and availability impact (VC:H/VI:H/VA:H), and vuln.today assigns an 'act_now' priority, so urgency is high. However, the defining nuance is AT:P and the attack direction: this is a CLIENT-side flaw where the attacker is a malicious OPC UA server, not a remotely reachable service - real-world risk therefore hinges on whether open62541-based clients connect to untrusted servers and call UA_Client_getRemoteDataTypes(). No EPSS score is provided in the input, so probabilistic exploitation likelihood cannot be compared. There is no CISA KEV listing, so this is not confirmed as actively exploited, and no confirmed working exploit code is present (the references are patches, source links, and a VulnCheck advisory, not a verified PoC). The mechanism is well understood and a fix exists (1.5.7), and heap overflow with potential code execution plus the act_now label justify prompt patching; the primary mitigating factor against mass exploitation is that the victim must initiate a request to an attacker-controlled server rather than the server being passively exploitable.

Exploit ScenarioDerived

An attacker operates or compromises an OPC UA server that a victim open62541 1.5.x client connects to. When the client calls UA_Client_getRemoteDataTypes() to resolve custom types, the malicious server returns an oversized DataType structure definition whose field count or cumulative size exceeds the 16-bit memSize bitfield; the resulting integer overflow desynchronizes the computed member layout and corrupts the heap in decodeBinaryStructure(), crashing the client or potentially achieving code execution. No confirmed public exploit code was identified at time of analysis.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.4% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 24, 2026

An integer overflow in open62541's UA_DataType_fromStructureDescription() allows a malicious or compromised OPC UA server to corrupt client heap memory when the client fetches custom DataType definitions, resulting in a crash or potential code execution. The flaw affects open62541 1.5.0 through 1.5.6: oversized structure definitions wrap the 16-bit memSize bitfield (and the 8-bit membersSize field), so the size computed during type construction no longer matches the true member layout used later by decodeBinaryStructure(). Exploitation is not passive - the client must connect to an untrusted server and actively invoke UA_Client_getRemoteDataTypes(), which is why CVSS 4.0 records AT:P and the assessed CVSS 3.1 vector uses AC:H despite unauthenticated remote reachability (PR:N); no public exploit was identified at time of analysis, but vuln.today assigns an act_now priority and the vendor has released 1.5.7.

RemediationAI

Vendor-released patch: upgrade to open62541 1.5.7 (https://github.com/open62541/open62541/releases/tag/v1.5.7), which contains commit 0cf4806768c493bc6ccffcd4419da24153b970ec (PRs https://github.com/open62541/open62541/pull/8298 and https://github.com/open62541/open62541/pull/8302) and makes UA_DataType_fromStructureDescription() reject structure and enum definitions whose field count exceeds UA_BYTE_MAX or whose cumulative size exceeds UA_UINT16_MAX by returning UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED instead of wrapping memSize. Note that this bounds-checking behavior rejects previously accepted oversized type definitions, so code that legitimately depends on very large structures may observe new decoding errors after upgrading. Where upgrading is not immediately possible, remove exposure by not calling UA_Client_getRemoteDataTypes() against servers that are not fully trusted, and by pinning client connections to known-good endpoints; the trade-off is that clients relying on runtime discovery of custom vendor DataTypes lose that functionality, and clients that must connect to third-party servers remain exposed. Advisory details are at https://www.vulncheck.com/advisories/open62541-1.5.0-before-1.5.7-integer-overflow-heap-buffer-overflow-via-custom-datatype and ENISA EUVD-2026-109272.

Affected VersionsENISA

Open62541 1.5.0 <1.5.7

Affected Packages

euvd open62541 fix: 1.5.7

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

open62541 is an open-source C implementation of OPC UA. OPC UA permits servers to expose their own structured DataType definitions, which a client can retrieve at runtime and turn into locally usable type metadata via UA_DataType_fromStructureDescription() in src/ua_types_definition.c. The UA_DataType structure stores the total size of a type in memSize, a 16-bit bitfield, and the number of members in an 8-bit membersSize field; the constructor accumulated per-member sizes and padding directly into memSize without bounds checks. A server-supplied StructureDescription with either more than UA_BYTE_MAX fields or a cumulative member size beyond UA_UINT16_MAX therefore silently truncates/wraps those fields (CWE-190), desynchronizing the recorded size from the real layout. When decodeBinaryStructure() later decodes data using this inconsistent type, it writes beyond the allocated buffer, producing a heap-based buffer overflow. The upstream fix (commit 0cf4806768c493bc6ccffcd4419da24153b970ec, PRs #8298 and #8302) accumulates sizes in a wide size_t temporary, rejects definitions exceeding UA_BYTE_MAX fields or UA_UINT16_MAX cumulative size with UA_STATUSCODE_BADENCODINGLIMITSEXCEEDED, and applies the same field-count check to UA_DataType_fromEnumDescription(). The trigger is specifically a client-side retrieval of remote type definitions; the sources do not describe any server-side or library-parsing path that is exploitable without that call.

Know when Open62541 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 (VulnCheck) PRIMARY 9.2 CRITICAL
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 8.1 HIGH

AC:H reflects the required condition that the client must connect to a malicious server and request remote DataTypes; PR:N since the attacker is the server; heap overflow yields full C/I/A impact.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
Present
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

open62541 1.5.0 before 1.5.7 contains an integer overflow in UA_DataType_fromStructureDescription() that wraps the 16-bit memSize field for large custom structure definitions. A malicious OPC UA server can supply DataType definitions via UA_Client_getRemoteDataTypes(), causing decodeBinaryStructure() to overflow the heap, crashing clients or enabling code execution.

Executive ViewAI

Why It Matters

CVE-2026-116014 is a critical integer overflow in open62541 versions 1.5.0 through 1.5.6 that can lead to heap memory corruption and potential code execution on client systems when they connect to malicious OPC UA servers. Organizations using these versions in industrial or IoT environments face significant risk of operational disruption and data compromise, requiring immediate remediation to version 1.5.7.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.4%
Top 63% exploitable
Prevalence
Medium
popular open-source OPC UA stack, but industrial/OT-specific deployment
Social Media
1
Sightings
Data Quality
5 sources
Confidence: Medium

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 CRITICAL
CISA KEV No
Public POC No
EPSS 0.4%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

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

Attack Technique

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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