Gracefully handle when the LSKF is removed. (#566)

Introduce KeyInvalidatedException for SecureArea and mention that any
implementation may throw this expection and it means that the key is
now unusable. Also add getKeyInvalidate() method as a way to check
directly without having to use a key.

For AndroidKeystoreSecureArea, introduce ScreenLockRequiredException
and throw this if trying to create an authbound key when no screenlock
is set up.

On Document, introduce deleteInvalidatedCredentials() which uses this
facility to delete all pending and certified keys that are
invalidated. Also add hasUsableCredential() as a convenience function.

Use hot flows instead of the home-grown observer pattern on
DocumentStore, IssuingAuthority, and IssuingAuthorityRepository.

Rename CardViewModel to DocumentModel and move instantiation so it's
created by WalletApplication instead of MainActivity. This is
important because this model is used by more than just the UI. Also
rename objects exposed by DocumentModel and the composables rendering
these.

Move all credential housekeeping into DocumentModel and add support
for batch processing of the very chatty DOCUMENT_UPDATED events. This
saves a lot of processing.

Add SettingsModel.screenLockIsSetup and use this to show a snackbar
telling the user that this is the case and some things might not
work. Catch exceptions and show errors in the UI if the user is trying
to refresh a credential (w/ special-case for ScreenLockRequiredException).

In DocumentModel, add an observer for screenLockIsSetup and call
deleteInvalidatedCredentials() on all documents and make sure we
convey this to the user through the status field with "Credentials
expired or missing".

Add a worker for daily pings to the issuer (for pulling PII updates,
refreshing MSOs, etc).

Test: Manually tested
Test: All unit tests pass.

Signed-off-by: David Zeuthen <zeuthen@google.com>

Author: davidz25

gradle/libs.versions.toml

@@ -66,6 +66,7 @@
     androidx-navigation-ktx = { module = "androidx.navigation:navigation-fragment-ktx", version.ref = "navigation" }
     androidx-navigation-ui-ktx = { module = "androidx.navigation:navigation-ui-ktx", version.ref = "navigation" }
 
+    kotlinx-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref="kotlinx-coroutines" }
     kotlinx-coroutines-android = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-android", version.ref="kotlinx-coroutines" }
     kotlinx-coroutines-guava = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-guava", version.ref="kotlinx-coroutines" }
 

identity-android/src/main/java/com/android/identity/android/securearea/AndroidKeystoreSecureArea.kt

@@ -33,6 +33,7 @@ import com.android.identity.crypto.CertificateChain
 import com.android.identity.crypto.EcCurve
 import com.android.identity.crypto.EcPublicKey
 import com.android.identity.crypto.javaPublicKey
+import com.android.identity.securearea.KeyInvalidatedException
 import com.android.identity.securearea.KeyLockedException
 import com.android.identity.securearea.KeyPurpose
 import com.android.identity.securearea.SecureArea
@@ -197,6 +198,12 @@ class AndroidKeystoreSecureArea(
                 else -> throw IllegalArgumentException("Curve is not supported")
             }
             if (aSettings.userAuthenticationRequired) {
+                val keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+                if (!keyguardManager.isDeviceSecure) {
+                    throw ScreenLockRequiredException(
+                        "Screen lock must be set up to create keys with user authentication"
+                    )
+                }
                 builder.setUserAuthenticationRequired(true)
                 val timeoutMillis = aSettings.userAuthenticationTimeoutMillis
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
@@ -246,7 +253,7 @@ class AndroidKeystoreSecureArea(
             try {
                 kpg.initialize(builder.build())
             } catch (e: InvalidAlgorithmParameterException) {
-                throw IllegalStateException(e.message, e)
+                throw IllegalStateException(e)
             }
             kpg.generateKeyPair()
         } catch (e: NoSuchAlgorithmException) {
@@ -282,11 +289,13 @@ class AndroidKeystoreSecureArea(
      * @param existingAlias the alias of the existing key.
      */
     fun createKeyForExistingAlias(existingAlias: String) {
+
+        val ks = KeyStore.getInstance("AndroidKeyStore")
+        ks.load(null)
+        val entry = ks.getEntry(existingAlias, null)
+            ?: throw IllegalArgumentException("A key with this alias doesn't exist")
+
         var keyInfo: android.security.keystore.KeyInfo = try {
-            val ks = KeyStore.getInstance("AndroidKeyStore")
-            ks.load(null)
-            val entry = ks.getEntry(existingAlias, null)
-                ?: throw IllegalArgumentException("No entry for alias")
             val privateKey = (entry as KeyStore.PrivateKeyEntry).privateKey
             val factory = KeyFactory.getInstance(privateKey.algorithm, "AndroidKeyStore")
             try {
@@ -415,11 +424,10 @@ class AndroidKeystoreSecureArea(
                 }
             }
         }
+
+        val (entry, _) = loadKey(alias)
+
         return try {
-            val ks = KeyStore.getInstance("AndroidKeyStore")
-            ks.load(null)
-            val entry = ks.getEntry(alias, null)
-                ?: throw IllegalArgumentException("No entry for alias")
             val privateKey = (entry as KeyStore.PrivateKeyEntry).privateKey
             val s = Signature.getInstance(getSignatureAlgorithmName(signatureAlgorithm))
             s.initSign(privateKey)
@@ -447,11 +455,8 @@ class AndroidKeystoreSecureArea(
         otherKey: EcPublicKey,
         keyUnlockData: com.android.identity.securearea.KeyUnlockData?
     ): ByteArray {
+        val (entry, _) = loadKey(alias)
         return try {
-            val ks = KeyStore.getInstance("AndroidKeyStore")
-            ks.load(null)
-            val entry = ks.getEntry(alias, null)
-                ?: throw IllegalArgumentException("No entry for alias")
             val privateKey = (entry as KeyStore.PrivateKeyEntry).privateKey
             val ka = KeyAgreement.getInstance("ECDH", "AndroidKeyStore")
             ka.init(privateKey)
@@ -474,19 +479,37 @@ class AndroidKeystoreSecureArea(
         }
     }
 
+    // @throws IllegalArgumentException if the key doesn't exist.
+    // @throws KeyInvalidatedException if LSKF was removed and the key is no longer available.
+    private fun loadKey(alias: String): Pair<KeyStore.Entry, ByteArray> {
+        val data = storageEngine[PREFIX + alias] ?: throw IllegalArgumentException("No key with given alias")
+
+        val ks = KeyStore.getInstance("AndroidKeyStore")
+        ks.load(null)
+        // If the LSKF is removed, all auth-bound keys are removed and the result is
+        // that KeyStore.getEntry() returns null.
+        val entry = ks.getEntry(alias, null)
+            ?: throw KeyInvalidatedException("This key is no longer available")
+
+        return Pair(entry, data)
+    }
+
+    override fun getKeyInvalidated(alias: String): Boolean {
+        try {
+            loadKey(alias)
+        } catch (e: KeyInvalidatedException) {
+            return true
+        }
+        return false
+    }
+
     override fun getKeyInfo(alias: String): AndroidKeystoreKeyInfo {
+        val (entry, data) = loadKey(alias)
         return try {
-            val ks = KeyStore.getInstance("AndroidKeyStore")
-            ks.load(null)
-            val entry = ks.getEntry(alias, null)
-                ?: throw IllegalArgumentException("No entry for alias")
             val privateKey = (entry as KeyStore.PrivateKeyEntry).privateKey
             val factory = KeyFactory.getInstance(privateKey.algorithm, "AndroidKeyStore")
             val keyInfo =
                 factory.getKeySpec(privateKey, android.security.keystore.KeyInfo::class.java)
-
-            val data = storageEngine[PREFIX + alias]
-                ?: throw IllegalArgumentException("No key with given alias")
             val map = Cbor.decode(data)
             val keyPurposes = map["keyPurposes"].asNumber.keyPurposeSet
             val userAuthenticationRequired = map["userAuthenticationRequired"].asBoolean
@@ -572,16 +595,16 @@ class AndroidKeystoreSecureArea(
      * @param context the application context.
      */
     class Capabilities(context: Context) {
-        private val mKeyguardManager: KeyguardManager
-        private val mApiLevel: Int
-        private val mTeeFeatureLevel: Int
-        private val mSbFeatureLevel: Int
+        private val keyguardManager: KeyguardManager
+        private val apiLevel: Int
+        private val teeFeatureLevel: Int
+        private val sbFeatureLevel: Int
 
         init {
-            mKeyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
-            mTeeFeatureLevel = getFeatureVersionKeystore(context, false)
-            mSbFeatureLevel = getFeatureVersionKeystore(context, true)
-            mApiLevel = Build.VERSION.SDK_INT
+            keyguardManager = context.getSystemService(Context.KEYGUARD_SERVICE) as KeyguardManager
+            teeFeatureLevel = getFeatureVersionKeystore(context, false)
+            sbFeatureLevel = getFeatureVersionKeystore(context, true)
+            apiLevel = Build.VERSION.SDK_INT
         }
 
         val secureLockScreenSetup: Boolean
@@ -591,7 +614,7 @@ class AndroidKeystoreSecureArea(
              * This checks whether the device currently has a secure lock
              * screen (either PIN, pattern, or password).
              */
-            get() = mKeyguardManager.isDeviceSecure
+            get() = keyguardManager.isDeviceSecure
 
         /**
          * Whether it's possible to specify multiple authentication types.
@@ -602,63 +625,63 @@ class AndroidKeystoreSecureArea(
          * Biometric only, or both).
          */
         val multipleAuthenticationTypesSupported: Boolean
-            get() = mApiLevel >= Build.VERSION_CODES.R
+            get() = apiLevel >= Build.VERSION_CODES.R
 
         /**
          * Whether Attest Keys are supported.
          *
          * This is only supported in KeyMint 1.0 (version 100) and higher.
          */
         val attestKeySupported: Boolean
-            get() = mTeeFeatureLevel >= 100
+            get() = teeFeatureLevel >= 100
 
         /**
          * Whether Key Agreement is supported.
          *
          * This is only supported in KeyMint 1.0 (version 100) and higher.
          */
         val keyAgreementSupported: Boolean
-            get() = mTeeFeatureLevel >= 100
+            get() = teeFeatureLevel >= 100
 
         /**
          * Whether Curve25519 is supported.
          *
          * This is only supported in KeyMint 2.0 (version 200) and higher.
          */
         val curve25519Supported: Boolean
-            get() = mTeeFeatureLevel >= 200
+            get() = teeFeatureLevel >= 200
 
         /**
          * Whether StrongBox is supported.
          *
          * StrongBox requires dedicated hardware and is not available on all devices.
          */
         val strongBoxSupported: Boolean
-            get() = mSbFeatureLevel > 0
+            get() = sbFeatureLevel > 0
 
         /**
          * Whether StrongBox Attest Keys are supported.
          *
          * This is only supported in StrongBox KeyMint 1.0 (version 100) and higher.
          */
         val strongBoxAttestKeySupported: Boolean
-            get() = mSbFeatureLevel >= 100
+            get() = sbFeatureLevel >= 100
 
         /**
          * Whether StrongBox Key Agreement is supported.
          *
          * This is only supported in StrongBox KeyMint 1.0 (version 100) and higher.
          */
         val strongBoxKeyAgreementSupported: Boolean
-            get() = mSbFeatureLevel >= 100
+            get() = sbFeatureLevel >= 100
 
         /**
          * Whether StrongBox Curve25519 is supported.
          *
          * This is only supported in StrongBox KeyMint 2.0 (version 200) and higher.
          */
         val strongBoxCurve25519Supported: Boolean
-            get() = mSbFeatureLevel >= 200
+            get() = sbFeatureLevel >= 200
     }
 
     companion object {

identity-android/src/main/java/com/android/identity/android/securearea/ScreenLockRequiredException.kt

@@ -0,0 +1,36 @@
+package com.android.identity.android.securearea
+
+/**
+ * Exception thrown when trying to create a key with user authentication but
+ * no screen lock has been set up.
+ */
+class ScreenLockRequiredException : Exception {
+    /**
+     * Construct a new exception.
+     */
+    constructor()
+
+    /**
+     * Construct a new exception.
+     *
+     */
+    constructor(message: String) : super(message)
+
+    /**
+     * Construct a new exception.
+     *
+     * @param message the message.
+     * @param cause the cause.
+     */
+    constructor(
+        message: String,
+        cause: Exception
+    ) : super(message, cause)
+
+    /**
+     * Construct a new exception.
+     *
+     * @param cause the cause.
+     */
+    constructor(cause: Exception) : super(cause)
+}

identity/build.gradle

@@ -19,9 +19,11 @@ dependencies {
     implementation libs.bouncy.castle.bcpkix
     implementation libs.kotlinx.io.bytestring
     implementation libs.kotlinx.datetime
+    implementation libs.kotlinx.coroutines.core
 
     testImplementation libs.bundles.unit.testing
     testImplementation libs.bouncy.castle.bcprov
+    testImplementation libs.kotlinx.coroutine.test
 }
 
 apply from: '../publish-helper.gradle'

identity/src/main/java/com/android/identity/document/Document.kt

@@ -25,6 +25,8 @@ import com.android.identity.util.ApplicationData
 import com.android.identity.util.Logger
 import com.android.identity.util.SimpleApplicationData
 import com.android.identity.util.Timestamp
+import kotlinx.datetime.Clock
+import kotlinx.datetime.Instant
 
 /**
  * This class represents a document created in [DocumentStore].
@@ -262,6 +264,44 @@ class Document private constructor(
         return credential
     }
 
+    /**
+     * Goes through all credentials and deletes the ones with keys that are invalidated.
+     */
+    fun deleteInvalidatedCredentials() {
+        for (pendingCredential in pendingCredentials) {
+            if (pendingCredential.secureArea.getKeyInvalidated(pendingCredential.alias)) {
+                Logger.i(TAG, "Deleting invalidated pending credential  ${pendingCredential.alias}")
+                pendingCredential.delete()
+            }
+        }
+        for (credential in certifiedCredentials) {
+            if (credential.secureArea.getKeyInvalidated(credential.alias)) {
+                Logger.i(TAG, "Deleting invalidated credential ${credential.alias}")
+                credential.delete()
+            }
+        }
+    }
+
+    /**
+     * Returns whether an usable credential exists at a given point in time.
+     *
+     * @param at the point in time to check for.
+     * @returns `true` if an usable credential exists for the given time, `false` otherwise
+     */
+    fun hasUsableCredential(at: Instant = Clock.System.now()): Boolean {
+        val credentials = certifiedCredentials
+        if (credentials.isEmpty()) {
+            return false
+        }
+        for (credential in credentials) {
+            val validFrom = Instant.fromEpochMilliseconds(credential.validFrom.toEpochMilli())
+            val validUntil = Instant.fromEpochMilliseconds(credential.validUntil.toEpochMilli())
+            if (at >= validFrom && at < validUntil) {
+                return true
+            }
+        }
+        return false
+    }
 
     internal fun removeCredential(credential: Credential) {
         val listToModify = if (credential.isCertified) _certifiedCredentials