@opentdf/sdk 0.1.0-beta.1701

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

@@ -0,0 +1,423 @@
+import { v4 } from 'uuid';
+import axios from 'axios';
+import { ZipReader, fromBuffer, fromDataSource, streamToBuffer, isAppIdProviderCheck, keyMiddleware as defaultKeyMiddleware, } from '../utils/index.js';
+import { base64 } from '../../../src/encodings/index.js';
+import { buildKeyAccess, fetchKasPublicKey, loadTDFStream, unwrapHtml, validatePolicyObject, readStream, wrapHtml, writeStream, } from '../tdf.js';
+import { OIDCRefreshTokenProvider } from '../../../src/auth/oidc-refreshtoken-provider.js';
+import { OIDCExternalJwtProvider } from '../../../src/auth/oidc-externaljwt-provider.js';
+import { AppIdAuthProvider, HttpRequest, withHeaders, } from '../../../src/auth/auth.js';
+import EAS from '../../../src/auth/Eas.js';
+import { cryptoPublicToPem, pemToCryptoPublicKey, rstrip, validateSecureUrl, } from '../../../src/utils.js';
+import { DecoratedReadableStream } from './DecoratedReadableStream.js';
+import { DEFAULT_SEGMENT_SIZE, DecryptParamsBuilder, EncryptParamsBuilder, } from './builders.js';
+import { OriginAllowList } from '../../../src/access.js';
+import { ConfigurationError } from '../../../src/errors.js';
+import { AesGcmCipher } from '../ciphers/aes-gcm-cipher.js';
+import { toCryptoKeyPair } from '../crypto/crypto-utils.js';
+import * as defaultCryptoService from '../crypto/index.js';
+import { AttributeSet, SplitKey } from '../models/index.js';
+import { plan } from '../../../src/policy/granter.js';
+import { attributeFQNsAsValues } from '../../../src/policy/api.js';
+const GLOBAL_BYTE_LIMIT = 64 * 1000 * 1000 * 1000; // 64 GB, see WS-9363.
+const HTML_BYTE_LIMIT = 100 * 1000 * 1000; // 100 MB, see WS-9476.
+// No default config for now. Delegate to Virtru wrapper for endpoints.
+const defaultClientConfig = { oidcOrigin: '', cryptoService: defaultCryptoService };
+export const uploadBinaryToS3 = async function (stream, uploadUrl, fileSize) {
+    try {
+        const body = await streamToBuffer(stream);
+        await axios.put(uploadUrl, body, {
+            headers: {
+                'Content-Length': fileSize,
+                'content-type': 'application/zip',
+                'cache-control': 'no-store',
+            },
+            maxContentLength: Infinity,
+            maxBodyLength: Infinity,
+        });
+    }
+    catch (e) {
+        console.error(e);
+        throw e;
+    }
+};
+const getFirstTwoBytes = async (chunker) => new TextDecoder().decode(await chunker(0, 2));
+const makeChunkable = async (source) => {
+    if (!source) {
+        throw new ConfigurationError('invalid source');
+    }
+    // dump stream to buffer
+    // we don't support streams anyways (see zipreader.js)
+    let initialChunker;
+    let buf = null;
+    switch (source.type) {
+        case 'stream':
+            buf = await streamToBuffer(source.location);
+            initialChunker = fromBuffer(buf);
+            break;
+        case 'buffer':
+            buf = source.location;
+            initialChunker = fromBuffer(buf);
+            break;
+        case 'chunker':
+            initialChunker = source.location;
+            break;
+        default:
+            initialChunker = await fromDataSource(source);
+    }
+    const magic = await getFirstTwoBytes(initialChunker);
+    // Pull first two bytes from source.
+    if (magic === 'PK') {
+        return initialChunker;
+    }
+    // Unwrap if it's html.
+    // If NOT zip (html), convert/dump to buffer, unwrap, and continue.
+    const htmlBuf = buf ?? (await initialChunker());
+    const zipBuf = unwrapHtml(htmlBuf);
+    return fromBuffer(zipBuf);
+};
+/*
+ * Extract a keypair provided as part of the options dict.
+ * Default to using the clientwide keypair, generating one if necessary.
+ *
+ * Additionally, update the auth injector with the (potentially new) pubkey
+ */
+export async function createSessionKeys({ authProvider, 
+// FIXME use cryptoservice to generate keys again
+cryptoService, dpopKeys, }) {
+    let signingKeys;
+    if (dpopKeys) {
+        signingKeys = await dpopKeys;
+    }
+    else {
+        const keys = await cryptoService.generateSigningKeyPair();
+        // signingKeys = await crypto.subtle.generateKey(rsaPkcs1Sha256(), true, ['sign']);
+        signingKeys = await toCryptoKeyPair(keys);
+    }
+    // This will contact the auth server and forcibly refresh the auth token claims,
+    // binding the token and the (new) pubkey together.
+    // Note that we base64 encode the PEM string here as a quick workaround, simply because
+    // a formatted raw PEM string isn't a valid header value and sending it raw makes keycloak's
+    // header parser barf. There are more subtle ways to solve this, but this works for now.
+    if (authProvider && !isAppIdProviderCheck(authProvider)) {
+        await authProvider?.updateClientPublicKey(signingKeys);
+    }
+    return signingKeys;
+}
+/*
+ * Create a policy object for an encrypt operation.
+ */
+function asPolicy(scope) {
+    if (scope.policyObject) {
+        // use the client override if provided
+        return scope.policyObject;
+    }
+    const policyId = scope.policyId ?? v4();
+    let dataAttributes;
+    if (scope.attributeValues) {
+        dataAttributes = scope.attributeValues
+            .filter(({ fqn }) => !!fqn)
+            .map(({ fqn }) => {
+            return { attribute: fqn };
+        });
+    }
+    else {
+        dataAttributes = (scope.attributes ?? []).map((attribute) => typeof attribute === 'string' ? { attribute } : attribute);
+    }
+    return {
+        uuid: policyId,
+        body: {
+            dataAttributes,
+            dissem: scope.dissem ?? [],
+        },
+    };
+}
+export class Client {
+    /**
+     * An abstraction for protecting and accessing data using TDF3 services.
+     * @param {Object} [config.keypair] - keypair generated for signing. Optional, will be generated by sdk if not passed
+     * @param {String} [config.clientId]
+     * @param {String} [config.kasEndpoint] - Key Access Server url
+     * @param {String} [config.refreshToken] - After logging in to browser OIDC interface user
+     * receives fresh token that needed by SDK for auth needs
+     * @param {String} [config.externalJwt] - JWT from external authority (eg Google)
+     * @param {String} [config.oidcOrigin] - Endpoint of authentication service
+     */
+    constructor(config) {
+        this.kasKeys = {};
+        const clientConfig = { ...defaultClientConfig, ...config };
+        this.cryptoService = clientConfig.cryptoService;
+        this.dpopEnabled = !!(clientConfig.dpopEnabled || clientConfig.dpopKeys);
+        clientConfig.readerUrl && (this.readerUrl = clientConfig.readerUrl);
+        if (clientConfig.kasEndpoint) {
+            this.kasEndpoint = clientConfig.kasEndpoint;
+        }
+        else {
+            // handle Deprecated `kasRewrapEndpoint` parameter
+            if (!clientConfig.keyRewrapEndpoint) {
+                throw new ConfigurationError('KAS definition not found');
+            }
+            this.kasEndpoint = clientConfig.keyRewrapEndpoint.replace(/\/rewrap$/, '');
+        }
+        this.kasEndpoint = rstrip(this.kasEndpoint, '/');
+        if (clientConfig.policyEndpoint) {
+            this.policyEndpoint = rstrip(clientConfig.policyEndpoint, '/');
+        }
+        else if (this.kasEndpoint.endsWith('/kas')) {
+            this.policyEndpoint = this.kasEndpoint.slice(0, -4);
+        }
+        const kasOrigin = new URL(this.kasEndpoint).origin;
+        if (clientConfig.allowedKases) {
+            this.allowedKases = new OriginAllowList(clientConfig.allowedKases, !!clientConfig.ignoreAllowList);
+            if (!validateSecureUrl(this.kasEndpoint) && !this.allowedKases.allows(kasOrigin)) {
+                throw new ConfigurationError(`Invalid KAS endpoint [${this.kasEndpoint}]`);
+            }
+        }
+        else {
+            if (!validateSecureUrl(this.kasEndpoint)) {
+                throw new ConfigurationError(`Invalid KAS endpoint [${this.kasEndpoint}]; to force, please list it among allowedKases`);
+            }
+            this.allowedKases = new OriginAllowList([kasOrigin], !!clientConfig.ignoreAllowList);
+        }
+        this.authProvider = config.authProvider;
+        this.clientConfig = clientConfig;
+        if (this.authProvider && isAppIdProviderCheck(this.authProvider)) {
+            this.eas = new EAS({
+                authProvider: this.authProvider,
+                endpoint: clientConfig.entityObjectEndpoint ?? `${clientConfig.easEndpoint}/api/entityobject`,
+            });
+        }
+        this.clientId = clientConfig.clientId;
+        if (!this.authProvider) {
+            if (!clientConfig.clientId) {
+                throw new ConfigurationError('Client ID or custom AuthProvider must be defined');
+            }
+            //Are we exchanging a refreshToken for a bearer token (normal AuthCode browser auth flow)?
+            //If this is a browser context, we expect the caller to handle the initial
+            //browser-based OIDC login and authentication process against the OIDC endpoint using their chosen method,
+            //and provide us with a valid refresh token/clientId obtained from that process.
+            if (clientConfig.refreshToken) {
+                this.authProvider = new OIDCRefreshTokenProvider({
+                    clientId: clientConfig.clientId,
+                    refreshToken: clientConfig.refreshToken,
+                    oidcOrigin: clientConfig.oidcOrigin,
+                });
+            }
+            else if (clientConfig.externalJwt) {
+                //Are we exchanging a JWT previously issued by a trusted external entity (e.g. Google) for a bearer token?
+                this.authProvider = new OIDCExternalJwtProvider({
+                    clientId: clientConfig.clientId,
+                    externalJwt: clientConfig.externalJwt,
+                    oidcOrigin: clientConfig.oidcOrigin,
+                });
+            }
+        }
+        this.dpopKeys = createSessionKeys({
+            authProvider: this.authProvider,
+            cryptoService: this.cryptoService,
+            dpopKeys: clientConfig.dpopKeys,
+        });
+        if (clientConfig.kasPublicKey) {
+            this.kasKeys[this.kasEndpoint] = Promise.resolve({
+                url: this.kasEndpoint,
+                algorithm: 'rsa:2048',
+                key: pemToCryptoPublicKey(clientConfig.kasPublicKey),
+                publicKey: clientConfig.kasPublicKey,
+            });
+        }
+    }
+    /**
+     * Encrypt plaintext into TDF ciphertext. One of the core operations of the Virtru SDK.
+     *
+     * @param scope dissem and attributes for constructing the policy
+     * @param source source object of unencrypted data
+     * @param [asHtml] If we should wrap the TDF data in a self-opening HTML wrapper. Defaults to false
+     * @param [autoconfigure] If we should use scope.attributes to configure KAOs
+     * @param [metadata] Additional non-secret data to store with the TDF
+     * @param [opts] Test only
+     * @param [mimeType] mime type of source. defaults to `unknown`
+     * @param [offline] Where to store the policy. Defaults to `false` - which results in `upsert` events to store/update a policy
+     * @param [windowSize] - segment size in bytes. Defaults to a a million bytes.
+     * @param [keyMiddleware] - function that handle keys
+     * @param [streamMiddleware] - function that handle stream
+     * @param [eo] - (deprecated) entity object
+     * @return a {@link https://nodejs.org/api/stream.html#stream_class_stream_readable|Readable} a new stream containing the TDF ciphertext
+     */
+    async encrypt({ scope = { attributes: [], dissem: [] }, autoconfigure, source, asHtml = false, metadata, mimeType, offline = false, windowSize = DEFAULT_SEGMENT_SIZE, eo, keyMiddleware = defaultKeyMiddleware, streamMiddleware = async (stream) => stream, splitPlan, assertionConfigs = [], }) {
+        const dpopKeys = await this.dpopKeys;
+        const policyObject = asPolicy(scope);
+        validatePolicyObject(policyObject);
+        if (!splitPlan && autoconfigure) {
+            let avs = scope.attributeValues ?? [];
+            const fqns = scope.attributes
+                ? scope.attributes.map((attribute) => typeof attribute === 'string' ? attribute : attribute.attribute)
+                : [];
+            if (!avs.length && fqns.length) {
+                // Hydrate avs from policy endpoint givnen the fqns
+                if (!this.policyEndpoint) {
+                    throw new ConfigurationError('policyEndpoint not set in TDF3 Client constructor');
+                }
+                avs = await attributeFQNsAsValues(this.policyEndpoint, this.authProvider, ...fqns);
+            }
+            else if (scope.attributeValues) {
+                avs = scope.attributeValues;
+                if (!scope.attributes) {
+                    scope.attributes = avs.map(({ fqn }) => fqn);
+                }
+            }
+            if (avs.length != scope.attributes?.length ||
+                !avs.map(({ fqn }) => fqn).every((a) => fqns.indexOf(a) >= 0)) {
+                throw new ConfigurationError(`Attribute mismatch between [${fqns}] and explicit values ${JSON.stringify(avs.map(({ fqn }) => fqn))}`);
+            }
+            const detailedPlan = plan(avs);
+            splitPlan = detailedPlan.map((kat) => {
+                const { kas, sid } = kat;
+                if (kas?.publicKey?.cached?.keys && !(kas.uri in this.kasKeys)) {
+                    const keys = kas.publicKey.cached.keys.filter(({ alg }) => alg == 'KAS_PUBLIC_KEY_ALG_ENUM_RSA_2048');
+                    if (keys?.length) {
+                        const key = keys[0];
+                        this.kasKeys[kas.uri] = Promise.resolve({
+                            key: pemToCryptoPublicKey(key.pem),
+                            publicKey: key.pem,
+                            url: kas.uri,
+                            algorithm: 'rsa:2048',
+                            kid: key.kid,
+                        });
+                    }
+                }
+                return { kas: kas.uri, sid };
+            });
+        }
+        // TODO: Refactor underlying builder to remove some of this unnecessary config.
+        const byteLimit = asHtml ? HTML_BYTE_LIMIT : GLOBAL_BYTE_LIMIT;
+        const encryptionInformation = new SplitKey(new AesGcmCipher(this.cryptoService));
+        let attributeSet;
+        let entity;
+        if (eo) {
+            entity = eo;
+            const s = new AttributeSet();
+            eo.attributes.forEach((attr) => s.addJwtAttribute(attr));
+            attributeSet = s;
+        }
+        const splits = splitPlan?.length ? splitPlan : [{ kas: this.kasEndpoint }];
+        encryptionInformation.keyAccess = await Promise.all(splits.map(async ({ kas, sid }) => {
+            if (!(kas in this.kasKeys)) {
+                this.kasKeys[kas] = fetchKasPublicKey(kas);
+            }
+            const kasPublicKey = await this.kasKeys[kas];
+            return buildKeyAccess({
+                attributeSet,
+                type: offline ? 'wrapped' : 'remote',
+                url: kasPublicKey.url,
+                kid: kasPublicKey.kid,
+                publicKey: kasPublicKey.publicKey,
+                metadata,
+                sid,
+            });
+        }));
+        const { keyForEncryption, keyForManifest } = await keyMiddleware();
+        const ecfg = {
+            allowList: this.allowedKases,
+            attributeSet,
+            byteLimit,
+            cryptoService: this.cryptoService,
+            dpopKeys,
+            encryptionInformation,
+            entity,
+            segmentSizeDefault: windowSize,
+            integrityAlgorithm: 'HS256',
+            segmentIntegrityAlgorithm: 'GMAC',
+            contentStream: source,
+            mimeType,
+            policy: policyObject,
+            authProvider: this.authProvider,
+            progressHandler: this.clientConfig.progressHandler,
+            keyForEncryption,
+            keyForManifest,
+            assertionConfigs,
+        };
+        const stream = await streamMiddleware(await writeStream(ecfg));
+        if (!asHtml) {
+            return stream;
+        }
+        // Wrap if it's html.
+        if (!stream.manifest) {
+            throw new Error('internal: missing manifest in encrypt function');
+        }
+        const htmlBuf = wrapHtml(await stream.toBuffer(), stream.manifest, this.readerUrl ?? '');
+        return new DecoratedReadableStream({
+            pull(controller) {
+                controller.enqueue(htmlBuf);
+                controller.close();
+            },
+        });
+    }
+    /**
+     * Decrypt TDF ciphertext into plaintext. One of the core operations of the Virtru SDK.
+     *
+     * @param params keyMiddleware fucntion to process key
+     * @param params streamMiddleware fucntion to process streamMiddleware
+     * @param params.source A data stream object, one of remote, stream, buffer, etc. types.
+     * @param params.eo Optional entity object (legacy AuthZ)
+     * @param params.assertionVerificationKeys Optional verification keys for assertions.
+     * @return a {@link https://nodejs.org/api/stream.html#stream_class_stream_readable|Readable} stream containing the decrypted plaintext.
+     * @see DecryptParamsBuilder
+     */
+    async decrypt({ eo, source, keyMiddleware = async (key) => key, streamMiddleware = async (stream) => stream, assertionVerificationKeys, noVerifyAssertions, }) {
+        const dpopKeys = await this.dpopKeys;
+        let entityObject;
+        if (this.eas || eo) {
+            const sessionPublicKey = await cryptoPublicToPem(dpopKeys.publicKey);
+            if (eo && eo.publicKey == sessionPublicKey) {
+                entityObject = eo;
+            }
+            else if (this.eas) {
+                entityObject = await this.eas.fetchEntityObject({
+                    publicKey: sessionPublicKey,
+                });
+            }
+        }
+        if (!this.authProvider) {
+            throw new ConfigurationError('AuthProvider missing');
+        }
+        const chunker = await makeChunkable(source);
+        // Await in order to catch any errors from this call.
+        // TODO: Write error event to stream and don't await.
+        return await streamMiddleware(await readStream({
+            allowList: this.allowedKases,
+            authProvider: this.authProvider,
+            chunker,
+            cryptoService: this.cryptoService,
+            dpopKeys,
+            entity: entityObject,
+            fileStreamServiceWorker: this.clientConfig.fileStreamServiceWorker,
+            keyMiddleware,
+            progressHandler: this.clientConfig.progressHandler,
+            assertionVerificationKeys,
+            noVerifyAssertions,
+        }));
+    }
+    /**
+     * Get the unique policyId associated with TDF ciphertext. Useful for managing authorization policies of encrypted data.
+     * <br/><br/>
+     * The policyId is embedded in the ciphertext so this is a local operation.
+     *
+     * @param {object} source - Required. TDF data stream,
+     * generated using {@link DecryptParamsBuilder#build|DecryptParamsBuilder's build()}.
+     * @return {string} - the unique policyId, which can be used for tracking purposes or policy management operations.
+     * @see DecryptParamsBuilder
+     */
+    async getPolicyId({ source }) {
+        const chunker = await makeChunkable(source);
+        const zipHelper = new ZipReader(chunker);
+        const centralDirectory = await zipHelper.getCentralDirectory();
+        const manifest = await zipHelper.getManifest(centralDirectory, '0.manifest.json');
+        const policyJson = base64.decode(manifest.encryptionInformation.policy);
+        return JSON.parse(policyJson).uuid;
+    }
+    async loadTDFStream({ source }) {
+        const chunker = await makeChunkable(source);
+        return loadTDFStream(chunker);
+    }
+}
+export { AppIdAuthProvider, DecryptParamsBuilder, EncryptParamsBuilder, HttpRequest, fromDataSource, withHeaders, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../../tdf3/src/client/index.ts"],"names":[],"mappings":"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"}

package/dist/web/tdf3/src/client/validation.js

@@ -0,0 +1,58 @@
+import { AttributeValidationError } from '../../../src/errors.js';
+const sageGetMatch = (match) => (match ? match[0] : null);
+export const ATTR_NAME_PROP_NAME = 'attr';
+export const ATTR_VALUE_PROP_NAME = 'value';
+// Validate attribute url protocol starts with `http://` or `https://`
+const SCHEME = '(https?://)';
+// validate url host be like `localhost:4000`
+const HOST_PORT = '([a-z0-9][a-z0-9]{1,}:[0-9]{1,4})';
+// validate url host be like `www.example.com`
+const WWW_HOST = '([a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z]{2,}';
+// validate url host be like `127.0.0.1:4000`
+const IP_HOST_PORT = '([0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}\\.[0-9]{1,3}:[0-9]{1,4})';
+// validate host is one of those above
+const HOST = `(${HOST_PORT}|${WWW_HOST}|${IP_HOST_PORT})`;
+// validate attr  name be like `/attr/<attr_name>`
+export const ATTR_NAME = `(/${ATTR_NAME_PROP_NAME}/[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]?)`;
+// validate value pattern
+export const ATTR_VALUE = `(/${ATTR_VALUE_PROP_NAME}/[a-zA-Z0-9][a-zA-Z0-9-]*[a-zA-Z0-9]?)`;
+// validate attribute authority  e.g. https://example.com
+const ATTR_AUTHORITY_PATTERN = `(${SCHEME}${HOST})`;
+// validate attribute namespace e.g. https://example.com/attr/someattribute
+const ATTR_NAMESPACE_PATTERN = `(${ATTR_AUTHORITY_PATTERN}${ATTR_NAME})`;
+// validate whole attribute e.g. https://example.com/attr/someattribute/value/somevalue
+export const ATTR_ATTRIBUTE_PATTERN = `^(${ATTR_NAMESPACE_PATTERN}${ATTR_VALUE})$`;
+export const validateAttributeObject = (attr) => {
+    const isObject = typeof attr === 'object';
+    if (!isObject) {
+        throw new AttributeValidationError(`attribute should be an object`, attr);
+    }
+    const { attribute } = attr;
+    const isString = typeof attribute === 'string';
+    if (!isString) {
+        throw new AttributeValidationError(`attribute prop should be a string`, attr);
+    }
+    return validateAttribute(attribute);
+};
+export function validateAttribute(attribute) {
+    if (!attribute.match(ATTR_ATTRIBUTE_PATTERN)) {
+        throw new AttributeValidationError(`attribute is in invalid format [${attribute}]`, attribute);
+    }
+    const ATTR_NAME_PREFIX = `/${ATTR_NAME_PROP_NAME}/`;
+    const ATTR_VALUE_PREFIX = `/${ATTR_VALUE_PROP_NAME}/`;
+    const attrNameMatch = sageGetMatch(attribute.match(ATTR_NAME));
+    const attrValueMatch = sageGetMatch(attribute.match(ATTR_VALUE));
+    if (!attrNameMatch) {
+        throw new AttributeValidationError(`attribute name matching error`, attribute);
+    }
+    if (!attrValueMatch) {
+        throw new AttributeValidationError(`attribute value matching error`, attribute);
+    }
+    const attributeName = attrNameMatch.slice(ATTR_NAME_PREFIX.length);
+    const attributeValue = attrValueMatch.slice(ATTR_VALUE_PREFIX.length);
+    if (attributeName === attributeValue) {
+        throw new AttributeValidationError(`attribute name should be unique with its value`, attribute);
+    }
+    return true;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/web/tdf3/src/crypto/crypto-utils.js

@@ -0,0 +1,107 @@
+import { base64 } from '../../../src/encodings/index.js';
+import { rsaPkcs1Sha256 } from './index.js';
+/**
+ * Validates a specified key size
+ * @param size in bits requested
+ * @param minSize in bits allowed
+ */
+export const isValidAsymmetricKeySize = (size, minSize) => {
+    // No size specified is fine because the minSize will be used
+    if (size === undefined) {
+        return !!minSize;
+    }
+    if (typeof size !== 'number' || (minSize && size < minSize)) {
+        return false;
+    }
+    return true;
+};
+/**
+ * Format a base64 string representation of a key file
+ * in PEM PKCS#8 format by adding a header and footer
+ * and new lines.
+ *
+ * The PEM spec says to use <CR><LF> (\r\n) per
+ * https://tools.ietf.org/html/rfc1421#section-4.3.2.2, but
+ * many implementations use just \n, so this function
+ * follows the convention over the spec.
+ *
+ * @param  base64KeyString input
+ * @param  label header and footer label that identifies key type
+ * @return formatted output
+ */
+export const formatAsPem = (bytes, label) => {
+    let pemCert = `-----BEGIN ${label}-----\n`;
+    let nextIndex = 0;
+    const base64KeyString = base64.encodeArrayBuffer(bytes);
+    while (nextIndex < base64KeyString.length) {
+        if (nextIndex + 64 <= base64KeyString.length) {
+            pemCert += `${base64KeyString.substr(nextIndex, 64)}\n`;
+        }
+        else {
+            pemCert += `${base64KeyString.substr(nextIndex)}\n`;
+        }
+        nextIndex += 64;
+    }
+    pemCert += `-----END ${label}-----\n`;
+    return pemCert;
+};
+/**
+ * Remove PEM formatting (new line characters and headers / footers)
+ * from a PEM string
+ *
+ * @param  input - PEM formatted string
+ * @return String with formatting removed
+ */
+export const removePemFormatting = (input) => {
+    if (typeof input !== 'string') {
+        console.error('Not a pem string', input);
+        return input;
+    }
+    const oneLiner = input.replace(/[\n\r]/g, '');
+    // https://www.rfc-editor.org/rfc/rfc7468#section-2
+    return oneLiner.replace(/-----(?:BEGIN|END)\s(?:RSA\s)?(?:PUBLIC|PRIVATE|CERTIFICATE)\sKEY-----/g, '');
+};
+const PEMRE = /-----BEGIN\s((?:RSA\s)?(?:PUBLIC\sKEY|PRIVATE\sKEY|CERTIFICATE))-----[\s0-9A-Za-z+/=]+-----END\s\1-----/;
+export const isPemKeyPair = (i) => {
+    const { privateKey, publicKey } = i;
+    if (typeof privateKey !== 'string' || typeof publicKey !== 'string') {
+        return false;
+    }
+    const privateMatch = PEMRE.exec(privateKey);
+    if (!privateMatch || !privateMatch[1] || privateMatch[1].indexOf('PRIVATE KEY') < 0) {
+        return false;
+    }
+    const publicMatch = PEMRE.exec(publicKey);
+    if (!publicMatch || !publicMatch[1] || publicMatch[1].indexOf('PRIVATE') >= 0) {
+        return false;
+    }
+    return true;
+};
+export const isCryptoKeyPair = (i) => {
+    const { privateKey, publicKey } = i;
+    if (typeof privateKey !== 'object' || typeof publicKey !== 'object') {
+        return false;
+    }
+    if (!(privateKey instanceof CryptoKey) || !(publicKey instanceof CryptoKey)) {
+        return false;
+    }
+    return privateKey.type === 'private' && publicKey.type === 'public';
+};
+export const toCryptoKeyPair = async (input) => {
+    if (isCryptoKeyPair(input)) {
+        return input;
+    }
+    if (!isPemKeyPair(input)) {
+        throw new Error('internal: generated invalid keypair');
+    }
+    const k = [input.publicKey, input.privateKey]
+        .map(removePemFormatting)
+        .map((e) => base64.decodeArrayBuffer(e));
+    const algorithm = rsaPkcs1Sha256();
+    const [publicKey, privateKey] = await Promise.all([
+        crypto.subtle.importKey('spki', k[0], algorithm, true, ['verify']),
+        crypto.subtle.importKey('pkcs8', k[1], algorithm, true, ['sign']),
+    ]);
+    return { privateKey, publicKey };
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+/**
+ * The minimum acceptable asymetric key size, currently 2^11.
+ */
+export const MIN_ASYMMETRIC_KEY_SIZE_BITS = 2048;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjbGFyYXRpb25zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vdGRmMy9zcmMvY3J5cHRvL2RlY2xhcmF0aW9ucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFzQkE7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSw0QkFBNEIsR0FBRyxJQUFJLENBQUMifQ==