fix spec char issue

lib/tdf3/src/binary.ts

@@ -44,6 +44,10 @@ export abstract class Binary {
 
   abstract asArrayBuffer(): ArrayBuffer;
 
+  abstract asB64(): string;
+
+  abstract asHex(): string;
+
   abstract asByteArray(): number[];
 
   abstract asString(): string;
@@ -60,7 +64,12 @@ function adjustSliceParams(length: number, start: number, end?: number): [number
   if (end && end < 0) {
     end = length + end;
   }
-  return [start, end];
+  const result = [start];
+  if (end) {
+    result.push(end);
+  }
+
+  return result as [number, number?];
 }
 
 class ArrayBufferBinary extends Binary {
@@ -87,11 +96,18 @@ class ArrayBufferBinary extends Binary {
 
   override asString(): string {
     const uint8Array = new Uint8Array(this.value);
-    let str = '';
-    for (let i = 0; i < uint8Array.length; i++) {
-      str = str + String.fromCharCode(uint8Array[i]);
-    }
-    return str;
+    return new TextDecoder('utf-8').decode(uint8Array);
+  }
+
+  override asB64(): string {
+    const uint8Array = new Uint8Array(this.value);
+    return window.btoa([...uint8Array].map((byte) => String.fromCharCode(byte)).join(''));
+  }
+
+  override asHex(): string {
+    return Array.from(new Uint8Array(this.value))
+      .map((byte) => byte.toString(16).padStart(2, '0'))
+      .join('');
   }
 
   override isArrayBuffer(): boolean {
@@ -127,11 +143,16 @@ class ByteArrayBinary extends Binary {
 
   override asString(): string {
     const uint8Array = new Uint8Array(this.value);
-    let str = '';
-    for (let i = 0; i < uint8Array.length; i++) {
-      str = str + String.fromCharCode(uint8Array[i]);
-    }
-    return str;
+    return new TextDecoder('utf-8').decode(uint8Array);
+  }
+
+  override asB64(): string {
+    const uint8Array = new Uint8Array(this.value);
+    return window.btoa([...uint8Array].map((byte) => String.fromCharCode(byte)).join(''));
+  }
+
+  override asHex(): string {
+    return this.value.map((byte) => byte.toString(16).padStart(2, '0')).join('');
   }
 
   override isByteArray(): boolean {
@@ -178,6 +199,18 @@ class StringBinary extends Binary {
     return this.value;
   }
 
+  override asB64(): string {
+    const uint8Array = new TextEncoder().encode(this.asString());
+    const charArray = Array.from(uint8Array, (byte) => String.fromCharCode(byte));
+    return btoa(charArray.join(''));
+  }
+
+  override asHex(): string {
+    return Array.from(new TextEncoder().encode(this.value))
+      .map((byte) => byte.toString(16).padStart(2, '0'))
+      .join('');
+  }
+
   override isString(): boolean {
     return true;
   }

lib/tdf3/src/models/encryption-information.ts

@@ -106,8 +106,8 @@ export class SplitKey {
       );
 
       const encryptedMetadataOb = {
-        ciphertext: base64.encode(encryptedMetadataResult.payload.asString()),
-        iv: base64.encode(keyInfo.unwrappedKeyIvBinary.asString()),
+        ciphertext: encryptedMetadataResult.payload.asB64(),
+        iv: keyInfo.unwrappedKeyIvBinary.asB64(),
       };
 
       const encryptedMetadataStr = JSON.stringify(encryptedMetadataOb);
@@ -143,7 +143,7 @@ export class SplitKey {
       method: {
         algorithm,
         isStreamable: false,
-        iv: base64.encode(keyInfo.unwrappedKeyIvBinary.asString()),
+        iv: keyInfo.unwrappedKeyIvBinary.asB64(),
       },
       integrityInformation: {
         rootSignature: {

lib/tdf3/src/models/key-access.ts

@@ -40,7 +40,7 @@ export class Wrapped {
       type: 'wrapped',
       url: this.url,
       protocol: 'kas',
-      wrappedKey: base64.encode(wrappedKeyBinary.asString()),
+      wrappedKey: wrappedKeyBinary.asB64(),
       encryptedMetadata: base64.encode(encryptedMetadataStr),
       policyBinding: base64.encode(policyBinding),
     };
@@ -77,8 +77,7 @@ export class Remote {
       this.publicKey
     );
 
-    // this.wrappedKey = wrappedKeyBinary.asBuffer().toString('hex');
-    this.wrappedKey = base64.encode(wrappedKeyBinary.asString());
+    this.wrappedKey = wrappedKeyBinary.asB64();
 
     this.keyAccessObject = {
       type: 'remote',

lib/tdf3/src/tdf.ts

@@ -25,6 +25,7 @@ import {
   ZipReader,
   ZipWriter,
   base64ToBuffer,
+  bufferToBase64,
   fromUrl,
   isAppIdProviderCheck,
   keyMerge,
@@ -193,7 +194,7 @@ export class TDF extends EventEmitter {
       transferUrl,
       transferBaseUrl: origin,
       manifest: base64.encode(exportManifest),
-      payload: base64.encodeArrayBuffer(payload.buffer),
+      payload: bufferToBase64(payload),
     });
 
     return new TextEncoder().encode(fullHtmlString);
@@ -475,10 +476,7 @@ export class TDF extends EventEmitter {
         return hex.encodeArrayBuffer(new Uint8Array(payloadBinary.asByteArray()).slice(-16).buffer);
       case 'hs256':
         // simple hmac is the default
-        return await this.cryptoService.hmac(
-          hex.encodeArrayBuffer(new Uint8Array(unwrappedKeyBinary.asByteArray()).buffer),
-          new TextDecoder().decode(new Uint8Array(payloadBinary.asByteArray()).buffer)
-        );
+        return await this.cryptoService.hmac(unwrappedKeyBinary.asHex(), payloadBinary.asString());
       default:
         throw new IllegalArgumentError(`Unsupported signature alg [${algorithmType}]`);
     }
@@ -781,7 +779,7 @@ export class TDF extends EventEmitter {
     if (upsertResponse) {
       plaintextStream.upsertResponse = upsertResponse;
       plaintextStream.tdfSize = totalByteCount;
-      plaintextStream.KEK = payloadKey ? null : btoa(kek.payload.asString());
+      plaintextStream.KEK = payloadKey ? null : kek.payload.asB64();
       plaintextStream.algorithm = manifest.encryptionInformation.method.algorithm;
     }
 

lib/tdf3/src/utils/index.ts

@@ -10,6 +10,14 @@ export function base64ToBuffer(b64: string): Uint8Array {
   return Uint8Array.from(atob(b64).split(''), (c) => c.charCodeAt(0));
 }
 
+export function bufferToBase64(slice: Uint8Array) {
+  return btoa(
+    Array.from(slice)
+      .map((byte) => String.fromCharCode(byte))
+      .join('')
+  );
+}
+
 export function isAppIdProviderCheck(
   provider: AuthProvider | AppIdAuthProvider
 ): provider is AppIdAuthProvider {

lib/tests/mocha/unit/tdf.spec.ts

@@ -74,7 +74,7 @@ describe('TDF', () => {
     const wrapped = TDF.wrapHtml(cipherText, JSON.stringify({ thisIs: 'metadata' }), transferUrl);
     expect(TDF.unwrapHtml(wrapped)).to.eql(cipherText);
     expect(TDF.unwrapHtml(wrapped.buffer)).to.eql(cipherText);
-    expect(TDF.unwrapHtml(new TextDecoder().decode(wrapped))).to.eql(cipherText);
+    expect(TDF.unwrapHtml(new TextDecoder('utf-8').decode(wrapped))).to.eql(cipherText);
   });
 
   it('should fail on invalid cypher param', () => {