Remove unused EncryptionService.decryptWithAES method

Author: mondoreale

packages/sdk/src/encryption/EncryptionService.ts

@@ -45,20 +45,6 @@ export class EncryptionService {
         return result.data
     }
 
-    /**
-     * Decrypt AES-256-CTR encrypted data.
-     * Note: The input cipher buffer is transferred to the worker and becomes unusable after this call.
-     */
-    async decryptWithAES(cipher: Uint8Array, cipherKey: Uint8Array): Promise<Uint8Array> {
-        const result = await this.getWorkerApi().decrypt(
-            transfer({ cipher, cipherKey }, [cipher.buffer])
-        )
-        if (result.type === 'error') {
-            throw new Error(`AES decryption failed: ${result.message}`)
-        }
-        return result.data
-    }
-
     /**
      * Encrypt the next group key using the current group key.
      */

packages/sdk/src/encryption/EncryptionWorker.ts

@@ -3,18 +3,16 @@
  * Offloads CPU-intensive cryptographic operations to a separate thread.
  */
 import { expose, transfer } from 'comlink'
-import { decryptWithAES, encryptWithAES } from './aesUtils'
+import { encryptWithAES } from './aesUtils'
 import {
     encryptNextGroupKey,
     decryptNextGroupKey,
     decryptStreamMessageContent,
     AESEncryptRequest,
-    AESDecryptRequest,
     EncryptGroupKeyRequest,
     DecryptGroupKeyRequest,
     DecryptStreamMessageRequest,
     AESEncryptResult,
-    AESDecryptResult,
     EncryptGroupKeyResult,
     DecryptGroupKeyResult,
     DecryptStreamMessageResult
@@ -30,15 +28,6 @@ const workerApi = {
         }
     },
 
-    decrypt: async (request: AESDecryptRequest): Promise<AESDecryptResult> => {
-        try {
-            const result = decryptWithAES(request.cipher, request.cipherKey)
-            return transfer({ type: 'success', data: result }, [result.buffer])
-        } catch (err) {
-            return { type: 'error', message: String(err) }
-        }
-    },
-
     encryptGroupKey: async (request: EncryptGroupKeyRequest): Promise<EncryptGroupKeyResult> => {
         try {
             const result = encryptNextGroupKey(

packages/sdk/src/encryption/encryptionUtils.ts

@@ -14,11 +14,6 @@ export interface AESEncryptRequest {
     cipherKey: Uint8Array
 }
 
-export interface AESDecryptRequest {
-    cipher: Uint8Array
-    cipherKey: Uint8Array
-}
-
 export interface EncryptGroupKeyRequest {
     nextGroupKeyId: string
     nextGroupKeyData: Uint8Array
@@ -47,10 +42,6 @@ export type AESEncryptResult =
     | { type: 'success', data: Uint8Array }
     | { type: 'error', message: string }
 
-export type AESDecryptResult =
-    | { type: 'success', data: Uint8Array }
-    | { type: 'error', message: string }
-
 export type EncryptGroupKeyResult =
     | { type: 'success', id: string, data: Uint8Array }
     | { type: 'error', message: string }

packages/sdk/test/test-utils/utils.ts

@@ -45,7 +45,7 @@ import { GroupKeyManager } from '../../src/encryption/GroupKeyManager'
 import { LocalGroupKeyStore } from '../../src/encryption/LocalGroupKeyStore'
 import { SubscriberKeyExchange } from '../../src/encryption/SubscriberKeyExchange'
 import { EncryptionService } from '../../src/encryption/EncryptionService'
-import { encryptWithAES, decryptWithAES } from '../../src/encryption/aesUtils'
+import { encryptWithAES } from '../../src/encryption/aesUtils'
 import { encryptNextGroupKey, decryptNextGroupKey, decryptStreamMessageContent } from '../../src/encryption/encryptionUtils'
 import { StreamrClientEventEmitter } from '../../src/events'
 import { StreamMessage } from '../../src/protocol/StreamMessage'
@@ -92,9 +92,6 @@ export function createMockEncryptionService(): EncryptionService {
         encryptWithAES: async (data: Uint8Array, cipherKey: Uint8Array) => {
             return encryptWithAES(data, cipherKey)
         },
-        decryptWithAES: async (cipher: Uint8Array, cipherKey: Uint8Array) => {
-            return decryptWithAES(cipher, cipherKey)
-        },
         encryptNextGroupKey: async (currentKey: GroupKey, nextKey: GroupKey) => {
             return encryptNextGroupKey(nextKey.id, nextKey.data, currentKey.data)
         },

packages/sdk/test/unit/EncryptionService.test.ts

@@ -18,7 +18,7 @@ describe('EncryptionService', () => {
         encryptionService.destroy()
     })
 
-    describe('encryptWithAES / decryptWithAES', () => {
+    describe('encryptWithAES', () => {
         it('encrypts and decrypts data correctly', async () => {
             const plaintextOriginal = utf8ToBinary('hello world')
             const key = GroupKey.generate()
@@ -32,7 +32,8 @@ describe('EncryptionService', () => {
             expect(ciphertext).not.toStrictEqual(plaintextOriginal)
             expect(ciphertext.length).toBeGreaterThan(plaintextOriginal.length)
 
-            const decrypted = await encryptionService.decryptWithAES(ciphertext, key.data)
+            // Use decryptStreamMessage to verify encryption worked correctly
+            const [decrypted] = await encryptionService.decryptStreamMessage(ciphertext, key)
 
             expect(decrypted).toStrictEqual(plaintextOriginal)
         })
@@ -55,7 +56,7 @@ describe('EncryptionService', () => {
                 Uint8Array.from(plaintextOriginal), 
                 key.data
             )
-            const decrypted = await encryptionService.decryptWithAES(ciphertext, key.data)
+            const [decrypted] = await encryptionService.decryptStreamMessage(ciphertext, key)
 
             expect(decrypted).toStrictEqual(plaintextOriginal)
         })
@@ -68,7 +69,7 @@ describe('EncryptionService', () => {
                 Uint8Array.from(plaintextOriginal), 
                 key.data
             )
-            const decrypted = await encryptionService.decryptWithAES(ciphertext, key.data)
+            const [decrypted] = await encryptionService.decryptStreamMessage(ciphertext, key)
 
             expect(decrypted).toStrictEqual(plaintextOriginal)
         })
@@ -200,7 +201,7 @@ describe('EncryptionService', () => {
                     Uint8Array.from(plaintext), 
                     key.data
                 )
-                const decrypted = await encryptionService.decryptWithAES(ciphertext, key.data)
+                const [decrypted] = await encryptionService.decryptStreamMessage(ciphertext, key)
                 results.push(decrypted)
             }