@opentdf/sdk 0.9.0-beta.91 → 0.9.0-beta.93

package/dist/web/tdf3/src/crypto/index.js

@@ -10,8 +10,12 @@ import { ConfigurationError, DecryptError } from '../../../src/errors.js';
 import { formatAsPem, removePemFormatting } from './crypto-utils.js';
 import { encodeArrayBuffer as hexEncode } from '../../../src/encodings/hex.js';
 import { decodeArrayBuffer as base64Decode } from '../../../src/encodings/base64.js';
+import { exportSPKI, importX509 } from 'jose';
+import { toJwsAlg, guessAlgorithmName, guessCurveName, } from '../../../src/crypto/pemPublicToCrypto.js';
+import { keySplit, keyMerge } from '../utils/keysplit.js';
 // Used to pass into native crypto functions
-const METHODS = ['encrypt', 'decrypt'];
+const ENC_DEC_METHODS = ['encrypt', 'decrypt'];
+const SIGN_VERIFY_METHODS = ['sign', 'verify'];
 export const isSupported = typeof globalThis?.crypto !== 'undefined';
 export const method = 'http://www.w3.org/2001/04/xmlenc#aes256-cbc';
 export const name = 'BrowserNativeCryptoService';
@@ -46,11 +50,93 @@ export function rsaPkcs1Sha256(modulusLength = MIN_ASYMMETRIC_KEY_SIZE_BITS) {
     };
 }
 /**
- * Generate a random hex key
- * @return New key as a hex string
+ * Generate a random symmetric key (opaque).
+ * @param length - Key length in bytes (default 32 for AES-256)
+ * @return Opaque symmetric key
  */
 export async function generateKey(length) {
-    return randomBytesAsHex(length || 32);
+    const keyBytes = await randomBytes(length || 32);
+    return wrapSymmetricKey(keyBytes);
+}
+// ============================================================
+// Opaque Key Wrapping/Unwrapping Helpers
+// ============================================================
+/**
+ * Wrap a CryptoKey as an opaque PublicKey.
+ * @internal
+ */
+function wrapPublicKey(key, algorithm) {
+    const result = {
+        _brand: 'PublicKey',
+        algorithm,
+        _internal: key,
+    };
+    if (algorithm.startsWith('rsa:')) {
+        result.modulusBits = parseInt(algorithm.split(':')[1], 10);
+    }
+    else if (algorithm.startsWith('ec:')) {
+        const curvePart = algorithm.split(':')[1];
+        result.curve =
+            curvePart === 'secp256r1'
+                ? 'P-256'
+                : curvePart === 'secp384r1'
+                    ? 'P-384'
+                    : curvePart === 'secp521r1'
+                        ? 'P-521'
+                        : undefined;
+    }
+    return result;
+}
+/**
+ * Wrap a CryptoKey as an opaque PrivateKey.
+ * @internal
+ */
+function wrapPrivateKey(key, algorithm) {
+    const result = {
+        _brand: 'PrivateKey',
+        algorithm,
+        _internal: key,
+    };
+    if (algorithm.startsWith('rsa:')) {
+        result.modulusBits = parseInt(algorithm.split(':')[1], 10);
+    }
+    else if (algorithm.startsWith('ec:')) {
+        const curvePart = algorithm.split(':')[1];
+        result.curve =
+            curvePart === 'secp256r1'
+                ? 'P-256'
+                : curvePart === 'secp384r1'
+                    ? 'P-384'
+                    : curvePart === 'secp521r1'
+                        ? 'P-521'
+                        : undefined;
+    }
+    return result;
+}
+/**
+ * Unwrap an opaque key to get the internal CryptoKey.
+ * @internal
+ */
+function unwrapKey(key) {
+    return key._internal;
+}
+/**
+ * Wrap raw key bytes as an opaque SymmetricKey.
+ * @internal
+ */
+function wrapSymmetricKey(keyBytes) {
+    return {
+        _brand: 'SymmetricKey',
+        length: keyBytes.length * 8, // bits
+        _internal: keyBytes,
+    };
+}
+/**
+ * Unwrap an opaque SymmetricKey to get raw bytes.
+ * @internal
+ */
+function unwrapSymmetricKey(key) {
+    return key._internal;
 }
 /**
  * Generate an RSA key pair
@@ -58,61 +144,60 @@ export async function generateKey(length) {
  * @param  size in bits
  */
 export async function generateKeyPair(size) {
-    const algoDomString = rsaOaepSha1(size || MIN_ASYMMETRIC_KEY_SIZE_BITS);
-    return crypto.subtle.generateKey(algoDomString, true, METHODS);
+    const keySize = size || MIN_ASYMMETRIC_KEY_SIZE_BITS;
+    const algoDomString = rsaOaepSha1(keySize);
+    const keyPair = await crypto.subtle.generateKey(algoDomString, true, ENC_DEC_METHODS);
+    // Map to supported algorithm sizes
+    let algorithm;
+    if (keySize === 2048) {
+        algorithm = 'rsa:2048';
+    }
+    else if (keySize === 4096) {
+        algorithm = 'rsa:4096';
+    }
+    else {
+        throw new ConfigurationError(`Unsupported RSA key size: ${keySize}. Only 2048 and 4096 are supported.`);
+    }
+    return {
+        publicKey: wrapPublicKey(keyPair.publicKey, algorithm),
+        privateKey: wrapPrivateKey(keyPair.privateKey, algorithm),
+    };
 }
 /**
  * Generate an RSA key pair suitable for signatures
  * @see    {@link https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey}
  */
 export async function generateSigningKeyPair() {
-    return crypto.subtle.generateKey({
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: 'SHA-256',
-        modulusLength: 2048,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-    }, true, ['sign', 'verify']);
-}
-export async function cryptoToPemPair(keysMaybe) {
-    const keys = keysMaybe;
-    if (!keys.privateKey || !keys.publicKey) {
-        // These are only ever generated here, so this should not happen
-        throw new Error('internal: invalid keys');
-    }
-    const [exPublic, exPrivate] = await Promise.all([
-        crypto.subtle.exportKey('spki', keys.publicKey),
-        crypto.subtle.exportKey('pkcs8', keys.privateKey),
-    ]);
+    const rsaParams = rsaPkcs1Sha256(2048);
+    const keyPair = await crypto.subtle.generateKey(rsaParams, true, SIGN_VERIFY_METHODS);
+    const algorithm = 'rsa:2048';
     return {
-        publicKey: formatAsPem(exPublic, 'PUBLIC KEY'),
-        privateKey: formatAsPem(exPrivate, 'PRIVATE KEY'),
+        publicKey: wrapPublicKey(keyPair.publicKey, algorithm),
+        privateKey: wrapPrivateKey(keyPair.privateKey, algorithm),
     };
 }
 /**
- * Encrypt using a public key
- * @param payload Payload to encrypt
- * @param publicKey PEM formatted public key
+ * Encrypt using a public key (RSA-OAEP).
+ * Accepts Binary or SymmetricKey for key wrapping.
+ * @param payload Payload to encrypt (Binary) or symmetric key to wrap (SymmetricKey)
+ * @param publicKey Opaque public key
  * @return Encrypted payload
  */
 export async function encryptWithPublicKey(payload, publicKey) {
-    console.assert(typeof payload === 'object');
-    console.assert(typeof publicKey === 'string');
-    const algoDomString = rsaOaepSha1();
-    // Web Crypto APIs don't work with PEM formatted strings
-    publicKey = removePemFormatting(publicKey);
-    const keyBuffer = base64Decode(publicKey);
-    const cryptoKey = await crypto.subtle.importKey('spki', keyBuffer, algoDomString, false, [
-        'encrypt',
-    ]);
-    const result = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, cryptoKey, payload.asArrayBuffer());
+    let payloadBuffer;
+    // Handle SymmetricKey unwrapping
+    if ('_brand' in payload && payload._brand === 'SymmetricKey') {
+        // Pass Uint8Array directly — Web Crypto respects byteOffset/byteLength on typed array views.
+        payloadBuffer = unwrapSymmetricKey(payload);
+    }
+    else {
+        // Binary payload
+        payloadBuffer = payload.asArrayBuffer();
+    }
+    const cryptoKey = unwrapKey(publicKey);
+    const result = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, cryptoKey, payloadBuffer);
     return Binary.fromArrayBuffer(result);
 }
-/**
- * Generate a 16-byte initialization vector
- */
-export async function generateInitializationVector(length) {
-    return randomBytesAsHex(length || 16);
-}
 export async function randomBytes(byteLength) {
     const r = new Uint8Array(byteLength);
     crypto.getRandomValues(r);
@@ -137,25 +222,20 @@ export async function randomBytesAsHex(length) {
 /**
  * Decrypt a public-key encrypted payload with a private key
  * @param  encryptedPayload  Payload to decrypt
- * @param  privateKey        PEM formatted private keynpmv
+ * @param  privateKey        Opaque private key
  * @return Decrypted payload
  */
 export async function decryptWithPrivateKey(encryptedPayload, privateKey) {
     console.assert(typeof encryptedPayload === 'object', 'encryptedPayload must be object');
-    console.assert(typeof privateKey === 'string', 'privateKey must be string');
-    const algoDomString = rsaOaepSha1();
-    // Web Crypto APIs don't work with PEM formatted strings
-    const keyDataString = removePemFormatting(privateKey);
-    const keyData = base64Decode(keyDataString);
-    const key = await crypto.subtle.importKey('pkcs8', keyData, algoDomString, false, ['decrypt']);
-    const payload = await crypto.subtle.decrypt({ name: 'RSA-OAEP' }, key, encryptedPayload.asArrayBuffer());
+    const cryptoKey = unwrapKey(privateKey);
+    const payload = await crypto.subtle.decrypt({ name: 'RSA-OAEP' }, cryptoKey, encryptedPayload.asArrayBuffer());
     const bufferView = new Uint8Array(payload);
     return Binary.fromArrayBuffer(bufferView.buffer);
 }
 /**
  * Decrypt content synchronously
  * @param payload The payload to decrypt
- * @param key     The encryption key
+ * @param key     The symmetric encryption key (opaque)
  * @param iv      The initialization vector
  * @param algorithm The algorithm to use for encryption
  * @param authTag The authentication tag for authenticated crypto.
@@ -177,9 +257,20 @@ async function _doEncrypt(payload, key, iv, algorithm) {
     console.assert(payload != null);
     console.assert(key != null);
     console.assert(iv != null);
-    const payloadBuffer = payload.asArrayBuffer();
+    // Handle both Binary and SymmetricKey payloads
+    let payloadBuffer;
+    if ('_brand' in payload && payload._brand === 'SymmetricKey') {
+        // Pass Uint8Array directly — Web Crypto respects byteOffset/byteLength on typed array views.
+        payloadBuffer = unwrapSymmetricKey(payload);
+    }
+    else {
+        // Binary payload
+        payloadBuffer = payload.asArrayBuffer();
+    }
     const algoDomString = getSymmetricAlgoDomString(iv, algorithm);
-    const importedKey = await _importKey(key, algoDomString);
+    // Unwrap symmetric key to get raw bytes
+    const keyBytes = unwrapSymmetricKey(key);
+    const importedKey = await _importKey(keyBytes, algoDomString);
     const encrypted = await crypto.subtle.encrypt(algoDomString, importedKey, payloadBuffer);
     if (algoDomString.name === 'AES-GCM') {
         return {
@@ -205,7 +296,9 @@ async function _doDecrypt(payload, key, iv, algorithm, authTag) {
         payloadBuffer = gcmPayload.buffer;
     }
     const algoDomString = getSymmetricAlgoDomString(iv, algorithm);
-    const importedKey = await _importKey(key, algoDomString);
+    // Unwrap symmetric key to get raw bytes
+    const keyBytes = unwrapSymmetricKey(key);
+    const importedKey = await _importKey(keyBytes, algoDomString);
     algoDomString.iv = iv.asArrayBuffer();
     const decrypted = await crypto.subtle
         .decrypt(algoDomString, importedKey, payloadBuffer)
@@ -218,8 +311,8 @@ async function _doDecrypt(payload, key, iv, algorithm, authTag) {
     });
     return { payload: Binary.fromArrayBuffer(decrypted) };
 }
-function _importKey(key, algorithm) {
-    return crypto.subtle.importKey('raw', key.asArrayBuffer(), algorithm, true, METHODS);
+function _importKey(keyBytes, algorithm) {
+    return crypto.subtle.importKey('raw', keyBytes, algorithm, true, ENC_DEC_METHODS);
 }
 /**
  * Get a DOMString representing the algorithm to use for a crypto
@@ -243,27 +336,6 @@ function getSymmetricAlgoDomString(iv, algorithm) {
  * @param  content  String content
  * @return Hex hash
  */
-export async function sha256(content) {
-    const buffer = new TextEncoder().encode(content);
-    const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
-    return hexEncode(hashBuffer);
-}
-/**
- * Create an HMAC SHA256 hash
- * @param  key     Key string
- * @param  content Content string
- * @return Hex hash
- */
-export async function hmac(key, content) {
-    const contentBuffer = new TextEncoder().encode(content);
-    const keyBuffer = hex2Ab(key);
-    const cryptoKey = await crypto.subtle.importKey('raw', keyBuffer, {
-        name: 'HMAC',
-        hash: { name: 'SHA-256' },
-    }, true, ['sign', 'verify']);
-    const hashBuffer = await crypto.subtle.sign('HMAC', cryptoKey, contentBuffer);
-    return hexEncode(hashBuffer);
-}
 /**
  * Create an ArrayBuffer from a hex string.
  * https://developers.google.com/web/updates/2012/06/How-to-convert-ArrayBuffer-to-and-from-String?hl=en
@@ -277,20 +349,694 @@ export function hex2Ab(hex) {
     }
     return buffer;
 }
+/**
+ * Get the Web Crypto algorithm parameters for a signing algorithm.
+ */
+function getSigningAlgorithmParams(algorithm) {
+    switch (algorithm) {
+        case 'RS256':
+            return {
+                importParams: { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' },
+                signParams: 'RSASSA-PKCS1-v1_5',
+            };
+        case 'ES256':
+            return {
+                importParams: { name: 'ECDSA', namedCurve: 'P-256' },
+                signParams: { name: 'ECDSA', hash: 'SHA-256' },
+            };
+        case 'ES384':
+            return {
+                importParams: { name: 'ECDSA', namedCurve: 'P-384' },
+                signParams: { name: 'ECDSA', hash: 'SHA-384' },
+            };
+        case 'ES512':
+            return {
+                importParams: { name: 'ECDSA', namedCurve: 'P-521' },
+                signParams: { name: 'ECDSA', hash: 'SHA-512' },
+            };
+        default:
+            throw new ConfigurationError(`Unsupported signing algorithm: ${algorithm}`);
+    }
+}
+/**
+ * Convert IEEE P1363 signature format (used by WebCrypto ECDSA) to DER format (used by JWT).
+ * RS256 signatures don't need conversion.
+ */
+function ieeeP1363ToDer(signature, algorithm) {
+    if (algorithm === 'RS256') {
+        return signature;
+    }
+    // IEEE P1363: r || s where each is padded to key size
+    const halfLen = signature.length / 2;
+    const r = signature.slice(0, halfLen);
+    const s = signature.slice(halfLen);
+    // Remove leading zeros but keep one if the high bit is set
+    const trimLeadingZeros = (arr) => {
+        let i = 0;
+        while (i < arr.length - 1 && arr[i] === 0)
+            i++;
+        return arr.slice(i);
+    };
+    let rTrimmed = trimLeadingZeros(r);
+    let sTrimmed = trimLeadingZeros(s);
+    // Add leading zero if high bit is set (to keep positive in DER)
+    if (rTrimmed[0] & 0x80) {
+        const padded = new Uint8Array(rTrimmed.length + 1);
+        padded.set(rTrimmed, 1);
+        rTrimmed = padded;
+    }
+    if (sTrimmed[0] & 0x80) {
+        const padded = new Uint8Array(sTrimmed.length + 1);
+        padded.set(sTrimmed, 1);
+        sTrimmed = padded;
+    }
+    // DER SEQUENCE: 0x30 [length] [r INTEGER] [s INTEGER]
+    // INTEGER: 0x02 [length] [value]
+    const rDer = new Uint8Array([0x02, rTrimmed.length, ...rTrimmed]);
+    const sDer = new Uint8Array([0x02, sTrimmed.length, ...sTrimmed]);
+    const seqLen = rDer.length + sDer.length;
+    // DER length: short-form for < 128, long-form (0x81 nn) for 128-255.
+    // ECDSA sequences never exceed 255 bytes for any supported curve.
+    const lenBytes = seqLen < 128 ? new Uint8Array([seqLen]) : new Uint8Array([0x81, seqLen]);
+    const result = new Uint8Array(1 + lenBytes.length + seqLen);
+    result[0] = 0x30;
+    result.set(lenBytes, 1);
+    result.set(rDer, 1 + lenBytes.length);
+    result.set(sDer, 1 + lenBytes.length + rDer.length);
+    return result;
+}
+/**
+ * Convert DER signature format (used by JWT) to IEEE P1363 format (used by WebCrypto ECDSA).
+ * RS256 signatures don't need conversion.
+ */
+function derToIeeeP1363(signature, algorithm) {
+    if (algorithm === 'RS256') {
+        return signature;
+    }
+    // Determine the expected component length based on algorithm
+    let componentLen;
+    switch (algorithm) {
+        case 'ES256':
+            componentLen = 32;
+            break;
+        case 'ES384':
+            componentLen = 48;
+            break;
+        case 'ES512':
+            componentLen = 66;
+            break;
+        default:
+            throw new ConfigurationError(`Unsupported algorithm for DER conversion: ${algorithm}`);
+    }
+    // Parse DER: SEQUENCE { INTEGER r, INTEGER s }
+    if (signature[0] !== 0x30) {
+        throw new ConfigurationError('Invalid DER signature: expected SEQUENCE');
+    }
+    // Skip SEQUENCE tag, then parse DER length (short- or long-form).
+    let offset = 1;
+    if (signature[offset] & 0x80) {
+        // Long-form: low 7 bits = number of subsequent length bytes.
+        const lenBytesCount = signature[offset] & 0x7f;
+        if (lenBytesCount === 0 || lenBytesCount > 4) {
+            throw new ConfigurationError('Invalid DER signature: invalid long-form length');
+        }
+        offset += 1 + lenBytesCount;
+        if (offset > signature.length) {
+            throw new ConfigurationError('Invalid DER signature: length bytes exceed signature length');
+        }
+    }
+    else {
+        // Short-form: single length byte.
+        offset += 1;
+    }
+    // Parse r INTEGER
+    if (signature[offset] !== 0x02) {
+        throw new ConfigurationError('Invalid DER signature: expected INTEGER for r');
+    }
+    const rLen = signature[offset + 1];
+    offset += 2;
+    let r = signature.slice(offset, offset + rLen);
+    offset += rLen;
+    // Parse s INTEGER
+    if (signature[offset] !== 0x02) {
+        throw new ConfigurationError('Invalid DER signature: expected INTEGER for s');
+    }
+    const sLen = signature[offset + 1];
+    offset += 2;
+    let s = signature.slice(offset, offset + sLen);
+    // Remove leading zero padding if present
+    if (r[0] === 0 && r.length > componentLen) {
+        r = r.slice(1);
+    }
+    if (s[0] === 0 && s.length > componentLen) {
+        s = s.slice(1);
+    }
+    // Pad to component length
+    const result = new Uint8Array(componentLen * 2);
+    result.set(r, componentLen - r.length);
+    result.set(s, componentLen * 2 - s.length);
+    return result;
+}
+/**
+ * Sign data with an asymmetric private key.
+ */
+export async function sign(data, privateKey, algorithm) {
+    const { signParams } = getSigningAlgorithmParams(algorithm);
+    // Unwrap the internal CryptoKey
+    const key = unwrapKey(privateKey);
+    // Sign the data
+    const signature = await crypto.subtle.sign(signParams, key, data);
+    // Convert from IEEE P1363 to DER for EC algorithms
+    return ieeeP1363ToDer(new Uint8Array(signature), algorithm);
+}
+/**
+ * Verify signature with an asymmetric public key.
+ */
+export async function verify(data, signature, publicKey, algorithm) {
+    const { signParams } = getSigningAlgorithmParams(algorithm);
+    // Unwrap the internal CryptoKey
+    const key = unwrapKey(publicKey);
+    // Convert from DER to IEEE P1363 for EC algorithms
+    const ieeeSignature = derToIeeeP1363(signature, algorithm);
+    // Verify the signature
+    return crypto.subtle.verify(signParams, key, ieeeSignature, data);
+}
+/**
+ * Compute hash digest.
+ */
+export async function digest(algorithm, data) {
+    // Validate algorithm and map to Web Crypto name
+    const validAlgorithms = ['SHA-256', 'SHA-384', 'SHA-512'];
+    if (!validAlgorithms.includes(algorithm)) {
+        throw new ConfigurationError(`Unsupported hash algorithm: ${algorithm}`);
+    }
+    const hashBuffer = await crypto.subtle.digest(algorithm, data);
+    return new Uint8Array(hashBuffer);
+}
+/**
+ * Extract PEM public key from X.509 certificate or return PEM key as-is.
+ *
+ * @param certOrPem - A PEM-encoded X.509 certificate or public key
+ * @param jwaAlgorithm - JWA algorithm hint for certificate parsing (RS256, RS512, ES256, ES384, ES512).
+ *                       If not provided for a certificate, will attempt to auto-detect from OIDs.
+ */
+export async function extractPublicKeyPem(certOrPem, jwaAlgorithm) {
+    // If it's a certificate, extract the public key
+    if (certOrPem.includes('-----BEGIN CERTIFICATE-----')) {
+        let alg = jwaAlgorithm;
+        if (!alg) {
+            // Auto-detect algorithm from certificate OIDs
+            const certBody = certOrPem.replace(/-----(BEGIN|END) CERTIFICATE-----|\s/g, '');
+            const certBytes = base64Decode(certBody);
+            const hex = hexEncode(certBytes);
+            alg = toJwsAlg(hex);
+        }
+        const cert = await importX509(certOrPem, alg, { extractable: true });
+        return exportSPKI(cert);
+    }
+    // If it's already a PEM public key, return as-is
+    if (certOrPem.includes('-----BEGIN PUBLIC KEY-----')) {
+        return certOrPem;
+    }
+    throw new ConfigurationError('Input must be a PEM-encoded certificate or public key');
+}
+/**
+ * Map ECCurve to Web Crypto named curve.
+ */
+function curveToNamedCurve(curve) {
+    switch (curve) {
+        case 'P-256':
+            return 'P-256';
+        case 'P-384':
+            return 'P-384';
+        case 'P-521':
+            return 'P-521';
+        default:
+            throw new ConfigurationError(`Unsupported curve: ${curve}`);
+    }
+}
+/**
+ * Generate an EC key pair for ECDH key agreement.
+ */
+export async function generateECKeyPair(curve = 'P-256') {
+    const namedCurve = curveToNamedCurve(curve);
+    // Generate key pair for ECDH key agreement
+    const keyPair = await crypto.subtle.generateKey({ name: 'ECDH', namedCurve }, true, [
+        'deriveBits',
+    ]);
+    // Map to KeyAlgorithm literal type
+    let algorithm;
+    switch (namedCurve) {
+        case 'P-256':
+            algorithm = 'ec:secp256r1';
+            break;
+        case 'P-384':
+            algorithm = 'ec:secp384r1';
+            break;
+        case 'P-521':
+            algorithm = 'ec:secp521r1';
+            break;
+        default:
+            throw new ConfigurationError(`Unsupported curve: ${namedCurve}`);
+    }
+    return {
+        publicKey: wrapPublicKey(keyPair.publicKey, algorithm),
+        privateKey: wrapPrivateKey(keyPair.privateKey, algorithm),
+    };
+}
+/**
+ * Supported EC curves.
+ */
+const SUPPORTED_EC_CURVES = ['P-256', 'P-384', 'P-521'];
+/**
+ * Decode base64url string and return byte length.
+ * Uses the existing base64 decoder which handles both standard and URL-safe encoding.
+ */
+function base64urlByteLength(base64url) {
+    // Add padding if needed (base64url omits padding)
+    const padding = (4 - (base64url.length % 4)) % 4;
+    const padded = base64url + '='.repeat(padding);
+    return base64Decode(padded).byteLength;
+}
+/**
+ * Extract EC curve from a public key by parsing ASN.1 OIDs.
+ * Reuses the existing guessCurveName function that checks for curve OIDs.
+ */
+function extractEcCurveFromPublicKey(keyData) {
+    // Convert to hex for OID parsing
+    const hexKey = hexEncode(keyData);
+    // Use existing OID parser (returns 'P-256', 'P-384', or 'P-521')
+    const curveName = guessCurveName(hexKey);
+    return curveName;
+}
+/**
+ * Perform ECDH key agreement followed by HKDF key derivation.
+ * Returns opaque symmetric key for symmetric encryption.
+ */
+export async function deriveKeyFromECDH(privateKey, publicKey, hkdfParams) {
+    // Unwrap the internal CryptoKeys
+    const privateKeyCrypto = unwrapKey(privateKey);
+    const publicKeyCrypto = unwrapKey(publicKey);
+    // Get curve from key metadata
+    const curve = publicKey.curve;
+    if (!curve) {
+        throw new ConfigurationError('EC curve not found on public key');
+    }
+    // Determine bits based on curve
+    const curveBits = {
+        'P-256': 256,
+        'P-384': 384,
+        'P-521': 528, // P-521 derives 528 bits (66 bytes)
+    };
+    const bits = curveBits[curve];
+    // Perform ECDH to get shared secret
+    const sharedSecret = await crypto.subtle.deriveBits({ name: 'ECDH', public: publicKeyCrypto }, privateKeyCrypto, bits);
+    // Import shared secret as HKDF key material
+    const hkdfKey = await crypto.subtle.importKey('raw', sharedSecret, 'HKDF', false, ['deriveKey']);
+    // Derive the final key using HKDF
+    const keyLength = hkdfParams.keyLength ?? 256;
+    const derivedKey = await crypto.subtle.deriveKey({
+        name: 'HKDF',
+        hash: hkdfParams.hash,
+        salt: hkdfParams.salt,
+        info: hkdfParams.info ?? new Uint8Array(0),
+    }, hkdfKey, { name: 'AES-GCM', length: keyLength }, true, ['encrypt', 'decrypt']);
+    // Export the derived key as raw bytes and wrap as SymmetricKey
+    const keyBytes = await crypto.subtle.exportKey('raw', derivedKey);
+    return wrapSymmetricKey(new Uint8Array(keyBytes));
+}
+/**
+ * Compute HMAC-SHA256 of data with a symmetric key.
+ */
+export async function hmac(data, key) {
+    // Unwrap symmetric key to get raw bytes
+    const keyBytes = unwrapSymmetricKey(key);
+    const cryptoKey = await crypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+    const signature = await crypto.subtle.sign('HMAC', cryptoKey, data);
+    return new Uint8Array(signature);
+}
+/**
+ * Verify HMAC-SHA256. Standalone utility — not part of CryptoService interface.
+ */
+export async function verifyHmac(data, signature, key) {
+    const keyBytes = unwrapSymmetricKey(key);
+    const cryptoKey = await crypto.subtle.importKey('raw', keyBytes, { name: 'HMAC', hash: 'SHA-256' }, false, ['verify']);
+    return crypto.subtle.verify('HMAC', cryptoKey, signature, data);
+}
+/**
+ * Extract RSA modulus bit length by importing key and exporting as JWK.
+ * Uses Web Crypto's built-in ASN.1 parsing for robustness.
+ */
+async function extractRsaModulusBitLength(keyData) {
+    const key = await crypto.subtle.importKey('spki', keyData, { name: 'RSA-OAEP', hash: 'SHA-256' }, true, // extractable
+    ['encrypt']);
+    const jwk = await crypto.subtle.exportKey('jwk', key);
+    if (!jwk.n) {
+        throw new ConfigurationError('Invalid RSA key: missing modulus');
+    }
+    // JWK 'n' is base64url-encoded modulus
+    // Decode and count bytes, multiply by 8 for bits
+    return base64urlByteLength(jwk.n) * 8;
+}
+/**
+ * Import and validate a PEM public key, returning algorithm info.
+ * Uses JWK export for robust key parameter detection.
+ */
+export async function parsePublicKeyPem(pem) {
+    // First extract public key if it's a certificate
+    let publicKeyPem = pem;
+    if (pem.includes('-----BEGIN CERTIFICATE-----')) {
+        publicKeyPem = await extractPublicKeyPem(pem);
+    }
+    if (!publicKeyPem.includes('-----BEGIN PUBLIC KEY-----')) {
+        throw new ConfigurationError('Input must be a PEM-encoded public key or certificate');
+    }
+    const keyData = base64Decode(removePemFormatting(publicKeyPem));
+    // Try RSA first - use JWK export to get modulus size
+    try {
+        const modulusBits = await extractRsaModulusBitLength(keyData);
+        let algorithm;
+        if (modulusBits < MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+            throw new ConfigurationError(`RSA key size ${modulusBits} bits is below the minimum of ${MIN_ASYMMETRIC_KEY_SIZE_BITS} bits`);
+        }
+        else if (modulusBits <= 2048) {
+            algorithm = 'rsa:2048';
+        }
+        else if (modulusBits <= 4096) {
+            algorithm = 'rsa:4096';
+        }
+        else {
+            throw new ConfigurationError(`Unsupported RSA key size: ${modulusBits} bits`);
+        }
+        return { algorithm, pem: publicKeyPem };
+    }
+    catch (e) {
+        // If it's our own ConfigurationError, rethrow
+        if (e instanceof ConfigurationError) {
+            throw e;
+        }
+        // Not an RSA key, try EC next
+    }
+    // Try EC - parse curve from OID
+    try {
+        const detectedCurve = extractEcCurveFromPublicKey(keyData);
+        const curveMap = {
+            'P-256': 'ec:secp256r1',
+            'P-384': 'ec:secp384r1',
+            'P-521': 'ec:secp521r1',
+        };
+        return { algorithm: curveMap[detectedCurve], pem: publicKeyPem };
+    }
+    catch {
+        // Not a valid EC key
+    }
+    throw new ConfigurationError('Unable to determine public key algorithm - unsupported key type');
+}
+/**
+ * Convert a JWK (JSON Web Key) to PEM format.
+ */
+export async function jwkToPublicKeyPem(jwk) {
+    let key;
+    if (jwk.kty === 'RSA') {
+        // RSA key
+        key = await crypto.subtle.importKey('jwk', jwk, { name: 'RSA-OAEP', hash: 'SHA-256' }, true, [
+            'encrypt',
+        ]);
+    }
+    else if (jwk.kty === 'EC') {
+        // EC key
+        const crv = jwk.crv;
+        if (!crv || !['P-256', 'P-384', 'P-521'].includes(crv)) {
+            throw new ConfigurationError(`Unsupported EC curve: ${crv}`);
+        }
+        key = await crypto.subtle.importKey('jwk', jwk, { name: 'ECDH', namedCurve: crv }, true, []);
+    }
+    else {
+        throw new ConfigurationError(`Unsupported JWK key type: ${jwk.kty}`);
+    }
+    const spkiBuffer = await crypto.subtle.exportKey('spki', key);
+    return formatAsPem(spkiBuffer, 'PUBLIC KEY');
+}
+/**
+ * Convert a PEM public key to JWK format.
+ * Returns only public key components (no private key data).
+ */
+export async function publicKeyPemToJwk(publicKeyPem) {
+    const keyDataBase64 = removePemFormatting(publicKeyPem);
+    const keyBuffer = base64Decode(keyDataBase64);
+    const hex = hexEncode(keyBuffer);
+    // Detect key type using OID
+    const algorithmName = guessAlgorithmName(hex);
+    if (algorithmName === 'ECDH' || algorithmName === 'ECDSA') {
+        // EC key - detect curve from OID
+        const namedCurve = guessCurveName(hex);
+        const key = await crypto.subtle.importKey('spki', keyBuffer, { name: 'ECDSA', namedCurve }, true, ['verify']);
+        const jwk = await crypto.subtle.exportKey('jwk', key);
+        // Return only public key components
+        const { kty, crv, x, y } = jwk;
+        return { kty, crv, x, y };
+    }
+    else {
+        // RSA key
+        const key = await crypto.subtle.importKey('spki', keyBuffer, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, true, ['verify']);
+        const jwk = await crypto.subtle.exportKey('jwk', key);
+        // Return only public key components
+        const { kty, e, n } = jwk;
+        return { kty, e, n };
+    }
+}
+// ============================================================
+// Key Import Functions (PEM → Opaque)
+// ============================================================
+/**
+ * Import a PEM public key as an opaque key.
+ */
+export async function importPublicKey(pem, options) {
+    const { usage = 'encrypt', extractable = true, algorithmHint } = options;
+    // Detect algorithm from PEM; also normalises certificates → plain SPKI PEM.
+    const keyInfo = await parsePublicKeyPem(pem);
+    const algorithm = algorithmHint || keyInfo.algorithm;
+    // Use keyInfo.pem (normalised SPKI) not the original pem, which may be a certificate.
+    // Passing raw X.509 DER bytes to crypto.subtle.importKey('spki') would throw DataError.
+    const keyData = removePemFormatting(keyInfo.pem);
+    const keyBuffer = base64Decode(keyData);
+    // Determine Web Crypto algorithm and usages based on key type and usage
+    let cryptoAlgorithm;
+    let keyUsages;
+    if (algorithm.startsWith('rsa:')) {
+        if (usage === 'encrypt') {
+            cryptoAlgorithm = rsaOaepSha1();
+            keyUsages = ['encrypt'];
+        }
+        else if (usage === 'sign') {
+            cryptoAlgorithm = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' };
+            keyUsages = ['verify'];
+        }
+        else {
+            throw new ConfigurationError('RSA keys only support usage: encrypt or sign');
+        }
+    }
+    else if (algorithm.startsWith('ec:')) {
+        const curve = algorithm.split(':')[1];
+        const namedCurve = curve === 'secp256r1'
+            ? 'P-256'
+            : curve === 'secp384r1'
+                ? 'P-384'
+                : curve === 'secp521r1'
+                    ? 'P-521'
+                    : (() => {
+                        throw new ConfigurationError(`Unsupported EC curve: ${curve}`);
+                    })();
+        if (usage === 'derive') {
+            cryptoAlgorithm = { name: 'ECDH', namedCurve };
+            keyUsages = [];
+        }
+        else if (usage === 'sign') {
+            cryptoAlgorithm = { name: 'ECDSA', namedCurve };
+            keyUsages = ['verify'];
+        }
+        else {
+            throw new ConfigurationError('EC keys only support usage: derive or sign');
+        }
+    }
+    else {
+        throw new ConfigurationError(`Unsupported algorithm: ${algorithm}`);
+    }
+    // Import as CryptoKey
+    const cryptoKey = await crypto.subtle.importKey('spki', keyBuffer, cryptoAlgorithm, extractable, keyUsages);
+    return wrapPublicKey(cryptoKey, algorithm);
+}
+/**
+ * Import a PEM private key as an opaque key.
+ */
+export async function importPrivateKey(pem, options) {
+    const { usage = 'encrypt', extractable = true, algorithmHint } = options;
+    // Detect algorithm from PEM structure (similar to public key detection)
+    // For now, use algorithmHint if provided, otherwise detect from key structure
+    let algorithm;
+    const keyData = removePemFormatting(pem);
+    const keyBuffer = base64Decode(keyData);
+    if (algorithmHint) {
+        algorithm = algorithmHint;
+    }
+    else {
+        // PKCS#8 PrivateKeyInfo embeds the same AlgorithmIdentifier OIDs as SPKI,
+        // so guessAlgorithmName / guessCurveName work on private key bytes too.
+        const hex = hexEncode(keyBuffer);
+        const algorithmName = guessAlgorithmName(hex); // throws on unrecognised OID
+        if (algorithmName === 'ECDH' || algorithmName === 'ECDSA') {
+            const namedCurve = guessCurveName(hex);
+            const curveMap = {
+                'P-256': 'ec:secp256r1',
+                'P-384': 'ec:secp384r1',
+                'P-521': 'ec:secp521r1',
+            };
+            const mapped = curveMap[namedCurve];
+            if (!mapped)
+                throw new ConfigurationError(`Unsupported EC curve in private key: ${namedCurve}`);
+            algorithm = mapped;
+        }
+        else {
+            // RSA — determine key size by importing and reading modulus length from JWK
+            const tempKey = await crypto.subtle.importKey('pkcs8', keyBuffer, { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' }, true, ['sign']);
+            const jwk = await crypto.subtle.exportKey('jwk', tempKey);
+            if (!jwk.n) {
+                throw new ConfigurationError('Invalid RSA private key: missing modulus');
+            }
+            const modulusBits = base64urlByteLength(jwk.n) * 8;
+            if (modulusBits < MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+                throw new ConfigurationError(`RSA key size ${modulusBits} bits is below the minimum of ${MIN_ASYMMETRIC_KEY_SIZE_BITS} bits`);
+            }
+            algorithm = modulusBits <= 2048 ? 'rsa:2048' : 'rsa:4096';
+        }
+    }
+    // Determine Web Crypto algorithm and usages
+    let cryptoAlgorithm;
+    let keyUsages;
+    if (algorithm.startsWith('rsa:')) {
+        if (usage === 'encrypt') {
+            cryptoAlgorithm = rsaOaepSha1();
+            keyUsages = ['decrypt'];
+        }
+        else if (usage === 'sign') {
+            cryptoAlgorithm = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' };
+            keyUsages = ['sign'];
+        }
+        else {
+            throw new ConfigurationError('RSA keys only support usage: encrypt or sign');
+        }
+    }
+    else if (algorithm.startsWith('ec:')) {
+        const curve = algorithm.split(':')[1];
+        const namedCurve = curve === 'secp256r1'
+            ? 'P-256'
+            : curve === 'secp384r1'
+                ? 'P-384'
+                : curve === 'secp521r1'
+                    ? 'P-521'
+                    : (() => {
+                        throw new ConfigurationError(`Unsupported EC curve: ${curve}`);
+                    })();
+        if (usage === 'derive') {
+            cryptoAlgorithm = { name: 'ECDH', namedCurve };
+            keyUsages = ['deriveBits'];
+        }
+        else if (usage === 'sign') {
+            cryptoAlgorithm = { name: 'ECDSA', namedCurve };
+            keyUsages = ['sign'];
+        }
+        else {
+            throw new ConfigurationError('EC keys only support usage: derive or sign');
+        }
+    }
+    else {
+        throw new ConfigurationError(`Unsupported algorithm: ${algorithm}`);
+    }
+    // Import as CryptoKey
+    const cryptoKey = await crypto.subtle.importKey('pkcs8', keyBuffer, cryptoAlgorithm, extractable, keyUsages);
+    return wrapPrivateKey(cryptoKey, algorithm);
+}
+// ============================================================
+// Key Export Functions (Opaque → PEM/JWK)
+// ============================================================
+/**
+ * Export an opaque public key to PEM format.
+ */
+export async function exportPublicKeyPem(key) {
+    const cryptoKey = unwrapKey(key);
+    const keyBuffer = await crypto.subtle.exportKey('spki', cryptoKey);
+    return formatAsPem(keyBuffer, 'PUBLIC KEY');
+}
+/**
+ * Export an opaque private key to PEM format.
+ * ONLY USE FOR TESTING/DEVELOPMENT. Private keys should NOT be exportable in secure environments.
+ */
+export async function exportPrivateKeyPem(key) {
+    const cryptoKey = unwrapKey(key);
+    const keyBuffer = await crypto.subtle.exportKey('pkcs8', cryptoKey);
+    return formatAsPem(keyBuffer, 'PRIVATE KEY');
+}
+/**
+ * Export an opaque public key to JWK format.
+ */
+export async function exportPublicKeyJwk(key) {
+    const cryptoKey = unwrapKey(key);
+    return await crypto.subtle.exportKey('jwk', cryptoKey);
+}
+/**
+ * Import raw key bytes as an opaque symmetric key.
+ * Used for external keys (e.g., unwrapped from KAS).
+ */
+export async function importSymmetricKey(keyBytes) {
+    return wrapSymmetricKey(keyBytes);
+}
+/**
+ * Split a symmetric key into N shares using XOR secret sharing.
+ * Key bytes are extracted internally for splitting.
+ * HSM implementations cannot extract bytes and should throw ConfigurationError.
+ */
+export async function splitSymmetricKey(key, numShares) {
+    const keyBytes = unwrapSymmetricKey(key);
+    const splits = await keySplit(keyBytes, numShares, DefaultCryptoService);
+    return splits.map(wrapSymmetricKey);
+}
+/**
+ * Merge symmetric key shares back into the original key using XOR.
+ * Key bytes are extracted internally for merging.
+ */
+export async function mergeSymmetricKeys(shares) {
+    const splitBytes = shares.map(unwrapSymmetricKey);
+    const merged = keyMerge(splitBytes);
+    return wrapSymmetricKey(merged);
+}
 export const DefaultCryptoService = {
     name,
     method,
-    cryptoToPemPair,
     decrypt,
     decryptWithPrivateKey,
+    deriveKeyFromECDH,
+    digest,
     encrypt,
     encryptWithPublicKey,
-    generateInitializationVector,
+    exportPublicKeyJwk,
+    exportPrivateKeyPem,
+    exportPublicKeyPem,
+    extractPublicKeyPem,
+    generateECKeyPair,
     generateKey,
     generateKeyPair,
     generateSigningKeyPair,
-    hmac,
+    importPrivateKey,
+    importPublicKey,
+    importSymmetricKey,
+    jwkToPublicKeyPem,
+    mergeSymmetricKeys,
+    parsePublicKeyPem,
     randomBytes,
-    sha256,
+    hmac,
+    verifyHmac,
+    sign,
+    splitSymmetricKey,
+    verify,
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../tdf3/src/crypto/index.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../tdf3/src/crypto/index.ts"],"names":[],"mappings":"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"}