@opentdf/sdk 0.2.0-beta.1758 → 0.2.0-beta.1941

package/tdf3/src/assertions.ts

@@ -3,7 +3,7 @@ import { type KeyLike, SignJWT, jwtVerify } from 'jose';
 import { base64, hex } from '../../src/encodings/index.js';
 import { ConfigurationError, IntegrityError, InvalidFileError } from '../../src/errors.js';
 
-export type AssertionKeyAlg = 'RS256' | 'HS256';
+export type AssertionKeyAlg = 'ES256' | 'RS256' | 'HS256';
 export type AssertionType = 'handling' | 'other';
 export type Scope = 'tdo' | 'payload';
 export type AppliesToState = 'encrypted' | 'unencrypted';
@@ -110,8 +110,9 @@ export function isAssertionConfig(obj: unknown): obj is AssertionConfig {
  */
 export async function verify(
   thiz: Assertion,
-  aggregateHash: string,
-  key: AssertionKey
+  aggregateHash: Uint8Array,
+  key: AssertionKey,
+  isLegacyTDF: boolean
 ): Promise<void> {
   let payload: AssertionPayload;
   try {
@@ -126,14 +127,25 @@ export async function verify(
 
   // Get the hash of the assertion
   const hashOfAssertion = await hash(thiz);
-  const combinedHash = aggregateHash + hashOfAssertion;
-  const encodedHash = base64.encode(combinedHash);
 
   // check if assertionHash is same as hashOfAssertion
   if (hashOfAssertion !== assertionHash) {
     throw new IntegrityError('Assertion hash mismatch');
   }
 
+  let encodedHash: string;
+  if (isLegacyTDF) {
+    const aggregateHashAsStr = new TextDecoder('utf-8').decode(aggregateHash);
+    const combinedHash = aggregateHashAsStr + hashOfAssertion;
+    encodedHash = base64.encode(combinedHash);
+  } else {
+    const combinedHash = concatenateUint8Arrays(
+      aggregateHash,
+      new Uint8Array(hex.decodeArrayBuffer(assertionHash))
+    );
+    encodedHash = base64.encodeArrayBuffer(combinedHash);
+  }
+
   // check if assertionSig is same as encodedHash
   if (assertionSig !== encodedHash) {
     throw new IntegrityError('Failed integrity check on assertion signature');
@@ -144,7 +156,7 @@ export async function verify(
  * Creates an Assertion object with the specified properties.
  */
 export async function CreateAssertion(
-  aggregateHash: string,
+  aggregateHash: Uint8Array,
   assertionConfig: AssertionConfig
 ): Promise<Assertion> {
   if (!assertionConfig.signingKey) {
@@ -162,8 +174,11 @@ export async function CreateAssertion(
   };
 
   const assertionHash = await hash(a);
-  const combinedHash = aggregateHash + assertionHash;
-  const encodedHash = base64.encode(combinedHash);
+  const combinedHash = concatenateUint8Arrays(
+    aggregateHash,
+    new Uint8Array(hex.decodeArrayBuffer(assertionHash))
+  );
+  const encodedHash = base64.encodeArrayBuffer(combinedHash);
 
   return await sign(a, assertionHash, encodedHash, assertionConfig.signingKey);
 }
@@ -189,3 +204,13 @@ export type AssertionVerificationKeys = {
   DefaultKey?: AssertionKey;
   Keys: Record<string, AssertionKey>;
 };
+
+function concatenateUint8Arrays(array1: Uint8Array, array2: Uint8Array): Uint8Array {
+  const combinedLength = array1.length + array2.length;
+  const combinedArray = new Uint8Array(combinedLength);
+
+  combinedArray.set(array1, 0);
+  combinedArray.set(array2, array1.length);
+
+  return combinedArray;
+}

package/tdf3/src/client/DecoratedReadableStream.ts

@@ -1,11 +1,5 @@
-import { EventEmitter } from 'eventemitter3';
-import streamSaver from 'streamsaver';
-import { fileSave } from 'browser-fs-access';
-import { isFirefox } from '../../../src/utils.js';
-
 import { type Metadata } from '../tdf.js';
 import { type Manifest } from '../models/index.js';
-import { ConfigurationError } from '../../../src/errors.js';
 
 export async function streamToBuffer(stream: ReadableStream<Uint8Array>): Promise<Uint8Array> {
   const accumulator = await new Response(stream).arrayBuffer();
@@ -24,9 +18,6 @@ export class DecoratedReadableStream {
   tdfSize: number;
   fileSize: number | undefined;
   stream: ReadableStream<Uint8Array>;
-  ee: EventEmitter;
-  on: EventEmitter['on'];
-  emit: EventEmitter['emit'];
   metadata?: Metadata;
   manifest: Manifest;
   fileStreamServiceWorker?: string;
@@ -42,23 +33,10 @@ export class DecoratedReadableStream {
     this.stream = new ReadableStream(underlyingSource, {
       highWaterMark: 1,
     }) as ReadableStream<Uint8Array>;
-    this.ee = new EventEmitter();
-    this.on = (...args) => this.ee.on(...args);
-    this.emit = (...args) => this.ee.emit(...args);
   }
 
   async getMetadata() {
-    return new Promise((resolve, reject) => {
-      if (this.metadata) {
-        resolve(this.metadata);
-      } else {
-        this.on('error', reject);
-        this.on('rewrap', (rewrapResponse: Metadata) => {
-          this.metadata = rewrapResponse;
-          resolve(rewrapResponse);
-        });
-      }
-    });
+    return this.metadata;
   }
 
   /**
@@ -82,66 +60,12 @@ export class DecoratedReadableStream {
   async toString(): Promise<string> {
     return new Response(this.stream).text();
   }
-
-  /**
-   * Dump the stream content to a local file. This will consume the stream.
-   *
-   * @param filepath The path of the local file to write plaintext to.
-   * @param encoding The charset encoding to use. Defaults to utf-8.
-   */
-  async toFile(
-    filepath = 'download.tdf',
-    options?: BufferEncoding | DecoratedReadableStreamSinkOptions
-  ): Promise<void> {
-    if (options && typeof options === 'string') {
-      throw new ConfigurationError('unsupported operation: Cannot set encoding in browser');
-    }
-    if (isFirefox()) {
-      await fileSave(new Response(this.stream), {
-        fileName: filepath,
-        extensions: [`.${filepath.split('.').pop()}`],
-      });
-      return;
-    }
-
-    if (this.fileStreamServiceWorker) {
-      streamSaver.mitm = this.fileStreamServiceWorker;
-    }
-
-    const fileStream = streamSaver.createWriteStream(filepath, {
-      writableStrategy: { highWaterMark: 1 },
-      readableStrategy: { highWaterMark: 1 },
-    });
-
-    if (WritableStream) {
-      return this.stream.pipeTo(fileStream, options);
-    }
-
-    // Write (pipe) manually
-    const reader = this.stream.getReader();
-    const writer = fileStream.getWriter();
-    const pump = async (): Promise<void> => {
-      const res = await reader.read();
-
-      if (res.done) {
-        return await writer.close();
-      } else {
-        await writer.write(res.value);
-        return pump();
-      }
-    };
-    return pump();
-
-    // const pump = (): Promise<void> =>
-    //   reader.read().then((res) => (res.done ? writer.close() : writer.write(res.value).then(pump)));
-    // pump();
-  }
 }
 
 export function isDecoratedReadableStream(s: unknown): s is DecoratedReadableStream {
   return (
+    typeof (s as DecoratedReadableStream)?.stream !== 'undefined' &&
     typeof (s as DecoratedReadableStream)?.toBuffer !== 'undefined' &&
-    typeof (s as DecoratedReadableStream)?.toFile !== 'undefined' &&
     typeof (s as DecoratedReadableStream)?.toString !== 'undefined'
   );
 }

package/tdf3/src/client/builders.ts

@@ -6,9 +6,10 @@ import { Binary } from '../binary.js';
 import { ConfigurationError } from '../../../src/errors.js';
 import { PemKeyPair } from '../crypto/declarations.js';
 import { DecoratedReadableStream } from './DecoratedReadableStream.js';
-import { type Chunker } from '../utils/chunkers.js';
+import { type Chunker } from '../../../src/seekable.js';
 import { AssertionConfig, AssertionVerificationKeys } from '../assertions.js';
 import { Value } from '../../../src/policy/attributes.js';
+import { KasPublicKeyAlgorithm, OriginAllowList } from '../../../src/access.js';
 
 export const DEFAULT_SEGMENT_SIZE: number = 1024 * 1024;
 export type Scope = {
@@ -34,16 +35,14 @@ export type SplitStep = {
 };
 
 export type EncryptParams = {
+  byteLimit?: number;
   source: ReadableStream<Uint8Array>;
   opts?: { keypair: PemKeyPair };
   autoconfigure?: boolean;
   scope?: Scope;
   metadata?: Metadata;
   keypair?: CryptoKeyPair;
-  // Deprecated: Only offline more is currently supported
-  offline?: boolean;
   windowSize?: number;
-  asHtml?: boolean;
   getPolicyId?: () => Scope['policyId'];
   mimeType?: string;
   payloadKey?: Binary;
@@ -51,10 +50,18 @@ export type EncryptParams = {
   splitPlan?: SplitStep[];
   streamMiddleware?: EncryptStreamMiddleware;
   assertionConfigs?: AssertionConfig[];
+  defaultKASEndpoint?: string;
+
+  // Preferred wrapping key algorithm. Used when KID resolution is not available.
+  wrappingKeyAlgorithm?: KasPublicKeyAlgorithm;
+
+  // Unsupported
+  asHtml?: boolean;
+  // Unsupported
+  offline?: boolean;
 };
 
 // 'Readonly<EncryptParams>': scope, metadata, offline, windowSize, asHtml
-
 // deep copy is expensive, could be faster is Immer used, but to keep SDK work
 // stable we can just make this object readonly
 function freeze<Type>(obj: Type): Readonly<Type> {
@@ -75,9 +82,7 @@ class EncryptParamsBuilder {
         attributes: [],
       },
       keypair: undefined,
-      offline: false,
       windowSize: DEFAULT_SEGMENT_SIZE,
-      asHtml: false,
       assertionConfigs: [],
     }
   ) {
@@ -93,6 +98,11 @@ class EncryptParamsBuilder {
    * @param {Readable} readStream - a Readable Stream to encrypt.
    */
   setStreamSource(readStream: ReadableStream<Uint8Array>) {
+    if (!readStream?.getReader) {
+      throw new ConfigurationError(
+        `Source must be a WebReadableStream. Run node streams through stream.Readable.toWeb()`
+      );
+    }
     this._params.source = readStream;
   }
 
@@ -117,6 +127,9 @@ class EncryptParamsBuilder {
    * @param {string} string - a string to encrypt.
    */
   setStringSource(string: string) {
+    if (!(string && typeof string === 'string')) {
+      throw new ConfigurationError('StringSource must be a string');
+    }
     const stream = new ReadableStream({
       pull(controller) {
         controller.enqueue(new TextEncoder().encode(string));
@@ -382,37 +395,24 @@ class EncryptParamsBuilder {
   }
 
   /**
-   * Whether the encrypted data should be formatted using html. This allows authorized users to
-   * double click and read using the Virtru Secure Reader, at the cost of reduced space efficiency.
-   * <br/><br/>
-   * This is enabled by default.
-   * @return {boolean} true if the encrypted data will be in html format.
+   * @deprecated This feature is not supported
    */
   hasHtmlFormat(): boolean {
-    return !!this._params.asHtml;
+    return false;
   }
 
   /**
-   * Specify that the encrypted data should be formatted using html. This allows authorized users to
-   * double click and read using the Virtru Secure Reader, at the cost of reduced space efficiency.
-   * <br/><br/>
-   * This is enabled by default.
+   * @deprecated This feature is not supported
    */
   setHtmlFormat() {
-    this._params.asHtml = true;
+    throw new ConfigurationError('HTML format is not supported');
   }
 
   /**
-   * Specify that the encrypted data should be formatted using html. This allows authorized users to
-   * double click and read using the Virtru Secure Reader, at the cost of reduced space efficiency.
-   * Returns this object for method chaining.
-   * <br/><br/>
-   * This is enabled by default.
-   * @return {EncryptParamsBuilder} - this object.
+   * @deprecated This feature is not supported
    */
   withHtmlFormat(): EncryptParamsBuilder {
-    this.setHtmlFormat();
-    return this;
+    throw new ConfigurationError('HTML format is not supported');
   }
 
   /**
@@ -514,11 +514,13 @@ export type DecryptSource =
 
 export type DecryptParams = {
   source: DecryptSource;
+  allowList?: OriginAllowList;
   keyMiddleware?: DecryptKeyMiddleware;
   streamMiddleware?: DecryptStreamMiddleware;
   assertionVerificationKeys?: AssertionVerificationKeys;
   concurrencyLimit?: number;
   noVerifyAssertions?: boolean;
+  wrappingKeyAlgorithm?: KasPublicKeyAlgorithm;
 };
 
 /**
@@ -637,6 +639,9 @@ class DecryptParamsBuilder {
    * @param source (node) the path of the local file to decrypt, or the Blob (browser/node)
    */
   setFileSource(source: Blob) {
+    if (!(source instanceof Blob)) {
+      throw new ConfigurationError('File source must be a Blob');
+    }
     this._params.source = { type: 'file-browser', location: source };
   }
 
@@ -680,6 +685,19 @@ class DecryptParamsBuilder {
     return this;
   }
 
+  /**
+   * Sets the assertion verification keys for the decryption parameters.
+   *
+   * @param {AssertionVerificationKeys} assertionVerificationKeys - An array of assertion configurations to be set.
+   * @returns {DecryptParamsBuilder} The current instance of the EncryptParamsBuilder for method chaining.
+   */
+  withAssertionVerificationKeys(
+    assertionVerificationKeys: AssertionVerificationKeys
+  ): DecryptParamsBuilder {
+    this._params.assertionVerificationKeys = assertionVerificationKeys;
+    return this;
+  }
+
   _deepCopy(_params: DecryptParams) {
     return freeze({ ..._params });
   }