@opentdf/sdk 0.11.0 → 0.12.0-beta.112

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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

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

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rsaOaepSha1 = rsaOaepSha1;
+exports.rsaPkcs1Sha256 = rsaPkcs1Sha256;
+exports.generateKeyPair = generateKeyPair;
+exports.generateSigningKeyPair = generateSigningKeyPair;
+exports.encryptWithPublicKey = encryptWithPublicKey;
+exports.decryptWithPrivateKey = decryptWithPrivateKey;
+const binary_js_1 = require("../../binary.js");
+const declarations_js_1 = require("../declarations.js");
+const errors_js_1 = require("../../../../src/errors.js");
+const keys_js_1 = require("./keys.js");
+const ENC_DEC_METHODS = ['encrypt', 'decrypt'];
+const SIGN_VERIFY_METHODS = ['sign', 'verify'];
+/**
+ * Get a DOMString representing the algorithm to use for an
+ * asymmetric key generation.
+ */
+function rsaOaepSha1(modulusLength = declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+    if (!modulusLength || modulusLength < declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+        throw new errors_js_1.ConfigurationError('Invalid key size requested');
+    }
+    return {
+        name: 'RSA-OAEP',
+        hash: {
+            name: 'SHA-1',
+        },
+        modulusLength,
+        // 24 bit representation of 65537
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+    };
+}
+function rsaPkcs1Sha256(modulusLength = declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+    if (!modulusLength || modulusLength < declarations_js_1.MIN_ASYMMETRIC_KEY_SIZE_BITS) {
+        throw new errors_js_1.ConfigurationError('Invalid key size requested');
+    }
+    return {
+        name: 'RSASSA-PKCS1-v1_5',
+        hash: {
+            name: 'SHA-256',
+        },
+        modulusLength,
+        // 24 bit representation of 65537
+        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
+    };
+}
+/**
+ * Generate an RSA key pair
+ * @see    {@link https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/generateKey}
+ * @param  size in bits
+ */
+async function generateKeyPair(size) {
+    const keySize = size || declarations_js_1.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 errors_js_1.ConfigurationError(`Unsupported RSA key size: ${keySize}. Only 2048 and 4096 are supported.`);
+    }
+    return {
+        publicKey: (0, keys_js_1.wrapPublicKey)(keyPair.publicKey, algorithm),
+        privateKey: (0, keys_js_1.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}
+ */
+async function generateSigningKeyPair() {
+    const rsaParams = rsaPkcs1Sha256(2048);
+    const keyPair = await crypto.subtle.generateKey(rsaParams, true, SIGN_VERIFY_METHODS);
+    const algorithm = 'rsa:2048';
+    return {
+        publicKey: (0, keys_js_1.wrapPublicKey)(keyPair.publicKey, algorithm),
+        privateKey: (0, keys_js_1.wrapPrivateKey)(keyPair.privateKey, algorithm),
+    };
+}
+/**
+ * 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
+ */
+async function encryptWithPublicKey(payload, publicKey) {
+    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 = (0, keys_js_1.unwrapSymmetricKey)(payload);
+    }
+    else {
+        // Binary payload
+        payloadBuffer = payload.asArrayBuffer();
+    }
+    const cryptoKey = (0, keys_js_1.unwrapKey)(publicKey);
+    const result = await crypto.subtle.encrypt({ name: 'RSA-OAEP' }, cryptoKey, payloadBuffer);
+    return binary_js_1.Binary.fromArrayBuffer(result);
+}
+/**
+ * Decrypt a public-key encrypted payload with a private key
+ * @param  encryptedPayload  Payload to decrypt
+ * @param  privateKey        Opaque private key
+ * @return Decrypted payload
+ */
+async function decryptWithPrivateKey(encryptedPayload, privateKey) {
+    console.assert(typeof encryptedPayload === 'object', 'encryptedPayload must be object');
+    const cryptoKey = (0, keys_js_1.unwrapKey)(privateKey);
+    const payload = await crypto.subtle.decrypt({ name: 'RSA-OAEP' }, cryptoKey, encryptedPayload.asArrayBuffer());
+    const bufferView = new Uint8Array(payload);
+    return binary_js_1.Binary.fromArrayBuffer(bufferView.buffer);
+}
+//# sourceMappingURL=data:application/json;base64,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