@zwave-js/cc 14.1.0 → 14.2.0

package/build/cjs/cc/Security2CC.js

@@ -832,6 +832,7 @@ let Security2CCMessageEncapsulation = (() => {
         throw new import_core.ZWaveError("Multicast Security S2 encapsulation requires the MGRP extension", import_core.ZWaveErrorCodes.Security2CC_MissingExtension);
       }
     }
+    /** @deprecated Use {@link fromAsync} instead */
     static from(raw, ctx) {
       const securityManager = assertSecurityRX(ctx);
       (0, import_core.validatePayload)(raw.payload.length >= 2);
@@ -997,6 +998,171 @@ let Security2CCMessageEncapsulation = (() => {
       ret.plaintext = decryptedCCBytes;
       return ret;
     }
+    static async fromAsync(raw, ctx) {
+      const securityManager = assertSecurityRX(ctx);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
+      const sequenceNumber = raw.payload[0];
+      import_core.validatePayload.withReason("No security class granted")(ctx.getHighestSecurityClass(ctx.sourceNodeId) !== import_core.SecurityClass.None);
+      const hasExtensions = !!(raw.payload[1] & 1);
+      const hasEncryptedExtensions = !!(raw.payload[1] & 2);
+      let offset = 2;
+      const extensions = [];
+      let mustDiscardCommand = false;
+      const parseExtensions = (buffer, wasEncrypted) => {
+        while (true) {
+          if (buffer.length < offset + 2) {
+            mustDiscardCommand = true;
+            return;
+          }
+          const { actual: actualLength, expected: expectedLength } = import_Extension.Security2Extension.getExtensionLength(buffer.subarray(offset));
+          const extensionLength = expectedLength ?? actualLength;
+          if (extensionLength < 2) {
+            mustDiscardCommand = true;
+            return;
+          } else if (extensionLength > buffer.length - offset - (wasEncrypted ? 0 : import_core.SECURITY_S2_AUTH_TAG_LENGTH)) {
+            mustDiscardCommand = true;
+            return;
+          }
+          const extensionData = buffer.subarray(offset, offset + extensionLength);
+          offset += extensionLength;
+          const ext = import_Extension.Security2Extension.parse(extensionData);
+          switch ((0, import_Extension.validateS2Extension)(ext, wasEncrypted)) {
+            case import_Extension.ValidateS2ExtensionResult.OK:
+              if (expectedLength != void 0 && actualLength !== expectedLength) {
+              } else {
+                extensions.push(ext);
+              }
+              break;
+            case import_Extension.ValidateS2ExtensionResult.DiscardExtension:
+              break;
+            case import_Extension.ValidateS2ExtensionResult.DiscardCommand:
+              mustDiscardCommand = true;
+              break;
+          }
+          if (!ext.moreToFollow)
+            break;
+        }
+      };
+      if (hasExtensions)
+        parseExtensions(raw.payload, false);
+      const mcctx = (() => {
+        const multicastGroupId = getMulticastGroupId(extensions);
+        if (ctx.frameType === "multicast" || ctx.frameType === "broadcast") {
+          if (multicastGroupId == void 0) {
+            import_core.validatePayload.fail("Multicast frames without MGRP extension");
+          }
+          return {
+            isMulticast: true,
+            groupId: multicastGroupId
+          };
+        } else {
+          return { isMulticast: false, groupId: multicastGroupId };
+        }
+      })();
+      if (mustDiscardCommand) {
+        if (mcctx.isMulticast) {
+          securityManager.nextPeerMPAN(ctx.sourceNodeId, mcctx.groupId);
+        } else {
+          securityManager.nextNonce(ctx.sourceNodeId);
+        }
+        import_core.validatePayload.fail("Invalid S2 extension");
+      }
+      let prevSequenceNumber;
+      let mpanState;
+      if (mcctx.isMulticast) {
+        mpanState = securityManager.getPeerMPAN(ctx.sourceNodeId, mcctx.groupId);
+      } else {
+        prevSequenceNumber = validateSequenceNumber(securityManager, ctx.sourceNodeId, sequenceNumber);
+        if (mcctx.groupId == void 0) {
+          securityManager.resetOutOfSyncMPANs(ctx.sourceNodeId);
+        }
+      }
+      const unencryptedPayload = raw.payload.subarray(0, offset);
+      const ciphertext = raw.payload.subarray(offset, -import_core.SECURITY_S2_AUTH_TAG_LENGTH);
+      const authTag = raw.payload.subarray(-import_core.SECURITY_S2_AUTH_TAG_LENGTH);
+      const messageLength = 2 + raw.payload.length;
+      const authData = getAuthenticationData(ctx.sourceNodeId, getDestinationIDRX(ctx, extensions), ctx.homeId, messageLength, unencryptedPayload);
+      let decrypt;
+      if (mcctx.isMulticast) {
+        if (mpanState?.type !== import_core.MPANState.MPAN) {
+          securityManager.storePeerMPAN(ctx.sourceNodeId, mcctx.groupId, { type: import_core.MPANState.OutOfSync });
+          failNoMPAN();
+        }
+        decrypt = () => decryptMulticast(ctx.sourceNodeId, securityManager, mcctx.groupId, ciphertext, authData, authTag);
+      } else {
+        const spanState = securityManager.getSPANState(ctx.sourceNodeId);
+        if (spanState.type === import_core.SPANState.None) {
+          failNoSPAN();
+        } else if (spanState.type === import_core.SPANState.RemoteEI) {
+          failNoSPAN();
+        }
+        decrypt = () => decryptSinglecast(ctx, securityManager, ctx.sourceNodeId, sequenceNumber, prevSequenceNumber, ciphertext, authData, authTag, spanState, extensions);
+      }
+      let plaintext;
+      let authOK = false;
+      let key;
+      let iv;
+      let decryptionSecurityClass;
+      const decryptAttempts = mcctx.isMulticast ? MAX_DECRYPT_ATTEMPTS_MULTICAST : mcctx.groupId != void 0 ? MAX_DECRYPT_ATTEMPTS_SC_FOLLOWUP : MAX_DECRYPT_ATTEMPTS_SINGLECAST;
+      for (let i = 0; i < decryptAttempts; i++) {
+        ({
+          plaintext,
+          authOK,
+          key,
+          iv,
+          securityClass: decryptionSecurityClass
+        } = decrypt());
+        if (!!authOK && !!plaintext)
+          break;
+        if (!!getSenderEI(extensions))
+          break;
+      }
+      if (!authOK || !plaintext) {
+        if (mcctx.isMulticast) {
+          securityManager.storePeerMPAN(ctx.sourceNodeId, mcctx.groupId, { type: import_core.MPANState.OutOfSync });
+          import_core.validatePayload.fail(import_core.ZWaveErrorCodes.Security2CC_CannotDecodeMulticast);
+        } else {
+          import_core.validatePayload.fail(import_core.ZWaveErrorCodes.Security2CC_CannotDecode);
+        }
+      } else if (!mcctx.isMulticast && mcctx.groupId != void 0) {
+        securityManager.tryIncrementPeerMPAN(ctx.sourceNodeId, mcctx.groupId);
+      }
+      const securityClass = decryptionSecurityClass;
+      offset = 0;
+      if (hasEncryptedExtensions)
+        parseExtensions(plaintext, true);
+      if (mustDiscardCommand) {
+        import_core.validatePayload.fail("Invalid extension");
+      }
+      if (!mcctx.isMulticast) {
+        const mpanExtension = extensions.find((e) => e instanceof import_Extension.MPANExtension);
+        if (mpanExtension) {
+          securityManager.storePeerMPAN(ctx.sourceNodeId, mpanExtension.groupId, {
+            type: import_core.MPANState.MPAN,
+            currentMPAN: mpanExtension.innerMPANState
+          });
+        }
+      }
+      const decryptedCCBytes = plaintext.subarray(offset);
+      let encapsulated;
+      if (decryptedCCBytes.length > 0) {
+        (0, import_core.validatePayload)(decryptedCCBytes.length >= 2);
+        encapsulated = await import_CommandClass.CommandClass.parseAsync(decryptedCCBytes, ctx);
+      }
+      const ret = new Security2CCMessageEncapsulation2({
+        nodeId: ctx.sourceNodeId,
+        sequenceNumber,
+        securityClass,
+        extensions,
+        encapsulated
+      });
+      ret.key = key;
+      ret.iv = iv;
+      ret.authData = authData;
+      ret.authTag = authTag;
+      ret.plaintext = decryptedCCBytes;
+      return ret;
+    }
     securityClass;
     // Only used for testing/debugging purposes
     key;
@@ -1062,6 +1228,7 @@ let Security2CCMessageEncapsulation = (() => {
         }
       }
     }
+    /** @deprecated Use {@link serializeAsync} instead */
     serialize(ctx) {
       const securityManager = assertSecurityTX(ctx, this.nodeId);
       this.ensureSequenceNumber(securityManager);
@@ -1110,6 +1277,54 @@ let Security2CCMessageEncapsulation = (() => {
       ]);
       return super.serialize(ctx);
     }
+    async serializeAsync(ctx) {
+      const securityManager = assertSecurityTX(ctx, this.nodeId);
+      this.ensureSequenceNumber(securityManager);
+      this.maybeAddSPANExtension(ctx, securityManager);
+      const unencryptedExtensions = this.extensions.filter((e) => !e.isEncrypted());
+      const encryptedExtensions = this.extensions.filter((e) => e.isEncrypted());
+      const unencryptedPayload = import_safe2.Bytes.concat([
+        import_safe2.Bytes.from([
+          this.sequenceNumber,
+          (encryptedExtensions.length > 0 ? 2 : 0) | (unencryptedExtensions.length > 0 ? 1 : 0)
+        ]),
+        ...unencryptedExtensions.map((e, index) => e.serialize(index < unencryptedExtensions.length - 1))
+      ]);
+      const serializedCC = await this.encapsulated?.serializeAsync(ctx) ?? new import_safe2.Bytes();
+      const plaintextPayload = import_safe2.Bytes.concat([
+        ...encryptedExtensions.map((e, index) => e.serialize(index < encryptedExtensions.length - 1)),
+        serializedCC
+      ]);
+      const destinationTag = getDestinationIDTX.call(this);
+      const messageLength = this.computeEncapsulationOverhead() + serializedCC.length;
+      const authData = getAuthenticationData(ctx.ownNodeId, destinationTag, ctx.homeId, messageLength, unencryptedPayload);
+      let key;
+      let iv;
+      if (this.isSinglecast()) {
+        iv = securityManager.nextNonce(this.nodeId, true);
+        const { keyCCM } = (
+          // Prefer the overridden security class if it was given
+          this.securityClass != void 0 ? securityManager.getKeysForSecurityClass(this.securityClass) : securityManager.getKeysForNode(this.nodeId)
+        );
+        key = keyCCM;
+      } else {
+        const keyAndIV = securityManager.getMulticastKeyAndIV(destinationTag);
+        key = keyAndIV.key;
+        iv = keyAndIV.iv;
+      }
+      const { ciphertext: ciphertextPayload, authTag } = (0, import_core.encryptAES128CCM)(key, iv, plaintextPayload, authData, import_core.SECURITY_S2_AUTH_TAG_LENGTH);
+      this.key = key;
+      this.iv = iv;
+      this.authData = authData;
+      this.authTag = authTag;
+      this.ciphertext = ciphertextPayload;
+      this.payload = import_safe2.Bytes.concat([
+        unencryptedPayload,
+        ciphertextPayload,
+        authTag
+      ]);
+      return super.serializeAsync(ctx);
+    }
     computeEncapsulationOverhead() {
       const extensionBytes = this.extensions.map((e) => e.computeLength()).reduce((a, b) => a + b, 0);
       return super.computeEncapsulationOverhead() + 2 + import_core.SECURITY_S2_AUTH_TAG_LENGTH + extensionBytes;