@zwave-js/cc 14.0.0-beta.1 → 14.0.0-beta.4

package/build/cjs/cc/SecurityCC.js

@@ -0,0 +1,757 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var SecurityCC_exports = {};
+__export(SecurityCC_exports, {
+  SecurityCC: () => SecurityCC,
+  SecurityCCAPI: () => SecurityCCAPI,
+  SecurityCCCommandEncapsulation: () => SecurityCCCommandEncapsulation,
+  SecurityCCCommandEncapsulationNonceGet: () => SecurityCCCommandEncapsulationNonceGet,
+  SecurityCCCommandsSupportedGet: () => SecurityCCCommandsSupportedGet,
+  SecurityCCCommandsSupportedReport: () => SecurityCCCommandsSupportedReport,
+  SecurityCCNetworkKeySet: () => SecurityCCNetworkKeySet,
+  SecurityCCNetworkKeyVerify: () => SecurityCCNetworkKeyVerify,
+  SecurityCCNonceGet: () => SecurityCCNonceGet,
+  SecurityCCNonceReport: () => SecurityCCNonceReport,
+  SecurityCCSchemeGet: () => SecurityCCSchemeGet,
+  SecurityCCSchemeInherit: () => SecurityCCSchemeInherit,
+  SecurityCCSchemeReport: () => SecurityCCSchemeReport
+});
+module.exports = __toCommonJS(SecurityCC_exports);
+var import_core = require("@zwave-js/core");
+var import_safe = require("@zwave-js/shared/safe");
+var import_safe2 = require("@zwave-js/shared/safe");
+var import_async = require("alcalzone-shared/async/index.js");
+var import_node_crypto = require("node:crypto");
+var import_API = require("../lib/API.js");
+var import_CommandClass = require("../lib/CommandClass.js");
+var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
+var import_Types = require("../lib/_Types.js");
+var import_CRC16CC = require("./CRC16CC.js");
+var import_Security2CC = require("./Security2CC.js");
+var import_TransportServiceCC = require("./TransportServiceCC.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var SecurityCC_1, SecurityCCNonceReport_1, SecurityCCCommandEncapsulation_1, SecurityCCSchemeReport_1, SecurityCCNetworkKeySet_1, SecurityCCCommandsSupportedReport_1;
+function getAuthenticationData(senderNonce, receiverNonce, ccCommand, sendingNodeId, receivingNodeId, encryptedPayload) {
+  return import_safe.Bytes.concat([
+    senderNonce,
+    receiverNonce,
+    import_safe.Bytes.from([
+      ccCommand,
+      sendingNodeId,
+      receivingNodeId,
+      encryptedPayload.length
+    ]),
+    encryptedPayload
+  ]);
+}
+function throwNoNonce(reason) {
+  let message = `Security CC requires a nonce to be sent!`;
+  if (reason)
+    message += ` Reason: ${reason}`;
+  throw new import_core.ZWaveError(message, import_core.ZWaveErrorCodes.SecurityCC_NoNonce);
+}
+const HALF_NONCE_SIZE = 8;
+function assertSecurityRX(ctx) {
+  if (!ctx.ownNodeId) {
+    throw new import_core.ZWaveError(`Secure commands (S0) can only be decoded when the controller's node id is known!`, import_core.ZWaveErrorCodes.Driver_NotReady);
+  }
+  if (!ctx.securityManager) {
+    throw new import_core.ZWaveError(`Secure commands (S0) can only be decoded when the security manager is set up!`, import_core.ZWaveErrorCodes.Driver_NoSecurity);
+  }
+}
+function assertSecurityTX(ctx) {
+  if (!ctx.ownNodeId) {
+    throw new import_core.ZWaveError(`Secure commands (S0) can only be sent when the controller's node id is known!`, import_core.ZWaveErrorCodes.Driver_NotReady);
+  }
+  if (!ctx.securityManager) {
+    throw new import_core.ZWaveError(`Secure commands (S0) can only be sent when the security manager is set up!`, import_core.ZWaveErrorCodes.Driver_NoSecurity);
+  }
+}
+let SecurityCCAPI = class SecurityCCAPI2 extends import_API.PhysicalCCAPI {
+  supportsCommand(_cmd) {
+    return true;
+  }
+  async sendEncapsulated(encapsulated, requestNextNonce = false) {
+    if (requestNextNonce) {
+      this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.CommandEncapsulation);
+    } else {
+      this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.CommandEncapsulationNonceGet);
+    }
+    const cc = new (requestNextNonce ? SecurityCCCommandEncapsulationNonceGet : SecurityCCCommandEncapsulation)({
+      nodeId: this.endpoint.nodeId,
+      encapsulated
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  /**
+   * Requests a new nonce for Security CC encapsulation which is not directly linked to a specific command.
+   */
+  async getNonce() {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.NonceGet);
+    const cc = new SecurityCCNonceGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, {
+      ...this.commandOptions,
+      // Only try getting a nonce once
+      maxSendAttempts: 1
+    });
+    if (!response)
+      return;
+    const nonce = response.nonce;
+    const secMan = this.host.securityManager;
+    secMan.setNonce({
+      issuer: this.endpoint.nodeId,
+      nonceId: secMan.getNonceId(nonce)
+    }, { nonce, receiver: this.host.ownNodeId }, { free: true });
+    return nonce;
+  }
+  /**
+   * Responds to a NonceGet request. The message is sent without any retransmission etc.
+   * The return value indicates whether a nonce was successfully sent
+   */
+  async sendNonce() {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.NonceReport);
+    if (!this.host.securityManager) {
+      throw new import_core.ZWaveError(`Nonces can only be sent if secure communication is set up!`, import_core.ZWaveErrorCodes.Driver_NoSecurity);
+    }
+    const nonce = this.host.securityManager.generateNonce(this.endpoint.nodeId, HALF_NONCE_SIZE);
+    const nonceId = this.host.securityManager.getNonceId(nonce);
+    const cc = new SecurityCCNonceReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      nonce
+    });
+    try {
+      await this.host.sendCommand(cc, {
+        ...this.commandOptions,
+        // Seems we need these options or some nodes won't accept the nonce
+        transmitOptions: import_core.TransmitOptions.ACK | import_core.TransmitOptions.AutoRoute,
+        // Only try sending a nonce once
+        maxSendAttempts: 1,
+        // Nonce requests must be handled immediately
+        priority: import_core.MessagePriority.Immediate,
+        // We don't want failures causing us to treat the node as asleep or dead
+        changeNodeStatusOnMissingACK: false
+      });
+    } catch (e) {
+      if ((0, import_core.isTransmissionError)(e)) {
+        this.host.securityManager.deleteNonce(nonceId);
+        return false;
+      } else {
+        throw e;
+      }
+    }
+    return true;
+  }
+  async getSecurityScheme() {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.SchemeGet);
+    const cc = new SecurityCCSchemeGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+    return [0];
+  }
+  async reportSecurityScheme(encapsulated) {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.SchemeReport);
+    let cc = new SecurityCCSchemeReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    if (encapsulated) {
+      cc = new SecurityCCCommandEncapsulation({
+        nodeId: this.endpoint.nodeId,
+        endpointIndex: this.endpoint.index,
+        encapsulated: cc
+      });
+    }
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  async inheritSecurityScheme() {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.SchemeInherit);
+    const cc = new SecurityCCSchemeInherit({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  async setNetworkKey(networkKey) {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.NetworkKeySet);
+    const keySet = new SecurityCCNetworkKeySet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      networkKey
+    });
+    const cc = new SecurityCCCommandEncapsulation({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      encapsulated: keySet,
+      alternativeNetworkKey: new Uint8Array(16).fill(0)
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  async verifyNetworkKey() {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.NetworkKeyVerify);
+    const cc = new SecurityCCNetworkKeyVerify({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  async getSupportedCommands() {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.CommandsSupportedGet);
+    const cc = new SecurityCCCommandsSupportedGet({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index
+    });
+    const response = await this.host.sendCommand(cc, this.commandOptions);
+    if (response) {
+      return (0, import_safe2.pick)(response, ["supportedCCs", "controlledCCs"]);
+    }
+  }
+  async reportSupportedCommands(supportedCCs, controlledCCs) {
+    this.assertSupportsCommand(import_Types.SecurityCommand, import_Types.SecurityCommand.CommandsSupportedReport);
+    const cc = new SecurityCCCommandsSupportedReport({
+      nodeId: this.endpoint.nodeId,
+      endpointIndex: this.endpoint.index,
+      supportedCCs,
+      controlledCCs,
+      reportsToFollow: 0
+    });
+    await this.host.sendCommand(cc, this.commandOptions);
+  }
+};
+SecurityCCAPI = __decorate([
+  (0, import_CommandClassDecorators.API)(import_core.CommandClasses.Security)
+], SecurityCCAPI);
+let SecurityCC = SecurityCC_1 = class SecurityCC2 extends import_CommandClass.CommandClass {
+  async interview(ctx) {
+    const node = this.getNode(ctx);
+    const endpoint = this.getEndpoint(ctx);
+    const api = import_API.CCAPI.create(import_core.CommandClasses.Security, ctx, endpoint).withOptions({
+      priority: import_core.MessagePriority.NodeQuery
+    });
+    ctx.logNode(node.id, {
+      message: "Querying securely supported commands (S0)...",
+      direction: "outbound"
+    });
+    let supportedCCs;
+    let controlledCCs;
+    const MAX_ATTEMPTS = this.endpointIndex === 0 ? 3 : 1;
+    for (let attempts = 1; attempts <= MAX_ATTEMPTS; attempts++) {
+      const resp = await api.getSupportedCommands();
+      if (resp) {
+        supportedCCs = resp.supportedCCs;
+        controlledCCs = resp.controlledCCs;
+        break;
+      } else if (attempts < MAX_ATTEMPTS) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `Querying securely supported commands (S0), attempt ${attempts}/${MAX_ATTEMPTS} failed. Retrying in 500ms...`,
+          level: "warn"
+        });
+        await (0, import_async.wait)(500);
+      }
+    }
+    if (!supportedCCs || !controlledCCs) {
+      if (node.hasSecurityClass(import_core.SecurityClass.S0_Legacy) === true) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: "Querying securely supported commands (S0) failed",
+          level: "warn"
+        });
+      } else {
+        ctx.logNode(node.id, `The node was not granted the S0 security class. Continuing interview non-securely.`);
+        node.setSecurityClass(import_core.SecurityClass.S0_Legacy, false);
+      }
+      return;
+    }
+    const logLines = [
+      "received secure commands (S0)",
+      "supported CCs:"
+    ];
+    for (const cc of supportedCCs) {
+      logLines.push(`\xB7 ${(0, import_core.getCCName)(cc)}`);
+    }
+    logLines.push("controlled CCs:");
+    for (const cc of controlledCCs) {
+      logLines.push(`\xB7 ${(0, import_core.getCCName)(cc)}`);
+    }
+    ctx.logNode(node.id, {
+      message: logLines.join("\n"),
+      direction: "inbound"
+    });
+    for (const cc of supportedCCs) {
+      if (cc === import_core.CommandClasses.Basic) {
+        endpoint.addCC(cc, { secure: true });
+      } else {
+        endpoint.addCC(cc, {
+          isSupported: true,
+          secure: true
+        });
+      }
+    }
+    for (const cc of controlledCCs) {
+      if (cc === import_core.CommandClasses.Basic) {
+        endpoint.addCC(cc, { secure: true });
+      } else {
+        endpoint.addCC(cc, {
+          isControlled: true,
+          secure: true
+        });
+      }
+    }
+    if (node.hasSecurityClass(import_core.SecurityClass.S0_Legacy) !== true) {
+      node.setSecurityClass(import_core.SecurityClass.S0_Legacy, true);
+      ctx.logNode(node.id, `The node was granted the S0 security class`);
+    }
+    this.setInterviewComplete(ctx, true);
+  }
+  /** Tests if a command should be sent secure and thus requires encapsulation */
+  static requiresEncapsulation(cc) {
+    if (!(cc.encapsulationFlags & import_core.EncapsulationFlags.Security)) {
+      return false;
+    }
+    if (cc instanceof import_Security2CC.Security2CC || cc instanceof import_CRC16CC.CRC16CC || cc instanceof import_TransportServiceCC.TransportServiceCC) {
+      return false;
+    }
+    if (cc instanceof SecurityCC_1) {
+      switch (cc.ccCommand) {
+        // Already encapsulated
+        case import_Types.SecurityCommand.CommandEncapsulation:
+        case import_Types.SecurityCommand.CommandEncapsulationNonceGet:
+        // Cannot be sent encapsulated:
+        case import_Types.SecurityCommand.NonceGet:
+        case import_Types.SecurityCommand.NonceReport:
+        case import_Types.SecurityCommand.SchemeGet:
+        case import_Types.SecurityCommand.SchemeReport:
+          return false;
+        default:
+          return true;
+      }
+    }
+    return true;
+  }
+  /** Encapsulates a command that should be sent encrypted */
+  static encapsulate(ownNodeId, securityManager, cc) {
+    const ret = new SecurityCCCommandEncapsulation({
+      nodeId: cc.nodeId,
+      encapsulated: cc
+    });
+    ret.encapsulationFlags = cc.encapsulationFlags & ~import_core.EncapsulationFlags.Security;
+    return ret;
+  }
+};
+SecurityCC = SecurityCC_1 = __decorate([
+  (0, import_CommandClassDecorators.commandClass)(import_core.CommandClasses.Security),
+  (0, import_CommandClassDecorators.implementedVersion)(1)
+], SecurityCC);
+let SecurityCCNonceReport = SecurityCCNonceReport_1 = class SecurityCCNonceReport2 extends SecurityCC {
+  constructor(options) {
+    super(options);
+    if (options.nonce.length !== HALF_NONCE_SIZE) {
+      throw new import_core.ZWaveError(`Nonce must have length ${HALF_NONCE_SIZE}!`, import_core.ZWaveErrorCodes.Argument_Invalid);
+    }
+    this.nonce = options.nonce;
+  }
+  static from(raw, ctx) {
+    import_core.validatePayload.withReason("Invalid nonce length")(raw.payload.length === HALF_NONCE_SIZE);
+    return new SecurityCCNonceReport_1({
+      nodeId: ctx.sourceNodeId,
+      nonce: raw.payload
+    });
+  }
+  nonce;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.view(this.nonce);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: { nonce: (0, import_safe2.buffer2hex)(this.nonce) }
+    };
+  }
+};
+SecurityCCNonceReport = SecurityCCNonceReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.NonceReport)
+], SecurityCCNonceReport);
+let SecurityCCNonceGet = class SecurityCCNonceGet2 extends SecurityCC {
+};
+SecurityCCNonceGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.NonceGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SecurityCCNonceReport)
+], SecurityCCNonceGet);
+function getCCResponseForCommandEncapsulation(sent) {
+  if (sent.encapsulated.expectsCCResponse()) {
+    return SecurityCCCommandEncapsulation;
+  }
+}
+let SecurityCCCommandEncapsulation = SecurityCCCommandEncapsulation_1 = class SecurityCCCommandEncapsulation2 extends SecurityCC {
+  constructor(options) {
+    super(options);
+    if ("encapsulated" in options) {
+      this.encapsulated = options.encapsulated;
+      this.encapsulated.encapsulatingCC = this;
+    } else {
+      this.decryptedCCBytes = options.decryptedCCBytes;
+      this.sequenced = options.sequenced;
+      this.secondFrame = options.secondFrame;
+      this.sequenceCounter = options.sequenceCounter;
+    }
+    this.alternativeNetworkKey = options.alternativeNetworkKey;
+  }
+  static from(raw, ctx) {
+    assertSecurityRX(ctx);
+    (0, import_core.validatePayload)(raw.payload.length >= HALF_NONCE_SIZE + 1 + 1 + 1 + 8);
+    const iv = raw.payload.subarray(0, HALF_NONCE_SIZE);
+    const encryptedPayload = raw.payload.subarray(HALF_NONCE_SIZE, -9);
+    const nonceId = raw.payload.at(-9);
+    const authCode = raw.payload.subarray(-8);
+    const nonce = ctx.securityManager.getNonce(nonceId);
+    if (!nonce) {
+      import_core.validatePayload.fail(`Nonce ${(0, import_safe2.num2hex)(nonceId)} expired, cannot decode security encapsulated command.`);
+    }
+    ctx.securityManager.deleteNonce(nonceId);
+    const authData = getAuthenticationData(iv, nonce, import_Types.SecurityCommand.CommandEncapsulation, ctx.sourceNodeId, ctx.ownNodeId, encryptedPayload);
+    const expectedAuthCode = (0, import_core.computeMAC)(authData, ctx.securityManager.authKey);
+    import_core.validatePayload.withReason("Invalid auth code, won't accept security encapsulated command.")(authCode.equals(expectedAuthCode));
+    const frameControlAndDecryptedCC = (0, import_core.decryptAES128OFB)(encryptedPayload, ctx.securityManager.encryptionKey, import_safe.Bytes.concat([iv, nonce]));
+    const frameControl = frameControlAndDecryptedCC[0];
+    const sequenceCounter = frameControl & 15;
+    const sequenced = !!(frameControl & 16);
+    const secondFrame = !!(frameControl & 32);
+    const decryptedCCBytes = frameControlAndDecryptedCC.subarray(1);
+    const ret = new SecurityCCCommandEncapsulation_1({
+      nodeId: ctx.sourceNodeId,
+      sequenceCounter,
+      sequenced,
+      secondFrame,
+      decryptedCCBytes
+    });
+    ret.authData = authData;
+    ret.authCode = authCode;
+    ret.iv = iv;
+    return ret;
+  }
+  sequenced;
+  secondFrame;
+  sequenceCounter;
+  decryptedCCBytes;
+  encapsulated;
+  alternativeNetworkKey;
+  get nonceId() {
+    return this.nonce?.[0];
+  }
+  nonce;
+  // Only used testing/for debugging purposes
+  iv;
+  authData;
+  authCode;
+  ciphertext;
+  getPartialCCSessionId() {
+    if (this.sequenced) {
+      return {
+        // Treat Encapsulation and EncapsulationNonceGet as one
+        ccCommand: void 0,
+        sequence: this.sequenceCounter
+      };
+    } else {
+      return {
+        // Treat Encapsulation and EncapsulationNonceGet as one
+        ccCommand: void 0
+      };
+    }
+  }
+  expectMoreMessages() {
+    return !!this.sequenced && !this.secondFrame;
+  }
+  mergePartialCCs(partials, ctx) {
+    this.decryptedCCBytes = import_safe.Bytes.concat([...partials, this].map((cc) => cc.decryptedCCBytes));
+    (0, import_core.validatePayload)(this.decryptedCCBytes.length >= 2);
+    this.encapsulated = import_CommandClass.CommandClass.parse(this.decryptedCCBytes, ctx);
+    this.encapsulated.encapsulatingCC = this;
+  }
+  serialize(ctx) {
+    if (!this.nonce)
+      throwNoNonce();
+    if (this.nonce.length !== HALF_NONCE_SIZE) {
+      throwNoNonce("Invalid nonce size");
+    }
+    assertSecurityTX(ctx);
+    let authKey;
+    let encryptionKey;
+    if (this.alternativeNetworkKey) {
+      authKey = (0, import_core.generateAuthKey)(this.alternativeNetworkKey);
+      encryptionKey = (0, import_core.generateEncryptionKey)(this.alternativeNetworkKey);
+    } else {
+      authKey = ctx.securityManager.authKey;
+      encryptionKey = ctx.securityManager.encryptionKey;
+    }
+    const serializedCC = this.encapsulated.serialize(ctx);
+    const plaintext = import_safe.Bytes.concat([
+      import_safe.Bytes.from([0]),
+      // TODO: frame control
+      serializedCC
+    ]);
+    const senderNonce = (0, import_node_crypto.randomBytes)(HALF_NONCE_SIZE);
+    const iv = import_safe.Bytes.concat([senderNonce, this.nonce]);
+    const ciphertext = (0, import_core.encryptAES128OFB)(plaintext, encryptionKey, iv);
+    const authData = getAuthenticationData(senderNonce, this.nonce, this.ccCommand, ctx.ownNodeId, this.nodeId, ciphertext);
+    const authCode = (0, import_core.computeMAC)(authData, authKey);
+    this.iv = iv;
+    this.authData = authData;
+    this.authCode = authCode;
+    this.ciphertext = ciphertext;
+    this.payload = import_safe.Bytes.concat([
+      senderNonce,
+      ciphertext,
+      import_safe.Bytes.from([this.nonceId]),
+      authCode
+    ]);
+    return super.serialize(ctx);
+  }
+  computeEncapsulationOverhead() {
+    return super.computeEncapsulationOverhead() + 18;
+  }
+  toLogEntry(ctx) {
+    const message = {};
+    if (this.nonceId != void 0) {
+      message["nonce id"] = this.nonceId;
+    }
+    if (this.sequenced != void 0) {
+      message.sequenced = this.sequenced;
+      if (this.sequenced) {
+        if (this.secondFrame != void 0) {
+          message["second frame"] = this.secondFrame;
+        }
+        if (this.sequenceCounter != void 0) {
+          message["sequence counter"] = this.sequenceCounter;
+        }
+      }
+    }
+    if (process.env.NODE_ENV === "test" || process.env.NODE_ENV === "development") {
+      if (this.iv) {
+        message.IV = (0, import_safe2.buffer2hex)(this.iv);
+      }
+      if (this.ciphertext) {
+        message.ciphertext = (0, import_safe2.buffer2hex)(this.ciphertext);
+      } else if (this.decryptedCCBytes) {
+        message.plaintext = (0, import_safe2.buffer2hex)(this.decryptedCCBytes);
+      }
+      if (this.authData) {
+        message["auth data"] = (0, import_safe2.buffer2hex)(this.authData);
+      }
+      if (this.authCode) {
+        message["auth code"] = (0, import_safe2.buffer2hex)(this.authCode);
+      }
+    }
+    return {
+      ...super.toLogEntry(ctx),
+      message
+    };
+  }
+};
+SecurityCCCommandEncapsulation = SecurityCCCommandEncapsulation_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.CommandEncapsulation),
+  (0, import_CommandClassDecorators.expectedCCResponse)(getCCResponseForCommandEncapsulation, () => "checkEncapsulated")
+], SecurityCCCommandEncapsulation);
+let SecurityCCCommandEncapsulationNonceGet = class SecurityCCCommandEncapsulationNonceGet2 extends SecurityCCCommandEncapsulation {
+};
+SecurityCCCommandEncapsulationNonceGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.CommandEncapsulationNonceGet)
+], SecurityCCCommandEncapsulationNonceGet);
+let SecurityCCSchemeReport = SecurityCCSchemeReport_1 = class SecurityCCSchemeReport2 extends SecurityCC {
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    return new SecurityCCSchemeReport_1({
+      nodeId: ctx.sourceNodeId
+    });
+  }
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([0]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      // Hide the default payload line
+      message: void 0
+    };
+  }
+};
+SecurityCCSchemeReport = SecurityCCSchemeReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.SchemeReport)
+], SecurityCCSchemeReport);
+let SecurityCCSchemeGet = class SecurityCCSchemeGet2 extends SecurityCC {
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([0]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      // Hide the default payload line
+      message: void 0
+    };
+  }
+};
+SecurityCCSchemeGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.SchemeGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SecurityCCSchemeReport)
+], SecurityCCSchemeGet);
+let SecurityCCSchemeInherit = class SecurityCCSchemeInherit2 extends SecurityCC {
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.from([0]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      // Hide the default payload line
+      message: void 0
+    };
+  }
+};
+SecurityCCSchemeInherit = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.SchemeInherit),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SecurityCCSchemeReport)
+], SecurityCCSchemeInherit);
+let SecurityCCNetworkKeyVerify = class SecurityCCNetworkKeyVerify2 extends SecurityCC {
+};
+SecurityCCNetworkKeyVerify = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.NetworkKeyVerify)
+], SecurityCCNetworkKeyVerify);
+let SecurityCCNetworkKeySet = SecurityCCNetworkKeySet_1 = class SecurityCCNetworkKeySet2 extends SecurityCC {
+  constructor(options) {
+    super(options);
+    if (options.networkKey.length !== 16) {
+      throw new import_core.ZWaveError(`The network key must have length 16!`, import_core.ZWaveErrorCodes.Argument_Invalid);
+    }
+    this.networkKey = options.networkKey;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 16);
+    const networkKey = raw.payload.subarray(0, 16);
+    return new SecurityCCNetworkKeySet_1({
+      nodeId: ctx.sourceNodeId,
+      networkKey
+    });
+  }
+  networkKey;
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.view(this.networkKey);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    const { message, ...log } = super.toLogEntry(ctx);
+    return log;
+  }
+};
+SecurityCCNetworkKeySet = SecurityCCNetworkKeySet_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.NetworkKeySet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SecurityCCNetworkKeyVerify)
+], SecurityCCNetworkKeySet);
+let SecurityCCCommandsSupportedReport = SecurityCCCommandsSupportedReport_1 = class SecurityCCCommandsSupportedReport2 extends SecurityCC {
+  constructor(options) {
+    super(options);
+    this.supportedCCs = options.supportedCCs;
+    this.controlledCCs = options.controlledCCs;
+    this.reportsToFollow = options.reportsToFollow ?? 0;
+  }
+  static from(raw, ctx) {
+    (0, import_core.validatePayload)(raw.payload.length >= 1);
+    const reportsToFollow = raw.payload[0];
+    const list = (0, import_core.parseCCList)(raw.payload.subarray(1));
+    const supportedCCs = list.supportedCCs;
+    const controlledCCs = list.controlledCCs;
+    return new SecurityCCCommandsSupportedReport_1({
+      nodeId: ctx.sourceNodeId,
+      reportsToFollow,
+      supportedCCs,
+      controlledCCs
+    });
+  }
+  reportsToFollow;
+  supportedCCs;
+  controlledCCs;
+  getPartialCCSessionId() {
+    return {};
+  }
+  expectMoreMessages() {
+    return this.reportsToFollow > 0;
+  }
+  mergePartialCCs(partials) {
+    this.supportedCCs = [...partials, this].map((report) => report.supportedCCs).reduce((prev, cur) => prev.concat(...cur), []);
+    this.controlledCCs = [...partials, this].map((report) => report.controlledCCs).reduce((prev, cur) => prev.concat(...cur), []);
+  }
+  serialize(ctx) {
+    this.payload = import_safe.Bytes.concat([
+      import_safe.Bytes.from([this.reportsToFollow]),
+      (0, import_core.encodeCCList)(this.supportedCCs, this.controlledCCs)
+    ]);
+    return super.serialize(ctx);
+  }
+  toLogEntry(ctx) {
+    return {
+      ...super.toLogEntry(ctx),
+      message: {
+        reportsToFollow: this.reportsToFollow,
+        supportedCCs: this.supportedCCs.map((cc) => (0, import_core.getCCName)(cc)).map((cc) => `
+\xB7 ${cc}`).join(""),
+        controlledCCs: this.controlledCCs.map((cc) => (0, import_core.getCCName)(cc)).map((cc) => `
+\xB7 ${cc}`).join("")
+      }
+    };
+  }
+};
+SecurityCCCommandsSupportedReport = SecurityCCCommandsSupportedReport_1 = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.CommandsSupportedReport)
+], SecurityCCCommandsSupportedReport);
+let SecurityCCCommandsSupportedGet = class SecurityCCCommandsSupportedGet2 extends SecurityCC {
+};
+SecurityCCCommandsSupportedGet = __decorate([
+  (0, import_CommandClassDecorators.CCCommand)(import_Types.SecurityCommand.CommandsSupportedGet),
+  (0, import_CommandClassDecorators.expectedCCResponse)(SecurityCCCommandsSupportedReport)
+], SecurityCCCommandsSupportedGet);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SecurityCC,
+  SecurityCCAPI,
+  SecurityCCCommandEncapsulation,
+  SecurityCCCommandEncapsulationNonceGet,
+  SecurityCCCommandsSupportedGet,
+  SecurityCCCommandsSupportedReport,
+  SecurityCCNetworkKeySet,
+  SecurityCCNetworkKeyVerify,
+  SecurityCCNonceGet,
+  SecurityCCNonceReport,
+  SecurityCCSchemeGet,
+  SecurityCCSchemeInherit,
+  SecurityCCSchemeReport
+});
+//# sourceMappingURL=SecurityCC.js.map