On this page (7 sections)
node-opcua, an OPC UA implementation for TypeScript and Node.js, has a critical authorization flaw. When an operator locks down a whole namespace with setDefaultRolePermissions, the server's runtime check does not actually use that setting, and an anonymous network client can write protected variables or call methods on nodes that have no per-node permissions.
If you run an OPC UA server built on node-opcua, especially one that bridges industrial, IoT or dashboard data into web applications, check your version and your access-control setup. The GitHub advisory lists 2.180.0 as the fixed release.
What happened
OPC UA lets a server define role-based access control (RBAC). A node can carry its own RolePermissions, and nodes without them inherit a namespace-wide DefaultRolePermissions value. According to the advisory, node-opcua's runtime enforcement does not honor that inherited namespace default, so a restrictive policy that an operator believes is active has no effect.
The advisory was published on October 23, 2026 and updated on November 10, 2026; the CVE record shows a publication date of November 3, 2026. Only one independent publisher covers this story so far, and that is the project's own advisory, so treat details beyond it as unconfirmed.
Technical details
The maintainers describe the root cause as a combination of a fail-open authorization decision and a disconnect between the configuration API and the enforcement path. In plain terms, three problems work together:
- Null means allow. When the applicable permission list resolves to null, the permission check returns all permissions (Read, Write, Call) to whatever role is asking, including Anonymous. The OPC UA specification's default-deny rule (OPC 10000-3 section 4.8.3) requires the opposite, according to the advisory.
- The namespace default resolves to null. Runtime enforcement reads DefaultRolePermissions variable nodes under Server/Namespaces. The advisory says these resolve to null in every reachable configuration: nodeset-loaded namespaces ship the property without a value, and programmatically created namespaces have no metadata node at all.
- Two disconnected paths.
setDefaultRolePermissions()stores the policy in a private field, while enforcement queries the variable node instead. The call succeeds but changes nothing the enforcement code looks at.
The weakness class is a classic fail-open: when the system cannot determine a rule, it grants access instead of denying it. Combined with a configuration API that appears to work, operators get a false sense of safety. The CVE record lists CWE-285, CWE-636, CWE-863 and CWE-1188.
Which configurations are actually bypassed
The advisory is explicit that two cases are not equally severe:
| Configuration | Status |
|---|---|
| No RolePermissions declared anywhere | Permissive by node-opcua's documented behavior; nothing is bypassed. Treated as an insecure default (CWE-1188), not the 9.1 bypass. |
| A namespace default is set with setDefaultRolePermissions and nodes rely on inheritance | This is the real bypass. The policy is silently ignored and anonymous clients can write variables with CurrentWrite access or call bound methods. |
| Nodes with explicit per-node RolePermissions | Outside the authorization-bypass case. |
| Correctly bound programmatic namespace metadata | Outside the authorization-bypass case. |
Who is affected
You are exposed if all of the following are true: you run node-opcua (or node-opcua-address-space or node-opcua-server) at version 2.42.0 up to but not including 2.180.0, your server is reachable by untrusted clients, and you configured a restrictive namespace default and rely on nodes inheriting it. The CVE record says an anonymous network client can then write variables and call methods.
Servers that never declared a policy are not in the bypass case, because the advisory says the stock nodeset ships DefaultRolePermissions with no value and node-opcua's documented behavior is permissive there. That is still an insecure default worth reviewing, so consider adding explicit permissions.
How to check your exposure
First, find which node-opcua packages and versions your project resolves. Run this in the project directory; any of the three packages showing a version in the affected range needs attention.
npm ls node-opcua node-opcua-address-space node-opcua-serverNext, search your own code for the configuration call. Run this from the repository root; if it returns matches, you probably rely on namespace-level inheritance and are in the real bypass case.
grep -rn "setDefaultRolePermissions" --include=*.ts --include=*.js --exclude-dir=node_modules .Finally, test behavior rather than trusting configuration. In a non-production copy of your server, connect with an anonymous client and confirm that writes and method calls on nodes without explicit permissions are refused. A successful write there means the policy is not being enforced.
What to do now
- Upgrade node-opcua, node-opcua-address-space and node-opcua-server to 2.180.0 or later.
- Rebuild and redeploy, then confirm the resolved versions with npm ls.
- Retest anonymous write and call attempts against a staging copy of your server.
- Review nodes that matter (setpoints, control methods) and consider adding explicit per-node RolePermissions, which the advisory lists as outside the bypass case.
- Restrict network access to the OPC UA endpoint to known clients using firewall rules or network segmentation.
- Disable anonymous sessions where your deployment allows it, and review server data and logs for unexpected changes made while a vulnerable version was running.
This command upgrades all three packages together so their versions stay consistent. Run it in your project directory, then rebuild and redeploy.
npm install node-opcua@2.180.0 node-opcua-address-space@2.180.0 node-opcua-server@2.180.0The fix is in release v2.180.0; the maintainers' change is in pull request 1580.
Detection and monitoring
The research does not describe any known indicators of compromise or in-the-wild exploitation, so detection has to rely on your own records. Look for writes and method calls from anonymous sessions in server logs, unexpected changes to variable values, and connections from addresses you do not recognize.
- Log session creation with the user identity type, and alert on anonymous sessions that perform writes or calls.
- Track changes to critical variables and compare against expected operating ranges.
- Watch for new or unexpected clients reaching the OPC UA port, typically from outside your management network.
Why silent failures matter
The dangerous part is not only the missing check but the silent failure. A configuration call that returns success and enforces nothing is hard to catch in review, and nobody notices until someone tests with an unprivileged client. Make a habit of testing access control from the outside with the lowest-privilege identity, after every upgrade and configuration change. For broader habits that keep small teams on top of fixes like this, see our small business website security guide.
Sources
This article is based on the public sources below. Details can change as vendors and researchers publish more; check the original advisories before acting on version numbers.
