@gjsify/webcrypto 0.1.0

package/lib/esm/subtle.js

@@ -0,0 +1,607 @@
+import {
+  CryptoKey
+} from "./crypto-key.js";
+import {
+  normalizeAlgorithm,
+  toNodeHashName,
+  toNodeCurveName,
+  hashSize,
+  validateUsages,
+  checkUsage,
+  base64urlEncode,
+  base64urlDecode,
+  toUint8Array
+} from "./util.js";
+let _cryptoLoaded = false;
+let _createHash;
+let _createHmac;
+let _createCipheriv;
+let _createDecipheriv;
+let _createSign;
+let _createVerify;
+let _pbkdf2Sync;
+let _hkdfSync;
+let _createECDH;
+let _randomBytes;
+let _publicEncrypt;
+let _privateDecrypt;
+let _createPublicKey;
+let _createPrivateKey;
+let _ecdsaSign;
+let _ecdsaVerify;
+let _rsaPssSign;
+let _rsaPssVerify;
+let _rsaOaepEncrypt;
+let _rsaOaepDecrypt;
+async function loadCrypto() {
+  if (_cryptoLoaded) return;
+  const crypto = await import("crypto");
+  _createHash = crypto.createHash;
+  _createHmac = crypto.createHmac;
+  _createCipheriv = crypto.createCipheriv;
+  _createDecipheriv = crypto.createDecipheriv;
+  _createSign = crypto.createSign;
+  _createVerify = crypto.createVerify;
+  _pbkdf2Sync = crypto.pbkdf2Sync;
+  _hkdfSync = crypto.hkdfSync;
+  _createECDH = crypto.createECDH;
+  _randomBytes = crypto.randomBytes;
+  _publicEncrypt = crypto.publicEncrypt;
+  _privateDecrypt = crypto.privateDecrypt;
+  _createPublicKey = crypto.createPublicKey;
+  _createPrivateKey = crypto.createPrivateKey;
+  _ecdsaSign = crypto.ecdsaSign;
+  _ecdsaVerify = crypto.ecdsaVerify;
+  _rsaPssSign = crypto.rsaPssSign;
+  _rsaPssVerify = crypto.rsaPssVerify;
+  _rsaOaepEncrypt = crypto.rsaOaepEncrypt;
+  _rsaOaepDecrypt = crypto.rsaOaepDecrypt;
+  _cryptoLoaded = true;
+}
+const cryptoReady = loadCrypto();
+function ensureCrypto() {
+  if (!_cryptoLoaded) {
+    throw new Error("crypto not yet loaded. Ensure module initialization is complete.");
+  }
+}
+class SubtleCrypto {
+  // ==================== digest ====================
+  async digest(algorithm, data) {
+    await cryptoReady;
+    const alg = normalizeAlgorithm(algorithm);
+    const nodeName = toNodeHashName(alg.name);
+    const bytes = toUint8Array(data);
+    const hash = _createHash(nodeName);
+    hash.update(bytes);
+    const result = hash.digest();
+    return result.buffer.slice(result.byteOffset, result.byteOffset + result.byteLength);
+  }
+  // ==================== generateKey ====================
+  async generateKey(algorithm, extractable, keyUsages) {
+    await cryptoReady;
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    switch (name) {
+      case "AES-CBC":
+      case "AES-CTR":
+      case "AES-GCM": {
+        const length = algorithm.length;
+        if (![128, 192, 256].includes(length)) {
+          throw new DOMException(`Invalid AES key length: ${length}`, "OperationError");
+        }
+        validateUsages(keyUsages, ["encrypt", "decrypt", "wrapKey", "unwrapKey"]);
+        const keyData = _randomBytes(length / 8);
+        return new CryptoKey("secret", extractable, { name: alg.name, length }, keyUsages, new Uint8Array(keyData));
+      }
+      case "HMAC": {
+        const hmacParams = algorithm;
+        const hashAlg = normalizeAlgorithm(hmacParams.hash);
+        const length = hmacParams.length || hashSize(hashAlg.name) * 8;
+        validateUsages(keyUsages, ["sign", "verify"]);
+        const keyData = _randomBytes(Math.ceil(length / 8));
+        return new CryptoKey("secret", extractable, { name: "HMAC", hash: { name: hashAlg.name }, length }, keyUsages, new Uint8Array(keyData));
+      }
+      case "ECDH": {
+        const namedCurve = algorithm.namedCurve;
+        const nodeCurve = toNodeCurveName(namedCurve);
+        validateUsages(keyUsages, ["deriveKey", "deriveBits"]);
+        const ecdh = _createECDH(nodeCurve);
+        ecdh.generateKeys();
+        const pubBytes = new Uint8Array(ecdh.getPublicKey());
+        const privBytes = new Uint8Array(ecdh.getPrivateKey());
+        const pubKey = new CryptoKey("public", true, { name: "ECDH", namedCurve }, [], pubBytes);
+        const privKey = new CryptoKey("private", extractable, { name: "ECDH", namedCurve }, keyUsages, { pub: pubBytes, priv: privBytes });
+        return { publicKey: pubKey, privateKey: privKey };
+      }
+      case "ECDSA": {
+        const namedCurve = algorithm.namedCurve;
+        const nodeCurve = toNodeCurveName(namedCurve);
+        validateUsages(keyUsages, ["sign", "verify"]);
+        const ecdh = _createECDH(nodeCurve);
+        ecdh.generateKeys();
+        const pubBytes = new Uint8Array(ecdh.getPublicKey());
+        const privBytes = new Uint8Array(ecdh.getPrivateKey());
+        const pubKey = new CryptoKey("public", true, { name: "ECDSA", namedCurve }, ["verify"], pubBytes);
+        const privKey = new CryptoKey("private", extractable, { name: "ECDSA", namedCurve }, ["sign"], { pub: pubBytes, priv: privBytes });
+        return { publicKey: pubKey, privateKey: privKey };
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  // ==================== importKey ====================
+  async importKey(format, keyData, algorithm, extractable, keyUsages) {
+    await cryptoReady;
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    switch (name) {
+      case "AES-CBC":
+      case "AES-CTR":
+      case "AES-GCM": {
+        if (format === "raw") {
+          const bytes = toUint8Array(keyData);
+          if (![16, 24, 32].includes(bytes.length)) {
+            throw new DOMException(`Invalid AES key length: ${bytes.length * 8}`, "DataError");
+          }
+          validateUsages(keyUsages, ["encrypt", "decrypt", "wrapKey", "unwrapKey"]);
+          return new CryptoKey("secret", extractable, { name: alg.name, length: bytes.length * 8 }, keyUsages, new Uint8Array(bytes));
+        }
+        if (format === "jwk") {
+          const jwk = keyData;
+          if (jwk.kty !== "oct") throw new DOMException('JWK kty must be "oct"', "DataError");
+          const bytes = base64urlDecode(jwk.k);
+          if (![16, 24, 32].includes(bytes.length)) {
+            throw new DOMException(`Invalid AES key length: ${bytes.length * 8}`, "DataError");
+          }
+          validateUsages(keyUsages, ["encrypt", "decrypt", "wrapKey", "unwrapKey"]);
+          return new CryptoKey("secret", extractable, { name: alg.name, length: bytes.length * 8 }, keyUsages, bytes);
+        }
+        throw new DOMException(`Unsupported format: ${format}`, "NotSupportedError");
+      }
+      case "HMAC": {
+        const hmacParams = algorithm;
+        const hashAlg = normalizeAlgorithm(hmacParams.hash);
+        if (format === "raw") {
+          const bytes = toUint8Array(keyData);
+          validateUsages(keyUsages, ["sign", "verify"]);
+          return new CryptoKey("secret", extractable, { name: "HMAC", hash: { name: hashAlg.name }, length: bytes.length * 8 }, keyUsages, new Uint8Array(bytes));
+        }
+        if (format === "jwk") {
+          const jwk = keyData;
+          if (jwk.kty !== "oct") throw new DOMException('JWK kty must be "oct"', "DataError");
+          const bytes = base64urlDecode(jwk.k);
+          validateUsages(keyUsages, ["sign", "verify"]);
+          return new CryptoKey("secret", extractable, { name: "HMAC", hash: { name: hashAlg.name }, length: bytes.length * 8 }, keyUsages, bytes);
+        }
+        throw new DOMException(`Unsupported format: ${format}`, "NotSupportedError");
+      }
+      case "PBKDF2": {
+        if (format === "raw") {
+          const bytes = toUint8Array(keyData);
+          validateUsages(keyUsages, ["deriveKey", "deriveBits"]);
+          return new CryptoKey("secret", false, { name: "PBKDF2" }, keyUsages, new Uint8Array(bytes));
+        }
+        throw new DOMException(`Unsupported format: ${format}`, "NotSupportedError");
+      }
+      case "HKDF": {
+        if (format === "raw") {
+          const bytes = toUint8Array(keyData);
+          validateUsages(keyUsages, ["deriveKey", "deriveBits"]);
+          return new CryptoKey("secret", false, { name: "HKDF" }, keyUsages, new Uint8Array(bytes));
+        }
+        throw new DOMException(`Unsupported format: ${format}`, "NotSupportedError");
+      }
+      case "ECDH":
+      case "ECDSA": {
+        const namedCurve = algorithm.namedCurve;
+        if (format === "raw") {
+          const bytes = toUint8Array(keyData);
+          if (name === "ECDH") {
+            if (keyUsages.length > 0) {
+              validateUsages(keyUsages, ["deriveKey", "deriveBits"]);
+            }
+          } else {
+            validateUsages(keyUsages, ["verify"]);
+          }
+          return new CryptoKey("public", extractable, { name: alg.name, namedCurve }, keyUsages, new Uint8Array(bytes));
+        }
+        if (format === "jwk") {
+          const jwk = keyData;
+          if (jwk.kty !== "EC") throw new DOMException('JWK kty must be "EC"', "DataError");
+          if (jwk.d) {
+            const privBytes = base64urlDecode(jwk.d);
+            const xBytes = base64urlDecode(jwk.x);
+            const yBytes = base64urlDecode(jwk.y);
+            const pubBytes = new Uint8Array(1 + xBytes.length + yBytes.length);
+            pubBytes[0] = 4;
+            pubBytes.set(xBytes, 1);
+            pubBytes.set(yBytes, 1 + xBytes.length);
+            const allowedUsages = name === "ECDH" ? ["deriveKey", "deriveBits"] : ["sign"];
+            validateUsages(keyUsages, allowedUsages);
+            return new CryptoKey("private", extractable, { name: alg.name, namedCurve }, keyUsages, { pub: pubBytes, priv: privBytes });
+          } else {
+            const xBytes = base64urlDecode(jwk.x);
+            const yBytes = base64urlDecode(jwk.y);
+            const pubBytes = new Uint8Array(1 + xBytes.length + yBytes.length);
+            pubBytes[0] = 4;
+            pubBytes.set(xBytes, 1);
+            pubBytes.set(yBytes, 1 + xBytes.length);
+            if (name === "ECDH") {
+              if (keyUsages.length > 0) {
+                validateUsages(keyUsages, ["deriveKey", "deriveBits"]);
+              }
+            } else {
+              validateUsages(keyUsages, ["verify"]);
+            }
+            return new CryptoKey("public", extractable, { name: alg.name, namedCurve }, keyUsages, pubBytes);
+          }
+        }
+        throw new DOMException(`Unsupported format: ${format}`, "NotSupportedError");
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  // ==================== exportKey ====================
+  async exportKey(format, key) {
+    if (!key.extractable) {
+      throw new DOMException("Key is not extractable", "InvalidAccessError");
+    }
+    const name = key.algorithm.name.toUpperCase();
+    if (format === "raw") {
+      if (key.type === "secret") {
+        const handle = key._handle;
+        return handle.buffer.slice(handle.byteOffset, handle.byteOffset + handle.byteLength);
+      }
+      if (key.type === "public" && (name === "ECDH" || name === "ECDSA")) {
+        const handle = key._handle;
+        return handle.buffer.slice(handle.byteOffset, handle.byteOffset + handle.byteLength);
+      }
+      throw new DOMException("Cannot export in raw format", "InvalidAccessError");
+    }
+    if (format === "jwk") {
+      if (key.type === "secret") {
+        const handle = key._handle;
+        const jwk = {
+          kty: "oct",
+          k: base64urlEncode(handle),
+          ext: key.extractable,
+          key_ops: [...key.usages]
+        };
+        if (name.startsWith("AES-")) {
+          jwk.alg = `A${key.algorithm.length}${name.replace("AES-", "")}`;
+        } else if (name === "HMAC") {
+          const hashName = key.algorithm.hash.name;
+          jwk.alg = `HS${hashName.replace("SHA-", "")}`;
+        }
+        return jwk;
+      }
+      if ((name === "ECDH" || name === "ECDSA") && (key.type === "public" || key.type === "private")) {
+        const namedCurve = key.algorithm.namedCurve;
+        let pubBytes;
+        if (key.type === "public") {
+          pubBytes = key._handle;
+        } else {
+          pubBytes = key._handle.pub;
+        }
+        const coordLen = (pubBytes.length - 1) / 2;
+        const x = pubBytes.slice(1, 1 + coordLen);
+        const y = pubBytes.slice(1 + coordLen);
+        const jwk = {
+          kty: "EC",
+          crv: namedCurve,
+          x: base64urlEncode(x),
+          y: base64urlEncode(y),
+          ext: key.extractable,
+          key_ops: [...key.usages]
+        };
+        if (key.type === "private") {
+          jwk.d = base64urlEncode(key._handle.priv);
+        }
+        return jwk;
+      }
+      throw new DOMException(`JWK export not supported for ${name} ${key.type}`, "NotSupportedError");
+    }
+    throw new DOMException(`Unsupported export format: ${format}`, "NotSupportedError");
+  }
+  // ==================== encrypt ====================
+  async encrypt(algorithm, key, data) {
+    await cryptoReady;
+    checkUsage(key, "encrypt");
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    const plaintext = toUint8Array(data);
+    switch (name) {
+      case "AES-CBC": {
+        const iv = toUint8Array(algorithm.iv);
+        const keyBytes = key._handle;
+        const keyLen = keyBytes.length * 8;
+        const cipher = _createCipheriv(`aes-${keyLen}-cbc`, keyBytes, iv);
+        const part1 = cipher.update(plaintext);
+        const part2 = cipher.final();
+        const result = new Uint8Array(part1.length + part2.length);
+        result.set(new Uint8Array(part1), 0);
+        result.set(new Uint8Array(part2), part1.length);
+        return result.buffer;
+      }
+      case "AES-CTR": {
+        const counter = toUint8Array(algorithm.counter);
+        const keyBytes = key._handle;
+        const keyLen = keyBytes.length * 8;
+        const cipher = _createCipheriv(`aes-${keyLen}-ctr`, keyBytes, counter);
+        const part1 = cipher.update(plaintext);
+        const part2 = cipher.final();
+        const result = new Uint8Array(part1.length + part2.length);
+        result.set(new Uint8Array(part1), 0);
+        result.set(new Uint8Array(part2), part1.length);
+        return result.buffer;
+      }
+      case "AES-GCM": {
+        const gcmParams = algorithm;
+        const iv = toUint8Array(gcmParams.iv);
+        const aad = gcmParams.additionalData ? toUint8Array(gcmParams.additionalData) : void 0;
+        const keyBytes = key._handle;
+        const keyLen = keyBytes.length * 8;
+        const cipher = _createCipheriv(`aes-${keyLen}-gcm`, keyBytes, iv);
+        if (aad) cipher.setAAD(aad);
+        const part1 = cipher.update(plaintext);
+        const part2 = cipher.final();
+        const tag = cipher.getAuthTag();
+        const result = new Uint8Array(part1.length + part2.length + tag.length);
+        result.set(new Uint8Array(part1), 0);
+        result.set(new Uint8Array(part2), part1.length);
+        result.set(new Uint8Array(tag), part1.length + part2.length);
+        return result.buffer;
+      }
+      case "RSA-OAEP": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const handle = key._handle;
+        const rsaOaepParams = algorithm;
+        const label = rsaOaepParams.label ? toUint8Array(rsaOaepParams.label) : void 0;
+        const ct = _rsaOaepEncrypt(nodeHash, handle.pem, plaintext, label);
+        return ct.buffer.slice(ct.byteOffset, ct.byteOffset + ct.byteLength);
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  // ==================== decrypt ====================
+  async decrypt(algorithm, key, data) {
+    await cryptoReady;
+    checkUsage(key, "decrypt");
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    const ciphertext = toUint8Array(data);
+    switch (name) {
+      case "AES-CBC": {
+        const iv = toUint8Array(algorithm.iv);
+        const keyBytes = key._handle;
+        const keyLen = keyBytes.length * 8;
+        const decipher = _createDecipheriv(`aes-${keyLen}-cbc`, keyBytes, iv);
+        const part1 = decipher.update(ciphertext);
+        const part2 = decipher.final();
+        const result = new Uint8Array(part1.length + part2.length);
+        result.set(new Uint8Array(part1), 0);
+        result.set(new Uint8Array(part2), part1.length);
+        return result.buffer;
+      }
+      case "AES-CTR": {
+        const counter = toUint8Array(algorithm.counter);
+        const keyBytes = key._handle;
+        const keyLen = keyBytes.length * 8;
+        const decipher = _createDecipheriv(`aes-${keyLen}-ctr`, keyBytes, counter);
+        const part1 = decipher.update(ciphertext);
+        const part2 = decipher.final();
+        const result = new Uint8Array(part1.length + part2.length);
+        result.set(new Uint8Array(part1), 0);
+        result.set(new Uint8Array(part2), part1.length);
+        return result.buffer;
+      }
+      case "AES-GCM": {
+        const gcmParams = algorithm;
+        const iv = toUint8Array(gcmParams.iv);
+        const tagLength = (gcmParams.tagLength || 128) / 8;
+        const aad = gcmParams.additionalData ? toUint8Array(gcmParams.additionalData) : void 0;
+        const keyBytes = key._handle;
+        const keyLen = keyBytes.length * 8;
+        const actualCiphertext = ciphertext.slice(0, ciphertext.length - tagLength);
+        const tag = ciphertext.slice(ciphertext.length - tagLength);
+        const decipher = _createDecipheriv(`aes-${keyLen}-gcm`, keyBytes, iv);
+        decipher.setAuthTag(tag);
+        if (aad) decipher.setAAD(aad);
+        const part1 = decipher.update(actualCiphertext);
+        const part2 = decipher.final();
+        const result = new Uint8Array(part1.length + part2.length);
+        result.set(new Uint8Array(part1), 0);
+        result.set(new Uint8Array(part2), part1.length);
+        return result.buffer;
+      }
+      case "RSA-OAEP": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const handle = key._handle;
+        const rsaOaepParams = algorithm;
+        const label = rsaOaepParams.label ? toUint8Array(rsaOaepParams.label) : void 0;
+        const pt = _rsaOaepDecrypt(nodeHash, handle.pem, ciphertext, label);
+        return pt.buffer.slice(pt.byteOffset, pt.byteOffset + pt.byteLength);
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  // ==================== sign ====================
+  async sign(algorithm, key, data) {
+    await cryptoReady;
+    checkUsage(key, "sign");
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    const bytes = toUint8Array(data);
+    switch (name) {
+      case "HMAC": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const keyBytes = key._handle;
+        const hmac = _createHmac(nodeHash, keyBytes);
+        hmac.update(bytes);
+        const sig = hmac.digest();
+        return sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+      }
+      case "RSASSA-PKCS1-V1_5": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const handle = key._handle;
+        const signer = _createSign(nodeHash);
+        signer.update(bytes);
+        const sig = signer.sign(handle.pem);
+        return sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+      }
+      case "ECDSA": {
+        const ecdsaParams = algorithm;
+        const hashName = typeof ecdsaParams.hash === "string" ? ecdsaParams.hash : ecdsaParams.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const namedCurve = key.algorithm.namedCurve;
+        const handle = key._handle;
+        const sig = _ecdsaSign(nodeHash, handle.priv, bytes, namedCurve);
+        return sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+      }
+      case "RSA-PSS": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const handle = key._handle;
+        const saltLen = algorithm.saltLength ?? hashSize(hashName);
+        const sig = _rsaPssSign(nodeHash, handle.pem, bytes, saltLen);
+        return sig.buffer.slice(sig.byteOffset, sig.byteOffset + sig.byteLength);
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  // ==================== verify ====================
+  async verify(algorithm, key, signature, data) {
+    await cryptoReady;
+    checkUsage(key, "verify");
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    const bytes = toUint8Array(data);
+    const sig = toUint8Array(signature);
+    switch (name) {
+      case "HMAC": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const keyBytes = key._handle;
+        const hmac = _createHmac(nodeHash, keyBytes);
+        hmac.update(bytes);
+        const expected = new Uint8Array(hmac.digest());
+        if (expected.length !== sig.length) return false;
+        let diff = 0;
+        for (let i = 0; i < expected.length; i++) {
+          diff |= expected[i] ^ sig[i];
+        }
+        return diff === 0;
+      }
+      case "RSASSA-PKCS1-V1_5": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const handle = key._handle;
+        const verifier = _createVerify(nodeHash);
+        verifier.update(bytes);
+        return verifier.verify(handle.pem, sig);
+      }
+      case "ECDSA": {
+        const ecdsaParams = algorithm;
+        const hashName = typeof ecdsaParams.hash === "string" ? ecdsaParams.hash : ecdsaParams.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const namedCurve = key.algorithm.namedCurve;
+        const pubBytes = key._handle;
+        return _ecdsaVerify(nodeHash, pubBytes, sig, bytes, namedCurve);
+      }
+      case "RSA-PSS": {
+        const hashName = key.algorithm.hash.name;
+        const nodeHash = toNodeHashName(hashName);
+        const handle = key._handle;
+        const saltLen = algorithm.saltLength ?? hashSize(hashName);
+        return _rsaPssVerify(nodeHash, handle.pem, sig, bytes, saltLen);
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  // ==================== deriveBits ====================
+  /** Internal deriveBits without usage check (used by deriveKey) */
+  async _deriveBitsInternal(algorithm, baseKey, length) {
+    await cryptoReady;
+    const alg = normalizeAlgorithm(algorithm);
+    const name = alg.name.toUpperCase();
+    switch (name) {
+      case "PBKDF2": {
+        const pbkdf2Params = algorithm;
+        const hashName = toNodeHashName(normalizeAlgorithm(pbkdf2Params.hash).name);
+        const salt = toUint8Array(pbkdf2Params.salt);
+        const iterations = pbkdf2Params.iterations;
+        const keyBytes = baseKey._handle;
+        const result = _pbkdf2Sync(keyBytes, salt, iterations, length / 8, hashName);
+        return result.buffer.slice(result.byteOffset, result.byteOffset + result.byteLength);
+      }
+      case "HKDF": {
+        const hkdfParams = algorithm;
+        const hashName = toNodeHashName(normalizeAlgorithm(hkdfParams.hash).name);
+        const salt = toUint8Array(hkdfParams.salt);
+        const info = toUint8Array(hkdfParams.info);
+        const keyBytes = baseKey._handle;
+        const result = _hkdfSync(hashName, keyBytes, salt, info, length / 8);
+        return result;
+      }
+      case "ECDH": {
+        const ecdhParams = algorithm;
+        const publicKey = ecdhParams.public;
+        const namedCurve = baseKey.algorithm.namedCurve;
+        const nodeCurve = toNodeCurveName(namedCurve);
+        const ecdh = _createECDH(nodeCurve);
+        const privHandle = baseKey._handle;
+        ecdh.setPrivateKey(privHandle.priv);
+        const pubBytes = publicKey._handle instanceof Uint8Array ? publicKey._handle : publicKey._handle.pub;
+        const secret = ecdh.computeSecret(pubBytes);
+        const secretBytes = new Uint8Array(secret);
+        if (length) {
+          return secretBytes.buffer.slice(0, length / 8);
+        }
+        return secretBytes.buffer.slice(secretBytes.byteOffset, secretBytes.byteOffset + secretBytes.byteLength);
+      }
+      default:
+        throw new DOMException(`Unsupported algorithm: ${alg.name}`, "NotSupportedError");
+    }
+  }
+  async deriveBits(algorithm, baseKey, length) {
+    checkUsage(baseKey, "deriveBits");
+    return this._deriveBitsInternal(algorithm, baseKey, length);
+  }
+  // ==================== deriveKey ====================
+  async deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+    checkUsage(baseKey, "deriveKey");
+    const derivedAlg = normalizeAlgorithm(derivedKeyAlgorithm);
+    let length;
+    const dName = derivedAlg.name.toUpperCase();
+    if (dName === "AES-CBC" || dName === "AES-CTR" || dName === "AES-GCM") {
+      length = derivedKeyAlgorithm.length;
+    } else if (dName === "HMAC") {
+      const hmacParams = derivedKeyAlgorithm;
+      const hashAlg = normalizeAlgorithm(hmacParams.hash);
+      length = hmacParams.length || hashSize(hashAlg.name) * 8;
+    } else {
+      throw new DOMException(`Unsupported derived key algorithm: ${derivedAlg.name}`, "NotSupportedError");
+    }
+    const bits = await this._deriveBitsInternal(algorithm, baseKey, length);
+    return this.importKey("raw", bits, derivedKeyAlgorithm, extractable, keyUsages);
+  }
+  // ==================== wrapKey / unwrapKey (stubs) ====================
+  async wrapKey(_format, _key, _wrappingKey, _wrapAlgorithm) {
+    throw new DOMException("wrapKey not yet implemented", "NotSupportedError");
+  }
+  async unwrapKey(_format, _wrappedKey, _unwrappingKey, _unwrapAlgorithm, _unwrappedKeyAlgorithm, _extractable, _keyUsages) {
+    throw new DOMException("unwrapKey not yet implemented", "NotSupportedError");
+  }
+}
+export {
+  SubtleCrypto
+};