react-native-nitro-storage 0.3.0 → 0.3.1

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,42 @@ 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::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,24 @@ 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 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,46 @@ 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
+        }
+    }
     
-    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 +64,30 @@ 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
+            }
         }
     }
     
@@ -94,6 +117,8 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
         fun getContext(): Context {
             return getInstanceOrThrow().context
         }
+
+        // --- Disk ---
         
         @JvmStatic
         fun setDisk(key: String, value: String) {
@@ -136,10 +161,32 @@ 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 (uses commit for reliability) ---
         
         @JvmStatic
         fun setSecure(key: String, value: String) {
-            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).apply()
+            getInstanceOrThrow().encryptedPreferences.edit().putString(key, value).commit()
         }
 
         @JvmStatic
@@ -149,44 +196,94 @@ class AndroidStorageAdapter private constructor(private val context: Context) {
             for (index in 0 until count) {
                 editor.putString(keys[index], values[index])
             }
-            editor.apply()
+            editor.commit()
         }
         
         @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.encryptedPreferences.edit().remove(key).commit()
+            inst.biometricPreferences.edit().remove(key).commit()
         }
 
         @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()
+            secureEditor.commit()
+            biometricEditor.commit()
         }
 
         @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.encryptedPreferences.edit().clear().commit()
+            inst.biometricPreferences.edit().clear().commit()
+        }
+
+        // --- Biometric (separate encrypted store, requires recent biometric auth on Android) ---
+
+        @JvmStatic
+        fun setSecureBiometric(key: String, value: String) {
+            getInstanceOrThrow().biometricPreferences.edit().putString(key, value).commit()
+        }
+
+        @JvmStatic
+        fun getSecureBiometric(key: String): String? {
+            return getInstanceOrThrow().getSecureSafe(getInstanceOrThrow().biometricPreferences, key)
+        }
+
+        @JvmStatic
+        fun deleteSecureBiometric(key: String) {
+            getInstanceOrThrow().biometricPreferences.edit().remove(key).commit()
+        }
+
+        @JvmStatic
+        fun hasSecureBiometric(key: String): Boolean {
+            return getInstanceOrThrow().biometricPreferences.contains(key)
+        }
+
+        @JvmStatic
+        fun clearSecureBiometric() {
+            getInstanceOrThrow().biometricPreferences.edit().clear().commit()
         }
     }
 }

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
   }

package/cpp/bindings/HybridStorage.cpp

@@ -143,6 +143,65 @@ void HybridStorage::remove(const std::string& key, double scope) {
     notifyListeners(static_cast<int>(s), key, std::nullopt);
 }
 
+bool HybridStorage::has(const std::string& key, double scope) {
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            return memoryStore_.find(key) != memoryStore_.end();
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            return nativeAdapter_->hasDisk(key);
+        case Scope::Secure:
+            ensureAdapter();
+            return nativeAdapter_->hasSecure(key);
+    }
+    return false;
+}
+
+std::vector<std::string> HybridStorage::getAllKeys(double scope) {
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            std::vector<std::string> keys;
+            keys.reserve(memoryStore_.size());
+            for (const auto& pair : memoryStore_) {
+                keys.push_back(pair.first);
+            }
+            return keys;
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            return nativeAdapter_->getAllKeysDisk();
+        case Scope::Secure:
+            ensureAdapter();
+            return nativeAdapter_->getAllKeysSecure();
+    }
+    return {};
+}
+
+double HybridStorage::size(double scope) {
+    Scope s = toScope(scope);
+
+    switch (s) {
+        case Scope::Memory: {
+            std::lock_guard<std::mutex> lock(memoryMutex_);
+            return static_cast<double>(memoryStore_.size());
+        }
+        case Scope::Disk:
+            ensureAdapter();
+            return static_cast<double>(nativeAdapter_->sizeDisk());
+        case Scope::Secure:
+            ensureAdapter();
+            return static_cast<double>(nativeAdapter_->sizeSecure());
+    }
+    return 0.0;
+}
+
 std::function<void()> HybridStorage::addOnChange(
     double scope,
     const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
@@ -244,7 +303,6 @@ void HybridStorage::setBatch(const std::vector<std::string>& keys, const std::ve
     }
 }
 
-
 std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>& keys, double scope) {
     std::vector<std::string> results;
     results.reserve(keys.size());
@@ -276,11 +334,7 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
             }
 
             for (const auto& value : values) {
-                if (value.has_value()) {
-                    results.push_back(*value);
-                } else {
-                    results.push_back(kBatchMissingSentinel);
-                }
+                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
             }
             return results;
         }
@@ -296,11 +350,7 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
             }
 
             for (const auto& value : values) {
-                if (value.has_value()) {
-                    results.push_back(*value);
-                } else {
-                    results.push_back(kBatchMissingSentinel);
-                }
+                results.push_back(value.has_value() ? *value : std::string(kBatchMissingSentinel));
             }
             return results;
         }
@@ -309,7 +359,6 @@ std::vector<std::string> HybridStorage::getBatch(const std::vector<std::string>&
     return results;
 }
 
-
 void HybridStorage::removeBatch(const std::vector<std::string>& keys, double scope) {
     Scope s = toScope(scope);
 
@@ -348,6 +397,66 @@ void HybridStorage::removeBatch(const std::vector<std::string>& keys, double sco
     }
 }
 
+// --- Configuration ---
+
+void HybridStorage::setSecureAccessControl(double level) {
+    ensureAdapter();
+    nativeAdapter_->setSecureAccessControl(static_cast<int>(level));
+}
+
+void HybridStorage::setKeychainAccessGroup(const std::string& group) {
+    ensureAdapter();
+    nativeAdapter_->setKeychainAccessGroup(group);
+}
+
+// --- Biometric ---
+
+void HybridStorage::setSecureBiometric(const std::string& key, const std::string& value) {
+    ensureAdapter();
+    try {
+        nativeAdapter_->setSecureBiometric(key, value);
+        notifyListeners(static_cast<int>(Scope::Secure), key, value);
+    } catch (const std::exception& e) {
+        throw std::runtime_error(std::string("NitroStorage: Biometric set failed: ") + e.what());
+    }
+}
+
+std::optional<std::string> HybridStorage::getSecureBiometric(const std::string& key) {
+    ensureAdapter();
+    try {
+        return nativeAdapter_->getSecureBiometric(key);
+    } catch (const std::exception& e) {
+        throw std::runtime_error(std::string("NitroStorage: Biometric get failed: ") + e.what());
+    }
+}
+
+void HybridStorage::deleteSecureBiometric(const std::string& key) {
+    ensureAdapter();
+    try {
+        nativeAdapter_->deleteSecureBiometric(key);
+        notifyListeners(static_cast<int>(Scope::Secure), key, std::nullopt);
+    } catch (const std::exception& e) {
+        throw std::runtime_error(std::string("NitroStorage: Biometric delete failed: ") + e.what());
+    }
+}
+
+bool HybridStorage::hasSecureBiometric(const std::string& key) {
+    ensureAdapter();
+    return nativeAdapter_->hasSecureBiometric(key);
+}
+
+void HybridStorage::clearSecureBiometric() {
+    ensureAdapter();
+    try {
+        nativeAdapter_->clearSecureBiometric();
+        notifyListeners(static_cast<int>(Scope::Secure), "", std::nullopt);
+    } catch (const std::exception& e) {
+        throw std::runtime_error(std::string("NitroStorage: Biometric clear failed: ") + e.what());
+    }
+}
+
+// --- Internal ---
+
 void HybridStorage::notifyListeners(
     int scope,
     const std::string& key,

package/cpp/bindings/HybridStorage.hpp

@@ -20,6 +20,9 @@ public:
     std::optional<std::string> get(const std::string& key, double scope) override;
     void remove(const std::string& key, double scope) override;
     void clear(double scope) override;
+    bool has(const std::string& key, double scope) override;
+    std::vector<std::string> getAllKeys(double scope) override;
+    double size(double scope) override;
     void setBatch(const std::vector<std::string>& keys, const std::vector<std::string>& values, double scope) override;
     std::vector<std::string> getBatch(const std::vector<std::string>& keys, double scope) override;
     void removeBatch(const std::vector<std::string>& keys, double scope) override;
@@ -27,6 +30,13 @@ public:
         double scope,
         const std::function<void(const std::string&, const std::optional<std::string>&)>& callback
     ) override;
+    void setSecureAccessControl(double level) 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;
 
 private:
     enum class Scope {