IssueTracker

• Component used: androidx.security.crypto
• Version used: 1.1.0-alpha03
• Devices/Android versions reproduced on: Samsung Galaxy A6, Android 10

Hello, we got this from Crashlytics and we are not able to replicate this. The library has a problem to create master key, but reason is unknown. Any clue what this could cause?

Caused by android.security.KeyStoreException: Unknown error
       at android.security.KeyStore.getKeyStoreException(KeyStore.java:1575)
       at android.security.keystore.AndroidKeyStoreKeyGeneratorSpi.engineGenerateKey(AndroidKeyStoreKeyGeneratorSpi.java:386)
       at javax.crypto.KeyGenerator.generateKey(KeyGenerator.java:612)
       at androidx.security.crypto.MasterKeys.generateKey(MasterKeys.java:142)
       at androidx.security.crypto.MasterKeys.getOrCreate(MasterKeys.java:97)
       at androidx.security.crypto.MasterKey$Builder.buildOnM(MasterKey.java:357)
       at androidx.security.crypto.MasterKey$Builder.build(MasterKey.java:314)
       at redacted$Companion.createEncryptedSharedPreference(Redacted.kt:82)
       at redacted$Companion.recreateEncryptedSharedPreference(Redacted.kt:98)
       at redacted$Companion.access$recreateEncryptedSharedPreference(Redacted.kt:70)
       at redacted$sharedPreferences$2.invoke(Redacted.kt:43)    
       <redacted>
       at kotlin.coroutines.jvm.internal.BaseContinuationImpl.resumeWith(ContinuationImpl.kt:33)
       at kotlinx.coroutines.DispatchedTask.run(DispatchedTask.kt:106)
       at kotlinx.coroutines.internal.LimitedDispatcher.run(LimitedDispatcher.kt:42)
       at kotlinx.coroutines.scheduling.TaskImpl.run(Tasks.kt:95)
       at kotlinx.coroutines.scheduling.CoroutineScheduler.runSafely(CoroutineScheduler.java:570)
       at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.executeTask(CoroutineScheduler.kt:750)
       at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.runWorker(CoroutineScheduler.kt:677)
       at kotlinx.coroutines.scheduling.CoroutineScheduler$Worker.run(CoroutineScheduler.kt:664)

We do not do anything fancy, just create master key which is then used in EncryptedSharedPreferences. We only try to recovery from issue https://issuetracker.google.com/issues/164901843, which consist of removing shared preferences and master key before creating a new master key and EncryptedSharedPreferences.

    // values from constructor
    val context = applicationContext
    val masterKeyAlias = "_our_master_key_"
    val sharedPreferenceName = "our_storage"

    private val sharedPreferences by lazy {
        // fix for bug https://issuetracker.google.com/issues/164901843
        // recreate shared preference if is broken
        try {
            createEncryptedSharedPreference(context, masterKeyAlias, sharedPreferenceName)
        } catch (_: IOException) {
            recreateEncryptedSharedPreference(context, masterKeyAlias, sharedPreferenceName)
        } catch (_: GeneralSecurityException) {
            recreateEncryptedSharedPreference(context, masterKeyAlias, sharedPreferenceName)
        }
    }

    companion object {
        private fun createEncryptedSharedPreference(
            context: Context,
            masterKeyAlias: String,
            sharedPreferenceName: String
        ): SharedPreferences {
            val masterKey = MasterKey.Builder(context, masterKeyAlias)
                .setKeyScheme(MasterKey.KeyScheme.AES256_GCM)
                .setUserAuthenticationRequired(false)
                .build()

            return EncryptedSharedPreferences.create(
                context, sharedPreferenceName, masterKey,
                EncryptedSharedPreferences.PrefKeyEncryptionScheme.AES256_SIV,
                EncryptedSharedPreferences.PrefValueEncryptionScheme.AES256_GCM
            )
        }

        private fun recreateEncryptedSharedPreference(
            context: Context,
            masterKeyAlias: String,
            sharedPreferenceName: String
        ): SharedPreferences {
            deleteMasterKey(masterKeyAlias)
            deleteSharedPreferences(context, sharedPreferenceName)
            return createEncryptedSharedPreference(context, masterKeyAlias, sharedPreferenceName)
        }

        @SuppressLint("ApplySharedPref")
        private fun deleteSharedPreferences(context: Context, name: String): Boolean =
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
                context.deleteSharedPreferences(name)
            } else {
                context.getSharedPreferences(name, MODE_PRIVATE).edit().clear().commit()
                val dir = File(context.applicationInfo.dataDir, "shared_prefs")
                File(dir, "$name.xml").delete()
            }

        private fun deleteMasterKey(masterKeyAlias: String) {
            val keyStore = KeyStore.getInstance("AndroidKeyStore")
            keyStore.load(null)
            if (keyStore.containsAlias(masterKeyAlias)) {
                keyStore.deleteEntry(masterKeyAlias)
            }
        }
    }