Skip to main content

open62541 CVE-2026-18784

| EUVDEUVD-2026-52789 LOW
Heap-based Buffer Overflow (CWE-122)
2026-08-04 VulDB GHSA-r2hr-h3px-675c
1.9
CVSS 4.0 · Vendor: VulDB
View

Attack ChainAIDerived

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

  1. Access
    Obtain low-privileged local account
  2. Delivery
    Access system running open62541 client
  3. Exploit
    Invoke or influence UA_Client_readNodeClassAttribute call
  4. Execution
    Trigger heap buffer overflow with crafted input
  5. Persist
    Read or corrupt adjacent heap memory
  6. Impact
    Achieve limited local confidentiality/integrity impact

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

Local system access with at minimum a low-privileged OS account is required - remote unauthenticated exploitation is not possible given AV:L/PR:L in the CVSS 4.0 vector. The vulnerability is triggered through the UA_Client_readNodeClassAttribute function in the open62541 client high-level API, meaning the vulnerable code path is only exercised when an application calls this function to read node class attributes from an OPC UA server. If the client connects to a legitimate trusted server and no local attacker can influence the response or invoke the function independently, exploitation is further constrained. Limiting factors include: requirement for local interactive or programmatic access, low-privilege OS account at minimum, and dependency on the application actually invoking the affected high-level API function.

Impact

The CVSS 4.0 score of 1.9 reflects the combination of local-only attack vector (AV:L), low privileges required (PR:L), and uniformly low impact across confidentiality, integrity, and availability (VC:L/VI:L/VA:L). No scope change affects subsequent systems (SC:N/SI:N/SA:N), which is consistent with a client-side library vulnerability that does not propagate to the OPC UA server or other network hosts. The E:P supplemental metric confirms POC existence but does not elevate the base score meaningfully. CVE is not listed in CISA KEV, and EPSS data is not provided - given the local-only constraint and low impact ratings, widespread opportunistic exploitation is unlikely. The primary realistic risk is insider threat or post-compromise lateral movement on multi-user industrial workstations or embedded Linux devices running open62541 client software. The project's dismissal of the report through unofficial channels introduces uncertainty about whether a vendor-sanctioned fix will be released; this governance gap may leave the library unpatched for an extended period.

Exploit ScenarioDerived

An attacker with a low-privileged local account on an industrial workstation or embedded device running an open62541 OPC UA client invokes or manipulates the UA_Client_readNodeClassAttribute function - either directly if they have code execution, or by crafting a malicious OPC UA server response if the client connects to an attacker-controlled endpoint - triggering the heap buffer overflow. Public exploit code exists (referenced at https://github.com/gff-cw/information/issues/11), which lowers the skill threshold for an insider or a post-compromise attacker seeking to escalate access or read adjacent heap memory.

Monitor Track and reassess. Why: LOW severity (CVSS 0.1-3.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Aug 04, 2026

Heap-based buffer overflow in open62541 up to version 1.5.5 allows local low-privileged attackers to corrupt heap memory via the UA_Client_readNodeClassAttribute function in the client high-level API. The vulnerability is confined to local exploitation (AV:L/PR:L), limiting its network attack surface, but publicly available exploit code lowers the barrier for abuse on compromised or multi-tenant systems running open62541 OPC UA clients. The open62541 project closed the issue report as filed through unofficial channels, leaving patch status and official acknowledgment unconfirmed.

RemediationAI

No vendor-released patch has been identified at time of analysis; the open62541 project closed the GitHub issue (https://github.com/open62541/open62541/issues/8139) citing improper reporting channels, and no official advisory has been published. Operators should monitor the official open62541 repository for a future patched release and apply it when available. As a compensating control, restrict local shell and user access to systems running open62541 client software, since exploitation requires local low-privileged access - reducing the attack surface to only essential personnel. In industrial environments, enforce least-privilege OS accounts for processes running OPC UA clients and audit user access logs. Avoid exposing systems running open62541 clients to untrusted local users. Note that these controls address the access prerequisite but do not eliminate the underlying heap overflow; code-level patching remains the definitive fix.

Affected VersionsENISA

Open62541 1.5.1
Open62541 1.5.4
Open62541 1.5.0
Open62541 1.5.2
Open62541 1.5.5
Open62541 1.5.3

Affected Packages

euvd open62541 no fix

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 a widely-adopted open-source C implementation of the OPC UA (OPC Unified Architecture) communication standard, commonly embedded in industrial automation devices, PLCs, SCADA gateways, and IoT edge systems (CPE: cpe:2.3:a:o6:open62541:*:*:*:*:*:*:*:*). The affected function UA_Client_readNodeClassAttribute resides in src/client/ua_client_highlevel.c, which provides a high-level client API for reading node attributes from an OPC UA server. CWE-122 (Heap-based Buffer Overflow) indicates the root cause is a write beyond allocated heap buffer bounds during attribute reading, likely arising from insufficient validation of server-returned data lengths or node class attribute payloads before copying into a fixed-size heap allocation. This class of flaw can corrupt adjacent heap metadata or objects, potentially enabling limited memory disclosure or controlled memory writes.

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 (VulDB) PRIMARY 1.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:L/UI:N/VC:L/VI:L/VA:L/SC:N/SI:N/SA:N/E:P
vuln.today AI 5.3 MEDIUM

Local attack vector and low privileges align with AV:L/PR:L; all impacts are bounded to low given no scope change and limited heap corruption reach.

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

Primary rating from Vendor (VulDB).

CVSS VectorVendor: VulDB

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

Lifecycle Timeline

3
Severity Changed
Aug 04, 2026 - 17:23 NVD
MEDIUM LOW
CVSS changed
Aug 04, 2026 - 17:23 NVD
4.8 (MEDIUM) 1.9 (LOW)
CVE Published
Aug 04, 2026 - 16:30 cve.org
LOW 1.9

DescriptionCVE.org

A vulnerability was found in o6 open62541 up to 1.5.5. This issue affects the function UA_Client_readNodeClassAttribute of the file src/client/ua_client_highlevel.c. Performing a manipulation results in heap-based buffer overflow. Attacking locally is a requirement. The exploit has been made public and could be used. The project closed the issue report, stating that this is not the official way to report a security vulnerability.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Medium
widely used open-source OPC UA library in industrial IoT deployments
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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 LOW
CISA KEV No
Public POC Yes
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
LOW severity (CVSS 0.1-3.9)
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
Defer
Exploitation
Poc
System Exposure· derived
Small
Automatable
No
Human Impact· derived
Low
Technical Impact
Partial

Priority Score

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

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.

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