Function testEncapsulateKey

test/parallel/test-webcrypto-encap-decap-ml-kem.js:26–98

({ name, publicKeyPem, privateKeyPem, results })

}

async function testEncapsulateKey({ name, publicKeyPem, privateKeyPem, results }) {
  const [
    publicKey,
    noEncapsulatePublicKey,
    privateKey,
  ] = await Promise.all([
    crypto.createPublicKey(publicKeyPem)
      .toCryptoKey(name, false, ['encapsulateKey']),
    crypto.createPublicKey(publicKeyPem)
      .toCryptoKey(name, false, ['encapsulateBits']),
    crypto.createPrivateKey(privateKeyPem)
      .toCryptoKey(name, false, ['decapsulateKey']),
  ]);

  // Test successful encapsulation
  const encapsulated = await subtle.encapsulateKey(
    { name },
    publicKey,
    'HKDF',
    false,
    ['deriveBits']
  );

  assert.strictEqual(Object.getPrototypeOf(encapsulated), Object.prototype);
  assert(encapsulated.sharedKey instanceof CryptoKey);
  assert(encapsulated.ciphertext instanceof ArrayBuffer);
  assert.strictEqual(encapsulated.sharedKey.type, 'secret');
  assert.strictEqual(encapsulated.sharedKey.algorithm.name, 'HKDF');
  assert.strictEqual(encapsulated.sharedKey.extractable, false);
  assert.deepStrictEqual(encapsulated.sharedKey.usages, ['deriveBits']);

  // Verify ciphertext length matches expected for algorithm
  assert.strictEqual(encapsulated.ciphertext.byteLength, results.ciphertext.byteLength);

  // Test with different shared key algorithm
  const encapsulated2 = await subtle.encapsulateKey(
    { name },
    publicKey,
    { name: 'HMAC', hash: 'SHA-256' },
    false,
    ['sign', 'verify']
  );

  assert.strictEqual(Object.getPrototypeOf(encapsulated2), Object.prototype);
  assert(encapsulated2.sharedKey instanceof CryptoKey);
  assert.strictEqual(encapsulated2.sharedKey.algorithm.name, 'HMAC');
  assert.strictEqual(encapsulated2.sharedKey.extractable, false);

  const encapsulated3 = await subtle.encapsulateKey(
    { name },
    publicKey,
    { name: 'HMAC', hash: 'SHA-256', length: 255 },
    false,
    ['sign', 'verify']
  );

  assert.strictEqual(encapsulated3.sharedKey.algorithm.name, 'HMAC');
  assert.strictEqual(encapsulated3.sharedKey.algorithm.length, 255);