@enbox/crypto 0.0.3 → 0.0.5

package/src/algorithms/aes-kw.ts

@@ -0,0 +1,182 @@
+import type { Jwk } from '../jose/jwk.js';
+import type { KeyConverter } from '../types/key-converter.js';
+import type { KeyGenerator } from '../types/key-generator.js';
+import type { KeyWrapper } from '../types/key-wrapper.js';
+import type { RequireOnly } from '@enbox/common';
+import type { BytesToPrivateKeyParams, GenerateKeyParams, PrivateKeyToBytesParams, UnwrapKeyParams, WrapKeyParams } from '../types/params-direct.js';
+
+import { AesKw } from '../primitives/aes-kw.js';
+import { CryptoAlgorithm } from './crypto-algorithm.js';
+
+/**
+ * The `AesKwGenerateKeyParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `generateKey()` method when using the AES-KW algorithm.
+ */
+export interface AesKwGenerateKeyParams extends GenerateKeyParams {
+  /** Specifies the algorithm variant for key generation in AES-KW mode.
+   * The value determines the length of the key to be generated and must be one of the following:
+   * - `"A128KW"`: AES Key Wrap using a 128-bit key.
+   * - `"A192KW"`: AES Key Wrap using a 192-bit key.
+   * - `"A256KW"`: AES Key Wrap using a 256-bit key.
+   */
+  algorithm: 'A128KW' | 'A192KW' | 'A256KW';
+}
+
+/**
+ * The `AesKwAlgorithm` class provides a concrete implementation for cryptographic operations using
+ * the AES algorithm for key wrapping. This class implements both
+ * {@link KeyGenerator | `KeyGenerator`} and {@link KeyWrapper | `KeyWrapper`} interfaces, providing
+ * key generation, key wrapping, and key unwrapping features.
+ *
+ * This class is typically accessed through implementations that extend the
+ * {@link DsaApi | `DsaApi`} interface.
+ */
+export class AesKwAlgorithm extends CryptoAlgorithm
+  implements KeyConverter,
+             KeyGenerator<AesKwGenerateKeyParams, Jwk>,
+             KeyWrapper<WrapKeyParams, UnwrapKeyParams> {
+
+  /**
+   * Converts a private key from a byte array to JWK format, setting the `alg` property based on
+   * the key length.
+   *
+   * @param params - The parameters for the private key conversion.
+   * @param params.privateKeyBytes - The raw private key as a Uint8Array.
+   *
+   * @returns A Promise that resolves to the private key in JWK format.
+   */
+  public async bytesToPrivateKey({ privateKeyBytes }:
+    RequireOnly<BytesToPrivateKeyParams, 'privateKeyBytes'>
+  ): Promise<Jwk> {
+    // Convert the byte array to a JWK.
+    const privateKey = await AesKw.bytesToPrivateKey({ privateKeyBytes });
+
+    // Set the `alg` property based on the key length.
+    privateKey.alg = { 16: 'A128KW', 24: 'A192KW', 32: 'A256KW' }[privateKeyBytes.length];
+
+    return privateKey;
+  }
+
+  /**
+   * Generates a symmetric key for AES for key wrapping in JSON Web Key (JWK) format.
+   *
+   * @remarks
+   * This method generates a symmetric AES key for use in key wrapping mode, based on the specified
+   * `algorithm` parameter which determines the key length. It uses cryptographically secure random
+   * number generation to ensure the uniqueness and security of the key. The key is returned in JWK
+   * format.
+   *
+   * The generated key includes the following components:
+   * - `kty`: Key Type, set to 'oct' for Octet Sequence.
+   * - `k`: The symmetric key component, base64url-encoded.
+   * - `kid`: Key ID, generated based on the JWK thumbprint.
+   * - `alg`: Algorithm, set to 'A128KW', 'A192KW', or 'A256KW' for AES Key Wrap with the
+   *   specified key length.
+   *
+   * @example
+   * ```ts
+   * const aesKw = new AesKwAlgorithm();
+   * const privateKey = await aesKw.generateKey({ algorithm: 'A256KW' });
+   * ```
+   *
+   * @param params - The parameters for the key generation.
+   *
+   * @returns A Promise that resolves to the generated symmetric key in JWK format.
+   */
+  public async generateKey({ algorithm }:
+    AesKwGenerateKeyParams
+  ): Promise<Jwk> {
+    // Map algorithm name to key length.
+    const length = { A128KW: 128, A192KW: 192, A256KW: 256 }[algorithm] as 128 | 192 | 256;
+
+    // Generate a random private key.
+    const privateKey = await AesKw.generateKey({ length });
+
+    // Set the `alg` property based on the specified algorithm.
+    privateKey.alg = algorithm;
+
+    return privateKey;
+  }
+
+  /**
+   * Converts a private key from JWK format to a byte array.
+   *
+   * @param params - The parameters for the private key conversion.
+   * @param params.privateKey - The private key in JWK format.
+   *
+   * @returns A Promise that resolves to the private key as a Uint8Array.
+   */
+  public async privateKeyToBytes({ privateKey }:
+    PrivateKeyToBytesParams
+  ): Promise<Uint8Array> {
+    // Convert the JWK to a byte array.
+    const privateKeyBytes = await AesKw.privateKeyToBytes({ privateKey });
+
+    return privateKeyBytes;
+  }
+
+  /**
+   * Decrypts a wrapped key using the AES Key Wrap algorithm.
+   *
+   * @remarks
+   * This method unwraps a previously wrapped cryptographic key using the AES Key Wrap algorithm.
+   * The wrapped key, provided as a byte array, is unwrapped using the decryption key specified in
+   * the parameters.
+   *
+   * This operation is useful for securely receiving keys transmitted over untrusted mediums. The
+   * method returns the unwrapped key as a JSON Web Key (JWK).
+   *
+   * @example
+   * ```ts
+   * const aesKw = new AesKwAlgorithm();
+   * const wrappedKeyBytes = new Uint8Array([...]); // Byte array of a wrapped AES-256 GCM key
+   * const decryptionKey = { ... }; // A Jwk object representing the AES unwrapping key
+   * const unwrappedKey = await aesKw.unwrapKey({
+   *   wrappedKeyBytes,
+   *   wrappedKeyAlgorithm: 'A256GCM',
+   *   decryptionKey
+   * });
+   * ```
+   *
+   * @param params - The parameters for the key unwrapping operation.
+   *
+   * @returns A Promise that resolves to the unwrapped key in JWK format.
+   */
+  public async unwrapKey(params:
+    UnwrapKeyParams
+  ): Promise<Jwk> {
+    const unwrappedKey = await AesKw.unwrapKey(params);
+
+    return unwrappedKey;
+  }
+
+  /**
+   * Encrypts a given key using the AES Key Wrap algorithm.
+   *
+   * @remarks
+   * This method wraps a given cryptographic key using the AES Key Wrap algorithm. The private key
+   * to be wrapped is provided in the form of a JSON Web Key (JWK).
+   *
+   * This operation is useful for securely transmitting keys over untrusted mediums. The method
+   * returns the wrapped key as a byte array.
+   *
+   * @example
+   * ```ts
+   * const aesKw = new AesKwAlgorithm();
+   * const unwrappedKey = { ... }; // A Jwk object representing the key to be wrapped
+   * const encryptionKey = { ... }; // A Jwk object representing the AES wrapping key
+   * const wrappedKeyBytes = await aesKw.wrapKey({ unwrappedKey, encryptionKey });
+   * ```
+   *
+   * @param params - The parameters for the key wrapping operation.
+   *
+   * @returns A Promise that resolves to the wrapped key as a Uint8Array.
+   */
+  public async wrapKey(params:
+    WrapKeyParams
+  ): Promise<Uint8Array> {
+    const wrappedKeyBytes = AesKw.wrapKey(params);
+
+    return wrappedKeyBytes;
+  }
+}

package/src/algorithms/ecdsa.ts

@@ -1,10 +1,15 @@
 import type { AsymmetricKeyGenerator } from '../types/key-generator.js';
 import type { Jwk } from '../jose/jwk.js';
 import type { Signer } from '../types/signer.js';
+import type { AsymmetricKeyConverter, KeyConverter } from '../types/key-converter.js';
 import type {
+  BytesToPrivateKeyParams,
+  BytesToPublicKeyParams,
   ComputePublicKeyParams,
   GenerateKeyParams,
   GetPublicKeyParams,
+  PrivateKeyToBytesParams,
+  PublicKeyToBytesParams,
   SignParams,
   VerifyParams,
 } from '../types/params-direct.js';
@@ -12,6 +17,7 @@ import type {
 import { CryptoAlgorithm } from './crypto-algorithm.js';
 import { Secp256k1 } from '../primitives/secp256k1.js';
 import { Secp256r1 } from '../primitives/secp256r1.js';
+import { CryptoError, CryptoErrorCode } from '../crypto-error.js';
 import { isEcPrivateJwk, isEcPublicJwk } from '../jose/jwk.js';
 
 /**
@@ -37,12 +43,83 @@ export interface EcdsaGenerateKeyParams extends GenerateKeyParams {
  * of signatures.
  *
  * This class is typically accessed through implementations that extend the
- * {@link CryptoApi | `CryptoApi`} interface.
+ * {@link DsaApi | `DsaApi`} interface.
  */
 export class EcdsaAlgorithm extends CryptoAlgorithm
   implements AsymmetricKeyGenerator<EcdsaGenerateKeyParams, Jwk, GetPublicKeyParams>,
+             KeyConverter, AsymmetricKeyConverter,
              Signer<SignParams, VerifyParams> {
 
+  /**
+   * Converts a private key from a byte array to JWK format, setting the `alg` property based on
+   * the algorithm.
+   *
+   * @param params - The parameters for the private key conversion.
+   * @param params.algorithm - The ECDSA algorithm identifier.
+   * @param params.privateKeyBytes - The raw private key as a Uint8Array.
+   *
+   * @returns A Promise that resolves to the private key in JWK format.
+   */
+  public async bytesToPrivateKey({ algorithm, privateKeyBytes }:
+    BytesToPrivateKeyParams & { algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1' }
+  ): Promise<Jwk> {
+    switch (algorithm) {
+
+      case 'ES256K':
+      case 'secp256k1': {
+        const privateKey = await Secp256k1.bytesToPrivateKey({ privateKeyBytes });
+        privateKey.alg = 'ES256K';
+        return privateKey;
+      }
+
+      case 'ES256':
+      case 'secp256r1': {
+        const privateKey = await Secp256r1.bytesToPrivateKey({ privateKeyBytes });
+        privateKey.alg = 'ES256';
+        return privateKey;
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Algorithm not supported: ${algorithm}`);
+      }
+    }
+  }
+
+  /**
+   * Converts a public key from a byte array to JWK format, setting the `alg` property based on
+   * the algorithm.
+   *
+   * @param params - The parameters for the public key conversion.
+   * @param params.algorithm - The ECDSA algorithm identifier.
+   * @param params.publicKeyBytes - The raw public key as a Uint8Array.
+   *
+   * @returns A Promise that resolves to the public key in JWK format.
+   */
+  public async bytesToPublicKey({ algorithm, publicKeyBytes }:
+    BytesToPublicKeyParams & { algorithm: 'ES256' | 'ES256K' | 'secp256k1' | 'secp256r1' }
+  ): Promise<Jwk> {
+    switch (algorithm) {
+
+      case 'ES256K':
+      case 'secp256k1': {
+        const publicKey = await Secp256k1.bytesToPublicKey({ publicKeyBytes });
+        publicKey.alg = 'ES256K';
+        return publicKey;
+      }
+
+      case 'ES256':
+      case 'secp256r1': {
+        const publicKey = await Secp256r1.bytesToPublicKey({ publicKeyBytes });
+        publicKey.alg = 'ES256';
+        return publicKey;
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Algorithm not supported: ${algorithm}`);
+      }
+    }
+  }
+
   /**
    * Derives the public key in JWK format from a given private key.
    *
@@ -272,4 +349,58 @@ export class EcdsaAlgorithm extends CryptoAlgorithm
       }
     }
   }
+
+  /**
+   * Converts a private key from JWK format to a byte array.
+   *
+   * @param params - The parameters for the private key conversion.
+   * @param params.privateKey - The private key in JWK format.
+   *
+   * @returns A Promise that resolves to the private key as a Uint8Array.
+   */
+  public async privateKeyToBytes({ privateKey }:
+    PrivateKeyToBytesParams
+  ): Promise<Uint8Array> {
+    switch (privateKey.crv) {
+
+      case 'secp256k1': {
+        return await Secp256k1.privateKeyToBytes({ privateKey });
+      }
+
+      case 'P-256': {
+        return await Secp256r1.privateKeyToBytes({ privateKey });
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Curve not supported: ${privateKey.crv}`);
+      }
+    }
+  }
+
+  /**
+   * Converts a public key from JWK format to a byte array.
+   *
+   * @param params - The parameters for the public key conversion.
+   * @param params.publicKey - The public key in JWK format.
+   *
+   * @returns A Promise that resolves to the public key as a Uint8Array.
+   */
+  public async publicKeyToBytes({ publicKey }:
+    PublicKeyToBytesParams
+  ): Promise<Uint8Array> {
+    switch (publicKey.crv) {
+
+      case 'secp256k1': {
+        return await Secp256k1.publicKeyToBytes({ publicKey });
+      }
+
+      case 'P-256': {
+        return await Secp256r1.publicKeyToBytes({ publicKey });
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Curve not supported: ${publicKey.crv}`);
+      }
+    }
+  }
 }

package/src/algorithms/eddsa.ts

@@ -1,16 +1,22 @@
 import type { AsymmetricKeyGenerator } from '../types/key-generator.js';
 import type { Jwk } from '../jose/jwk.js';
 import type { Signer } from '../types/signer.js';
+import type { AsymmetricKeyConverter, KeyConverter } from '../types/key-converter.js';
 import type {
+  BytesToPrivateKeyParams,
+  BytesToPublicKeyParams,
   ComputePublicKeyParams,
   GenerateKeyParams,
   GetPublicKeyParams,
+  PrivateKeyToBytesParams,
+  PublicKeyToBytesParams,
   SignParams,
   VerifyParams,
 } from '../types/params-direct.js';
 
 import { CryptoAlgorithm } from './crypto-algorithm.js';
 import { Ed25519 } from '../primitives/ed25519.js';
+import { CryptoError, CryptoErrorCode } from '../crypto-error.js';
 import { isOkpPrivateJwk, isOkpPublicJwk } from '../jose/jwk.js';
 
 /**
@@ -33,12 +39,67 @@ export interface EdDsaGenerateKeyParams extends GenerateKeyParams {
  * of signatures.
  *
  * This class is typically accessed through implementations that extend the
- * {@link CryptoApi | `CryptoApi`} interface.
+ * {@link DsaApi | `DsaApi`} interface.
  */
 export class EdDsaAlgorithm extends CryptoAlgorithm
   implements AsymmetricKeyGenerator<EdDsaGenerateKeyParams, Jwk, GetPublicKeyParams>,
+             KeyConverter, AsymmetricKeyConverter,
              Signer<SignParams, VerifyParams> {
 
+  /**
+   * Converts a private key from a byte array to JWK format, setting the `alg` property to
+   * `'EdDSA'`.
+   *
+   * @param params - The parameters for the private key conversion.
+   * @param params.algorithm - The EdDSA algorithm identifier (`'Ed25519'`).
+   * @param params.privateKeyBytes - The raw private key as a Uint8Array.
+   *
+   * @returns A Promise that resolves to the private key in JWK format.
+   */
+  public async bytesToPrivateKey({ algorithm, privateKeyBytes }:
+    BytesToPrivateKeyParams & { algorithm: 'Ed25519' }
+  ): Promise<Jwk> {
+    switch (algorithm) {
+
+      case 'Ed25519': {
+        const privateKey = await Ed25519.bytesToPrivateKey({ privateKeyBytes });
+        privateKey.alg = 'EdDSA';
+        return privateKey;
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Algorithm not supported: ${algorithm}`);
+      }
+    }
+  }
+
+  /**
+   * Converts a public key from a byte array to JWK format, setting the `alg` property to
+   * `'EdDSA'`.
+   *
+   * @param params - The parameters for the public key conversion.
+   * @param params.algorithm - The EdDSA algorithm identifier (`'Ed25519'`).
+   * @param params.publicKeyBytes - The raw public key as a Uint8Array.
+   *
+   * @returns A Promise that resolves to the public key in JWK format.
+   */
+  public async bytesToPublicKey({ algorithm, publicKeyBytes }:
+    BytesToPublicKeyParams & { algorithm: 'Ed25519' }
+  ): Promise<Jwk> {
+    switch (algorithm) {
+
+      case 'Ed25519': {
+        const publicKey = await Ed25519.bytesToPublicKey({ publicKeyBytes });
+        publicKey.alg = 'EdDSA';
+        return publicKey;
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Algorithm not supported: ${algorithm}`);
+      }
+    }
+  }
+
   /**
    * Derives the public key in JWK format from a given private key.
    *
@@ -240,4 +301,50 @@ export class EdDsaAlgorithm extends CryptoAlgorithm
       }
     }
   }
+
+  /**
+   * Converts a private key from JWK format to a byte array.
+   *
+   * @param params - The parameters for the private key conversion.
+   * @param params.privateKey - The private key in JWK format.
+   *
+   * @returns A Promise that resolves to the private key as a Uint8Array.
+   */
+  public async privateKeyToBytes({ privateKey }:
+    PrivateKeyToBytesParams
+  ): Promise<Uint8Array> {
+    switch (privateKey.crv) {
+
+      case 'Ed25519': {
+        return await Ed25519.privateKeyToBytes({ privateKey });
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Curve not supported: ${privateKey.crv}`);
+      }
+    }
+  }
+
+  /**
+   * Converts a public key from JWK format to a byte array.
+   *
+   * @param params - The parameters for the public key conversion.
+   * @param params.publicKey - The public key in JWK format.
+   *
+   * @returns A Promise that resolves to the public key as a Uint8Array.
+   */
+  public async publicKeyToBytes({ publicKey }:
+    PublicKeyToBytesParams
+  ): Promise<Uint8Array> {
+    switch (publicKey.crv) {
+
+      case 'Ed25519': {
+        return await Ed25519.publicKeyToBytes({ publicKey });
+      }
+
+      default: {
+        throw new CryptoError(CryptoErrorCode.AlgorithmNotSupported, `Curve not supported: ${publicKey.crv}`);
+      }
+    }
+  }
 }

package/src/algorithms/hkdf.ts

@@ -0,0 +1,54 @@
+import type { DeriveKeyBytesParams } from '../types/params-direct.js';
+import type { HkdfParams } from '../primitives/hkdf.js';
+import type { KeyBytesDeriver } from '../types/key-deriver.js';
+
+import { CryptoAlgorithm } from './crypto-algorithm.js';
+import { Hkdf } from '../primitives/hkdf.js';
+
+/**
+ * The `HkdfDeriveKeyBytesParams` interface defines the algorithm-specific parameters that should be
+ * passed into the `deriveKeyBytes()` method when using the HKDF algorithm.
+ */
+export interface HkdfDeriveKeyBytesParams extends DeriveKeyBytesParams {
+  /** Specifies the algorithm variant for HKDF key derivation.
+   * The value determines the hash function that will be used and must be one of the following:
+   * - `"HKDF-256"`: HKDF with SHA-256.
+   * - `"HKDF-384"`: HKDF with SHA-384.
+   * - `"HKDF-512"`: HKDF with SHA-512.
+   */
+  algorithm: 'HKDF-256' | 'HKDF-384' | 'HKDF-512';
+}
+
+/**
+ * The `HkdfAlgorithm` class provides a concrete implementation for HKDF key derivation. It wraps
+ * the {@link Hkdf} primitive and maps JOSE algorithm names to hash functions.
+ */
+export class HkdfAlgorithm extends CryptoAlgorithm
+  implements KeyBytesDeriver<HkdfDeriveKeyBytesParams, Uint8Array> {
+
+  /**
+   * Derives a cryptographic byte array using HKDF.
+   *
+   * @param params - The parameters for the key derivation operation.
+   * @param params.algorithm - The HKDF algorithm variant (e.g., `'HKDF-256'`).
+   * @param params.baseKeyBytes - The input key material.
+   * @param params.length - The desired length of the output in bits.
+   *
+   * @returns A Promise that resolves to the derived key bytes.
+   */
+  public async deriveKeyBytes({ algorithm, ...params }:
+    HkdfDeriveKeyBytesParams & Omit<HkdfParams, 'hash'>
+  ): Promise<Uint8Array> {
+    // Map algorithm name to hash function.
+    const hash = {
+      'HKDF-256' : 'SHA-256' as const,
+      'HKDF-384' : 'SHA-384' as const,
+      'HKDF-512' : 'SHA-512' as const
+    }[algorithm];
+
+    // Derive a cryptographic byte array using HKDF.
+    const derivedKeyBytes = await Hkdf.deriveKeyBytes({ ...params, hash });
+
+    return derivedKeyBytes;
+  }
+}

package/src/algorithms/pbkdf2.ts

@@ -0,0 +1,57 @@
+import type { DeriveKeyBytesParams } from '../types/params-direct.js';
+import type { KeyBytesDeriver } from '../types/key-deriver.js';
+import type { Pbkdf2Params } from '../primitives/pbkdf2.js';
+
+import { CryptoAlgorithm } from './crypto-algorithm.js';
+import { Pbkdf2 } from '../primitives/pbkdf2.js';
+
+/**
+ * The `Pbkdf2DeriveKeyBytesParams` interface defines the algorithm-specific parameters that
+ * should be passed into the `deriveKeyBytes()` method when using the PBKDF2 algorithm.
+ */
+export interface Pbkdf2DeriveKeyBytesParams extends DeriveKeyBytesParams {
+  /** Specifies the algorithm variant for PBKDF2 key derivation.
+   * The value determines the hash function that will be used and must be one of the following:
+   * - `"PBES2-HS256+A128KW"`: PBKDF2 with HMAC SHA-256 and A128KW key wrapping.
+   * - `"PBES2-HS384+A192KW"`: PBKDF2 with HMAC SHA-384 and A192KW key wrapping.
+   * - `"PBES2-HS512+A256KW"`: PBKDF2 with HMAC SHA-512 and A256KW key wrapping.
+   */
+  algorithm: 'PBES2-HS256+A128KW' | 'PBES2-HS384+A192KW' | 'PBES2-HS512+A256KW';
+}
+
+/**
+ * The `Pbkdf2Algorithm` class provides a concrete implementation for PBKDF2 key derivation. It
+ * wraps the {@link Pbkdf2} primitive and maps PBES2 JOSE algorithm names to hash functions.
+ */
+export class Pbkdf2Algorithm extends CryptoAlgorithm
+  implements KeyBytesDeriver<Pbkdf2DeriveKeyBytesParams, Uint8Array> {
+
+  /**
+   * Derives a cryptographic byte array using PBKDF2.
+   *
+   * @param params - The parameters for the key derivation operation.
+   * @param params.algorithm - The PBES2 algorithm variant (e.g., `'PBES2-HS512+A256KW'`).
+   * @param params.baseKeyBytes - The password or passphrase as bytes.
+   * @param params.length - The desired length of the output in bits.
+   *
+   * @returns A Promise that resolves to the derived key bytes.
+   */
+  public async deriveKeyBytes({ algorithm, ...params }:
+    Pbkdf2DeriveKeyBytesParams & Omit<Pbkdf2Params, 'hash'>
+  ): Promise<Uint8Array> {
+    // Extract the hash function component of the `algorithm` parameter.
+    const [, hashFunction] = algorithm.split(/[-+]/);
+
+    // Map from JOSE algorithm name to "SHA" hash function identifier.
+    const hash = {
+      'HS256' : 'SHA-256' as const,
+      'HS384' : 'SHA-384' as const,
+      'HS512' : 'SHA-512' as const
+    }[hashFunction]!;
+
+    // Derive a cryptographic byte array using PBKDF2.
+    const derivedKeyBytes = await Pbkdf2.deriveKeyBytes({ ...params, hash });
+
+    return derivedKeyBytes;
+  }
+}

package/src/algorithms/sha-2.ts

@@ -22,7 +22,7 @@ export interface Sha2DigestParams extends DigestParams {
  * of the hash function and arbitrary data as input and returns the hash digest of the data.
  *
  * This class is typically accessed through implementations that extend the
- * {@link CryptoApi | `CryptoApi`} interface.
+ * {@link DsaApi | `DsaApi`} interface.
  */
 export class Sha2Algorithm extends CryptoAlgorithm
   implements Hasher<Sha2DigestParams> {