From 213653e594650be6e4c954f6bca30d07cd565201 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:22:32 +0100
Subject: [PATCH 01/56] Fix USER_ID authorization security level to match AOSP
 keystore2

In real AOSP keystore2, USER_ID is added at SecurityLevel.SOFTWARE
(see store_new_key in security_level.rs), since the application UID
is a software concept not enforced by the TEE. The previous code
assigned all authorizations the same TEE/StrongBox security level,
making generated keys distinguishable from real ones.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt        | 14 +++++++++++++-
 1 file changed, 13 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index f86b1bda..e799555d 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -3,6 +3,7 @@ package org.matrix.TEESimulator.interception.keystore.shim
 import android.hardware.security.keymint.KeyOrigin
 import android.hardware.security.keymint.KeyParameter
 import android.hardware.security.keymint.KeyParameterValue
+import android.hardware.security.keymint.SecurityLevel
 import android.hardware.security.keymint.Tag
 import android.os.IBinder
 import android.os.Parcel
@@ -498,8 +499,19 @@ private fun KeyMintAttestation.toAuthorizations(
         createAuth(Tag.CREATION_DATETIME, KeyParameterValue.dateTime(System.currentTimeMillis()))
     )
 
+    // AOSP keystore2 adds USER_ID at SecurityLevel.SOFTWARE (not TEE), since the
+    // application UID is a software concept. See AOSP security_level.rs store_new_key().
     // AOSP class android.os.UserHandle: PER_USER_RANGE = 100000;
-    authList.add(createAuth(Tag.USER_ID, KeyParameterValue.integer(callingUid / 100000)))
+    authList.add(
+        Authorization().apply {
+            this.keyParameter =
+                KeyParameter().apply {
+                    this.tag = Tag.USER_ID
+                    this.value = KeyParameterValue.integer(callingUid / 100000)
+                }
+            this.securityLevel = SecurityLevel.SOFTWARE
+        }
+    )
 
     return authList.toTypedArray()
 }

From c263ab1a7791a3a70a493054a19621fb78302d82 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:23:52 +0100
Subject: [PATCH 02/56] Implement updateAad for software-backed crypto
 operations

The IKeystoreOperation AIDL interface defines updateAad() for providing
additional authenticated data in AEAD modes (e.g. AES-GCM). The previous
SoftwareOperationBinder inherited the default stub which throws
UnsupportedOperationException, causing crashes for GCM operations.

Add updateAad to the CryptoPrimitive interface with proper implementations:
cipher.updateAAD() for CipherPrimitive, no-op for Signer/Verifier.
---
 .../keystore/shim/SoftwareOperation.kt        | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index 79cd2c9a..f6beea8d 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -17,6 +17,8 @@ import org.matrix.TEESimulator.logging.SystemLogger
 
 // A sealed interface to represent the different cryptographic operations we can perform.
 private sealed interface CryptoPrimitive {
+    fun updateAad(data: ByteArray?)
+
     fun update(data: ByteArray?): ByteArray?
 
     fun finish(data: ByteArray?, signature: ByteArray?): ByteArray?
@@ -82,6 +84,8 @@ private class Signer(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPrimi
             initSign(keyPair.private)
         }
 
+    override fun updateAad(data: ByteArray?) {}
+
     override fun update(data: ByteArray?): ByteArray? {
         if (data != null) signature.update(data)
         return null
@@ -102,6 +106,8 @@ private class Verifier(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPri
             initVerify(keyPair.public)
         }
 
+    override fun updateAad(data: ByteArray?) {}
+
     override fun update(data: ByteArray?): ByteArray? {
         if (data != null) signature.update(data)
         return null
@@ -133,6 +139,10 @@ private class CipherPrimitive(
             init(opMode, key)
         }
 
+    override fun updateAad(data: ByteArray?) {
+        if (data != null) cipher.updateAAD(data)
+    }
+
     override fun update(data: ByteArray?): ByteArray? =
         if (data != null) cipher.update(data) else null
 
@@ -168,6 +178,15 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
             }
     }
 
+    fun updateAad(data: ByteArray?) {
+        try {
+            primitive.updateAad(data)
+        } catch (e: Exception) {
+            SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to updateAad.", e)
+            throw e
+        }
+    }
+
     fun update(data: ByteArray?): ByteArray? {
         try {
             return primitive.update(data)
@@ -199,6 +218,11 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
 class SoftwareOperationBinder(private val operation: SoftwareOperation) :
     IKeystoreOperation.Stub() {
 
+    @Throws(RemoteException::class)
+    override fun updateAad(aadInput: ByteArray?) {
+        operation.updateAad(aadInput)
+    }
+
     @Throws(RemoteException::class)
     override fun update(input: ByteArray?): ByteArray? {
         return operation.update(input)

From 45ebf9a664d68ba34387b17d48c009d8996412ab Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:26:42 +0100
Subject: [PATCH 03/56] Patch authorizations alongside certificate chains in
 PATCH mode

When operating in PATCH mode, the post-transaction hooks for both
generateKey and getKeyEntry were patching the certificate chain to
embed custom patch levels, but leaving the KeyMetadata.authorizations
array untouched. This created an inconsistency where the attestation
certificate reported one set of patch levels while the authorizations
(OS_PATCHLEVEL, VENDOR_PATCHLEVEL, BOOT_PATCHLEVEL) still contained
the real device values.

Add patchAuthorizations() utility to InterceptorUtils and apply it
in both the SecurityLevel post-generateKey hook and the KeystoreService
post-getKeyEntry hook.
---
 .../interception/keystore/InterceptorUtils.kt | 52 +++++++++++++++++++
 .../keystore/Keystore2Interceptor.kt          |  5 ++
 .../shim/KeyMintSecurityLevelInterceptor.kt   |  2 +
 3 files changed, 59 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
index b0a87a17..f4dc6f0f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
@@ -1,11 +1,16 @@
 package org.matrix.TEESimulator.interception.keystore
 
+import android.hardware.security.keymint.KeyParameter
+import android.hardware.security.keymint.KeyParameterValue
+import android.hardware.security.keymint.Tag
 import android.os.Parcel
 import android.os.Parcelable
 import android.security.KeyStore
 import android.security.keystore.KeystoreResponse
+import android.system.keystore2.Authorization
 import org.matrix.TEESimulator.interception.core.BinderInterceptor
 import org.matrix.TEESimulator.logging.SystemLogger
+import org.matrix.TEESimulator.util.AndroidDeviceUtils
 
 data class KeyIdentifier(val uid: Int, val alias: String)
 
@@ -112,4 +117,51 @@ object InterceptorUtils {
         if (exception != null) reply.setDataPosition(0)
         return exception != null
     }
+
+    /**
+     * Patches the system-level authorization values (OS_PATCHLEVEL, VENDOR_PATCHLEVEL,
+     * BOOT_PATCHLEVEL) in an authorization array to match the configured patch levels for the
+     * given calling UID. Each authorization's original [Authorization.securityLevel] is preserved.
+     *
+     * When a patch level is configured as "no" ([AndroidDeviceUtils.DO_NOT_REPORT]), the original
+     * hardware value is kept as-is.
+     */
+    fun patchAuthorizations(
+        authorizations: Array<Authorization>?,
+        callingUid: Int,
+    ): Array<Authorization>? {
+        if (authorizations == null) return null
+
+        val osPatch = AndroidDeviceUtils.getPatchLevel(callingUid)
+        val vendorPatch = AndroidDeviceUtils.getVendorPatchLevelLong(callingUid)
+        val bootPatch = AndroidDeviceUtils.getBootPatchLevelLong(callingUid)
+
+        return authorizations
+            .map { auth ->
+                val replacement =
+                    when (auth.keyParameter.tag) {
+                        Tag.OS_PATCHLEVEL ->
+                            if (osPatch != AndroidDeviceUtils.DO_NOT_REPORT) osPatch else null
+                        Tag.VENDOR_PATCHLEVEL ->
+                            if (vendorPatch != AndroidDeviceUtils.DO_NOT_REPORT) vendorPatch
+                            else null
+                        Tag.BOOT_PATCHLEVEL ->
+                            if (bootPatch != AndroidDeviceUtils.DO_NOT_REPORT) bootPatch else null
+                        else -> null
+                    }
+                if (replacement != null) {
+                    Authorization().apply {
+                        keyParameter =
+                            KeyParameter().apply {
+                                tag = auth.keyParameter.tag
+                                value = KeyParameterValue.integer(replacement)
+                            }
+                        securityLevel = auth.securityLevel
+                    }
+                } else {
+                    auth
+                }
+            }
+            .toTypedArray()
+    }
 }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index e6358fbe..3378fbe2 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -302,6 +302,11 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
 
                     CertificateHelper.updateCertificateChain(response.metadata, finalChain)
                         .getOrThrow()
+                    response.metadata.authorizations =
+                        InterceptorUtils.patchAuthorizations(
+                            response.metadata.authorizations,
+                            callingUid,
+                        )
 
                     return InterceptorUtils.createTypedObjectReply(response)
                 }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index e799555d..598de30a 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -163,6 +163,8 @@ class KeyMintSecurityLevelInterceptor(
                 val key = metadata.key!!
                 val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                 CertificateHelper.updateCertificateChain(metadata, newChain).getOrThrow()
+                metadata.authorizations =
+                    InterceptorUtils.patchAuthorizations(metadata.authorizations, callingUid)
 
                 // We must clean up cached generated keys before storing the patched chain
                 cleanupKeyData(keyId)

From e75689194735444904e4cf5ef03097bfe8f75d00 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:42:49 +0100
Subject: [PATCH 04/56] Derive certificate signature algorithm from signing
 key, not subject key

The signing algorithm for the leaf certificate must match the signing
key's type (from keybox or attestation key), not the subject key's
algorithm. An EC attestation key signing an RSA subject key's
certificate would previously select SHA256withRSA (wrong) instead of
SHA256withECDSA, producing an invalid or failing certificate.
---
 .../matrix/TEESimulator/pki/CertificateGenerator.kt | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
index 411c43be..fa6b7810 100644
--- a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
@@ -240,11 +240,16 @@ object CertificateGenerator {
             AttestationBuilder.buildAttestationExtension(params, uid, securityLevel)
         )
 
+        // The signature algorithm must match the SIGNING key, not the subject key.
+        // An EC attestation key may sign an RSA subject key's certificate (or vice versa).
         val signerAlgorithm =
-            when (params.algorithm) {
-                Algorithm.EC -> "SHA256withECDSA"
-                Algorithm.RSA -> "SHA256withRSA"
-                else -> throw IllegalArgumentException("Unsupported algorithm: ${params.algorithm}")
+            when (signingKeyPair.private) {
+                is java.security.interfaces.ECKey -> "SHA256withECDSA"
+                is java.security.interfaces.RSAKey -> "SHA256withRSA"
+                else ->
+                    throw IllegalArgumentException(
+                        "Unsupported signing key type: ${signingKeyPair.private.javaClass}"
+                    )
             }
         val contentSigner =
             JcaContentSignerBuilder(signerAlgorithm)

From 962cef6aa83f54561c642e284aff58d73e7fb87a Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:45:24 +0100
Subject: [PATCH 05/56] Add operation lifecycle tracking, concurrency guard,
 and input limits

Software operations now track finalization state and reject calls after
finish/abort with INVALID_OPERATION_HANDLE, matching AOSP operation.rs
outcome tracking. Errors during update/updateAad also finalize the
operation.

SoftwareOperationBinder wraps all methods in synchronized blocks to
prevent concurrent access, matching AOSP's Mutex-protected
KeystoreOperation wrapper that returns OPERATION_BUSY.

Input data is validated against MAX_RECEIVE_DATA (32KB) on update,
updateAad, and finish to match the AOSP-enforced limit.

CryptoPrimitive gains getBeginParameters() for exposing begin-phase
output (e.g. GCM nonce/IV) via CreateOperationResponse.parameters.
---
 .../keystore/shim/SoftwareOperation.kt        | 85 +++++++++++++++++--
 1 file changed, 76 insertions(+), 9 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index f6beea8d..0b3bb10a 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -3,10 +3,14 @@ package org.matrix.TEESimulator.interception.keystore.shim
 import android.hardware.security.keymint.Algorithm
 import android.hardware.security.keymint.BlockMode
 import android.hardware.security.keymint.Digest
+import android.hardware.security.keymint.KeyParameter
+import android.hardware.security.keymint.KeyParameterValue
 import android.hardware.security.keymint.KeyPurpose
 import android.hardware.security.keymint.PaddingMode
+import android.hardware.security.keymint.Tag
 import android.os.RemoteException
 import android.system.keystore2.IKeystoreOperation
+import android.system.keystore2.KeyParameters
 import java.security.KeyPair
 import java.security.Signature
 import java.security.SignatureException
@@ -24,6 +28,9 @@ private sealed interface CryptoPrimitive {
     fun finish(data: ByteArray?, signature: ByteArray?): ByteArray?
 
     fun abort()
+
+    /** Returns parameters from the begin phase (e.g. GCM nonce), or null if none. */
+    fun getBeginParameters(): Array<KeyParameter>? = null
 }
 
 // Helper object to map KeyMint constants to JCA algorithm strings.
@@ -150,19 +157,33 @@ private class CipherPrimitive(
         if (data != null) cipher.doFinal(data) else cipher.doFinal()
 
     override fun abort() {}
+
+    /** Returns the cipher IV as a NONCE parameter for GCM operations. */
+    override fun getBeginParameters(): Array<KeyParameter>? {
+        val iv = cipher.iv ?: return null
+        return arrayOf(
+            KeyParameter().apply {
+                tag = Tag.NONCE
+                value = KeyParameterValue.blob(iv)
+            }
+        )
+    }
 }
 
 /**
  * A software-only implementation of a cryptographic operation. This class acts as a controller,
  * delegating to a specific cryptographic primitive based on the operation's purpose.
+ *
+ * Tracks operation lifecycle: once [finish] or [abort] is called, subsequent calls will throw.
+ * This matches AOSP keystore2 behavior where finalized operations return
+ * INVALID_OPERATION_HANDLE.
  */
 class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMintAttestation) {
-    // This now holds the specific strategy object (Signer, Verifier, etc.)
     private val primitive: CryptoPrimitive
 
+    @Volatile private var finalized = false
+
     init {
-        // The "Strategy" pattern: choose the implementation based on the purpose.
-        // For simplicity, we only consider the first purpose listed.
         val purpose = params.purpose.firstOrNull()
         val purposeName = KeyMintParameterLogger.purposeNames[purpose] ?: "UNKNOWN"
         SystemLogger.debug("[SoftwareOp TX_ID: $txId] Initializing for purpose: $purposeName.")
@@ -178,63 +199,109 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
             }
     }
 
+    /** Parameters produced during begin (e.g. GCM nonce), to populate CreateOperationResponse. */
+    val beginParameters: KeyParameters?
+        get() {
+            val params = primitive.getBeginParameters() ?: return null
+            if (params.isEmpty()) return null
+            return KeyParameters().apply { keyParameter = params }
+        }
+
+    private fun checkActive() {
+        if (finalized) throw IllegalStateException("INVALID_OPERATION_HANDLE")
+    }
+
     fun updateAad(data: ByteArray?) {
+        checkActive()
         try {
             primitive.updateAad(data)
         } catch (e: Exception) {
+            finalized = true
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to updateAad.", e)
             throw e
         }
     }
 
     fun update(data: ByteArray?): ByteArray? {
+        checkActive()
         try {
             return primitive.update(data)
         } catch (e: Exception) {
+            finalized = true
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to update operation.", e)
             throw e
         }
     }
 
     fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
+        checkActive()
         try {
             val result = primitive.finish(data, signature)
             SystemLogger.info("[SoftwareOp TX_ID: $txId] Finished operation successfully.")
             return result
         } catch (e: Exception) {
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to finish operation.", e)
-            // Re-throw the exception so the binder can report it to the client.
             throw e
+        } finally {
+            finalized = true
         }
     }
 
     fun abort() {
+        checkActive()
+        finalized = true
         primitive.abort()
         SystemLogger.debug("[SoftwareOp TX_ID: $txId] Operation aborted.")
     }
 }
 
-/** The Binder interface for our [SoftwareOperation]. */
+/**
+ * The Binder interface for [SoftwareOperation].
+ *
+ * All methods are synchronized to prevent concurrent access, matching AOSP's Mutex-protected
+ * KeystoreOperation wrapper. Input data is validated against [MAX_RECEIVE_DATA] (32KB) to match
+ * AOSP's enforced limit.
+ */
 class SoftwareOperationBinder(private val operation: SoftwareOperation) :
     IKeystoreOperation.Stub() {
 
+    private fun checkInputLength(data: ByteArray?) {
+        if (data != null && data.size > MAX_RECEIVE_DATA)
+            throw IllegalStateException("TOO_MUCH_DATA")
+    }
+
     @Throws(RemoteException::class)
     override fun updateAad(aadInput: ByteArray?) {
-        operation.updateAad(aadInput)
+        synchronized(this) {
+            checkInputLength(aadInput)
+            operation.updateAad(aadInput)
+        }
     }
 
     @Throws(RemoteException::class)
     override fun update(input: ByteArray?): ByteArray? {
-        return operation.update(input)
+        synchronized(this) {
+            checkInputLength(input)
+            return operation.update(input)
+        }
     }
 
     @Throws(RemoteException::class)
     override fun finish(input: ByteArray?, signature: ByteArray?): ByteArray? {
-        return operation.finish(input, signature)
+        synchronized(this) {
+            checkInputLength(input)
+            checkInputLength(signature)
+            return operation.finish(input, signature)
+        }
     }
 
     @Throws(RemoteException::class)
     override fun abort() {
-        operation.abort()
+        synchronized(this) { operation.abort() }
+    }
+
+    companion object {
+        // AOSP operation.rs MAX_RECEIVE_DATA = 0x8000
+        private const val MAX_RECEIVE_DATA = 0x8000
     }
 }

From b6bc7a19d598c19c517ce6cf1c8f57edd07e2205 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:46:17 +0100
Subject: [PATCH 06/56] Patch certificates and authorizations for imported keys

The post-importKey hook previously only cleaned up cached data but never
patched the KeyMetadata returned from importKey. Imported asymmetric
keys with attestation chains now get the same certificate and
authorization patching treatment as generated keys.

Also remove the unconditional early return for imported keys in the
post-getKeyEntry handler. The existing chain-length check already
correctly handles keys without attestation chains, so the blanket
import-key skip was overly broad.
---
 .../keystore/Keystore2Interceptor.kt          |  5 -----
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 21 ++++++++++++++++++-
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 3378fbe2..52bef356 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -231,11 +231,6 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                             authorizations?.map { it.keyParameter }?.toTypedArray() ?: emptyArray()
                         )
 
-                    if (parsedParameters.isImportKey()) {
-                        SystemLogger.info("[TX_ID: $txId] Skip patching for imported keys.")
-                        return TransactionResult.SkipTransaction
-                    }
-
                     if (parsedParameters.isAttestKey()) {
                         SystemLogger.warning(
                             "[TX_ID: $txId] Found hardware attest key ${keyId.alias} in the reply."
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 598de30a..2ca11eda 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -106,7 +106,26 @@ class KeyMintSecurityLevelInterceptor(
             val keyDescriptor =
                 data.readTypedObject(KeyDescriptor.CREATOR)
                     ?: return TransactionResult.SkipTransaction
-            cleanupKeyData(KeyIdentifier(callingUid, keyDescriptor.alias))
+            val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
+            cleanupKeyData(keyId)
+
+            // Patch imported key certificates the same way as generated keys.
+            if (!ConfigurationManager.shouldSkipUid(callingUid)) {
+                val metadata: KeyMetadata =
+                    reply.readTypedObject(KeyMetadata.CREATOR)
+                        ?: return TransactionResult.SkipTransaction
+                val originalChain = CertificateHelper.getCertificateChain(metadata)
+                if (originalChain != null && originalChain.size > 1) {
+                    val newChain =
+                        AttestationPatcher.patchCertificateChain(originalChain, callingUid)
+                    CertificateHelper.updateCertificateChain(metadata, newChain).getOrThrow()
+                    metadata.authorizations =
+                        InterceptorUtils.patchAuthorizations(metadata.authorizations, callingUid)
+                    patchedChains[keyId] = newChain
+                    SystemLogger.debug("Cached patched certificate chain for imported key $keyId.")
+                    return InterceptorUtils.createTypedObjectReply(metadata)
+                }
+            }
         } else if (code == CREATE_OPERATION_TRANSACTION) {
             logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
 

From da452cf2be91791c5a4dd5c7eea63fc3e29a8f3e Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:46:57 +0100
Subject: [PATCH 07/56] Populate CreateOperationResponse.parameters for GCM
 operations

AOSP returns begin_result.params in CreateOperationResponse.parameters,
which contains the IV/nonce for AES-GCM encryption operations. Software
operations previously left this field null, so clients expecting the
server-generated IV from the response would not receive it.

CipherPrimitive now exposes cipher.iv as a NONCE KeyParameter via
getBeginParameters(), surfaced through SoftwareOperation.beginParameters
and into the CreateOperationResponse.
---
 .../keystore/shim/KeyMintSecurityLevelInterceptor.kt             | 1 +
 1 file changed, 1 insertion(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 2ca11eda..c156cf6b 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -238,6 +238,7 @@ class KeyMintSecurityLevelInterceptor(
             CreateOperationResponse().apply {
                 iOperation = operationBinder
                 operationChallenge = null
+                parameters = softwareOperation.beginParameters
             }
 
         return InterceptorUtils.createTypedObjectReply(response)

From 0ebddedb265a6a25bf1de45da4b5d269240bd6ad Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:56:35 +0100
Subject: [PATCH 08/56] Use ServiceSpecificException with AOSP error codes for
 operation errors

AOSP keystore2 reports all errors via ServiceSpecificException with
numeric codes: negative values for KeyMint ErrorCode (e.g. -28 for
INVALID_OPERATION_HANDLE, -30 for VERIFICATION_FAILED) and positive
values for Keystore2 ResponseCode (e.g. 16 for TOO_MUCH_DATA). The
binder framework serializes these as EX_SERVICE_SPECIFIC on the wire.

Previously, software operations threw plain Java exceptions
(IllegalStateException, SignatureException) which serialize differently
and produce unrecognizable error codes on the client side.

Replace all error paths with ServiceSpecificException using the correct
AOSP error codes. Add ServiceSpecificException stub to the stub module.
---
 .../keystore/shim/SoftwareOperation.kt        | 81 +++++++++++++++----
 .../android/os/ServiceSpecificException.java  | 21 +++++
 2 files changed, 85 insertions(+), 17 deletions(-)
 create mode 100644 stub/src/main/java/android/os/ServiceSpecificException.java

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index 0b3bb10a..354667ac 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -9,6 +9,7 @@ import android.hardware.security.keymint.KeyPurpose
 import android.hardware.security.keymint.PaddingMode
 import android.hardware.security.keymint.Tag
 import android.os.RemoteException
+import android.os.ServiceSpecificException
 import android.system.keystore2.IKeystoreOperation
 import android.system.keystore2.KeyParameters
 import java.security.KeyPair
@@ -19,6 +20,27 @@ import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.logging.KeyMintParameterLogger
 import org.matrix.TEESimulator.logging.SystemLogger
 
+/**
+ * AOSP keystore2 error codes used in ServiceSpecificException. Negative values are KeyMint
+ * ErrorCode constants; positive values are Keystore2 ResponseCode constants. See AOSP error.rs.
+ */
+private object KeystoreErrorCode {
+    /** KeyMint ErrorCode::INVALID_OPERATION_HANDLE */
+    const val INVALID_OPERATION_HANDLE = -28
+
+    /** KeyMint ErrorCode::VERIFICATION_FAILED */
+    const val VERIFICATION_FAILED = -30
+
+    /** KeyMint ErrorCode::UNSUPPORTED_PURPOSE */
+    const val UNSUPPORTED_PURPOSE = -2
+
+    /** Keystore2 ResponseCode::SYSTEM_ERROR */
+    const val SYSTEM_ERROR = 4
+
+    /** Keystore2 ResponseCode::TOO_MUCH_DATA */
+    const val TOO_MUCH_DATA = 16
+}
+
 // A sealed interface to represent the different cryptographic operations we can perform.
 private sealed interface CryptoPrimitive {
     fun updateAad(data: ByteArray?)
@@ -48,8 +70,9 @@ private object JcaAlgorithmMapper {
                 Algorithm.EC -> "ECDSA"
                 Algorithm.RSA -> "RSA"
                 else ->
-                    throw IllegalArgumentException(
-                        "Unsupported signature algorithm: ${params.algorithm}"
+                    throw ServiceSpecificException(
+                        KeystoreErrorCode.SYSTEM_ERROR,
+                        "Unsupported signature algorithm: ${params.algorithm}",
                     )
             }
         return "${digest}with${keyAlgo}"
@@ -61,8 +84,9 @@ private object JcaAlgorithmMapper {
                 Algorithm.RSA -> "RSA"
                 Algorithm.AES -> "AES"
                 else ->
-                    throw IllegalArgumentException(
-                        "Unsupported cipher algorithm: ${params.algorithm}"
+                    throw ServiceSpecificException(
+                        KeystoreErrorCode.SYSTEM_ERROR,
+                        "Unsupported cipher algorithm: ${params.algorithm}",
                     )
             }
         val blockMode =
@@ -122,12 +146,17 @@ private class Verifier(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPri
 
     override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
         if (data != null) update(data)
-        if (signature == null) throw SignatureException("Signature to verify is null")
+        if (signature == null)
+            throw ServiceSpecificException(
+                KeystoreErrorCode.VERIFICATION_FAILED,
+                "Signature to verify is null",
+            )
         if (!this.signature.verify(signature)) {
-            // Throwing an exception is how Keystore signals verification failure.
-            throw SignatureException("Signature verification failed")
+            throw ServiceSpecificException(
+                KeystoreErrorCode.VERIFICATION_FAILED,
+                "Signature/MAC verification failed",
+            )
         }
-        // A successful verification returns no data.
         return null
     }
 
@@ -174,9 +203,9 @@ private class CipherPrimitive(
  * A software-only implementation of a cryptographic operation. This class acts as a controller,
  * delegating to a specific cryptographic primitive based on the operation's purpose.
  *
- * Tracks operation lifecycle: once [finish] or [abort] is called, subsequent calls will throw.
- * This matches AOSP keystore2 behavior where finalized operations return
- * INVALID_OPERATION_HANDLE.
+ * Tracks operation lifecycle: once [finish] or [abort] is called, subsequent calls throw
+ * [ServiceSpecificException] with [KeystoreErrorCode.INVALID_OPERATION_HANDLE], matching AOSP
+ * keystore2 behavior (operation.rs check_active).
  */
 class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMintAttestation) {
     private val primitive: CryptoPrimitive
@@ -195,7 +224,10 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
                 KeyPurpose.ENCRYPT -> CipherPrimitive(keyPair, params, Cipher.ENCRYPT_MODE)
                 KeyPurpose.DECRYPT -> CipherPrimitive(keyPair, params, Cipher.DECRYPT_MODE)
                 else ->
-                    throw UnsupportedOperationException("Unsupported operation purpose: $purpose")
+                    throw ServiceSpecificException(
+                        KeystoreErrorCode.UNSUPPORTED_PURPOSE,
+                        "Unsupported operation purpose: $purpose",
+                    )
             }
     }
 
@@ -208,17 +240,24 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
         }
 
     private fun checkActive() {
-        if (finalized) throw IllegalStateException("INVALID_OPERATION_HANDLE")
+        if (finalized)
+            throw ServiceSpecificException(
+                KeystoreErrorCode.INVALID_OPERATION_HANDLE,
+                "Operation already finalized.",
+            )
     }
 
     fun updateAad(data: ByteArray?) {
         checkActive()
         try {
             primitive.updateAad(data)
+        } catch (e: ServiceSpecificException) {
+            finalized = true
+            throw e
         } catch (e: Exception) {
             finalized = true
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to updateAad.", e)
-            throw e
+            throw ServiceSpecificException(KeystoreErrorCode.SYSTEM_ERROR, e.message)
         }
     }
 
@@ -226,10 +265,13 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
         checkActive()
         try {
             return primitive.update(data)
+        } catch (e: ServiceSpecificException) {
+            finalized = true
+            throw e
         } catch (e: Exception) {
             finalized = true
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to update operation.", e)
-            throw e
+            throw ServiceSpecificException(KeystoreErrorCode.SYSTEM_ERROR, e.message)
         }
     }
 
@@ -239,9 +281,11 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
             val result = primitive.finish(data, signature)
             SystemLogger.info("[SoftwareOp TX_ID: $txId] Finished operation successfully.")
             return result
+        } catch (e: ServiceSpecificException) {
+            throw e
         } catch (e: Exception) {
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to finish operation.", e)
-            throw e
+            throw ServiceSpecificException(KeystoreErrorCode.SYSTEM_ERROR, e.message)
         } finally {
             finalized = true
         }
@@ -261,13 +305,16 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
  * All methods are synchronized to prevent concurrent access, matching AOSP's Mutex-protected
  * KeystoreOperation wrapper. Input data is validated against [MAX_RECEIVE_DATA] (32KB) to match
  * AOSP's enforced limit.
+ *
+ * All errors are reported as [ServiceSpecificException] with AOSP-compatible numeric error codes,
+ * matching the wire format produced by AOSP's `into_binder()` in error.rs.
  */
 class SoftwareOperationBinder(private val operation: SoftwareOperation) :
     IKeystoreOperation.Stub() {
 
     private fun checkInputLength(data: ByteArray?) {
         if (data != null && data.size > MAX_RECEIVE_DATA)
-            throw IllegalStateException("TOO_MUCH_DATA")
+            throw ServiceSpecificException(KeystoreErrorCode.TOO_MUCH_DATA)
     }
 
     @Throws(RemoteException::class)
diff --git a/stub/src/main/java/android/os/ServiceSpecificException.java b/stub/src/main/java/android/os/ServiceSpecificException.java
new file mode 100644
index 00000000..f0a93432
--- /dev/null
+++ b/stub/src/main/java/android/os/ServiceSpecificException.java
@@ -0,0 +1,21 @@
+package android.os;
+
+/**
+ * Stub for android.os.ServiceSpecificException.
+ *
+ * <p>Used by AIDL-generated binder stubs to report service-specific errors with numeric codes.
+ * The binder framework serializes this as EX_SERVICE_SPECIFIC on the wire, preserving the integer
+ * error code for the client.
+ */
+public class ServiceSpecificException extends RuntimeException {
+    public final int errorCode;
+
+    public ServiceSpecificException(int errorCode, String message) {
+        super(message);
+        this.errorCode = errorCode;
+    }
+
+    public ServiceSpecificException(int errorCode) {
+        this(errorCode, null);
+    }
+}

From fbe56056704115d7805d4a458c357dfcd717a4aa Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 16:59:34 +0100
Subject: [PATCH 09/56] Fix default certificate subject to match KeyMint
 reference

The AOSP KeyMint reference implementation uses "CN=Android Keystore Key"
(lowercase 's') as the default certificate subject when no
CERTIFICATE_SUBJECT tag is provided. The previous value used camelCase
"KeyStore" which differs from real hardware output.
---
 .../java/org/matrix/TEESimulator/pki/CertificateGenerator.kt    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
index fa6b7810..19b81d92 100644
--- a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
@@ -215,7 +215,7 @@ object CertificateGenerator {
         uid: Int,
         securityLevel: Int,
     ): Certificate {
-        val subject = params.certificateSubject ?: X500Name("CN=Android KeyStore Key")
+        val subject = params.certificateSubject ?: X500Name("CN=Android Keystore Key")
         val leafNotAfter =
             (signingKeyPair.public as? X509Certificate)?.notAfter
                 ?: Date(System.currentTimeMillis() + 31536000000L)

From f33769de4f8e62799ca20e6738104d76b7776884 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:06:36 +0100
Subject: [PATCH 10/56] Fix certificate validity defaults and RSA exponent null
 safety

AOSP add_required_parameters (security_level.rs) sets default
CERTIFICATE_NOT_BEFORE to 0 (Unix epoch) and CERTIFICATE_NOT_AFTER to
253402300799000 (9999-12-31T23:59:59 UTC, the RFC 5280 GeneralizedTime
maximum). Since TEESimulator intercepts before add_required_parameters
runs, the defaults must match what keystore2 would have injected.

Previously, notBefore defaulted to the current time and notAfter to
one year from now, producing certificates with drastically different
validity periods than real hardware.

Also add null-safe default for RSA public exponent using
RSAKeyGenParameterSpec.F4 (65537), preventing potential NPE when the
caller omits RSA_PUBLIC_EXPONENT.
---
 .../TEESimulator/pki/CertificateGenerator.kt  | 23 +++++++++++++------
 1 file changed, 16 insertions(+), 7 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
index 19b81d92..e8ec69b7 100644
--- a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
@@ -8,7 +8,6 @@ import java.math.BigInteger
 import java.security.KeyPair
 import java.security.KeyPairGenerator
 import java.security.cert.Certificate
-import java.security.cert.X509Certificate
 import java.security.spec.ECGenParameterSpec
 import java.security.spec.RSAKeyGenParameterSpec
 import java.util.Date
@@ -36,6 +35,10 @@ import org.matrix.TEESimulator.logging.SystemLogger
  */
 object CertificateGenerator {
 
+    // AOSP utils.rs: pub const UNDEFINED_NOT_AFTER: i64 = 253402300799000i64;
+    // RFC 5280 GeneralizedTime maximum: 9999-12-31T23:59:59 UTC (millis since epoch)
+    private const val UNDEFINED_NOT_AFTER = 253402300799000L
+
     /**
      * Generates a software-based cryptographic key pair.
      *
@@ -49,7 +52,10 @@ object CertificateGenerator {
                         Algorithm.EC -> "EC" to ECGenParameterSpec(params.ecCurveName)
                         Algorithm.RSA ->
                             "RSA" to
-                                RSAKeyGenParameterSpec(params.keySize, params.rsaPublicExponent)
+                                RSAKeyGenParameterSpec(
+                                    params.keySize,
+                                    params.rsaPublicExponent ?: RSAKeyGenParameterSpec.F4,
+                                )
                         else ->
                             throw IllegalArgumentException(
                                 "Unsupported algorithm: ${params.algorithm}"
@@ -216,16 +222,19 @@ object CertificateGenerator {
         securityLevel: Int,
     ): Certificate {
         val subject = params.certificateSubject ?: X500Name("CN=Android Keystore Key")
-        val leafNotAfter =
-            (signingKeyPair.public as? X509Certificate)?.notAfter
-                ?: Date(System.currentTimeMillis() + 31536000000L)
+
+        // AOSP add_required_parameters (security_level.rs) defaults:
+        //   CERTIFICATE_NOT_BEFORE = 0 (Unix epoch)
+        //   CERTIFICATE_NOT_AFTER  = 253402300799000 (9999-12-31T23:59:59 UTC)
+        val notBefore = params.certificateNotBefore ?: Date(0)
+        val notAfter = params.certificateNotAfter ?: Date(UNDEFINED_NOT_AFTER)
 
         val builder =
             JcaX509v3CertificateBuilder(
                 issuer,
                 params.certificateSerial ?: BigInteger.ONE,
-                params.certificateNotBefore ?: Date(),
-                params.certificateNotAfter ?: leafNotAfter,
+                notBefore,
+                notAfter,
                 subject,
                 subjectKeyPair.public,
             )

From 8a90ea3f71b338d0e80d386c0a0cf4cc44eebdda Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:17:05 +0100
Subject: [PATCH 11/56] Only include ATTESTATION_APPLICATION_ID when challenge
 is present

AOSP add_required_parameters (security_level.rs) only adds
ATTESTATION_APPLICATION_ID to the key parameters when an
ATTESTATION_CHALLENGE tag is present. The previous code unconditionally
included it in every softwareEnforced list, violating the Android Key
Attestation specification.

Pass KeyMintAttestation params to buildSoftwareEnforcedList and gate
the ATTESTATION_APPLICATION_ID entry on attestationChallenge != null.
---
 .../attestation/AttestationBuilder.kt         | 32 +++++++++++++------
 1 file changed, 22 insertions(+), 10 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 0625001d..f4bfc3f5 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -133,7 +133,7 @@ object AttestationBuilder {
         securityLevel: Int,
     ): ASN1Sequence {
         val teeEnforced = buildTeeEnforcedList(params, uid, securityLevel)
-        val softwareEnforced = buildSoftwareEnforcedList(uid, securityLevel)
+        val softwareEnforced = buildSoftwareEnforcedList(params, uid, securityLevel)
 
         val fields =
             arrayOf(
@@ -320,20 +320,32 @@ object AttestationBuilder {
      * Builds the `SoftwareEnforced` authorization list. These are properties guaranteed by
      * Keystore.
      */
-    private fun buildSoftwareEnforcedList(uid: Int, securityLevel: Int): DERSequence {
-        val list =
-            mutableListOf<ASN1Encodable>(
-                DERTaggedObject(
-                    true,
-                    AttestationConstants.TAG_CREATION_DATETIME,
-                    ASN1Integer(System.currentTimeMillis()),
-                ),
+    private fun buildSoftwareEnforcedList(
+        params: KeyMintAttestation,
+        uid: Int,
+        securityLevel: Int,
+    ): DERSequence {
+        val list = mutableListOf<ASN1Encodable>()
+
+        list.add(
+            DERTaggedObject(
+                true,
+                AttestationConstants.TAG_CREATION_DATETIME,
+                ASN1Integer(System.currentTimeMillis()),
+            )
+        )
+
+        // AOSP add_required_parameters (security_level.rs) only adds
+        // ATTESTATION_APPLICATION_ID when an attestation challenge is present.
+        if (params.attestationChallenge != null) {
+            list.add(
                 DERTaggedObject(
                     true,
                     AttestationConstants.TAG_ATTESTATION_APPLICATION_ID,
                     createApplicationId(uid),
-                ),
+                )
             )
+        }
         if (AndroidDeviceUtils.getAttestVersion(securityLevel) >= 400) {
             list.add(
                 DERTaggedObject(

From e4814bf7e5f46df081f2ce09ba640053aa02f5b8 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:17:38 +0100
Subject: [PATCH 12/56] Fix attestation key override to update nspace and patch
 authorizations

When overriding a hardware attestation key in the post-getKeyEntry hook,
the response metadata's key.nspace was not updated to the new randomly
assigned value. This caused subsequent createOperation calls to fail
because the nspace in the cached GeneratedKeyInfo did not match the
descriptor the client received.

Also patch the authorizations (patch levels) in this path, matching
the behavior already applied to non-attestation hardware keys.
---
 .../interception/keystore/Keystore2Interceptor.kt      | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 52bef356..259c1252 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -250,12 +250,18 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                                 keyData.second.toTypedArray(),
                             )
                             .getOrThrow()
+                        response.metadata.authorizations =
+                            InterceptorUtils.patchAuthorizations(
+                                response.metadata.authorizations,
+                                callingUid,
+                            )
 
-                        keyDescriptor.nspace = SecureRandom().nextLong()
+                        val newNspace = SecureRandom().nextLong()
+                        response.metadata.key?.let { it.nspace = newNspace }
                         KeyMintSecurityLevelInterceptor.generatedKeys[keyId] =
                             KeyMintSecurityLevelInterceptor.GeneratedKeyInfo(
                                 keyData.first,
-                                keyDescriptor.nspace,
+                                newNspace,
                                 response,
                             )
                         KeyMintSecurityLevelInterceptor.attestationKeys.add(keyId)

From 086a580a254540725e488e01ff47448ff6abfd46 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:23:42 +0100
Subject: [PATCH 13/56] Add .gitattributes to enforce LF line endings for shell
 scripts

On Windows with core.autocrlf=true, shell scripts were checked out
with CRLF line endings and packaged as-is into the flashable zip.
Android's sh interpreter cannot parse CRLF scripts, causing
"syntax error: unexpected word" on module installation.

Force *.sh and module/daemon to always use LF regardless of platform.
---
 .gitattributes | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 .gitattributes

diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 00000000..ac18c939
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1,4 @@
+# Ensure shell scripts always have LF line endings, even on Windows.
+# These get packaged into flashable zips and run on Android devices.
+*.sh text eol=lf
+module/daemon text eol=lf

From e7676498052017a3c56e34808ed6fdfbbce2538b Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:35:02 +0100
Subject: [PATCH 14/56] Derive KEY_SIZE from EC_CURVE when not explicitly
 provided

For EC keys, callers often provide only EC_CURVE (e.g. P-256) without
an explicit KEY_SIZE tag. The parser defaulted keySize to 0, causing
the attestation teeEnforced list and KeyMetadata authorizations to
report keySize=0 instead of the correct value (e.g. 256 for P-256).

Add deriveKeySizeFromCurve() that maps EcCurve constants to their
corresponding key sizes as a fallback when KEY_SIZE is absent.
---
 .../attestation/KeyMintAttestation.kt            | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
index baa174d4..6dd7b61c 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
@@ -50,7 +50,8 @@ data class KeyMintAttestation(
         algorithm = params.findAlgorithm(Tag.ALGORITHM) ?: 0,
 
         // AOSP: [key_param(tag = KEY_SIZE, field = Integer)]
-        keySize = params.findInteger(Tag.KEY_SIZE) ?: 0,
+        // For EC keys, derive keySize from EC_CURVE when KEY_SIZE is absent.
+        keySize = params.findInteger(Tag.KEY_SIZE) ?: params.deriveKeySizeFromCurve(),
 
         // AOSP: [key_param(tag = EC_CURVE, field = EcCurve)]
         ecCurve = params.findEcCurve(Tag.EC_CURVE),
@@ -167,6 +168,19 @@ private fun Array<KeyParameter>.findAllKeyPurpose(tag: Int): List<Int> =
 private fun Array<KeyParameter>.findAllDigests(tag: Int): List<Int> =
     this.filter { it.tag == tag }.map { it.value.digest }
 
+/** Derives keySize from EC_CURVE tag when KEY_SIZE is not explicitly provided. */
+private fun Array<KeyParameter>.deriveKeySizeFromCurve(): Int {
+    val curveId = this.find { it.tag == Tag.EC_CURVE }?.value?.ecCurve ?: return 0
+    return when (curveId) {
+        EcCurve.P_224 -> 224
+        EcCurve.P_256 -> 256
+        EcCurve.P_384 -> 384
+        EcCurve.P_521 -> 521
+        EcCurve.CURVE_25519 -> 256
+        else -> 0
+    }
+}
+
 /**
  * Derives the EC Curve name. Logic: Checks specific EC_CURVE tag first (field=EcCurve), falls back
  * to KEY_SIZE (field=Integer).

From 50cd77f5f40537de370164e7c9ea62a935640ec9 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:35:26 +0100
Subject: [PATCH 15/56] Validate operation purpose and reject caller-provided
 CREATION_DATETIME

createOperation now validates the requested purpose against the key's
allowed purposes before creating a SoftwareOperation. Mismatched
purposes return INCOMPATIBLE_PURPOSE (-3) via ServiceSpecificException,
matching AOSP enforcements.rs authorize_create behavior. Previously,
mismatched purposes caused SoftwareOperation constructor to throw an
unrelated error, which fell through as KEY_NOT_FOUND.

Also wrap SoftwareOperation creation in runCatching so any construction
failure returns a proper ServiceSpecificException error reply instead
of propagating as an unhandled exception.

generateKey now rejects caller-provided CREATION_DATETIME with
INVALID_ARGUMENT (20), matching AOSP add_required_parameters which
explicitly forbids callers from specifying this tag.

Add createServiceSpecificErrorReply utility to InterceptorUtils for
writing ServiceSpecificException to binder reply parcels.
---
 .../interception/keystore/InterceptorUtils.kt | 14 +++++
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 63 ++++++++++++++++---
 .../keystore/shim/SoftwareOperation.kt        |  5 +-
 3 files changed, 71 insertions(+), 11 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
index f4dc6f0f..161e85ed 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
@@ -118,6 +118,20 @@ object InterceptorUtils {
         return exception != null
     }
 
+    /**
+     * Creates an `OverrideReply` that writes a `ServiceSpecificException` with the given error
+     * code, matching AOSP's `into_binder()` wire format (EX_SERVICE_SPECIFIC).
+     */
+    fun createServiceSpecificErrorReply(
+        errorCode: Int
+    ): BinderInterceptor.TransactionResult.OverrideReply {
+        val parcel =
+            Parcel.obtain().apply {
+                writeException(android.os.ServiceSpecificException(errorCode))
+            }
+        return BinderInterceptor.TransactionResult.OverrideReply(parcel)
+    }
+
     /**
      * Patches the system-level authorization values (OS_PATCHLEVEL, VENDOR_PATCHLEVEL,
      * BOOT_PATCHLEVEL) in an authorization array to match the configured patch levels for the
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index c156cf6b..e432f207 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -231,17 +231,48 @@ class KeyMintSecurityLevelInterceptor(
         val params = data.createTypedArray(KeyParameter.CREATOR)!!
         val parsedParams = KeyMintAttestation(params)
 
-        val softwareOperation = SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedParams)
-        val operationBinder = SoftwareOperationBinder(softwareOperation)
-
-        val response =
-            CreateOperationResponse().apply {
-                iOperation = operationBinder
-                operationChallenge = null
-                parameters = softwareOperation.beginParameters
-            }
+        // Validate the requested purpose against the key's allowed purposes,
+        // matching AOSP enforcements.rs authorize_create behavior.
+        val requestedPurpose = parsedParams.purpose.firstOrNull()
+        val keyResponse = generatedKeyInfo.response
+        val keyAuthorizations =
+            keyResponse.metadata?.authorizations?.map { it.keyParameter.tag to it.keyParameter }
+        val allowedPurposes =
+            keyAuthorizations
+                ?.filter { it.first == Tag.PURPOSE }
+                ?.map { it.second.value.keyPurpose }
+                ?: emptyList()
+
+        if (requestedPurpose != null && requestedPurpose !in allowedPurposes) {
+            SystemLogger.info(
+                "[TX_ID: $txId] Rejecting operation: purpose $requestedPurpose not in $allowedPurposes"
+            )
+            return InterceptorUtils.createServiceSpecificErrorReply(
+                KeystoreErrorCode.INCOMPATIBLE_PURPOSE
+            )
+        }
 
-        return InterceptorUtils.createTypedObjectReply(response)
+        return runCatching {
+                val softwareOperation =
+                    SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedParams)
+                val operationBinder = SoftwareOperationBinder(softwareOperation)
+
+                val response =
+                    CreateOperationResponse().apply {
+                        iOperation = operationBinder
+                        operationChallenge = null
+                        parameters = softwareOperation.beginParameters
+                    }
+
+                InterceptorUtils.createTypedObjectReply(response)
+            }
+            .getOrElse { e ->
+                SystemLogger.error("[TX_ID: $txId] Failed to create software operation.", e)
+                InterceptorUtils.createServiceSpecificErrorReply(
+                    if (e is android.os.ServiceSpecificException) e.errorCode
+                    else KeystoreErrorCode.SYSTEM_ERROR
+                )
+            }
     }
 
     /**
@@ -257,6 +288,15 @@ class KeyMintSecurityLevelInterceptor(
                     "Handling generateKey ${keyDescriptor.alias}, attestKey=${attestationKey?.alias}"
                 )
                 val params = data.createTypedArray(KeyParameter.CREATOR)!!
+
+                // AOSP add_required_parameters rejects caller-provided CREATION_DATETIME
+                // with INVALID_ARGUMENT. (security_level.rs:425-430)
+                if (params.any { it.tag == Tag.CREATION_DATETIME }) {
+                    return@runCatching InterceptorUtils.createServiceSpecificErrorReply(
+                        INVALID_ARGUMENT
+                    )
+                }
+
                 val parsedParams = KeyMintAttestation(params)
                 val isAttestKeyRequest = parsedParams.isAttestKey()
 
@@ -346,6 +386,9 @@ class KeyMintSecurityLevelInterceptor(
     companion object {
         private val secureRandom = SecureRandom()
 
+        // AOSP ResponseCode / ErrorCode constants used for ServiceSpecificException.
+        private const val INVALID_ARGUMENT = 20 // Keystore2 ResponseCode::INVALID_ARGUMENT
+
         // Transaction codes for IKeystoreSecurityLevel interface.
         private val GENERATE_KEY_TRANSACTION =
             InterceptorUtils.getTransactCode(IKeystoreSecurityLevel.Stub::class.java, "generateKey")
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index 354667ac..1f5eeec2 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -24,7 +24,7 @@ import org.matrix.TEESimulator.logging.SystemLogger
  * AOSP keystore2 error codes used in ServiceSpecificException. Negative values are KeyMint
  * ErrorCode constants; positive values are Keystore2 ResponseCode constants. See AOSP error.rs.
  */
-private object KeystoreErrorCode {
+internal object KeystoreErrorCode {
     /** KeyMint ErrorCode::INVALID_OPERATION_HANDLE */
     const val INVALID_OPERATION_HANDLE = -28
 
@@ -34,6 +34,9 @@ private object KeystoreErrorCode {
     /** KeyMint ErrorCode::UNSUPPORTED_PURPOSE */
     const val UNSUPPORTED_PURPOSE = -2
 
+    /** KeyMint ErrorCode::INCOMPATIBLE_PURPOSE */
+    const val INCOMPATIBLE_PURPOSE = -3
+
     /** Keystore2 ResponseCode::SYSTEM_ERROR */
     const val SYSTEM_ERROR = 4
 

From 60d978d9e3138c4c8948a7ed6943ead419937f22 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:47:14 +0100
Subject: [PATCH 16/56] Fix TOO_MUCH_DATA error code to 21 and add missing
 error constants

ResponseCode::TOO_MUCH_DATA is 21 in AOSP, not 16. Add remaining
AOSP error code constants (KEY_EXPIRED, KEY_NOT_YET_VALID,
CALLER_NONCE_PROHIBITED, INVALID_ARGUMENT, PERMISSION_DENIED,
KEY_NOT_FOUND) for use in operation enforcement.

Add onFinishCallback to SoftwareOperation for USAGE_COUNT_LIMIT
enforcement on successful finish.
---
 .../keystore/shim/SoftwareOperation.kt        | 29 +++++++++++++++++--
 1 file changed, 27 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index 1f5eeec2..7c8e6346 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -41,7 +41,25 @@ internal object KeystoreErrorCode {
     const val SYSTEM_ERROR = 4
 
     /** Keystore2 ResponseCode::TOO_MUCH_DATA */
-    const val TOO_MUCH_DATA = 16
+    const val TOO_MUCH_DATA = 21
+
+    /** KeyMint ErrorCode::KEY_EXPIRED */
+    const val KEY_EXPIRED = -25
+
+    /** KeyMint ErrorCode::KEY_NOT_YET_VALID */
+    const val KEY_NOT_YET_VALID = -24
+
+    /** KeyMint ErrorCode::CALLER_NONCE_PROHIBITED */
+    const val CALLER_NONCE_PROHIBITED = -55
+
+    /** KeyMint ErrorCode::INVALID_ARGUMENT */
+    const val INVALID_ARGUMENT = -38
+
+    /** Keystore2 ResponseCode::PERMISSION_DENIED */
+    const val PERMISSION_DENIED = 6
+
+    /** Keystore2 ResponseCode::KEY_NOT_FOUND */
+    const val KEY_NOT_FOUND = 7
 }
 
 // A sealed interface to represent the different cryptographic operations we can perform.
@@ -210,7 +228,13 @@ private class CipherPrimitive(
  * [ServiceSpecificException] with [KeystoreErrorCode.INVALID_OPERATION_HANDLE], matching AOSP
  * keystore2 behavior (operation.rs check_active).
  */
-class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMintAttestation) {
+class SoftwareOperation(
+    private val txId: Long,
+    keyPair: KeyPair,
+    params: KeyMintAttestation,
+    /** Called after a successful finish(), used for USAGE_COUNT_LIMIT enforcement. */
+    var onFinishCallback: (() -> Unit)? = null,
+) {
     private val primitive: CryptoPrimitive
 
     @Volatile private var finalized = false
@@ -283,6 +307,7 @@ class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMin
         try {
             val result = primitive.finish(data, signature)
             SystemLogger.info("[SoftwareOp TX_ID: $txId] Finished operation successfully.")
+            onFinishCallback?.invoke()
             return result
         } catch (e: ServiceSpecificException) {
             throw e

From 4bc471363f8adbba685e350f1e8ba75efe6fe4ec Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:50:10 +0100
Subject: [PATCH 17/56] Parse enforcement tags from key generation parameters

Add parsing for ACTIVE_DATETIME, ORIGINATION_EXPIRE_DATETIME,
USAGE_EXPIRE_DATETIME, USAGE_COUNT_LIMIT, CALLER_NONCE, and
UNLOCKED_DEVICE_REQUIRED to KeyMintAttestation. These are needed
both for reflecting them in the attestation extension and for
enforcing key policies during createOperation.
---
 .../attestation/KeyMintAttestation.kt             | 15 +++++++++++++++
 .../interception/keystore/KeystoreInterceptor.kt  |  6 ++++++
 2 files changed, 21 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
index 6dd7b61c..eb27ed8f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
@@ -41,6 +41,13 @@ data class KeyMintAttestation(
     val manufacturer: ByteArray?,
     val model: ByteArray?,
     val secondImei: ByteArray?,
+    // --- Enforcement tags ---
+    val activeDateTime: Date?,
+    val originationExpireDateTime: Date?,
+    val usageExpireDateTime: Date?,
+    val usageCountLimit: Int?,
+    val callerNonce: Boolean?,
+    val unlockedDeviceRequired: Boolean?,
 ) {
     /** Secondary constructor that populates the fields by parsing an array of `KeyParameter`. */
     constructor(
@@ -104,6 +111,14 @@ data class KeyMintAttestation(
         manufacturer = params.findBlob(Tag.ATTESTATION_ID_MANUFACTURER),
         model = params.findBlob(Tag.ATTESTATION_ID_MODEL),
         secondImei = params.findBlob(Tag.ATTESTATION_ID_SECOND_IMEI),
+
+        // --- Enforcement tags ---
+        activeDateTime = params.findDate(Tag.ACTIVE_DATETIME),
+        originationExpireDateTime = params.findDate(Tag.ORIGINATION_EXPIRE_DATETIME),
+        usageExpireDateTime = params.findDate(Tag.USAGE_EXPIRE_DATETIME),
+        usageCountLimit = params.findInteger(Tag.USAGE_COUNT_LIMIT),
+        callerNonce = params.findBoolean(Tag.CALLER_NONCE),
+        unlockedDeviceRequired = params.findBoolean(Tag.UNLOCKED_DEVICE_REQUIRED),
     ) {
         // Log all parsed parameters for debugging purposes.
         params.forEach { KeyMintParameterLogger.logParameter(it) }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
index 3c7705a5..36fb14fa 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
@@ -432,6 +432,12 @@ private data class LegacyKeygenParameters(
             manufacturer = null,
             model = null,
             secondImei = null,
+            activeDateTime = null,
+            originationExpireDateTime = null,
+            usageExpireDateTime = null,
+            usageCountLimit = null,
+            callerNonce = null,
+            unlockedDeviceRequired = null,
         )
     }
 

From 41abe773a3efc71ca69c17c809fa3e8743adab5c Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:52:05 +0100
Subject: [PATCH 18/56] Include enforcement tags in attestation teeEnforced
 list

Add CALLER_NONCE, ACTIVE_DATETIME, ORIGINATION_EXPIRE_DATETIME,
USAGE_EXPIRE_DATETIME, USAGE_COUNT_LIMIT, and UNLOCKED_DEVICE_REQUIRED
to the teeEnforced AuthorizationList in the attestation extension when
present in the key generation parameters. Previously these tags were
silently dropped, allowing detection by generating a key with these
constraints and observing they're absent from the attestation.
---
 .../attestation/AttestationBuilder.kt         | 52 +++++++++++++++++++
 .../attestation/AttestationConstants.kt       |  1 +
 2 files changed, 53 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index f4bfc3f5..380b3699 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -313,6 +313,58 @@ object AttestationBuilder {
                 )
             }
         }
+        // Add enforcement-related tags that are reflected in the attestation.
+        if (params.callerNonce == true) {
+            list.add(
+                DERTaggedObject(true, AttestationConstants.TAG_CALLER_NONCE, DERNull.INSTANCE)
+            )
+        }
+        params.activeDateTime?.let {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_ACTIVE_DATETIME,
+                    ASN1Integer(it.time),
+                )
+            )
+        }
+        params.originationExpireDateTime?.let {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_ORIGINATION_EXPIRE_DATETIME,
+                    ASN1Integer(it.time),
+                )
+            )
+        }
+        params.usageExpireDateTime?.let {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_USAGE_EXPIRE_DATETIME,
+                    ASN1Integer(it.time),
+                )
+            )
+        }
+        params.usageCountLimit?.let {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_USAGE_COUNT_LIMIT,
+                    ASN1Integer(it.toLong()),
+                )
+            )
+        }
+        if (params.unlockedDeviceRequired == true) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_UNLOCKED_DEVICE_REQUIRED,
+                    DERNull.INSTANCE,
+                )
+            )
+        }
+
         return DERSequence(list.sortedBy { (it as DERTaggedObject).tagNo }.toTypedArray())
     }
 
diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt
index 767e8b39..f695a204 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt
@@ -56,6 +56,7 @@ object AttestationConstants {
     const val TAG_NO_AUTH_REQUIRED = 503
     const val TAG_USER_AUTH_TYPE = 504
     const val TAG_AUTH_TIMEOUT = 505
+    const val TAG_UNLOCKED_DEVICE_REQUIRED = 509
 
     // --- Attestation and Application Info ---
     const val TAG_APPLICATION_ID = 601

From 3078ea9db9ac7a246f120a5743fa796e82cee9c1 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 17:57:12 +0100
Subject: [PATCH 19/56] Implement AOSP enforcements.rs authorize_create for
 software operations

Software-generated keys now enforce the same operation policies as
AOSP keystore2's authorize_create():

- Missing PURPOSE rejected with INVALID_ARGUMENT (-38)
- Incompatible PURPOSE rejected with INCOMPATIBLE_PURPOSE (-3)
- Forced operations rejected with PERMISSION_DENIED (6)
- ACTIVE_DATETIME in future rejected with KEY_NOT_YET_VALID (-24)
- ORIGINATION_EXPIRE past rejected with KEY_EXPIRED (-25) for SIGN/ENCRYPT
- USAGE_EXPIRE past rejected with KEY_EXPIRED (-25) for DECRYPT/VERIFY
- CALLER_NONCE without permission rejected with CALLER_NONCE_PROHIBITED (-55)
- USAGE_COUNT_LIMIT enforced on finish via callback; key deleted on exhaustion

Store KeyMintAttestation in GeneratedKeyInfo so enforcement checks can
access the original key parameters during createOperation.
---
 .../keystore/Keystore2Interceptor.kt          |   1 +
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 124 +++++++++++++++---
 2 files changed, 106 insertions(+), 19 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 259c1252..1516d6b5 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -263,6 +263,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                                 keyData.first,
                                 newNspace,
                                 response,
+                                parsedParameters,
                             )
                         KeyMintSecurityLevelInterceptor.attestationKeys.add(keyId)
                         return InterceptorUtils.createTypedObjectReply(response)
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index e432f207..6fab235b 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -3,6 +3,7 @@ package org.matrix.TEESimulator.interception.keystore.shim
 import android.hardware.security.keymint.KeyOrigin
 import android.hardware.security.keymint.KeyParameter
 import android.hardware.security.keymint.KeyParameterValue
+import android.hardware.security.keymint.KeyPurpose
 import android.hardware.security.keymint.SecurityLevel
 import android.hardware.security.keymint.Tag
 import android.os.IBinder
@@ -37,6 +38,7 @@ class KeyMintSecurityLevelInterceptor(
         val keyPair: KeyPair,
         val nspace: Long,
         val response: KeyEntryResponse,
+        val keyParams: KeyMintAttestation,
     )
 
     override fun onPreTransact(
@@ -228,33 +230,107 @@ class KeyMintSecurityLevelInterceptor(
 
         SystemLogger.info("[TX_ID: $txId] Creating SOFTWARE operation for KeyId $nspace.")
 
-        val params = data.createTypedArray(KeyParameter.CREATOR)!!
-        val parsedParams = KeyMintAttestation(params)
-
-        // Validate the requested purpose against the key's allowed purposes,
-        // matching AOSP enforcements.rs authorize_create behavior.
-        val requestedPurpose = parsedParams.purpose.firstOrNull()
-        val keyResponse = generatedKeyInfo.response
-        val keyAuthorizations =
-            keyResponse.metadata?.authorizations?.map { it.keyParameter.tag to it.keyParameter }
-        val allowedPurposes =
-            keyAuthorizations
-                ?.filter { it.first == Tag.PURPOSE }
-                ?.map { it.second.value.keyPurpose }
-                ?: emptyList()
-
-        if (requestedPurpose != null && requestedPurpose !in allowedPurposes) {
+        val opParams = data.createTypedArray(KeyParameter.CREATOR)!!
+        val parsedOpParams = KeyMintAttestation(opParams)
+        val forced = data.readBoolean()
+
+        // --- AOSP enforcements.rs authorize_create() equivalent ---
+        val keyParams = generatedKeyInfo.keyParams
+
+        // F14: Missing PURPOSE → INVALID_ARGUMENT (-38)
+        val requestedPurpose = parsedOpParams.purpose.firstOrNull()
+        if (requestedPurpose == null) {
+            return InterceptorUtils.createServiceSpecificErrorReply(
+                KeystoreErrorCode.INVALID_ARGUMENT
+            )
+        }
+
+        // F9: Forced op without permission → PERMISSION_DENIED (6)
+        if (forced) {
+            return InterceptorUtils.createServiceSpecificErrorReply(
+                KeystoreErrorCode.PERMISSION_DENIED
+            )
+        }
+
+        // F1: PURPOSE not in key's allowed purposes → INCOMPATIBLE_PURPOSE (-3)
+        if (requestedPurpose !in keyParams.purpose) {
             SystemLogger.info(
-                "[TX_ID: $txId] Rejecting operation: purpose $requestedPurpose not in $allowedPurposes"
+                "[TX_ID: $txId] Rejecting: purpose $requestedPurpose not in ${keyParams.purpose}"
             )
             return InterceptorUtils.createServiceSpecificErrorReply(
                 KeystoreErrorCode.INCOMPATIBLE_PURPOSE
             )
         }
 
+        // F4: ACTIVE_DATETIME — KEY_NOT_YET_VALID (-24)
+        keyParams.activeDateTime?.let { activeDate ->
+            if (System.currentTimeMillis() < activeDate.time) {
+                return InterceptorUtils.createServiceSpecificErrorReply(
+                    KeystoreErrorCode.KEY_NOT_YET_VALID
+                )
+            }
+        }
+
+        // F2: ORIGINATION_EXPIRE_DATETIME — KEY_EXPIRED (-25) for SIGN/ENCRYPT only
+        keyParams.originationExpireDateTime?.let { expireDate ->
+            if (
+                (requestedPurpose == KeyPurpose.SIGN ||
+                    requestedPurpose == KeyPurpose.ENCRYPT) &&
+                    System.currentTimeMillis() > expireDate.time
+            ) {
+                return InterceptorUtils.createServiceSpecificErrorReply(
+                    KeystoreErrorCode.KEY_EXPIRED
+                )
+            }
+        }
+
+        // F3: USAGE_EXPIRE_DATETIME — KEY_EXPIRED (-25) for DECRYPT/VERIFY only
+        keyParams.usageExpireDateTime?.let { expireDate ->
+            if (
+                (requestedPurpose == KeyPurpose.DECRYPT ||
+                    requestedPurpose == KeyPurpose.VERIFY) &&
+                    System.currentTimeMillis() > expireDate.time
+            ) {
+                return InterceptorUtils.createServiceSpecificErrorReply(
+                    KeystoreErrorCode.KEY_EXPIRED
+                )
+            }
+        }
+
+        // F7: CALLER_NONCE — CALLER_NONCE_PROHIBITED (-55)
+        if (
+            (requestedPurpose == KeyPurpose.SIGN || requestedPurpose == KeyPurpose.ENCRYPT) &&
+                keyParams.callerNonce != true &&
+                opParams.any { it.tag == Tag.NONCE }
+        ) {
+            return InterceptorUtils.createServiceSpecificErrorReply(
+                KeystoreErrorCode.CALLER_NONCE_PROHIBITED
+            )
+        }
+
         return runCatching {
                 val softwareOperation =
-                    SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedParams)
+                    SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedOpParams)
+
+                // F11: USAGE_COUNT_LIMIT — decrement on finish, delete key when exhausted
+                keyParams.usageCountLimit?.let { limit ->
+                    val keyId =
+                        generatedKeys.entries
+                            .find { it.value === generatedKeyInfo }
+                            ?.key ?: return@let
+                    val remaining =
+                        usageCounters.getOrPut(keyId) {
+                            java.util.concurrent.atomic.AtomicInteger(limit)
+                        }
+                    softwareOperation.onFinishCallback = {
+                        if (remaining.decrementAndGet() <= 0) {
+                            cleanupKeyData(keyId)
+                            usageCounters.remove(keyId)
+                            SystemLogger.info("Key $keyId exhausted (USAGE_COUNT_LIMIT=$limit).")
+                        }
+                    }
+                }
+
                 val operationBinder = SoftwareOperationBinder(softwareOperation)
 
                 val response =
@@ -336,7 +412,12 @@ class KeyMintSecurityLevelInterceptor(
                             keyDescriptor,
                         )
                     generatedKeys[keyId] =
-                        GeneratedKeyInfo(keyData.first, keyDescriptor.nspace, response)
+                        GeneratedKeyInfo(
+                            keyData.first,
+                            keyDescriptor.nspace,
+                            response,
+                            parsedParams,
+                        )
                     if (isAttestKeyRequest) attestationKeys.add(keyId)
 
                     // Return the metadata of our generated key, skipping the real hardware call.
@@ -417,6 +498,9 @@ class KeyMintSecurityLevelInterceptor(
         val attestationKeys = ConcurrentHashMap.newKeySet<KeyIdentifier>()
         // Caches patched certificate chains to prevent re-generation and signature inconsistencies.
         val patchedChains = ConcurrentHashMap<KeyIdentifier, Array<Certificate>>()
+        // Tracks remaining usage count per key for USAGE_COUNT_LIMIT enforcement.
+        private val usageCounters =
+            ConcurrentHashMap<KeyIdentifier, java.util.concurrent.atomic.AtomicInteger>()
         // Stores interceptors for active cryptographic operations.
         private val interceptedOperations = ConcurrentHashMap<IBinder, OperationInterceptor>()
 
@@ -456,6 +540,7 @@ class KeyMintSecurityLevelInterceptor(
             if (attestationKeys.remove(keyId)) {
                 SystemLogger.debug("Remove cached attestaion key ${keyId}")
             }
+            usageCounters.remove(keyId)
         }
 
         fun removeOperationInterceptor(operationBinder: IBinder, backdoor: IBinder) {
@@ -474,6 +559,7 @@ class KeyMintSecurityLevelInterceptor(
             generatedKeys.clear()
             patchedChains.clear()
             attestationKeys.clear()
+            usageCounters.clear()
             SystemLogger.info("Cleared all cached keys ($count entries)$reasonMessage.")
         }
     }

From 890ee705152cc33e459d0dac2a87f119f9ec8c5a Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 18:10:59 +0100
Subject: [PATCH 20/56] Handle Domain.APP in createOperation for
 software-generated keys

handleCreateOperation only accepted Domain.KEY_ID descriptors, rejecting
Domain.APP with ContinueAndSkipPost. Native callers and the Android
framework can call createOperation with Domain.APP + alias, which was
being forwarded to hardware where the software-generated key doesn't
exist, resulting in KEY_NOT_FOUND for all operation enforcement tests.

Add alias-based lookup from generatedKeys when domain is APP, matching
AOSP's create_operation which resolves all domain types via database.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 26 ++++++++++++-------
 1 file changed, 17 insertions(+), 9 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 6fab235b..ecc7dba7 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -213,22 +213,30 @@ class KeyMintSecurityLevelInterceptor(
         data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
         val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
 
-        // An operation must use the KEY_ID domain.
-        if (keyDescriptor.domain != Domain.KEY_ID) {
-            return TransactionResult.ContinueAndSkipPost
-        }
-
-        val nspace = keyDescriptor.nspace
-        val generatedKeyInfo = findGeneratedKeyByKeyId(callingUid, nspace)
+        // AOSP createOperation accepts Domain::APP (alias), Domain::KEY_ID (nspace),
+        // Domain::SELINUX, and Domain::BLOB. Resolve to our generated key by trying
+        // both alias-based and nspace-based lookups.
+        val generatedKeyInfo =
+            when (keyDescriptor.domain) {
+                Domain.KEY_ID -> findGeneratedKeyByKeyId(callingUid, keyDescriptor.nspace)
+                Domain.APP ->
+                    keyDescriptor.alias?.let { alias ->
+                        generatedKeys[KeyIdentifier(callingUid, alias)]
+                    }
+                else -> null
+            }
 
         if (generatedKeyInfo == null) {
             SystemLogger.debug(
-                "[TX_ID: $txId] Operation for unknown/hardware KeyId ($nspace). Forwarding."
+                "[TX_ID: $txId] Operation for unknown/hardware key (domain=${keyDescriptor.domain}, " +
+                    "alias=${keyDescriptor.alias}, nspace=${keyDescriptor.nspace}). Forwarding."
             )
             return TransactionResult.Continue
         }
 
-        SystemLogger.info("[TX_ID: $txId] Creating SOFTWARE operation for KeyId $nspace.")
+        SystemLogger.info(
+            "[TX_ID: $txId] Creating SOFTWARE operation for key ${generatedKeyInfo.nspace}."
+        )
 
         val opParams = data.createTypedArray(KeyParameter.CREATOR)!!
         val parsedOpParams = KeyMintAttestation(opParams)

From 2bc46beac5e7bf645527e72a78d8437f50691ec6 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <52679407+MhmRdd@users.noreply.github.com>
Date: Wed, 18 Mar 2026 18:20:09 +0100
Subject: [PATCH 21/56] Fix UNSUPPORTED_PURPOSE for EC VERIFY/ENCRYPT and
 USAGE_COUNT_LIMIT

AOSP rejects VERIFY and ENCRYPT for asymmetric keys (EC/RSA) at the HAL
level with UNSUPPORTED_PURPOSE (-2), distinct from INCOMPATIBLE_PURPOSE
(-3) which applies when the purpose isn't in the key's authorized list.
Add algorithm-level check before purpose-list check.

Fix USAGE_COUNT_LIMIT tracking: use nspace comparison instead of
identity comparison for key lookup, and check exhaustion before creating
the operation to return KEY_NOT_FOUND when the limit is reached.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 24 +++++++++++++++++--
 1 file changed, 22 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index ecc7dba7..3c90b68f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -1,5 +1,6 @@
 package org.matrix.TEESimulator.interception.keystore.shim
 
+import android.hardware.security.keymint.Algorithm
 import android.hardware.security.keymint.KeyOrigin
 import android.hardware.security.keymint.KeyParameter
 import android.hardware.security.keymint.KeyParameterValue
@@ -260,6 +261,18 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
+        // F8/F13: AOSP rejects VERIFY/ENCRYPT for asymmetric keys at the HAL level
+        // with UNSUPPORTED_PURPOSE (-2), distinct from INCOMPATIBLE_PURPOSE (-3).
+        val algorithm = keyParams.algorithm
+        if (
+            (algorithm == Algorithm.EC || algorithm == Algorithm.RSA) &&
+                (requestedPurpose == KeyPurpose.VERIFY || requestedPurpose == KeyPurpose.ENCRYPT)
+        ) {
+            return InterceptorUtils.createServiceSpecificErrorReply(
+                KeystoreErrorCode.UNSUPPORTED_PURPOSE
+            )
+        }
+
         // F1: PURPOSE not in key's allowed purposes → INCOMPATIBLE_PURPOSE (-3)
         if (requestedPurpose !in keyParams.purpose) {
             SystemLogger.info(
@@ -320,16 +333,23 @@ class KeyMintSecurityLevelInterceptor(
                 val softwareOperation =
                     SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedOpParams)
 
-                // F11: USAGE_COUNT_LIMIT — decrement on finish, delete key when exhausted
+                // F11: USAGE_COUNT_LIMIT — decrement on finish, delete key when exhausted.
+                // AOSP tracks this in database via check_and_update_key_usage_count on after_finish.
                 keyParams.usageCountLimit?.let { limit ->
                     val keyId =
                         generatedKeys.entries
-                            .find { it.value === generatedKeyInfo }
+                            .find { it.value.nspace == generatedKeyInfo.nspace }
                             ?.key ?: return@let
                     val remaining =
                         usageCounters.getOrPut(keyId) {
                             java.util.concurrent.atomic.AtomicInteger(limit)
                         }
+                    // Check if already exhausted before creating the operation
+                    if (remaining.get() <= 0) {
+                        cleanupKeyData(keyId)
+                        usageCounters.remove(keyId)
+                        throw android.os.ServiceSpecificException(KeystoreErrorCode.KEY_NOT_FOUND)
+                    }
                     softwareOperation.onFinishCallback = {
                         if (remaining.decrementAndGet() <= 0) {
                             cleanupKeyData(keyId)

From 400df41674ad18c7c243a4ef2de1e3798d00e218 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 18:39:35 +0100
Subject: [PATCH 22/56] Remove verbose AOSP references and test-label comments

---
 .../attestation/AttestationBuilder.kt         |  3 +-
 .../interception/keystore/InterceptorUtils.kt |  2 +-
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 30 +++++-----------
 .../keystore/shim/SoftwareOperation.kt        | 35 ++-----------------
 .../TEESimulator/pki/CertificateGenerator.kt  |  7 ++--
 5 files changed, 15 insertions(+), 62 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 380b3699..28cc468b 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -387,8 +387,7 @@ object AttestationBuilder {
             )
         )
 
-        // AOSP add_required_parameters (security_level.rs) only adds
-        // ATTESTATION_APPLICATION_ID when an attestation challenge is present.
+        // ATTESTATION_APPLICATION_ID is only included when an attestation challenge is present.
         if (params.attestationChallenge != null) {
             list.add(
                 DERTaggedObject(
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
index 161e85ed..d404eef5 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
@@ -120,7 +120,7 @@ object InterceptorUtils {
 
     /**
      * Creates an `OverrideReply` that writes a `ServiceSpecificException` with the given error
-     * code, matching AOSP's `into_binder()` wire format (EX_SERVICE_SPECIFIC).
+     * code via EX_SERVICE_SPECIFIC.
      */
     fun createServiceSpecificErrorReply(
         errorCode: Int
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 3c90b68f..8f1d618f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -214,9 +214,7 @@ class KeyMintSecurityLevelInterceptor(
         data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
         val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
 
-        // AOSP createOperation accepts Domain::APP (alias), Domain::KEY_ID (nspace),
-        // Domain::SELINUX, and Domain::BLOB. Resolve to our generated key by trying
-        // both alias-based and nspace-based lookups.
+        // Resolve key descriptor to a generated key via nspace (KEY_ID) or alias (APP).
         val generatedKeyInfo =
             when (keyDescriptor.domain) {
                 Domain.KEY_ID -> findGeneratedKeyByKeyId(callingUid, keyDescriptor.nspace)
@@ -243,10 +241,8 @@ class KeyMintSecurityLevelInterceptor(
         val parsedOpParams = KeyMintAttestation(opParams)
         val forced = data.readBoolean()
 
-        // --- AOSP enforcements.rs authorize_create() equivalent ---
         val keyParams = generatedKeyInfo.keyParams
 
-        // F14: Missing PURPOSE → INVALID_ARGUMENT (-38)
         val requestedPurpose = parsedOpParams.purpose.firstOrNull()
         if (requestedPurpose == null) {
             return InterceptorUtils.createServiceSpecificErrorReply(
@@ -254,15 +250,13 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
-        // F9: Forced op without permission → PERMISSION_DENIED (6)
         if (forced) {
             return InterceptorUtils.createServiceSpecificErrorReply(
                 KeystoreErrorCode.PERMISSION_DENIED
             )
         }
 
-        // F8/F13: AOSP rejects VERIFY/ENCRYPT for asymmetric keys at the HAL level
-        // with UNSUPPORTED_PURPOSE (-2), distinct from INCOMPATIBLE_PURPOSE (-3).
+        // Asymmetric keys reject VERIFY/ENCRYPT at the HAL level (UNSUPPORTED_PURPOSE).
         val algorithm = keyParams.algorithm
         if (
             (algorithm == Algorithm.EC || algorithm == Algorithm.RSA) &&
@@ -273,7 +267,6 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
-        // F1: PURPOSE not in key's allowed purposes → INCOMPATIBLE_PURPOSE (-3)
         if (requestedPurpose !in keyParams.purpose) {
             SystemLogger.info(
                 "[TX_ID: $txId] Rejecting: purpose $requestedPurpose not in ${keyParams.purpose}"
@@ -283,7 +276,6 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
-        // F4: ACTIVE_DATETIME — KEY_NOT_YET_VALID (-24)
         keyParams.activeDateTime?.let { activeDate ->
             if (System.currentTimeMillis() < activeDate.time) {
                 return InterceptorUtils.createServiceSpecificErrorReply(
@@ -292,7 +284,7 @@ class KeyMintSecurityLevelInterceptor(
             }
         }
 
-        // F2: ORIGINATION_EXPIRE_DATETIME — KEY_EXPIRED (-25) for SIGN/ENCRYPT only
+        // ORIGINATION_EXPIRE applies to SIGN/ENCRYPT only.
         keyParams.originationExpireDateTime?.let { expireDate ->
             if (
                 (requestedPurpose == KeyPurpose.SIGN ||
@@ -305,7 +297,7 @@ class KeyMintSecurityLevelInterceptor(
             }
         }
 
-        // F3: USAGE_EXPIRE_DATETIME — KEY_EXPIRED (-25) for DECRYPT/VERIFY only
+        // USAGE_EXPIRE applies to DECRYPT/VERIFY only.
         keyParams.usageExpireDateTime?.let { expireDate ->
             if (
                 (requestedPurpose == KeyPurpose.DECRYPT ||
@@ -318,7 +310,6 @@ class KeyMintSecurityLevelInterceptor(
             }
         }
 
-        // F7: CALLER_NONCE — CALLER_NONCE_PROHIBITED (-55)
         if (
             (requestedPurpose == KeyPurpose.SIGN || requestedPurpose == KeyPurpose.ENCRYPT) &&
                 keyParams.callerNonce != true &&
@@ -333,8 +324,7 @@ class KeyMintSecurityLevelInterceptor(
                 val softwareOperation =
                     SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedOpParams)
 
-                // F11: USAGE_COUNT_LIMIT — decrement on finish, delete key when exhausted.
-                // AOSP tracks this in database via check_and_update_key_usage_count on after_finish.
+                // Decrement usage counter on finish; delete key when exhausted.
                 keyParams.usageCountLimit?.let { limit ->
                     val keyId =
                         generatedKeys.entries
@@ -393,8 +383,7 @@ class KeyMintSecurityLevelInterceptor(
                 )
                 val params = data.createTypedArray(KeyParameter.CREATOR)!!
 
-                // AOSP add_required_parameters rejects caller-provided CREATION_DATETIME
-                // with INVALID_ARGUMENT. (security_level.rs:425-430)
+                // Caller-provided CREATION_DATETIME is not allowed.
                 if (params.any { it.tag == Tag.CREATION_DATETIME }) {
                     return@runCatching InterceptorUtils.createServiceSpecificErrorReply(
                         INVALID_ARGUMENT
@@ -495,8 +484,7 @@ class KeyMintSecurityLevelInterceptor(
     companion object {
         private val secureRandom = SecureRandom()
 
-        // AOSP ResponseCode / ErrorCode constants used for ServiceSpecificException.
-        private const val INVALID_ARGUMENT = 20 // Keystore2 ResponseCode::INVALID_ARGUMENT
+        private const val INVALID_ARGUMENT = 20
 
         // Transaction codes for IKeystoreSecurityLevel interface.
         private val GENERATE_KEY_TRANSACTION =
@@ -678,9 +666,7 @@ private fun KeyMintAttestation.toAuthorizations(
         createAuth(Tag.CREATION_DATETIME, KeyParameterValue.dateTime(System.currentTimeMillis()))
     )
 
-    // AOSP keystore2 adds USER_ID at SecurityLevel.SOFTWARE (not TEE), since the
-    // application UID is a software concept. See AOSP security_level.rs store_new_key().
-    // AOSP class android.os.UserHandle: PER_USER_RANGE = 100000;
+    // USER_ID is a software-level property. PER_USER_RANGE = 100000.
     authList.add(
         Authorization().apply {
             this.keyParameter =
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index 7c8e6346..d8dca748 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -20,33 +20,15 @@ import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.logging.KeyMintParameterLogger
 import org.matrix.TEESimulator.logging.SystemLogger
 
-/**
- * AOSP keystore2 error codes used in ServiceSpecificException. Negative values are KeyMint
- * ErrorCode constants; positive values are Keystore2 ResponseCode constants. See AOSP error.rs.
- */
+/** Keystore2 error codes for ServiceSpecificException. Negative = KeyMint, positive = Keystore. */
 internal object KeystoreErrorCode {
-    /** KeyMint ErrorCode::INVALID_OPERATION_HANDLE */
     const val INVALID_OPERATION_HANDLE = -28
-
-    /** KeyMint ErrorCode::VERIFICATION_FAILED */
     const val VERIFICATION_FAILED = -30
-
-    /** KeyMint ErrorCode::UNSUPPORTED_PURPOSE */
     const val UNSUPPORTED_PURPOSE = -2
-
-    /** KeyMint ErrorCode::INCOMPATIBLE_PURPOSE */
     const val INCOMPATIBLE_PURPOSE = -3
-
-    /** Keystore2 ResponseCode::SYSTEM_ERROR */
     const val SYSTEM_ERROR = 4
-
-    /** Keystore2 ResponseCode::TOO_MUCH_DATA */
     const val TOO_MUCH_DATA = 21
-
-    /** KeyMint ErrorCode::KEY_EXPIRED */
     const val KEY_EXPIRED = -25
-
-    /** KeyMint ErrorCode::KEY_NOT_YET_VALID */
     const val KEY_NOT_YET_VALID = -24
 
     /** KeyMint ErrorCode::CALLER_NONCE_PROHIBITED */
@@ -225,8 +207,7 @@ private class CipherPrimitive(
  * delegating to a specific cryptographic primitive based on the operation's purpose.
  *
  * Tracks operation lifecycle: once [finish] or [abort] is called, subsequent calls throw
- * [ServiceSpecificException] with [KeystoreErrorCode.INVALID_OPERATION_HANDLE], matching AOSP
- * keystore2 behavior (operation.rs check_active).
+ * [ServiceSpecificException] with [KeystoreErrorCode.INVALID_OPERATION_HANDLE].
  */
 class SoftwareOperation(
     private val txId: Long,
@@ -327,16 +308,7 @@ class SoftwareOperation(
     }
 }
 
-/**
- * The Binder interface for [SoftwareOperation].
- *
- * All methods are synchronized to prevent concurrent access, matching AOSP's Mutex-protected
- * KeystoreOperation wrapper. Input data is validated against [MAX_RECEIVE_DATA] (32KB) to match
- * AOSP's enforced limit.
- *
- * All errors are reported as [ServiceSpecificException] with AOSP-compatible numeric error codes,
- * matching the wire format produced by AOSP's `into_binder()` in error.rs.
- */
+/** Binder interface for [SoftwareOperation]. Synchronized and input-length validated. */
 class SoftwareOperationBinder(private val operation: SoftwareOperation) :
     IKeystoreOperation.Stub() {
 
@@ -376,7 +348,6 @@ class SoftwareOperationBinder(private val operation: SoftwareOperation) :
     }
 
     companion object {
-        // AOSP operation.rs MAX_RECEIVE_DATA = 0x8000
         private const val MAX_RECEIVE_DATA = 0x8000
     }
 }
diff --git a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
index e8ec69b7..000f537e 100644
--- a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
@@ -35,8 +35,7 @@ import org.matrix.TEESimulator.logging.SystemLogger
  */
 object CertificateGenerator {
 
-    // AOSP utils.rs: pub const UNDEFINED_NOT_AFTER: i64 = 253402300799000i64;
-    // RFC 5280 GeneralizedTime maximum: 9999-12-31T23:59:59 UTC (millis since epoch)
+    // RFC 5280 GeneralizedTime maximum: 9999-12-31T23:59:59 UTC (millis since epoch).
     private const val UNDEFINED_NOT_AFTER = 253402300799000L
 
     /**
@@ -223,9 +222,7 @@ object CertificateGenerator {
     ): Certificate {
         val subject = params.certificateSubject ?: X500Name("CN=Android Keystore Key")
 
-        // AOSP add_required_parameters (security_level.rs) defaults:
-        //   CERTIFICATE_NOT_BEFORE = 0 (Unix epoch)
-        //   CERTIFICATE_NOT_AFTER  = 253402300799000 (9999-12-31T23:59:59 UTC)
+        // Default validity: epoch to 9999-12-31T23:59:59 UTC (matches add_required_parameters).
         val notBefore = params.certificateNotBefore ?: Date(0)
         val notAfter = params.certificateNotAfter ?: Date(UNDEFINED_NOT_AFTER)
 

From 07c98bcd06487209e9cc5e640165c11193575cfb Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 18:45:58 +0100
Subject: [PATCH 23/56] Reject device ID attestation tags, fix operation param
 merging and usage tracking

Reject ATTESTATION_ID_SERIAL, ATTESTATION_ID_IMEI, ATTESTATION_ID_MEID,
and DEVICE_UNIQUE_ATTESTATION in generateKey with CANNOT_ATTEST_IDS
(-66), since normal apps lack READ_PRIVILEGED_PHONE_STATE.

Fix createOperation to merge key params with operation params when
constructing SoftwareOperation: use the key's algorithm/digest for
crypto, but the operation's purpose. Previously, missing DIGEST in
operation params caused signature algorithm resolution to fail.

Fix USAGE_COUNT_LIMIT by resolving KeyIdentifier during key lookup
instead of re-searching generatedKeys by nspace inside the let block.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 57 +++++++++++++------
 1 file changed, 41 insertions(+), 16 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 8f1d618f..c493ad52 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -215,15 +215,25 @@ class KeyMintSecurityLevelInterceptor(
         val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
 
         // Resolve key descriptor to a generated key via nspace (KEY_ID) or alias (APP).
-        val generatedKeyInfo =
+        val resolvedEntry: Map.Entry<KeyIdentifier, GeneratedKeyInfo>? =
             when (keyDescriptor.domain) {
-                Domain.KEY_ID -> findGeneratedKeyByKeyId(callingUid, keyDescriptor.nspace)
+                Domain.KEY_ID -> {
+                    val nspace = keyDescriptor.nspace
+                    if (nspace == null || nspace == 0L) null
+                    else
+                        generatedKeys.entries
+                            .filter { it.key.uid == callingUid }
+                            .find { it.value.nspace == nspace }
+                }
                 Domain.APP ->
                     keyDescriptor.alias?.let { alias ->
-                        generatedKeys[KeyIdentifier(callingUid, alias)]
+                        val key = KeyIdentifier(callingUid, alias)
+                        generatedKeys[key]?.let { java.util.AbstractMap.SimpleEntry(key, it) }
                     }
                 else -> null
             }
+        val generatedKeyInfo = resolvedEntry?.value
+        val resolvedKeyId = resolvedEntry?.key
 
         if (generatedKeyInfo == null) {
             SystemLogger.debug(
@@ -321,30 +331,29 @@ class KeyMintSecurityLevelInterceptor(
         }
 
         return runCatching {
+                // Use key params for crypto properties (algorithm, digest, etc.) but
+                // override purpose from the operation params.
+                val effectiveParams =
+                    keyParams.copy(purpose = parsedOpParams.purpose, digest = parsedOpParams.digest.ifEmpty { keyParams.digest })
                 val softwareOperation =
-                    SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedOpParams)
+                    SoftwareOperation(txId, generatedKeyInfo.keyPair, effectiveParams)
 
                 // Decrement usage counter on finish; delete key when exhausted.
-                keyParams.usageCountLimit?.let { limit ->
-                    val keyId =
-                        generatedKeys.entries
-                            .find { it.value.nspace == generatedKeyInfo.nspace }
-                            ?.key ?: return@let
+                if (keyParams.usageCountLimit != null && resolvedKeyId != null) {
+                    val limit = keyParams.usageCountLimit
                     val remaining =
-                        usageCounters.getOrPut(keyId) {
+                        usageCounters.getOrPut(resolvedKeyId) {
                             java.util.concurrent.atomic.AtomicInteger(limit)
                         }
-                    // Check if already exhausted before creating the operation
                     if (remaining.get() <= 0) {
-                        cleanupKeyData(keyId)
-                        usageCounters.remove(keyId)
+                        cleanupKeyData(resolvedKeyId)
+                        usageCounters.remove(resolvedKeyId)
                         throw android.os.ServiceSpecificException(KeystoreErrorCode.KEY_NOT_FOUND)
                     }
                     softwareOperation.onFinishCallback = {
                         if (remaining.decrementAndGet() <= 0) {
-                            cleanupKeyData(keyId)
-                            usageCounters.remove(keyId)
-                            SystemLogger.info("Key $keyId exhausted (USAGE_COUNT_LIMIT=$limit).")
+                            cleanupKeyData(resolvedKeyId)
+                            usageCounters.remove(resolvedKeyId)
                         }
                     }
                 }
@@ -390,6 +399,21 @@ class KeyMintSecurityLevelInterceptor(
                     )
                 }
 
+                // Device ID attestation requires READ_PRIVILEGED_PHONE_STATE which
+                // normal apps lack.
+                if (
+                    params.any {
+                        it.tag == Tag.ATTESTATION_ID_SERIAL ||
+                            it.tag == Tag.ATTESTATION_ID_IMEI ||
+                            it.tag == Tag.ATTESTATION_ID_MEID ||
+                            it.tag == Tag.DEVICE_UNIQUE_ATTESTATION
+                    }
+                ) {
+                    return@runCatching InterceptorUtils.createServiceSpecificErrorReply(
+                        CANNOT_ATTEST_IDS
+                    )
+                }
+
                 val parsedParams = KeyMintAttestation(params)
                 val isAttestKeyRequest = parsedParams.isAttestKey()
 
@@ -485,6 +509,7 @@ class KeyMintSecurityLevelInterceptor(
         private val secureRandom = SecureRandom()
 
         private const val INVALID_ARGUMENT = 20
+        private const val CANNOT_ATTEST_IDS = -66
 
         // Transaction codes for IKeystoreSecurityLevel interface.
         private val GENERATE_KEY_TRANSACTION =

From ca3fcbc3885a9ddf52a2748b0c6f4fdd6386e45a Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 19:02:09 +0100
Subject: [PATCH 24/56] Filter intercepted transaction codes at native level to
 reduce latency

Previously, every transaction on a registered binder was hijacked to the
BinderStub and round-tripped through Java, even for codes the
interceptor immediately returns ContinueAndSkipPost on. This added
measurable binder latency detectable by timing-based checks.

Add transaction code filtering to the native RegistrationEntry. When
registering an interceptor, callers can now specify which codes to
intercept. Non-matching codes pass through the ioctl hook without any
hijacking, BinderStub dispatch, or Java round-trip.

- IKeystoreService: only intercept getKeyEntry, deleteKey,
  updateSubcomponent, listEntries, listEntriesBatched
- IKeystoreSecurityLevel: only intercept generateKey, importKey,
  createOperation
- IKeystoreOperation: only intercept finish, abort
---
 app/src/main/cpp/binder_interceptor.cpp       | 33 +++++++++++++++----
 .../interception/core/BinderInterceptor.kt    | 18 ++++++++--
 .../keystore/AbstractKeystoreInterceptor.kt   |  8 ++++-
 .../keystore/Keystore2Interceptor.kt          | 25 ++++++++++++--
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 11 ++++++-
 .../keystore/shim/OperationInterceptor.kt     |  3 ++
 6 files changed, 85 insertions(+), 13 deletions(-)

diff --git a/app/src/main/cpp/binder_interceptor.cpp b/app/src/main/cpp/binder_interceptor.cpp
index bc2b2b5f..8eef4ed7 100644
--- a/app/src/main/cpp/binder_interceptor.cpp
+++ b/app/src/main/cpp/binder_interceptor.cpp
@@ -235,6 +235,8 @@ class BinderInterceptor : public BBinder {
     struct RegistrationEntry {
         wp<IBinder> target;
         sp<IBinder> callback_interface;
+        // Transaction codes to intercept. Empty = intercept all (legacy behavior).
+        std::vector<uint32_t> filtered_codes;
     };
 
     // Reader-Writer lock for the registry to allow concurrent reads (lookups)
@@ -244,10 +246,15 @@ class BinderInterceptor : public BBinder {
 public:
     BinderInterceptor() = default;
 
-    // Checks if a specific Binder instance is currently registered for interception
-    bool isBinderIntercepted(const wp<BBinder> &target) const {
+    // Checks if a specific Binder+code combination should be intercepted.
+    // Returns true if the binder is registered AND the code is in its filter
+    // (or the filter is empty, meaning intercept everything).
+    bool shouldIntercept(const wp<BBinder> &target, uint32_t code) const {
         std::shared_lock lock(registry_mutex_);
-        return registry_.find(target) != registry_.end();
+        auto it = registry_.find(target);
+        if (it == registry_.end()) return false;
+        const auto &codes = it->second.filtered_codes;
+        return codes.empty() || std::find(codes.begin(), codes.end(), code) != codes.end();
     }
 
     // Main entry point for processing the "Man-in-the-Middle" logic
@@ -386,7 +393,7 @@ void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
             // This is safe because we are holding a strong reference.
             wp<BBinder> wp_target = target_binder_ptr;
 
-            if (g_interceptor_instance->isBinderIntercepted(wp_target)) {
+            if (g_interceptor_instance->shouldIntercept(wp_target, txn_data->code)) {
                 info.transaction_code = txn_data->code;
                 info.target_binder = wp_target; // Assign the valid weak pointer
                 hijack = true;
@@ -537,12 +544,26 @@ status_t BinderInterceptor::handleRegister(const Parcel &data) {
         return BAD_TYPE;
     }
 
+    // Read optional transaction code filter. If present: int32 count + count * uint32 codes.
+    // If absent or count <= 0: intercept all transaction codes (legacy behavior).
+    std::vector<uint32_t> codes;
+    int32_t code_count = 0;
+    if (data.dataAvail() >= sizeof(int32_t) && data.readInt32(&code_count) == OK && code_count > 0) {
+        codes.reserve(code_count);
+        for (int32_t i = 0; i < code_count; i++) {
+            uint32_t c = 0;
+            if (data.readUint32(&c) == OK) codes.push_back(c);
+        }
+        LOGI("Interceptor registered for binder %p with %zu filtered codes", target.get(), codes.size());
+    } else {
+        LOGI("Interceptor registered for binder %p (all codes)", target.get());
+    }
+
     wp<IBinder> weak_target = target;
 
     std::unique_lock lock(registry_mutex_);
-    registry_[weak_target] = {weak_target, callback};
+    registry_[weak_target] = {weak_target, callback, std::move(codes)};
 
-    LOGI("Interceptor registered for binder %p", target.get());
     return OK;
 }
 
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt
index 370141b8..b5bc3900 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt
@@ -293,15 +293,27 @@ abstract class BinderInterceptor : Binder() {
             }
         }
 
-        /** Uses the backdoor binder to register an interceptor for a specific target service. */
-        fun register(backdoor: IBinder, target: IBinder, interceptor: BinderInterceptor) {
+        /**
+         * Uses the backdoor binder to register an interceptor for a specific target service.
+         *
+         * @param filteredCodes If non-empty, only these transaction codes will be intercepted at
+         *   the native level. All other codes pass through without the round-trip to Java.
+         */
+        fun register(
+            backdoor: IBinder,
+            target: IBinder,
+            interceptor: BinderInterceptor,
+            filteredCodes: IntArray = intArrayOf(),
+        ) {
             val data = Parcel.obtain()
             val reply = Parcel.obtain()
             try {
                 data.writeStrongBinder(target)
                 data.writeStrongBinder(interceptor)
+                data.writeInt(filteredCodes.size)
+                for (code in filteredCodes) data.writeInt(code)
                 backdoor.transact(REGISTER_INTERCEPTOR_CODE, data, reply, 0)
-                SystemLogger.info("Registered interceptor for target: $target")
+                SystemLogger.info("Registered interceptor for target: $target (${filteredCodes.size} filtered codes)")
             } catch (e: Exception) {
                 SystemLogger.error("Failed to register binder interceptor.", e)
             } finally {
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/AbstractKeystoreInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/AbstractKeystoreInterceptor.kt
index d080fb68..826dbabe 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/AbstractKeystoreInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/AbstractKeystoreInterceptor.kt
@@ -68,11 +68,17 @@ abstract class AbstractKeystoreInterceptor : BinderInterceptor() {
         }
     }
 
+    /**
+     * Transaction codes this interceptor needs to handle at the native level. Override in
+     * subclasses to filter; empty means intercept everything (legacy behavior).
+     */
+    protected open val interceptedCodes: IntArray = intArrayOf()
+
     /** Registers this interceptor with the native hook layer and sets up a death recipient. */
     private fun setupInterceptor(service: IBinder, backdoor: IBinder) {
         keystoreService = service
         SystemLogger.info("Registering interceptor for service: $serviceName")
-        register(backdoor, service, this)
+        register(backdoor, service, this, interceptedCodes)
         service.linkToDeath(createDeathRecipient(), 0)
         onInterceptorReady(service, backdoor)
     }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 1516d6b5..ce0092a6 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -57,6 +57,17 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
     override val processName = "keystore2"
     override val injectionCommand = "exec ./inject `pidof keystore2` libTEESimulator.so entry"
 
+    override val interceptedCodes: IntArray by lazy {
+        listOfNotNull(
+                GET_KEY_ENTRY_TRANSACTION,
+                DELETE_KEY_TRANSACTION,
+                UPDATE_SUBCOMPONENT_TRANSACTION,
+                LIST_ENTRIES_TRANSACTION,
+                LIST_ENTRIES_BATCHED_TRANSACTION,
+            )
+            .toIntArray()
+    }
+
     /**
      * This method is called once the main service is hooked. It proceeds to find and hook the
      * security level sub-services (e.g., TEE, StrongBox).
@@ -73,7 +84,12 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                     SystemLogger.info("Found TEE SecurityLevel. Registering interceptor...")
                     val interceptor =
                         KeyMintSecurityLevelInterceptor(tee, SecurityLevel.TRUSTED_ENVIRONMENT)
-                    register(backdoor, tee.asBinder(), interceptor)
+                    register(
+                        backdoor,
+                        tee.asBinder(),
+                        interceptor,
+                        KeyMintSecurityLevelInterceptor.INTERCEPTED_CODES,
+                    )
                 }
             }
             .onFailure { SystemLogger.error("Failed to intercept TEE SecurityLevel.", it) }
@@ -84,7 +100,12 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                     SystemLogger.info("Found StrongBox SecurityLevel. Registering interceptor...")
                     val interceptor =
                         KeyMintSecurityLevelInterceptor(strongbox, SecurityLevel.STRONGBOX)
-                    register(backdoor, strongbox.asBinder(), interceptor)
+                    register(
+                        backdoor,
+                        strongbox.asBinder(),
+                        interceptor,
+                        KeyMintSecurityLevelInterceptor.INTERCEPTED_CODES,
+                    )
                 }
             }
             .onFailure { SystemLogger.error("Failed to intercept StrongBox SecurityLevel.", it) }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index c493ad52..9546badf 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -155,7 +155,12 @@ class KeyMintSecurityLevelInterceptor(
                     val backdoor = getBackdoor(target)
                     if (backdoor != null) {
                         val interceptor = OperationInterceptor(operation, backdoor)
-                        register(backdoor, operationBinder, interceptor)
+                        register(
+                            backdoor,
+                            operationBinder,
+                            interceptor,
+                            OperationInterceptor.INTERCEPTED_CODES,
+                        )
                         interceptedOperations[operationBinder] = interceptor
                     } else {
                         SystemLogger.error(
@@ -522,6 +527,10 @@ class KeyMintSecurityLevelInterceptor(
                 "createOperation",
             )
 
+        /** Only these transaction codes need native-level interception. */
+        val INTERCEPTED_CODES =
+            intArrayOf(GENERATE_KEY_TRANSACTION, IMPORT_KEY_TRANSACTION, CREATE_OPERATION_TRANSACTION)
+
         private val transactionNames: Map<Int, String> by lazy {
             IKeystoreSecurityLevel.Stub::class
                 .java
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt
index 91e0dde6..adfd18db 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt
@@ -44,6 +44,9 @@ class OperationInterceptor(
         private val ABORT_TRANSACTION =
             InterceptorUtils.getTransactCode(IKeystoreOperation.Stub::class.java, "abort")
 
+        /** Only intercept finish/abort for cleanup. Other ops pass through without round-trip. */
+        val INTERCEPTED_CODES = intArrayOf(FINISH_TRANSACTION, ABORT_TRANSACTION)
+
         private val transactionNames: Map<Int, String> by lazy {
             IKeystoreOperation.Stub::class
                 .java

From ed987685e207d25fecfe0b05e6311c7e8d8f805b Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 19:18:31 +0100
Subject: [PATCH 25/56] Check READ_PRIVILEGED_PHONE_STATE before rejecting
 device ID attestation

Query PackageManager.checkPermission for the calling UID's packages
instead of using a hardcoded UID threshold. This correctly allows
system apps, privileged apps (e.g. GMS), and shell-level callers
that hold READ_PRIVILEGED_PHONE_STATE to attest device IDs, while
rejecting unprivileged apps that lack the permission.
---
 .../TEESimulator/config/ConfigurationManager.kt      | 12 ++++++++++++
 .../keystore/shim/KeyMintSecurityLevelInterceptor.kt | 11 ++++++++---
 .../java/android/content/pm/IPackageManager.java     |  2 ++
 3 files changed, 22 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
index dacda945..6847928e 100644
--- a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
@@ -351,6 +351,18 @@ object ConfigurationManager {
         return iPackageManager
     }
 
+    /** Checks if any package belonging to the UID holds the given permission. */
+    fun hasPermissionForUid(uid: Int, permission: String): Boolean {
+        val userId = uid / 100000
+        return getPackagesForUid(uid).any { pkg ->
+            try {
+                getPackageManager()?.checkPermission(permission, pkg, userId) == 0
+            } catch (_: Exception) {
+                false
+            }
+        }
+    }
+
     /** Retrieves the package names associated with a UID. */
     fun getPackagesForUid(uid: Int): Array<String> {
         return uidToPackagesCache.getOrPut(uid) {
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 9546badf..214ad503 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -404,15 +404,20 @@ class KeyMintSecurityLevelInterceptor(
                     )
                 }
 
-                // Device ID attestation requires READ_PRIVILEGED_PHONE_STATE which
-                // normal apps lack.
-                if (
+                // Device ID attestation requires READ_PRIVILEGED_PHONE_STATE.
+                val hasDeviceIdTags =
                     params.any {
                         it.tag == Tag.ATTESTATION_ID_SERIAL ||
                             it.tag == Tag.ATTESTATION_ID_IMEI ||
                             it.tag == Tag.ATTESTATION_ID_MEID ||
                             it.tag == Tag.DEVICE_UNIQUE_ATTESTATION
                     }
+                if (
+                    hasDeviceIdTags &&
+                        !ConfigurationManager.hasPermissionForUid(
+                            callingUid,
+                            "android.permission.READ_PRIVILEGED_PHONE_STATE",
+                        )
                 ) {
                     return@runCatching InterceptorUtils.createServiceSpecificErrorReply(
                         CANNOT_ATTEST_IDS
diff --git a/stub/src/main/java/android/content/pm/IPackageManager.java b/stub/src/main/java/android/content/pm/IPackageManager.java
index 2b0b97b6..7356f826 100644
--- a/stub/src/main/java/android/content/pm/IPackageManager.java
+++ b/stub/src/main/java/android/content/pm/IPackageManager.java
@@ -13,6 +13,8 @@ public interface IPackageManager {
 
     ParceledListSlice<PackageInfo> getInstalledPackages(long flags, int userId);
 
+    int checkPermission(String permName, String pkgName, int userId);
+
     class Stub {
         public static IPackageManager asInterface(IBinder binder) {
             throw new UnsupportedOperationException("STUB!");

From 9ffeda193a8e06dd6a7a93d84e489bfa50fc361a Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 19:26:00 +0100
Subject: [PATCH 26/56] Use hardcoded AndroidSystem AAID for system and root
 UIDs

AOSP keystore_attestation_id.cpp uses a fixed identity for AID_SYSTEM
(1000) and AID_ROOT (0): package "AndroidSystem", version 1, with no
signing certificate digests. TEESimulator was calling
getPackagesForUid(1000) which returns all shared-UID packages,
producing a completely different attestation application ID.

Revert the "system" target.txt entry since it's not a real package
name. The AAID for uid 1000 is now handled correctly in the
attestation builder regardless of target configuration.
---
 .../attestation/AttestationBuilder.kt         | 52 ++++++++++++-------
 .../config/ConfigurationManager.kt            | 22 ++++----
 2 files changed, 43 insertions(+), 31 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 28cc468b..18496fe2 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -434,6 +434,17 @@ object AttestationBuilder {
      */
     @Throws(Throwable::class)
     private fun createApplicationId(uid: Int): DEROctetString {
+        // AOSP keystore_attestation_id.cpp: gather_attestation_application_id()
+        // uses a hardcoded identity for AID_SYSTEM (1000) and AID_ROOT (0):
+        //   packageName = "AndroidSystem", versionCode = 1, no signing digests.
+        val appUid = uid % 100000
+        if (appUid == 0 || appUid == 1000) {
+            return buildApplicationIdDer(
+                listOf("AndroidSystem" to 1L),
+                emptySet(),
+            )
+        }
+
         val pm =
             ConfigurationManager.getPackageManager()
                 ?: throw IllegalStateException("PackageManager not found!")
@@ -441,12 +452,11 @@ object AttestationBuilder {
             pm.getPackagesForUid(uid) ?: throw IllegalStateException("No packages for UID $uid")
 
         val sha256 = MessageDigest.getInstance("SHA-256")
-        val packageInfoList = mutableListOf<DERSequence>()
+        val packageInfoList = mutableListOf<Pair<String, Long>>()
         val signatureDigests = mutableSetOf<Digest>()
 
-        // Process all packages associated with the UID in a single loop.
+        val userId = uid / 100000
         packages.forEach { packageName ->
-            val userId = uid / 100000
             val packageInfo =
                 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                     pm.getPackageInfo(
@@ -459,34 +469,36 @@ object AttestationBuilder {
                     pm.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES, userId)
                 }
 
-            // Add package information (name and version code) to our list.
-            packageInfoList.add(
-                DERSequence(
-                    arrayOf(
-                        DEROctetString(packageInfo.packageName.toByteArray(StandardCharsets.UTF_8)),
-                        ASN1Integer(packageInfo.longVersionCode),
-                    )
-                )
-            )
+            packageInfoList.add(packageInfo.packageName to packageInfo.longVersionCode)
 
-            // Collect unique signature digests from the signing history.
             packageInfo.signingInfo?.signingCertificateHistory?.forEach { signature ->
-                val digest = sha256.digest(signature.toByteArray())
-                signatureDigests.add(Digest(digest))
+                signatureDigests.add(Digest(sha256.digest(signature.toByteArray())))
             }
         }
 
-        // The application ID is a sequence of two sets:
-        // 1. A set of package information (name and version).
-        // 2. A set of SHA-256 digests of the signing certificates.
+        return buildApplicationIdDer(packageInfoList, signatureDigests)
+    }
+
+    private fun buildApplicationIdDer(
+        packages: List<Pair<String, Long>>,
+        digests: Set<Digest>,
+    ): DEROctetString {
+        val packageInfoList =
+            packages.map { (name, version) ->
+                DERSequence(
+                    arrayOf(
+                        DEROctetString(name.toByteArray(StandardCharsets.UTF_8)),
+                        ASN1Integer(version),
+                    )
+                )
+            }
         val applicationIdSequence =
             DERSequence(
                 arrayOf(
                     DERSet(packageInfoList.toTypedArray()),
-                    DERSet(signatureDigests.map { DEROctetString(it.digest) }.toTypedArray()),
+                    DERSet(digests.map { DEROctetString(it.digest) }.toTypedArray()),
                 )
             )
-
         return DEROctetString(applicationIdSequence.encoded)
     }
 }
diff --git a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
index 6847928e..d75fec8f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
@@ -158,25 +158,25 @@ object ConfigurationManager {
                     return@forEach
                 }
 
+                val mode: Mode
+                val rawPkg: String
                 when {
-                    // Suffix '!' means force GENERATE mode.
                     trimmedLine.endsWith("!") -> {
-                        val pkg = trimmedLine.removeSuffix("!").trim()
-                        newModes[pkg] = Mode.GENERATE
-                        newKeyboxes[pkg] = currentKeybox
+                        mode = Mode.GENERATE
+                        rawPkg = trimmedLine.removeSuffix("!").trim()
                     }
-                    // Suffix '?' means force PATCH mode.
                     trimmedLine.endsWith("?") -> {
-                        val pkg = trimmedLine.removeSuffix("?").trim()
-                        newModes[pkg] = Mode.PATCH
-                        newKeyboxes[pkg] = currentKeybox
+                        mode = Mode.PATCH
+                        rawPkg = trimmedLine.removeSuffix("?").trim()
                     }
-                    // No suffix means AUTO mode.
                     else -> {
-                        newModes[trimmedLine] = Mode.AUTO
-                        newKeyboxes[trimmedLine] = currentKeybox
+                        mode = Mode.AUTO
+                        rawPkg = trimmedLine
                     }
                 }
+
+                newModes[rawPkg] = mode
+                newKeyboxes[rawPkg] = currentKeybox
             }
 
             // Atomically update the configuration maps.

From 3ec215391b1d2e7aacede6fd204f3ac9ae810c29 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 20:13:24 +0100
Subject: [PATCH 27/56] Add android and com.android.shell to default target
 list

---
 module/target.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/module/target.txt b/module/target.txt
index 9f3ec54e..92e12487 100644
--- a/module/target.txt
+++ b/module/target.txt
@@ -1,3 +1,5 @@
+android
+com.android.shell
 com.android.vending
 com.google.android.gms
 io.github.vvb2060.keyattestation

From 4b264b8de72ea87a51304e10b8703b507144566d Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 20:32:13 +0100
Subject: [PATCH 28/56] Compute unique ID when INCLUDE_UNIQUE_ID is present

Implement the KeyMint HAL unique ID algorithm:
HMAC-SHA256(T || C || R, HBK) truncated to 128 bits, where
T is the 30-day temporal counter (creationTime / 2592000000),
C is the DER-encoded ATTESTATION_APPLICATION_ID,
R is RESET_SINCE_ID_ROTATION (false), and
HBK is a device-unique 32-byte secret read from hbk.

Generate hbk from /dev/random during module installation if it does
not already exist. This ensures the HBK is unique per device and
stable across reboots, but not derived from any attestation material.

Parse INCLUDE_UNIQUE_ID tag in KeyMintAttestation. Pass a consistent
creation timestamp to both the unique ID computation and the
CREATION_DATETIME field in softwareEnforced.
---
 .../attestation/AttestationBuilder.kt         | 54 +++++++++++++++++--
 .../attestation/KeyMintAttestation.kt         |  2 +
 .../keystore/KeystoreInterceptor.kt           |  1 +
 module/customize.sh                           |  5 ++
 4 files changed, 59 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 18496fe2..31fb22ca 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -2,8 +2,11 @@ package org.matrix.TEESimulator.attestation
 
 import android.content.pm.PackageManager
 import android.os.Build
+import java.nio.ByteBuffer
 import java.nio.charset.StandardCharsets
 import java.security.MessageDigest
+import javax.crypto.Mac
+import javax.crypto.spec.SecretKeySpec
 import org.bouncycastle.asn1.ASN1Boolean
 import org.bouncycastle.asn1.ASN1Encodable
 import org.bouncycastle.asn1.ASN1Enumerated
@@ -132,8 +135,16 @@ object AttestationBuilder {
         uid: Int,
         securityLevel: Int,
     ): ASN1Sequence {
+        val creationTime = System.currentTimeMillis()
         val teeEnforced = buildTeeEnforcedList(params, uid, securityLevel)
-        val softwareEnforced = buildSoftwareEnforcedList(params, uid, securityLevel)
+        val softwareEnforced = buildSoftwareEnforcedList(params, uid, securityLevel, creationTime)
+
+        val uniqueId =
+            if (params.includeUniqueId == true && params.attestationChallenge != null) {
+                computeUniqueId(creationTime, createApplicationId(uid).octets)
+            } else {
+                ByteArray(0)
+            }
 
         val fields =
             arrayOf(
@@ -146,13 +157,49 @@ object AttestationBuilder {
                 ), // keymasterVersion
                 ASN1Enumerated(securityLevel), // keymasterSecurityLevel
                 DEROctetString(params.attestationChallenge ?: ByteArray(0)), // attestationChallenge
-                DEROctetString(ByteArray(0)), // uniqueId
+                DEROctetString(uniqueId),
                 softwareEnforced,
                 teeEnforced,
             )
         return DERSequence(fields)
     }
 
+    /**
+     * Computes the unique ID per the KeyMint HAL spec:
+     * HMAC-SHA256(T || C || R, HBK) truncated to 128 bits.
+     *
+     * T = temporal counter (creationTime / 2592000000, i.e. 30-day periods since epoch)
+     * C = DER-encoded ATTESTATION_APPLICATION_ID
+     * R = 0x00 (no factory reset since ID rotation)
+     * HBK = device-unique secret generated once during module installation
+     */
+    private fun computeUniqueId(creationTimeMs: Long, aaidDer: ByteArray): ByteArray {
+        val temporalCounter = creationTimeMs / 2592000000L
+
+        val message =
+            ByteBuffer.allocate(8 + aaidDer.size + 1)
+                .putLong(temporalCounter)
+                .put(aaidDer)
+                .put(0x00) // RESET_SINCE_ID_ROTATION = false
+                .array()
+
+        val mac = Mac.getInstance("HmacSHA256")
+        mac.init(SecretKeySpec(hbk, "HmacSHA256"))
+        return mac.doFinal(message).copyOf(16)
+    }
+
+    /** Device-unique key seed, generated once at module installation. */
+    private val hbk: ByteArray by lazy {
+        val file = java.io.File(ConfigurationManager.CONFIG_PATH, "hbk")
+        if (file.exists() && file.length() == 32L) {
+            file.readBytes()
+        } else {
+            // Fallback: generate in-memory (won't persist across reboots)
+            SystemLogger.warning("hbk not found, generating ephemeral HBK.")
+            ByteArray(32).also { java.security.SecureRandom().nextBytes(it) }
+        }
+    }
+
     /** Builds the `TeeEnforced` authorization list. These are properties the TEE "guarantees". */
     private fun buildTeeEnforcedList(
         params: KeyMintAttestation,
@@ -376,6 +423,7 @@ object AttestationBuilder {
         params: KeyMintAttestation,
         uid: Int,
         securityLevel: Int,
+        creationTimeMs: Long = System.currentTimeMillis(),
     ): DERSequence {
         val list = mutableListOf<ASN1Encodable>()
 
@@ -383,7 +431,7 @@ object AttestationBuilder {
             DERTaggedObject(
                 true,
                 AttestationConstants.TAG_CREATION_DATETIME,
-                ASN1Integer(System.currentTimeMillis()),
+                ASN1Integer(creationTimeMs),
             )
         )
 
diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
index eb27ed8f..a050006b 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
@@ -48,6 +48,7 @@ data class KeyMintAttestation(
     val usageCountLimit: Int?,
     val callerNonce: Boolean?,
     val unlockedDeviceRequired: Boolean?,
+    val includeUniqueId: Boolean?,
 ) {
     /** Secondary constructor that populates the fields by parsing an array of `KeyParameter`. */
     constructor(
@@ -119,6 +120,7 @@ data class KeyMintAttestation(
         usageCountLimit = params.findInteger(Tag.USAGE_COUNT_LIMIT),
         callerNonce = params.findBoolean(Tag.CALLER_NONCE),
         unlockedDeviceRequired = params.findBoolean(Tag.UNLOCKED_DEVICE_REQUIRED),
+        includeUniqueId = params.findBoolean(Tag.INCLUDE_UNIQUE_ID),
     ) {
         // Log all parsed parameters for debugging purposes.
         params.forEach { KeyMintParameterLogger.logParameter(it) }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
index 36fb14fa..b6d2345d 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
@@ -438,6 +438,7 @@ private data class LegacyKeygenParameters(
             usageCountLimit = null,
             callerNonce = null,
             unlockedDeviceRequired = null,
+            includeUniqueId = null,
         )
     }
 
diff --git a/module/customize.sh b/module/customize.sh
index 373cd427..367532dc 100644
--- a/module/customize.sh
+++ b/module/customize.sh
@@ -87,3 +87,8 @@ if [ ! -f "$CONFIG_DIR/target.txt" ]; then
   ui_print "- Adding default target scope"
   install_file "target.txt" "$CONFIG_DIR"
 fi
+
+if [ ! -f "$CONFIG_DIR/hbk" ]; then
+  ui_print "- Generating device-unique hardware-bound key seed"
+  head -c 32 /dev/random > "$CONFIG_DIR/hbk"
+fi

From fd8799e9063465805b51263e954f9ad0e38b1eab Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 20:45:08 +0100
Subject: [PATCH 29/56] Skip cert re-patching for keys updated via
 updateSubcomponent

When updateSubcomponent sets new certificates on a hardware key, the
subsequent getKeyEntry post-hook was overwriting them with the patched
attestation chain, causing inconsistency between what was set and what
was returned.

Track keys that had updateSubcomponent called and skip cert patching
on the next getKeyEntry. The tracking entry is consumed on first read.
---
 .../attestation/KeyMintAttestation.kt            |  4 ++--
 .../keystore/Keystore2Interceptor.kt             | 16 +++++++++++++++-
 2 files changed, 17 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
index a050006b..095e69c6 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
@@ -41,7 +41,7 @@ data class KeyMintAttestation(
     val manufacturer: ByteArray?,
     val model: ByteArray?,
     val secondImei: ByteArray?,
-    // --- Enforcement tags ---
+    // Enforcement tags
     val activeDateTime: Date?,
     val originationExpireDateTime: Date?,
     val usageExpireDateTime: Date?,
@@ -113,7 +113,7 @@ data class KeyMintAttestation(
         model = params.findBlob(Tag.ATTESTATION_ID_MODEL),
         secondImei = params.findBlob(Tag.ATTESTATION_ID_SECOND_IMEI),
 
-        // --- Enforcement tags ---
+        // Enforcement tags
         activeDateTime = params.findDate(Tag.ACTIVE_DATETIME),
         originationExpireDateTime = params.findDate(Tag.ORIGINATION_EXPIRE_DATETIME),
         usageExpireDateTime = params.findDate(Tag.USAGE_EXPIRE_DATETIME),
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index ce0092a6..f944e116 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -10,6 +10,7 @@ import android.system.keystore2.KeyDescriptor
 import android.system.keystore2.KeyEntryResponse
 import java.security.SecureRandom
 import java.security.cert.Certificate
+import java.util.concurrent.ConcurrentHashMap
 import org.matrix.TEESimulator.attestation.AttestationPatcher
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.config.ConfigurationManager
@@ -53,6 +54,9 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
             .associate { field -> (field.get(null) as Int) to field.name.split("_")[1] }
     }
 
+    // Keys whose certs were updated via updateSubcomponent; skip re-patching on getKeyEntry.
+    private val userUpdatedKeys = ConcurrentHashMap.newKeySet<KeyIdentifier>()
+
     override val serviceName = "android.system.keystore2.IKeystoreService/default"
     override val processName = "keystore2"
     override val injectionCommand = "exec ./inject `pidof keystore2` libTEESimulator.so entry"
@@ -246,6 +250,12 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                     val response = reply.readTypedObject(KeyEntryResponse.CREATOR)!!
                     val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
 
+                    // Skip patching for keys whose certs were explicitly set via updateSubcomponent.
+                    if (userUpdatedKeys.remove(keyId)) {
+                        SystemLogger.debug("[TX_ID: $txId] Skipping cert patch for user-updated key $keyId.")
+                        return TransactionResult.SkipTransaction
+                    }
+
                     val authorizations = response.metadata.authorizations
                     val parsedParameters =
                         KeyMintAttestation(
@@ -349,7 +359,11 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         val descriptor = data.readTypedObject(KeyDescriptor.CREATOR)
         val generatedKeyInfo =
             KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(callingUid, descriptor?.nspace)
-                ?: return TransactionResult.ContinueAndSkipPost
+        if (generatedKeyInfo == null) {
+            // Hardware key: mark so getKeyEntry skips cert re-patching.
+            descriptor?.alias?.let { userUpdatedKeys.add(KeyIdentifier(callingUid, it)) }
+            return TransactionResult.ContinueAndSkipPost
+        }
 
         SystemLogger.info("Updating sub-component with key[${generatedKeyInfo.nspace}]")
         val metadata = generatedKeyInfo.response.metadata

From 2a30b33698b341289d4c93e9eb579236bb62227c Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 20:55:55 +0100
Subject: [PATCH 30/56] Move enforcement tags to softwareEnforced and fix
 updateSubcomponent lookup

ACTIVE_DATETIME, ORIGINATION_EXPIRE_DATETIME, USAGE_EXPIRE_DATETIME,
USAGE_COUNT_LIMIT, and UNLOCKED_DEVICE_REQUIRED are enforced by
keystore2 software (authorize_create / after_finish), not by the
KeyMint HAL. They belong in softwareEnforced, matching real hardware
attestation output. CALLER_NONCE remains in teeEnforced as it is a
HAL-level capability tag.

Fix updateSubcomponent to resolve keys via Domain.APP (alias) in
addition to Domain.KEY_ID (nspace), matching the same pattern used
in createOperation. Previously, APP-domain descriptors caused the
lookup to fail, forwarding to hardware where the software key does
not exist.
---
 .../attestation/AttestationBuilder.kt         | 89 +++++++++----------
 .../keystore/Keystore2Interceptor.kt          | 20 ++++-
 2 files changed, 62 insertions(+), 47 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 31fb22ca..feadec7f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -366,15 +366,56 @@ object AttestationBuilder {
                 DERTaggedObject(true, AttestationConstants.TAG_CALLER_NONCE, DERNull.INSTANCE)
             )
         }
-        params.activeDateTime?.let {
+        return DERSequence(list.sortedBy { (it as DERTaggedObject).tagNo }.toTypedArray())
+    }
+
+    /**
+     * Builds the `SoftwareEnforced` authorization list. These are properties guaranteed by
+     * Keystore.
+     */
+    private fun buildSoftwareEnforcedList(
+        params: KeyMintAttestation,
+        uid: Int,
+        securityLevel: Int,
+        creationTimeMs: Long = System.currentTimeMillis(),
+    ): DERSequence {
+        val list = mutableListOf<ASN1Encodable>()
+
+        list.add(
+            DERTaggedObject(
+                true,
+                AttestationConstants.TAG_CREATION_DATETIME,
+                ASN1Integer(creationTimeMs),
+            )
+        )
+
+        // ATTESTATION_APPLICATION_ID is only included when an attestation challenge is present.
+        if (params.attestationChallenge != null) {
             list.add(
                 DERTaggedObject(
                     true,
-                    AttestationConstants.TAG_ACTIVE_DATETIME,
-                    ASN1Integer(it.time),
+                    AttestationConstants.TAG_ATTESTATION_APPLICATION_ID,
+                    createApplicationId(uid),
                 )
             )
         }
+        if (AndroidDeviceUtils.getAttestVersion(securityLevel) >= 400) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_MODULE_HASH,
+                    DEROctetString(AndroidDeviceUtils.moduleHash),
+                )
+            )
+        }
+
+        // Keystore2-enforced tags belong in softwareEnforced, not teeEnforced.
+        // The HAL does not enforce these; keystore2's authorize_create handles them.
+        params.activeDateTime?.let {
+            list.add(
+                DERTaggedObject(true, AttestationConstants.TAG_ACTIVE_DATETIME, ASN1Integer(it.time))
+            )
+        }
         params.originationExpireDateTime?.let {
             list.add(
                 DERTaggedObject(
@@ -415,48 +456,6 @@ object AttestationBuilder {
         return DERSequence(list.sortedBy { (it as DERTaggedObject).tagNo }.toTypedArray())
     }
 
-    /**
-     * Builds the `SoftwareEnforced` authorization list. These are properties guaranteed by
-     * Keystore.
-     */
-    private fun buildSoftwareEnforcedList(
-        params: KeyMintAttestation,
-        uid: Int,
-        securityLevel: Int,
-        creationTimeMs: Long = System.currentTimeMillis(),
-    ): DERSequence {
-        val list = mutableListOf<ASN1Encodable>()
-
-        list.add(
-            DERTaggedObject(
-                true,
-                AttestationConstants.TAG_CREATION_DATETIME,
-                ASN1Integer(creationTimeMs),
-            )
-        )
-
-        // ATTESTATION_APPLICATION_ID is only included when an attestation challenge is present.
-        if (params.attestationChallenge != null) {
-            list.add(
-                DERTaggedObject(
-                    true,
-                    AttestationConstants.TAG_ATTESTATION_APPLICATION_ID,
-                    createApplicationId(uid),
-                )
-            )
-        }
-        if (AndroidDeviceUtils.getAttestVersion(securityLevel) >= 400) {
-            list.add(
-                DERTaggedObject(
-                    true,
-                    AttestationConstants.TAG_MODULE_HASH,
-                    DEROctetString(AndroidDeviceUtils.moduleHash),
-                )
-            )
-        }
-        return DERSequence(list.toTypedArray())
-    }
-
     /**
      * A wrapper for a byte array that provides content-based equality. This is necessary for using
      * signature digests in a Set.
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index f944e116..0d49c9e9 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -5,6 +5,7 @@ import android.hardware.security.keymint.SecurityLevel
 import android.os.Build
 import android.os.IBinder
 import android.os.Parcel
+import android.system.keystore2.Domain
 import android.system.keystore2.IKeystoreService
 import android.system.keystore2.KeyDescriptor
 import android.system.keystore2.KeyEntryResponse
@@ -357,11 +358,26 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
     private fun handleUpdateSubcomponent(callingUid: Int, data: Parcel): TransactionResult {
         data.enforceInterface(IKeystoreService.DESCRIPTOR)
         val descriptor = data.readTypedObject(KeyDescriptor.CREATOR)
+            ?: return TransactionResult.ContinueAndSkipPost
+
+        // Resolve by nspace (KEY_ID) or alias (APP), same as createOperation.
         val generatedKeyInfo =
-            KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(callingUid, descriptor?.nspace)
+            when (descriptor.domain) {
+                Domain.KEY_ID ->
+                    KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(
+                        callingUid,
+                        descriptor.nspace,
+                    )
+                Domain.APP ->
+                    descriptor.alias?.let {
+                        KeyMintSecurityLevelInterceptor.generatedKeys[KeyIdentifier(callingUid, it)]
+                    }
+                else -> null
+            }
+
         if (generatedKeyInfo == null) {
             // Hardware key: mark so getKeyEntry skips cert re-patching.
-            descriptor?.alias?.let { userUpdatedKeys.add(KeyIdentifier(callingUid, it)) }
+            descriptor.alias?.let { userUpdatedKeys.add(KeyIdentifier(callingUid, it)) }
             return TransactionResult.ContinueAndSkipPost
         }
 

From e55d16d474e522042d5448e4ca681ef15641dcc6 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 21:04:21 +0100
Subject: [PATCH 31/56] Check SELinux gen_unique_id and
 REQUEST_UNIQUE_ID_ATTESTATION for unique ID

Match AOSP add_required_parameters (security_level.rs:478-485) which
allows INCLUDE_UNIQUE_ID if either SELinux gen_unique_id OR Android
REQUEST_UNIQUE_ID_ATTESTATION passes. Read the caller's SELinux
context from /proc/<pid>/attr/current and check via
SELinux.checkSELinuxAccess against the keystore_key class.

Add android.os.SELinux stub and checkSELinuxPermission helper in
ConfigurationManager.
---
 .../config/ConfigurationManager.kt            | 14 ++++++++++
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 26 +++++++++++++++++--
 stub/src/main/java/android/os/SELinux.java    |  9 +++++++
 3 files changed, 47 insertions(+), 2 deletions(-)
 create mode 100644 stub/src/main/java/android/os/SELinux.java

diff --git a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
index d75fec8f..5ef227c1 100644
--- a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
@@ -351,6 +351,20 @@ object ConfigurationManager {
         return iPackageManager
     }
 
+    /** Checks if any package belonging to the UID holds the given permission. */
+    /** Checks a SELinux permission for a caller identified by PID against the keystore context. */
+    fun checkSELinuxPermission(callingPid: Int, tclass: String, perm: String): Boolean {
+        return try {
+            val callerCtx =
+                java.io.File("/proc/$callingPid/attr/current").readText().trim('\u0000', ' ', '\n')
+            val selfCtx =
+                java.io.File("/proc/self/attr/current").readText().trim('\u0000', ' ', '\n')
+            android.os.SELinux.checkSELinuxAccess(callerCtx, selfCtx, tclass, perm)
+        } catch (_: Exception) {
+            false
+        }
+    }
+
     /** Checks if any package belonging to the UID holds the given permission. */
     fun hasPermissionForUid(uid: Int, permission: String): Boolean {
         val userId = uid / 100000
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 214ad503..9caa32f4 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -57,7 +57,7 @@ class KeyMintSecurityLevelInterceptor(
             GENERATE_KEY_TRANSACTION -> {
                 logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
 
-                if (!shouldSkip) return handleGenerateKey(callingUid, data)
+                if (!shouldSkip) return handleGenerateKey(callingUid, callingPid, data)
             }
             CREATE_OPERATION_TRANSACTION -> {
                 logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
@@ -387,7 +387,7 @@ class KeyMintSecurityLevelInterceptor(
      * Handles the `generateKey` transaction. Based on the configuration for the calling UID, it
      * either generates a key in software or lets the call pass through to the hardware.
      */
-    private fun handleGenerateKey(callingUid: Int, data: Parcel): TransactionResult {
+    private fun handleGenerateKey(callingUid: Int, callingPid: Int, data: Parcel): TransactionResult {
         return runCatching {
                 data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
                 val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
@@ -424,6 +424,27 @@ class KeyMintSecurityLevelInterceptor(
                     )
                 }
 
+                // INCLUDE_UNIQUE_ID requires SELinux gen_unique_id OR Android
+                // REQUEST_UNIQUE_ID_ATTESTATION (security_level.rs:478-485).
+                if (params.any { it.tag == Tag.INCLUDE_UNIQUE_ID }) {
+                    val hasSELinux =
+                        ConfigurationManager.checkSELinuxPermission(
+                            callingPid,
+                            "keystore_key",
+                            "gen_unique_id",
+                        )
+                    val hasAndroid =
+                        ConfigurationManager.hasPermissionForUid(
+                            callingUid,
+                            "android.permission.REQUEST_UNIQUE_ID_ATTESTATION",
+                        )
+                    if (!hasSELinux && !hasAndroid) {
+                        return@runCatching InterceptorUtils.createServiceSpecificErrorReply(
+                            PERMISSION_DENIED
+                        )
+                    }
+                }
+
                 val parsedParams = KeyMintAttestation(params)
                 val isAttestKeyRequest = parsedParams.isAttestKey()
 
@@ -519,6 +540,7 @@ class KeyMintSecurityLevelInterceptor(
         private val secureRandom = SecureRandom()
 
         private const val INVALID_ARGUMENT = 20
+        private const val PERMISSION_DENIED = 6
         private const val CANNOT_ATTEST_IDS = -66
 
         // Transaction codes for IKeystoreSecurityLevel interface.
diff --git a/stub/src/main/java/android/os/SELinux.java b/stub/src/main/java/android/os/SELinux.java
new file mode 100644
index 00000000..6191b903
--- /dev/null
+++ b/stub/src/main/java/android/os/SELinux.java
@@ -0,0 +1,9 @@
+package android.os;
+
+/** Stub for android.os.SELinux. */
+public class SELinux {
+    public static boolean checkSELinuxAccess(
+            String scon, String tcon, String tclass, String perm) {
+        throw new UnsupportedOperationException("STUB!");
+    }
+}

From 7c952f78cd1bd940848315759fa793873f9cda80 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Wed, 18 Mar 2026 23:20:21 +0100
Subject: [PATCH 32/56] Return proper TEE error codes on software generation
 failure

Throw ATTESTATION_KEYS_NOT_PROVISIONED (-75) from getKeyboxForAlgorithm
when the keybox lacks the required algorithm key. Let
ServiceSpecificException propagate through the runCatching chains in
CertificateGenerator so the original error code reaches the caller.

Use SECURE_HW_COMMUNICATION_FAILED (-49) as the generic catch-all for
unexpected failures. Fix error code from -1000 (UNKNOWN_ERROR) to -49
which is the actual KeyMint ErrorCode value.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 10 +++++--
 .../TEESimulator/pki/CertificateGenerator.kt  | 30 ++++++++++---------
 2 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 9caa32f4..0a156c1a 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -500,9 +500,12 @@ class KeyMintSecurityLevelInterceptor(
                     TransactionResult.ContinueAndSkipPost
                 }
             }
-            .getOrElse {
-                SystemLogger.error("No key pair generated for UID $callingUid.", it)
-                TransactionResult.ContinueAndSkipPost
+            .getOrElse { e ->
+                SystemLogger.error("No key pair generated for UID $callingUid.", e)
+                val code =
+                    if (e is android.os.ServiceSpecificException) e.errorCode
+                    else SECURE_HW_COMMUNICATION_FAILED
+                InterceptorUtils.createServiceSpecificErrorReply(code)
             }
     }
 
@@ -541,6 +544,7 @@ class KeyMintSecurityLevelInterceptor(
 
         private const val INVALID_ARGUMENT = 20
         private const val PERMISSION_DENIED = 6
+        private const val SECURE_HW_COMMUNICATION_FAILED = -49
         private const val CANNOT_ATTEST_IDS = -66
 
         // Transaction codes for IKeystoreSecurityLevel interface.
diff --git a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
index 000f537e..50a92f37 100644
--- a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
@@ -93,11 +93,9 @@ object CertificateGenerator {
                 "Attestation challenge exceeds length limit (${challenge.size} > ${AttestationConstants.CHALLENGE_LENGTH_LIMIT})"
             )
 
-        return runCatching {
+        return try {
                 val keybox = getKeyboxForAlgorithm(uid, params.algorithm)
 
-                // Determine the signing key and issuer. If an attestKey is provided, use it.
-                // Otherwise, fall back to the root key from the keybox.
                 val (signingKey, issuer) =
                     if (attestKeyAlias != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                         getAttestationKeyInfo(uid, attestKeyAlias)?.let { it.first to it.second }
@@ -106,20 +104,20 @@ object CertificateGenerator {
                         keybox.keyPair to getIssuerFromKeybox(keybox)
                     }
 
-                // Build the new leaf certificate with the simulated attestation.
                 val leafCert =
                     buildCertificate(subjectKeyPair, signingKey, issuer, params, uid, securityLevel)
 
-                // If not self-attesting, the chain is just the leaf. Otherwise, append the keybox
-                // chain.
                 if (attestKeyAlias != null) {
                     listOf(leafCert)
                 } else {
                     listOf(leafCert) + keybox.certificates
                 }
+            } catch (e: android.os.ServiceSpecificException) {
+                throw e
+            } catch (e: Exception) {
+                SystemLogger.error("Failed to generate certificate chain.", e)
+                null
             }
-            .onFailure { SystemLogger.error("Failed to generate certificate chain.", it) }
-            .getOrNull()
     }
 
     /**
@@ -133,7 +131,7 @@ object CertificateGenerator {
         params: KeyMintAttestation,
         securityLevel: Int,
     ): Pair<KeyPair, List<Certificate>>? {
-        return runCatching {
+        return try {
                 SystemLogger.info(
                     "Generating new attested key pair for alias: '$alias' (UID: $uid)"
                 )
@@ -149,11 +147,12 @@ object CertificateGenerator {
                     "Successfully generated new certificate chain for alias: '$alias'."
                 )
                 Pair(newKeyPair, chain)
+            } catch (e: android.os.ServiceSpecificException) {
+                throw e
+            } catch (e: Exception) {
+                SystemLogger.error("Failed to generate attested key pair for alias '$alias'.", e)
+                null
             }
-            .onFailure {
-                SystemLogger.error("Failed to generate attested key pair for alias '$alias'.", it)
-            }
-            .getOrNull()
     }
 
     fun getIssuerFromKeybox(keybox: KeyBox) =
@@ -168,7 +167,10 @@ object CertificateGenerator {
                 else -> throw IllegalArgumentException("Unsupported algorithm ID: $algorithm")
             }
         return KeyBoxManager.getAttestationKey(keyboxFile, algorithmName)
-            ?: throw Exception("Could not load keybox for UID $uid and algorithm $algorithmName")
+            ?: throw android.os.ServiceSpecificException(
+                -75, // ATTESTATION_KEYS_NOT_PROVISIONED
+                "No attestation key for algorithm $algorithmName in $keyboxFile",
+            )
     }
 
     /** Retrieves the key pair and issuer name for a given attestation key alias. */

From 37ee5f1bf9d094d6f83ea25770520cdb26493123 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 02:00:30 +0100
Subject: [PATCH 33/56] Replace static TEE check with async race for AUTO mode

Remove the blocking TEE functionality check at boot. Instead, determine
TEE status lazily on first AUTO-mode generateKey by racing two
concurrent futures: one calls the real TEE via the original binder,
the other performs software generation. On hardware success, the
software future is cancelled and TEE is marked functional. On hardware
failure, the software result is used.

Once TEE is marked functional, subsequent AUTO-mode requests go
directly through the PATCH path without racing.

Remove tee_status.txt, storeTeeStatus, loadTeeStatus, and isTeeBroken.
---
 .../main/java/org/matrix/TEESimulator/App.kt  |   5 +-
 .../attestation/DeviceAttestationService.kt   |  48 -----
 .../config/ConfigurationManager.kt            |  45 +----
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 177 +++++++++++++-----
 .../main/java/android/os/ServiceManager.java  |   4 +
 5 files changed, 149 insertions(+), 130 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/App.kt b/app/src/main/java/org/matrix/TEESimulator/App.kt
index de71061c..1fab1922 100644
--- a/app/src/main/java/org/matrix/TEESimulator/App.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/App.kt
@@ -40,9 +40,10 @@ object App {
             // Initialize and start the appropriate keystore interceptors.
             initializeInterceptors()
 
-            // Load the package configuration.
+            // Load configuration and check TEE status after interceptors are active.
+            // The TEE check key alias is excluded from interception so it goes
+            // directly to real hardware.
             ConfigurationManager.initialize()
-            // Set up the device's boot key and hash, which are crucial for attestation.
             AndroidDeviceUtils.setupBootKeyAndHash()
 
             // Android ships with a stripped-down Bouncy Castle provider under the name "BC".
diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/DeviceAttestationService.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/DeviceAttestationService.kt
index 114ad3de..4bad10a2 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/DeviceAttestationService.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/DeviceAttestationService.kt
@@ -1,13 +1,8 @@
 package org.matrix.TEESimulator.attestation
 
 import android.annotation.SuppressLint
-import android.security.keystore.KeyGenParameterSpec
-import android.security.keystore.KeyProperties
-import java.security.KeyPairGenerator
 import java.security.KeyStore
-import java.security.SecureRandom
 import java.security.cert.X509Certificate
-import java.security.spec.ECGenParameterSpec
 import org.bouncycastle.asn1.ASN1Integer
 import org.bouncycastle.asn1.ASN1ObjectIdentifier
 import org.bouncycastle.asn1.ASN1OctetString
@@ -57,55 +52,14 @@ object DeviceAttestationService {
         val bootPatchLevel: Int?,
     )
 
-    // A unique alias for the key used to perform the TEE functionality check.
     private const val TEE_CHECK_KEY_ALIAS = "TEESimulator_AttestationCheck"
 
-    /**
-     * Lazily determines if the device's TEE is functional by attempting to generate an
-     * attestation-backed key pair. The result is cached.
-     */
-    val isTeeFunctional: Boolean by lazy { checkTeeFunctionality() }
-
     /**
      * Lazily fetches and parses attestation data from a genuinely generated certificate. The result
      * is cached. Returns null if the TEE is not functional or parsing fails.
      */
     val CachedAttestationData: AttestationData? by lazy { fetchAttestationData() }
 
-    /**
-     * Checks if the TEE is working correctly by generating a key in the Android Keystore with an
-     * attestation challenge.
-     *
-     * @return `true` if a key with attestation was generated successfully, `false` otherwise.
-     */
-    private fun checkTeeFunctionality(): Boolean {
-        SystemLogger.info("Performing TEE functionality check...")
-        return try {
-            val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
-            val keyPairGenerator =
-                KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore")
-
-            // A random challenge is required for attestation.
-            val challenge = ByteArray(16).apply { SecureRandom().nextBytes(this) }
-
-            val spec =
-                KeyGenParameterSpec.Builder(TEE_CHECK_KEY_ALIAS, KeyProperties.PURPOSE_SIGN)
-                    .setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
-                    .setDigests(KeyProperties.DIGEST_SHA256)
-                    .setAttestationChallenge(challenge)
-                    .build()
-
-            keyPairGenerator.initialize(spec)
-            keyPairGenerator.generateKeyPair()
-
-            SystemLogger.info("TEE functionality check successful.")
-            true
-        } catch (e: Exception) {
-            SystemLogger.warning("TEE functionality check failed.", e)
-            false
-        }
-    }
-
     /**
      * Retrieves the attestation certificate generated during the TEE check. The key entry is
      * deleted after retrieval to clean up.
@@ -113,8 +67,6 @@ object DeviceAttestationService {
      * @return The leaf `X509Certificate` containing the attestation, or `null` if unavailable.
      */
     private fun getAttestationCertificate(): X509Certificate? {
-        if (!isTeeFunctional) return null
-
         return try {
             val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
             val certChain = keyStore.getCertificateChain(TEE_CHECK_KEY_ALIAS)
diff --git a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
index 5ef227c1..f65ff53d 100644
--- a/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt
@@ -7,7 +7,6 @@ import android.os.IBinder
 import android.os.ServiceManager
 import java.io.File
 import java.util.concurrent.ConcurrentHashMap
-import org.matrix.TEESimulator.attestation.DeviceAttestationService
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.KeyBoxManager
 
@@ -31,7 +30,6 @@ object ConfigurationManager {
     // --- Configuration Paths ---
     const val CONFIG_PATH = "/data/adb/tricky_store"
     private const val TARGET_PACKAGES_FILE = "target.txt"
-    private const val TEE_STATUS_FILE = "tee_status.txt"
     private const val PATCH_LEVEL_FILE = "security_patch.txt"
     private const val DEFAULT_KEYBOX_FILE = "keybox.xml"
     private val configRoot = File(CONFIG_PATH)
@@ -39,7 +37,6 @@ object ConfigurationManager {
     // --- In-Memory Configuration State ---
     @Volatile private var packageModes = mapOf<String, Mode>()
     @Volatile private var packageKeyboxes = mapOf<String, String>()
-    @Volatile private var isTeeBroken: Boolean? = null
     @Volatile private var globalCustomPatchLevel: CustomPatchLevel? = null
     @Volatile private var packagePatchLevels = mapOf<String, CustomPatchLevel>()
 
@@ -68,7 +65,6 @@ object ConfigurationManager {
         // Initial load of all configuration files.
         loadTargetPackages(File(configRoot, TARGET_PACKAGES_FILE))
         loadPatchLevelConfig(File(configRoot, PATCH_LEVEL_FILE))
-        storeTeeStatus() // Check and store the current TEE status.
 
         // Start watching for any subsequent file changes.
         ConfigObserver.startWatching()
@@ -88,7 +84,10 @@ object ConfigurationManager {
     }
 
     /** Determines if the certificate for a given UID needs to be patched. */
-    fun shouldPatch(uid: Int): Boolean = getPackageModeForUid(uid) == Mode.PATCH
+    fun shouldPatch(uid: Int): Boolean {
+        val mode = getPackageModeForUid(uid)
+        return mode == Mode.PATCH || mode == Mode.AUTO
+    }
 
     /** Determines if a new certificate needs to be generated for a given UID. */
     fun shouldGenerate(uid: Int): Boolean = getPackageModeForUid(uid) == Mode.GENERATE
@@ -96,24 +95,23 @@ object ConfigurationManager {
     /** Determines if no operation is needed for a given UID. */
     fun shouldSkipUid(uid: Int): Boolean = getPackageModeForUid(uid) == null
 
+    /** Determines if the UID is in AUTO mode (no explicit ! or ? suffix). */
+    fun isAutoMode(uid: Int): Boolean = getPackageModeForUid(uid) == Mode.AUTO
+
     /** Resolves the operating mode for a given UID based on its packages and the TEE status. */
     private fun getPackageModeForUid(uid: Int): Mode? {
         val packages = getPackagesForUid(uid)
         if (packages.isEmpty()) return null
 
-        // Lazily load TEE status if it hasn't been checked yet.
-        if (isTeeBroken == null) loadTeeStatus()
-
-        // Find the first configured mode for any of the UID's packages.
         for (pkg in packages) {
             when (packageModes[pkg]) {
                 Mode.GENERATE -> return Mode.GENERATE
                 Mode.PATCH -> return Mode.PATCH
-                Mode.AUTO -> return if (isTeeBroken == true) Mode.GENERATE else Mode.PATCH
-                null -> continue // No config for this package, check the next one.
+                Mode.AUTO -> return Mode.AUTO
+                null -> continue
             }
         }
-        return null // No configuration found for this UID.
+        return null
     }
 
     /**
@@ -273,29 +271,6 @@ object ConfigurationManager {
         }
     }
 
-    /** Checks the device's TEE status and writes the result to a file for persistence. */
-    private fun storeTeeStatus() {
-        val statusFile = File(configRoot, TEE_STATUS_FILE)
-        isTeeBroken = !DeviceAttestationService.isTeeFunctional
-        try {
-            statusFile.writeText("tee_broken=$isTeeBroken")
-            SystemLogger.info("TEE status stored: isTeeBroken=$isTeeBroken")
-        } catch (e: Exception) {
-            SystemLogger.error("Failed to write TEE status to file.", e)
-        }
-    }
-
-    /** Loads the TEE status from the file. */
-    private fun loadTeeStatus() {
-        val statusFile = File(configRoot, TEE_STATUS_FILE)
-        isTeeBroken =
-            if (statusFile.exists()) {
-                statusFile.readText().trim() == "tee_broken=true"
-            } else {
-                null // Status is unknown.
-            }
-    }
-
     /**
      * A FileObserver that monitors the configuration directory for changes and triggers reloads of
      * the relevant settings.
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 0a156c1a..2f4a28e3 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -13,6 +13,8 @@ import android.system.keystore2.*
 import java.security.KeyPair
 import java.security.SecureRandom
 import java.security.cert.Certificate
+import java.util.concurrent.CancellationException
+import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
 import org.matrix.TEESimulator.attestation.AttestationPatcher
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
@@ -224,7 +226,7 @@ class KeyMintSecurityLevelInterceptor(
             when (keyDescriptor.domain) {
                 Domain.KEY_ID -> {
                     val nspace = keyDescriptor.nspace
-                    if (nspace == null || nspace == 0L) null
+                    if (nspace == 0L) null
                     else
                         generatedKeys.entries
                             .filter { it.key.uid == callingUid }
@@ -395,6 +397,7 @@ class KeyMintSecurityLevelInterceptor(
                 SystemLogger.debug(
                     "Handling generateKey ${keyDescriptor.alias}, attestKey=${attestationKey?.alias}"
                 )
+
                 val params = data.createTypedArray(KeyParameter.CREATOR)!!
 
                 // Caller-provided CREATION_DATETIME is not allowed.
@@ -448,56 +451,23 @@ class KeyMintSecurityLevelInterceptor(
                 val parsedParams = KeyMintAttestation(params)
                 val isAttestKeyRequest = parsedParams.isAttestKey()
 
-                // Determine if we need to generate a key based on config or
-                // if it's an attestation request in patch mode.
-                val needsSoftwareGeneration =
+                val forceGenerate =
                     ConfigurationManager.shouldGenerate(callingUid) ||
                         (ConfigurationManager.shouldPatch(callingUid) && isAttestKeyRequest) ||
                         (attestationKey != null &&
                             isAttestationKey(KeyIdentifier(callingUid, attestationKey.alias)))
 
-                if (needsSoftwareGeneration) {
-                    keyDescriptor.nspace = secureRandom.nextLong()
-                    SystemLogger.info(
-                        "Generating software key for ${keyDescriptor.alias}[${keyDescriptor.nspace}]."
-                    )
+                val isAuto = ConfigurationManager.isAutoMode(callingUid)
 
-                    // Generate the key pair and certificate chain.
-                    val keyData =
-                        CertificateGenerator.generateAttestedKeyPair(
-                            callingUid,
-                            keyDescriptor.alias,
-                            attestationKey?.alias,
-                            parsedParams,
-                            securityLevel,
-                        ) ?: throw Exception("CertificateGenerator failed to create key pair.")
-
-                    val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
-                    // It is unnecessary but a good practice to clean up possible caches
-                    cleanupKeyData(keyId)
-                    // Store the generated key data.
-                    val response =
-                        buildKeyEntryResponse(
-                            callingUid,
-                            keyData.second,
-                            parsedParams,
-                            keyDescriptor,
-                        )
-                    generatedKeys[keyId] =
-                        GeneratedKeyInfo(
-                            keyData.first,
-                            keyDescriptor.nspace,
-                            response,
-                            parsedParams,
-                        )
-                    if (isAttestKeyRequest) attestationKeys.add(keyId)
-
-                    // Return the metadata of our generated key, skipping the real hardware call.
-                    InterceptorUtils.createTypedObjectReply(response.metadata)
-                } else if (parsedParams.attestationChallenge != null) {
-                    TransactionResult.Continue
-                } else {
-                    TransactionResult.ContinueAndSkipPost
+                when {
+                    forceGenerate -> doSoftwareGeneration(
+                        callingUid, keyDescriptor, attestationKey, parsedParams, isAttestKeyRequest
+                    )
+                    isAuto && !teeFunctional -> raceTeePatch(
+                        callingUid, keyDescriptor, attestationKey, params, parsedParams, isAttestKeyRequest
+                    )
+                    parsedParams.attestationChallenge != null -> TransactionResult.Continue
+                    else -> TransactionResult.ContinueAndSkipPost
                 }
             }
             .getOrElse { e ->
@@ -509,6 +479,120 @@ class KeyMintSecurityLevelInterceptor(
             }
     }
 
+    /** Performs software key generation and caches the result. */
+    private fun doSoftwareGeneration(
+        callingUid: Int,
+        keyDescriptor: KeyDescriptor,
+        attestationKey: KeyDescriptor?,
+        parsedParams: KeyMintAttestation,
+        isAttestKeyRequest: Boolean,
+    ): TransactionResult {
+        keyDescriptor.nspace = secureRandom.nextLong()
+        SystemLogger.info(
+            "Generating software key for ${keyDescriptor.alias}[${keyDescriptor.nspace}]."
+        )
+
+        val keyData =
+            CertificateGenerator.generateAttestedKeyPair(
+                callingUid,
+                keyDescriptor.alias,
+                attestationKey?.alias,
+                parsedParams,
+                securityLevel,
+            ) ?: throw Exception("CertificateGenerator failed to create key pair.")
+
+        val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
+        cleanupKeyData(keyId)
+        val response =
+            buildKeyEntryResponse(callingUid, keyData.second, parsedParams, keyDescriptor)
+        generatedKeys[keyId] =
+            GeneratedKeyInfo(keyData.first, keyDescriptor.nspace, response, parsedParams)
+        if (isAttestKeyRequest) attestationKeys.add(keyId)
+
+        return InterceptorUtils.createTypedObjectReply(response.metadata)
+    }
+
+    /**
+     * Races TEE hardware generation against software generation for AUTO mode when the TEE
+     * status is unknown. The hardware path is attempted concurrently with software generation.
+     * On hardware success, the software future is cancelled and TEE is marked functional.
+     * On hardware failure, the software result is used instead.
+     */
+    private fun raceTeePatch(
+        callingUid: Int,
+        keyDescriptor: KeyDescriptor,
+        attestationKey: KeyDescriptor?,
+        rawParams: Array<KeyParameter>,
+        parsedParams: KeyMintAttestation,
+        isAttestKeyRequest: Boolean,
+    ): TransactionResult {
+        SystemLogger.info("AUTO mode: racing TEE vs software for ${keyDescriptor.alias}")
+
+        val teeDescriptor = KeyDescriptor().apply {
+            domain = keyDescriptor.domain
+            nspace = keyDescriptor.nspace
+            alias = keyDescriptor.alias
+            blob = keyDescriptor.blob
+        }
+        val teeAttestKey =
+            attestationKey?.let {
+                KeyDescriptor().apply {
+                    domain = it.domain
+                    nspace = it.nspace
+                    alias = it.alias
+                    blob = it.blob
+                }
+            }
+
+        val threadA = CompletableFuture.supplyAsync {
+            original.generateKey(teeDescriptor, teeAttestKey, rawParams, 0, byteArrayOf())
+        }
+
+        val swDescriptor = KeyDescriptor().apply {
+            domain = keyDescriptor.domain
+            nspace = secureRandom.nextLong()
+            alias = keyDescriptor.alias
+            blob = keyDescriptor.blob
+        }
+
+        val threadB = CompletableFuture.supplyAsync {
+            doSoftwareGeneration(
+                callingUid, swDescriptor, attestationKey, parsedParams, isAttestKeyRequest
+            )
+        }
+
+        return try {
+            val teeMetadata = threadA.join()
+            threadB.cancel(true)
+            teeFunctional = true
+            SystemLogger.info("AUTO: TEE succeeded for ${keyDescriptor.alias}, marked functional.")
+
+            val originalChain = CertificateHelper.getCertificateChain(teeMetadata)
+            if (originalChain != null && originalChain.size > 1) {
+                val newChain = AttestationPatcher.patchCertificateChain(originalChain, callingUid)
+                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
+                CertificateHelper.updateCertificateChain(teeMetadata, newChain).getOrThrow()
+                teeMetadata.authorizations =
+                    InterceptorUtils.patchAuthorizations(teeMetadata.authorizations, callingUid)
+                cleanupKeyData(keyId)
+                patchedChains[keyId] = newChain
+            }
+            InterceptorUtils.createTypedObjectReply(teeMetadata)
+        } catch (_: Exception) {
+            SystemLogger.info("AUTO: TEE failed for ${keyDescriptor.alias}, using software result.")
+            try {
+                threadB.join()
+            } catch (e: Exception) {
+                SystemLogger.error("AUTO: both paths failed for ${keyDescriptor.alias}.", e)
+                val code =
+                    if (e.cause is android.os.ServiceSpecificException)
+                        (e.cause as android.os.ServiceSpecificException).errorCode
+                    else SECURE_HW_COMMUNICATION_FAILED
+                InterceptorUtils.createServiceSpecificErrorReply(code)
+            }
+        }
+    }
+
     /**
      * Constructs a fake `KeyEntryResponse` that mimics a real response from the Keystore service.
      */
@@ -542,6 +626,9 @@ class KeyMintSecurityLevelInterceptor(
     companion object {
         private val secureRandom = SecureRandom()
 
+        /** Once set to true, AUTO mode skips the race and uses PATCH directly. */
+        @Volatile var teeFunctional = false
+
         private const val INVALID_ARGUMENT = 20
         private const val PERMISSION_DENIED = 6
         private const val SECURE_HW_COMMUNICATION_FAILED = -49
diff --git a/stub/src/main/java/android/os/ServiceManager.java b/stub/src/main/java/android/os/ServiceManager.java
index 2e810d4e..14990bfa 100644
--- a/stub/src/main/java/android/os/ServiceManager.java
+++ b/stub/src/main/java/android/os/ServiceManager.java
@@ -17,6 +17,10 @@ public static IBinder checkService(String name) {
         throw new UnsupportedOperationException("STUB!");
     }
 
+    public static boolean isDeclared(String name) {
+        throw new UnsupportedOperationException("STUB!");
+    }
+
     public static String[] listServices() {
         throw new UnsupportedOperationException("STUB!");
     }

From 453950de44490c3761489cafad33181870d76d23 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 02:01:54 +0100
Subject: [PATCH 34/56] Remove legacy tee_status.txt during module installation

---
 app/src/main/java/org/matrix/TEESimulator/App.kt | 3 ---
 module/customize.sh                              | 3 +++
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/App.kt b/app/src/main/java/org/matrix/TEESimulator/App.kt
index 1fab1922..0ff56752 100644
--- a/app/src/main/java/org/matrix/TEESimulator/App.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/App.kt
@@ -40,9 +40,6 @@ object App {
             // Initialize and start the appropriate keystore interceptors.
             initializeInterceptors()
 
-            // Load configuration and check TEE status after interceptors are active.
-            // The TEE check key alias is excluded from interception so it goes
-            // directly to real hardware.
             ConfigurationManager.initialize()
             AndroidDeviceUtils.setupBootKeyAndHash()
 
diff --git a/module/customize.sh b/module/customize.sh
index 367532dc..7d6d62f6 100644
--- a/module/customize.sh
+++ b/module/customize.sh
@@ -88,6 +88,9 @@ if [ ! -f "$CONFIG_DIR/target.txt" ]; then
   install_file "target.txt" "$CONFIG_DIR"
 fi
 
+# Remove legacy TEE status file; TEE status is now determined at runtime.
+rm -f "$CONFIG_DIR/tee_status.txt"
+
 if [ ! -f "$CONFIG_DIR/hbk" ]; then
   ui_print "- Generating device-unique hardware-bound key seed"
   head -c 32 /dev/random > "$CONFIG_DIR/hbk"

From ed134bc6ff59750d1b0fb976798e84d2d0ec3fcb Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 02:34:14 +0100
Subject: [PATCH 35/56] Encode TAG_PADDING as SET OF INTEGER in attestation
 extension

PADDING was encoded as individual tagged objects per value, creating
multiple tag [6] entries in the AuthorizationList. The spec defines
padding as a single SET OF INTEGER (like PURPOSE and DIGEST). The
malformed encoding caused CertificateParsingException on RSA keys
where padding is present.
---
 .../matrix/TEESimulator/attestation/AttestationBuilder.kt | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index feadec7f..3da6082d 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -240,9 +240,13 @@ object AttestationBuilder {
             )
         }
 
-        params.padding.forEach {
+        if (params.padding.isNotEmpty()) {
             list.add(
-                DERTaggedObject(true, AttestationConstants.TAG_PADDING, ASN1Integer(it.toLong()))
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_PADDING,
+                    DERSet(params.padding.map { ASN1Integer(it.toLong()) }.toTypedArray()),
+                )
             )
         }
 

From 509d15752f581aa7487b9a3b637486aa105da9bf Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 02:46:06 +0100
Subject: [PATCH 36/56] Reject AGREE_KEY for all non-EC algorithms with
 UNSUPPORTED_PURPOSE

AOSP enforcements.rs rejects AGREE_KEY for any algorithm that is not
EC, not just RSA. Restructure the unsupported purpose check to match
the exact authorize_create decision tree.
---
 .../keystore/shim/KeyMintSecurityLevelInterceptor.kt | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 2f4a28e3..517d0e1c 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -273,12 +273,14 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
-        // Asymmetric keys reject VERIFY/ENCRYPT at the HAL level (UNSUPPORTED_PURPOSE).
         val algorithm = keyParams.algorithm
-        if (
-            (algorithm == Algorithm.EC || algorithm == Algorithm.RSA) &&
-                (requestedPurpose == KeyPurpose.VERIFY || requestedPurpose == KeyPurpose.ENCRYPT)
-        ) {
+        val isAsymmetric = algorithm == Algorithm.EC || algorithm == Algorithm.RSA
+        val unsupported =
+            (isAsymmetric &&
+                (requestedPurpose == KeyPurpose.VERIFY ||
+                    requestedPurpose == KeyPurpose.ENCRYPT)) ||
+                (requestedPurpose == KeyPurpose.AGREE_KEY && algorithm != Algorithm.EC)
+        if (unsupported) {
             return InterceptorUtils.createServiceSpecificErrorReply(
                 KeystoreErrorCode.UNSUPPORTED_PURPOSE
             )

From 7952e55ec3470f33da3bf19bd0e86aa6733893c0 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 02:52:23 +0100
Subject: [PATCH 37/56] Fix NO_AUTH_REQUIRED and ORIGIN in attestation, add
 WRAP_KEY rejection

NO_AUTH_REQUIRED was unconditionally added to teeEnforced, making all
keys appear to not require authentication. Only include it when the
key parameter is actually set.

ORIGIN was hardcoded to GENERATED (0). Use the actual origin value
from the key parameters to correctly reflect IMPORTED keys.

Add explicit WRAP_KEY rejection with INCOMPATIBLE_PURPOSE before the
purpose-list check, matching AOSP enforcements.rs behavior.
---
 .../TEESimulator/attestation/AttestationBuilder.kt    | 11 ++++++++---
 .../keystore/shim/KeyMintSecurityLevelInterceptor.kt  |  6 ++++++
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 3da6082d..e1a59208 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -260,14 +260,19 @@ object AttestationBuilder {
             )
         }
 
+        if (params.noAuthRequired == true) {
+            list.add(
+                DERTaggedObject(true, AttestationConstants.TAG_NO_AUTH_REQUIRED, DERNull.INSTANCE)
+            )
+        }
+
         list.addAll(
             listOf(
-                DERTaggedObject(true, AttestationConstants.TAG_NO_AUTH_REQUIRED, DERNull.INSTANCE),
                 DERTaggedObject(
                     true,
                     AttestationConstants.TAG_ORIGIN,
-                    ASN1Integer(0L),
-                ), // KeyOrigin.GENERATED
+                    ASN1Integer((params.origin ?: 0).toLong()),
+                ),
                 DERTaggedObject(
                     true,
                     AttestationConstants.TAG_ROOT_OF_TRUST,
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 517d0e1c..7aac61f2 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -286,6 +286,12 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
+        if (requestedPurpose == KeyPurpose.WRAP_KEY) {
+            return InterceptorUtils.createServiceSpecificErrorReply(
+                KeystoreErrorCode.INCOMPATIBLE_PURPOSE
+            )
+        }
+
         if (requestedPurpose !in keyParams.purpose) {
             SystemLogger.info(
                 "[TX_ID: $txId] Rejecting: purpose $requestedPurpose not in ${keyParams.purpose}"

From 550bacdf8426a1eaaa0a50b6dd86a16d69dc351f Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 03:04:53 +0100
Subject: [PATCH 38/56] Parse additional attestation tags from key generation
 parameters

---
 .../attestation/KeyMintAttestation.kt          | 18 ++++++++++++++++++
 .../keystore/KeystoreInterceptor.kt            |  9 +++++++++
 2 files changed, 27 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
index 095e69c6..92b0d30f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt
@@ -49,6 +49,15 @@ data class KeyMintAttestation(
     val callerNonce: Boolean?,
     val unlockedDeviceRequired: Boolean?,
     val includeUniqueId: Boolean?,
+    val rollbackResistance: Boolean?,
+    val earlyBootOnly: Boolean?,
+    val allowWhileOnBody: Boolean?,
+    val trustedUserPresenceRequired: Boolean?,
+    val trustedConfirmationRequired: Boolean?,
+    val maxUsesPerBoot: Int?,
+    val maxBootLevel: Int?,
+    val minMacLength: Int?,
+    val rsaOaepMgfDigest: List<Int>,
 ) {
     /** Secondary constructor that populates the fields by parsing an array of `KeyParameter`. */
     constructor(
@@ -121,6 +130,15 @@ data class KeyMintAttestation(
         callerNonce = params.findBoolean(Tag.CALLER_NONCE),
         unlockedDeviceRequired = params.findBoolean(Tag.UNLOCKED_DEVICE_REQUIRED),
         includeUniqueId = params.findBoolean(Tag.INCLUDE_UNIQUE_ID),
+        rollbackResistance = params.findBoolean(Tag.ROLLBACK_RESISTANCE),
+        earlyBootOnly = params.findBoolean(Tag.EARLY_BOOT_ONLY),
+        allowWhileOnBody = params.findBoolean(Tag.ALLOW_WHILE_ON_BODY),
+        trustedUserPresenceRequired = params.findBoolean(Tag.TRUSTED_USER_PRESENCE_REQUIRED),
+        trustedConfirmationRequired = params.findBoolean(Tag.TRUSTED_CONFIRMATION_REQUIRED),
+        maxUsesPerBoot = params.findInteger(Tag.MAX_USES_PER_BOOT),
+        maxBootLevel = params.findInteger(Tag.MAX_BOOT_LEVEL),
+        minMacLength = params.findInteger(Tag.MIN_MAC_LENGTH),
+        rsaOaepMgfDigest = params.findAllDigests(Tag.RSA_OAEP_MGF_DIGEST),
     ) {
         // Log all parsed parameters for debugging purposes.
         params.forEach { KeyMintParameterLogger.logParameter(it) }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
index b6d2345d..8fc03001 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt
@@ -439,6 +439,15 @@ private data class LegacyKeygenParameters(
             callerNonce = null,
             unlockedDeviceRequired = null,
             includeUniqueId = null,
+            rollbackResistance = null,
+            earlyBootOnly = null,
+            allowWhileOnBody = null,
+            trustedUserPresenceRequired = null,
+            trustedConfirmationRequired = null,
+            maxUsesPerBoot = null,
+            maxBootLevel = null,
+            minMacLength = null,
+            rsaOaepMgfDigest = emptyList(),
         )
     }
 

From 1cc1be007c25b184dc3e9a976ec905fc71549926 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 03:05:07 +0100
Subject: [PATCH 39/56] Add EARLY_BOOT_ONLY, ALLOW_WHILE_ON_BODY,
 TRUSTED_USER_PRESENCE_REQUIRED, TRUSTED_CONFIRMATION_REQUIRED, and
 MAX_BOOT_LEVEL constants

---
 .../matrix/TEESimulator/attestation/AttestationConstants.kt  | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt
index f695a204..2ba04c75 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationConstants.kt
@@ -44,9 +44,11 @@ object AttestationConstants {
 
     // --- Key Lifetime and Usage Control ---
     const val TAG_ROLLBACK_RESISTANCE = 303
+    const val TAG_EARLY_BOOT_ONLY = 305
     const val TAG_ACTIVE_DATETIME = 400
     const val TAG_ORIGINATION_EXPIRE_DATETIME = 401
     const val TAG_USAGE_EXPIRE_DATETIME = 402
+    const val TAG_MAX_BOOT_LEVEL = 403
     const val TAG_MAX_USES_PER_BOOT = 404
     const val TAG_USAGE_COUNT_LIMIT = 405
 
@@ -56,6 +58,9 @@ object AttestationConstants {
     const val TAG_NO_AUTH_REQUIRED = 503
     const val TAG_USER_AUTH_TYPE = 504
     const val TAG_AUTH_TIMEOUT = 505
+    const val TAG_ALLOW_WHILE_ON_BODY = 506
+    const val TAG_TRUSTED_USER_PRESENCE_REQUIRED = 507
+    const val TAG_TRUSTED_CONFIRMATION_REQUIRED = 508
     const val TAG_UNLOCKED_DEVICE_REQUIRED = 509
 
     // --- Attestation and Application Info ---

From eec69abbf5d0451fb0c0435d733d3c007a7e831b Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 03:05:19 +0100
Subject: [PATCH 40/56] Include version-guarded tags and remove non-attestation
 tags

Add RSA_OAEP_MGF_DIGEST (>= v100), ROLLBACK_RESISTANCE (>= v3),
EARLY_BOOT_ONLY (>= v4), ALLOW_WHILE_ON_BODY, TRUSTED_USER_PRESENCE
(>= v3), TRUSTED_CONFIRMATION (>= v3) to teeEnforced.

Remove CALLER_NONCE, MIN_MAC_LENGTH, MAX_USES_PER_BOOT from teeEnforced
and MAX_BOOT_LEVEL from softwareEnforced as they are not part of the
attestation extension schema per the Android specification.
---
 .../attestation/AttestationBuilder.kt         | 66 +++++++++++++++++--
 1 file changed, 60 insertions(+), 6 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index e1a59208..a882d92e 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -260,12 +260,72 @@ object AttestationBuilder {
             )
         }
 
+        val attestVersion = AndroidDeviceUtils.getAttestVersion(securityLevel)
+
+        if (params.rsaOaepMgfDigest.isNotEmpty() && attestVersion >= 100) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_RSA_OAEP_MGF_DIGEST,
+                    DERSet(
+                        params.rsaOaepMgfDigest.map { ASN1Integer(it.toLong()) }.toTypedArray()
+                    ),
+                )
+            )
+        }
+
+        if (params.rollbackResistance == true && attestVersion >= 3) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_ROLLBACK_RESISTANCE,
+                    DERNull.INSTANCE,
+                )
+            )
+        }
+
+        if (params.earlyBootOnly == true && attestVersion >= 4) {
+            list.add(
+                DERTaggedObject(true, AttestationConstants.TAG_EARLY_BOOT_ONLY, DERNull.INSTANCE)
+            )
+        }
+
         if (params.noAuthRequired == true) {
             list.add(
                 DERTaggedObject(true, AttestationConstants.TAG_NO_AUTH_REQUIRED, DERNull.INSTANCE)
             )
         }
 
+        if (params.allowWhileOnBody == true) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_ALLOW_WHILE_ON_BODY,
+                    DERNull.INSTANCE,
+                )
+            )
+        }
+
+        if (params.trustedUserPresenceRequired == true && attestVersion >= 3) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_TRUSTED_USER_PRESENCE_REQUIRED,
+                    DERNull.INSTANCE,
+                )
+            )
+        }
+
+        if (params.trustedConfirmationRequired == true && attestVersion >= 3) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_TRUSTED_CONFIRMATION_REQUIRED,
+                    DERNull.INSTANCE,
+                )
+            )
+        }
+
         list.addAll(
             listOf(
                 DERTaggedObject(
@@ -369,12 +429,6 @@ object AttestationBuilder {
                 )
             }
         }
-        // Add enforcement-related tags that are reflected in the attestation.
-        if (params.callerNonce == true) {
-            list.add(
-                DERTaggedObject(true, AttestationConstants.TAG_CALLER_NONCE, DERNull.INSTANCE)
-            )
-        }
         return DERSequence(list.sortedBy { (it as DERTaggedObject).tagNo }.toTypedArray())
     }
 

From 1acf6861d2568a21f3f48ddac4496f1ea4ad0114 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 03:08:46 +0100
Subject: [PATCH 41/56] Include BLOCK_MODE as SET OF INTEGER in teeEnforced
 attestation

---
 .../TEESimulator/attestation/AttestationBuilder.kt     | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index a882d92e..499a14d1 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -240,6 +240,16 @@ object AttestationBuilder {
             )
         }
 
+        if (params.blockMode.isNotEmpty()) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_BLOCK_MODE,
+                    DERSet(params.blockMode.map { ASN1Integer(it.toLong()) }.toTypedArray()),
+                )
+            )
+        }
+
         if (params.padding.isNotEmpty()) {
             list.add(
                 DERTaggedObject(

From d3bf3c8a70aff34ce6f10ca138ecea5cfe9a7cb2 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 03:27:26 +0100
Subject: [PATCH 42/56] Support symmetric key generation (AES, HMAC) in
 software mode

AES and HMAC keys were failing in GENERATE mode because
doSoftwareGeneration only handled asymmetric key pairs. Generate
symmetric keys via javax.crypto.KeyGenerator and return KeyMetadata
without certificates (symmetric keys have no cert chain).

Store SecretKey in GeneratedKeyInfo alongside KeyPair. Update
SoftwareOperation and CipherPrimitive to accept either key type.
---
 .../keystore/Keystore2Interceptor.kt          |  1 +
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 56 +++++++++++++++++--
 .../keystore/shim/SoftwareOperation.kt        | 23 +++++---
 3 files changed, 66 insertions(+), 14 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 0d49c9e9..bf1956fe 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -293,6 +293,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                         KeyMintSecurityLevelInterceptor.generatedKeys[keyId] =
                             KeyMintSecurityLevelInterceptor.GeneratedKeyInfo(
                                 keyData.first,
+                                null,
                                 newNspace,
                                 response,
                                 parsedParameters,
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 7aac61f2..edeeab8e 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -38,7 +38,8 @@ class KeyMintSecurityLevelInterceptor(
 
     // --- Data Structures for State Management ---
     data class GeneratedKeyInfo(
-        val keyPair: KeyPair,
+        val keyPair: KeyPair?,
+        val secretKey: javax.crypto.SecretKey?,
         val nspace: Long,
         val response: KeyEntryResponse,
         val keyParams: KeyMintAttestation,
@@ -351,7 +352,12 @@ class KeyMintSecurityLevelInterceptor(
                 val effectiveParams =
                     keyParams.copy(purpose = parsedOpParams.purpose, digest = parsedOpParams.digest.ifEmpty { keyParams.digest })
                 val softwareOperation =
-                    SoftwareOperation(txId, generatedKeyInfo.keyPair, effectiveParams)
+                    SoftwareOperation(
+                        txId,
+                        generatedKeyInfo.keyPair,
+                        generatedKeyInfo.secretKey,
+                        effectiveParams,
+                    )
 
                 // Decrement usage counter on finish; delete key when exhausted.
                 if (keyParams.usageCountLimit != null && resolvedKeyId != null) {
@@ -500,6 +506,48 @@ class KeyMintSecurityLevelInterceptor(
             "Generating software key for ${keyDescriptor.alias}[${keyDescriptor.nspace}]."
         )
 
+        val isSymmetric =
+            parsedParams.algorithm != Algorithm.EC && parsedParams.algorithm != Algorithm.RSA
+
+        val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
+        cleanupKeyData(keyId)
+
+        if (isSymmetric) {
+            val algoName =
+                when (parsedParams.algorithm) {
+                    Algorithm.AES -> "AES"
+                    Algorithm.HMAC -> "HmacSHA256"
+                    else -> throw android.os.ServiceSpecificException(
+                        SECURE_HW_COMMUNICATION_FAILED,
+                        "Unsupported symmetric algorithm: ${parsedParams.algorithm}",
+                    )
+                }
+            val keyGen = javax.crypto.KeyGenerator.getInstance(algoName)
+            keyGen.init(parsedParams.keySize)
+            val secretKey = keyGen.generateKey()
+
+            val metadata = KeyMetadata().apply {
+                keySecurityLevel = securityLevel
+                key = KeyDescriptor().apply {
+                    domain = Domain.KEY_ID
+                    nspace = keyDescriptor.nspace
+                    alias = null
+                    blob = null
+                }
+                certificate = null
+                certificateChain = null
+                authorizations = parsedParams.toAuthorizations(callingUid, securityLevel)
+                modificationTimeMs = System.currentTimeMillis()
+            }
+            val response = KeyEntryResponse().apply {
+                this.metadata = metadata
+                iSecurityLevel = original
+            }
+            generatedKeys[keyId] =
+                GeneratedKeyInfo(null, secretKey, keyDescriptor.nspace, response, parsedParams)
+            return InterceptorUtils.createTypedObjectReply(metadata)
+        }
+
         val keyData =
             CertificateGenerator.generateAttestedKeyPair(
                 callingUid,
@@ -509,12 +557,10 @@ class KeyMintSecurityLevelInterceptor(
                 securityLevel,
             ) ?: throw Exception("CertificateGenerator failed to create key pair.")
 
-        val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
-        cleanupKeyData(keyId)
         val response =
             buildKeyEntryResponse(callingUid, keyData.second, parsedParams, keyDescriptor)
         generatedKeys[keyId] =
-            GeneratedKeyInfo(keyData.first, keyDescriptor.nspace, response, parsedParams)
+            GeneratedKeyInfo(keyData.first, null, keyDescriptor.nspace, response, parsedParams)
         if (isAttestKeyRequest) attestationKeys.add(keyId)
 
         return InterceptorUtils.createTypedObjectReply(response.metadata)
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index d8dca748..79448a23 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -168,14 +168,13 @@ private class Verifier(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPri
 
 // Concrete implementation for Encryption/Decryption.
 private class CipherPrimitive(
-    keyPair: KeyPair,
+    cryptoKey: java.security.Key,
     params: KeyMintAttestation,
     private val opMode: Int,
 ) : CryptoPrimitive {
     private val cipher: Cipher =
         Cipher.getInstance(JcaAlgorithmMapper.mapCipherAlgorithm(params)).apply {
-            val key = if (opMode == Cipher.ENCRYPT_MODE) keyPair.public else keyPair.private
-            init(opMode, key)
+            init(opMode, cryptoKey)
         }
 
     override fun updateAad(data: ByteArray?) {
@@ -211,9 +210,9 @@ private class CipherPrimitive(
  */
 class SoftwareOperation(
     private val txId: Long,
-    keyPair: KeyPair,
+    keyPair: KeyPair?,
+    secretKey: javax.crypto.SecretKey?,
     params: KeyMintAttestation,
-    /** Called after a successful finish(), used for USAGE_COUNT_LIMIT enforcement. */
     var onFinishCallback: (() -> Unit)? = null,
 ) {
     private val primitive: CryptoPrimitive
@@ -227,10 +226,16 @@ class SoftwareOperation(
 
         primitive =
             when (purpose) {
-                KeyPurpose.SIGN -> Signer(keyPair, params)
-                KeyPurpose.VERIFY -> Verifier(keyPair, params)
-                KeyPurpose.ENCRYPT -> CipherPrimitive(keyPair, params, Cipher.ENCRYPT_MODE)
-                KeyPurpose.DECRYPT -> CipherPrimitive(keyPair, params, Cipher.DECRYPT_MODE)
+                KeyPurpose.SIGN -> Signer(keyPair!!, params)
+                KeyPurpose.VERIFY -> Verifier(keyPair!!, params)
+                KeyPurpose.ENCRYPT -> {
+                    val key: java.security.Key = secretKey ?: keyPair!!.public
+                    CipherPrimitive(key, params, Cipher.ENCRYPT_MODE)
+                }
+                KeyPurpose.DECRYPT -> {
+                    val key: java.security.Key = secretKey ?: keyPair!!.private
+                    CipherPrimitive(key, params, Cipher.DECRYPT_MODE)
+                }
                 else ->
                     throw ServiceSpecificException(
                         KeystoreErrorCode.UNSUPPORTED_PURPOSE,

From 25aca9bd46a94ba42867a236cfdf1728d8e24327 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 03:35:07 +0100
Subject: [PATCH 43/56] Include BLOCK_MODE in KeyMetadata authorizations

---
 .../keystore/shim/KeyMintSecurityLevelInterceptor.kt           | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index edeeab8e..75298c55 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -823,6 +823,9 @@ private fun KeyMintAttestation.toAuthorizations(
     }
 
     this.purpose.forEach { authList.add(createAuth(Tag.PURPOSE, KeyParameterValue.keyPurpose(it))) }
+    this.blockMode.forEach {
+        authList.add(createAuth(Tag.BLOCK_MODE, KeyParameterValue.blockMode(it)))
+    }
     this.digest.forEach { authList.add(createAuth(Tag.DIGEST, KeyParameterValue.digest(it))) }
     this.padding.forEach {
         authList.add(createAuth(Tag.PADDING, KeyParameterValue.paddingMode(it)))

From 98472d3573fc13b478302921b4ebb1754505f923 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 04:17:19 +0100
Subject: [PATCH 44/56] Simulate realistic TEE hardware latency for software
 key generation

Software key generation completes in ~8ms, while real TEE hardware
(QTEE, Trustonic) takes 55-75ms. Add TeeLatencySimulator that models
three independent latency components:

1. Base crypto delay (log-normal, algorithm-dependent): EC ~45ms,
   RSA ~55ms, AES ~30ms. Log-normal matches the positive skew
   observed in real hardware measurements.
2. Kernel/binder transit noise (exponential, mean 5ms): models IPC
   scheduling jitter with occasional spikes.
3. TEE scheduler jitter (Gaussian, stddev 3ms): models non-deterministic
   TrustZone world-switch cost.

A per-boot session bias (Gaussian, stddev 8ms) shifts the distribution
to prevent cross-session fingerprinting. The actual generation time is
subtracted so faster CPUs get more padding naturally.

Distribution parameters derived from observed QTEE (7 sessions, 56
runs) and Trustonic (7 sessions, 56 runs) timing profiles.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt   |  8 ++
 .../TEESimulator/util/TeeLatencySimulator.kt  | 80 +++++++++++++++++++
 2 files changed, 88 insertions(+)
 create mode 100644 app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 75298c55..41957711 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -26,6 +26,7 @@ import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.CertificateGenerator
 import org.matrix.TEESimulator.pki.CertificateHelper
 import org.matrix.TEESimulator.util.AndroidDeviceUtils
+import org.matrix.TEESimulator.util.TeeLatencySimulator
 
 /**
  * Intercepts calls to an `IKeystoreSecurityLevel` service (e.g., TEE or StrongBox). This is where
@@ -501,6 +502,7 @@ class KeyMintSecurityLevelInterceptor(
         parsedParams: KeyMintAttestation,
         isAttestKeyRequest: Boolean,
     ): TransactionResult {
+        val genStartNanos = System.nanoTime()
         keyDescriptor.nspace = secureRandom.nextLong()
         SystemLogger.info(
             "Generating software key for ${keyDescriptor.alias}[${keyDescriptor.nspace}]."
@@ -545,6 +547,9 @@ class KeyMintSecurityLevelInterceptor(
             }
             generatedKeys[keyId] =
                 GeneratedKeyInfo(null, secretKey, keyDescriptor.nspace, response, parsedParams)
+            TeeLatencySimulator.simulateGenerateKeyDelay(
+                parsedParams.algorithm, System.nanoTime() - genStartNanos
+            )
             return InterceptorUtils.createTypedObjectReply(metadata)
         }
 
@@ -563,6 +568,9 @@ class KeyMintSecurityLevelInterceptor(
             GeneratedKeyInfo(keyData.first, null, keyDescriptor.nspace, response, parsedParams)
         if (isAttestKeyRequest) attestationKeys.add(keyId)
 
+        TeeLatencySimulator.simulateGenerateKeyDelay(
+            parsedParams.algorithm, System.nanoTime() - genStartNanos
+        )
         return InterceptorUtils.createTypedObjectReply(response.metadata)
     }
 
diff --git a/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt b/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt
new file mode 100644
index 00000000..bdaf9ba4
--- /dev/null
+++ b/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt
@@ -0,0 +1,80 @@
+package org.matrix.TEESimulator.util
+
+import android.hardware.security.keymint.Algorithm
+import java.security.SecureRandom
+import java.util.concurrent.locks.LockSupport
+import kotlin.math.exp
+import kotlin.math.ln
+import kotlin.math.max
+
+/**
+ * Simulates realistic TEE hardware latency for software key generation. Real TEE key generation
+ * involves hardware crypto operations, TrustZone world-switching, and binder IPC overhead that
+ * produce characteristic timing distributions. This simulator models those delays using
+ * statistical distributions derived from observed QTEE and Trustonic hardware profiles.
+ *
+ * The delay is composed of three independent components:
+ * 1. Base crypto processing time (log-normal, algorithm-dependent)
+ * 2. Kernel/binder transit noise (exponential, models IPC jitter)
+ * 3. TEE scheduler jitter (Gaussian, models world-switch variance)
+ *
+ * A per-boot session bias prevents cross-session fingerprinting.
+ */
+object TeeLatencySimulator {
+
+    private val rng = SecureRandom()
+
+    // Per-boot bias shifts the entire distribution to model manufacturing variance.
+    private val sessionBiasMs: Double by lazy { rng.nextGaussian() * 8.0 }
+
+    /**
+     * Pads the current thread to simulate realistic TEE generateKey latency.
+     *
+     * @param algorithm The KeyMint algorithm constant (EC, RSA, AES, HMAC).
+     * @param elapsedNanos Wall time already spent on the actual software key generation.
+     */
+    fun simulateGenerateKeyDelay(algorithm: Int, elapsedNanos: Long) {
+        val elapsedMs = elapsedNanos / 1_000_000.0
+        val targetMs = sampleTotalDelay(algorithm)
+        val remainingMs = targetMs - elapsedMs
+
+        if (remainingMs > 1.0) {
+            LockSupport.parkNanos((remainingMs * 1_000_000).toLong())
+        }
+    }
+
+    private fun sampleTotalDelay(algorithm: Int): Double {
+        val base = sampleBaseCryptoDelay(algorithm)
+        val transit = sampleExponential(5.0)
+        val jitter = (rng.nextGaussian() * 3.0).coerceIn(-8.0, 15.0)
+        return max(15.0, base + transit + jitter + sessionBiasMs)
+    }
+
+    /**
+     * Base crypto delay models the hardware processing time. Log-normal distribution produces
+     * the characteristic positive skew observed in real TEE measurements: most operations
+     * cluster around the median, with occasional slower outliers.
+     */
+    private fun sampleBaseCryptoDelay(algorithm: Int): Double {
+        val (mu, sigma) =
+            when (algorithm) {
+                Algorithm.EC -> ln(45.0) to 0.20
+                Algorithm.RSA -> ln(55.0) to 0.22
+                Algorithm.AES -> ln(30.0) to 0.15
+                else -> ln(35.0) to 0.18 // HMAC, others
+            }
+        return sampleLogNormal(mu, sigma)
+    }
+
+    /** Log-normal sample via inverse CDF transform of Gaussian. */
+    private fun sampleLogNormal(mu: Double, sigma: Double): Double {
+        return exp(mu + sigma * rng.nextGaussian())
+    }
+
+    /** Exponential sample via inverse CDF: -mean * ln(U). */
+    private fun sampleExponential(mean: Double): Double {
+        var u = rng.nextDouble()
+        while (u == 0.0) u = rng.nextDouble()
+        return -mean * ln(u)
+    }
+}

From 802f7b7d4774085d36f774b1c5555d6fb9a7f085 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 04:24:25 +0100
Subject: [PATCH 45/56] Restore async race for AUTO mode with getKeyEntry
 caching fix

Restore the concurrent CompletableFuture race between TEE hardware
and software generation. The original KEY_NOT_FOUND issue was caused
by the TEE-generated key not being cached in generatedKeys, making
getKeyEntry unable to find it through our pre-hook.

Cache the patched TEE result in generatedKeys after the hardware path
succeeds, so getKeyEntry returns it correctly regardless of which UID
namespace the hardware stored it under.
---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 28 +++++++++++++------
 1 file changed, 20 insertions(+), 8 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 41957711..9d9dccfd 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -13,7 +13,6 @@ import android.system.keystore2.*
 import java.security.KeyPair
 import java.security.SecureRandom
 import java.security.cert.Certificate
-import java.util.concurrent.CancellationException
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
 import org.matrix.TEESimulator.attestation.AttestationPatcher
@@ -575,10 +574,9 @@ class KeyMintSecurityLevelInterceptor(
     }
 
     /**
-     * Races TEE hardware generation against software generation for AUTO mode when the TEE
-     * status is unknown. The hardware path is attempted concurrently with software generation.
-     * On hardware success, the software future is cancelled and TEE is marked functional.
-     * On hardware failure, the software result is used instead.
+     * Races TEE hardware generation against software generation concurrently for AUTO mode.
+     * If TEE succeeds, the software future is cancelled and TEE is marked functional.
+     * If TEE fails, the already-running software result is used without additional delay.
      */
     private fun raceTeePatch(
         callingUid: Int,
@@ -588,7 +586,7 @@ class KeyMintSecurityLevelInterceptor(
         parsedParams: KeyMintAttestation,
         isAttestKeyRequest: Boolean,
     ): TransactionResult {
-        SystemLogger.info("AUTO mode: racing TEE vs software for ${keyDescriptor.alias}")
+        SystemLogger.info("AUTO: racing TEE vs software for ${keyDescriptor.alias}")
 
         val teeDescriptor = KeyDescriptor().apply {
             domain = keyDescriptor.domain
@@ -632,13 +630,23 @@ class KeyMintSecurityLevelInterceptor(
             val originalChain = CertificateHelper.getCertificateChain(teeMetadata)
             if (originalChain != null && originalChain.size > 1) {
                 val newChain = AttestationPatcher.patchCertificateChain(originalChain, callingUid)
-                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                 CertificateHelper.updateCertificateChain(teeMetadata, newChain).getOrThrow()
                 teeMetadata.authorizations =
                     InterceptorUtils.patchAuthorizations(teeMetadata.authorizations, callingUid)
+                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                 cleanupKeyData(keyId)
                 patchedChains[keyId] = newChain
             }
+
+            // Cache the patched response for getKeyEntry. Stored in teeResponses
+            // (not generatedKeys) so createOperation forwards to real hardware.
+            val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
+            val patchedResponse = KeyEntryResponse().apply {
+                this.metadata = teeMetadata
+                iSecurityLevel = original
+            }
+            teeResponses[keyId] = patchedResponse
+
             InterceptorUtils.createTypedObjectReply(teeMetadata)
         } catch (_: Exception) {
             SystemLogger.info("AUTO: TEE failed for ${keyDescriptor.alias}, using software result.")
@@ -728,6 +736,8 @@ class KeyMintSecurityLevelInterceptor(
         val attestationKeys = ConcurrentHashMap.newKeySet<KeyIdentifier>()
         // Caches patched certificate chains to prevent re-generation and signature inconsistencies.
         val patchedChains = ConcurrentHashMap<KeyIdentifier, Array<Certificate>>()
+        // TEE-generated responses cached for getKeyEntry (not for createOperation).
+        val teeResponses = ConcurrentHashMap<KeyIdentifier, KeyEntryResponse>()
         // Tracks remaining usage count per key for USAGE_COUNT_LIMIT enforcement.
         private val usageCounters =
             ConcurrentHashMap<KeyIdentifier, java.util.concurrent.atomic.AtomicInteger>()
@@ -736,7 +746,7 @@ class KeyMintSecurityLevelInterceptor(
 
         // --- Public Accessors for Other Interceptors ---
         fun getGeneratedKeyResponse(keyId: KeyIdentifier): KeyEntryResponse? =
-            generatedKeys[keyId]?.response
+            generatedKeys[keyId]?.response ?: teeResponses[keyId]
 
         /**
          * Finds a software-generated key by first filtering all known keys by the caller's UID, and
@@ -771,6 +781,7 @@ class KeyMintSecurityLevelInterceptor(
                 SystemLogger.debug("Remove cached attestaion key ${keyId}")
             }
             usageCounters.remove(keyId)
+            teeResponses.remove(keyId)
         }
 
         fun removeOperationInterceptor(operationBinder: IBinder, backdoor: IBinder) {
@@ -790,6 +801,7 @@ class KeyMintSecurityLevelInterceptor(
             patchedChains.clear()
             attestationKeys.clear()
             usageCounters.clear()
+            teeResponses.clear()
             SystemLogger.info("Cleared all cached keys ($count entries)$reasonMessage.")
         }
     }

From a0985f299ac6143939d89b9290e6fbea48ba999a Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 04:51:36 +0100
Subject: [PATCH 46/56] Fix deleteKey to forward to hardware for TEE-cached
 keys

deleteKey was intercepting TEE-generated keys (found via teeResponses)
and returning success without forwarding to real hardware, leaving
orphaned keys in the keystore2 database. Only skip hardware for
software-generated keys that exist solely in our generatedKeys cache.
---
 .../keystore/Keystore2Interceptor.kt          |  6 +-
 .../TEESimulator/util/TeeLatencySimulator.kt  | 62 ++++++++++---------
 2 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index bf1956fe..235fcee8 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -165,8 +165,10 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
             val keyId = KeyIdentifier(callingUid, descriptor.alias)
 
             if (code == DELETE_KEY_TRANSACTION) {
-                if (KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId) != null) {
-                    KeyMintSecurityLevelInterceptor.cleanupKeyData(keyId)
+                val isSoftwareKey =
+                    KeyMintSecurityLevelInterceptor.generatedKeys.containsKey(keyId)
+                KeyMintSecurityLevelInterceptor.cleanupKeyData(keyId)
+                if (isSoftwareKey) {
                     SystemLogger.info(
                         "[TX_ID: $txId] Deleted cached keypair ${descriptor.alias}, replying with empty response."
                     )
diff --git a/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt b/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt
index bdaf9ba4..0106984f 100644
--- a/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt
@@ -3,36 +3,35 @@ package org.matrix.TEESimulator.util
 import android.hardware.security.keymint.Algorithm
 import java.security.SecureRandom
 import java.util.concurrent.locks.LockSupport
+import kotlin.math.abs
 import kotlin.math.exp
 import kotlin.math.ln
 import kotlin.math.max
 
 /**
- * Simulates realistic TEE hardware latency for software key generation. Real TEE key generation
- * involves hardware crypto operations, TrustZone world-switching, and binder IPC overhead that
- * produce characteristic timing distributions. This simulator models those delays using
- * statistical distributions derived from observed QTEE and Trustonic hardware profiles.
+ * Simulates realistic TEE hardware latency for software key generation.
  *
- * The delay is composed of three independent components:
- * 1. Base crypto processing time (log-normal, algorithm-dependent)
- * 2. Kernel/binder transit noise (exponential, models IPC jitter)
- * 3. TEE scheduler jitter (Gaussian, models world-switch variance)
+ * The delay model is derived from 64+ timing measurements across QTEE (Qualcomm) and Trustonic
+ * (MediaTek) hardware. It combines four independent noise sources that model different physical
+ * latency origins in a real TrustZone-based TEE:
  *
- * A per-boot session bias prevents cross-session fingerprinting.
+ * 1. Base crypto processing (log-normal): hardware RNG + key derivation + cert signing
+ * 2. Binder/kernel transit (exponential): IPC scheduling, context switches
+ * 3. TrustZone scheduler jitter (Gaussian): world-switch non-determinism
+ * 4. Cold-start penalty (half-normal): first operation after idle is slower due to TEE
+ *    secure world re-initialization and TLB/cache warming
+ *
+ * Per-boot session bias models manufacturing variance between TEE hardware instances.
  */
 object TeeLatencySimulator {
 
     private val rng = SecureRandom()
 
-    // Per-boot bias shifts the entire distribution to model manufacturing variance.
-    private val sessionBiasMs: Double by lazy { rng.nextGaussian() * 8.0 }
+    private val sessionBiasMs: Double by lazy { rng.nextGaussian() * 5.0 }
+    private val coldPenaltyMs: Double by lazy { abs(rng.nextGaussian() * 12.0) }
+
+    @Volatile private var firstCall = true
 
-    /**
-     * Pads the current thread to simulate realistic TEE generateKey latency.
-     *
-     * @param algorithm The KeyMint algorithm constant (EC, RSA, AES, HMAC).
-     * @param elapsedNanos Wall time already spent on the actual software key generation.
-     */
     fun simulateGenerateKeyDelay(algorithm: Int, elapsedNanos: Long) {
         val elapsedMs = elapsedNanos / 1_000_000.0
         val targetMs = sampleTotalDelay(algorithm)
@@ -45,33 +44,38 @@ object TeeLatencySimulator {
 
     private fun sampleTotalDelay(algorithm: Int): Double {
         val base = sampleBaseCryptoDelay(algorithm)
-        val transit = sampleExponential(5.0)
-        val jitter = (rng.nextGaussian() * 3.0).coerceIn(-8.0, 15.0)
-        return max(15.0, base + transit + jitter + sessionBiasMs)
+        val transit = sampleExponential(2.5)
+        val jitter = (rng.nextGaussian() * 2.5).coerceIn(-8.0, 12.0)
+
+        var cold = 0.0
+        if (firstCall) {
+            firstCall = false
+            cold = coldPenaltyMs
+        }
+
+        return max(20.0, base + transit + jitter + sessionBiasMs + cold)
     }
 
     /**
-     * Base crypto delay models the hardware processing time. Log-normal distribution produces
-     * the characteristic positive skew observed in real TEE measurements: most operations
-     * cluster around the median, with occasional slower outliers.
+     * Log-normal base delay. Parameters tuned to match observed hardware profiles:
+     * EC P-256 on QTEE averages ~65ms, RSA-2048 ~75ms, AES ~40ms.
+     * Sigma kept low (0.08) to match the tight clustering seen in real measurements.
      */
     private fun sampleBaseCryptoDelay(algorithm: Int): Double {
         val (mu, sigma) =
             when (algorithm) {
-                Algorithm.EC -> ln(45.0) to 0.20
-                Algorithm.RSA -> ln(55.0) to 0.22
-                Algorithm.AES -> ln(30.0) to 0.15
-                else -> ln(35.0) to 0.18 // HMAC, others
+                Algorithm.EC -> ln(60.0) to 0.08
+                Algorithm.RSA -> ln(70.0) to 0.08
+                Algorithm.AES -> ln(35.0) to 0.10
+                else -> ln(40.0) to 0.10
             }
         return sampleLogNormal(mu, sigma)
     }
 
-    /** Log-normal sample via inverse CDF transform of Gaussian. */
     private fun sampleLogNormal(mu: Double, sigma: Double): Double {
         return exp(mu + sigma * rng.nextGaussian())
     }
 
-    /** Exponential sample via inverse CDF: -mean * ln(U). */
     private fun sampleExponential(mean: Double): Double {
         var u = rng.nextDouble()
         while (u == 0.0) u = rng.nextDouble()

From 5c85dd279b3e5a454dc626c7b63714ecbda093a2 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 05:49:19 +0100
Subject: [PATCH 47/56] Include software key count in getNumberOfEntries

listEntries and listEntriesBatched inject software-generated keys into
results, but getNumberOfEntries returned only the hardware database
count. An app verifying count == list.size would detect the mismatch.

Intercept getNumberOfEntries in the post-hook, add the count of
software keys matching the caller UID to the hardware count.
---
 .../keystore/Keystore2Interceptor.kt          | 31 +++++++++++++++++--
 1 file changed, 29 insertions(+), 2 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 235fcee8..f96a45d0 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -45,6 +45,8 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         if (Build.VERSION.SDK_INT >= 34)
             InterceptorUtils.getTransactCode(stubBinderClass, "listEntriesBatched")
         else null
+    private val GET_NUMBER_OF_ENTRIES_TRANSACTION =
+        InterceptorUtils.getTransactCode(stubBinderClass, "getNumberOfEntries")
 
     private val transactionNames: Map<Int, String> by lazy {
         stubBinderClass.declaredFields
@@ -69,6 +71,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                 UPDATE_SUBCOMPONENT_TRANSACTION,
                 LIST_ENTRIES_TRANSACTION,
                 LIST_ENTRIES_BATCHED_TRANSACTION,
+                GET_NUMBER_OF_ENTRIES_TRANSACTION,
             )
             .toIntArray()
     }
@@ -125,7 +128,12 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         callingPid: Int,
         data: Parcel,
     ): TransactionResult {
-        if (code == LIST_ENTRIES_TRANSACTION || code == LIST_ENTRIES_BATCHED_TRANSACTION) {
+        if (code == GET_NUMBER_OF_ENTRIES_TRANSACTION) {
+            logTransaction(txId, transactionNames[code]!!, callingUid, callingPid, true)
+            return if (ConfigurationManager.shouldSkipUid(callingUid))
+                TransactionResult.ContinueAndSkipPost
+            else TransactionResult.Continue
+        } else if (code == LIST_ENTRIES_TRANSACTION || code == LIST_ENTRIES_BATCHED_TRANSACTION) {
             logTransaction(txId, transactionNames[code]!!, callingUid, callingPid, true)
 
             val packages = ConfigurationManager.getPackagesForUid(callingUid).joinToString()
@@ -217,7 +225,26 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         if (target != keystoreService || reply == null || InterceptorUtils.hasException(reply))
             return TransactionResult.SkipTransaction
 
-        if (code == LIST_ENTRIES_TRANSACTION || code == LIST_ENTRIES_BATCHED_TRANSACTION) {
+        if (code == GET_NUMBER_OF_ENTRIES_TRANSACTION) {
+            logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
+            return runCatching {
+                    val hardwareCount = reply.readInt()
+                    val softwareCount =
+                        KeyMintSecurityLevelInterceptor.generatedKeys.keys.count {
+                            it.uid == callingUid
+                        }
+                    val totalCount = hardwareCount + softwareCount
+                    val parcel = Parcel.obtain().apply {
+                        writeNoException()
+                        writeInt(totalCount)
+                    }
+                    TransactionResult.OverrideReply(parcel)
+                }
+                .getOrElse {
+                    SystemLogger.error("[TX_ID: $txId] Failed to modify getNumberOfEntries.", it)
+                    TransactionResult.SkipTransaction
+                }
+        } else if (code == LIST_ENTRIES_TRANSACTION || code == LIST_ENTRIES_BATCHED_TRANSACTION) {
             logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
 
             return runCatching {

From 7486530b3f7eeab4178aec9806d69352aa7f6b31 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 05:54:34 +0100
Subject: [PATCH 48/56] Handle deleteKey for KEY_ID domain to prevent stale
 cache entries

deleteKey only resolved keys by alias (Domain::APP). Keys deleted
via Domain::KEY_ID with nspace were skipped, leaving stale entries
in generatedKeys and teeResponses. Resolve by nspace via
findGeneratedKeyByKeyId for KEY_ID domain deletes.
---
 .../keystore/Keystore2Interceptor.kt          | 45 ++++++++++++-------
 1 file changed, 28 insertions(+), 17 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index f96a45d0..a918ae75 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -162,28 +162,39 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                 data.readTypedObject(KeyDescriptor.CREATOR)
                     ?: return TransactionResult.ContinueAndSkipPost
 
-            if (descriptor.alias != null) {
-                SystemLogger.info("Handling ${transactionNames[code]!!} ${descriptor.alias}")
-            } else {
-                SystemLogger.info(
-                    "Skip ${transactionNames[code]!!} for key [alias, blob, domain, nspace]: [${descriptor.alias}, ${descriptor.blob}, ${descriptor.domain}, ${descriptor.nspace}]"
-                )
+            if (code == DELETE_KEY_TRANSACTION) {
+                // Handle delete by alias (APP domain) or nspace (KEY_ID domain).
+                val keyId =
+                    if (descriptor.alias != null) {
+                        KeyIdentifier(callingUid, descriptor.alias)
+                    } else if (descriptor.domain == Domain.KEY_ID) {
+                        KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(
+                            callingUid, descriptor.nspace
+                        )?.let { info ->
+                            KeyMintSecurityLevelInterceptor.generatedKeys.entries
+                                .find { it.value.nspace == info.nspace && it.key.uid == callingUid }
+                                ?.key
+                        }
+                    } else null
+
+                if (keyId != null) {
+                    val isSoftwareKey =
+                        KeyMintSecurityLevelInterceptor.generatedKeys.containsKey(keyId)
+                    KeyMintSecurityLevelInterceptor.cleanupKeyData(keyId)
+                    if (isSoftwareKey) {
+                        SystemLogger.info(
+                            "[TX_ID: $txId] Deleted cached keypair ${keyId.alias}, replying with empty response."
+                        )
+                        return InterceptorUtils.createSuccessReply(writeResultCode = false)
+                    }
+                }
                 return TransactionResult.ContinueAndSkipPost
             }
-            val keyId = KeyIdentifier(callingUid, descriptor.alias)
 
-            if (code == DELETE_KEY_TRANSACTION) {
-                val isSoftwareKey =
-                    KeyMintSecurityLevelInterceptor.generatedKeys.containsKey(keyId)
-                KeyMintSecurityLevelInterceptor.cleanupKeyData(keyId)
-                if (isSoftwareKey) {
-                    SystemLogger.info(
-                        "[TX_ID: $txId] Deleted cached keypair ${descriptor.alias}, replying with empty response."
-                    )
-                    return InterceptorUtils.createSuccessReply(writeResultCode = false)
-                }
+            if (descriptor.alias == null) {
                 return TransactionResult.ContinueAndSkipPost
             }
+            val keyId = KeyIdentifier(callingUid, descriptor.alias)
 
             val response =
                 KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId)

From fa38975156533eb7cec2c55498959bef678f8ed7 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 06:12:36 +0100
Subject: [PATCH 49/56] Skip attest key override for imported keys in
 getKeyEntry

---
 .../interception/keystore/Keystore2Interceptor.kt            | 4 +++-
 .../keystore/shim/KeyMintSecurityLevelInterceptor.kt         | 5 +++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index a918ae75..65917f4e 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -303,7 +303,9 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                             authorizations?.map { it.keyParameter }?.toTypedArray() ?: emptyArray()
                         )
 
-                    if (parsedParameters.isAttestKey()) {
+                    if (parsedParameters.isAttestKey() &&
+                        !KeyMintSecurityLevelInterceptor.importedKeys.contains(keyId)
+                    ) {
                         SystemLogger.warning(
                             "[TX_ID: $txId] Found hardware attest key ${keyId.alias} in the reply."
                         )
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 9d9dccfd..d1bbd0f0 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -114,6 +114,7 @@ class KeyMintSecurityLevelInterceptor(
                     ?: return TransactionResult.SkipTransaction
             val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
             cleanupKeyData(keyId)
+            importedKeys.add(keyId)
 
             // Patch imported key certificates the same way as generated keys.
             if (!ConfigurationManager.shouldSkipUid(callingUid)) {
@@ -736,6 +737,8 @@ class KeyMintSecurityLevelInterceptor(
         val attestationKeys = ConcurrentHashMap.newKeySet<KeyIdentifier>()
         // Caches patched certificate chains to prevent re-generation and signature inconsistencies.
         val patchedChains = ConcurrentHashMap<KeyIdentifier, Array<Certificate>>()
+        // Keys imported via importKey; getKeyEntry must not override these.
+        val importedKeys: MutableSet<KeyIdentifier> = ConcurrentHashMap.newKeySet()
         // TEE-generated responses cached for getKeyEntry (not for createOperation).
         val teeResponses = ConcurrentHashMap<KeyIdentifier, KeyEntryResponse>()
         // Tracks remaining usage count per key for USAGE_COUNT_LIMIT enforcement.
@@ -780,6 +783,7 @@ class KeyMintSecurityLevelInterceptor(
             if (attestationKeys.remove(keyId)) {
                 SystemLogger.debug("Remove cached attestaion key ${keyId}")
             }
+            importedKeys.remove(keyId)
             usageCounters.remove(keyId)
             teeResponses.remove(keyId)
         }
@@ -800,6 +804,7 @@ class KeyMintSecurityLevelInterceptor(
             generatedKeys.clear()
             patchedChains.clear()
             attestationKeys.clear()
+            importedKeys.clear()
             usageCounters.clear()
             teeResponses.clear()
             SystemLogger.info("Cleared all cached keys ($count entries)$reasonMessage.")

From 492d6dcf45fc4efe43439f6c2d071039a01e470f Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Thu, 19 Mar 2026 06:45:44 +0100
Subject: [PATCH 50/56] Align KeyMetadata authorizations and operation
 semantics with AOSP

---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 91 +++++++++++++++----
 .../keystore/shim/SoftwareOperation.kt        | 39 +++++++-
 2 files changed, 111 insertions(+), 19 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index d1bbd0f0..5b64fed0 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -258,7 +258,7 @@ class KeyMintSecurityLevelInterceptor(
 
         val opParams = data.createTypedArray(KeyParameter.CREATOR)!!
         val parsedOpParams = KeyMintAttestation(opParams)
-        val forced = data.readBoolean()
+        data.readBoolean() // forced: no-op for sw ops
 
         val keyParams = generatedKeyInfo.keyParams
 
@@ -269,12 +269,6 @@ class KeyMintSecurityLevelInterceptor(
             )
         }
 
-        if (forced) {
-            return InterceptorUtils.createServiceSpecificErrorReply(
-                KeystoreErrorCode.PERMISSION_DENIED
-            )
-        }
-
         val algorithm = keyParams.algorithm
         val isAsymmetric = algorithm == Algorithm.EC || algorithm == Algorithm.RSA
         val unsupported =
@@ -873,6 +867,42 @@ private fun KeyMintAttestation.toAuthorizations(
         )
     }
 
+    if (this.callerNonce == true) {
+        authList.add(createAuth(Tag.CALLER_NONCE, KeyParameterValue.boolValue(true)))
+    }
+    if (this.minMacLength != null) {
+        authList.add(createAuth(Tag.MIN_MAC_LENGTH, KeyParameterValue.integer(this.minMacLength)))
+    }
+    if (this.rollbackResistance == true) {
+        authList.add(createAuth(Tag.ROLLBACK_RESISTANCE, KeyParameterValue.boolValue(true)))
+    }
+    if (this.earlyBootOnly == true) {
+        authList.add(createAuth(Tag.EARLY_BOOT_ONLY, KeyParameterValue.boolValue(true)))
+    }
+    if (this.allowWhileOnBody == true) {
+        authList.add(createAuth(Tag.ALLOW_WHILE_ON_BODY, KeyParameterValue.boolValue(true)))
+    }
+    if (this.trustedUserPresenceRequired == true) {
+        authList.add(
+            createAuth(Tag.TRUSTED_USER_PRESENCE_REQUIRED, KeyParameterValue.boolValue(true))
+        )
+    }
+    if (this.trustedConfirmationRequired == true) {
+        authList.add(
+            createAuth(Tag.TRUSTED_CONFIRMATION_REQUIRED, KeyParameterValue.boolValue(true))
+        )
+    }
+    if (this.maxUsesPerBoot != null) {
+        authList.add(
+            createAuth(Tag.MAX_USES_PER_BOOT, KeyParameterValue.integer(this.maxUsesPerBoot))
+        )
+    }
+    if (this.maxBootLevel != null) {
+        authList.add(
+            createAuth(Tag.MAX_BOOT_LEVEL, KeyParameterValue.integer(this.maxBootLevel))
+        )
+    }
+
     authList.add(
         createAuth(Tag.ORIGIN, KeyParameterValue.origin(this.origin ?: KeyOrigin.GENERATED))
     )
@@ -896,20 +926,47 @@ private fun KeyMintAttestation.toAuthorizations(
         authList.add(createAuth(Tag.BOOT_PATCHLEVEL, KeyParameterValue.integer(bootPatch)))
     }
 
+    // Software-enforced tags: CREATION_DATETIME, enforcement dates, USER_ID.
+    fun createSwAuth(tag: Int, value: KeyParameterValue): Authorization {
+        val param =
+            KeyParameter().apply {
+                this.tag = tag
+                this.value = value
+            }
+        return Authorization().apply {
+            this.keyParameter = param
+            this.securityLevel = SecurityLevel.SOFTWARE
+        }
+    }
+
     authList.add(
-        createAuth(Tag.CREATION_DATETIME, KeyParameterValue.dateTime(System.currentTimeMillis()))
+        createSwAuth(Tag.CREATION_DATETIME, KeyParameterValue.dateTime(System.currentTimeMillis()))
     )
 
-    // USER_ID is a software-level property. PER_USER_RANGE = 100000.
+    this.activeDateTime?.let {
+        authList.add(createSwAuth(Tag.ACTIVE_DATETIME, KeyParameterValue.dateTime(it.time)))
+    }
+    this.originationExpireDateTime?.let {
+        authList.add(
+            createSwAuth(Tag.ORIGINATION_EXPIRE_DATETIME, KeyParameterValue.dateTime(it.time))
+        )
+    }
+    this.usageExpireDateTime?.let {
+        authList.add(
+            createSwAuth(Tag.USAGE_EXPIRE_DATETIME, KeyParameterValue.dateTime(it.time))
+        )
+    }
+    this.usageCountLimit?.let {
+        authList.add(createSwAuth(Tag.USAGE_COUNT_LIMIT, KeyParameterValue.integer(it)))
+    }
+    if (this.unlockedDeviceRequired == true) {
+        authList.add(
+            createSwAuth(Tag.UNLOCKED_DEVICE_REQUIRED, KeyParameterValue.boolValue(true))
+        )
+    }
+
     authList.add(
-        Authorization().apply {
-            this.keyParameter =
-                KeyParameter().apply {
-                    this.tag = Tag.USER_ID
-                    this.value = KeyParameterValue.integer(callingUid / 100000)
-                }
-            this.securityLevel = SecurityLevel.SOFTWARE
-        }
+        createSwAuth(Tag.USER_ID, KeyParameterValue.integer(callingUid / 100000))
     )
 
     return authList.toTypedArray()
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index 79448a23..bc36cb9a 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -37,6 +37,9 @@ internal object KeystoreErrorCode {
     /** KeyMint ErrorCode::INVALID_ARGUMENT */
     const val INVALID_ARGUMENT = -38
 
+    /** KeyMint ErrorCode::INVALID_TAG */
+    const val INVALID_TAG = -40
+
     /** Keystore2 ResponseCode::PERMISSION_DENIED */
     const val PERMISSION_DENIED = 6
 
@@ -118,7 +121,9 @@ private class Signer(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPrimi
             initSign(keyPair.private)
         }
 
-    override fun updateAad(data: ByteArray?) {}
+    override fun updateAad(data: ByteArray?) {
+        throw ServiceSpecificException(KeystoreErrorCode.INVALID_TAG)
+    }
 
     override fun update(data: ByteArray?): ByteArray? {
         if (data != null) signature.update(data)
@@ -140,7 +145,9 @@ private class Verifier(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPri
             initVerify(keyPair.public)
         }
 
-    override fun updateAad(data: ByteArray?) {}
+    override fun updateAad(data: ByteArray?) {
+        throw ServiceSpecificException(KeystoreErrorCode.INVALID_TAG)
+    }
 
     override fun update(data: ByteArray?): ByteArray? {
         if (data != null) signature.update(data)
@@ -201,6 +208,33 @@ private class CipherPrimitive(
     }
 }
 
+// Concrete implementation for ECDH Key Agreement.
+private class KeyAgreementPrimitive(keyPair: KeyPair) : CryptoPrimitive {
+    private val agreement: javax.crypto.KeyAgreement =
+        javax.crypto.KeyAgreement.getInstance("ECDH").apply { init(keyPair.private) }
+
+    override fun updateAad(data: ByteArray?) {
+        throw ServiceSpecificException(KeystoreErrorCode.INVALID_TAG)
+    }
+
+    override fun update(data: ByteArray?): ByteArray? = null
+
+    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
+        if (data == null)
+            throw ServiceSpecificException(
+                KeystoreErrorCode.INVALID_ARGUMENT,
+                "Peer public key required for key agreement",
+            )
+        val peerKey =
+            java.security.KeyFactory.getInstance("EC")
+                .generatePublic(java.security.spec.X509EncodedKeySpec(data))
+        agreement.doPhase(peerKey, true)
+        return agreement.generateSecret()
+    }
+
+    override fun abort() {}
+}
+
 /**
  * A software-only implementation of a cryptographic operation. This class acts as a controller,
  * delegating to a specific cryptographic primitive based on the operation's purpose.
@@ -236,6 +270,7 @@ class SoftwareOperation(
                     val key: java.security.Key = secretKey ?: keyPair!!.private
                     CipherPrimitive(key, params, Cipher.DECRYPT_MODE)
                 }
+                KeyPurpose.AGREE_KEY -> KeyAgreementPrimitive(keyPair!!)
                 else ->
                     throw ServiceSpecificException(
                         KeystoreErrorCode.UNSUPPORTED_PURPOSE,

From 4c8d078d24ca527ede0927462834022c3b5eefb7 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Sat, 21 Mar 2026 23:15:34 +0100
Subject: [PATCH 51/56] Harden getKeyEntry cache resolution and restore import
 key skip

---
 .../keystore/Keystore2Interceptor.kt          | 28 +++++++++++++++++--
 1 file changed, 25 insertions(+), 3 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
index 65917f4e..33e764ec 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt
@@ -73,6 +73,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                 LIST_ENTRIES_BATCHED_TRANSACTION,
                 GET_NUMBER_OF_ENTRIES_TRANSACTION,
             )
+            .filter { it != -1 } // Exclude methods unavailable on this Android version
             .toIntArray()
     }
 
@@ -151,7 +152,9 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         ) {
             logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
 
-            if (ConfigurationManager.shouldSkipUid(callingUid))
+            val skipUid = ConfigurationManager.shouldSkipUid(callingUid)
+
+            if (skipUid && code == UPDATE_SUBCOMPONENT_TRANSACTION)
                 return TransactionResult.ContinueAndSkipPost
 
             if (code == UPDATE_SUBCOMPONENT_TRANSACTION)
@@ -196,9 +199,17 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
             }
             val keyId = KeyIdentifier(callingUid, descriptor.alias)
 
+            // Always return software-generated keys from cache, even if UID
+            // config changed after generation. Without this, a config reload
+            // mid-session orphans keys that only exist in memory.
             val response =
                 KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId)
-                    ?: return TransactionResult.Continue
+            if (response == null) {
+                val action = if (skipUid) "passthrough (skipped UID)" else "forwarding to hardware"
+                SystemLogger.debug("[TX_ID: $txId] getKeyEntry ${descriptor.alias}: cache miss, $action")
+                return if (skipUid) TransactionResult.ContinueAndSkipPost
+                else TransactionResult.Continue
+            }
 
             if (KeyMintSecurityLevelInterceptor.isAttestationKey(keyId))
                 SystemLogger.info("${descriptor.alias} was an attestation key")
@@ -233,8 +244,14 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         reply: Parcel?,
         resultCode: Int,
     ): TransactionResult {
-        if (target != keystoreService || reply == null || InterceptorUtils.hasException(reply))
+        if (target != keystoreService || reply == null || InterceptorUtils.hasException(reply)) {
+            if (reply != null && InterceptorUtils.hasException(reply)) {
+                SystemLogger.debug(
+                    "[TX_ID: $txId] post-${transactionNames[code] ?: code}: hardware returned exception, forwarding as-is"
+                )
+            }
             return TransactionResult.SkipTransaction
+        }
 
         if (code == GET_NUMBER_OF_ENTRIES_TRANSACTION) {
             logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
@@ -303,6 +320,11 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                             authorizations?.map { it.keyParameter }?.toTypedArray() ?: emptyArray()
                         )
 
+                    if (parsedParameters.isImportKey()) {
+                        SystemLogger.info("[TX_ID: $txId] Skip patching for imported keys.")
+                        return TransactionResult.SkipTransaction
+                    }
+
                     if (parsedParameters.isAttestKey() &&
                         !KeyMintSecurityLevelInterceptor.importedKeys.contains(keyId)
                     ) {

From 2b3e5dedb4e054b9a93767f266062a4a527f7cb9 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Sat, 21 Mar 2026 23:15:55 +0100
Subject: [PATCH 52/56] Verify TEE attestation capability, pass operation
 params, and add SECOND_IMEI

---
 .../shim/KeyMintSecurityLevelInterceptor.kt   | 113 ++++++++++++------
 1 file changed, 74 insertions(+), 39 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
index 5b64fed0..84d0a6b5 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/KeyMintSecurityLevelInterceptor.kt
@@ -15,6 +15,8 @@ import java.security.SecureRandom
 import java.security.cert.Certificate
 import java.util.concurrent.CompletableFuture
 import java.util.concurrent.ConcurrentHashMap
+import org.matrix.TEESimulator.attestation.ATTESTATION_OID
+import org.matrix.TEESimulator.attestation.AttestationConstants
 import org.matrix.TEESimulator.attestation.AttestationPatcher
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.config.ConfigurationManager
@@ -102,8 +104,15 @@ class KeyMintSecurityLevelInterceptor(
         resultCode: Int,
     ): TransactionResult {
         // We only care about successful transactions.
-        if (resultCode != 0 || reply == null || InterceptorUtils.hasException(reply))
+        if (resultCode != 0 || reply == null || InterceptorUtils.hasException(reply)) {
+            val reason = when {
+                resultCode != 0 -> "binder error (resultCode=$resultCode)"
+                reply != null && InterceptorUtils.hasException(reply) -> "service exception in reply"
+                else -> "null reply"
+            }
+            SystemLogger.debug("[TX_ID: $txId] post-${transactionNames[code] ?: code}: skipped ($reason)")
             return TransactionResult.SkipTransaction
+        }
 
         if (code == IMPORT_KEY_TRANSACTION) {
             logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
@@ -115,24 +124,6 @@ class KeyMintSecurityLevelInterceptor(
             val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
             cleanupKeyData(keyId)
             importedKeys.add(keyId)
-
-            // Patch imported key certificates the same way as generated keys.
-            if (!ConfigurationManager.shouldSkipUid(callingUid)) {
-                val metadata: KeyMetadata =
-                    reply.readTypedObject(KeyMetadata.CREATOR)
-                        ?: return TransactionResult.SkipTransaction
-                val originalChain = CertificateHelper.getCertificateChain(metadata)
-                if (originalChain != null && originalChain.size > 1) {
-                    val newChain =
-                        AttestationPatcher.patchCertificateChain(originalChain, callingUid)
-                    CertificateHelper.updateCertificateChain(metadata, newChain).getOrThrow()
-                    metadata.authorizations =
-                        InterceptorUtils.patchAuthorizations(metadata.authorizations, callingUid)
-                    patchedChains[keyId] = newChain
-                    SystemLogger.debug("Cached patched certificate chain for imported key $keyId.")
-                    return InterceptorUtils.createTypedObjectReply(metadata)
-                }
-            }
         } else if (code == CREATE_OPERATION_TRANSACTION) {
             logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
 
@@ -345,13 +336,19 @@ class KeyMintSecurityLevelInterceptor(
                 // Use key params for crypto properties (algorithm, digest, etc.) but
                 // override purpose from the operation params.
                 val effectiveParams =
-                    keyParams.copy(purpose = parsedOpParams.purpose, digest = parsedOpParams.digest.ifEmpty { keyParams.digest })
+                    keyParams.copy(
+                        purpose = parsedOpParams.purpose,
+                        digest = parsedOpParams.digest.ifEmpty { keyParams.digest },
+                        blockMode = parsedOpParams.blockMode.ifEmpty { keyParams.blockMode },
+                        padding = parsedOpParams.padding.ifEmpty { keyParams.padding },
+                    )
                 val softwareOperation =
                     SoftwareOperation(
                         txId,
                         generatedKeyInfo.keyPair,
                         generatedKeyInfo.secretKey,
                         effectiveParams,
+                        opParams,
                     )
 
                 // Decrement usage counter on finish; delete key when exhausted.
@@ -421,6 +418,7 @@ class KeyMintSecurityLevelInterceptor(
                     params.any {
                         it.tag == Tag.ATTESTATION_ID_SERIAL ||
                             it.tag == Tag.ATTESTATION_ID_IMEI ||
+                            it.tag == Tag.ATTESTATION_ID_SECOND_IMEI ||
                             it.tag == Tag.ATTESTATION_ID_MEID ||
                             it.tag == Tag.DEVICE_UNIQUE_ATTESTATION
                     }
@@ -469,18 +467,30 @@ class KeyMintSecurityLevelInterceptor(
                 val isAuto = ConfigurationManager.isAutoMode(callingUid)
 
                 when {
-                    forceGenerate -> doSoftwareGeneration(
-                        callingUid, keyDescriptor, attestationKey, parsedParams, isAttestKeyRequest
-                    )
-                    isAuto && !teeFunctional -> raceTeePatch(
-                        callingUid, keyDescriptor, attestationKey, params, parsedParams, isAttestKeyRequest
-                    )
-                    parsedParams.attestationChallenge != null -> TransactionResult.Continue
-                    else -> TransactionResult.ContinueAndSkipPost
+                    forceGenerate -> {
+                        SystemLogger.debug("generateKey ${keyDescriptor.alias}: mode=GENERATE")
+                        doSoftwareGeneration(
+                            callingUid, keyDescriptor, attestationKey, parsedParams, isAttestKeyRequest
+                        )
+                    }
+                    isAuto && !teeFunctional -> {
+                        SystemLogger.debug("generateKey ${keyDescriptor.alias}: mode=AUTO (racing)")
+                        raceTeePatch(
+                            callingUid, keyDescriptor, attestationKey, params, parsedParams, isAttestKeyRequest
+                        )
+                    }
+                    parsedParams.attestationChallenge != null -> {
+                        SystemLogger.debug("generateKey ${keyDescriptor.alias}: mode=PATCH (forwarding to TEE)")
+                        TransactionResult.Continue
+                    }
+                    else -> {
+                        SystemLogger.debug("generateKey ${keyDescriptor.alias}: no challenge, passthrough")
+                        TransactionResult.ContinueAndSkipPost
+                    }
                 }
             }
             .getOrElse { e ->
-                SystemLogger.error("No key pair generated for UID $callingUid.", e)
+                SystemLogger.error("generateKey failed for UID $callingUid: ${e.javaClass.simpleName}", e)
                 val code =
                     if (e is android.os.ServiceSpecificException) e.errorCode
                     else SECURE_HW_COMMUNICATION_FAILED
@@ -565,6 +575,10 @@ class KeyMintSecurityLevelInterceptor(
         TeeLatencySimulator.simulateGenerateKeyDelay(
             parsedParams.algorithm, System.nanoTime() - genStartNanos
         )
+        val elapsedMs = (System.nanoTime() - genStartNanos) / 1_000_000.0
+        SystemLogger.debug(
+            "doSoftwareGeneration ${keyDescriptor.alias}: completed in %.1fms (chain=${keyData.second.size} certs, nspace=${keyDescriptor.nspace})".format(elapsedMs)
+        )
         return InterceptorUtils.createTypedObjectReply(response.metadata)
     }
 
@@ -619,18 +633,39 @@ class KeyMintSecurityLevelInterceptor(
         return try {
             val teeMetadata = threadA.join()
             threadB.cancel(true)
-            teeFunctional = true
-            SystemLogger.info("AUTO: TEE succeeded for ${keyDescriptor.alias}, marked functional.")
 
             val originalChain = CertificateHelper.getCertificateChain(teeMetadata)
-            if (originalChain != null && originalChain.size > 1) {
-                val newChain = AttestationPatcher.patchCertificateChain(originalChain, callingUid)
-                CertificateHelper.updateCertificateChain(teeMetadata, newChain).getOrThrow()
-                teeMetadata.authorizations =
-                    InterceptorUtils.patchAuthorizations(teeMetadata.authorizations, callingUid)
-                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
-                cleanupKeyData(keyId)
-                patchedChains[keyId] = newChain
+
+            // Verify TEE attestation: the leaf cert must contain the attestation
+            // extension with the exact challenge we requested. Only then is the TEE
+            // proven capable of attestation and the chain can be patched.
+            if (parsedParams.attestationChallenge != null &&
+                originalChain != null && originalChain.size > 1
+            ) {
+                val verified = runCatching {
+                    val leaf = org.bouncycastle.cert.X509CertificateHolder(originalChain[0].encoded)
+                    val ext = leaf.getExtension(ATTESTATION_OID)
+                    if (ext != null) {
+                        val seq = org.bouncycastle.asn1.ASN1Sequence.getInstance(ext.extnValue.octets)
+                        val challenge = (seq.getObjectAt(
+                            AttestationConstants.KEY_DESCRIPTION_ATTESTATION_CHALLENGE_INDEX
+                        ) as org.bouncycastle.asn1.ASN1OctetString).octets
+                        challenge.contentEquals(parsedParams.attestationChallenge)
+                    } else false
+                }.getOrDefault(false)
+
+                if (verified) {
+                    teeFunctional = true
+                    SystemLogger.info("AUTO: TEE attestation verified for ${keyDescriptor.alias}, marked functional.")
+
+                    val newChain = AttestationPatcher.patchCertificateChain(originalChain, callingUid)
+                    CertificateHelper.updateCertificateChain(teeMetadata, newChain).getOrThrow()
+                    teeMetadata.authorizations =
+                        InterceptorUtils.patchAuthorizations(teeMetadata.authorizations, callingUid)
+                    val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
+                    cleanupKeyData(keyId)
+                    patchedChains[keyId] = newChain
+                }
             }
 
             // Cache the patched response for getKeyEntry. Stored in teeResponses

From 25538dacb153be62a7424d2ef23050f9b07b5160 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Sat, 21 Mar 2026 23:16:10 +0100
Subject: [PATCH 53/56] Handle IV/nonce, OAEP, GCM tags, CTR mode, and ECDH in
 software operations

---
 .../keystore/shim/SoftwareOperation.kt        | 56 +++++++++++++++++--
 1 file changed, 50 insertions(+), 6 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
index bc36cb9a..ff2cf3f9 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt
@@ -99,6 +99,7 @@ private object JcaAlgorithmMapper {
             when (params.blockMode.firstOrNull()) {
                 BlockMode.ECB -> "ECB"
                 BlockMode.CBC -> "CBC"
+                BlockMode.CTR -> "CTR"
                 BlockMode.GCM -> "GCM"
                 else -> "ECB" // Default for RSA
             }
@@ -178,10 +179,39 @@ private class CipherPrimitive(
     cryptoKey: java.security.Key,
     params: KeyMintAttestation,
     private val opMode: Int,
+    nonce: ByteArray?,
+    macLength: Int?,
 ) : CryptoPrimitive {
     private val cipher: Cipher =
         Cipher.getInstance(JcaAlgorithmMapper.mapCipherAlgorithm(params)).apply {
-            init(opMode, cryptoKey)
+            val algSpec = when {
+                nonce != null && params.blockMode.contains(BlockMode.GCM) ->
+                    javax.crypto.spec.GCMParameterSpec((macLength ?: 128), nonce)
+                params.padding.contains(PaddingMode.RSA_OAEP) -> {
+                    val mgfDigest = when (params.rsaOaepMgfDigest.firstOrNull()) {
+                        Digest.SHA_2_256 -> "SHA-256"
+                        Digest.SHA_2_384 -> "SHA-384"
+                        Digest.SHA_2_512 -> "SHA-512"
+                        else -> "SHA-1"
+                    }
+                    val mainDigest = when (params.digest.firstOrNull()) {
+                        Digest.SHA_2_256 -> "SHA-256"
+                        Digest.SHA_2_384 -> "SHA-384"
+                        Digest.SHA_2_512 -> "SHA-512"
+                        else -> "SHA-1"
+                    }
+                    javax.crypto.spec.OAEPParameterSpec(
+                        mainDigest,
+                        "MGF1",
+                        java.security.spec.MGF1ParameterSpec(mgfDigest),
+                        javax.crypto.spec.PSource.PSpecified.DEFAULT,
+                    )
+                }
+                nonce != null ->
+                    javax.crypto.spec.IvParameterSpec(nonce)
+                else -> null
+            }
+            if (algSpec != null) init(opMode, cryptoKey, algSpec) else init(opMode, cryptoKey)
         }
 
     override fun updateAad(data: ByteArray?) {
@@ -191,8 +221,13 @@ private class CipherPrimitive(
     override fun update(data: ByteArray?): ByteArray? =
         if (data != null) cipher.update(data) else null
 
-    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? =
-        if (data != null) cipher.doFinal(data) else cipher.doFinal()
+    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
+        return try {
+            if (data != null) cipher.doFinal(data) else cipher.doFinal()
+        } catch (e: javax.crypto.AEADBadTagException) {
+            throw ServiceSpecificException(KeystoreErrorCode.VERIFICATION_FAILED, "GCM tag verification failed")
+        }
+    }
 
     override fun abort() {}
 
@@ -247,6 +282,7 @@ class SoftwareOperation(
     keyPair: KeyPair?,
     secretKey: javax.crypto.SecretKey?,
     params: KeyMintAttestation,
+    opParams: Array<KeyParameter> = emptyArray(),
     var onFinishCallback: (() -> Unit)? = null,
 ) {
     private val primitive: CryptoPrimitive
@@ -264,11 +300,15 @@ class SoftwareOperation(
                 KeyPurpose.VERIFY -> Verifier(keyPair!!, params)
                 KeyPurpose.ENCRYPT -> {
                     val key: java.security.Key = secretKey ?: keyPair!!.public
-                    CipherPrimitive(key, params, Cipher.ENCRYPT_MODE)
+                    val nonce = opParams.find { it.tag == Tag.NONCE }?.value?.blob
+                    val macLen = opParams.find { it.tag == Tag.MAC_LENGTH }?.value?.integer
+                    CipherPrimitive(key, params, Cipher.ENCRYPT_MODE, nonce, macLen)
                 }
                 KeyPurpose.DECRYPT -> {
                     val key: java.security.Key = secretKey ?: keyPair!!.private
-                    CipherPrimitive(key, params, Cipher.DECRYPT_MODE)
+                    val nonce = opParams.find { it.tag == Tag.NONCE }?.value?.blob
+                    val macLen = opParams.find { it.tag == Tag.MAC_LENGTH }?.value?.integer
+                    CipherPrimitive(key, params, Cipher.DECRYPT_MODE, nonce, macLen)
                 }
                 KeyPurpose.AGREE_KEY -> KeyAgreementPrimitive(keyPair!!)
                 else ->
@@ -328,7 +368,11 @@ class SoftwareOperation(
         try {
             val result = primitive.finish(data, signature)
             SystemLogger.info("[SoftwareOp TX_ID: $txId] Finished operation successfully.")
-            onFinishCallback?.invoke()
+            try {
+                onFinishCallback?.invoke()
+            } catch (e: Exception) {
+                SystemLogger.error("[SoftwareOp TX_ID: $txId] onFinishCallback failed.", e)
+            }
             return result
         } catch (e: ServiceSpecificException) {
             throw e

From d839b6932382d3a2d1242df08fba79762ba9c468 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Sat, 21 Mar 2026 23:16:39 +0100
Subject: [PATCH 54/56] Fix silent error paths, challenge error code, and null
 handling

---
 .../attestation/AttestationBuilder.kt         |  4 +++-
 .../interception/keystore/InterceptorUtils.kt | 22 ++++++++++++++-----
 .../keystore/ListEntriesHandler.kt            |  2 +-
 .../keystore/shim/OperationInterceptor.kt     |  7 +++++-
 .../TEESimulator/pki/CertificateGenerator.kt  |  4 ++--
 5 files changed, 29 insertions(+), 10 deletions(-)

diff --git a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
index 499a14d1..02dcad34 100644
--- a/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/attestation/AttestationBuilder.kt
@@ -591,7 +591,9 @@ object AttestationBuilder {
 
             packageInfoList.add(packageInfo.packageName to packageInfo.longVersionCode)
 
-            packageInfo.signingInfo?.signingCertificateHistory?.forEach { signature ->
+            val certs = packageInfo.signingInfo?.signingCertificateHistory
+                ?: packageInfo.signingInfo?.apkContentsSigners
+            certs?.forEach { signature ->
                 signatureDigests.add(Digest(sha256.digest(signature.toByteArray())))
             }
         }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
index d404eef5..8ea04038 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt
@@ -113,21 +113,33 @@ object InterceptorUtils {
 
     /** Checks if a reply parcel contains an exception without consuming it. */
     fun hasException(reply: Parcel): Boolean {
-        val exception = runCatching { reply.readException() }.exceptionOrNull()
-        if (exception != null) reply.setDataPosition(0)
-        return exception != null
+        val pos = reply.dataPosition()
+        return try {
+            reply.readException()
+            false
+        } catch (_: Exception) {
+            reply.setDataPosition(pos)
+            true
+        }
     }
 
     /**
      * Creates an `OverrideReply` that writes a `ServiceSpecificException` with the given error
-     * code via EX_SERVICE_SPECIFIC.
+     * code. Uses the C++ binder::Status wire format which includes a remote stack trace
+     * header between the message and the error code. Java's Parcel.writeException omits
+     * this header, making it incompatible with native C++ AIDL clients on Android 12+.
+     *
+     * Wire format: [int32 exceptionCode] [String16 message] [int32 stackTraceSize=0] [int32 errorCode]
      */
     fun createServiceSpecificErrorReply(
         errorCode: Int
     ): BinderInterceptor.TransactionResult.OverrideReply {
         val parcel =
             Parcel.obtain().apply {
-                writeException(android.os.ServiceSpecificException(errorCode))
+                writeInt(-8) // EX_SERVICE_SPECIFIC
+                writeString(null) // message (null → writeInt(-1) as String16 null marker)
+                writeInt(0) // remote stack trace header size (empty)
+                writeInt(errorCode) // service-specific error code
             }
         return BinderInterceptor.TransactionResult.OverrideReply(parcel)
     }
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/ListEntriesHandler.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/ListEntriesHandler.kt
index 2cad788a..dae4ecbc 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/ListEntriesHandler.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/ListEntriesHandler.kt
@@ -81,7 +81,7 @@ object ListEntriesHandler {
         // See AOSP function `get_key_descriptor_for_lookup` in service.rs.
         val keysToInject =
             extractGeneratedKeyDescriptors(callingUid, callingUid.toLong(), params.startPastAlias)
-        val originalList = reply.createTypedArray(KeyDescriptor.CREATOR)!!
+        val originalList = reply.createTypedArray(KeyDescriptor.CREATOR) ?: emptyArray()
         val mergedArray = mergeKeyDescriptors(originalList, keysToInject)
 
         // Limit response size to avoid binder buffer overflow.
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt
index adfd18db..b0748dc9 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt
@@ -5,6 +5,7 @@ import android.os.Parcel
 import android.system.keystore2.IKeystoreOperation
 import org.matrix.TEESimulator.interception.core.BinderInterceptor
 import org.matrix.TEESimulator.interception.keystore.InterceptorUtils
+import org.matrix.TEESimulator.logging.SystemLogger
 
 /**
  * Intercepts calls to an `IKeystoreOperation` service. This is used to log the data manipulation
@@ -28,7 +29,11 @@ class OperationInterceptor(
         logTransaction(txId, methodName, callingUid, callingPid, true)
 
         if (code == FINISH_TRANSACTION || code == ABORT_TRANSACTION) {
-            KeyMintSecurityLevelInterceptor.removeOperationInterceptor(target, backdoor)
+            try {
+                KeyMintSecurityLevelInterceptor.removeOperationInterceptor(target, backdoor)
+            } catch (e: Exception) {
+                SystemLogger.error("[TX_ID: $txId] Failed to unregister operation interceptor.", e)
+            }
         }
 
         return TransactionResult.ContinueAndSkipPost
diff --git a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
index 50a92f37..9bd17b11 100644
--- a/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/pki/CertificateGenerator.kt
@@ -89,8 +89,8 @@ object CertificateGenerator {
     ): List<Certificate>? {
         val challenge = params.attestationChallenge
         if (challenge != null && challenge.size > AttestationConstants.CHALLENGE_LENGTH_LIMIT)
-            throw IllegalArgumentException(
-                "Attestation challenge exceeds length limit (${challenge.size} > ${AttestationConstants.CHALLENGE_LENGTH_LIMIT})"
+            throw android.os.ServiceSpecificException(
+                -21, // INVALID_INPUT_LENGTH (KM_ERROR_INVALID_INPUT_LENGTH)
             )
 
         return try {

From 7a7e36222b9f489b3cef735838429a43975daf81 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Sat, 21 Mar 2026 23:16:53 +0100
Subject: [PATCH 55/56] Add dir class to sepolicy and crash safety for binder
 interceptors

---
 app/src/main/cpp/binder_interceptor.cpp       | 47 ++++++++++++++++---
 .../interception/core/BinderInterceptor.kt    | 12 +++++
 module/sepolicy.rule                          |  3 +-
 3 files changed, 55 insertions(+), 7 deletions(-)

diff --git a/app/src/main/cpp/binder_interceptor.cpp b/app/src/main/cpp/binder_interceptor.cpp
index 8eef4ed7..79ded3ec 100644
--- a/app/src/main/cpp/binder_interceptor.cpp
+++ b/app/src/main/cpp/binder_interceptor.cpp
@@ -314,7 +314,11 @@ class BinderStub : public BBinder {
         }
 
         if (!found_context) {
-            LOGW("BinderStub received transaction but no context found for thread");
+            LOGW("BinderStub received transaction but no context found for thread (code=%u)", code);
+#ifndef NDEBUG
+            std::lock_guard<std::mutex> dbg_lock(g_thread_context_mutex);
+            LOGW("  Thread context map has %zu entries", g_thread_context_map.size());
+#endif
             return UNKNOWN_TRANSACTION;
         }
 
@@ -400,6 +404,9 @@ void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
             }
             // Manually release the temporary strong reference we acquired at the start.
             target_binder_ptr->decStrong(nullptr);
+        } else {
+            LOGD("[Hook] attemptIncStrong failed for target %p (code=%u, uid=%d) — binder may be dying",
+                 reinterpret_cast<void*>(txn_data->target.ptr), txn_data->code, txn_data->sender_euid);
         }
     }
 
@@ -416,7 +423,13 @@ void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
 
         // Store context for the stub to retrieve later in its onTransact
         std::lock_guard<std::mutex> lock(g_thread_context_mutex);
-        g_thread_context_map[std::this_thread::get_id()].push(std::move(info));
+        auto &queue = g_thread_context_map[std::this_thread::get_id()];
+        queue.push(std::move(info));
+#ifndef NDEBUG
+        if (queue.size() > 8) {
+            LOGW("[Hook] Thread context queue depth=%zu for thread — possible leak", queue.size());
+        }
+#endif
     }
 }
 
@@ -613,8 +626,24 @@ bool BinderInterceptor::processInterceptedTransaction(uint64_t tx_id, sp<BBinder
     Parcel pre_req, pre_resp;
     writeTransactionData(pre_req, tx_id, target, code, flags, request);
 
-    if (callback->transact(intercept::kPreTransact, pre_req, &pre_resp) != OK) {
-        LOGW("[TX_ID: %" PRIu64 "] Pre-transaction callback failed. Forwarding original call.", tx_id);
+#ifndef NDEBUG
+    struct timespec ts_start{};
+    clock_gettime(CLOCK_MONOTONIC, &ts_start);
+#endif
+
+    status_t pre_cb_status = callback->transact(intercept::kPreTransact, pre_req, &pre_resp);
+
+#ifndef NDEBUG
+    struct timespec ts_end{};
+    clock_gettime(CLOCK_MONOTONIC, &ts_end);
+    double pre_ms = (ts_end.tv_sec - ts_start.tv_sec) * 1000.0 + (ts_end.tv_nsec - ts_start.tv_nsec) / 1e6;
+    if (pre_ms > 5000.0) {
+        LOGW("[TX_ID: %" PRIu64 "] Pre-callback took %.0fms (code=%u) — possible hang", tx_id, pre_ms, code);
+    }
+#endif
+
+    if (pre_cb_status != OK) {
+        LOGW("[TX_ID: %" PRIu64 "] Pre-transaction callback failed (status=%d). Forwarding original call.", tx_id, pre_cb_status);
         return false; // Callback failed, proceed as if not intercepted
     }
 
@@ -648,8 +677,10 @@ bool BinderInterceptor::processInterceptedTransaction(uint64_t tx_id, sp<BBinder
     if (action == intercept::kActionOverrideData) {
         size_t size = pre_resp.readUint64();
         final_request.appendFrom(&pre_resp, pre_resp.dataPosition(), size);
+    } else if (action == intercept::kActionContinue) {
+        final_request.appendFrom(&request, 0, request.dataSize());
     } else {
-        // Default (kActionContinue): Use original data
+        LOGW("[TX_ID: %" PRIu64 "] Unknown pre-callback action %d (code=%u). Forwarding original data.", tx_id, action, code);
         final_request.appendFrom(&request, 0, request.dataSize());
     }
 
@@ -668,7 +699,8 @@ bool BinderInterceptor::processInterceptedTransaction(uint64_t tx_id, sp<BBinder
         VALIDATE_STATUS(tx_id, post_req.appendFrom(reply, 0, reply_size));
     }
 
-    if (callback->transact(intercept::kPostTransact, post_req, &post_resp) == OK) {
+    status_t post_cb_status = callback->transact(intercept::kPostTransact, post_req, &post_resp);
+    if (post_cb_status == OK) {
         int32_t post_action = post_resp.readInt32();
         if (post_action == intercept::kActionOverrideReply && reply) {
             result = post_resp.readInt32(); // Read new status
@@ -676,6 +708,9 @@ bool BinderInterceptor::processInterceptedTransaction(uint64_t tx_id, sp<BBinder
             reply->setDataSize(0); // Clear original reply
             VALIDATE_STATUS(tx_id, reply->appendFrom(&post_resp, post_resp.dataPosition(), new_size));
         }
+    } else {
+        LOGW("[TX_ID: %" PRIu64 "] Post-transaction callback failed (status=%d, code=%u). Using original reply.",
+             tx_id, post_cb_status, code);
     }
 
     return true; // We handled the flow, even if we just forwarded it
diff --git a/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt b/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt
index b5bc3900..fdc75553 100644
--- a/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt
+++ b/app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt
@@ -148,6 +148,12 @@ abstract class BinderInterceptor : Binder() {
                 callingPid,
                 transactionData,
             )
+        } catch (e: Exception) {
+            SystemLogger.error(
+                "[TX_ID: $txId] onPreTransact crashed (code=$transactionCode, uid=$callingUid)",
+                e,
+            )
+            TransactionResult.ContinueAndSkipPost
         } finally {
             transactionData.recycle()
         }
@@ -191,6 +197,12 @@ abstract class BinderInterceptor : Binder() {
                 reply,
                 resultCode,
             )
+        } catch (e: Exception) {
+            SystemLogger.error(
+                "[TX_ID: $txId] onPostTransact crashed (code=$transactionCode, uid=$callingUid, resultCode=${data.readInt()})",
+                e,
+            )
+            TransactionResult.SkipTransaction
         } finally {
             transactionData.recycle()
             transactionReply.recycle()
diff --git a/module/sepolicy.rule b/module/sepolicy.rule
index 21b522ac..50e02fdd 100644
--- a/module/sepolicy.rule
+++ b/module/sepolicy.rule
@@ -1,2 +1,3 @@
-allow keystore {adb_data_file shell_data_file} file *
+allow keystore {adb_data_file shell_data_file} {file dir} *
 allow crash_dump keystore process *
+allow crash_dump keystore {dir file lnk_file} *

From 92186573b7875d0180e1e3d3b33c922d3949e209 Mon Sep 17 00:00:00 2001
From: Mohammed Riad <1@mhmrdd.me>
Date: Sat, 21 Mar 2026 23:17:10 +0100
Subject: [PATCH 56/56] Wire DEBUG flag to build variant and add bughunter
 logcat capture

---
 app/build.gradle.kts | 14 +++++++++++++-
 module/service.sh    | 17 +++++++++++++++++
 2 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 7b873290..bf9091be 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -122,7 +122,7 @@ androidComponents {
                 // Now, copy and process the files from 'module' directory.
                 val sourceModuleDir = rootProject.projectDir.resolve("module")
                 from(sourceModuleDir) {
-                    exclude("module.prop") // Exclude the template file.
+                    exclude("module.prop", "service.sh") // Exclude templated files.
                 }
 
                 // Copy and filter the module.prop template separately.
@@ -136,6 +136,18 @@ androidComponents {
                     )
                 }
 
+                // Wire DEBUG flag in service.sh to the build variant.
+                // Cannot use expand() here because shell syntax ${0%/*} conflicts.
+                // FixCrLfFilter applied last to ensure LF output on Windows.
+                from(sourceModuleDir) {
+                    include("service.sh")
+                    filter { it.replace("DEBUG=false", "DEBUG=$isDebug") }
+                    filter(
+                        mapOf("eol" to org.apache.tools.ant.filters.FixCrLfFilter.CrLf.newInstance("lf")),
+                        org.apache.tools.ant.filters.FixCrLfFilter::class.java,
+                    )
+                }
+
                 // The destination for all the above 'from' operations.
                 into(tempModuleDir)
             }
diff --git a/module/service.sh b/module/service.sh
index b2a35624..cd3466c3 100644
--- a/module/service.sh
+++ b/module/service.sh
@@ -4,6 +4,23 @@ MODDIR=${0%/*}
 
 cd $MODDIR
 
+# Continuous logcat capture for debug builds.
+if [ "$DEBUG" = "true" ]; then
+  BUGHUNTER_DIR="/data/adb/tricky_store/bughunter"
+  mkdir -p "$BUGHUNTER_DIR"
+  LOGFILE="$BUGHUNTER_DIR/bughunter_$(date +%Y%m%d_%H%M%S).log"
+  # Restart loop: if logcat is killed (lmkd, oom, etc.), it respawns.
+  # Append mode (>>) preserves data across restarts.
+  # head -c caps total output at 8MB then the pipeline terminates logcat.
+  (while true; do
+    logcat -v threadtime -T 1 -s "TEESimulator:*" 2>/dev/null | head -c 8388608 >> "$LOGFILE"
+    # head exits after 8MB causing logcat to receive SIGPIPE and die.
+    # If we reached the cap, the file is full — stop permanently.
+    [ "$(stat -c%s "$LOGFILE" 2>/dev/null || echo 0)" -ge 8388608 ] && break
+    sleep 1
+  done) &
+fi
+
 while true; do
   ./daemon "$MODDIR" || exit 1
   # ensure keystore initialized