WebCryptoAPI/supports.tentative.https.any.js

// META: title=WebCrypto API: supports method tests
// META: script=util/helpers.js
// META: script=util/supports.js

'use strict';

const standardAlgorithms = {
  // Asymmetric algorithms
  'RSASSA-PKCS1-v1_5': {
    operations: ['generateKey', 'importKey', 'sign', 'verify', 'getPublicKey'],
    keyGenParams: {
      name: 'RSASSA-PKCS1-v1_5',
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: 'SHA-256',
    },
    importParams: { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
    signParams: { name: 'RSASSA-PKCS1-v1_5' },
  },
  'RSA-PSS': {
    operations: ['generateKey', 'importKey', 'sign', 'verify', 'getPublicKey'],
    keyGenParams: {
      name: 'RSA-PSS',
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: 'SHA-256',
    },
    importParams: { name: 'RSA-PSS', hash: 'SHA-256' },
    signParams: { name: 'RSA-PSS', saltLength: 32 },
  },
  'RSA-OAEP': {
    operations: ['generateKey', 'importKey', 'encrypt', 'decrypt', 'getPublicKey'],
    keyGenParams: {
      name: 'RSA-OAEP',
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: 'SHA-256',
    },
    importParams: { name: 'RSA-OAEP', hash: 'SHA-256' },
    encryptParams: { name: 'RSA-OAEP' },
  },
  ECDSA: {
    operations: ['generateKey', 'importKey', 'sign', 'verify', 'getPublicKey'],
    keyGenParams: { name: 'ECDSA', namedCurve: 'P-256' },
    importParams: { name: 'ECDSA', namedCurve: 'P-256' },
    signParams: { name: 'ECDSA', hash: 'SHA-256' },
  },
  ECDH: {
    operations: ['generateKey', 'importKey', 'deriveBits', 'getPublicKey'],
    keyGenParams: { name: 'ECDH', namedCurve: 'P-256' },
    importParams: { name: 'ECDH', namedCurve: 'P-256' },
    deriveBitsParamsFactory: async () => {
      const {publicKey} = await crypto.subtle.generateKey(
        {name: 'ECDH', namedCurve: 'P-256'}, false, ['deriveBits']);
      return {name: 'ECDH', public: publicKey};
    },
  },
  Ed25519: {
    operations: ['generateKey', 'importKey', 'sign', 'verify', 'getPublicKey'],
    keyGenParams: null,
    signParams: { name: 'Ed25519' },
  },
  X25519: {
    operations: ['generateKey', 'importKey', 'deriveBits', 'getPublicKey'],
    keyGenParams: null,
    deriveBitsParamsFactory: async () => {
      const {publicKey} = await crypto.subtle.generateKey(
        'X25519', false, ['deriveBits']);
      return {name: 'X25519', public: publicKey};
    },
  },

  // Symmetric algorithms
  'AES-CBC': {
    operations: ['generateKey', 'importKey', 'encrypt', 'decrypt'],
    keyGenParams: { name: 'AES-CBC', length: 256 },
    encryptParams: { name: 'AES-CBC', iv: new Uint8Array(16) },
  },
  'AES-CTR': {
    operations: ['generateKey', 'importKey', 'encrypt', 'decrypt'],
    keyGenParams: { name: 'AES-CTR', length: 256 },
    encryptParams: {
      name: 'AES-CTR',
      counter: new Uint8Array(16),
      length: 128,
    },
  },
  'AES-GCM': {
    operations: ['generateKey', 'importKey', 'encrypt', 'decrypt'],
    keyGenParams: { name: 'AES-GCM', length: 256 },
    encryptParams: { name: 'AES-GCM', iv: new Uint8Array(12) },
  },
  'AES-KW': {
    operations: ['generateKey', 'importKey'], // wrapKey/unwrapKey not in requested operations
    keyGenParams: { name: 'AES-KW', length: 256 },
  },
  HMAC: {
    operations: ['generateKey', 'importKey', 'sign', 'verify'],
    keyGenParams: { name: 'HMAC', hash: 'SHA-256' },
    importParams: { name: 'HMAC', hash: 'SHA-256' },
    signParams: { name: 'HMAC' },
  },

  // Hash algorithms
  'SHA-1': {
    operations: ['digest'],
    keyGenParams: null,
  },
  'SHA-256': {
    operations: ['digest'],
    keyGenParams: null,
  },
  'SHA-384': {
    operations: ['digest'],
    keyGenParams: null,
  },
  'SHA-512': {
    operations: ['digest'],
    keyGenParams: null,
  },

  // Key derivation algorithms
  HKDF: {
    operations: ['importKey', 'deriveBits'],
    keyGenParams: null,
    deriveBitsParams: {
      name: 'HKDF',
      hash: 'SHA-256',
      salt: new Uint8Array(16),
      info: new Uint8Array(0),
    },
  },
  PBKDF2: {
    operations: ['importKey', 'deriveBits'],
    keyGenParams: null,
    deriveBitsParams: {
      name: 'PBKDF2',
      hash: 'SHA-256',
      salt: new Uint8Array(16),
      iterations: 100000,
    },
  },
};

const operations = [
  'generateKey',
  'importKey',
  'sign',
  'verify',
  'encrypt',
  'decrypt',
  'deriveBits',
  'digest',
  'getPublicKey',
];

// Test that supports method exists and is a static method
testSupportsMethod();

// Test invalid operation names
test(() => {
  assert_false(
    SubtleCrypto.supports('invalidOperation', 'AES-GCM'),
    'Invalid operation should return false'
  );
  assert_false(
    SubtleCrypto.supports('', 'AES-GCM'),
    'Empty operation should return false'
  );
  assert_false(
    SubtleCrypto.supports('GENERATEKEY', 'AES-GCM'),
    'Case-sensitive operation check'
  );
}, 'supports returns false for invalid operations');

// Test invalid algorithm identifiers
test(() => {
  assert_false(
    SubtleCrypto.supports('generateKey', 'InvalidAlgorithm'),
    'Invalid algorithm should return false'
  );
  assert_false(
    SubtleCrypto.supports('generateKey', ''),
    'Empty algorithm should return false'
  );
}, 'supports returns false for invalid algorithms');

// Test standard WebCrypto algorithms for requested operations
runSupportsTests(standardAlgorithms, operations);

// Test algorithm objects (not just strings)
test(() => {
  assert_true(
    SubtleCrypto.supports('generateKey', { name: 'AES-GCM', length: 256 }),
    'Algorithm object should be supported'
  );
  assert_true(
    SubtleCrypto.supports('generateKey', { name: 'HMAC', hash: 'SHA-256' }),
    'Algorithm object with parameters should be supported'
  );
}, 'supports works with algorithm objects');

// Test with algorithm objects that have invalid parameters
test(() => {
  assert_false(
    SubtleCrypto.supports('generateKey', { name: 'AES-GCM', length: 100 }),
    'Invalid key length should return false'
  );
  assert_false(
    SubtleCrypto.supports('generateKey', {
      name: 'HMAC',
      hash: 'INVALID-HASH',
    }),
    'Invalid hash parameter should return false'
  );
  assert_false(
      SubtleCrypto.supports(
          'encrypt', {name: 'AES-CBC', iv: new Uint8Array(10)}),
      'Invalid IV for AES-CBC should return false');
  assert_false(
      SubtleCrypto.supports('encrypt', {
        name: 'AES-CTR',
        counter: new Uint8Array(10),
        length: 128,
      }),
      'Invalid IV for AES-CTR should return false');
  assert_false(
      SubtleCrypto.supports('encrypt', {
        name: 'AES-CTR',
        counter: new Uint8Array(16),
        length: 0,
      }),
      'Invalid length=0 for AES-CTR should return false');
  assert_false(
      SubtleCrypto.supports('encrypt', {
        name: 'AES-CTR',
        counter: new Uint8Array(16),
        length: 129,
      }),
      'Invalid length=129 for AES-CTR should return false');
  assert_false(
      SubtleCrypto.supports('encrypt', {
        name: 'AES-GCM',
        iv: new Uint8Array(16),
        tagLength: 100,
      }),
      'Invalid tag length for AES-GCM should return false');
  assert_false(
      SubtleCrypto.supports('decrypt', {
        name: 'AES-GCM',
        iv: new Uint8Array(16),
        tagLength: 100,
      }),
      'Invalid tag length for AES-GCM should return false');
  assert_false(
      SubtleCrypto.supports('generateKey', {name: 'ECDH', namedCurve: 'P-51'}),
      'Invalid curve for ECDH should return false');
  assert_false(
      SubtleCrypto.supports(
          'deriveBits', {
            name: 'HKDF',
            hash: 'SHA-25',
            salt: new Uint8Array(16),
            info: new Uint8Array(0),
          },
          8),
      'Invalid hash for HKDF should return false');
  assert_false(
      SubtleCrypto.supports(
          'deriveBits', {
            name: 'HKDF',
            hash: 'SHA-256',
            salt: new Uint8Array(16),
            info: new Uint8Array(0),
          },
          11),
      'Invalid length for HKDF should return false');
  assert_false(
      SubtleCrypto.supports(
          'deriveBits', {
            name: 'HKDF',
            hash: 'SHA-256',
            salt: new Uint8Array(16),
            info: new Uint8Array(0),
          }),
      'null length for HKDF should return false');
  assert_false(
      SubtleCrypto.supports('generateKey', {
        name: 'HMAC',
        hash: 'SHA-25',
      }),
      'Invalid hash for HMAC should return false');
  assert_false(
      SubtleCrypto.supports('generateKey', {
        name: 'HMAC',
        hash: 'SHA-256',
        length: 0,
      }),
      'Invalid length for HMAC should return false');
  assert_false(
      SubtleCrypto.supports(
          'deriveBits', {
            name: 'PBKDF2',
            hash: 'SHA-25',
            salt: new Uint8Array(16),
            iterations: 100000,
          },
          8),
      'Invalid hash for PBKDF2 should return false');
  assert_false(
      SubtleCrypto.supports(
          'deriveBits', {
            name: 'PBKDF2',
            hash: 'SHA-256',
            salt: new Uint8Array(16),
            iterations: 100000,
          },
          11),
      'Invalid length for PBKDF2 should return false');
  assert_false(
      SubtleCrypto.supports(
          'deriveBits', {
            name: 'PBKDF2',
            hash: 'SHA-256',
            salt: new Uint8Array(16),
            iterations: 100000,
          }),
      'null length for PBKDF2 should return false');
  assert_false(
      SubtleCrypto.supports('generateKey', {
        name: 'RSASSA-PKCS1-v1_5',
        modulusLength: 2048,
        publicExponent: new Uint8Array([1, 0, 1]),
        hash: 'SHA-56',
      }),
      'Invalid hash for RSA PKCS1 should return false');
  assert_false(
      SubtleCrypto.supports('generateKey', {
        name: 'RSA-PSS',
        modulusLength: 2048,
        publicExponent: new Uint8Array([1, 0, 1]),
        hash: 'SHA-56',
      }),
      'Invalid hash for RSA PSS should return false');
  assert_false(
      SubtleCrypto.supports('generateKey', {
        name: 'RSA-OAEP',
        modulusLength: 2048,
        publicExponent: new Uint8Array([1, 0, 1]),
        hash: 'SHA-26',
      }),
      'Invalid hash for RSA OAEP should return false');

}, 'supports returns false for algorithm objects with invalid parameters');

[
  ['SHA-1', 160],
  ['SHA-256', 256],
  ['SHA-384', 384],
  ['SHA-512', 512],
].forEach(([hash, hashLength]) => {
  test(() => {
    const algorithm = {
      name: 'HKDF',
      hash,
      salt: new Uint8Array(),
      info: new Uint8Array(),
    };
    const maximumLength = 255 * hashLength;

    assert_true(
      SubtleCrypto.supports('deriveBits', algorithm, maximumLength),
      `HKDF with ${hash} supports its maximum output length`
    );
    assert_false(
      SubtleCrypto.supports('deriveBits', algorithm, maximumLength + 8),
      `HKDF with ${hash} rejects output longer than its maximum`
    );
  }, `supports validates HKDF ${hash} output length`);
});

test(() => {
  assert_false(
    SubtleCrypto.supports(
      'deriveKey',
      {
        name: 'HKDF',
        hash: 'SHA-256',
        salt: new Uint8Array(),
        info: new Uint8Array(),
      },
      {name: 'HMAC', hash: 'SHA-256', length: 65288}
    ),
    'HKDF rejects a derived key longer than 255 hash blocks'
  );
}, 'supports validates HKDF output length for deriveKey');

test(() => {
  assert_false(
    SubtleCrypto.supports('importKey', {
      name: 'HMAC',
      hash: 'SHA-256',
      length: 0,
    }),
    'HMAC rejects an explicitly zero-length imported key'
  );
}, 'supports validates HMAC import length');

const invalidRsaKeyGenParameters = [
  {
    description: 'a modulus shorter than 4 bits',
    modulusLength: 3,
    publicExponent: Uint8Array.of(3),
  },
  {
    description: 'a public exponent less than 3',
    modulusLength: 2048,
    publicExponent: Uint8Array.of(1),
  },
  {
    description: 'an even public exponent',
    modulusLength: 2048,
    publicExponent: Uint8Array.of(4),
  },
  {
    description: 'a public exponent equal to 2^modulusLength - 1',
    modulusLength: 2048,
    publicExponent: new Uint8Array(256).fill(0xff),
  },
];

[
  'RSASSA-PKCS1-v1_5',
  'RSA-PSS',
  'RSA-OAEP',
].forEach(name => {
  invalidRsaKeyGenParameters.forEach(({description, ...parameters}) => {
    test(() => {
      assert_false(
        SubtleCrypto.supports('generateKey', {
          name,
          ...parameters,
          hash: 'SHA-256',
        }),
        `${name} rejects ${description}`
      );
    }, `supports rejects ${name} generateKey with ${description}`);
  });
});

['ECDSA', 'ECDH'].forEach(name => {
  test(() => {
    assert_false(
      SubtleCrypto.supports('importKey', {
        name,
        namedCurve: 'not-a-curve',
      }),
      `${name} rejects an unknown named curve`
    );
  }, `supports validates ${name} import namedCurve`);
});

[
  ['P-256', 256],
  ['P-384', 384],
  ['P-521', 528],
].forEach(([namedCurve, maximumLength]) => {
  promise_test(async () => {
    const {publicKey} = await crypto.subtle.generateKey(
      {name: 'ECDH', namedCurve}, false, ['deriveBits']);
    const algorithm = {name: 'ECDH', public: publicKey};

    assert_true(
      SubtleCrypto.supports('deriveBits', algorithm, maximumLength),
      `ECDH ${namedCurve} supports its maximum output length`
    );
    assert_false(
      SubtleCrypto.supports('deriveBits', algorithm, maximumLength + 1),
      `ECDH ${namedCurve} rejects output longer than its maximum`
    );
  }, `supports validates ECDH ${namedCurve} deriveBits length`);
});

promise_test(async () => {
  const {publicKey} = await crypto.subtle.generateKey(
    'X25519', false, ['deriveBits']);
  const algorithm = {name: 'X25519', public: publicKey};

  assert_true(
    SubtleCrypto.supports('deriveBits', algorithm, 256),
    'X25519 supports its maximum output length'
  );
  assert_false(
    SubtleCrypto.supports('deriveBits', algorithm, 257),
    'X25519 rejects output longer than its maximum'
  );
}, 'supports validates X25519 deriveBits length');

promise_test(async () => {
  const [ecdhKeyPair, x25519KeyPair] = await Promise.all([
    crypto.subtle.generateKey(
      {name: 'ECDH', namedCurve: 'P-256'}, false, ['deriveBits']),
    crypto.subtle.generateKey('X25519', false, ['deriveBits']),
  ]);

  assert_false(
    SubtleCrypto.supports(
      'deriveBits', {name: 'ECDH', public: ecdhKeyPair.privateKey}, 256),
    'ECDH rejects a private public property'
  );
  assert_false(
    SubtleCrypto.supports(
      'deriveBits', {name: 'ECDH', public: x25519KeyPair.publicKey}, 256),
    'ECDH rejects a public property for another algorithm'
  );
}, 'supports validates the ECDH public key');

promise_test(async () => {
  const [x25519KeyPair, ecdhKeyPair] = await Promise.all([
    crypto.subtle.generateKey('X25519', false, ['deriveBits']),
    crypto.subtle.generateKey(
      {name: 'ECDH', namedCurve: 'P-256'}, false, ['deriveBits']),
  ]);

  assert_false(
    SubtleCrypto.supports(
      'deriveBits', {name: 'X25519', public: x25519KeyPair.privateKey}, 256),
    'X25519 rejects a private public property'
  );
  assert_false(
    SubtleCrypto.supports(
      'deriveBits', {name: 'X25519', public: ecdhKeyPair.publicKey}, 256),
    'X25519 rejects a public property for another algorithm'
  );
}, 'supports validates the X25519 public key');

promise_test(async () => {
  const [p256KeyPair, p521KeyPair] = await Promise.all([
    crypto.subtle.generateKey(
      {name: 'ECDH', namedCurve: 'P-256'}, false, ['deriveBits']),
    crypto.subtle.generateKey(
      {name: 'ECDH', namedCurve: 'P-521'}, false, ['deriveBits']),
  ]);
  const derivedKeyAlgorithm = {name: 'HMAC', hash: 'SHA-256'};

  assert_false(
    SubtleCrypto.supports(
      'deriveKey',
      {name: 'ECDH', public: p256KeyPair.publicKey},
      derivedKeyAlgorithm
    ),
    'ECDH P-256 cannot derive a 512-bit HMAC key'
  );
  assert_true(
    SubtleCrypto.supports(
      'deriveKey',
      {name: 'ECDH', public: p521KeyPair.publicKey},
      derivedKeyAlgorithm
    ),
    'ECDH P-521 can derive a 512-bit HMAC key'
  );
}, 'supports derives the ECDH output limit from the public curve');

// Test some specific combinations that should work
test(() => {
  // RSA algorithms
  assert_true(
    SubtleCrypto.supports('generateKey', {
      name: 'RSASSA-PKCS1-v1_5',
      modulusLength: 2048,
      publicExponent: new Uint8Array([1, 0, 1]),
      hash: 'SHA-256',
    }),
    'RSASSA-PKCS1-v1_5 generateKey'
  );
  assert_true(
    SubtleCrypto.supports('sign', { name: 'RSASSA-PKCS1-v1_5' }),
    'RSASSA-PKCS1-v1_5 sign'
  );
  assert_true(
    SubtleCrypto.supports('verify', { name: 'RSASSA-PKCS1-v1_5' }),
    'RSASSA-PKCS1-v1_5 verify'
  );

  // ECDSA
  assert_true(
    SubtleCrypto.supports('generateKey', {
      name: 'ECDSA',
      namedCurve: 'P-256',
    }),
    'ECDSA generateKey'
  );
  assert_true(
    SubtleCrypto.supports('sign', { name: 'ECDSA', hash: 'SHA-256' }),
    'ECDSA sign'
  );
  assert_true(
    SubtleCrypto.supports('verify', { name: 'ECDSA', hash: 'SHA-256' }),
    'ECDSA verify'
  );

  // AES-GCM
  assert_true(
    SubtleCrypto.supports('generateKey', { name: 'AES-GCM', length: 256 }),
    'AES-GCM generateKey'
  );
  assert_true(
    SubtleCrypto.supports('encrypt', {
      name: 'AES-GCM',
      iv: new Uint8Array(12),
    }),
    'AES-GCM encrypt'
  );
  assert_true(
    SubtleCrypto.supports('decrypt', {
      name: 'AES-GCM',
      iv: new Uint8Array(12),
    }),
    'AES-GCM decrypt'
  );

  // HMAC
  assert_true(
    SubtleCrypto.supports('generateKey', { name: 'HMAC', hash: 'SHA-256' }),
    'HMAC generateKey'
  );
  assert_true(SubtleCrypto.supports('sign', { name: 'HMAC' }), 'HMAC sign');
  assert_true(SubtleCrypto.supports('verify', { name: 'HMAC' }), 'HMAC verify');
}, 'Common algorithm and operation combinations work');

// Test some specific combinations that should not work
test(() => {
  // Hash algorithms don't support key operations
  assert_false(
    SubtleCrypto.supports('generateKey', 'SHA-256'),
    'SHA-256 generateKey should fail'
  );
  assert_false(
    SubtleCrypto.supports('sign', 'SHA-256'),
    'SHA-256 sign should fail'
  );

  // AES can't sign/verify (these require algorithm parameters due to normalization)
  assert_false(
    SubtleCrypto.supports('sign', 'AES-GCM'),
    'AES-GCM sign should fail'
  );
  assert_false(
    SubtleCrypto.supports('verify', 'AES-GCM'),
    'AES-GCM verify should fail'
  );

  // ECDSA can't encrypt/decrypt
  assert_false(
    SubtleCrypto.supports('encrypt', 'ECDSA'),
    'ECDSA encrypt should fail'
  );
  assert_false(
    SubtleCrypto.supports('decrypt', 'ECDSA'),
    'ECDSA decrypt should fail'
  );

  // HMAC can't encrypt/decrypt
  assert_false(
    SubtleCrypto.supports('encrypt', 'HMAC'),
    'HMAC encrypt should fail'
  );
  assert_false(
    SubtleCrypto.supports('decrypt', 'HMAC'),
    'HMAC decrypt should fail'
  );

  // Non-hash algorithms can't digest
  assert_false(
    SubtleCrypto.supports('digest', 'AES-GCM'),
    'AES-GCM digest should fail'
  );
  assert_false(
    SubtleCrypto.supports('digest', 'ECDSA'),
    'ECDSA digest should fail'
  );
  assert_false(
    SubtleCrypto.supports('digest', 'HMAC'),
    'HMAC digest should fail'
  );
}, 'Invalid algorithm and operation combinations fail');

// Test supports for deriveKey op
test(() => {
  assert_true(
      SubtleCrypto.supports(
          'deriveKey', {
            name: 'HKDF',
            hash: 'SHA-256',
            salt: new Uint8Array(16),
            info: new Uint8Array(0),
          },
          {name: 'HMAC', hash: 'SHA-256'}),

      'deriveKey HKDF-HMAC should pass');
}, 'deriveKey tests');

promise_test(async (t) => {
  let keypair = await crypto.subtle.generateKey(
      {
        name: 'X25519',
      },
      false, ['deriveKey', 'deriveBits']);

  assert_true(
      SubtleCrypto.supports(
          'deriveKey', {
            name: 'X25519',
            public: keypair.publicKey,
          },
          {name: 'AES-GCM', length: 256}),

      'deriveKey X25519-AES-GCM-256 should pass');

  assert_false(
      SubtleCrypto.supports(
          'deriveKey', {
            name: 'X25519',
            public: keypair.publicKey,
          },
          {name: 'HMAC', hash: 'SHA-256'}),

      'deriveKey X25519-HMAC-SHA-256 should fail');
}, 'deriveKey promise tests');

// Test supports for exportKey op
test(() => {
  assert_true(SubtleCrypto.supports('exportKey', 'AES-GCM'),
              'exportKey AES-GCM should pass');
  assert_false(SubtleCrypto.supports('exportKey', 'HKDF'),
               'exportKey HKDF should fail');
  assert_false(SubtleCrypto.supports('exportKey', 'PBKDF2'),
               'exportKey PBKDF2 should fail');
}, 'exportKey tests');

// Test supports for wrapKey op
test(() => {
  assert_true(SubtleCrypto.supports('wrapKey', 'AES-KW', 'AES-GCM'),
              'wrapKey AES-KW-AES-GCM should pass');
  assert_false(SubtleCrypto.supports('wrapKey', 'AES-KW', 'HKDF'),
               'wrapKey AES-KW-HKDF should fail');
  assert_false(SubtleCrypto.supports('wrapKey', 'AES-KW', 'PBKDF2'),
               'wrapKey AES-KW-PBKDF2 should fail');
}, 'wrapKey tests');


done();