react-native-security-suite 0.1.2 → 0.2.0

package/lib/typescript/index.d.ts

@@ -1,3 +1,22 @@
 declare const SecuritySuite: any;
+export declare const getPublicKey: () => Promise<string>;
+export declare const getSharedKey: (serverPublicKey: string) => Promise<string>;
+export declare const encryptBySharedKey: (input: string) => Promise<string>;
+export declare const decryptBySharedKey: (input: string) => any;
+export declare const getDeviceId: () => Promise<string>;
+export declare const encrypt: (input: string, hardEncryption?: boolean, secretKey?: null) => Promise<string>;
+export declare const decrypt: (input: string, hardEncryption?: boolean, secretKey?: null) => Promise<string>;
+export declare const SecureStorage: {
+    setItem: (key: string, value: string) => Promise<unknown>;
+    getItem: (key: string) => Promise<unknown>;
+    mergeItem: (key: string, value: string) => Promise<unknown>;
+    removeItem: (key: string) => Promise<unknown>;
+    getAllKeys: () => Promise<unknown>;
+    multiSet: (keyValuePairs: Array<Array<string>>) => Promise<unknown>;
+    multiGet: (keys: Array<string>) => Promise<unknown>;
+    multiMerge: (keyValuePairs: Array<Array<string>>) => Promise<unknown>;
+    multiRemove: (keys: Array<string>) => Promise<unknown>;
+    clear: () => Promise<unknown>;
+};
 export declare function deviceHasSecurityRisk(): Promise<boolean>;
 export default SecuritySuite;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-security-suite",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Security suite for React Native",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -54,6 +54,7 @@
     "@react-native-community/eslint-config": "^2.0.0",
     "@release-it/conventional-changelog": "^2.0.0",
     "@types/jest": "^26.0.0",
+    "@types/lodash": "^4.14.195",
     "@types/react": "^16.9.19",
     "@types/react-native": "0.62.13",
     "commitlint": "^11.0.0",
@@ -71,9 +72,16 @@
     "typescript": "^4.1.3"
   },
   "peerDependencies": {
+    "@react-native-async-storage/async-storage": "*",
+    "lodash": "*",
     "react": "*",
     "react-native": "*"
   },
+  "peerDependenciesMeta": {
+    "@react-native-async-storage/async-storage": {
+      "optional": false
+    }
+  },
   "jest": {
     "preset": "react-native",
     "modulePathIgnorePatterns": [
@@ -149,5 +157,8 @@
   },
   "directories": {
     "example": "example"
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.19.0"
   }
 }

package/react-native-security-suite.podspec

@@ -10,7 +10,7 @@ Pod::Spec.new do |s|
   s.license      = package["license"]
   s.authors      = package["author"]
 
-  s.platforms    = { :ios => "10.0" }
+  s.platforms    = { :ios => "13.0" }
   s.source       = { :git => "https://github.com/mohamadnavabi/react-native-security-suite.git", :tag => "#{s.version}" }
 
   s.source_files = "ios/**/*.{h,m,mm,swift}"

package/src/helpers.ts

@@ -0,0 +1,8 @@
+export const isJsonString = (value: string): boolean => {
+  try {
+    JSON.parse(value);
+  } catch (e) {
+    return false;
+  }
+  return true;
+};

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,199 @@ 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>>) => {
+    try {
+      const encryptedKeyValuePairs: any = await Promise.all(
+        keyValuePairs.map(async (item: Array<string>) => {
+          if (item.length !== 2) return [];
+          const encryptedKey = await encrypt(item[0], false);
+          const encryptedValue = await encrypt(item[1]);
+          return [encryptedKey, encryptedValue];
+        })
+      );
+      AsyncStorage.multiSet(encryptedKeyValuePairs);
+    } catch (e) {
+      return 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) return;
+        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);
+      });
+    } 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;