react-native-nitro-storage 0.3.0 → 0.3.2

package/android/CMakeLists.txt

@@ -11,6 +11,8 @@ file(GLOB SOURCES
   "../cpp/core/*.cpp"
   "./src/main/cpp/*.cpp"
 )
+# Unit/integration C++ tests define `main()` and must never be linked into the Android shared library.
+list(FILTER SOURCES EXCLUDE REGEX ".*/[^/]*Test\\.cpp$")
 
 # 2. Create the library target
 add_library(

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

@@ -16,13 +16,11 @@ local_ref<JavaStringArray> toJavaStringArray(const std::vector<std::string>& val
     return javaArray;
 }
 
-std::vector<std::optional<std::string>> fromJavaStringArray(alias_ref<JavaStringArray> values) {
+std::vector<std::optional<std::string>> fromNullableJavaStringArray(alias_ref<JavaStringArray> values) {
     std::vector<std::optional<std::string>> parsedValues;
-    if (!values) {
-        return parsedValues;
-    }
+    if (!values) return parsedValues;
 
-    const auto size = values->size();
+    const jsize size = static_cast<jsize>(values->size());
     parsedValues.reserve(size);
     for (jsize i = 0; i < size; ++i) {
         auto currentValue = values->getElement(i);
@@ -35,6 +33,21 @@ std::vector<std::optional<std::string>> fromJavaStringArray(alias_ref<JavaString
     return parsedValues;
 }
 
+std::vector<std::string> fromJavaStringArray(alias_ref<JavaStringArray> values) {
+    std::vector<std::string> result;
+    if (!values) return result;
+
+    const jsize size = static_cast<jsize>(values->size());
+    result.reserve(size);
+    for (jsize i = 0; i < size; ++i) {
+        auto currentValue = values->getElement(i);
+        if (currentValue) {
+            result.push_back(currentValue->toStdString());
+        }
+    }
+    return result;
+}
+
 } // namespace
 
 AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> context) {
@@ -45,6 +58,8 @@ AndroidStorageAdapterCpp::AndroidStorageAdapterCpp(alias_ref<JObject> context) {
 
 AndroidStorageAdapterCpp::~AndroidStorageAdapterCpp() = default;
 
+// --- Disk ---
+
 void AndroidStorageAdapterCpp::setDisk(const std::string& key, const std::string& value) {
     static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setDisk");
     method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
@@ -62,6 +77,24 @@ void AndroidStorageAdapterCpp::deleteDisk(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+bool AndroidStorageAdapterCpp::hasDisk(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasDisk");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+        local_ref<JavaStringArray>()
+    >("getAllKeysDisk");
+    auto keys = method(AndroidStorageAdapterJava::javaClassStatic());
+    return fromJavaStringArray(keys);
+}
+
+size_t AndroidStorageAdapterCpp::sizeDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jint()>("sizeDisk");
+    return static_cast<size_t>(method(AndroidStorageAdapterJava::javaClassStatic()));
+}
+
 void AndroidStorageAdapterCpp::setDiskBatch(
     const std::vector<std::string>& keys,
     const std::vector<std::string>& values
@@ -84,7 +117,7 @@ std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getDiskBatch(
             local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
         >("getDiskBatch");
     auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
-    return fromJavaStringArray(values);
+    return fromNullableJavaStringArray(values);
 }
 
 void AndroidStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& keys) {
@@ -96,6 +129,13 @@ void AndroidStorageAdapterCpp::deleteDiskBatch(const std::vector<std::string>& k
     method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
 }
 
+void AndroidStorageAdapterCpp::clearDisk() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
+    method(AndroidStorageAdapterJava::javaClassStatic());
+}
+
+// --- Secure ---
+
 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);
@@ -113,6 +153,24 @@ void AndroidStorageAdapterCpp::deleteSecure(const std::string& key) {
     method(AndroidStorageAdapterJava::javaClassStatic(), key);
 }
 
+bool AndroidStorageAdapterCpp::hasSecure(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasSecure");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+std::vector<std::string> AndroidStorageAdapterCpp::getAllKeysSecure() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<
+        local_ref<JavaStringArray>()
+    >("getAllKeysSecure");
+    auto keys = method(AndroidStorageAdapterJava::javaClassStatic());
+    return fromJavaStringArray(keys);
+}
+
+size_t AndroidStorageAdapterCpp::sizeSecure() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jint()>("sizeSecure");
+    return static_cast<size_t>(method(AndroidStorageAdapterJava::javaClassStatic()));
+}
+
 void AndroidStorageAdapterCpp::setSecureBatch(
     const std::vector<std::string>& keys,
     const std::vector<std::string>& values
@@ -135,7 +193,7 @@ std::vector<std::optional<std::string>> AndroidStorageAdapterCpp::getSecureBatch
             local_ref<JavaStringArray>(alias_ref<JavaStringArray>)
         >("getSecureBatch");
     auto values = method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
-    return fromJavaStringArray(values);
+    return fromNullableJavaStringArray(values);
 }
 
 void AndroidStorageAdapterCpp::deleteSecureBatch(const std::vector<std::string>& keys) {
@@ -147,13 +205,46 @@ void AndroidStorageAdapterCpp::deleteSecureBatch(const std::vector<std::string>&
     method(AndroidStorageAdapterJava::javaClassStatic(), javaKeys);
 }
 
-void AndroidStorageAdapterCpp::clearDisk() {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearDisk");
+void AndroidStorageAdapterCpp::clearSecure() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearSecure");
     method(AndroidStorageAdapterJava::javaClassStatic());
 }
 
-void AndroidStorageAdapterCpp::clearSecure() {
-    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearSecure");
+// --- Config (no-ops on Android; access control / groups are iOS-specific) ---
+
+void AndroidStorageAdapterCpp::setSecureAccessControl(int /*level*/) {}
+void AndroidStorageAdapterCpp::setSecureWritesAsync(bool enabled) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(jboolean)>("setSecureWritesAsync");
+    method(AndroidStorageAdapterJava::javaClassStatic(), enabled);
+}
+void AndroidStorageAdapterCpp::setKeychainAccessGroup(const std::string& /*group*/) {}
+
+// --- Biometric ---
+
+void AndroidStorageAdapterCpp::setSecureBiometric(const std::string& key, const std::string& value) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string, std::string)>("setSecureBiometric");
+    method(AndroidStorageAdapterJava::javaClassStatic(), key, value);
+}
+
+std::optional<std::string> AndroidStorageAdapterCpp::getSecureBiometric(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jstring(std::string)>("getSecureBiometric");
+    auto result = method(AndroidStorageAdapterJava::javaClassStatic(), key);
+    if (!result) return std::nullopt;
+    return result->toStdString();
+}
+
+void AndroidStorageAdapterCpp::deleteSecureBiometric(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void(std::string)>("deleteSecureBiometric");
+    method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+bool AndroidStorageAdapterCpp::hasSecureBiometric(const std::string& key) {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<jboolean(std::string)>("hasSecureBiometric");
+    return method(AndroidStorageAdapterJava::javaClassStatic(), key);
+}
+
+void AndroidStorageAdapterCpp::clearSecureBiometric() {
+    static auto method = AndroidStorageAdapterJava::javaClassStatic()->getStaticMethod<void()>("clearSecureBiometric");
     method(AndroidStorageAdapterJava::javaClassStatic());
 }
 

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

@@ -28,6 +28,9 @@ 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;
+    bool hasDisk(const std::string& key) override;
+    std::vector<std::string> getAllKeysDisk() override;
+    size_t sizeDisk() 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;
@@ -35,12 +38,25 @@ public:
     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;
+    bool hasSecure(const std::string& key) override;
+    std::vector<std::string> getAllKeysSecure() override;
+    size_t sizeSecure() 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;
+
+    void setSecureAccessControl(int level) override;
+    void setSecureWritesAsync(bool enabled) override;
+    void setKeychainAccessGroup(const std::string& group) override;
+
+    void setSecureBiometric(const std::string& key, const std::string& value) override;
+    std::optional<std::string> getSecureBiometric(const std::string& key) override;
+    void deleteSecureBiometric(const std::string& key) override;
+    bool hasSecureBiometric(const std::string& key) override;
+    void clearSecureBiometric() override;
 };
 
 } // namespace NitroStorage

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

@@ -17,34 +17,49 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
         .build()
     
-    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences()
+    private val encryptedPreferences: SharedPreferences = initializeEncryptedPreferences("NitroStorageSecure", masterKey)
+
+    private val biometricMasterKeyAlias = "${context.packageName}.nitro_storage.biometric_key"
+
+    private val biometricPreferences: SharedPreferences by lazy {
+        try {
+            val bioKey = MasterKey.Builder(context, biometricMasterKeyAlias)
+                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
+                .setUserAuthenticationRequired(true, 30)
+                .build()
+            initializeEncryptedPreferences("NitroStorageBiometric", bioKey)
+        } catch (e: Exception) {
+            Log.w("NitroStorage", "Biometric storage unavailable, falling back to regular encrypted storage: ${e.message}")
+            encryptedPreferences
+        }
+    }
+
+    @Volatile
+    private var secureWritesAsync = false
     
-    private fun initializeEncryptedPreferences(): SharedPreferences {
+    private fun initializeEncryptedPreferences(name: String, key: MasterKey): SharedPreferences {
         return try {
             EncryptedSharedPreferences.create(
                 context,
-                "NitroStorageSecure",
-                masterKey,
+                name,
+                key,
                 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
+                Log.w("NitroStorage", "Detected corrupted encryption keys for $name, clearing...")
+                clearCorruptedStorage(name, key)
                 EncryptedSharedPreferences.create(
                     context,
-                    "NitroStorageSecure",
-                    masterKey,
+                    name,
+                    key,
                     EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
                     EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
                 )
             } else {
                 throw RuntimeException(
-                    "NitroStorage: Failed to initialize secure storage. " +
+                    "NitroStorage: Failed to initialize $name. " +
                     "This may be due to corrupted encryption keys. " +
                     "Try clearing app data or reinstalling the app.", e
                 )
@@ -52,19 +67,38 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         }
     }
     
-    private fun clearCorruptedSecureStorage() {
+    private fun clearCorruptedStorage(name: String, key: MasterKey) {
         try {
-            // Delete the encrypted shared preferences file
-            context.deleteSharedPreferences("NitroStorageSecure")
-            
-            // Delete the master key from Android Keystore
+            context.deleteSharedPreferences(name)
             val keyStore = KeyStore.getInstance("AndroidKeyStore")
             keyStore.load(null)
-            keyStore.deleteEntry(masterKeyAlias)
-            
-            Log.i("NitroStorage", "Successfully cleared corrupted secure storage")
+            val alias = if (key === masterKey) masterKeyAlias else biometricMasterKeyAlias
+            keyStore.deleteEntry(alias)
+            Log.i("NitroStorage", "Cleared corrupted storage: $name")
         } catch (e: Exception) {
-            Log.e("NitroStorage", "Failed to clear corrupted secure storage", e)
+            Log.e("NitroStorage", "Failed to clear corrupted storage: $name", e)
+        }
+    }
+
+    private fun getSecureSafe(prefs: SharedPreferences, key: String): String? {
+        return try {
+            prefs.getString(key, null)
+        } catch (e: Exception) {
+            if (e is AEADBadTagException || e.cause is AEADBadTagException) {
+                Log.w("NitroStorage", "Corrupt entry for key '$key', removing")
+                prefs.edit().remove(key).commit()
+                null
+            } else {
+                throw e
+            }
+        }
+    }
+
+    private fun applySecureEditor(editor: SharedPreferences.Editor) {
+        if (secureWritesAsync) {
+            editor.apply()
+        } else {
+            editor.commit()
         }
     }
     
@@ -94,6 +128,13 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun getContext(): Context {
             return getInstanceOrThrow().context
         }
+
+        @JvmStatic
+        fun setSecureWritesAsync(enabled: Boolean) {
+            getInstanceOrThrow().secureWritesAsync = enabled
+        }
+
+        // --- Disk ---
         
         @JvmStatic
         fun setDisk(key: String, value: String) {
@@ -136,57 +177,136 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             }
             editor.apply()
         }
+
+        @JvmStatic
+        fun hasDisk(key: String): Boolean {
+            return getInstanceOrThrow().sharedPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun getAllKeysDisk(): Array<String> {
+            return getInstanceOrThrow().sharedPreferences.all.keys.toTypedArray()
+        }
+
+        @JvmStatic
+        fun sizeDisk(): Int {
+            return getInstanceOrThrow().sharedPreferences.all.size
+        }
+
+        @JvmStatic
+        fun clearDisk() {
+            getInstanceOrThrow().sharedPreferences.edit().clear().apply()
+        }
+
+        // --- Secure (sync commit by default, async apply when enabled) ---
         
         @JvmStatic
         fun setSecure(key: String, value: String) {
-            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).apply()
+            val inst = getInstanceOrThrow()
+            val editor = inst.encryptedPreferences.edit().putString(key, value)
+            inst.applySecureEditor(editor)
         }
 
         @JvmStatic
         fun setSecureBatch(keys: Array<String>, values: Array<String>) {
-            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            val inst = getInstanceOrThrow()
+            val editor = inst.encryptedPreferences.edit()
             val count = minOf(keys.size, values.size)
             for (index in 0 until count) {
                 editor.putString(keys[index], values[index])
             }
-            editor.apply()
+            inst.applySecureEditor(editor)
         }
         
         @JvmStatic
         fun getSecure(key: String): String? {
-            return getInstanceOrThrow().encryptedPreferences.getString(key, null)
+            return getInstanceOrThrow().getSecureSafe(getInstanceOrThrow().encryptedPreferences, key)
         }
 
         @JvmStatic
         fun getSecureBatch(keys: Array<String>): Array<String?> {
-            val prefs = getInstanceOrThrow().encryptedPreferences
+            val inst = getInstanceOrThrow()
             return Array(keys.size) { index ->
-                prefs.getString(keys[index], null)
+                inst.getSecureSafe(inst.encryptedPreferences, keys[index])
             }
         }
         
         @JvmStatic
         fun deleteSecure(key: String) {
-            getInstanceOrThrow().encryptedPreferences.edit().remove(key).apply()
+            val inst = getInstanceOrThrow()
+            inst.applySecureEditor(inst.encryptedPreferences.edit().remove(key))
+            inst.applySecureEditor(inst.biometricPreferences.edit().remove(key))
         }
 
         @JvmStatic
         fun deleteSecureBatch(keys: Array<String>) {
-            val editor = getInstanceOrThrow().encryptedPreferences.edit()
+            val inst = getInstanceOrThrow()
+            val secureEditor = inst.encryptedPreferences.edit()
+            val biometricEditor = inst.biometricPreferences.edit()
             for (key in keys) {
-                editor.remove(key)
+                secureEditor.remove(key)
+                biometricEditor.remove(key)
             }
-            editor.apply()
+            inst.applySecureEditor(secureEditor)
+            inst.applySecureEditor(biometricEditor)
         }
 
         @JvmStatic
-        fun clearDisk() {
-            getInstanceOrThrow().sharedPreferences.edit().clear().apply()
+        fun hasSecure(key: String): Boolean {
+            val inst = getInstanceOrThrow()
+            return inst.encryptedPreferences.contains(key) || inst.biometricPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun getAllKeysSecure(): Array<String> {
+            val inst = getInstanceOrThrow()
+            val keys = linkedSetOf<String>()
+            keys.addAll(inst.encryptedPreferences.all.keys)
+            keys.addAll(inst.biometricPreferences.all.keys)
+            return keys.toTypedArray()
+        }
+
+        @JvmStatic
+        fun sizeSecure(): Int {
+            return getAllKeysSecure().size
         }
 
         @JvmStatic
         fun clearSecure() {
-            getInstanceOrThrow().encryptedPreferences.edit().clear().apply()
+            val inst = getInstanceOrThrow()
+            inst.applySecureEditor(inst.encryptedPreferences.edit().clear())
+            inst.applySecureEditor(inst.biometricPreferences.edit().clear())
+        }
+
+        // --- Biometric (separate encrypted store, requires recent biometric auth on Android) ---
+
+        @JvmStatic
+        fun setSecureBiometric(key: String, value: String) {
+            val inst = getInstanceOrThrow()
+            val editor = inst.biometricPreferences.edit().putString(key, value)
+            inst.applySecureEditor(editor)
+        }
+
+        @JvmStatic
+        fun getSecureBiometric(key: String): String? {
+            return getInstanceOrThrow().getSecureSafe(getInstanceOrThrow().biometricPreferences, key)
+        }
+
+        @JvmStatic
+        fun deleteSecureBiometric(key: String) {
+            val inst = getInstanceOrThrow()
+            inst.applySecureEditor(inst.biometricPreferences.edit().remove(key))
+        }
+
+        @JvmStatic
+        fun hasSecureBiometric(key: String): Boolean {
+            return getInstanceOrThrow().biometricPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun clearSecureBiometric() {
+            val inst = getInstanceOrThrow()
+            inst.applySecureEditor(inst.biometricPreferences.edit().clear())
         }
     }
 }

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

@@ -1,13 +1,13 @@
 package com.nitrostorage
 
-import com.facebook.react.TurboReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import java.util.HashMap
 
-class NitroStoragePackage : TurboReactPackage() {
+class NitroStoragePackage : BaseReactPackage() {
   override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
     return null
   }