@wireapp/core 21.0.1 → 21.0.2

package/CHANGELOG.md

@@ -3,6 +3,17 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [21.0.2](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@21.0.1...@wireapp/core@21.0.2) (2022-01-19)
+
+
+### Bug Fixes
+
+* **core:** Use Uint8Array in place of Buffer ([#4214](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/issues/4214)) ([d9c8692](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/commit/d9c869291e60325411070b87f71d8803561bde49))
+
+
+
+
+
 ## [21.0.1](https://github.com/wireapp/wire-web-packages/tree/main/packages/core/compare/@wireapp/core@21.0.0...@wireapp/core@21.0.1) (2022-01-18)
 
 

package/package.json

@@ -69,6 +69,6 @@
     "test:project": "yarn dist && yarn test",
     "test:node": "nyc jasmine --config=jasmine.json"
   },
-  "version": "21.0.1",
-  "gitHead": "eddd7ebcdc4868900cd7f80b1da391e124593ec1"
+  "version": "21.0.2",
+  "gitHead": "9838da9b1a1dcb702154c73c28a15e53fc35af9f"
 }

package/src/main/conversation/ConversationService.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { APIClient } from '@wireapp/api-client';
 import { MessageSendingStatus, Conversation, DefaultConversationRoleName, MutedStatus, QualifiedUserClients, UserClients, ClientMismatch } from '@wireapp/api-client/src/conversation';
 import type { ConversationMemberLeaveEvent } from '@wireapp/api-client/src/event';
@@ -150,7 +149,7 @@ export declare class ConversationService {
     createConversation(name: string, otherUserIds?: string | string[]): Promise<Conversation>;
     getConversations(conversationId: string): Promise<Conversation>;
     getConversations(conversationIds?: string[]): Promise<Conversation[]>;
-    getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Buffer>;
+    getAsset({ assetId, assetToken, otrKey, sha256 }: RemoteData): Promise<Uint8Array>;
     getUnencryptedAsset(assetId: string, assetToken?: string): Promise<ArrayBuffer>;
     addUser<T extends string | string[] | QualifiedId | QualifiedId[]>(conversationId: string, userIds: T): Promise<T>;
     removeUser(conversationId: string, userId: string): Promise<string>;

package/src/main/conversation/ConversationService.js

@@ -633,9 +633,9 @@ class ConversationService {
         const request = this.apiClient.asset.api.getAssetV3(assetId, assetToken);
         const encryptedBuffer = (await request.response).buffer;
         return (0, AssetCryptography_1.decryptAsset)({
-            cipherText: Buffer.from(encryptedBuffer),
-            keyBytes: Buffer.from(otrKey),
-            sha256: Buffer.from(sha256),
+            cipherText: new Uint8Array(encryptedBuffer),
+            keyBytes: otrKey,
+            sha256: sha256,
         });
     }
     async getUnencryptedAsset(assetId, assetToken) {

package/src/main/cryptography/AssetCryptography/EncryptedAsset.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 export interface EncryptedAsset {
-    cipherText: Buffer;
-    keyBytes: Buffer;
+    cipherText: Uint8Array;
+    keyBytes: Uint8Array;
     /** The SHA-256 sum of `cipherText` */
-    sha256: Buffer;
+    sha256: Uint8Array;
 }
 export interface EncryptedAssetUploaded extends EncryptedAsset {
     key: string;

package/src/main/cryptography/AssetCryptography/crypto.browser.js

@@ -23,22 +23,22 @@ const cryptoLib = window.crypto;
 exports.crypto = {
     async digest(cipherText) {
         const checksum = await cryptoLib.subtle.digest('SHA-256', cipherText);
-        return Buffer.from(checksum);
+        return new Uint8Array(checksum);
     },
     async decrypt(cipherText, keyBytes) {
         const key = await cryptoLib.subtle.importKey('raw', keyBytes, 'AES-CBC', false, ['decrypt']);
         const initializationVector = cipherText.slice(0, 16);
         const assetCipherText = cipherText.slice(16);
         const decipher = await cryptoLib.subtle.decrypt({ iv: initializationVector, name: 'AES-CBC' }, key, assetCipherText);
-        return Buffer.from(decipher);
+        return new Uint8Array(decipher);
     },
     getRandomValues(size) {
-        return Buffer.from(cryptoLib.getRandomValues(new Uint8Array(size)));
+        return cryptoLib.getRandomValues(new Uint8Array(size));
     },
     async encrypt(plainText, keyBytes, initializationVector) {
         const key = await cryptoLib.subtle.importKey('raw', keyBytes, 'AES-CBC', true, ['encrypt']);
         return {
-            key: Buffer.from(await cryptoLib.subtle.exportKey('raw', key)),
+            key: new Uint8Array(await cryptoLib.subtle.exportKey('raw', key)),
             cipher: await cryptoLib.subtle.encrypt({ iv: initializationVector, name: 'AES-CBC' }, key, plainText),
         };
     },

package/src/main/cryptography/AssetCryptography/index.d.ts

@@ -1,9 +1,8 @@
-/// <reference types="node" />
 import { CipherOptions } from '@wireapp/api-client/src/asset';
 import type { EncryptedAsset } from './EncryptedAsset';
 interface EncryptOptions extends CipherOptions {
-    plainText: Buffer | Uint8Array;
+    plainText: Uint8Array;
 }
-export declare const decryptAsset: ({ cipherText, keyBytes, sha256: referenceSha256, }: EncryptedAsset) => Promise<Buffer>;
+export declare const decryptAsset: ({ cipherText, keyBytes, sha256: referenceSha256, }: EncryptedAsset) => Promise<Uint8Array>;
 export declare const encryptAsset: ({ plainText, algorithm }: EncryptOptions) => Promise<EncryptedAsset>;
 export {};

package/src/main/cryptography/AssetCryptography/index.js

@@ -44,7 +44,7 @@ const encryptAsset = async ({ plainText, algorithm = 'AES-256-CBC' }) => {
     ivCipherText.set(new Uint8Array(cipher), initializationVector.byteLength);
     const sha256 = await crypto_node_1.crypto.digest(ivCipherText);
     return {
-        cipherText: Buffer.from(ivCipherText.buffer),
+        cipherText: ivCipherText,
         keyBytes: key,
         sha256,
     };

package/src/main/cryptography/AssetCryptography/interfaces.d.ts

@@ -1,10 +1,9 @@
-/// <reference types="node" />
 export interface Crypto {
-    digest(cipherText: Buffer | Uint8Array): Promise<Buffer>;
-    decrypt(cipherText: Buffer | Uint8Array, keyBytes: Buffer): Promise<Buffer>;
-    getRandomValues(size: number): Buffer;
-    encrypt(plainText: Buffer | Uint8Array, keyBytes: Buffer, initializationVector: Buffer, algorithm: string): Promise<{
-        key: Buffer;
-        cipher: Buffer;
+    digest(cipherText: Uint8Array): Promise<Uint8Array>;
+    decrypt(cipherText: Uint8Array, keyBytes: Uint8Array): Promise<Uint8Array>;
+    getRandomValues(size: number): Uint8Array;
+    encrypt(plainText: Uint8Array, keyBytes: Uint8Array, initializationVector: Uint8Array, algorithm: string): Promise<{
+        key: Uint8Array;
+        cipher: Uint8Array;
     }>;
 }