release/5.37.3 (#2601)

* Bugfix/improve login (#2600)

* bump iterations

* generate unique iv

* bump version numbers

* Update extension/src/background/messageListener/__tests__/createAccount.test.ts

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: piyalbasu

extension/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extension",
-  "version": "5.37.2",
+  "version": "5.37.3",
   "license": "Apache-2.0",
   "prettier": "../.prettierrc.yaml",
   "scripts": {

extension/public/static/manifest/v3.json

@@ -1,7 +1,7 @@
 {
   "name": "Freighter",
-  "version": "5.37.2",
-  "version_name": "5.37.2",
+  "version": "5.37.3",
+  "version_name": "5.37.3",
   "description": "Freighter is a non-custodial wallet extension that enables you to sign Stellar transactions via your browser.",
   "browser_specific_settings": {
     "gecko": {

extension/src/background/ducks/session.ts

@@ -54,7 +54,6 @@ export interface SessionState {
 const initialState: InitialState = {
   publicKey: "",
   hashKey: {
-    iv: "",
     key: "",
   },
   allAccounts: [] as Account[],
@@ -69,7 +68,7 @@ interface UiData {
 
 interface AppData {
   privateKey?: string;
-  hashKey?: { key: string; iv: string };
+  hashKey?: { key: string };
   password?: string;
 }
 
@@ -82,7 +81,6 @@ export const sessionSlice = createSlice({
     setActiveHashKey: (state, action: { payload: AppData }) => {
       const {
         hashKey = {
-          iv: "",
           key: "",
         },
       } = action.payload;
@@ -106,7 +104,6 @@ export const sessionSlice = createSlice({
     timeoutAccountAccess: (state) => ({
       ...state,
       hashKey: {
-        iv: "",
         key: "",
       },
       password: "",

extension/src/background/helpers/__tests__/session.test.ts

@@ -9,16 +9,16 @@ describe("session", () => {
     const password = "password";
     const privateKey = "privateKey";
 
-    const { key, iv } = await deriveKeyFromString(password);
+    const { key } = await deriveKeyFromString(password);
 
     const encryptedPrivateKey = await encryptHashString({
       str: privateKey,
-      keyObject: { key, iv },
+      keyObject: { key },
     });
 
     const decryptedPrivateKey = await decryptHashString({
       hash: encryptedPrivateKey,
-      keyObject: { key, iv },
+      keyObject: { key },
     });
 
     expect(decryptedPrivateKey).toEqual(privateKey);
@@ -28,37 +28,60 @@ describe("session", () => {
       "passwordpasswordpasswordpasswordpasswordpassworw21w1w1@@@@dpasswordpasswordpasswordpcxassad@@@@asswordpasswordpasswordpasswordpassword";
     const privateKey = "privateKeyprivateKeyprivateKeyprivateKey";
 
-    const { key, iv } = await deriveKeyFromString(password);
+    const { key } = await deriveKeyFromString(password);
 
     const encryptedPrivateKey = await encryptHashString({
       str: privateKey,
-      keyObject: { key, iv },
+      keyObject: { key },
     });
 
     const decryptedPrivateKey = await decryptHashString({
       hash: encryptedPrivateKey,
-      keyObject: { key, iv },
+      keyObject: { key },
     });
 
     expect(decryptedPrivateKey).toEqual(privateKey);
   });
   it("should be able to encrypt and decrypt an empty string", async () => {
-    // this is an edge case and should never happen, but want to make sure this does not throw an error
     const password = "";
     const privateKey = "";
 
-    const { key, iv } = await deriveKeyFromString(password);
+    const { key } = await deriveKeyFromString(password);
 
     const encryptedPrivateKey = await encryptHashString({
       str: privateKey,
-      keyObject: { key, iv },
+      keyObject: { key },
     });
 
     const decryptedPrivateKey = await decryptHashString({
       hash: encryptedPrivateKey,
-      keyObject: { key, iv },
+      keyObject: { key },
     });
 
     expect(decryptedPrivateKey).toEqual(privateKey);
   });
+  it("should produce different ciphertexts for the same plaintext", async () => {
+    const password = "password";
+    const privateKey = "privateKey";
+
+    const { key } = await deriveKeyFromString(password);
+
+    const encrypted1 = await encryptHashString({
+      str: privateKey,
+      keyObject: { key },
+    });
+
+    const encrypted2 = await encryptHashString({
+      str: privateKey,
+      keyObject: { key },
+    });
+
+    const bytes1 = new Uint8Array(encrypted1);
+    const bytes2 = new Uint8Array(encrypted2);
+    const areEqual =
+      bytes1.length === bytes2.length &&
+      bytes1.every((val, i) => val === bytes2[i]);
+
+    expect(areEqual).toBe(false);
+  });
 });

extension/src/background/helpers/session.ts

@@ -29,44 +29,62 @@ export class SessionTimer {
   }
 }
 
+const IV_LENGTH = 16; // AES-CBC uses 128-bit (16 byte) IV
+
 interface HashString {
   str: string;
-  keyObject: { iv: ArrayBuffer; key: CryptoKey };
+  keyObject: { key: CryptoKey };
 }
 
 const TEMPORARY_STORE_ENCRYPTION_NAME = "AES-CBC";
 const HASH_KEY_ENCRYPTION_PARAMS = { name: "PBKDF2", hash: "SHA-256" };
 
-export const encryptHashString = ({ str, keyObject }: HashString) => {
+export const encryptHashString = async ({
+  str,
+  keyObject,
+}: HashString): Promise<ArrayBuffer> => {
+  const iv = crypto.getRandomValues(new Uint8Array(IV_LENGTH));
   const encoder = new TextEncoder();
   const encodedStr = encoder.encode(str);
 
-  return crypto.subtle.encrypt(
+  const ciphertext = await crypto.subtle.encrypt(
     {
       name: TEMPORARY_STORE_ENCRYPTION_NAME,
-      iv: keyObject.iv,
+      iv,
     },
     keyObject.key,
     encodedStr,
   );
+
+  // Prepend IV to ciphertext so each encryption is self-contained
+  const result = new Uint8Array(iv.byteLength + ciphertext.byteLength);
+  result.set(iv, 0);
+  result.set(new Uint8Array(ciphertext), iv.byteLength);
+
+  return result.buffer;
 };
 
 interface DecodeHashString {
   hash: ArrayBuffer;
-  keyObject: { iv: ArrayBuffer; key: CryptoKey };
+  keyObject: { key: CryptoKey };
 }
 
 export const decryptHashString = async ({
   hash,
   keyObject,
 }: DecodeHashString) => {
+  const data = new Uint8Array(hash);
+  // Extract the IV from the first 16 bytes
+  const iv = data.slice(0, IV_LENGTH);
+  const ciphertext = data.slice(IV_LENGTH);
+
   const decrypted = await crypto.subtle.decrypt(
     {
       name: TEMPORARY_STORE_ENCRYPTION_NAME,
-      iv: keyObject.iv,
+      iv,
     },
     keyObject.key,
-    hash,
+    ciphertext,
   );
 
   const textDecoder = new TextDecoder();
@@ -75,9 +93,8 @@ export const decryptHashString = async ({
 };
 
 export const deriveKeyFromString = async (str: string) => {
-  const iterations = 1000;
+  const iterations = 600000;
   const keylen = 32;
-  const keyLength = 48;
   // randomized salt will make sure the hashed password is different on every login
   const salt = crypto.getRandomValues(new Uint8Array(16)).toString();
 
@@ -101,31 +118,26 @@ export const deriveKeyFromString = async (str: string) => {
   const derivation = await crypto.subtle.deriveBits(
     params,
     importedKey,
-    keyLength * 8,
+    keylen * 8,
   );
 
-  const derivedKey = derivation.slice(0, keylen);
-  const iv = derivation.slice(keylen);
-
   const importedEncryptionKey = await crypto.subtle.importKey(
     "raw",
-    derivedKey,
+    derivation,
     { name: TEMPORARY_STORE_ENCRYPTION_NAME },
     true,
     ["encrypt", "decrypt"],
   );
 
   return {
     key: importedEncryptionKey,
-    iv,
   };
 };
 
 interface StoreActiveHashKey {
   sessionStore: Store;
   hashKey: {
     key: CryptoKey;
-    iv: ArrayBuffer;
   };
 }
 
@@ -141,8 +153,6 @@ export const storeActiveHashKey = async ({
   sessionStore.dispatch(
     setActiveHashKey({
       hashKey: {
-        // properly encode ArrayBuffer into serializable format
-        iv: encode(hashKey.iv),
         // JSON Web Key is able to be stringified without encoding
         key: JSON.stringify(exportedKey),
       },
@@ -159,7 +169,7 @@ export const getActiveHashKeyCryptoKey = async ({
 }: GetActiveHashKey) => {
   const hashKey = hashKeySelector(sessionStore.getState() as SessionState);
 
-  if (hashKey?.key && hashKey?.iv) {
+  if (hashKey?.key) {
     try {
       const format = "jwk";
       // JSON Web Key can be parsed with decoding
@@ -175,7 +185,6 @@ export const getActiveHashKeyCryptoKey = async ({
       );
 
       return {
-        iv: decode(hashKey.iv),
         key,
       };
     } catch (e) {
@@ -191,7 +200,6 @@ interface StoreEncryptedTemporaryData {
   keyName: string;
   temporaryData: string;
   hashKey: {
-    iv: ArrayBuffer;
     key: CryptoKey;
   };
 }

extension/src/background/messageListener/__tests__/createAccount.test.ts

@@ -57,7 +57,7 @@ describe("Create account message listener", () => {
     const tempStoreId = await mockDataStorage.getItem(TEMPORARY_STORE_ID);
 
     expect(response.hasPrivateKey).toBeTruthy();
-    expect(session.hashKey?.iv).not.toBeUndefined();
+    expect(session.hashKey?.key).toBeTruthy();
     expect(keyIdList.length).toBe(1);
     expect(keyId).toBeDefined();
     expect(applicationState).toBe(APPLICATION_STATE.PASSWORD_CREATED);