@opentdf/sdk 0.12.0 → 0.13.0-rc.121

package/dist/cjs/src/auth/dpop.js

@@ -30,8 +30,8 @@ function b64u(input) {
 /**
  * Generates 32 random bytes and encodes them using base64url.
  */
-async function randomBytes(cryptoService) {
-    return b64u(await cryptoService.randomBytes(32));
+async function randomBytes() {
+    return b64u(crypto.getRandomValues(new Uint8Array(32)));
 }
 class UnsupportedOperationError extends Error {
     constructor(message) {
@@ -111,11 +111,11 @@ async function DPoP(keypair, cryptoService, htu, htm, nonce, accessToken, additi
     }, {
         ...additional,
         iat: epochTime(),
-        jti: await randomBytes(cryptoService),
+        jti: await randomBytes(),
         htm,
         nonce,
         htu,
         ath,
     }, privateKey, cryptoService);
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/src/version.js

@@ -4,7 +4,7 @@ exports.tdfSpecVersion = exports.clientType = exports.version = void 0;
 /**
  * Exposes the released version number of the `@opentdf/sdk` package
  */
-exports.version = '0.12.0'; // x-release-please-version
+exports.version = '0.13.0'; // x-release-please-version
 /**
  * A string name used to label requests as coming from this library client.
  */

package/dist/cjs/tdf3/src/crypto/core/ec.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateECKeyPair = generateECKeyPair;
+exports.deriveKeyFromECDH = deriveKeyFromECDH;
+const errors_js_1 = require("../../../../src/errors.js");
+const keys_js_1 = require("./keys.js");
+/**
+ * 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 errors_js_1.ConfigurationError(`Unsupported curve: ${curve}`);
+    }
+}
+/**
+ * Generate an EC key pair for ECDH key agreement.
+ */
+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 errors_js_1.ConfigurationError(`Unsupported curve: ${namedCurve}`);
+    }
+    return {
+        publicKey: (0, keys_js_1.wrapPublicKey)(keyPair.publicKey, algorithm),
+        privateKey: (0, keys_js_1.wrapPrivateKey)(keyPair.privateKey, algorithm),
+    };
+}
+/**
+ * Perform ECDH key agreement followed by HKDF key derivation.
+ * Returns opaque symmetric key for symmetric encryption.
+ */
+async function deriveKeyFromECDH(privateKey, publicKey, hkdfParams) {
+    // Unwrap the internal CryptoKeys
+    const privateKeyCrypto = (0, keys_js_1.unwrapKey)(privateKey);
+    const publicKeyCrypto = (0, keys_js_1.unwrapKey)(publicKey);
+    // Get curve from key metadata
+    const curve = publicKey.curve;
+    if (!curve) {
+        throw new errors_js_1.ConfigurationError('EC curve not found on public key');
+    }
+    // Determine bits based on curve
+    const curveBits = {
+        'P-256': 256,
+        'P-384': 384,
+        // P-521 derives 528 bits (66 bytes)
+        'P-521': 528,
+    };
+    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 (0, keys_js_1.wrapSymmetricKey)(new Uint8Array(keyBytes));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/tdf3/src/crypto/core/key-format.js

@@ -0,0 +1,359 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPublicKeyPem = extractPublicKeyPem;
+exports.parsePublicKeyPem = parsePublicKeyPem;
+exports.jwkToPublicKeyPem = jwkToPublicKeyPem;
+exports.publicKeyPemToJwk = publicKeyPemToJwk;
+exports.importPublicKey = importPublicKey;
+exports.importPrivateKey = importPrivateKey;
+exports.exportPublicKeyPem = exportPublicKeyPem;
+exports.exportPrivateKeyPem = exportPrivateKeyPem;
+exports.exportPublicKeyJwk = exportPublicKeyJwk;
+const declarations_js_1 = require("../declarations.js");
+const errors_js_1 = require("../../../../src/errors.js");
+const crypto_utils_js_1 = require("../crypto-utils.js");
+const hex_js_1 = require("../../../../src/encodings/hex.js");
+const base64_js_1 = require("../../../../src/encodings/base64.js");
+const jose_1 = require("jose");
+const pemPublicToCrypto_js_1 = require("../../../../src/crypto/pemPublicToCrypto.js");
+const keys_js_1 = require("./keys.js");
+const rsa_js_1 = require("./rsa.js");
+/**
+ * Extract PEM public key from X.509 certificate or return PEM key as-is.
+ */
+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 = (0, base64_js_1.decodeArrayBuffer)(certBody);
+            const hex = (0, hex_js_1.encodeArrayBuffer)(certBytes);
+            alg = (0, pemPublicToCrypto_js_1.toJwsAlg)(hex);
+        }
+        const cert = await (0, jose_1.importX509)(certOrPem, alg, { extractable: true });
+        return (0, jose_1.exportSPKI)(cert);
+    }
+    // If it's already a PEM public key, return as-is
+    if (certOrPem.includes('-----BEGIN PUBLIC KEY-----')) {
+        return certOrPem;
+    }
+    throw new errors_js_1.ConfigurationError('Input must be a PEM-encoded certificate or public key');
+}
+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 (0, base64_js_1.decodeArrayBuffer)(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 = (0, hex_js_1.encodeArrayBuffer)(keyData);
+    // Use existing OID parser (returns 'P-256', 'P-384', or 'P-521')
+    const curveName = (0, pemPublicToCrypto_js_1.guessCurveName)(hexKey);
+    return curveName;
+}
+/**
+ * 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, ['encrypt']);
+    const jwk = await crypto.subtle.exportKey('jwk', key);
+    if (!jwk.n) {
+        throw new errors_js_1.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.
+ */
+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 errors_js_1.ConfigurationError('Input must be a PEM-encoded public key or certificate');
+    }
+    const keyData = (0, base64_js_1.decodeArrayBuffer)((0, crypto_utils_js_1.removePemFormatting)(publicKeyPem));
+    // Try RSA first - use JWK export to get modulus size
+    try {
+        const modulusBits = await extractRsaModulusBitLength(keyData);
+        let algorithm;
+        if (modulusBits < declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+            throw new errors_js_1.ConfigurationError(`RSA key size ${modulusBits} bits is below the minimum of ${declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS} bits`);
+        }
+        else if (modulusBits <= 2048) {
+            algorithm = 'rsa:2048';
+        }
+        else if (modulusBits <= 4096) {
+            algorithm = 'rsa:4096';
+        }
+        else {
+            throw new errors_js_1.ConfigurationError(`Unsupported RSA key size: ${modulusBits} bits`);
+        }
+        return { algorithm, pem: publicKeyPem };
+    }
+    catch (e) {
+        // If it's our own ConfigurationError, rethrow
+        if (e instanceof errors_js_1.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 errors_js_1.ConfigurationError('Unable to determine public key algorithm - unsupported key type');
+}
+/**
+ * Convert a JWK (JSON Web Key) to PEM format.
+ */
+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 errors_js_1.ConfigurationError(`Unsupported EC curve: ${crv}`);
+        }
+        key = await crypto.subtle.importKey('jwk', jwk, { name: 'ECDH', namedCurve: crv }, true, []);
+    }
+    else {
+        throw new errors_js_1.ConfigurationError(`Unsupported JWK key type: ${jwk.kty}`);
+    }
+    const spkiBuffer = await crypto.subtle.exportKey('spki', key);
+    return (0, crypto_utils_js_1.formatAsPem)(spkiBuffer, 'PUBLIC KEY');
+}
+/**
+ * Convert a PEM public key to JWK format.
+ * Returns only public key components (no private key data).
+ */
+async function publicKeyPemToJwk(publicKeyPem) {
+    const keyDataBase64 = (0, crypto_utils_js_1.removePemFormatting)(publicKeyPem);
+    const keyBuffer = (0, base64_js_1.decodeArrayBuffer)(keyDataBase64);
+    const hex = (0, hex_js_1.encodeArrayBuffer)(keyBuffer);
+    // Detect key type using OID
+    const algorithmName = (0, pemPublicToCrypto_js_1.guessAlgorithmName)(hex);
+    if (algorithmName === 'ECDH' || algorithmName === 'ECDSA') {
+        // EC key - detect curve from OID
+        const namedCurve = (0, pemPublicToCrypto_js_1.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 };
+    }
+}
+/**
+ * Import a PEM public key as an opaque key.
+ */
+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 = (0, crypto_utils_js_1.removePemFormatting)(keyInfo.pem);
+    const keyBuffer = (0, base64_js_1.decodeArrayBuffer)(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 = (0, rsa_js_1.rsaOaepSha1)();
+            keyUsages = ['encrypt'];
+        }
+        else if (usage === 'sign') {
+            cryptoAlgorithm = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' };
+            keyUsages = ['verify'];
+        }
+        else {
+            throw new errors_js_1.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 errors_js_1.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 errors_js_1.ConfigurationError('EC keys only support usage: derive or sign');
+        }
+    }
+    else {
+        throw new errors_js_1.ConfigurationError(`Unsupported algorithm: ${algorithm}`);
+    }
+    // Import as CryptoKey
+    const cryptoKey = await crypto.subtle.importKey('spki', keyBuffer, cryptoAlgorithm, extractable, keyUsages);
+    return (0, keys_js_1.wrapPublicKey)(cryptoKey, algorithm);
+}
+/**
+ * Import a PEM private key as an opaque key.
+ */
+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 = (0, crypto_utils_js_1.removePemFormatting)(pem);
+    const keyBuffer = (0, base64_js_1.decodeArrayBuffer)(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 = (0, hex_js_1.encodeArrayBuffer)(keyBuffer);
+        const algorithmName = (0, pemPublicToCrypto_js_1.guessAlgorithmName)(hex); // throws on unrecognised OID
+        if (algorithmName === 'ECDH' || algorithmName === 'ECDSA') {
+            const namedCurve = (0, pemPublicToCrypto_js_1.guessCurveName)(hex);
+            const curveMap = {
+                'P-256': 'ec:secp256r1',
+                'P-384': 'ec:secp384r1',
+                'P-521': 'ec:secp521r1',
+            };
+            const mapped = curveMap[namedCurve];
+            if (!mapped)
+                throw new errors_js_1.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 errors_js_1.ConfigurationError('Invalid RSA private key: missing modulus');
+            }
+            const modulusBits = base64urlByteLength(jwk.n) * 8;
+            if (modulusBits < declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+                throw new errors_js_1.ConfigurationError(`RSA key size ${modulusBits} bits is below the minimum of ${declarations_js_1.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 = (0, rsa_js_1.rsaOaepSha1)();
+            keyUsages = ['decrypt'];
+        }
+        else if (usage === 'sign') {
+            cryptoAlgorithm = { name: 'RSASSA-PKCS1-v1_5', hash: 'SHA-256' };
+            keyUsages = ['sign'];
+        }
+        else {
+            throw new errors_js_1.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 errors_js_1.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 errors_js_1.ConfigurationError('EC keys only support usage: derive or sign');
+        }
+    }
+    else {
+        throw new errors_js_1.ConfigurationError(`Unsupported algorithm: ${algorithm}`);
+    }
+    // Import as CryptoKey
+    const cryptoKey = await crypto.subtle.importKey('pkcs8', keyBuffer, cryptoAlgorithm, extractable, keyUsages);
+    return (0, keys_js_1.wrapPrivateKey)(cryptoKey, algorithm);
+}
+/**
+ * Export an opaque public key to PEM format.
+ */
+async function exportPublicKeyPem(key) {
+    const cryptoKey = (0, keys_js_1.unwrapKey)(key);
+    const keyBuffer = await crypto.subtle.exportKey('spki', cryptoKey);
+    return (0, crypto_utils_js_1.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.
+ */
+async function exportPrivateKeyPem(key) {
+    const cryptoKey = (0, keys_js_1.unwrapKey)(key);
+    const keyBuffer = await crypto.subtle.exportKey('pkcs8', cryptoKey);
+    return (0, crypto_utils_js_1.formatAsPem)(keyBuffer, 'PRIVATE KEY');
+}
+/**
+ * Export an opaque public key to JWK format.
+ */
+async function exportPublicKeyJwk(key) {
+    const cryptoKey = (0, keys_js_1.unwrapKey)(key);
+    return await crypto.subtle.exportKey('jwk', cryptoKey);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"key-format.js","sourceRoot":"","sources":["../../../../../../tdf3/src/crypto/core/key-format.ts"],"names":[],"mappings":"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"}

package/dist/cjs/tdf3/src/crypto/core/keys.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapPublicKey = wrapPublicKey;
+exports.wrapPrivateKey = wrapPrivateKey;
+exports.unwrapKey = unwrapKey;
+exports.wrapSymmetricKey = wrapSymmetricKey;
+exports.unwrapSymmetricKey = unwrapSymmetricKey;
+/**
+ * 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;
+}
+//# sourceMappingURL=data:application/json;base64,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