Function checkHmacKey

test/parallel/test-webcrypto-cryptokey-clone-transfer.js:71–121

(original)

}

async function checkHmacKey(original) {
  const data = Buffer.from('some data to sign');

  const cloned = structuredClone(original);
  assertSameCryptoKey(original, cloned);

  const viaPort = await roundTripViaMessageChannel(original);
  assertSameCryptoKey(original, viaPort);

  // Round-trip: clone a clone.
  const clonedAgain = structuredClone(viaPort);
  assertSameCryptoKey(original, clonedAgain);
  const viaPortAgain = await roundTripViaMessageChannel(cloned);
  assertSameCryptoKey(original, viaPortAgain);

  // Signatures produced by every copy must match.
  const sigs = await Promise.all(
    [original, cloned, viaPort, clonedAgain, viaPortAgain].map(
      (k) => subtle.sign('HMAC', k, data),
    ),
  );
  for (let i = 1; i < sigs.length; i++) {
    assert.deepStrictEqual(Buffer.from(sigs[0]), Buffer.from(sigs[i]));
  }

  // Each copy must verify a signature produced by any other copy.
  for (const verifier of [original, cloned, viaPort, clonedAgain]) {
    for (const sig of sigs) {
      assert.strictEqual(
        await subtle.verify('HMAC', verifier, sig, data), true);
    }
  }

  // Exported JWK must match byte-for-byte when extractable.
  if (original.extractable) {
    const jwks = await Promise.all(
      [original, cloned, viaPort, clonedAgain].map(
        (k) => subtle.exportKey('jwk', k),
      ),
    );
    for (let i = 1; i < jwks.length; i++) {
      assert.deepStrictEqual(jwks[0], jwks[i]);
    }
  } else {
    // Non-extractable keys must refuse export on every copy.
    for (const k of [cloned, viaPort, clonedAgain]) {
      await assert.rejects(subtle.exportKey('jwk', k),
                           { name: 'InvalidAccessError' });
    }
  }
}

async function checkAsymmetricKeyPair({ publicKey, privateKey }) {
  const data = Buffer.from('payload');