Modern Algorithms in the Web Cryptography API

The check support for an algorithm algorithm defines a process for checking whether the given algorithm is supported for the given operation. Its input is an operation name op, an AlgorithmIdentifier alg, and an optional length parameter. Its output is a boolean. It behaves as follows:

1. If op is "deriveKey", set op is "deriveBits".

2. Let normalizedAlgorithm be the result of normalizing an algorithm, with alg set to alg and op set to op.

3. If an error occurred:

   1. If op is "wrapKey", return the result of checking support for an algorithm with op set to "encrypt" and alg set to alg.

   2. If op is "unwrapKey", return the result of checking support for an algorithm with op set to "decrypt" and alg set to alg.

   3. Otherwise, return false.

4. If the specified operation or algorithm (or one of its parameter values) is expected to fail (for any key and/or data) for an implementation-specific reason (e.g. known nonconformance to the specification), return false.

5. If op is "generateKey" or "importKey", let usages be the empty list.

6. For each of the steps of the operation specified by op of the algorithm specified by normalizedAlgorithm:

   If the step says to throw an error:

   Return false.

   If the step says to generate a key:

   Return true.

   If the step relies on an unavailable parameter, such as key, plaintext or ciphertext:

   Return true.

   If the step says to return a value:

   Return true.

   Otherwise:

   Execute the step.

   Note

   The steps in the referenced algorithm may access the normalizedAlgorithm, length, and usages variables from this context.

7. Assert: this step is never reached, because one of the steps of the operation will have said to return a value or throw an error, causing us to return true or false, respectively.

The recognized algorithm name for this algorithm is "AES-OCB".

WebIDLdictionary AeadParams : Algorithm {
  required BufferSource iv;
  BufferSource additionalData;
  [EnforceRange] octet tagLength;
};

The iv member represents the initialization vector to use.

The additionalData member represents the additional authentication data to include.

The tagLength member represents the desired length of the authentication tag.

Encrypt

1. If the iv member of normalizedAlgorithm has a length greater than 15 bytes, then throw an OperationError.

2. If the tagLength member of normalizedAlgorithm is not present:

   Let tagLength be 128.

   If the tagLength member of normalizedAlgorithm is one of 64, 96 or 128:

   Let tagLength be equal to the tagLength member of normalizedAlgorithm

   Otherwise:

   throw an OperationError.

3. Let additionalData be the contents of the additionalData member of normalizedAlgorithm if present or the empty octet string otherwise.

4. Let C be the output that results from performing the OCB-ENCRYPT function described in Section 4.2 of [RFC7253] using AES as the block cipher, using the key represented by [[handle]] internal slot of key as the K input parameter, the contents of the iv member of normalizedAlgorithm as the N input parameter, the contents of additionalData as the A input parameter, the contents of plaintext as the P input parameter, and tagLength as the TAGLEN global parameter.

5. Return the result of creating an ArrayBuffer containing C.

Decrypt

1. If the iv member of normalizedAlgorithm has a length greater than 15 bytes, then throw an OperationError.

2. If the tagLength member of normalizedAlgorithm is not present:

   Let tagLength be 128.

   If the tagLength member of normalizedAlgorithm is one of 64, 96 or 128:

   Let tagLength be equal to the tagLength member of normalizedAlgorithm

   Otherwise:

   throw an OperationError.

3. If ciphertext has a length less than tagLength bits, then throw an OperationError.

4. Let additionalData be the contents of the additionalData member of normalizedAlgorithm if present or the empty octet string otherwise.

5. Perform the OCB-DECRYPT function described in Section 4.3 of [RFC7253] using AES as the block cipher, using the key represented by [[handle]] internal slot of key as the K input parameter, the contents of the iv member of normalizedAlgorithm as the N input parameter, the contents of additionalData as the A input parameter, the contents of ciphertext as the C input parameter, and tagLength as the TAGLEN global parameter.

   If the result of the algorithm is the indication of authentication failure, "INVALID":

   throw an OperationError

   Otherwise:

   Let plaintext be the output P of OCB-DECRYPT.

6. Return the result of creating an ArrayBuffer containing plaintext.

Generate Key

1. If usages contains any entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.

2. If the length member of normalizedAlgorithm is not equal to one of 128, 192 or 256, then throw an OperationError.

3. Generate an AES key of length equal to the length member of normalizedAlgorithm.

4. If the key generation step fails, then throw an OperationError.

5. Let key be a new CryptoKey object representing the generated AES key.

6. Let algorithm be a new AesKeyAlgorithm.

7. Set the name attribute of algorithm to "AES-OCB".

8. Set the length attribute of algorithm to equal the length member of normalizedAlgorithm.

9. Set the [[algorithm]] internal slot of key to algorithm.

10. Set the [[extractable]] internal slot of key to be extractable.

11. Set the [[usages]] internal slot of key to be usages.

12. Return key.

Import Key

1. If usages contains an entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.

2. If format is "raw":

   1. Let data be the octet string contained in keyData.

   2. If the length in bits of data is not 128, 192 or 256 then throw a DataError.

   If format is "jwk":

   1. If keyData is a JsonWebKey dictionary:

      Let jwk equal keyData.

      Otherwise:

      Throw a DataError.

   2. If the kty field of jwk is not "oct", then throw a DataError.

   3. If jwk does not meet the requirements of Section 6.4 of JSON Web Algorithms [JWA], then throw a DataError.

   4. Let data be the octet string obtained by decoding the k field of jwk.

   5. If data has length 128 bits:

      If the alg field of jwk is present, and is not "A128OCB", then throw a DataError.

      If data has length 192 bits:

      If the alg field of jwk is present, and is not "A192OCB", then throw a DataError.

      If data has length 256 bits:

      If the alg field of jwk is present, and is not "A256OCB", then throw a DataError.

      Otherwise:

      throw a DataError.

   6. If usages is non-empty and the use field of jwk is present and is not "enc", then throw a DataError.

   7. If the key_ops field of jwk is present, and is invalid according to the requirements of JSON Web Key [JWK] or does not contain all of the specified usages values, then throw a DataError.

   8. If the ext field of jwk is present and has the value false and extractable is true, then throw a DataError.

   Otherwise:

   throw a NotSupportedError.

3. Let key be a new CryptoKey object representing an AES key with value data.

4. Let algorithm be a new AesKeyAlgorithm.

5. Set the name attribute of algorithm to "AES-OCB".

6. Set the length attribute of algorithm to the length, in bits, of data.

7. Set the [[algorithm]] internal slot of key to algorithm.

8. Return key.

Export Key

1. If the underlying cryptographic key material represented by the [[handle]] internal slot of key cannot be accessed, then throw an OperationError.

2. If format is "raw":

   1. Let data be the raw octets of the key represented by [[handle]] internal slot of key.

   2. Let result be the result of creating an ArrayBuffer containing data.

   If format is "jwk":

   1. Let jwk be a new JsonWebKey dictionary.

   2. Set the kty attribute of jwk to the string "oct".

   3. Set the k attribute of jwk to be a string containing the raw octets of the key represented by [[handle]] internal slot of key, encoded according to Section 6.4 of JSON Web Algorithms [JWA].

   4. If the length attribute of key is 128:

      Set the alg attribute of jwk to the string "A128OCB".

      If the length attribute of key is 192:

      Set the alg attribute of jwk to the string "A192OCB".

      If the length attribute of key is 256:

      Set the alg attribute of jwk to the string "A256OCB".

   5. Set the key_ops attribute of jwk to equal the usages attribute of key.

   6. Set the ext attribute of jwk to equal the [[extractable]] internal slot of key.

   7. Let result be the result of converting jwk to an ECMAScript Object, as defined by [WebIDL].

   Otherwise:

   throw a NotSupportedError.

3. Return result.

Get key length

1. If the length member of normalizedDerivedKeyAlgorithm is not 128, 192 or 256, then throw an OperationError.

2. Return the length member of normalizedDerivedKeyAlgorithm.

The recognized algorithm name for this algorithm is "ChaCha20-Poly1305".

Encrypt

1. If the iv member of normalizedAlgorithm does not have a length of 12 bytes, then throw an OperationError.

2. If the tagLength member of normalizedAlgorithm is present and is not 128, then throw an OperationError.

3. Let additionalData be the contents of the additionalData member of normalizedAlgorithm if present or the empty octet string otherwise.

4. Let ciphertext be the output that results from performing the AEAD_CHACHA20_POLY1305 encryption algorithm described in Section 2.8 of [RFC8439], using the key represented by [[handle]] internal slot of key as the key input parameter, the contents of the iv member of normalizedAlgorithm as the nonce input parameter, the contents of plaintext as the plaintext input parameter, and the contents of additionalData as the additional authenticated data (AAD) input parameter.

5. Return the result of creating an ArrayBuffer containing ciphertext.

Decrypt

1. If the iv member of normalizedAlgorithm does not have a length of 12 bytes, then throw an OperationError.

2. If the tagLength member of normalizedAlgorithm is present and is not 128, then throw an OperationError.

3. If ciphertext has a length less than 128 bits, then throw an OperationError.

4. Let additionalData be the contents of the additionalData member of normalizedAlgorithm if present or the empty octet string otherwise.

5. Perform the AEAD_CHACHA20_POLY1305 decryption algorithm described in Section 2.8 of [RFC8439], using the key represented by [[handle]] internal slot of key as the key input parameter, the contents of the iv member of normalizedAlgorithm as the nonce input parameter, the contents of ciphertext as the ciphertext input parameter, and the contents of additionalData as the additional authenticated data (AAD) input parameter.

   If the result of the algorithm is the indication of authentication failure:

   throw an OperationError

   Otherwise:

   Let plaintext be the resulting plaintext.

6. Return the result of creating an ArrayBuffer containing plaintext.

Generate Key

1. If usages contains any entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.

2. Generate a 256-bit key.

3. If the key generation step fails, then throw an OperationError.

4. Let key be a new CryptoKey object representing the generated key.

5. Let algorithm be a new KeyAlgorithm.

6. Set the name attribute of algorithm to "ChaCha20-Poly1305".

7. Set the [[algorithm]] internal slot of key to algorithm.

8. Set the [[extractable]] internal slot of key to be extractable.

9. Set the [[usages]] internal slot of key to be usages.

10. Return key.

Import Key

1. If usages contains an entry which is not one of "encrypt", "decrypt", "wrapKey" or "unwrapKey", then throw a SyntaxError.

2. If format is "raw":

   1. Let data be the octet string contained in keyData.

   2. If the length in bits of data is not 256 then throw a DataError.

   If format is "jwk":

   1. If keyData is a JsonWebKey dictionary:

      Let jwk equal keyData.

      Otherwise:

      Throw a DataError.

   2. If the kty field of jwk is not "oct", then throw a DataError.

   3. If jwk does not meet the requirements of Section 6.4 of JSON Web Algorithms [JWA], then throw a DataError.

   4. Let data be the octet string obtained by decoding the k field of jwk.

   5. If the alg field of jwk is present, and is not "CC20P1305", then throw a DataError.

   6. If usages is non-empty and the use field of jwk is present and is not "enc", then throw a DataError.

   7. If the key_ops field of jwk is present, and is invalid according to the requirements of JSON Web Key [JWK] or does not contain all of the specified usages values, then throw a DataError.

   8. If the ext field of jwk is present and has the value false and extractable is true, then throw a DataError.

   Otherwise:

   throw a NotSupportedError.

3. Let key be a new CryptoKey object representing a key with value data.

4. Let algorithm be a new KeyAlgorithm.

5. Set the name attribute of algorithm to "ChaCha20-Poly1305".

6. Set the [[algorithm]] internal slot of key to algorithm.

7. Return key.

Export Key

1. If the underlying cryptographic key material represented by the [[handle]] internal slot of key cannot be accessed, then throw an OperationError.

2. If format is "raw":

   1. Let data be the raw octets of the key represented by [[handle]] internal slot of key.

   2. Let result be the result of creating an ArrayBuffer containing data.

   If format is "jwk":

   1. Let jwk be a new JsonWebKey dictionary.

   2. Set the kty attribute of jwk to the string "oct".

   3. Set the k attribute of jwk to be a string containing the raw octets of the key represented by [[handle]] internal slot of key, encoded according to Section 6.4 of JSON Web Algorithms [JWA].

   4. Set the alg attribute of jwk to the string "CC20P1305".

   5. Set the key_ops attribute of jwk to equal the usages attribute of key.

   6. Set the ext attribute of jwk to equal the [[extractable]] internal slot of key.

   7. Let result be the result of converting jwk to an ECMAScript Object, as defined by [WebIDL].

   Otherwise:

   throw a NotSupportedError.

3. Return result.

Get key length

1. Return 256.

The recognized algorithm names are "SHA3-256", "SHA3-384", and "SHA3-512" for the respective SHA-3 algorithms.

Digest

1. If the name member of normalizedAlgorithm is a case-sensitive string match for "SHA3-256":

   Let result be the result of performing the SHA3-256 hash function defined in Section 6.1 of [FIPS-202] using message as the input message, M.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "SHA3-384":

   Let result be the result of performing the SHA3-384 hash function defined in Section 6.1 of [FIPS-202] using message as the input message, M.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "SHA3-512":

   Let result be the result of performing the SHA3-512 hash function defined in Section 6.1 of [FIPS-202] using message as the input message, M.

2. If performing the operation results in an error, then throw an OperationError.

3. Return the result of creating an ArrayBuffer containing result.

The recognized algorithm names are "cSHAKE128" and "cSHAKE256".

WebIDLdictionary CShakeParams : Algorithm {
  required [EnforceRange] unsigned long length;
  BufferSource functionName;
  BufferSource customization;
};

The length member represents the requested output length in bits.

The functionName member represents the function name, used by NIST to define functions based on cSHAKE. When used, it should only be set to values defined by NIST.

The customization member represents the customization string. The application selects this string to define a variant of the function.

Digest

1. Let length be the length member of normalizedAlgorithm.

2. Let functionName be the contents of the functionName member of normalizedAlgorithm if present or the empty octet string otherwise.

3. Let customization be the contents of the customization member of normalizedAlgorithm if present or the empty octet string otherwise.

4. If the name member of normalizedAlgorithm is a case-sensitive string match for "cSHAKE128":

   Let result be the result of performing the cSHAKE128 function defined in Section 3 of [NIST-SP800-185] using message as the X input parameter, length as the L input parameter, functionName as the N input parameter, and customization as the S input parameter.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "cSHAKE256":

   Let result be the result of performing the cSHAKE256 function defined in Section 3 of [NIST-SP800-185] using message as the X input parameter, length as the L input parameter, functionName as the N input parameter, and customization as the S input parameter.

5. If performing the operation results in an error, then throw an OperationError.

6. Return the result of creating an ArrayBuffer containing result.

The recognized algorithm names are "KMAC128" and "KMAC256".

WebIDLdictionary KmacKeyGenParams : Algorithm {
  [EnforceRange] unsigned long length;
};

The length member represents the length (in bits) of the key to generate. If unspecified, the recommended length will be used, which is 128 for KMAC128 and 256 for KMAC256.

WebIDLdictionary KmacImportParams : Algorithm {
  [EnforceRange] unsigned long length;
};

The length member represents the length (in bits) of the key.

WebIDLdictionary KmacKeyAlgorithm : KeyAlgorithm {
  required unsigned long length;
};

The length member represents the length (in bits) of the key.

WebIDLdictionary KmacParams : Algorithm {
  required [EnforceRange] unsigned long length;
  BufferSource customization;
};

The length member represents the requested output length in bits.

The customization member represents the customization string. The application selects this string to define a variant of the function.

Sign

1. Let customization be the contents of the customization member of normalizedAlgorithm if present or the empty octet string otherwise.

2. If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC128":

   Let mac be the result of performing the KMAC128 function defined in Section 4 of [NIST-SP800-185] using the key represented by [[handle]] internal slot of key as the K input parameter, message as the X input parameter, the length member of normalizedAlgorithm as the L input parameter, and customization as the S input parameter.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC256":

   Let mac be the result of performing the KMAC256 function defined in Section 4 of [NIST-SP800-185] using the key represented by [[handle]] internal slot of key as the K input parameter, message as the X input parameter, the length member of normalizedAlgorithm as the L input parameter, and customization as the S input parameter.

3. Return the result of creating an ArrayBuffer containing mac.

Verify

1. Let customization be the contents of the customization member of normalizedAlgorithm if present or the empty octet string otherwise.

2. If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC128":

   Let mac be the result of performing the KMAC128 function defined in Section 4 of [NIST-SP800-185] using the key represented by [[handle]] internal slot of key as the K input parameter, message as the X input parameter, the length member of normalizedAlgorithm as the L input parameter, and customization as the S input parameter.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC256":

   Let mac be the result of performing the KMAC256 function defined in Section 4 of [NIST-SP800-185] using the key represented by [[handle]] internal slot of key as the K input parameter, message as the X input parameter, the length member of normalizedAlgorithm as the L input parameter, and customization as the S input parameter.

3. Return true if mac is equal to signature and false otherwise.

Generate Key

1. If usages contains any entry which is not "sign" or "verify", then throw a SyntaxError.

2. If the length member of normalizedAlgorithm is present:

   Let length be equal to the length member of normalizedAlgorithm.

   Otherwise, if the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC128":

   Let length be 128.

   Otherwise, if the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC256":

   Let length be 256.

3. Generate a key of length length bits.

4. If the key generation step fails, then throw an OperationError.

5. Let key be a new CryptoKey object representing the generated key.

6. Let algorithm be a new KmacKeyAlgorithm.

7. Set the name attribute of algorithm to "KMAC".

8. Set the [[algorithm]] internal slot of key to algorithm.

9. Set the [[extractable]] internal slot of key to be extractable.

10. Set the [[usages]] internal slot of key to be usages.

11. Return key.

Import Key

1. Let keyData be the key data to be imported.

2. If usages contains an entry which is not "sign" or "verify", then throw a SyntaxError.

3. If format is "raw":

   1. Let data be the octet string contained in keyData.

   If format is "jwk":

   1. If keyData is a JsonWebKey dictionary:

      Let jwk equal keyData.

      Otherwise:

      Throw a DataError.

   2. If the kty field of jwk is not "oct", then throw a DataError.

   3. If jwk does not meet the requirements of Section 6.4 of JSON Web Algorithms [JWA], then throw a DataError.

   4. Let data be the octet string obtained by decoding the k field of jwk.

   5. If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC128":

      If the alg field of jwk is present and is not "K128", then throw a DataError.

      If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC256":

      If the alg field of jwk is present and is not "K256", then throw a DataError.

   6. If usages is non-empty and the use field of jwk is present and is not "sign", then throw a DataError.

   7. If the key_ops field of jwk is present, and is invalid according to the requirements of JSON Web Key [JWK] or does not contain all of the specified usages values, then throw a DataError.

   8. If the ext field of jwk is present and has the value false and extractable is true, then throw a DataError.

   Otherwise:

   throw a NotSupportedError.

4. Let length be equivalent to the length, in octets, of data, multiplied by 8.

5. If length is zero then throw a DataError.

6. If the length member of normalizedAlgorithm is present:

   If the length member of normalizedAlgorithm is greater than length:

   throw a DataError.

   If the length member of normalizedAlgorithm, is less than or equal to length minus eight:

   throw a DataError.

   Otherwise:

   Set length equal to the length member of normalizedAlgorithm.

7. Let key be a new CryptoKey object representing an KMAC key with the first length bits of data.

8. Let algorithm be a new KmacKeyAlgorithm.

9. Set the name attribute of algorithm to "KMAC".

10. Set the length attribute of algorithm to length.

11. Set the [[algorithm]] internal slot of key to algorithm.

12. Return key.

Export Key

1. If the underlying cryptographic key material represented by the [[handle]] internal slot of key cannot be accessed, then throw an OperationError.

2. Let bits be the raw bits of the key represented by [[handle]] internal slot of key.

3. Let data be an octet string containing bits.

4. If format is "raw":

   1. Let result be the result of creating an ArrayBuffer containing data.

   If format is "jwk":

   1. Let jwk be a new JsonWebKey dictionary.

   2. Set the kty attribute of jwk to the string "oct".

   3. Set the k attribute of jwk to be a string containing data, encoded according to Section 6.4 of JSON Web Algorithms [JWA].

   4. Let algorithm be the [[algorithm]] internal slot of key.

   5. If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC128":

      Set the alg attribute of jwk to the string "K128".

      If the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC256":

      Set the alg attribute of jwk to the string "K256".

   6. Set the key_ops attribute of jwk to equal the usages attribute of key.

   7. Set the ext attribute of jwk to equal the [[extractable]] internal slot of key.

   8. Let result be the result of converting jwk to an ECMAScript Object, as defined by [WebIDL].

   Otherwise:

   throw a NotSupportedError.

5. Return result.

Get key length

1. If the length member of normalizedAlgorithm is present:

   Let length be equal to the length member of normalizedAlgorithm.

   Otherwise, if the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC128":

   Let length be 128.

   Otherwise, if the name member of normalizedAlgorithm is a case-sensitive string match for "KMAC256":

   Let length be 256.

2. Return length.

The recognized algorithm names are "Argon2d", "Argon2i", and "Argon2id" for the respective Argon2 types.

WebIDLdictionary Argon2Params : Algorithm {
  required BufferSource nonce;
  required [EnforceRange] unsigned long parallelism;
  required [EnforceRange] unsigned long memory;
  required [EnforceRange] unsigned long passes;
  [EnforceRange] octet version;
  BufferSource secretValue;
  BufferSource associatedData;
};

The nonce member represents the nonce, which is a salt for password hashing applications.

The parallelism member represents the degree of parallelism.

The memory member represents the memory size in kibibytes. It must be at least 8 times the degree of parallelism.

The passes member represents the number of passes.

The version member represents the version number. The default and currently only defined version is 19 (0x13).

The secretValue member represents the optional secret value.

The associatedData member represents the optional associated data.

Derive Bits

1. If length is null, or is less than 32 (4*8), then throw an OperationError.

2. If the version member of normalizedAlgorithm is present and is not 19 (0x13), then throw an OperationError.

3. If the parallelism member of normalizedAlgorithm is zero, or greater than 16777215 (2^24-1), then throw an OperationError.

4. If the memory member of normalizedAlgorithm is less than 8 times the parallelism member of normalizedAlgorithm, then throw an OperationError.

5. If the passes member of normalizedAlgorithm is zero, then throw an OperationError.

6. If the name member of normalizedAlgorithm is a case-sensitive string match for "Argon2d":

   Let type be 0.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "Argon2i":

   Let type be 1.

   If the name member of normalizedAlgorithm is a case-sensitive string match for "Argon2id":

   Let type be 2.

7. Let secretValue be the contents of the secretValue member of normalizedAlgorithm, if present.

8. Let associatedData be the contents of the associatedData member of normalizedAlgorithm, if present.

9. Let result be the result of performing the Argon2 function defined in Section 3 of [RFC9106] using the password represented by [[handle]] internal slot of key as the message, P, the contents of the nonce attribute of normalizedAlgorithm as the nonce, S, the value of the parallelism attribute of normalizedAlgorithm as the degree of parallelism, p, the value of the memory attribute of normalizedAlgorithm as the memory size, m, the value of the passes attribute of normalizedAlgorithm as the number of passes, t, 0x13 as the version number, v, secretValue (if present) as the secret value, K, associatedData (if present) as the associated data, X, type as the type, y, and length divided by 8 as the tag length, T.

10. If the key derivation operation fails, then throw an OperationError.

11. Return the result of creating an ArrayBuffer containing result.

Import key

1. If format is not "raw", throw a NotSupportedError

2. If usages contains a value that is not "deriveKey" or "deriveBits", then throw a SyntaxError.

3. If extractable is not false, then throw a SyntaxError.

4. Let key be a new CryptoKey representing keyData.

5. Set the [[type]] internal slot of key to "secret".

6. Set the [[extractable]] internal slot of key to false.

7. Let algorithm be a new KeyAlgorithm object.

8. Set the name attribute of algorithm to the name member of normalizedAlgorithm.

9. Set the [[algorithm]] internal slot of key to algorithm.

10. Return key.

Get key length

1. Return null.