Encryption: Fix - prevent data loss during encryption migration

Author: gabrielbazan7

index.js

@@ -146,6 +146,7 @@ const ReduxProvider = () => {
   }, [isPrimary]);
 
   const [storeReady, setStoreReady] = useState(false);
+  const [startupAttempt, setStartupAttempt] = useState(0);
   const [{store: reduxStore, persistor: reduxPersistor}, setStore] = useState({
     store: null,
     persistor: null,
@@ -158,22 +159,45 @@ const ReduxProvider = () => {
 
     let cancelled = false;
 
-    getStore().then(({store, persistor}) => {
-      if (cancelled) {
-        return;
-      }
+    getStore()
+      .then(({store, persistor}) => {
+        if (cancelled) {
+          persistor.pause();
+          return;
+        }
 
-      setStore({store, persistor});
-      setStoreReady(true);
-      setJSExceptionHandler(makeErrorHandler(store), true);
-      // executeDefaultHandler=true chains to Sentry's UncaughtExceptionHandler so native crashes are captured
-      setNativeExceptionHandler(makeNativeExceptionHandler(store), true, true);
-    });
+        setStore({store, persistor});
+        setStoreReady(true);
+        setJSExceptionHandler(makeErrorHandler(store), true);
+        // executeDefaultHandler=true chains to Sentry's UncaughtExceptionHandler so native crashes are captured
+        setNativeExceptionHandler(
+          makeNativeExceptionHandler(store),
+          true,
+          true,
+        );
+      })
+      .catch(error => {
+        if (cancelled) {
+          return;
+        }
+        Sentry.captureException(error, {level: 'error'});
+        Alert.alert(
+          'Wallet data could not be opened',
+          'Your local data was preserved. Please try again.',
+          [
+            {
+              text: 'Retry',
+              onPress: () => setStartupAttempt(attempt => attempt + 1),
+            },
+          ],
+          {cancelable: false},
+        );
+      });
 
     return () => {
       cancelled = true;
     };
-  }, [isPrimary]);
+  }, [isPrimary, startupAttempt]);
 
   if (!isPrimary || !storeReady) {
     return null;

metro.config.js

@@ -22,7 +22,7 @@ const ALIASES = {
   crypto: require.resolve('react-native-quick-crypto'),
   bitauth: path.resolve(
     __dirname,
-    'node_modules/bitauth/lib/bitauth-browserify.js',
+    'node_modules/bitauth/lib/bitauth-node.js',
   ),
 };
 

src/store/bitauth.spec.ts

@@ -0,0 +1,46 @@
+jest.mock('secp256k1', () => jest.requireActual('secp256k1/elliptic'));
+
+const BitAuth = require('bitauth/lib/bitauth-node');
+const metroConfig = require('../../metro.config');
+
+describe('BitAuth Metro implementation', () => {
+  it.each(['ios', 'android'])(
+    'aliases bitauth to the CBC-free production signer on %s',
+    platform => {
+      const resolveRequest = jest.fn(
+        (_context: unknown, moduleName: string) => moduleName,
+      );
+
+      metroConfig.resolver.resolveRequest(
+        {resolveRequest},
+        'bitauth',
+        platform,
+      );
+
+      expect(resolveRequest).toHaveBeenCalledWith(
+        expect.any(Object),
+        expect.stringMatching(/bitauth\/lib\/bitauth-node\.js$/),
+        platform,
+      );
+    },
+  );
+
+  it('preserves signing without exporting the CBC helpers', () => {
+    const privateKey =
+      '0000000000000000000000000000000000000000000000000000000000000001';
+    const publicKey = BitAuth.getPublicKeyFromPrivateKey(privateKey);
+    const signature = BitAuth.sign('bitpay-test-vector', privateKey);
+
+    expect(publicKey).toBe(
+      '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798',
+    );
+    expect(signature.toString('hex')).toBe(
+      '304402205807d12cfc30686cca25b7e7e5e3154875e10e13ce0dd26f5b502d42bea7b83402204832b41c3bc3713511b48cd27ac661d9102357330b4c66f5112af592c3aa2b29',
+    );
+    expect(
+      BitAuth.verifySignature('bitpay-test-vector', publicKey, signature),
+    ).toBe(true);
+    expect(BitAuth.encrypt).toBeUndefined();
+    expect(BitAuth.decrypt).toBeUndefined();
+  });
+});

src/store/index.ts

@@ -28,7 +28,11 @@ import {
   transformPortfolioPopulateStatus,
   encryptSpecificFields,
 } from './transforms/transforms';
-import {decryptPersistValue, encryptPersistValue} from './transforms/encrypt';
+import {
+  deserializePersistValue,
+  encryptPersistValue,
+} from './transforms/encrypt';
+import {createRehydrationFailureMiddleware} from './persistence-guard';
 import {appReducer, appReduxPersistBlackList} from './app/app.reducer';
 import {
   bitPayIdReducer,
@@ -421,8 +425,15 @@ const logger = createLogger({
 });
 
 const getStore = async () => {
+  let rehydrationFailure: Error | null = null;
   const middlewares: Middleware[] = [thunkMiddleware as unknown as Middleware];
 
+  middlewares.push(
+    createRehydrationFailureMiddleware(error => {
+      rehydrationFailure ??= error;
+    }),
+  );
+
   const cleanupPortfolioOnDeleteKeyMiddleware: Middleware = store => next => {
     return (action: AnyAction) => {
       if (action?.type !== WalletActionTypes.DELETE_KEY) {
@@ -515,25 +526,12 @@ const getStore = async () => {
           );
         },
         (outboundState, key) => {
-          if (typeof key === 'string' && unencryptedPersistStores.has(key)) {
-            if (typeof outboundState === 'string') {
-              try {
-                return JSON.parse(outboundState);
-              } catch {}
-            } else {
-              return outboundState;
-            }
-          }
-
-          if (typeof outboundState !== 'string') {
-            return outboundState;
-          }
-
           try {
-            return decryptPersistValue(
+            return deserializePersistValue(
               outboundState,
               secretKey,
               `persist:${String(key)}`,
+              typeof key === 'string' && unencryptedPersistStores.has(key),
             );
           } catch (err) {
             const errStr =
@@ -620,7 +618,18 @@ const getStore = async () => {
   storeDispatch(LogActions.clear());
   initLogs.drainAndDispatch(storeDispatch);
 
-  const persistor = persistStore(store);
+  let resolveBootstrap: () => void = () => {};
+  const bootstrapped = new Promise<void>(resolve => {
+    resolveBootstrap = resolve;
+  });
+  const persistor = persistStore(store, undefined, resolveBootstrap);
+
+  await bootstrapped;
+  if (rehydrationFailure) {
+    persistor.pause();
+    Sentry.captureException(rehydrationFailure, {level: 'error'});
+    throw rehydrationFailure;
+  }
 
   if (__DEV__) {
     // persistor.purge().then(() => console.log('purged persistence'));

src/store/persistence-guard.spec.ts

@@ -0,0 +1,50 @@
+import {applyMiddleware, createStore, Middleware} from 'redux';
+import {createTransform, persistReducer, persistStore} from 'redux-persist';
+import {createRehydrationFailureMiddleware} from './persistence-guard';
+
+describe('rehydration failure protection', () => {
+  it('pauses persistence before a decrypt error can overwrite the original root', async () => {
+    const originalRoot = JSON.stringify({
+      TEST: JSON.stringify('corrupted-ciphertext'),
+    });
+    let storedRoot = originalRoot;
+    const storage = {
+      getItem: jest.fn(async () => storedRoot),
+      setItem: jest.fn(async (_key: string, value: string) => {
+        storedRoot = value;
+      }),
+      removeItem: jest.fn(async () => undefined),
+    };
+    const transform = createTransform<any, any>(
+      state => state,
+      () => {
+        throw new Error('decrypt failed');
+      },
+    );
+    const onFailure = jest.fn();
+    const persistedReducer = persistReducer(
+      {key: 'root', storage, transforms: [transform], timeout: 0},
+      (state = {TEST: 'initial'}, action) =>
+        action.type === 'CHANGE' ? {TEST: 'changed'} : state,
+    );
+    const store = createStore(
+      persistedReducer,
+      applyMiddleware(
+        createRehydrationFailureMiddleware(onFailure) as Middleware,
+      ),
+    );
+
+    let persistor: ReturnType<typeof persistStore> | undefined;
+    await new Promise<void>(resolve => {
+      persistor = persistStore(store, undefined, resolve);
+    });
+
+    store.dispatch({type: 'CHANGE'});
+    await persistor!.flush();
+
+    expect(onFailure).toHaveBeenCalledWith(expect.any(Error));
+    expect(storage.setItem).not.toHaveBeenCalled();
+    expect(storedRoot).toBe(originalRoot);
+    expect(store.getState().TEST).toBe('changed');
+  });
+});

src/store/persistence-guard.ts

@@ -0,0 +1,22 @@
+import {AnyAction, Middleware} from 'redux';
+import {PAUSE, REHYDRATE} from 'redux-persist';
+
+const toError = (error: unknown): Error =>
+  error instanceof Error ? error : new Error(String(error));
+
+export const createRehydrationFailureMiddleware =
+  (onFailure: (error: Error) => void): Middleware =>
+  store =>
+  next =>
+  (action: AnyAction) => {
+    if (
+      action.type === REHYDRATE &&
+      action.key === 'root' &&
+      action.err != null
+    ) {
+      const error = toError(action.err);
+      store.dispatch({type: PAUSE});
+      onFailure(error);
+    }
+    return next(action);
+  };

src/store/transforms/encrypt.spec.ts

@@ -2,6 +2,7 @@ import crypto from 'crypto';
 import Aes from 'crypto-js/aes.js';
 import {
   decryptPersistValue,
+  deserializePersistValue,
   decryptValue,
   decryptWalletStore,
   encryptPersistValue,
@@ -118,4 +119,24 @@ describe('persisted reducer values', () => {
     );
     randomBytes.mockRestore();
   });
+
+  it.each([false, true])(
+    'rejects non-string reducers instead of bypassing decryption (plain JSON: %s)',
+    allowPlainJson => {
+      expect(() =>
+        deserializePersistValue(
+          {token: 'injected'},
+          secretKey,
+          context,
+          allowPlainJson,
+        ),
+      ).toThrow('to be a string');
+    },
+  );
+
+  it('reads production JSON only for reducers configured as plaintext', () => {
+    expect(
+      deserializePersistValue(JSON.stringify(state), secretKey, context, true),
+    ).toEqual(state);
+  });
 });

src/store/transforms/encrypt.ts

@@ -200,6 +200,25 @@ export const decryptPersistValue = (
   return JSON.parse(legacy);
 };
 
+export const deserializePersistValue = (
+  value: unknown,
+  secretKey: string,
+  context: string,
+  allowPlainJson: boolean,
+): any => {
+  if (typeof value !== 'string') {
+    throw new Error('Expected persisted reducer to be a string');
+  }
+
+  if (allowPlainJson) {
+    try {
+      return JSON.parse(value);
+    } catch {}
+  }
+
+  return decryptPersistValue(value, secretKey, context);
+};
+
 // Generic function to transform wallet store (encrypt or decrypt)
 const transformWalletStore = (
   state: any,