react-native-security-suite 0.1.2 → 0.3.0

package/src/index.tsx

@@ -1,4 +1,7 @@
 import { NativeModules, Platform } from 'react-native';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import _ from 'lodash';
+import { isJsonString } from './helpers';
 
 const LINKING_ERROR =
   `The package 'react-native-security-suite' doesn't seem to be linked. Make sure: \n\n` +
@@ -15,10 +18,207 @@ const SecuritySuite = NativeModules.SecuritySuite
           throw new Error(LINKING_ERROR);
         },
       }
-  );
-    
+    );
+
+export const getPublicKey = (): Promise<string> => SecuritySuite.getPublicKey();
+
+export const getSharedKey = (serverPublicKey: string): Promise<string> =>
+  SecuritySuite.getSharedKey(serverPublicKey);
+
+export const encryptBySharedKey = (input: string): Promise<string> =>
+  input && typeof input === 'string' ? SecuritySuite.encrypt(input) : '';
+
+export const decryptBySharedKey = (input: string) =>
+  input && typeof input === 'string' ? SecuritySuite.decrypt(input) : '';
+
+export const getDeviceId = (): Promise<string> =>
+  new Promise((resolve: any, reject: any) => {
+    SecuritySuite.getDeviceId((result: string | null, error: string | null) => {
+      if (error !== null) reject(error);
+      else resolve(result);
+    });
+  });
+
+export const encrypt = (
+  input: string,
+  hardEncryption = true,
+  secretKey = null
+): Promise<string> =>
+  new Promise((resolve: any, reject: any) => {
+    if (!input) resolve(input);
+
+    SecuritySuite.storageEncrypt(
+      input,
+      secretKey,
+      hardEncryption,
+      (result: string | null, error: string | null) => {
+        if (error !== null) reject(error);
+        else resolve(result);
+      }
+    );
+  });
+
+export const decrypt = (
+  input: string,
+  hardEncryption = true,
+  secretKey = null
+): Promise<string> =>
+  new Promise((resolve: any, reject: any) => {
+    if (!input) resolve(input);
+
+    SecuritySuite.storageDecrypt(
+      input,
+      secretKey,
+      hardEncryption,
+      (result: string | null, error: string | null) => {
+        if (error !== null) reject(error);
+        else resolve(result);
+      }
+    );
+  });
+
+export const SecureStorage = {
+  setItem: async (key: string, value: string) => {
+    try {
+      const encryptedKey = await encrypt(key, false);
+      const encryptedValue = await encrypt(value);
+      return AsyncStorage.setItem(encryptedKey, encryptedValue);
+    } catch (e) {
+      return e;
+    }
+  },
+  getItem: async (key: string) => {
+    try {
+      const encryptedKey = await encrypt(key, false);
+      const encryptedData = await AsyncStorage.getItem(encryptedKey);
+      return decrypt(encryptedData ?? '');
+    } catch (e) {
+      return e;
+    }
+  },
+  mergeItem: async (key: string, value: string) => {
+    try {
+      const encryptedKey = await encrypt(key, false);
+      const encryptedData = await AsyncStorage.getItem(encryptedKey);
+      const data = await decrypt(encryptedData ?? '');
+      if (!isJsonString(data) || !isJsonString(value)) return null;
+      const mergedData = await JSON.stringify(
+        _.merge(JSON.parse(data), JSON.parse(value))
+      );
+      const encryptedValue = await encrypt(mergedData);
+      return AsyncStorage.setItem(encryptedKey, encryptedValue);
+    } catch (e) {
+      return e;
+    }
+  },
+  removeItem: async (key: string) => {
+    try {
+      const encryptedKey = await encrypt(key, false);
+      return AsyncStorage.removeItem(encryptedKey);
+    } catch (e) {
+      return e;
+    }
+  },
+  getAllKeys: async () => {
+    try {
+      const encryptedKeys = await AsyncStorage.getAllKeys();
+      return await Promise.all(
+        encryptedKeys.map(async (item: string): Promise<string> => {
+          const decryptedKey = await decrypt(item, false);
+          return decryptedKey ? decryptedKey : item;
+        })
+      );
+    } catch (e) {
+      return e;
+    }
+  },
+  multiSet: async (
+    keyValuePairs: Array<Array<string>>
+  ): Promise<void | string[][]> => {
+    try {
+      const encryptedKeyValuePairs: any = await Promise.all(
+        keyValuePairs.map(async (item: Array<string>) => {
+          if (item.length === 2 && item[0] && item[1]) {
+            const encryptedKey = await encrypt(item[0], false);
+            const encryptedValue = await encrypt(item[1]);
+            return [encryptedKey, encryptedValue];
+          }
+
+          return null;
+        })
+      );
+      AsyncStorage.multiSet(encryptedKeyValuePairs);
+    } catch (e) {
+      console.error('multiSet error: ', e);
+    }
+  },
+  multiGet: async (keys: Array<string>) => {
+    try {
+      if (!Array.isArray(keys)) return null;
+      const encryptedKeys = await Promise.all(
+        keys.map(
+          async (item: string): Promise<string> => await encrypt(item, false)
+        )
+      );
+      const encryptedItems = await AsyncStorage.multiGet(encryptedKeys);
+      return await Promise.all(
+        encryptedItems && encryptedItems.length
+          ? encryptedItems.map(async (item: any): Promise<string[]> => {
+              const decryptedKey = await decrypt(item[0], false);
+              const decryptedalue = await decrypt(item[1]);
+              return [decryptedKey, decryptedalue];
+            })
+          : []
+      );
+    } catch (e) {
+      return e;
+    }
+  },
+  multiMerge: async (keyValuePairs: Array<Array<string>>) => {
+    try {
+      return keyValuePairs.map(async (item: Array<string>) => {
+        if (item.length === 2 && item[0] && item[1]) {
+          const encryptedKey = await encrypt(item[0], false);
+          const encryptedData = await AsyncStorage.getItem(item[0]);
+          const data = await decrypt(encryptedData ?? '');
+          if (!isJsonString(data) || !isJsonString(item[1])) return null;
+          const mergedData = await JSON.stringify(
+            _.merge(JSON.parse(data), JSON.parse(item[1]))
+          );
+          const encryptedValue = await encrypt(mergedData, false);
+          return AsyncStorage.setItem(encryptedKey, encryptedValue);
+        }
+
+        return null;
+      });
+    } catch (e) {
+      return e;
+    }
+  },
+  multiRemove: async (keys: Array<string>) => {
+    try {
+      if (!Array.isArray(keys)) return keys;
+      const encryptedKeys = await Promise.all(
+        keys.map(
+          async (item: string): Promise<string> => await encrypt(item, false)
+        )
+      );
+      return AsyncStorage.multiRemove(encryptedKeys);
+    } catch (e) {
+      return e;
+    }
+  },
+  clear: async () => {
+    try {
+      return AsyncStorage.clear();
+    } catch (e) {
+      return e;
+    }
+  },
+};
+
 export function deviceHasSecurityRisk(): Promise<boolean> {
   return SecuritySuite.deviceHasSecurityRisk();
 }
 
-export default SecuritySuite;
+export default SecuritySuite;

package/android/src/main/java/com/reactnativesecuritysuite/SecuritySuiteModule.java

@@ -1,38 +0,0 @@
-package com.reactnativesecuritysuite;
-
-import androidx.annotation.NonNull;
-
-import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
-import com.facebook.react.bridge.ReactMethod;
-import com.facebook.react.module.annotations.ReactModule;
-import com.scottyab.rootbeer.RootBeer;
-
-@ReactModule(name = SecuritySuiteModule.NAME)
-public class SecuritySuiteModule extends ReactContextBaseJavaModule {
-    public static final String NAME = "SecuritySuite";
-    private ReactApplicationContext context;
-
-    public SecuritySuiteModule(ReactApplicationContext reactContext) {
-        super(reactContext);
-        context = reactContext;
-    }
-
-    @Override
-    @NonNull
-    public String getName() {
-        return NAME;
-    }
-
-
-    // Example method
-    // See https://reactnative.dev/docs/native-modules-android
-    @ReactMethod
-    public void deviceHasSecurityRisk(Promise promise) {
-        RootBeer rootBeer = new RootBeer(context);
-        promise.resolve(rootBeer.isRooted());
-    }
-
-    public static native int nativeMultiply(int a, int b);
-}

package/android/src/main/java/com/reactnativesecuritysuite/SecuritySuitePackage.java

@@ -1,28 +0,0 @@
-package com.reactnativesecuritysuite;
-
-import androidx.annotation.NonNull;
-
-import com.facebook.react.ReactPackage;
-import com.facebook.react.bridge.NativeModule;
-import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.uimanager.ViewManager;
-
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-
-public class SecuritySuitePackage implements ReactPackage {
-    @NonNull
-    @Override
-    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
-        List<NativeModule> modules = new ArrayList<>();
-        modules.add(new SecuritySuiteModule(reactContext));
-        return modules;
-    }
-
-    @NonNull
-    @Override
-    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
-        return Collections.emptyList();
-    }
-}

package/ios/SecuritySuite.m

@@ -1,12 +0,0 @@
-#import <React/RCTBridgeModule.h>
-
-@interface RCT_EXTERN_MODULE(SecuritySuite, NSObject)
-
-RCT_EXTERN_METHOD(deviceHasSecurityRisk:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
-
-+ (BOOL)requiresMainQueueSetup
-{
-  return NO;
-}
-
-@end