@algorandfoundation/react-native-passkey-autofill 1.0.0-canary.2 → 1.0.0-canary.21

package/android/src/main/java/co/algorand/passkeyautofill/credentials/CredentialRepository.kt

@@ -22,17 +22,18 @@ import org.json.JSONObject
 import android.util.Base64 as AndroidBase64
 import java.io.ByteArrayOutputStream
 import java.security.SecureRandom
+import co.algorand.passkeyautofill.auth.BiometricRequirement
 
 
 interface CredentialRepository {
     val keyStore: KeyStore
-    fun saveCredential(context: Context, credential: Credential)
+    fun saveCredential(context: Context, credential: Credential, biometricCipher: Cipher? = null)
     fun generateCredentialId(keyPair: KeyPair): ByteArray
-    fun getKeyPair(context: Context, credentialId: ByteArray): KeyPair?
-    fun createDeterministicKeyPair(context: Context, origin: String, userHandle: String): KeyPair
+    fun getKeyPair(context: Context, credentialId: ByteArray, biometricCipher: Cipher? = null): KeyPair?
+    fun createDeterministicKeyPair(context: Context, origin: String, userHandle: String, biometricCipher: Cipher? = null): KeyPair
     fun getOrigin(info: CallingAppInfo): String
     fun appInfoToOrigin(info: CallingAppInfo): String
-    fun getCredential(context: Context, credentialId: ByteArray): Credential?
+    fun getCredential(context: Context, credentialId: ByteArray, biometricCipher: Cipher? = null): Credential?
     fun getCredentialByOrigin(context: Context, origin: String): Credential?
     fun getAllCredentials(context: Context): List<Credential>
     fun getPublicKeyFromKeyPair(keyPair: KeyPair?): ByteArray
@@ -45,6 +46,18 @@ interface CredentialRepository {
     fun getCreatePasskeyAction(context: Context): String?
     fun getGetPasskeyAction(context: Context): String?
     fun clearCredentials(context: Context)
+    fun deleteCredential(context: Context, credentialId: String)
+    fun recordCredentialUsage(context: Context, credentialId: ByteArray)
+
+    fun getBiometricCipherForEncryption(context: Context, requirement: BiometricRequirement): Cipher
+    fun getBiometricCipherForDecryption(context: Context, iv: ByteArray, requirement: BiometricRequirement): Cipher
+
+    /**
+     * Returns the raw HD root secret (seed bytes) that is used to derive
+     * domain-specific signing keys. Required by the PRF extension to
+     * deterministically derive the per-credential `credRandom` secret.
+     */
+    fun getHdRootSecret(context: Context): ByteArray?
 
     companion object {
         const val TAG = "CredentialRepository"
@@ -53,9 +66,20 @@ interface CredentialRepository {
         const val GET_PASSKEY_ACTION_KEY = "get_passkey_action"
         const val CREATE_PASSKEY_ACTION_KEY = "create_passkey_action"
         const val MASTER_KEY_ALIAS = "co.algorand.passkeyautofill.masterkey"
+        const val BIOMETRIC_KEY_ALIAS = "co.algorand.passkeyautofill.biometric.v2"
         const val KEYCHAIN_STORAGE_NAME = "PasskeyAutofillKeychain"
         const val PASSKEY_AUTOFILL_MMKV_ID = "passkey_autofill"
         const val HD_ROOT_KEY_ID_KEY = "hd_root_key_id"
+        const val BIOMETRIC_KEY_LEVEL_KEY = "biometric_key_level"
+
+        /**
+         * JCE provider that exposes AndroidKeyStore-backed symmetric Cipher
+         * transformations (including AES/GCM). Pinning to this provider avoids
+         * BouncyCastle — which this module installs at position 1 — trying to
+         * extract raw bytes from a hardware-bound SecretKey and crashing with
+         * NullPointerException in `KeyParameter.<init>`.
+         */
+        const val ANDROID_KEYSTORE_CIPHER_PROVIDER = "AndroidKeyStoreBCWorkaround"
     }
 }
 
@@ -80,7 +104,8 @@ class Repository() : CredentialRepository {
         return MMKV.mmkvWithID(CredentialRepository.PASSKEY_AUTOFILL_MMKV_ID, MMKV.MULTI_PROCESS_MODE)
     }
 
-    override fun saveCredential(context: Context, credential: Credential) {
+    override fun saveCredential(context: Context, credential: Credential, biometricCipher: Cipher?) {
+        Log.d(CredentialRepository.TAG, "saveCredential started for ${credential.origin}, userHandle: ${credential.userHandle}")
         val mmkv = getPasskeysMMKV(context)
         
         // 1. Create KeyData matching @algorandfoundation/keystore
@@ -91,7 +116,20 @@ class Repository() : CredentialRepository {
         keyData.put("extractable", false)
         keyData.put("keyUsages", JSONArray(listOf("sign")))
         keyData.put("name", "Passkey: ${credential.origin}")
-        keyData.put("privateKey", JSONArray(AndroidBase64.decode(credential.privateKey, AndroidBase64.DEFAULT).map { it.toInt() and 0xFF }))
+        
+        val privateKeyBytes = AndroidBase64.decode(credential.privateKey, AndroidBase64.DEFAULT)
+        if (biometricCipher != null) {
+            Log.d(CredentialRepository.TAG, "Using biometricCipher for encryption")
+            val encryptedBytes = biometricCipher.doFinal(privateKeyBytes)
+            val encJson = JSONObject()
+            encJson.put("iv", AndroidBase64.encodeToString(biometricCipher.iv, AndroidBase64.NO_WRAP))
+            encJson.put("data", AndroidBase64.encodeToString(encryptedBytes, AndroidBase64.NO_WRAP))
+            keyData.put("privateKeyEnc", encJson)
+        } else {
+            Log.d(CredentialRepository.TAG, "No biometricCipher, saving privateKey in plain (base64 in JSON)")
+            keyData.put("privateKey", JSONArray(privateKeyBytes.map { it.toInt() and 0xFF }))
+        }
+
         keyData.put("publicKey", JSONArray(AndroidBase64.decode(credential.publicKey, AndroidBase64.DEFAULT).map { it.toInt() and 0xFF }))
         
         // Custom fields for our use
@@ -128,17 +166,24 @@ class Repository() : CredentialRepository {
             val payload = mmkv.decodeString(key) ?: continue
             try {
                 val json = decodeKeyData(payload, masterKey)
-                // Basic validation to ensure it's a credential
+                // Only treat entries as passkey credentials that match p256
+                val keyType = json.optString("type", "")
+                if (keyType != "hd-derived-p256" && keyType != "xhd-derived-p256") {
+                    continue
+                }
                 if (json.has("id") && (json.has("origin") || json.has("metadata"))) {
                     val metadata = json.optJSONObject("metadata")
+                    val encJson = json.optJSONObject("privateKeyEnc")
+
                     credentials.add(Credential(
                         credentialId = json.getString("id"),
                         origin = metadata?.optString("origin") ?: json.optString("origin", ""),
                         userHandle = metadata?.optString("userHandle") ?: json.optString("userHandle", ""),
                         userId = metadata?.optString("userId") ?: json.optString("userId", ""),
                         publicKey = AndroidBase64.encodeToString(jsonArrayToByteArray(json.getJSONArray("publicKey")), AndroidBase64.DEFAULT),
-                        privateKey = AndroidBase64.encodeToString(jsonArrayToByteArray(json.getJSONArray("privateKey")), AndroidBase64.DEFAULT),
-                        count = metadata?.optInt("count") ?: json.optInt("count", 0)
+                        privateKey = if (json.has("privateKey")) AndroidBase64.encodeToString(jsonArrayToByteArray(json.getJSONArray("privateKey")), AndroidBase64.DEFAULT) else "",
+                        count = metadata?.optInt("count") ?: json.optInt("count", 0),
+                        biometricIv = encJson?.optString("iv")
                     ))
                 }
             } catch (e: Exception) {
@@ -163,22 +208,45 @@ class Repository() : CredentialRepository {
         return messageDigest.digest(publicKeyBytes)
     }
 
-    override fun getCredential(context: Context, credentialId: ByteArray): Credential? {
+    override fun getCredential(context: Context, credentialId: ByteArray, biometricCipher: Cipher?): Credential? {
         val id = AndroidBase64.encodeToString(credentialId, AndroidBase64.DEFAULT).trim()
+        Log.d(CredentialRepository.TAG, "getCredential started for id: $id")
         val mmkv = getPasskeysMMKV(context)
-        val payload = mmkv.decodeString(id) ?: return null
-        val masterKey = getMasterKey(context) ?: return null
+        val payload = mmkv.decodeString(id) ?: run {
+            Log.w(CredentialRepository.TAG, "No payload found for id: $id")
+            return null
+        }
+        val masterKey = getMasterKey(context) ?: run {
+            Log.e(CredentialRepository.TAG, "Master key not found")
+            return null
+        }
         return try {
             val json = decodeKeyData(payload, masterKey)
             val metadata = json.optJSONObject("metadata")
+            val encJson = json.optJSONObject("privateKeyEnc")
+            
+            val privateKey = if (encJson != null && biometricCipher != null) {
+                Log.d(CredentialRepository.TAG, "Decrypting privateKey with biometricCipher")
+                val data = AndroidBase64.decode(encJson.getString("data"), AndroidBase64.DEFAULT)
+                val decrypted = biometricCipher.doFinal(data)
+                AndroidBase64.encodeToString(decrypted, AndroidBase64.DEFAULT)
+            } else if (json.has("privateKey")) {
+                Log.d(CredentialRepository.TAG, "Using plain privateKey from JSON")
+                AndroidBase64.encodeToString(jsonArrayToByteArray(json.getJSONArray("privateKey")), AndroidBase64.DEFAULT)
+            } else {
+                Log.w(CredentialRepository.TAG, "No privateKey found in JSON")
+                ""
+            }
+
             Credential(
                 credentialId = json.getString("id"),
                 origin = metadata?.optString("origin") ?: json.optString("origin", ""),
                 userHandle = metadata?.optString("userHandle") ?: json.optString("userHandle", ""),
                 userId = metadata?.optString("userId") ?: json.optString("userId", ""),
                 publicKey = AndroidBase64.encodeToString(jsonArrayToByteArray(json.getJSONArray("publicKey")), AndroidBase64.DEFAULT),
-                privateKey = AndroidBase64.encodeToString(jsonArrayToByteArray(json.getJSONArray("privateKey")), AndroidBase64.DEFAULT),
-                count = metadata?.optInt("count") ?: json.optInt("count", 0)
+                privateKey = privateKey,
+                count = metadata?.optInt("count") ?: json.optInt("count", 0),
+                biometricIv = encJson?.optString("iv")
             )
         } catch (e: Exception) {
             null
@@ -190,63 +258,129 @@ class Repository() : CredentialRepository {
     }
 
     fun getKeyPairFromCredential(credential: Credential): KeyPair? {
+        if (credential.privateKey.isEmpty()) return null
         val publicKeyBytes = AndroidBase64.decode(credential.publicKey, AndroidBase64.DEFAULT)
         val privateKeyBytes = AndroidBase64.decode(credential.privateKey, AndroidBase64.DEFAULT)
-        val factory = KeyFactory.getInstance("EC")
-        val publicKey = factory.generatePublic(X509EncodedKeySpec(publicKeyBytes))
-        val privateKey = factory.generatePrivate(PKCS8EncodedKeySpec(privateKeyBytes))
-        return KeyPair(publicKey, privateKey)
+
+        return try {
+            // First try DER-encoded format (X509/PKCS8)
+            val factory = KeyFactory.getInstance("EC")
+            val publicKey = factory.generatePublic(X509EncodedKeySpec(publicKeyBytes))
+            val privateKey = factory.generatePrivate(PKCS8EncodedKeySpec(privateKeyBytes))
+            KeyPair(publicKey, privateKey)
+        } catch (e: Exception) {
+            // Fall back to raw EC bytes
+            try {
+                // Get the P-256 curve parameters
+                val ecGenSpec = ECGenParameterSpec("secp256r1")
+                val keyPairGen = KeyPairGenerator.getInstance("EC")
+                keyPairGen.initialize(ecGenSpec)
+                val paramSpec = (keyPairGen.generateKeyPair().public as java.security.interfaces.ECPublicKey).params
+                val factory = KeyFactory.getInstance("EC")
+
+                val publicKeyFromX509 = try {
+                    factory.generatePublic(X509EncodedKeySpec(publicKeyBytes))
+                } catch (_: Exception) {
+                    null
+                }
+
+                if (publicKeyFromX509 != null && privateKeyBytes.size == 32) {
+                    val s = java.math.BigInteger(1, privateKeyBytes)
+                    val privSpec = ECPrivateKeySpec(s, paramSpec)
+                    val privateKey = factory.generatePrivate(privSpec)
+                    return KeyPair(publicKeyFromX509, privateKey)
+                }
+
+                // privateKey is 32-byte scalar
+                val rawXY: Pair<ByteArray, ByteArray>? = when {
+                    // 65-byte uncompressed point: 04 || x(32) || y(32)
+                    publicKeyBytes.size == 65 && publicKeyBytes[0] == 0x04.toByte() ->
+                        Pair(publicKeyBytes.copyOfRange(1, 33), publicKeyBytes.copyOfRange(33, 65))
+                    // 64-byte raw x || y (no prefix)
+                    publicKeyBytes.size == 64 ->
+                        Pair(publicKeyBytes.copyOfRange(0, 32), publicKeyBytes.copyOfRange(32, 64))
+                    else -> null
+                }
+
+                if (rawXY != null) {
+                    val x = java.math.BigInteger(1, rawXY.first)
+                    val y = java.math.BigInteger(1, rawXY.second)
+                    val pubSpec = ECPublicKeySpec(ECPoint(x, y), paramSpec)
+                    val publicKey = factory.generatePublic(pubSpec)
+
+                    val s = java.math.BigInteger(1, privateKeyBytes)
+                    val privSpec = ECPrivateKeySpec(s, paramSpec)
+                    val privateKey = factory.generatePrivate(privSpec)
+
+                    KeyPair(publicKey, privateKey)
+                } else {
+                    Log.e(CredentialRepository.TAG, "Unrecognized key format: publicKey size=${publicKeyBytes.size}", e)
+                    null
+                }
+            } catch (e2: Exception) {
+                Log.e(CredentialRepository.TAG, "Failed to restore key from raw bytes", e2)
+                null
+            }
+        }
     }
 
-    override fun getKeyPair(context: Context, credentialId: ByteArray): KeyPair? {
-        val credential = getCredential(context, credentialId)
+    override fun getKeyPair(context: Context, credentialId: ByteArray, biometricCipher: Cipher?): KeyPair? {
+        val credential = getCredential(context, credentialId, biometricCipher)
         return credential?.let { getKeyPairFromCredential(it) }
     }
 
     override fun createDeterministicKeyPair(
         context: Context,
         origin: String,
-        userHandle: String
+        userHandle: String,
+        biometricCipher: Cipher?
     ): KeyPair {
-        val masterKey = getMasterKey(context) ?: throw IllegalStateException("Master key not found in Keystore. Ensure you have called setMasterKey(key) from JavaScript.")
-        
+        Log.d(CredentialRepository.TAG, "createDeterministicKeyPair for origin: $origin, userHandle: $userHandle")
+        val derivedParentSecret = getHdRootSecret(context)
+            ?: throw IllegalStateException("HD Root Key not available. Ensure setMasterKey(key) and setHdRootKeyId(id) have been called.")
+        return dP256.genDomainSpecificKeypair(derivedParentSecret, origin, userHandle.lowercase())
+    }
+
+    override fun getHdRootSecret(context: Context): ByteArray? {
+        val masterKey = getMasterKey(context) ?: return null
         val mmkvAutofill = getAutofillMMKV(context)
-        val hdRootKeyId = mmkvAutofill.decodeString(CredentialRepository.HD_ROOT_KEY_ID_KEY) ?: throw IllegalStateException("HD Root Key ID not found. Ensure you have called setHdRootKeyId(id) from JavaScript.")
-        
+        val hdRootKeyId = mmkvAutofill.decodeString(CredentialRepository.HD_ROOT_KEY_ID_KEY) ?: return null
         val mmkvKeystore = getPasskeysMMKV(context)
-        val hdRootKeyPayload = mmkvKeystore.decodeString(hdRootKeyId) ?: throw IllegalStateException("HD Root Key not found in keystore for ID: $hdRootKeyId")
-        
-        val hdRootKeyData = decodeKeyData(hdRootKeyPayload, masterKey)
-        
+        val hdRootKeyPayload = mmkvKeystore.decodeString(hdRootKeyId) ?: return null
+        val hdRootKeyData = try {
+            decodeKeyData(hdRootKeyPayload, masterKey)
+        } catch (e: Exception) {
+            Log.w(CredentialRepository.TAG, "Failed to decode HD root key", e)
+            return null
+        }
+
         // In react-native-keystore, the private key/seed are stored as arrays of numbers in JSON
         // due to how JSON.stringify handles Uint8Array.
-        // Our decode method in decryptHdRootKey might have already handled it if it matched react-native-keystore's decode.
-        
         val seedArray = hdRootKeyData.optJSONArray("seed") ?: hdRootKeyData.optJSONArray("privateKey")
-        val derivedParentSecret = if (seedArray != null) {
+        if (seedArray != null) {
             val bytes = ByteArray(seedArray.length())
             for (i in 0 until seedArray.length()) {
                 bytes[i] = seedArray.getInt(i).toByte()
             }
-            bytes
+            return bytes
+        }
+
+        val seed = (if (hdRootKeyData.has("seed")) hdRootKeyData.getString("seed") else null)
+            ?: (if (hdRootKeyData.has("privateKey")) hdRootKeyData.getString("privateKey") else null)
+            ?: return null
+        return if (seed.startsWith("0x")) {
+            hexToBytes(seed.substring(2))
         } else {
-            val seed = (if (hdRootKeyData.has("seed")) hdRootKeyData.getString("seed") else null)
-                ?: (if (hdRootKeyData.has("privateKey")) hdRootKeyData.getString("privateKey") else null)
-                ?: throw IllegalStateException("HD Root Key does not contain a seed or privateKey")
-            
-            if (seed.startsWith("0x")) {
-                hexToBytes(seed.substring(2))
-            } else {
-                // It might be base64url encoded or just hex
+            try {
+                hexToBytes(seed)
+            } catch (e: Exception) {
                 try {
-                    hexToBytes(seed)
-                } catch (e: Exception) {
                     AndroidBase64.decode(seed, AndroidBase64.URL_SAFE or AndroidBase64.NO_WRAP)
+                } catch (e2: Exception) {
+                    null
                 }
             }
         }
-
-        return dP256.genDomainSpecificKeypair(derivedParentSecret, origin, userHandle.lowercase())
     }
 
     private fun encryptData(key: ByteArray, data: String): String {
@@ -441,6 +575,59 @@ class Repository() : CredentialRepository {
         }
     }
 
+    override fun deleteCredential(context: Context, credentialId: String) {
+        try {
+            val mmkvPasskeys = getPasskeysMMKV(context)
+            for (candidateId in credentialIdCandidates(credentialId)) {
+                mmkvPasskeys.removeValueForKey(candidateId)
+            }
+        } catch (e: Exception) {
+            Log.e(CredentialRepository.TAG, "Error deleting credential", e)
+        }
+    }
+
+    override fun recordCredentialUsage(context: Context, credentialId: ByteArray) {
+        val id = AndroidBase64.encodeToString(credentialId, AndroidBase64.DEFAULT).trim()
+        try {
+            val mmkv = getPasskeysMMKV(context)
+            val payload = mmkv.decodeString(id) ?: return
+            val masterKey = getMasterKey(context) ?: return
+
+            val json = decodeKeyData(payload, masterKey)
+            val metadata = json.optJSONObject("metadata") ?: JSONObject()
+            metadata.put("lastUsedAt", System.currentTimeMillis())
+            metadata.put("count", metadata.optInt("count", 0) + 1)
+            json.put("metadata", metadata)
+
+            val base64urlJson = AndroidBase64.encodeToString(
+                json.toString().toByteArray(Charsets.UTF_8),
+                AndroidBase64.URL_SAFE or AndroidBase64.NO_WRAP,
+            )
+            mmkv.encode(id, encryptData(masterKey, base64urlJson))
+        } catch (e: Exception) {
+            Log.e(CredentialRepository.TAG, "Failed to record credential usage", e)
+        }
+    }
+
+    private fun credentialIdCandidates(id: String): Set<String> {
+        val candidates = mutableSetOf(id)
+        val decoded = try {
+            AndroidBase64.decode(id, AndroidBase64.URL_SAFE or AndroidBase64.NO_WRAP)
+        } catch (_: Exception) {
+            try {
+                AndroidBase64.decode(id, AndroidBase64.DEFAULT)
+            } catch (_: Exception) {
+                null
+            }
+        }
+
+        if (decoded != null) {
+            candidates.add(AndroidBase64.encodeToString(decoded, AndroidBase64.DEFAULT).trim())
+            candidates.add(AndroidBase64.encodeToString(decoded, AndroidBase64.URL_SAFE or AndroidBase64.NO_WRAP or AndroidBase64.NO_PADDING))
+        }
+        return candidates
+    }
+
     private fun hexToBytes(hex: String): ByteArray {
         val result = ByteArray(hex.length / 2)
         for (i in 0 until hex.length step 2) {
@@ -456,6 +643,86 @@ class Repository() : CredentialRepository {
         return bytes.joinToString("") { "%02x".format(it) }
     }
 
+    private fun getBiometricSecretKey(context: Context, requirement: BiometricRequirement): SecretKey {
+        // The key's auth binding is fixed at creation. If a new build changed the configured
+        // level, regenerate the key so the prompt's allowed authenticators stay compatible.
+        // Passkey private keys are deterministically re-derivable, so this is recoverable.
+        val mmkv = getAutofillMMKV(context)
+        val storedLevel = mmkv.decodeString(CredentialRepository.BIOMETRIC_KEY_LEVEL_KEY)
+        if (keyStore.containsAlias(CredentialRepository.BIOMETRIC_KEY_ALIAS) &&
+            storedLevel != requirement.name
+        ) {
+            Log.i(CredentialRepository.TAG, "Biometric requirement changed ($storedLevel -> ${requirement.name}); regenerating key")
+            keyStore.deleteEntry(CredentialRepository.BIOMETRIC_KEY_ALIAS)
+        }
+
+        if (!keyStore.containsAlias(CredentialRepository.BIOMETRIC_KEY_ALIAS)) {
+            val keyGenerator = KeyGenerator.getInstance(KeyProperties.KEY_ALGORITHM_AES, "AndroidKeyStore")
+            val builder = KeyGenParameterSpec.Builder(
+                CredentialRepository.BIOMETRIC_KEY_ALIAS,
+                KeyProperties.PURPOSE_ENCRYPT or KeyProperties.PURPOSE_DECRYPT
+            )
+                .setBlockModes(KeyProperties.BLOCK_MODE_GCM)
+                .setEncryptionPaddings(KeyProperties.ENCRYPTION_PADDING_NONE)
+                .setKeySize(256)
+                .setUserAuthenticationRequired(requirement.isCryptoBound)
+
+            // Biometric-enrollment invalidation and auth params only apply to user-auth-bound keys.
+            if (requirement.isCryptoBound) {
+                builder.setInvalidatedByBiometricEnrollment(true)
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+                    builder.setUserAuthenticationParameters(60, requirement.keystoreAuthType)
+                } else {
+                    @Suppress("DEPRECATION")
+                    builder.setUserAuthenticationValidityDurationSeconds(60)
+                }
+            }
+
+            keyGenerator.init(builder.build())
+            keyGenerator.generateKey()
+            mmkv.encode(CredentialRepository.BIOMETRIC_KEY_LEVEL_KEY, requirement.name)
+        }
+        return keyStore.getKey(CredentialRepository.BIOMETRIC_KEY_ALIAS, null) as SecretKey
+    }
+
+    /**
+     * Build an AES/GCM Cipher tied to the AndroidKeyStore-backed biometric key.
+     *
+     * We request the provider explicitly because this module installs
+     * BouncyCastle at position 1 (see [co.algorand.passkeyautofill.ReactNativePasskeyAutofillModule]).
+     * Without a pinned provider, [Cipher.getInstance] resolves to BouncyCastle, which
+     * then tries to extract raw key material from an AndroidKeyStore SecretKey
+     * (whose `getEncoded()` is null for hardware-bound keys) and crashes with:
+     *
+     *   java.lang.NullPointerException: Attempt to get length of null array
+     *       at org.bouncycastle.crypto.params.KeyParameter.<init>(...)
+     *
+     * AndroidKeyStore AES keys are served by the "AndroidKeyStoreBCWorkaround"
+     * JCE provider on all supported Android versions.
+     */
+    private fun newAndroidKeyStoreAesGcmCipher(): Cipher {
+        return try {
+            Cipher.getInstance("AES/GCM/NoPadding", CredentialRepository.ANDROID_KEYSTORE_CIPHER_PROVIDER)
+        } catch (e: NoSuchProviderException) {
+            // Extremely unlikely on stock Android, but fall back to provider discovery
+            // by key rather than by name so we never hand the key to BouncyCastle.
+            Log.w(CredentialRepository.TAG, "${CredentialRepository.ANDROID_KEYSTORE_CIPHER_PROVIDER} unavailable, falling back to default provider resolution", e)
+            Cipher.getInstance("AES/GCM/NoPadding")
+        }
+    }
+
+    override fun getBiometricCipherForEncryption(context: Context, requirement: BiometricRequirement): Cipher {
+        val cipher = newAndroidKeyStoreAesGcmCipher()
+        cipher.init(Cipher.ENCRYPT_MODE, getBiometricSecretKey(context, requirement))
+        return cipher
+    }
+
+    override fun getBiometricCipherForDecryption(context: Context, iv: ByteArray, requirement: BiometricRequirement): Cipher {
+        val cipher = newAndroidKeyStoreAesGcmCipher()
+        cipher.init(Cipher.DECRYPT_MODE, getBiometricSecretKey(context, requirement), GCMParameterSpec(128, iv))
+        return cipher
+    }
+
     override fun sign(keyPair: KeyPair, payload: ByteArray): ByteArray {
         return dP256.signWithDomainSpecificKeyPair(keyPair, payload)
     }
@@ -487,13 +754,7 @@ class Repository() : CredentialRepository {
 
     @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
     override fun getOrigin(info: CallingAppInfo): String {
-        return try {
-            info.origin ?: appInfoToOrigin(info)
-        } catch (e: NoSuchMethodError) {
-            appInfoToOrigin(info)
-        } catch (e: Exception) {
-            appInfoToOrigin(info)
-        }
+        return appInfoToOrigin(info)
     }
 
     @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
@@ -503,4 +764,4 @@ class Repository() : CredentialRepository {
         val certHash = md.digest(cert)
         return "android:apk-key-hash:${AndroidBase64.encodeToString(certHash, AndroidBase64.URL_SAFE or AndroidBase64.NO_WRAP or AndroidBase64.NO_PADDING)}"
     }
-}
+}