react-native-nitro-storage 0.1.3 → 0.3.0

package/android/src/main/cpp/AndroidStorageAdapterCpp.cpp

@@ -3,6 +3,39 @@
 namespace NitroStorage {
 
 using namespace facebook::jni;
+using JavaStringArray = JArrayClass<jstring>;
+
+namespace {
+
+local_ref<JavaStringArray> toJavaStringArray(const std::vector<std::string>& values) {
+    auto javaArray = JavaStringArray::newArray(static_cast<jsize>(values.size()));
+    for (size_t i = 0; i < values.size(); ++i) {
+        auto javaValue = make_jstring(values[i]);
+        javaArray->setElement(static_cast<jsize>(i), javaValue.get());
+    }
+    return javaArray;
+}
+
+std::vector<std::optional<std::string>> fromJavaStringArray(alias_ref<JavaStringArray> values) {
+    std::vector<std::optional<std::string>> parsedValues;
+    if (!values) {
+        return parsedValues;
+    }
+
+    const auto size = values->size();
+    parsedValues.reserve(size);
+    for (jsize i = 0; i < size; ++i) {
+        auto currentValue = values->getElement(i);
+        if (!currentValue) {
+            parsedValues.push_back(std::nullopt);
+            continue;
+        }
+        parsedValues.push_back(currentValue->toStdString());
+    }
+    return parsedValues;
+}
+
+} // namespace
 
 AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> context) {
     if (!context) [[unlikely]] {
@@ -29,6 +62,40 @@ void AndroidStorageAdapterCpp::deleteDisk(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+void AndroidStorageAdapterCpp::setDiskBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    auto javaValues = toJavaStringArray(values);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>, alias_ref<JavaStringArray>)
+        >("setDiskBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys, javaValues);
+}
+
+std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getDiskBatch(
+    const std::vector<std::string>& keys
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
+        >("getDiskBatch");
+    auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+    return fromJavaStringArray(values);
+}
+
+void AndroidStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& keys) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>)
+        >("deleteDiskBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+}
+
 void AndroidStorageAdapterCpp::setSecure(const std::string& key, const std::string& value) {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setSecure");
     method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
@@ -46,6 +113,40 @@ void AndroidStorageAdapterCpp::deleteSecure(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+void AndroidStorageAdapterCpp::setSecureBatch(
+    const std::vector<std::string>& keys,
+    const std::vector<std::string>& values
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    auto javaValues = toJavaStringArray(values);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>, alias_ref<JavaStringArray>)
+        >("setSecureBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys, javaValues);
+}
+
+std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getSecureBatch(
+    const std::vector<std::string>& keys
+) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
+        >("getSecureBatch");
+    auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+    return fromJavaStringArray(values);
+}
+
+void AndroidStorageAdapterCpp::deleteSecureBatch(const std::vector<std::string>& keys) {
+    auto javaKeys = toJavaStringArray(keys);
+    static auto method =
+        AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+            void(alias_ref<JavaStringArray>)
+        >("deleteSecureBatch");
+    method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
+}
+
 void AndroidStorageAdapterCpp::clearDisk() {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
     method(AndroidStorageAdapterJava::javaClassStatic());

package/android/src/main/cpp/AndroidStorageAdapterCpp.hpp

@@ -18,47 +18,6 @@ struct AndroidStorageAdapterJava : facebook::jni::JavaClass<AndroidStorageAdapte
      return method(javaClassStatic());
   }
 
-  void setDisk(std::string key, std::string value) {
-      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setDisk");
-      method(self(), key, value);
-  }
-
-  std::string getDisk(std::string key) {
-      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getDisk");
-      auto result = method(self(), key);
-      return result ? result->toStdString() : "";
-  }
-  
-  void deleteDisk(std::string key) {
-      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteDisk");
-      method(self(), key);
-  }
-
-  void setSecure(std::string key, std::string value) {
-      static auto method = javaClassStatic()->getMethod<void(std::string, std::string)>("setSecure");
-      method(self(), key, value);
-  }
-
-  std::string getSecure(std::string key) {
-      static auto method = javaClassStatic()->getMethod<jstring(std::string)>("getSecure");
-      auto result = method(self(), key);
-      return result ? result->toStdString() : "";
-  }
-  
-  void deleteSecure(std::string key) {
-      static auto method = javaClassStatic()->getMethod<void(std::string)>("deleteSecure");
-      method(self(), key);
-  }
-
-  void clearDisk() {
-      static auto method = javaClassStatic()->getStaticMethod<void()>("clearDisk");
-      method(javaClassStatic());
-  }
-
-  void clearSecure() {
-      static auto method = javaClassStatic()->getStaticMethod<void()>("clearSecure");
-      method(javaClassStatic());
-  }
 };
 
 class AndroidStorageAdapterCpp : public NativeStorageAdapter {
@@ -69,10 +28,16 @@ public:
     void setDisk(const std::string& key, const std::string& value) override;
     std::optional<std::string> getDisk(const std::string& key) override;
     void deleteDisk(const std::string& key) override;
+    void setDiskBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) override;
+    std::vector<std::optional<std::string>> getDiskBatch(const std::vector<std::string>& keys) override;
+    void deleteDiskBatch(const std::vector<std::string>& keys) override;
     
     void setSecure(const std::string& key, const std::string& value) override;
     std::optional<std::string> getSecure(const std::string& key) override;
     void deleteSecure(const std::string& key) override;
+    void setSecureBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values) override;
+    std::vector<std::optional<std::string>> getSecureBatch(const std::vector<std::string>& keys) override;
+    void deleteSecureBatch(const std::vector<std::string>& keys) override;
     
     void clearDisk() override;
     void clearSecure() override;

package/android/src/main/java/com/nitrostorage/AndroidStorageAdapter.kt

@@ -2,37 +2,83 @@ package com.nitrostorage
 
 import android.content.Context
 import android.content.SharedPreferences
+import android.util.Log
 import androidx.security.crypto.EncryptedSharedPreferences
 import androidx.security.crypto.MasterKey
+import java.security.KeyStore
+import javax.crypto.AEADBadTagException
 
 class AndroidStorageAdapter private constructor(private val context: Context) {
     private val sharedPreferences: SharedPreferences = 
         context.getSharedPreferences("NitroStorage", Context.MODE_PRIVATE)
-    
-    private val masterKey: MasterKey = MasterKey.Builder(context)
+
+    private val masterKeyAlias = "${context.packageName}.nitro_storage.master_key"
+    private val masterKey: MasterKey = MasterKey.Builder(context, masterKeyAlias)
         .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
         .build()
     
-    private val encryptedPreferences: SharedPreferences = try {
-        EncryptedSharedPreferences.create(
-            context,
-            "NitroStorageSecure",
-            masterKey,
-            EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
-            EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
-        )
-    } catch (e: Exception) {
-        throw RuntimeException(
-            "NitroStorage: Failed to initialize secure storage. " +
-            "This may be due to corrupted encryption keys. " +
-            "Try clearing app data or reinstalling the app.", e
-        )
+    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences()
+    
+    private fun initializeEncryptedPreferences(): SharedPreferences {
+        return try {
+            EncryptedSharedPreferences.create(
+                context,
+                "NitroStorageSecure",
+                masterKey,
+                EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+                EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+            )
+        } catch (e: Exception) {
+            // Handle corrupted keystore keys by clearing and re-initializing
+            if (e is AEADBadTagException || e.cause is AEADBadTagException) {
+                Log.w("NitroStorage", "Detected corrupted encryption keys, clearing secure storage...")
+                clearCorruptedSecureStorage()
+                
+                // Retry initialization
+                EncryptedSharedPreferences.create(
+                    context,
+                    "NitroStorageSecure",
+                    masterKey,
+                    EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
+                    EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
+                )
+            } else {
+                throw RuntimeException(
+                    "NitroStorage: Failed to initialize secure storage. " +
+                    "This may be due to corrupted encryption keys. " +
+                    "Try clearing app data or reinstalling the app.", e
+                )
+            }
+        }
+    }
+    
+    private fun clearCorruptedSecureStorage() {
+        try {
+            // Delete the encrypted shared preferences file
+            context.deleteSharedPreferences("NitroStorageSecure")
+            
+            // Delete the master key from Android Keystore
+            val keyStore = KeyStore.getInstance("AndroidKeyStore")
+            keyStore.load(null)
+            keyStore.deleteEntry(masterKeyAlias)
+            
+            Log.i("NitroStorage", "Successfully cleared corrupted secure storage")
+        } catch (e: Exception) {
+            Log.e("NitroStorage", "Failed to clear corrupted secure storage", e)
+        }
     }
     
     companion object {
         @Volatile
         private var instance: AndroidStorageAdapter? = null
 
+        private fun getInstanceOrThrow(): AndroidStorageAdapter {
+            return instance ?: throw IllegalStateException(
+                "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
+                "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
+            )
+        }
+
         @JvmStatic
         fun init(context: Context) {
             if (instance == null) {
@@ -46,59 +92,101 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
 
         @JvmStatic
         fun getContext(): Context {
-            return instance?.context 
-                ?: throw IllegalStateException(
-                    "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
-                    "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
-                )
+            return getInstanceOrThrow().context
         }
         
         @JvmStatic
         fun setDisk(key: String, value: String) {
-            instance?.sharedPreferences?.edit()?.putString(key, value)?.apply()
-                ?: throw IllegalStateException(
-                    "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
-                    "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
-                )
+            getInstanceOrThrow().sharedPreferences.edit().putString(key, value).apply()
+        }
+
+        @JvmStatic
+        fun setDiskBatch(keys: Array<String>, values: Array<String>) {
+            val editor = getInstanceOrThrow().sharedPreferences.edit()
+            val count = minOf(keys.size, values.size)
+            for (index in 0 until count) {
+                editor.putString(keys[index], values[index])
+            }
+            editor.apply()
         }
         
         @JvmStatic
         fun getDisk(key: String): String? {
-            return instance?.sharedPreferences?.getString(key, null)
+            return getInstanceOrThrow().sharedPreferences.getString(key, null)
+        }
+
+        @JvmStatic
+        fun getDiskBatch(keys: Array<String>): Array<String?> {
+            val prefs = getInstanceOrThrow().sharedPreferences
+            return Array(keys.size) { index ->
+                prefs.getString(keys[index], null)
+            }
         }
         
         @JvmStatic
         fun deleteDisk(key: String) {
-            instance?.sharedPreferences?.edit()?.remove(key)?.apply()
+            getInstanceOrThrow().sharedPreferences.edit().remove(key).apply()
+        }
+
+        @JvmStatic
+        fun deleteDiskBatch(keys: Array<String>) {
+            val editor = getInstanceOrThrow().sharedPreferences.edit()
+            for (key in keys) {
+                editor.remove(key)
+            }
+            editor.apply()
         }
         
         @JvmStatic
         fun setSecure(key: String, value: String) {
-            instance?.encryptedPreferences?.edit()?.putString(key, value)?.apply()
-                ?: throw IllegalStateException(
-                    "NitroStorage not initialized. Call AndroidStorageAdapter.init(this) in your MainApplication.onCreate(), " +
-                    "or add 'react-native-nitro-storage' to your Expo plugins array in app.json."
-                )
+            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).apply()
+        }
+
+        @JvmStatic
+        fun setSecureBatch(keys: Array<String>, values: Array<String>) {
+            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            val count = minOf(keys.size, values.size)
+            for (index in 0 until count) {
+                editor.putString(keys[index], values[index])
+            }
+            editor.apply()
         }
         
         @JvmStatic
         fun getSecure(key: String): String? {
-            return instance?.encryptedPreferences?.getString(key, null)
+            return getInstanceOrThrow().encryptedPreferences.getString(key, null)
+        }
+
+        @JvmStatic
+        fun getSecureBatch(keys: Array<String>): Array<String?> {
+            val prefs = getInstanceOrThrow().encryptedPreferences
+            return Array(keys.size) { index ->
+                prefs.getString(keys[index], null)
+            }
         }
         
         @JvmStatic
         fun deleteSecure(key: String) {
-            instance?.encryptedPreferences?.edit()?.remove(key)?.apply()
+            getInstanceOrThrow().encryptedPreferences.edit().remove(key).apply()
+        }
+
+        @JvmStatic
+        fun deleteSecureBatch(keys: Array<String>) {
+            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            for (key in keys) {
+                editor.remove(key)
+            }
+            editor.apply()
         }
 
         @JvmStatic
         fun clearDisk() {
-            instance?.sharedPreferences?.edit()?.clear()?.apply()
+            getInstanceOrThrow().sharedPreferences.edit().clear().apply()
         }
 
         @JvmStatic
         fun clearSecure() {
-            instance?.encryptedPreferences?.edit()?.clear()?.apply()
+            getInstanceOrThrow().encryptedPreferences.edit().clear().apply()
         }
     }
 }

package/app.plugin.js

@@ -6,19 +6,21 @@ const {
 } = require("@expo/config-plugins");
 
 const withNitroStorage = (config, props = {}) => {
-  const {
-    faceIDPermission = "Allow $(PRODUCT_NAME) to use Face ID for secure authentication",
-  } = props;
+  const defaultFaceIDPermission =
+    "Allow $(PRODUCT_NAME) to use Face ID for secure authentication";
+  const { faceIDPermission, addBiometricPermissions = false } = props;
 
   config = withInfoPlist(config, (config) => {
-    config.modResults.NSFaceIDUsageDescription =
-      faceIDPermission || config.modResults.NSFaceIDUsageDescription;
+    if (typeof faceIDPermission === "string" && faceIDPermission.trim() !== "") {
+      config.modResults.NSFaceIDUsageDescription = faceIDPermission;
+    } else if (!config.modResults.NSFaceIDUsageDescription) {
+      config.modResults.NSFaceIDUsageDescription = defaultFaceIDPermission;
+    }
     return config;
   });
 
   config = withAndroidManifest(config, (config) => {
-    const mainApplication = config.modResults.manifest.application?.[0];
-    if (!mainApplication) {
+    if (!addBiometricPermissions) {
       return config;
     }