@opentdf/sdk 0.1.0-beta.1701

package/dist/web/tdf3/src/tdf.js

@@ -0,0 +1,866 @@
+import axios from 'axios';
+import { unsigned } from './utils/buffer-crc32.js';
+import { exportSPKI, importX509 } from 'jose';
+import { DecoratedReadableStream } from './client/DecoratedReadableStream.js';
+import { pemToCryptoPublicKey, validateSecureUrl } from '../../src/utils.js';
+import * as assertions from './assertions.js';
+import { isRemote as isRemoteKeyAccess, Remote as KeyAccessRemote, Wrapped as KeyAccessWrapped, } from './models/index.js';
+import { base64 } from '../../src/encodings/index.js';
+import { ZipReader, ZipWriter, base64ToBuffer, isAppIdProviderCheck, keyMerge, buffToString, concatUint8, } from './utils/index.js';
+import { Binary } from './binary.js';
+import { OriginAllowList } from '../../src/access.js';
+import { ConfigurationError, DecryptError, InvalidFileError, IntegrityError, NetworkError, PermissionDeniedError, ServiceError, TdfError, UnauthenticatedError, UnsafeUrlError, UnsupportedFeatureError as UnsupportedError, } from '../../src/errors.js';
+import { htmlWrapperTemplate } from './templates/index.js';
+// configurable
+// TODO: remove dependencies from ciphers so that we can open-source instead of relying on other Virtru libs
+import { AesGcmCipher } from './ciphers/index.js';
+import { reqSignature, } from '../../src/auth/auth.js';
+// TODO: input validation on manifest JSON
+const DEFAULT_SEGMENT_SIZE = 1024 * 1024;
+/**
+ * If we have KAS url but not public key we can fetch it from KAS, fetching
+ * the value from `${kas}/kas_public_key`.
+ */
+export async function fetchKasPublicKey(kas, algorithm) {
+    if (!kas) {
+        throw new ConfigurationError('KAS definition not found');
+    }
+    // Logs insecure KAS. Secure is enforced in constructor
+    validateSecureUrl(kas);
+    const infoStatic = { url: kas, algorithm: algorithm || 'rsa:2048' };
+    const params = {};
+    if (algorithm) {
+        params.algorithm = algorithm;
+    }
+    const v2Url = `${kas}/v2/kas_public_key`;
+    try {
+        const response = await axios.get(v2Url, {
+            params: {
+                ...params,
+                v: '2',
+            },
+        });
+        const publicKey = typeof response.data === 'string'
+            ? await extractPemFromKeyString(response.data)
+            : response.data.publicKey;
+        return {
+            publicKey,
+            key: pemToCryptoPublicKey(publicKey),
+            ...infoStatic,
+            ...(typeof response.data !== 'string' && response.data.kid && { kid: response.data.kid }),
+        };
+    }
+    catch (cause) {
+        const status = cause?.response?.status;
+        switch (status) {
+            case 400:
+            case 404:
+                // KAS does not yet implement v2, maybe
+                break;
+            case 401:
+                throw new UnauthenticatedError(`[${v2Url}] requires auth`, cause);
+            case 403:
+                throw new PermissionDeniedError(`[${v2Url}] permission denied`, cause);
+            default:
+                if (status && status >= 400 && status < 500) {
+                    throw new ConfigurationError(`[${v2Url}] request error [${status}] [${cause.name}] [${cause.message}]`, cause);
+                }
+                throw new NetworkError(`[${v2Url}] error [${status}] [${cause.name}] [${cause.message}]`, cause);
+        }
+    }
+    // Retry with v1 params
+    const v1Url = `${kas}/kas_public_key`;
+    try {
+        const response = await axios.get(v1Url, {
+            params,
+        });
+        const publicKey = typeof response.data === 'string'
+            ? await extractPemFromKeyString(response.data)
+            : response.data.publicKey;
+        // future proof: allow v2 response even if not specified.
+        return {
+            publicKey,
+            key: pemToCryptoPublicKey(publicKey),
+            ...infoStatic,
+            ...(typeof response.data !== 'string' && response.data.kid && { kid: response.data.kid }),
+        };
+    }
+    catch (cause) {
+        const status = cause?.response?.status;
+        switch (status) {
+            case 401:
+                throw new UnauthenticatedError(`[${v1Url}] requires auth`, cause);
+            case 403:
+                throw new PermissionDeniedError(`[${v1Url}] permission denied`, cause);
+            default:
+                if (status && status >= 400 && status < 500) {
+                    throw new ConfigurationError(`[${v2Url}] request error [${status}] [${cause.name}] [${cause.message}]`, cause);
+                }
+                throw new NetworkError(`[${v1Url}] error [${status}] [${cause.name}] [${cause.message}]`, cause);
+        }
+    }
+}
+/**
+ *
+ * @param payload The TDF content to encode in HTML
+ * @param manifest A copy of the manifest
+ * @param transferUrl reader web-service start page
+ * @return utf-8 encoded HTML data
+ */
+export function wrapHtml(payload, manifest, transferUrl) {
+    const { origin } = new URL(transferUrl);
+    const exportManifest = typeof manifest === 'string' ? manifest : JSON.stringify(manifest);
+    const fullHtmlString = htmlWrapperTemplate({
+        transferUrl,
+        transferBaseUrl: origin,
+        manifest: base64.encode(exportManifest),
+        payload: buffToString(payload, 'base64'),
+    });
+    return new TextEncoder().encode(fullHtmlString);
+}
+export function unwrapHtml(htmlPayload) {
+    let html;
+    if (htmlPayload instanceof ArrayBuffer || ArrayBuffer.isView(htmlPayload)) {
+        html = new TextDecoder().decode(htmlPayload);
+    }
+    else {
+        html = htmlPayload.toString();
+    }
+    const payloadRe = /<input id=['"]?data-input['"]?[^>]*?value=['"]?([a-zA-Z0-9+/=]+)['"]?/;
+    const reResult = payloadRe.exec(html);
+    if (reResult === null) {
+        throw new InvalidFileError('Payload is missing');
+    }
+    const base64Payload = reResult[1];
+    try {
+        return base64ToBuffer(base64Payload);
+    }
+    catch (e) {
+        throw new InvalidFileError('There was a problem extracting the TDF3 payload', e);
+    }
+}
+export async function extractPemFromKeyString(keyString) {
+    let pem = keyString;
+    // Skip the public key extraction if we find that the KAS url provides a
+    // PEM-encoded key instead of certificate
+    if (keyString.includes('CERTIFICATE')) {
+        const cert = await importX509(keyString, 'RS256', { extractable: true });
+        pem = await exportSPKI(cert);
+    }
+    return pem;
+}
+/**
+ * Build a key access object and add it to the list. Can specify either
+ * a (url, publicKey) pair (legacy, deprecated) or an attribute URL (future).
+ * If all are missing then it attempts to use the default attribute. If that
+ * is missing it throws an error.
+ * @param  {Object} options
+ * @param  {String} options.type - enum representing how the object key is treated
+ * @param  {String} options.attributeUrl - URL of the attribute to use for pubKey and kasUrl. Omit to use default.
+ * @param  {String} options.url - directly set the KAS URL
+ * @param  {String} options.publicKey - directly set the (KAS) public key
+ * @param  {String?} options.kid - Key identifier of KAS public key
+ * @param  {String? Object?} options.metadata - Metadata. Appears to be dead code.
+ * @return {KeyAccess}- the key access object loaded
+ */
+export async function buildKeyAccess({ attributeSet, type, url, publicKey, kid, attributeUrl, metadata, sid = '', }) {
+    /** Internal function to keep it DRY */
+    function createKeyAccess(type, kasUrl, kasKeyIdentifier, pubKey, metadata) {
+        switch (type) {
+            case 'wrapped':
+                return new KeyAccessWrapped(kasUrl, kasKeyIdentifier, pubKey, metadata, sid);
+            case 'remote':
+                return new KeyAccessRemote(kasUrl, kasKeyIdentifier, pubKey, metadata, sid);
+            default:
+                throw new ConfigurationError(`buildKeyAccess: Key access type ${type} is unknown`);
+        }
+    }
+    // If an attributeUrl is provided try to load with that first.
+    if (attributeUrl && attributeSet) {
+        const attr = attributeSet.get(attributeUrl);
+        if (attr && attr.kasUrl && attr.pubKey) {
+            return createKeyAccess(type, attr.kasUrl, attr.kid, attr.pubKey, metadata);
+        }
+    }
+    // if url and pulicKey are specified load the key access object with them
+    if (url && publicKey) {
+        return createKeyAccess(type, url, kid, await extractPemFromKeyString(publicKey), metadata);
+    }
+    // Assume the default attribute is the source for kasUrl and pubKey
+    const defaultAttr = attributeSet?.getDefault();
+    if (defaultAttr) {
+        const { pubKey, kasUrl } = defaultAttr;
+        if (pubKey && kasUrl) {
+            return createKeyAccess(type, kasUrl, kid, await extractPemFromKeyString(pubKey), metadata);
+        }
+    }
+    // All failed. Raise an error.
+    throw new ConfigurationError('TDF.buildKeyAccess: No source for kasUrl or pubKey');
+}
+export function validatePolicyObject(policy) {
+    const missingFields = [];
+    if (!policy.uuid)
+        missingFields.push('uuid');
+    if (!policy.body)
+        missingFields.push('body', 'body.dissem');
+    if (policy.body && !policy.body.dissem)
+        missingFields.push('body.dissem');
+    if (missingFields.length) {
+        throw new ConfigurationError(`The given policy object requires the following properties: ${missingFields}`);
+    }
+}
+async function _generateManifest(keyInfo, encryptionInformation, policy, mimeType) {
+    // (maybe) Fields are quoted to avoid renaming
+    const payload = {
+        type: 'reference',
+        url: '0.payload',
+        protocol: 'zip',
+        isEncrypted: true,
+        schemaVersion: '3.0.0',
+        ...(mimeType && { mimeType }),
+    };
+    const encryptionInformationStr = await encryptionInformation.write(policy, keyInfo);
+    const assertions = [];
+    return {
+        payload,
+        // generate the manifest first, then insert integrity information into it
+        encryptionInformation: encryptionInformationStr,
+        assertions: assertions,
+    };
+}
+async function getSignature(unwrappedKeyBinary, payloadBinary, algorithmType, cryptoService) {
+    switch (algorithmType.toUpperCase()) {
+        case 'GMAC':
+            // use the auth tag baked into the encrypted payload
+            return buffToString(Uint8Array.from(payloadBinary.asByteArray()).slice(-16), 'hex');
+        case 'HS256':
+            // simple hmac is the default
+            return await cryptoService.hmac(buffToString(new Uint8Array(unwrappedKeyBinary.asArrayBuffer()), 'hex'), buffToString(new Uint8Array(payloadBinary.asArrayBuffer()), 'utf-8'));
+        default:
+            throw new ConfigurationError(`Unsupported signature alg [${algorithmType}]`);
+    }
+}
+function buildRequest(method, url, body) {
+    return {
+        headers: {},
+        method: method,
+        url: url,
+        body,
+    };
+}
+export async function upsert({ allowedKases, allowList, authProvider, entity, privateKey, unsavedManifest, ignoreType, }) {
+    const allowed = (() => {
+        if (allowList) {
+            return allowList;
+        }
+        if (!allowedKases) {
+            throw new ConfigurationError('Upsert cannot be done without allowlist');
+        }
+        return new OriginAllowList(allowedKases);
+    })();
+    const { keyAccess, policy } = unsavedManifest.encryptionInformation;
+    const isAppIdProvider = authProvider && isAppIdProviderCheck(authProvider);
+    if (authProvider === undefined) {
+        throw new ConfigurationError('Upsert cannot be done without auth provider');
+    }
+    return Promise.all(keyAccess.map(async (keyAccessObject) => {
+        // We only care about remote key access objects for the policy sync portion
+        const isRemote = isRemoteKeyAccess(keyAccessObject);
+        if (!ignoreType && !isRemote) {
+            return;
+        }
+        if (!allowed.allows(keyAccessObject.url)) {
+            throw new UnsafeUrlError(`Unexpected KAS url: [${keyAccessObject.url}]`);
+        }
+        const url = `${keyAccessObject.url}/${isAppIdProvider ? '' : 'v2/'}upsert`;
+        //TODO I dont' think we need a body at all for KAS requests
+        // Do we need ANY of this if it's already embedded in the EO in the Bearer OIDC token?
+        const body = {
+            keyAccess: keyAccessObject,
+            policy: unsavedManifest.encryptionInformation.policy,
+            entity: isAppIdProviderCheck(authProvider) ? entity : undefined,
+            authToken: undefined,
+            clientPayloadSignature: undefined,
+        };
+        if (isAppIdProviderCheck(authProvider)) {
+            body.authToken = await reqSignature({}, privateKey);
+        }
+        else {
+            body.clientPayloadSignature = await reqSignature(body, privateKey);
+        }
+        const httpReq = await authProvider.withCreds(buildRequest('POST', url, body));
+        try {
+            const response = await axios.post(httpReq.url, httpReq.body, {
+                headers: httpReq.headers,
+            });
+            // Remove additional properties which were needed to sync, but not that we want to save to
+            // the manifest
+            delete keyAccessObject.wrappedKey;
+            delete keyAccessObject.encryptedMetadata;
+            delete keyAccessObject.policyBinding;
+            if (isRemote) {
+                // Decode the policy and extract only the required info to save -- the uuid
+                const decodedPolicy = JSON.parse(base64.decode(policy));
+                unsavedManifest.encryptionInformation.policy = base64.encode(JSON.stringify({ uuid: decodedPolicy.uuid }));
+            }
+            return response.data;
+        }
+        catch (e) {
+            if (e.response) {
+                if (e.response.status >= 500) {
+                    throw new ServiceError('upsert failure', e);
+                }
+                else if (e.response.status === 403) {
+                    throw new PermissionDeniedError('upsert failure', e);
+                }
+                else if (e.response.status === 401) {
+                    throw new UnauthenticatedError('upsert auth failure', e);
+                }
+                else if (e.response.status === 400) {
+                    throw new ConfigurationError('upsert bad request; likely a configuration error', e);
+                }
+                else {
+                    throw new NetworkError('upsert server error', e);
+                }
+            }
+            else if (e.request) {
+                throw new NetworkError('upsert request failure', e);
+            }
+            throw new TdfError(`Unable to perform upsert operation on the KAS: [${e.name}: ${e.message}], response: [${e?.response?.body}]`, e);
+        }
+    }));
+}
+export async function writeStream(cfg) {
+    if (!cfg.authProvider) {
+        throw new ConfigurationError('No authorization middleware defined');
+    }
+    if (!cfg.contentStream) {
+        throw new ConfigurationError('No input stream defined');
+    }
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    const segmentInfos = [];
+    cfg.byteLimit ??= Number.MAX_SAFE_INTEGER;
+    const entryInfos = [
+        {
+            filename: '0.payload',
+        },
+        {
+            filename: '0.manifest.json',
+        },
+    ];
+    let currentBuffer = new Uint8Array();
+    let totalByteCount = 0;
+    let bytesProcessed = 0;
+    let crcCounter = 0;
+    let fileByteCount = 0;
+    let aggregateHash = '';
+    const zipWriter = new ZipWriter();
+    const manifest = await _generateManifest(cfg.keyForManifest, cfg.encryptionInformation, cfg.policy, cfg.mimeType);
+    if (!manifest) {
+        // Set in encrypt; should never be reached.
+        throw new ConfigurationError('internal: please use "loadTDFStream" first to load a manifest.');
+    }
+    const pkKeyLike = cfg.dpopKeys.privateKey;
+    // For all remote key access objects, sync its policy
+    const upsertResponse = await upsert({
+        allowedKases: cfg.allowList ? undefined : cfg.allowedKases,
+        allowList: cfg.allowList,
+        authProvider: cfg.authProvider,
+        entity: cfg.entity,
+        privateKey: pkKeyLike,
+        unsavedManifest: manifest,
+    });
+    // determine default segment size by writing empty buffer
+    const { segmentSizeDefault } = cfg;
+    const encryptedBlargh = await cfg.encryptionInformation.encrypt(Binary.fromArrayBuffer(new ArrayBuffer(segmentSizeDefault)), cfg.keyForEncryption.unwrappedKeyBinary);
+    const payloadBuffer = new Uint8Array(encryptedBlargh.payload.asByteArray());
+    const encryptedSegmentSizeDefault = payloadBuffer.length;
+    // start writing the content
+    entryInfos[0].filename = '0.payload';
+    entryInfos[0].offset = totalByteCount;
+    const sourceReader = cfg.contentStream.getReader();
+    /*
+    TODO: Code duplication should be addressed
+    - RCA operations require that the write stream has already finished executing it's .on('end') handler before being returned,
+      thus both handlers are wrapped in a encompassing promise when we have an RCA source. We should investigate
+      if this causes O(n) promises to be loaded into memory.
+    - LFS operations can have the write stream returned immediately after both .on('end') and .on('data') handlers
+      have been defined, thus not requiring the handlers to be wrapped in a promise.
+    */
+    const underlingSource = {
+        start: (controller) => {
+            controller.enqueue(getHeader(entryInfos[0].filename));
+            _countChunk(getHeader(entryInfos[0].filename));
+            crcCounter = 0;
+            fileByteCount = 0;
+        },
+        pull: async (controller) => {
+            let isDone;
+            while (currentBuffer.length < segmentSizeDefault && !isDone) {
+                const { value, done } = await sourceReader.read();
+                isDone = done;
+                if (value) {
+                    currentBuffer = concatUint8([currentBuffer, value]);
+                }
+            }
+            while (currentBuffer.length >= segmentSizeDefault &&
+                !!controller.desiredSize &&
+                controller.desiredSize > 0) {
+                const segment = currentBuffer.slice(0, segmentSizeDefault);
+                const encryptedSegment = await _encryptAndCountSegment(segment);
+                controller.enqueue(encryptedSegment);
+                currentBuffer = currentBuffer.slice(segmentSizeDefault);
+            }
+            const isFinalChunkLeft = isDone && currentBuffer.length;
+            if (isFinalChunkLeft) {
+                const encryptedSegment = await _encryptAndCountSegment(currentBuffer);
+                controller.enqueue(encryptedSegment);
+                currentBuffer = new Uint8Array();
+            }
+            if (isDone && currentBuffer.length === 0) {
+                entryInfos[0].crcCounter = crcCounter;
+                entryInfos[0].fileByteCount = fileByteCount;
+                const payloadDataDescriptor = zipWriter.writeDataDescriptor(crcCounter, fileByteCount);
+                controller.enqueue(payloadDataDescriptor);
+                _countChunk(payloadDataDescriptor);
+                // prepare the manifest
+                entryInfos[1].filename = '0.manifest.json';
+                entryInfos[1].offset = totalByteCount;
+                controller.enqueue(getHeader(entryInfos[1].filename));
+                _countChunk(getHeader(entryInfos[1].filename));
+                crcCounter = 0;
+                fileByteCount = 0;
+                // hash the concat of all hashes
+                const payloadSigStr = await getSignature(cfg.keyForEncryption.unwrappedKeyBinary, Binary.fromString(aggregateHash), cfg.integrityAlgorithm, cfg.cryptoService);
+                manifest.encryptionInformation.integrityInformation.rootSignature.sig =
+                    base64.encode(payloadSigStr);
+                manifest.encryptionInformation.integrityInformation.rootSignature.alg =
+                    cfg.integrityAlgorithm;
+                manifest.encryptionInformation.integrityInformation.segmentSizeDefault = segmentSizeDefault;
+                manifest.encryptionInformation.integrityInformation.encryptedSegmentSizeDefault =
+                    encryptedSegmentSizeDefault;
+                manifest.encryptionInformation.integrityInformation.segmentHashAlg =
+                    cfg.segmentIntegrityAlgorithm;
+                manifest.encryptionInformation.integrityInformation.segments = segmentInfos;
+                manifest.encryptionInformation.method.isStreamable = true;
+                const signedAssertions = [];
+                if (cfg.assertionConfigs && cfg.assertionConfigs.length > 0) {
+                    await Promise.all(cfg.assertionConfigs.map(async (assertionConfig) => {
+                        // Create assertion using the assertionConfig values
+                        const signingKey = assertionConfig.signingKey ?? {
+                            alg: 'HS256',
+                            key: new Uint8Array(cfg.keyForEncryption.unwrappedKeyBinary.asArrayBuffer()),
+                        };
+                        const assertion = await assertions.CreateAssertion(aggregateHash, {
+                            ...assertionConfig,
+                            signingKey,
+                        });
+                        // Add signed assertion to the signedAssertions array
+                        signedAssertions.push(assertion);
+                    }));
+                }
+                manifest.assertions = signedAssertions;
+                // write the manifest
+                const manifestBuffer = new TextEncoder().encode(JSON.stringify(manifest));
+                controller.enqueue(manifestBuffer);
+                _countChunk(manifestBuffer);
+                entryInfos[1].crcCounter = crcCounter;
+                entryInfos[1].fileByteCount = fileByteCount;
+                const manifestDataDescriptor = zipWriter.writeDataDescriptor(crcCounter, fileByteCount);
+                controller.enqueue(manifestDataDescriptor);
+                _countChunk(manifestDataDescriptor);
+                // write the central directory out
+                const centralDirectoryByteCount = totalByteCount;
+                for (let i = 0; i < entryInfos.length; i++) {
+                    const entryInfo = entryInfos[i];
+                    const result = zipWriter.writeCentralDirectoryRecord(entryInfo.fileByteCount || 0, entryInfo.filename, entryInfo.offset || 0, entryInfo.crcCounter || 0, 2175008768);
+                    controller.enqueue(result);
+                    _countChunk(result);
+                }
+                const endOfCentralDirectoryByteCount = totalByteCount - centralDirectoryByteCount;
+                const finalChunk = zipWriter.writeEndOfCentralDirectoryRecord(entryInfos.length, endOfCentralDirectoryByteCount, centralDirectoryByteCount);
+                controller.enqueue(finalChunk);
+                _countChunk(finalChunk);
+                controller.close();
+            }
+        },
+    };
+    const plaintextStream = new DecoratedReadableStream(underlingSource);
+    plaintextStream.manifest = manifest;
+    if (upsertResponse) {
+        plaintextStream.upsertResponse = upsertResponse;
+        plaintextStream.tdfSize = totalByteCount;
+        plaintextStream.algorithm = manifest.encryptionInformation.method.algorithm;
+    }
+    return plaintextStream;
+    // nested helper fn's
+    function getHeader(filename) {
+        return zipWriter.getLocalFileHeader(filename, 0, 0, 0);
+    }
+    function _countChunk(chunk) {
+        if (typeof chunk === 'string') {
+            chunk = new TextEncoder().encode(chunk);
+        }
+        totalByteCount += chunk.length;
+        if (totalByteCount > cfg.byteLimit) {
+            throw new ConfigurationError(`Safe byte limit (${cfg.byteLimit}) exceeded`);
+        }
+        //new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+        crcCounter = unsigned(chunk, crcCounter);
+        fileByteCount += chunk.length;
+    }
+    async function _encryptAndCountSegment(chunk) {
+        bytesProcessed += chunk.length;
+        cfg.progressHandler?.(bytesProcessed);
+        // Don't pass in an IV here. The encrypt function will generate one for you, ensuring that each segment has a unique IV.
+        const encryptedResult = await cfg.encryptionInformation.encrypt(Binary.fromArrayBuffer(chunk.buffer), cfg.keyForEncryption.unwrappedKeyBinary);
+        const payloadBuffer = new Uint8Array(encryptedResult.payload.asByteArray());
+        const payloadSigStr = await getSignature(cfg.keyForEncryption.unwrappedKeyBinary, encryptedResult.payload, cfg.segmentIntegrityAlgorithm, cfg.cryptoService);
+        // combined string of all hashes for root signature
+        aggregateHash += payloadSigStr;
+        segmentInfos.push({
+            hash: base64.encode(payloadSigStr),
+            segmentSize: chunk.length === segmentSizeDefault ? undefined : chunk.length,
+            encryptedSegmentSize: payloadBuffer.length === encryptedSegmentSizeDefault ? undefined : payloadBuffer.length,
+        });
+        const result = new Uint8Array(encryptedResult.payload.asByteArray());
+        _countChunk(result);
+        return result;
+    }
+}
+// load the TDF as a stream in memory, for further use in reading and key syncing
+export async function loadTDFStream(chunker) {
+    const zipReader = new ZipReader(chunker);
+    const centralDirectory = await zipReader.getCentralDirectory();
+    const manifest = await zipReader.getManifest(centralDirectory, '0.manifest.json');
+    return { manifest, zipReader, centralDirectory };
+}
+export function splitLookupTableFactory(keyAccess, allowedKases) {
+    const allowed = (k) => allowedKases.allows(k.url);
+    const splitIds = new Set(keyAccess.map(({ sid }) => sid ?? ''));
+    const accessibleSplits = new Set(keyAccess.filter(allowed).map(({ sid }) => sid));
+    if (splitIds.size > accessibleSplits.size) {
+        const disallowedKases = new Set(keyAccess.filter((k) => !allowed(k)).map(({ url }) => url));
+        throw new UnsafeUrlError(`Unreconstructable key - disallowed KASes include: ${JSON.stringify([
+            ...disallowedKases,
+        ])} from splitIds ${JSON.stringify([...splitIds])}`, ...disallowedKases);
+    }
+    const splitPotentials = Object.fromEntries([...splitIds].map((s) => [s, {}]));
+    for (const kao of keyAccess) {
+        const disjunction = splitPotentials[kao.sid ?? ''];
+        if (kao.url in disjunction) {
+            throw new InvalidFileError(`TODO: Fallback to no split ids. Repetition found for [${kao.url}] on split [${kao.sid}]`);
+        }
+        if (allowed(kao)) {
+            disjunction[kao.url] = kao;
+        }
+    }
+    return splitPotentials;
+}
+async function unwrapKey({ manifest, allowedKases, authProvider, dpopKeys, entity, cryptoService, }) {
+    if (authProvider === undefined) {
+        throw new ConfigurationError('upsert requires auth provider; must be configured in client constructor');
+    }
+    const { keyAccess } = manifest.encryptionInformation;
+    const splitPotentials = splitLookupTableFactory(keyAccess, allowedKases);
+    const isAppIdProvider = authProvider && isAppIdProviderCheck(authProvider);
+    async function tryKasRewrap(keySplitInfo) {
+        const url = `${keySplitInfo.url}/${isAppIdProvider ? '' : 'v2/'}rewrap`;
+        const ephemeralEncryptionKeys = await cryptoService.cryptoToPemPair(await cryptoService.generateKeyPair());
+        const clientPublicKey = ephemeralEncryptionKeys.publicKey;
+        const requestBodyStr = JSON.stringify({
+            algorithm: 'RS256',
+            keyAccess: keySplitInfo,
+            policy: manifest.encryptionInformation.policy,
+            clientPublicKey,
+        });
+        const jwtPayload = { requestBody: requestBodyStr };
+        const signedRequestToken = await reqSignature(isAppIdProvider ? {} : jwtPayload, dpopKeys.privateKey);
+        let requestBody;
+        if (isAppIdProvider) {
+            requestBody = {
+                keyAccess: keySplitInfo,
+                policy: manifest.encryptionInformation.policy,
+                entity: {
+                    ...entity,
+                    publicKey: clientPublicKey,
+                },
+                authToken: signedRequestToken,
+            };
+        }
+        else {
+            requestBody = {
+                signedRequestToken,
+            };
+        }
+        const httpReq = await authProvider.withCreds(buildRequest('POST', url, requestBody));
+        const { data: { entityWrappedKey, metadata }, } = await axios.post(httpReq.url, httpReq.body, { headers: httpReq.headers });
+        const key = Binary.fromString(base64.decode(entityWrappedKey));
+        const decryptedKeyBinary = await cryptoService.decryptWithPrivateKey(key, ephemeralEncryptionKeys.privateKey);
+        return {
+            key: new Uint8Array(decryptedKeyBinary.asByteArray()),
+            metadata,
+        };
+    }
+    // Get unique split IDs to determine if we have an OR or AND condition
+    const splitIds = new Set(Object.keys(splitPotentials));
+    // If we have only one split ID, it's an OR condition
+    if (splitIds.size === 1) {
+        const [splitId] = splitIds;
+        const potentials = splitPotentials[splitId];
+        try {
+            // OR condition: Try all KAS servers for this split, take first success
+            const result = await Promise.any(Object.values(potentials).map(async (keySplitInfo) => {
+                try {
+                    return await tryKasRewrap(keySplitInfo);
+                }
+                catch (e) {
+                    // Rethrow with more context
+                    throw handleRewrapError(e);
+                }
+            }));
+            const reconstructedKey = keyMerge([result.key]);
+            return {
+                reconstructedKeyBinary: Binary.fromArrayBuffer(reconstructedKey),
+                metadata: result.metadata,
+            };
+        }
+        catch (error) {
+            if (error instanceof AggregateError) {
+                // All KAS servers failed
+                throw error.errors[0]; // Throw the first error since we've already wrapped them
+            }
+            throw error;
+        }
+    }
+    else {
+        // AND condition: We need successful results from all different splits
+        const splitResults = await Promise.all(Object.entries(splitPotentials).map(async ([splitId, potentials]) => {
+            if (!potentials || !Object.keys(potentials).length) {
+                throw new UnsafeUrlError(`Unreconstructable key - no valid KAS found for split ${JSON.stringify(splitId)}`, '');
+            }
+            try {
+                // For each split, try all potential KAS servers until one succeeds
+                return await Promise.any(Object.values(potentials).map(async (keySplitInfo) => {
+                    try {
+                        return await tryKasRewrap(keySplitInfo);
+                    }
+                    catch (e) {
+                        throw handleRewrapError(e);
+                    }
+                }));
+            }
+            catch (error) {
+                if (error instanceof AggregateError) {
+                    // All KAS servers for this split failed
+                    throw error.errors[0]; // Throw the first error since we've already wrapped them
+                }
+                throw error;
+            }
+        }));
+        // Merge all the split keys
+        const reconstructedKey = keyMerge(splitResults.map((r) => r.key));
+        return {
+            reconstructedKeyBinary: Binary.fromArrayBuffer(reconstructedKey),
+            metadata: splitResults[0].metadata, // Use metadata from first split
+        };
+    }
+}
+function handleRewrapError(error) {
+    if (axios.isAxiosError(error)) {
+        if (error.response?.status && error.response?.status >= 500) {
+            return new ServiceError('rewrap failure', error);
+        }
+        else if (error.response?.status === 403) {
+            return new PermissionDeniedError('rewrap failure', error);
+        }
+        else if (error.response?.status === 401) {
+            return new UnauthenticatedError('rewrap auth failure', error);
+        }
+        else if (error.response?.status === 400) {
+            return new InvalidFileError('rewrap bad request; could indicate an invalid policy binding or a configuration error', error);
+        }
+        else {
+            return new NetworkError('rewrap server error', error);
+        }
+    }
+    else {
+        if (error.name === 'InvalidAccessError' || error.name === 'OperationError') {
+            return new DecryptError('unable to unwrap key from kas', error);
+        }
+        return new InvalidFileError(`Unable to decrypt the response from KAS: [${error.name}: ${error.message}]`, error);
+    }
+}
+async function decryptChunk(encryptedChunk, reconstructedKeyBinary, hash, cipher, segmentIntegrityAlgorithm, cryptoService) {
+    if (segmentIntegrityAlgorithm !== 'GMAC' && segmentIntegrityAlgorithm !== 'HS256') {
+    }
+    const segmentHashStr = await getSignature(reconstructedKeyBinary, Binary.fromArrayBuffer(encryptedChunk.buffer), segmentIntegrityAlgorithm, cryptoService);
+    if (hash !== btoa(segmentHashStr)) {
+        throw new IntegrityError('Failed integrity check on segment hash');
+    }
+    return await cipher.decrypt(encryptedChunk, reconstructedKeyBinary);
+}
+async function updateChunkQueue(chunkMap, centralDirectory, zipReader, reconstructedKeyBinary, cipher, segmentIntegrityAlgorithm, cryptoService) {
+    const chunksInOneDownload = 500;
+    let requests = [];
+    const maxLength = 3;
+    for (let i = 0; i < chunkMap.length; i += chunksInOneDownload) {
+        if (requests.length === maxLength) {
+            await Promise.all(requests);
+            requests = [];
+        }
+        requests.push((async () => {
+            let buffer;
+            const slice = chunkMap.slice(i, i + chunksInOneDownload);
+            try {
+                const bufferSize = slice.reduce((currentVal, { encryptedSegmentSize }) => currentVal + encryptedSegmentSize, 0);
+                buffer = await zipReader.getPayloadSegment(centralDirectory, '0.payload', slice[0].encryptedOffset, bufferSize);
+            }
+            catch (e) {
+                if (e instanceof InvalidFileError) {
+                    throw e;
+                }
+                throw new NetworkError('unable to fetch payload segment', e);
+            }
+            if (buffer) {
+                sliceAndDecrypt({
+                    buffer,
+                    cryptoService,
+                    reconstructedKeyBinary,
+                    slice,
+                    cipher,
+                    segmentIntegrityAlgorithm,
+                });
+            }
+        })());
+    }
+}
+export async function sliceAndDecrypt({ buffer, reconstructedKeyBinary, slice, cipher, cryptoService, segmentIntegrityAlgorithm, }) {
+    for (const index in slice) {
+        const { encryptedOffset, encryptedSegmentSize, _resolve, _reject } = slice[index];
+        const offset = slice[0].encryptedOffset === 0 ? encryptedOffset : encryptedOffset % slice[0].encryptedOffset;
+        const encryptedChunk = new Uint8Array(buffer.slice(offset, offset + encryptedSegmentSize));
+        try {
+            const result = await decryptChunk(encryptedChunk, reconstructedKeyBinary, slice[index]['hash'], cipher, segmentIntegrityAlgorithm, cryptoService);
+            slice[index].decryptedChunk = result;
+            if (_resolve) {
+                _resolve(null);
+            }
+        }
+        catch (e) {
+            if (_reject) {
+                _reject(e);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+}
+export async function readStream(cfg) {
+    let { allowList } = cfg;
+    if (!allowList) {
+        if (!cfg.allowedKases) {
+            throw new ConfigurationError('Upsert cannot be done without allowlist');
+        }
+        allowList = new OriginAllowList(cfg.allowedKases);
+    }
+    const { manifest, zipReader, centralDirectory } = await loadTDFStream(cfg.chunker);
+    if (!manifest) {
+        throw new InvalidFileError('Missing manifest data');
+    }
+    cfg.keyMiddleware ??= async (key) => key;
+    const { encryptedSegmentSizeDefault: defaultSegmentSize, rootSignature, segmentHashAlg, segments, } = manifest.encryptionInformation.integrityInformation;
+    const { metadata, reconstructedKeyBinary } = await unwrapKey({
+        manifest,
+        authProvider: cfg.authProvider,
+        allowedKases: allowList,
+        dpopKeys: cfg.dpopKeys,
+        entity: cfg.entity,
+        cryptoService: cfg.cryptoService,
+    });
+    // async function unwrapKey(manifest: Manifest, allowedKases: string[], authProvider: AuthProvider | AppIdAuthProvider, publicKey: string, privateKey: string, entity: EntityObject) {
+    const keyForDecryption = await cfg.keyMiddleware(reconstructedKeyBinary);
+    const encryptedSegmentSizeDefault = defaultSegmentSize || DEFAULT_SEGMENT_SIZE;
+    // check the combined string of hashes
+    const aggregateHash = segments.map(({ hash }) => base64.decode(hash)).join('');
+    const integrityAlgorithm = rootSignature.alg;
+    if (integrityAlgorithm !== 'GMAC' && integrityAlgorithm !== 'HS256') {
+        throw new UnsupportedError(`Unsupported integrity alg [${integrityAlgorithm}]`);
+    }
+    const payloadSigStr = await getSignature(keyForDecryption, Binary.fromString(aggregateHash), integrityAlgorithm, cfg.cryptoService);
+    if (manifest.encryptionInformation.integrityInformation.rootSignature.sig !==
+        base64.encode(payloadSigStr)) {
+        throw new IntegrityError('Failed integrity check on root signature');
+    }
+    if (!cfg.noVerifyAssertions) {
+        for (const assertion of manifest.assertions || []) {
+            // Create a default assertion key
+            let assertionKey = {
+                alg: 'HS256',
+                key: new Uint8Array(reconstructedKeyBinary.asArrayBuffer()),
+            };
+            if (cfg.assertionVerificationKeys) {
+                const foundKey = cfg.assertionVerificationKeys.Keys[assertion.id];
+                if (foundKey) {
+                    assertionKey = foundKey;
+                }
+            }
+            await assertions.verify(assertion, aggregateHash, assertionKey);
+        }
+    }
+    let mapOfRequestsOffset = 0;
+    const chunkMap = new Map(segments.map(({ hash, encryptedSegmentSize = encryptedSegmentSizeDefault }) => {
+        const result = (() => {
+            let _resolve, _reject;
+            const chunk = {
+                hash,
+                encryptedOffset: mapOfRequestsOffset,
+                encryptedSegmentSize,
+                promise: new Promise((resolve, reject) => {
+                    _resolve = resolve;
+                    _reject = reject;
+                }),
+            };
+            chunk._resolve = _resolve;
+            chunk._reject = _reject;
+            return chunk;
+        })();
+        mapOfRequestsOffset += encryptedSegmentSize || encryptedSegmentSizeDefault;
+        return [hash, result];
+    }));
+    const cipher = new AesGcmCipher(cfg.cryptoService);
+    const segmentIntegrityAlg = segmentHashAlg || integrityAlgorithm;
+    if (segmentIntegrityAlg !== 'GMAC' && segmentIntegrityAlg !== 'HS256') {
+        throw new UnsupportedError(`Unsupported segment hash alg [${segmentIntegrityAlg}]`);
+    }
+    // Not waiting for Promise to resolve
+    updateChunkQueue(Array.from(chunkMap.values()), centralDirectory, zipReader, keyForDecryption, cipher, segmentIntegrityAlg, cfg.cryptoService);
+    let progress = 0;
+    const underlyingSource = {
+        pull: async (controller) => {
+            if (chunkMap.size === 0) {
+                controller.close();
+                return;
+            }
+            const [hash, chunk] = chunkMap.entries().next().value;
+            if (!chunk.decryptedChunk) {
+                await chunk.promise;
+            }
+            const decryptedSegment = chunk.decryptedChunk;
+            controller.enqueue(new Uint8Array(decryptedSegment.payload.asByteArray()));
+            progress += chunk.encryptedSegmentSize;
+            cfg.progressHandler?.(progress);
+            chunk.decryptedChunk = null;
+            chunkMap.delete(hash);
+        },
+        ...(cfg.fileStreamServiceWorker && { fileStreamServiceWorker: cfg.fileStreamServiceWorker }),
+    };
+    const outputStream = new DecoratedReadableStream(underlyingSource);
+    outputStream.manifest = manifest;
+    outputStream.emit('manifest', manifest);
+    outputStream.metadata = metadata;
+    outputStream.emit('rewrap', metadata);
+    return outputStream;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tdf.js","sourceRoot":"","sources":["../../../../tdf3/src/tdf.ts"],"names":[],"mappings":"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"}