@opentdf/sdk 0.9.0-beta.91 → 0.9.0-beta.93

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

@@ -1,4 +1,3 @@
-import { keySplit } from '../utils/index.js';
 import { base64, hex } from '../../../src/encodings/index.js';
 import { Binary } from '../binary.js';
 import { type SymmetricCipher } from '../ciphers/symmetric-cipher-base.js';
@@ -8,12 +7,13 @@ import {
   type CryptoService,
   type DecryptResult,
   type EncryptResult,
+  type SymmetricKey,
 } from '../crypto/declarations.js';
 import { IntegrityAlgorithm } from '../tdf.js';
 import { ConfigurationError } from '../../../src/errors.js';
 
 export type KeyInfo = {
-  readonly unwrappedKeyBinary: Binary;
+  readonly unwrappedKey: SymmetricKey;
   readonly unwrappedKeyIvBinary: Binary;
 };
 
@@ -59,42 +59,39 @@ export class SplitKey {
 
   async generateKey(): Promise<KeyInfo> {
     const unwrappedKey = await this.cipher.generateKey();
-    const unwrappedKeyBinary = Binary.fromString(hex.decode(unwrappedKey));
     const unwrappedKeyIvBinary = await this.generateIvBinary();
-    return { unwrappedKeyBinary, unwrappedKeyIvBinary };
+    return { unwrappedKey, unwrappedKeyIvBinary };
   }
 
   async encrypt(
     contentBinary: Binary,
-    keyBinary: Binary,
+    key: SymmetricKey,
     ivBinaryOptional?: Binary
   ): Promise<EncryptResult> {
     const ivBinary = ivBinaryOptional || (await this.generateIvBinary());
-    return this.cipher.encrypt(contentBinary, keyBinary, ivBinary);
+    return this.cipher.encrypt(contentBinary, key, ivBinary);
   }
 
-  async decrypt(content: Uint8Array, keyBinary: Binary): Promise<DecryptResult> {
-    return this.cipher.decrypt(content, keyBinary);
+  async decrypt(content: Uint8Array, key: SymmetricKey): Promise<DecryptResult> {
+    return this.cipher.decrypt(content, key);
   }
 
   async getKeyAccessObjects(policy: Policy, keyInfo: KeyInfo): Promise<KeyAccessObject[]> {
     const splitIds = [...new Set(this.keyAccess.map(({ sid }) => sid))].sort((a = '', b = '') =>
       a.localeCompare(b)
     );
-    const unwrappedKeySplitBuffers = await keySplit(
-      new Uint8Array(keyInfo.unwrappedKeyBinary.asByteArray()),
-      splitIds.length,
-      this.cryptoService
+    const unwrappedKeySplits = await this.cryptoService.splitSymmetricKey(
+      keyInfo.unwrappedKey,
+      splitIds.length
     );
     const splitsByName = Object.fromEntries(
-      splitIds.map((sid, index) => [sid, unwrappedKeySplitBuffers[index]])
+      splitIds.map((sid, index) => [sid, unwrappedKeySplits[index]])
     );
 
     const keyAccessObjects = [];
     for (const item of this.keyAccess) {
       // use the key split to encrypt metadata for each key access object
-      const unwrappedKeySplitBuffer = splitsByName[item.sid || ''];
-      const unwrappedKeySplitBinary = Binary.fromArrayBuffer(unwrappedKeySplitBuffer.buffer);
+      const unwrappedKeySplit = splitsByName[item.sid || ''];
 
       const metadata = item.metadata || '';
       const metadataStr = (
@@ -113,7 +110,7 @@ export class SplitKey {
 
       const encryptedMetadataResult = await this.encrypt(
         metadataBinary,
-        unwrappedKeySplitBinary,
+        unwrappedKeySplit,
         keyInfo.unwrappedKeyIvBinary
       );
 
@@ -123,11 +120,7 @@ export class SplitKey {
       };
 
       const encryptedMetadataStr = JSON.stringify(encryptedMetadataOb);
-      const keyAccessObject = await item.write(
-        policy,
-        unwrappedKeySplitBuffer,
-        encryptedMetadataStr
-      );
+      const keyAccessObject = await item.write(policy, unwrappedKeySplit, encryptedMetadataStr);
       keyAccessObjects.push(keyAccessObject);
     }
 

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

@@ -1,11 +1,8 @@
 import { base64, hex } from '../../../src/encodings/index.js';
-import { generateRandomNumber } from '../../../src/crypto/generateRandomNumber.js';
-import { keyAgreement } from '../../../src/crypto/keyAgreement.js';
-import { pemPublicToCrypto } from '../../../src/crypto/pemPublicToCrypto.js';
-import { cryptoPublicToPem } from '../../../src/utils.js';
 import { Binary } from '../binary.js';
-import * as cryptoService from '../crypto/index.js';
-import { ztdfSalt } from '../crypto/salt.js';
+import type { CryptoService, KeyPair, SymmetricKey } from '../crypto/declarations.js';
+import { getZtdfSalt } from '../crypto/salt.js';
+import { Algorithms } from '../ciphers/index.js';
 import { Policy } from './policy.js';
 
 export type KeyAccessType = 'remote' | 'wrapped' | 'ec-wrapped';
@@ -14,7 +11,7 @@ export const schemaVersion = '1.0';
 
 export class ECWrapped {
   readonly type = 'ec-wrapped';
-  readonly ephemeralKeyPair: Promise<CryptoKeyPair>;
+  readonly ephemeralKeyPair: Promise<KeyPair>;
   keyAccessObject?: KeyAccessObject;
 
   constructor(
@@ -22,44 +19,62 @@ export class ECWrapped {
     public readonly kid: string | undefined,
     public readonly publicKey: string,
     public readonly metadata: unknown,
+    public readonly cryptoService: CryptoService,
     public readonly sid?: string
   ) {
-    this.ephemeralKeyPair = crypto.subtle.generateKey(
-      {
-        name: 'ECDH',
-        namedCurve: 'P-256',
-      },
-      false,
-      ['deriveBits', 'deriveKey']
-    );
+    // Generate EC key pair using CryptoService - returns opaque keys
+    this.ephemeralKeyPair = this.cryptoService.generateECKeyPair('P-256');
   }
 
   async write(
     policy: Policy,
-    dek: Uint8Array,
+    dek: SymmetricKey,
     encryptedMetadataStr: string
   ): Promise<KeyAccessObject> {
     const policyStr = JSON.stringify(policy);
-    const [ek, clientPublicKey] = await Promise.all([
-      this.ephemeralKeyPair,
-      pemPublicToCrypto(this.publicKey),
-    ]);
-    const kek = await keyAgreement(ek.privateKey, clientPublicKey, {
-      hkdfSalt: await ztdfSalt,
-      hkdfHash: 'SHA-256',
+    const ek = await this.ephemeralKeyPair;
+
+    // Import KAS public key from PEM
+    const kasPublicKey = await this.cryptoService.importPublicKey(this.publicKey, {
+      usage: 'derive',
     });
-    const iv = generateRandomNumber(12);
-    const cek = await crypto.subtle.encrypt({ name: 'AES-GCM', iv, tagLength: 128 }, kek, dek);
-    const entityWrappedKey = new Uint8Array(iv.length + cek.byteLength);
+
+    // Derive encryption key using ECDH + HKDF via CryptoService
+    const derivedKey = await this.cryptoService.deriveKeyFromECDH(ek.privateKey, kasPublicKey, {
+      hash: 'SHA-256',
+      salt: await getZtdfSalt(this.cryptoService),
+    });
+
+    // Generate random IV
+    const iv = await this.cryptoService.randomBytes(12);
+
+    // Encrypt DEK using derived key with AES-GCM
+    // Payload is SymmetricKey (the DEK), key is SymmetricKey (derived from ECDH)
+    const encryptResult = await this.cryptoService.encrypt(
+      dek,
+      derivedKey,
+      Binary.fromArrayBuffer(iv.buffer),
+      Algorithms.AES_256_GCM
+    );
+
+    // Combine IV, ciphertext, and authTag to form the wrapped key.
+    const ciphertext = new Uint8Array(encryptResult.payload.asArrayBuffer());
+    const authTag = encryptResult.authTag
+      ? new Uint8Array(encryptResult.authTag.asArrayBuffer())
+      : new Uint8Array(0);
+    const entityWrappedKey = new Uint8Array(iv.length + ciphertext.length + authTag.length);
     entityWrappedKey.set(iv);
-    entityWrappedKey.set(new Uint8Array(cek), iv.length);
+    entityWrappedKey.set(ciphertext, iv.length);
+    entityWrappedKey.set(authTag, iv.length + ciphertext.length);
 
-    const policyBinding = await cryptoService.hmac(
-      hex.encodeArrayBuffer(dek),
-      base64.encode(policyStr)
+    const policyBinding = hex.encodeArrayBuffer(
+      (await this.cryptoService.hmac(new TextEncoder().encode(base64.encode(policyStr)), dek))
+        .buffer
     );
 
-    const ephemeralPublicKeyPEM = await cryptoPublicToPem(ek.publicKey);
+    // Export ephemeral public key to PEM for manifest
+    const ephemeralPublicKeyPem = await this.cryptoService.exportPublicKeyPem(ek.publicKey);
+
     const kao: KeyAccessObject = {
       type: 'ec-wrapped',
       url: this.url,
@@ -71,7 +86,7 @@ export class ECWrapped {
         hash: base64.encode(policyBinding),
       },
       schemaVersion,
-      ephemeralPublicKey: ephemeralPublicKeyPEM,
+      ephemeralPublicKey: ephemeralPublicKeyPem,
     };
     if (this.kid) {
       kao.kid = this.kid;
@@ -93,24 +108,25 @@ export class Wrapped {
     public readonly kid: string | undefined,
     public readonly publicKey: string,
     public readonly metadata: unknown,
+    public readonly cryptoService: CryptoService,
     public readonly sid?: string
   ) {}
 
   async write(
     policy: Policy,
-    keyBuffer: Uint8Array,
+    key: SymmetricKey,
     encryptedMetadataStr: string
   ): Promise<KeyAccessObject> {
     const policyStr = JSON.stringify(policy);
-    const unwrappedKeyBinary = Binary.fromArrayBuffer(keyBuffer.buffer);
-    const wrappedKeyBinary = await cryptoService.encryptWithPublicKey(
-      unwrappedKeyBinary,
-      this.publicKey
-    );
+    // Import KAS public key from PEM
+    const kasPublicKey = await this.cryptoService.importPublicKey(this.publicKey, {
+      usage: 'encrypt',
+    });
+    const wrappedKeyBinary = await this.cryptoService.encryptWithPublicKey(key, kasPublicKey);
 
-    const policyBinding = await cryptoService.hmac(
-      hex.encodeArrayBuffer(keyBuffer),
-      base64.encode(policyStr)
+    const policyBinding = hex.encodeArrayBuffer(
+      (await this.cryptoService.hmac(new TextEncoder().encode(base64.encode(policyStr)), key))
+        .buffer
     );
 
     this.keyAccessObject = {