chore(release): v6.0.1-307

The 2026-07-08 public-release history scrub (0f1143a) rewrote history
and dropped `git rev-list --count` below the build number already
shipped to testers (298), so post-scrub builds (291, 294) read as
downgrades. Add a floor offset so versionCode clears 298 and stays
monotonic across the rewrite: the current count maps to 300, and each
later commit still increments by one.

.github/workflows/build.yml

@@ -3,16 +3,10 @@ name: Build
 on:
   push:
     branches: [ "main" ]
-    paths-ignore:
+    paths-ignore: [ '**.md' ]
-      - '**.md'
-      - '.github/**'
-      - '!.github/workflows/**'
   pull_request:
     branches: [ "main" ]
-    paths-ignore:
+    paths-ignore: [ '**.md' ]
-      - '**.md'
-      - '.github/**'
-      - '!.github/workflows/**'
   workflow_dispatch:
 
 concurrency:
@@ -22,18 +16,9 @@ concurrency:
 jobs:
   build:
     runs-on: ubuntu-latest
-    permissions:
+
-      id-token: write
-      attestations: write
-      contents: read
-    
-    outputs:
-      releaseName: ${{ steps.prepareArtifact.outputs.releaseName }}
-      debugName: ${{ steps.prepareArtifact.outputs.debugName }}
-    
     steps:
-      - name: Check out
+      - uses: actions/checkout@v4
-        uses: actions/checkout@v4
         with:
           submodules: "recursive"
           fetch-depth: 0
@@ -45,6 +30,25 @@ jobs:
           java-version: 21
           cache: 'gradle'
 
+      - name: Setup Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: aarch64-linux-android,armv7-linux-androideabi,i686-linux-android,x86_64-linux-android
+
+      - name: Cache Rust artifacts
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            ~/.cargo/bin/cargo-ndk
+            native-certgen/target
+          key: rust-${{ runner.os }}-${{ hashFiles('native-certgen/Cargo.lock') }}
+          restore-keys: rust-${{ runner.os }}-
+
+      - name: Install cargo-ndk
+        run: command -v cargo-ndk || cargo install cargo-ndk
+
       - name: Set up ccache
         uses: hendrikmuhs/ccache-action@v1.2
         with:
@@ -60,73 +64,106 @@ jobs:
       - name: Build with Gradle
         run: |
           chmod +x ./gradlew
-
           ./gradlew zipRelease zipDebug -Porg.gradle.parallel=true -Porg.gradle.vfs.watch=true -Dorg.gradle.jvmargs=-Xmx2048m
 
-      - name: Prepare artifact
+      - name: Read version
-        if: success()
+        id: ver
-        id: prepareArtifact
         run: |
-          set -e
+          ver=$(grep 'val verName' app/build.gradle.kts | sed 's/.*"\(.*\)".*/\1/')
-          RELEASE_FILE=$(find out -name "*Release*.zip" | head -1)
+          count=$(git rev-list HEAD --count)
-          DEBUG_FILE=$(find out -name "*Debug*.zip" | head -1)
+          echo "version=${ver}-${count}" >> "$GITHUB_OUTPUT"
-          
-          if [[ -z "$RELEASE_FILE" || -z "$DEBUG_FILE" ]]; then
-            echo "Error: Could not find release or debug files in out/"
-            echo "Contents of out/ directory:"
-            ls -la out/ || echo "out/ directory does not exist"
-            exit 1
-          fi
-          
-          # Extract names
-          RELEASE_NAME=$(basename "$RELEASE_FILE" .zip)
-          DEBUG_NAME=$(basename "$DEBUG_FILE" .zip)
-          
-          echo "releaseName=$RELEASE_NAME" >> $GITHUB_OUTPUT
-          echo "debugName=$DEBUG_NAME" >> $GITHUB_OUTPUT
 
-          mkdir -p module-release module-debug
+      - name: List build artifacts
-          unzip -q "$RELEASE_FILE" -d module-release
+        run: |
-          unzip -q "$DEBUG_FILE" -d module-debug
+          echo "Release: $(ls out/*Release*.zip | head -1) ($(du -h out/*Release*.zip | head -1 | cut -f1))"
-          echo "  Release: $RELEASE_NAME"
+          echo "Debug: $(ls out/*Debug*.zip | head -1) ($(du -h out/*Debug*.zip | head -1 | cut -f1))"
-          echo "  Debug: $DEBUG_NAME"
 
-      - name: Upload release
+      - uses: actions/upload-artifact@v4
-        if: success()
-        id: release
-        uses: actions/upload-artifact@v4
         with:
-          name: ${{ steps.prepareArtifact.outputs.releaseName }}
+          name: TEESimulator-RS-release-zip
-          path: "./module-release/*"
+          path: out/TEESimulator-RS-*-Release.zip
           retention-days: 30
-          compression-level: 6
+          compression-level: 0
 
-      - name: Upload debug
+      - uses: actions/upload-artifact@v4
-        if: success()
-        id: debug
-        uses: actions/upload-artifact@v4
         with:
-          name: ${{ steps.prepareArtifact.outputs.debugName }}
+          name: TEESimulator-RS-debug-zip
-          path: "./module-debug/*"
+          path: out/TEESimulator-RS-*-Debug.zip
           retention-days: 7
-          compression-level: 6
+          compression-level: 0
 
-      - name: Upload release mappings
+      - uses: actions/upload-artifact@v4
-        if: success()
-        uses: actions/upload-artifact@v4
         with:
-          name: release-mappings-${{ github.run_number }}
+          name: release-mappings
-          path: "./app/build/outputs/mapping/release"
+          path: app/build/outputs/mapping/release
           retention-days: 30
           compression-level: 9
 
-      - name: Summary
+  release:
-        if: always()
+    needs: build
+    if: (github.event_name == 'push' || github.event_name == 'workflow_dispatch') && github.ref == 'refs/heads/main'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Read version
+        id: ver
         run: |
-          echo "## Build Summary" >> $GITHUB_STEP_SUMMARY
+          ver=$(grep 'val verName' app/build.gradle.kts | sed 's/.*"\(.*\)".*/\1/')
-          echo "- **Status**: ${{ job.status }}" >> $GITHUB_STEP_SUMMARY
+          count=$(git rev-list HEAD --count)
-          echo "- **Gradle Tasks**: assembleRelease, assembleDebug" >> $GITHUB_STEP_SUMMARY
+          echo "version=${ver}-${count}" >> "$GITHUB_OUTPUT"
-          if [[ "${{ job.status }}" == "success" ]]; then
+
-            echo "- **Release Artifact**: ${{ steps.prepareArtifact.outputs.releaseName }}" >> $GITHUB_STEP_SUMMARY
+      - uses: actions/download-artifact@v4
-            echo "- **Debug Artifact**: ${{ steps.prepareArtifact.outputs.debugName }}" >> $GITHUB_STEP_SUMMARY
+        with:
-          fi
+          name: TEESimulator-RS-release-zip
+          path: zips
+
+      - uses: actions/download-artifact@v4
+        with:
+          name: TEESimulator-RS-debug-zip
+          path: zips
+
+      - name: Extract changelog
+        run: |
+          ver="${VER#v}"
+          awk "/^## TEESimulator-RS v${ver%%-*}/{flag=1; next} /^## TEESimulator-RS v/{if(flag) exit} flag" module/changelog.md > /tmp/notes.md
+          cat /tmp/notes.md
+        env:
+          VER: ${{ steps.ver.outputs.version }}
+
+      - name: Create release
+        run: |
+          gh release delete "$VER" --yes 2>/dev/null || true
+          RELEASE=$(ls zips/*Release*.zip | head -1)
+          DEBUG=$(ls zips/*Debug*.zip | head -1)
+          gh release create "$VER" \
+            --title "$VER" \
+            --latest \
+            --notes-file /tmp/notes.md \
+            "$RELEASE" \
+            "$DEBUG"
+        env:
+          VER: ${{ steps.ver.outputs.version }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Bump update.json
+        run: |
+          COUNT=$(git rev-list HEAD --count)
+          RELEASE_NAME=$(basename zips/*Release*.zip)
+          ZIP_URL="https://github.com/${{ github.repository }}/releases/download/${VER}/${RELEASE_NAME}"
+          jq ".versionCode = $COUNT | .zipUrl = \"$ZIP_URL\"" module/update.json > /tmp/update.json
+          mv /tmp/update.json module/update.json
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add module/update.json
+          git diff --cached --quiet || {
+            git commit -m "chore(release): bump update.json to $VER [skip ci]"
+            git push origin HEAD:main
+          }
+        env:
+          VER: ${{ steps.ver.outputs.version }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1 +0,0 @@
-out

README.md

@@ -1,237 +1,160 @@
 <p align="center">
-  <h1 align="center">🔐 TEESimulator</h1>
+  <h1 align="center">TEESimulator-RS</h1>
-  <p align="center"><b>Full TEE Emulation for Rooted Android</b></p>
+  <p align="center"><b>Pass hardware security checks on a rooted Android phone</b></p>
-  <p align="center">Hardware attestation. Software keys. Zero detection.</p>
   <p align="center">
-    <img src="https://img.shields.io/badge/version-v4.0-blue?style=for-the-badge" alt="v4.0">
+    <a href="https://github.com/Enginex0/TEESimulator-RS/actions/workflows/build.yml"><img src="https://github.com/Enginex0/TEESimulator-RS/actions/workflows/build.yml/badge.svg" alt="Build"></a>
-    <img src="https://img.shields.io/badge/Android-10%2B-green?style=for-the-badge&logo=android" alt="Android 10+">
+    <img src="https://img.shields.io/badge/Android-10%2B-green?logo=android" alt="Android 10+">
-    <img src="https://img.shields.io/badge/Telegram-community-blue?style=for-the-badge&logo=telegram" alt="Telegram">
+    <a href="https://t.me/superpowers9"><img src="https://img.shields.io/badge/Telegram-community-blue?logo=telegram" alt="Telegram"></a>
   </p>
 </p>
 
 ---
 
 > [!NOTE]
-> **This is a personal fork of [JingMatrix/TEESimulator](https://github.com/JingMatrix/TEESimulator)** with additional hardening, native Rust certificate generation, key persistence, and anti-detection features. For the upstream project, see the original repo.
+> This is a fork of [JingMatrix/TEESimulator](https://github.com/JingMatrix/TEESimulator). It adds certificate generation written in Rust, generated keys that survive reboots, and attestation behavior that matches stock Android. See the upstream repo for the original project.
 
----
+## What it does
 
-## 🧬 What is TEESimulator?
+Some Android apps refuse to run on a rooted phone. They ask the phone to prove it still has a genuine security chip, a check called hardware attestation. A rooted phone normally fails that check.
 
-TEESimulator is a **complete software simulation** of Android's hardware-backed [Trusted Execution Environment](https://source.android.com/docs/security/features/trusty) for [Key Attestation](https://developer.android.com/privacy-and-security/security-key-attestation). Instead of patching certificates from the real TEE after the fact, TEESimulator intercepts Binder IPC at the `ioctl` level and generates entire certificate chains from scratch — signed by your keybox, with correct attestation extensions, indistinguishable from hardware-generated keys.
+TEESimulator makes it pass. Android runs a system process named `keystore2` that answers these proof requests. TEESimulator sits in front of `keystore2`, watches for the requests apps make to create keys and read their certificates, and builds the proof itself: a full chain of certificates signed by your `keybox.xml`. To the app, the phone looks genuine.
 
-The result: **apps that verify hardware attestation see a legitimate, unmodified device** — even on rooted hardware with an unlocked bootloader.
+It replaces TrickyStore and its forks completely. It reads config from the same files, so you can switch without moving anything, but the internals are rewritten: certificates are generated in Rust, keys are saved across reboots, and each app gets its own limit on how fast it can request hardware-backed keys.
 
-> **This is not TrickyStore.** TEESimulator replaces TrickyStore and its forks entirely. It shares the same config paths for drop-in compatibility, but the architecture is fundamentally different: native Rust certificate generation, binder-level interception via `lsplt`, per-UID rate limiting, key persistence, and a multi-layer defense against detector apps.
+## Requirements
-
----
-
-## 🔥 Why TEESimulator?
-
-🔐 **Native Cert Generation** — v4.0 generates X.509 certificate chains in Rust with `ring` and manual DER encoding. No BouncyCastle overhead, no Java crypto quirks, byte-perfect issuer chain linkage.
-
-🎯 **Binder-Level Interception** — Hooks `ioctl()` on `libc.so` via `lsplt` inside the `keystore2` process. Intercepts `generateKey`, `importKey`, and `getKeyEntry` transactions before the HAL ever sees them.
-
-🛡️ **Detector Resistant** — Per-UID rate limiting blocks DuckDetector-style keygen flooding. Oversized challenges rejected with real KeyMint error codes. Chain consistency verified byte-for-byte.
-
-💾 **Key Persistence** — Generated keys survive reboots. Apps that store attestation keys (banking, biometrics) don't break after a restart.
-
-🔧 **Drop-In Replacement** — Same config paths as TrickyStore (`/data/adb/tricky_store/`). Swap the module ZIP, keep your keybox and target list.
-
----
-
-## ✨ Features
-
-**Core Attestation Engine**
-- [x] **Full certificate chain generation** — leaf + intermediates + root, signed by your keybox
-- [x] **Native Rust certgen** — `libcertgen.so` built with `ring`, `rsa`, and manual DER assembly
-- [x] **BouncyCastle fallback** — unsupported curves (P-224, P-521, Curve25519) fall back to Java
-- [x] **ASN.1 attestation extensions** — OID 1.3.6.1.4.1.11129.2.1.17 with all AOSP-specified tags
-- [x] **Multi-keybox support** — different keybox files per app group via `target.txt`
-
-**Interception Layer**
-- [x] **Binder ioctl hook** — `lsplt` PLT hook on `libc.so` inside `keystore2` process
-- [x] **generateKey / importKey / getKeyEntry** — all three transaction types intercepted
-- [x] **256KB native payload cap** — oversized binder payloads bypass interception cleanly
-- [x] **Challenge validation** — rejects >128-byte attestation challenges with `INVALID_INPUT_LENGTH`
-
-**Hardening**
-- [x] **Per-UID rate limiter** — 2 hardware keygens per 30s burst window, software fallback on overflow
-- [x] **importKey eviction guard** — retained patch chains prevent generate-then-import cache attacks
-- [x] **Key persistence** — file-backed storage with file-level locking, survives reboots and keybox rotations
-- [x] **Global exception handler** — uncaught exceptions logged, daemon stays alive
-
-**Configuration**
-- [x] **Live config reload** — `FileObserver` watches all config files, changes apply immediately
-- [x] **Security patch spoofing** — per-package `system`, `vendor`, `boot` patch levels with dynamic templates
-- [x] **Lifecycle scripts** — KSU Action button clears key cache, uninstall removes all traces
-
----
-
-## 📋 Requirements
 
 > [!IMPORTANT]
-> TEESimulator requires root access and a valid `keybox.xml` for hardware-level attestation results. Without a keybox, the module generates software-level certificates that won't pass strict hardware attestation checks.
+> You need a valid `keybox.xml`. This is the file used to sign the proof. Without it, TEESimulator can only produce software-only certificates, which strict apps reject.
 
-**You need:**
+1. Android 10 or newer
-1. Android 10 or above
+2. A root manager: KernelSU, Magisk, or APatch
-2. A supported root manager (KernelSU, Magisk, or APatch)
+3. A `keybox.xml` file at `/data/adb/tricky_store/keybox.xml`
-3. A hardware-backed `keybox.xml` placed at `/data/adb/tricky_store/keybox.xml`
 
----
+## Quick start
 
-## 📱 Compatibility
+1. Download the latest ZIP from [Releases](https://github.com/Enginex0/TEESimulator-RS/releases).
+2. Install it with your root manager, then reboot.
+3. Put your `keybox.xml` at `/data/adb/tricky_store/keybox.xml`.
+4. List the apps you want to cover in `/data/adb/tricky_store/target.txt`.
+5. Check that it works with Play Integrity or the Key Attestation Demo app.
 
-### Root Managers
+## How it works
 
-| Manager | Status | Notes |
+```
-|---|---|---|
+   App
-| KernelSU | ✅ Tested | Full support including Action button and lifecycle scripts |
+    |  asks the phone to prove it has real security hardware
-| Magisk | ✅ Supported | Standard module install |
+    v
-| APatch | ✅ Supported | Standard module install |
++----------------------------------------------------+
-
+| keystore2  (the Android process that answers)      |
-### Tested Devices
+|                                                    |
-
+|   ioctl  <- TEESimulator hooks the call here       |
-| Device | Android | TEE | Status |
+|     |                                              |
-|---|---|---|---|
+|     v                                              |
-| Redmi 14C (2409BRN2CA) | 14 (SDK 34) | Beanpod KeyMaster | ✅ Daily driver |
+|   builds a certificate chain and signs it          |
-
+|   with your keybox.xml                             |
-> Tested against DuckDetector, Luna, Play Integrity, and Key Attestation Demo. If you test on a different device, [open an issue](https://github.com/Enginex0/TEESimulator/issues) with your results.
++----------------------------------------------------+
-
+    |  the signed chain goes back to the app
----
+    v
+   App  ->  sees a genuine, hardware-backed device
+```
 
-## 🚀 Quick Start
+**Certificate generation in Rust.** A native library, `libcertgen.so`, builds the X.509 certificate chains in Rust with the `ring` crypto library, encoding the bytes by hand in DER, the standard certificate format. Three key types fall outside `ring`'s support (the P-224, P-521, and Curve25519 curves); for those it falls back to Java's BouncyCastle.
 
-1. **Download** the latest release ZIP from [Releases](https://github.com/Enginex0/TEESimulator/releases)
+**Hooking keystore2.** Inside the `keystore2` process, TEESimulator redirects `ioctl`, the low-level system call Android uses to pass messages between processes. It does this with `lsplt`, a hooking library. From there it can read and answer three kinds of request: creating a key, importing a key, and fetching a key's certificate.
-2. **Install** via your root manager (KSU / Magisk / APatch) and reboot
-3. **Place your keybox** at `/data/adb/tricky_store/keybox.xml`
-4. **Configure targets** in `/data/adb/tricky_store/target.txt`
-5. **Verify** — check Play Integrity or run Key Attestation Demo
 
-TEESimulator replaces TrickyStore, TrickyStoreOSS, and their forks. Existing config files are compatible.
+**Matching stock Android.** The output matches what a real device produces. Keys that are not attested get self-signed certificates. The fields inside the attestation record keep the same order. Fields that only exist on certain Android versions appear only on those versions. The same usage checks run before a key is used.
 
----
+**Keys that survive reboots.** Generated keys are written to disk and stay valid after a restart. File locking stops two writers from corrupting the store.
 
-## ⚙️ Configuration
+**Per-app rate limit.** Each app may request at most 2 hardware-backed keys per 30 seconds, and only 2 at a time. Past that, it receives a software-only certificate.
-
-All configuration files live at `/data/adb/tricky_store/` and are monitored by `FileObserver` — changes take effect immediately without rebooting.
-
-### The `keybox.xml` Root of Trust
-
-This file provides the master cryptographic identity. It contains a private key and a hardware-backed certificate chain from a real device. TEESimulator signs all generated certificates with this key, making them appear legitimate to verifiers.
-
-```xml
-<?xml version="1.0"?>
-<AndroidAttestation>
-    <Keybox DeviceID="...">
-        <Key algorithm="ecdsa|rsa">
-            <PrivateKey format="pem">...</PrivateKey>
-            <CertificateChain>...</CertificateChain>
-        </Key>
-    </Keybox>
-</AndroidAttestation>
-```
 
-### Target Packages (`target.txt`)
+## Configuration
 
-Controls which apps get intercepted and what simulation mode to use.
+All config files live in `/data/adb/tricky_store/`. TEESimulator reloads them the moment you save, so a reboot is not needed.
 
-#### Mode Suffixes
+### target.txt
 
-*   **`!` → Force Generation** — Creates a complete software-based virtual key. Full TEE simulation.
+Lists the apps TEESimulator handles, one package name per line. A suffix sets how each app is handled.
-*   **`?` → Force Leaf Hacking** — Real TEE key generated, but its attestation certificate is intercepted and patched.
-*   **No symbol → Automatic** — Module selects the best mode for your device.
 
-#### Multi-Keybox
+| Suffix | What it does |
+|--------|--------------|
+| `!` | Always make a software key |
+| `?` | Keep the real hardware key, patch only its certificate |
+| none | Decide automatically |
 
-Specify different keybox files for different app groups. Apps listed after a `[filename.xml]` line use that keybox. Apps before any declaration use the default `keybox.xml`.
+To use more than one keybox, add a `[filename.xml]` header above the apps that should use that file:
 
 ```
-# Default keybox
 com.google.android.gms!
 io.github.vvb2060.keyattestation?
 
-# Switch to a different keybox for the following apps
 [aosp_keybox.xml]
 com.google.android.gsf
-
-# Another keybox
-[demo_keybox.xml]
-org.matrix.demo
 ```
 
-### Security Patch Level (`security_patch.txt`)
+### security_patch.txt
 
-Configure the `osPatchLevel`, `vendorPatchLevel`, and `bootPatchLevel` reported in attestation certificates. This only affects attestation data — it does not change actual system properties.
+Sets the security patch dates reported in the attestation certificates. Global defaults go at the top. Override them for one app with a `[package.name]` header.
 
-#### Global and Per-Package
+| Key | What it sets |
-
+|-----|--------------|
-Settings at the top of the file are global defaults. Add `[package.name]` to override for specific apps.
-
-#### Keys
-
-| Key | Scope |
-|---|---|
 | `system` | OS patch level |
 | `vendor` | Vendor patch level |
-| `boot` | Boot/kernel patch level |
+| `boot` | Boot and kernel patch level |
-| `all` | Shorthand — sets all three at once |
+| `all` | All three at once |
 
-#### Special Keywords
+Accepted values: `today`, a `YYYY-MM-DD` template, `no` to omit the field, `device_default`, or `prop` to read the value from a system property.
-
-| Keyword | Effect |
-|---|---|
-| `today` | Current date, dynamically resolved on each attestation |
-| `YYYY-MM-DD` templates | Semi-dynamic — `YYYY-MM-05` resolves to the 5th of the current month |
-| `no` | Omit this patch level tag entirely from the attestation |
-| `device_default` | Use the device's real hardware value |
-| `prop` | Read from `ro.build.version.security_patch` (matches what detectors see via getprop) |
-
-#### Example
 
 ```
-# Global — default for all apps
 system=YYYY-MM-05
 vendor=device_default
 boot=no
 
-# Override for GMS
 [com.google.android.gms]
-system=2024-10-01
+system=2025-10-01
-
-# Custom config for a demo app
-[org.matrix.demo]
-all=2025-09-15
-boot=device_default
 ```
 
----
+### boot_props_mode
 
-## 💬 Community
+Controls global `ro.boot.*` property spoofing. Values: `auto` (default), `force`, or `disable`.
+
+In `auto`, Oplus-family devices (OnePlus/OPPO/realme/Oplus) skip boot-state prop spoofing to avoid conflicts with vendor TEE services such as ultrasonic fingerprint calibration. Create `/data/adb/tricky_store/boot_props_mode` with `force` to restore the old behavior, or `disable` to turn it off on any device.
+
+## Building from source
+
+You need JDK 21, the Android SDK and NDK 29, Rust (stable) with the `aarch64-linux-android` target, and `cargo-ndk`.
+
+```bash
+git clone --recursive https://github.com/Enginex0/TEESimulator-RS.git
+cd TEESimulator-RS
+./gradlew zipRelease zipDebug
+```
+
+The ZIPs land in `out/`. Gradle runs `cargo ndk` for you to cross-compile `libcertgen.so`. To build on CI instead, push to `main` or run Actions > Build > Run workflow.
+
+## Compatibility
+
+| Root manager | Status |
+|---|---|
+| KernelSU | Tested, including the Action button and lifecycle scripts |
+| Magisk | Supported |
+| APatch | Supported |
+
+## Community
 
 <p align="center">
   <a href="https://t.me/superpowers9">
-    <img src="https://img.shields.io/badge/⚡_JOIN_THE_GRID-SuperPowers_Telegram-black?style=for-the-badge&logo=telegram&logoColor=cyan&labelColor=0d1117&color=00d4ff" alt="Telegram">
+    <img src="https://img.shields.io/badge/SuperPowers_Telegram-Join-blue?style=for-the-badge&logo=telegram" alt="Telegram">
   </a>
 </p>
 
----
+## Credits
 
-## 🙏 Credits
+- [JingMatrix](https://github.com/JingMatrix/TEESimulator) for the original TEESimulator and its interception design
+- [ring](https://github.com/briansmith/ring) for the Rust cryptography
+- [fatalcoder524](https://github.com/fatalcoder524) for contributions and collaboration
+- [huguangares](https://github.com/huguangares) for collaboration and testing
 
-- **[JingMatrix](https://github.com/JingMatrix/TEESimulator)** — original author of TEESimulator and the interception architecture
+## License
-- **[5ec1cff](https://github.com/5ec1cff/TrickyStore)** — TrickyStore, the project that pioneered keystore interception on Android
-- **[LSPlt](https://github.com/LSPosed/LSPlt)** — PLT hook library used for binder interception
-- **[ring](https://github.com/briansmith/ring)** — Rust cryptography library powering native cert generation
 
----
+[GNU General Public License v3.0](LICENSE)
-
-## 📄 License
-
-This project is licensed under the [GNU General Public License v3.0](LICENSE).
-
----
-
-<p align="center">
-  <b>🔐 Because the best attestation is the one the TEE never generated.</b>
-</p>

app/build.gradle.kts

@@ -2,6 +2,7 @@ import com.android.build.api.artifact.SingleArtifact
 import java.io.ByteArrayOutputStream
 import javax.inject.Inject
 import org.gradle.process.ExecOperations
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 
 plugins {
     alias(libs.plugins.android.application)
@@ -27,9 +28,16 @@ abstract class GitExecutor @Inject constructor(private val execOperations: ExecO
 // Instantiate the helper class using Gradle's object factory
 val gitExecutor = objects.newInstance(GitExecutor::class.java)
 
-val gitCommitCount = gitExecutor.execute("git rev-list HEAD --count", rootDir).toInt()
+// versionCode = git commit count + floor offset. The 2026-07-08 public-release
+// history scrub (0f1143a) rewrote history and dropped the raw commit count below
+// the build number already shipped to testers (298), so post-scrub counts read as
+// downgrades. The floor offset lifts versionCode back above that peak and keeps it
+// monotonic across the rewrite; each later commit still bumps it by one.
+val versionCodeFloorOffset = 5
+val gitCommitCount =
+    gitExecutor.execute("git rev-list HEAD --count", rootDir).toInt() + versionCodeFloorOffset
 val gitCommitHash = gitExecutor.execute("git rev-parse --verify --short HEAD", rootDir)
-val verName = "v4.0"
+val verName = "v6.0.1"
 
 android {
     namespace = "org.matrix.TEESimulator"
@@ -65,6 +73,8 @@ android {
     }
 }
 
+kotlin { compilerOptions { jvmTarget.set(JvmTarget.JVM_21) } }
+
 dependencies {
     compileOnly(project(":stub"))
     compileOnly(libs.annotation)
@@ -72,26 +82,35 @@ dependencies {
 }
 
 // --- Rust native cert gen build task ---
-val buildRustCertgen by tasks.registering(Exec::class) {
+val buildRustCertgen by
-    group = "TEESimulator Native Build"
+    tasks.registering(Exec::class) {
-    description = "Builds libcertgen.so via cargo-ndk for arm64-v8a."
+        group = "TEESimulator-RS Native Build"
+        description = "Builds libcertgen.so via cargo-ndk for arm64-v8a."
 
-    workingDir = rootProject.projectDir.resolve("native-certgen")
+        workingDir = rootProject.projectDir.resolve("native-certgen")
 
-    commandLine(
+        commandLine(
-        "cargo", "ndk",
+            "cargo",
-        "-t", "arm64-v8a",
+            "ndk",
-        "-o", rootProject.projectDir.resolve("app/src/main/jniLibs").absolutePath,
+            "-t",
-        "build", "--release"
+            "arm64-v8a",
-    )
+            "-o",
+            rootProject.projectDir.resolve("app/src/main/jniLibs").absolutePath,
+            "build",
+            "--release",
+        )
 
-    inputs.dir(rootProject.projectDir.resolve("native-certgen/src"))
+        inputs.dir(rootProject.projectDir.resolve("native-certgen/src"))
-    inputs.file(rootProject.projectDir.resolve("native-certgen/Cargo.toml"))
+        inputs.file(rootProject.projectDir.resolve("native-certgen/Cargo.toml"))
-    inputs.file(rootProject.projectDir.resolve("native-certgen/Cargo.lock"))
+        inputs.file(rootProject.projectDir.resolve("native-certgen/Cargo.lock"))
-    outputs.dir(rootProject.projectDir.resolve("app/src/main/jniLibs"))
+        outputs.dir(rootProject.projectDir.resolve("app/src/main/jniLibs"))
 
-    environment("ANDROID_NDK_HOME", android.ndkDirectory.absolutePath)
+        environment("ANDROID_NDK_HOME", android.ndkDirectory.absolutePath)
-}
+        environment(
+            "PATH",
+            "${System.getProperty("user.home")}/.cargo/bin:${System.getenv("PATH") ?: ""}",
+        )
+    }
 
 // AGP auto-detects jniLibs/ as an input to mergeJniLibFolders — wire the dependency
 tasks.configureEach {
@@ -100,6 +119,35 @@ tasks.configureEach {
     }
 }
 
+// Auto-rewrite module/update.json on every packaging build so versionCode and
+// zipUrl track gitCommitCount automatically, matching module.prop.
+val refreshUpdateJson by
+    tasks.registering {
+        group = "TEESimulator-RS Module Packaging"
+        description = "Rewrite module/update.json to match current verName and gitCommitCount."
+
+        val updateJsonFile = rootProject.projectDir.resolve("module/update.json")
+        val capturedVerName = verName
+        val capturedCount = gitCommitCount
+
+        inputs.property("verName", capturedVerName)
+        inputs.property("gitCommitCount", capturedCount)
+        outputs.file(updateJsonFile)
+
+        doLast {
+            val fullVer = "$capturedVerName-$capturedCount"
+            updateJsonFile.writeText(
+                """{
+  "version": "$fullVer",
+  "versionCode": $capturedCount,
+  "zipUrl": "https://github.com/Enginex0/TEESimulator-RS/releases/download/$fullVer/TEESimulator-RS-$fullVer-Release.zip",
+  "changelog": "https://raw.githubusercontent.com/Enginex0/TEESimulator-RS/main/module/changelog.md"
+}
+"""
+            )
+        }
+    }
+
 androidComponents {
     onVariants(selector().all()) { variant ->
         val capitalized = variant.name.replaceFirstChar { it.uppercase() }
@@ -108,22 +156,23 @@ androidComponents {
         // --- Define output locations and file names ---
         // Stage all files in a temporary directory inside 'build' before zipping
         val tempModuleDir = project.layout.buildDirectory.dir("module/${variant.name}")
-        val zipFileName = "TEESimulator-$verName-$gitCommitCount-$gitCommitHash-$capitalized.zip"
+        val zipFileName = "TEESimulator-RS-$verName-$gitCommitCount-$capitalized.zip"
 
         // Task 1: Prepare all module files in the temporary build directory.
         // Using Sync ensures that stale files from previous runs are removed.
         val prepareModuleFilesTask =
             tasks.register<Sync>("prepareModuleFiles${capitalized}") {
-                group = "TEESimulator Module Packaging"
+                group = "TEESimulator-RS Module Packaging"
                 description = "Prepares all files for the ${variant.name} module zip."
 
                 if (isDebug) {
                     dependsOn("package${capitalized}")
                 } else {
                     dependsOn("minify${capitalized}WithR8")
+                    dependsOn("strip${capitalized}DebugSymbols")
                 }
-                dependsOn("strip${capitalized}DebugSymbols")
                 dependsOn(buildRustCertgen)
+                dependsOn(refreshUpdateJson)
 
                 if (isDebug) {
                     from(variant.artifacts.get(SingleArtifact.APK)) {
@@ -140,19 +189,27 @@ androidComponents {
                     }
                 }
 
-                from(
+                val nativeLibsDir =
-                    project.layout.buildDirectory.dir(
+                    if (isDebug) {
+                        "intermediates/merged_native_libs/${variant.name}/merge${capitalized}NativeLibs/out/lib"
+                    } else {
                         "intermediates/stripped_native_libs/${variant.name}/strip${capitalized}DebugSymbols/out/lib"
+                    }
+                from(project.layout.buildDirectory.dir(nativeLibsDir)) {
+                    into("lib")
+                    include(
+                        "**/libinject.so",
+                        "**/libTEESimulator.so",
+                        "**/libsupervisor.so",
+                        "**/libcertgen.so",
                     )
-                ) {
-                    into("lib") // Place them in the 'lib' subfolder of the staging directory.
-                    include("**/libinject.so", "**/libTEESimulator.so", "**/libsupervisor.so", "**/libcertgen.so")
                 }
 
                 // 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("diag.sh") // Debug-only diagnostic plane; included for debug below.
                 }
 
                 // Copy and filter the module.prop template separately.
@@ -161,19 +218,35 @@ androidComponents {
                     // Use expand() for simple key-value replacement.
                     expand(
                         "REPLACEMEVERCODE" to gitCommitCount.toString(),
-                        "REPLACEMEVER" to
+                        "REPLACEMEVER" to "$verName-$gitCommitCount",
-                            "$verName ($gitCommitCount-$gitCommitHash-${variant.name})",
                     )
                 }
 
+                if (isDebug) {
+                    from(sourceModuleDir) { include("diag.sh") }
+                }
+
                 // The destination for all the above 'from' operations.
                 into(tempModuleDir)
+
+                if (isDebug) {
+                    doLast {
+                        // Debug-only: grant the keystore + soterserver (platform_app) domains
+                        // external-storage access for the per-UID NDJSON sink. diag.sh (shipped
+                        // only in debug) carries the shell side of the diagnostic plane.
+                        tempModuleDir.get().asFile.resolve("sepolicy.rule")
+                            .appendText(
+                                "\nallow keystore media_rw_data_file { dir file } *" +
+                                    "\nallow platform_app media_rw_data_file { dir file } *\n",
+                            )
+                    }
+                }
             }
 
         // Task 2: Zip the prepared files from the temporary directory.
         val zipTask =
             tasks.register<Zip>("zip${capitalized}") {
-                group = "TEESimulator Module Packaging"
+                group = "TEESimulator-RS Module Packaging"
                 description = "Creates the flashable zip for the ${variant.name} module."
                 dependsOn(prepareModuleFilesTask)
 
@@ -186,7 +259,7 @@ androidComponents {
         fun createInstallTasks(rootProvider: String, installCli: String) {
             val pushTask =
                 tasks.register<Exec>("push${rootProvider}Module${capitalized}") {
-                    group = "TEESimulator Module Installation"
+                    group = "TEESimulator-RS Module Installation"
                     description =
                         "Pushes the ${variant.name} module to the device for $rootProvider."
                     dependsOn(zipTask)
@@ -200,7 +273,7 @@ androidComponents {
 
             val installTask =
                 tasks.register<Exec>("install${rootProvider}${capitalized}") {
-                    group = "TEESimulator Module Installation"
+                    group = "TEESimulator-RS Module Installation"
                     description = "Installs the ${variant.name} module via $rootProvider."
                     dependsOn(pushTask)
                     commandLine(
@@ -213,7 +286,7 @@ androidComponents {
                 }
 
             tasks.register<Exec>("install${rootProvider}AndReboot${capitalized}") {
-                group = "TEESimulator Module Installation"
+                group = "TEESimulator-RS Module Installation"
                 description = "Installs the ${variant.name} module via $rootProvider and reboots."
                 dependsOn(installTask)
                 commandLine("adb", "reboot")

app/src/main/cpp/CMakeLists.txt

@@ -5,6 +5,7 @@ set(CMAKE_CXX_STANDARD 23)
 set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-rtti")
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-exceptions")
+set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DNDEBUG")
 
 # LSPlt configuration
 OPTION(LSPLT_BUILD_SHARED OFF)

app/src/main/cpp/binder_interceptor.cpp

@@ -235,19 +235,21 @@ class BinderInterceptor : public BBinder {
     struct RegistrationEntry {
         wp<IBinder> target;
         sp<IBinder> callback_interface;
+        std::vector<uint32_t> filtered_codes;
     };
 
-    // Reader-Writer lock for the registry to allow concurrent reads (lookups)
     mutable std::shared_mutex registry_mutex_;
     std::map<wp<IBinder>, RegistrationEntry> registry_;
 
 public:
     BinderInterceptor() = default;
 
-    // Checks if a specific Binder instance is currently registered for interception
+    bool shouldIntercept(const wp<BBinder> &target, uint32_t code) const {
-    bool isBinderIntercepted(const wp<BBinder> &target) 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
@@ -348,14 +350,14 @@ static sp<BinderStub> g_stub_instance = nullptr;
 
 namespace {
 
-constexpr binder_size_t kMaxInterceptableDataSize = 256 * 1024;
-
 void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
     if (!txn_data || txn_data->target.ptr == 0)
         return;
 
-    // Bypass interception for oversized payloads to prevent thread starvation from flood attacks
+    // AIDL methods use codes in [FIRST_CALL_TRANSACTION, LAST_CALL_TRANSACTION] (1..0x00ffffff).
-    if (txn_data->data_size > kMaxInterceptableDataSize)
+    // System transactions (PING, INTERFACE, DUMP, SHELL_COMMAND) use codes above that range.
+    // Skip those — intercepting a ping adds measurable latency that timing detectors flag.
+    if (txn_data->code > 0x00ffffffu && txn_data->code != intercept::kBackdoorCode)
         return;
 
     bool hijack = false;
@@ -387,7 +389,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;
@@ -401,7 +403,10 @@ void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
         uint64_t tx_id = ++g_transaction_id_counter;
         info.transaction_id = tx_id;
 
-        LOGV("[Hook] Hijacking Transaction %" PRIu64 " (Code: %u)", tx_id, txn_data->code);
+        // tx_id is the same counter handed to the Kotlin interceptor, and sender_euid is the
+        // calling app; together they correlate this native hijack with that UID's per-UID file.
+        LOGV("[Hook] Hijacking Transaction %" PRIu64 " (Code: %u, uid=%u)", tx_id, txn_data->code,
+             txn_data->sender_euid);
 
         // Rewrite the destination to our Stub
         txn_data->target.ptr = reinterpret_cast<uintptr_t>(g_stub_instance->getWeakRefs());
@@ -426,44 +431,29 @@ void processBinderReadBuffer(const binder_write_read &bwr) {
     uintptr_t ptr = bwr.read_buffer;
     uintptr_t end = ptr + bwr.read_consumed;
 
-    LOGV("[Hook] Processing Read Buffer: Size=%llu, Consumed=%llu", bwr.read_size, bwr.read_consumed);
-
     while (ptr < end) {
-        // Ensure we can read at least the command header
         if (end - ptr < sizeof(uint32_t))
             break;
 
         uint32_t cmd = *reinterpret_cast<const uint32_t *>(ptr);
         ptr += sizeof(uint32_t);
-
-        // Calculate payload size from the ioctl command code
         size_t cmd_size = _IOC_SIZE(cmd);
 
-        // Log the command using our generated to-string function
-        LOGV("[Driver -> User] Command: %s (0x%x), DataSize: %zu", getBinderReturnCommandName(cmd), cmd, cmd_size);
-
-        // Safety check: ensure the command's data does not exceed the buffer
         if (ptr + cmd_size > end) {
-            LOGE("[Hook] Buffer overflow detected while parsing command %s", getBinderReturnCommandName(cmd));
+            LOGE("[Hook] Buffer overrun parsing command 0x%x", cmd);
             break;
         }
 
-        // We are primarily interested in BR_TRANSACTION commands to intercept
+        if (__builtin_expect(cmd == BR_TRANSACTION || cmd == BR_TRANSACTION_SEC_CTX, 0)) {
-        if (cmd == BR_TRANSACTION || cmd == BR_TRANSACTION_SEC_CTX) {
+            binder_transaction_data *txn;
-            binder_transaction_data *txn = nullptr;
-
             if (cmd == BR_TRANSACTION_SEC_CTX) {
-                // The data is wrapped in a secctx struct
+                txn = &reinterpret_cast<binder_transaction_data_secctx *>(ptr)->transaction_data;
-                auto *wrapper = reinterpret_cast<binder_transaction_data_secctx *>(ptr);
-                txn = &wrapper->transaction_data;
             } else {
                 txn = reinterpret_cast<binder_transaction_data *>(ptr);
             }
-
             inspectAndRewriteTransaction(txn);
         }
 
-        // Advance pointer to the next command
         ptr += cmd_size;
     }
 }
@@ -483,13 +473,17 @@ int intercepted_ioctl(int fd, int request, ...) {
     // 1. Call original kernel ioctl to let the driver do its work
     int result = g_original_ioctl(fd, request, arg);
 
-    // 2. After the call returns, check if it was a BINDER_WRITE_READ and if it succeeded
     if (result >= 0 && request == BINDER_WRITE_READ && arg != nullptr) {
         const auto *bwr = static_cast<const binder_write_read *>(arg);
-
+        // Fast reject: only enter the parser if the buffer could contain a BR_TRANSACTION.
-        // We only care about data read FROM the driver (i.e., incoming commands)
+        // Pings, ref ops, and looper management never produce BR_TRANSACTION, so scanning
-        if (bwr->read_consumed > 0) {
+        // their buffers is pure overhead (~2-5us per ioctl in debug builds).
-            processBinderReadBuffer(*bwr);
+        if (bwr->read_consumed >= sizeof(uint32_t)) {
+            uint32_t first_cmd = *reinterpret_cast<const uint32_t *>(bwr->read_buffer);
+            if (first_cmd == BR_TRANSACTION || first_cmd == BR_TRANSACTION_SEC_CTX
+                || bwr->read_consumed > sizeof(uint32_t) + _IOC_SIZE(first_cmd)) {
+                processBinderReadBuffer(*bwr);
+            }
         }
     }
 
@@ -532,18 +526,29 @@ status_t BinderInterceptor::handleRegister(const Parcel &data) {
     if (data.readStrongBinder(&callback) != OK || !callback)
         return BAD_VALUE;
 
-    // We can only intercept local Binders (BBinder), not remote proxies (BpBinder)
     if (target->localBinder() == nullptr) {
         LOGE("Cannot intercept remote binder proxies.");
         return BAD_TYPE;
     }
 
+    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;
 }
 

app/src/main/cpp/supervisor.cpp

@@ -2,11 +2,13 @@
 #include <unistd.h>
 #include <sys/wait.h>
 #include <sys/prctl.h>
+#include <sys/resource.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
+#include <time.h>
 
 static volatile sig_atomic_t should_exit = 0;
 
@@ -27,7 +29,12 @@ int main(int argc, char *argv[]) {
     const char *daemon_path = argv[1];
     char **daemon_argv = &argv[1];
 
+    int backoff_ms = 500;
+
     while (!should_exit) {
+        struct timespec child_start;
+        clock_gettime(CLOCK_MONOTONIC, &child_start);
+
         pid_t pid = fork();
 
         if (pid < 0) {
@@ -39,6 +46,7 @@ int main(int argc, char *argv[]) {
         if (pid == 0) {
             // Child: become the daemon
             prctl(PR_SET_PDEATHSIG, SIGKILL); // Die if parent dies
+            setpriority(PRIO_PROCESS, 0, 10);  // lower CPU priority than foreground
             execv(daemon_path, daemon_argv);
             perror("execv failed");
             _exit(127);
@@ -50,7 +58,18 @@ int main(int argc, char *argv[]) {
 
         if (should_exit) break;
 
-        // Instant restart - no delay
+        // Exponential backoff on rapid crashes, reset if child was stable
+        struct timespec now;
+        clock_gettime(CLOCK_MONOTONIC, &now);
+        long lived_ms = (now.tv_sec - child_start.tv_sec) * 1000 +
+                        (now.tv_nsec - child_start.tv_nsec) / 1000000;
+
+        if (lived_ms > 30000) {
+            backoff_ms = 500;
+        } else {
+            usleep(backoff_ms * 1000);
+            if (backoff_ms < 30000) backoff_ms *= 2;
+        }
     }
 
     return 0;

app/src/main/java/org/matrix/TEESimulator/App.kt

@@ -8,10 +8,12 @@ import android.os.Build
 import android.os.Looper
 import java.security.Security
 import org.bouncycastle.jce.provider.BouncyCastleProvider
+import org.matrix.TEESimulator.config.BootStateManager
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.interception.keystore.AbstractKeystoreInterceptor
 import org.matrix.TEESimulator.interception.keystore.Keystore2Interceptor
 import org.matrix.TEESimulator.interception.keystore.KeystoreInterceptor
+import org.matrix.TEESimulator.interception.soter.SoterProcessSupervisor
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.NativeCertGen
 import org.matrix.TEESimulator.util.AndroidDeviceUtils
@@ -23,8 +25,6 @@ import org.matrix.TEESimulator.util.AndroidDeviceUtils
 object App {
     // The delay in milliseconds before retrying to initialize the interceptor.
     private const val RETRY_DELAY_MS = 1000L
-    // The sleep duration in milliseconds for the main service loop to keep the process alive.
-    private const val SERVICE_SLEEP_MS = 1000000L
 
     /**
      * The main entry point of the TEESimulator application.
@@ -35,14 +35,23 @@ object App {
     fun main(args: Array<String>) {
         SystemLogger.info("Welcome to TEESimulator!")
 
+        Thread.setDefaultUncaughtExceptionHandler { thread, throwable ->
+            SystemLogger.error("Uncaught exception on ${thread.name}", throwable)
+        }
+
         try {
-            // Initialize the Android framework environment
+            val systemContext = prepareEnvironment()
-            prepareEnvironment()
+
-            // Initialize and start the appropriate keystore interceptors.
+            // Spoof boot-state props before any hook attaches, so keystore2's
-            initializeInterceptors()
+            // cached snapshot reflects the spoofed values.
+            BootStateManager.apply()
 
             // Load the package configuration.
             ConfigurationManager.initialize()
+
+            // Initialize and start the appropriate keystore interceptors.
+            initializeInterceptors()
+
             // Set up the device's boot key and hash, which are crucial for attestation.
             AndroidDeviceUtils.setupBootKeyAndHash()
 
@@ -54,6 +63,10 @@ object App {
 
             NativeCertGen.initialize("/data/adb/modules/tricky_store/libcertgen.so")
 
+            // Mount the SOTER forge on the on-demand soterserver process. The supervisor
+            // binds and (re)injects on its own thread, returning at once so it never blocks the loop.
+            SoterProcessSupervisor.start(systemContext)
+
             // This starts the message queue processing. It blocks here indefinitely
             // processing messages until Looper.myLooper().quit() is called.
             Looper.loop()
@@ -64,7 +77,7 @@ object App {
     }
 
     /** Initializes the necessary Android framework internals to satisfy KeyStore requirements. */
-    private fun prepareEnvironment() {
+    private fun prepareEnvironment(): Context {
         // 1. Prepare Main Looper
         if (Looper.getMainLooper() == null) {
             @Suppress("deprecation") Looper.prepareMainLooper()
@@ -73,8 +86,10 @@ object App {
         // 2. Initialize ActivityThread for the current process
         val activityThread = ActivityThread.systemMain()
 
-        // 3. Get the system context
+        // 3. Get the system context. The stub declares getSystemContext(): ContextImpl
-        val systemContext = activityThread.getSystemContext()
+        //    (a bare class), so cast to the Context it really is at runtime for the wiring.
+        @Suppress("CAST_NEVER_SUCCEEDS")
+        val systemContext = activityThread.getSystemContext() as Context
 
         // 4. Create a dummy Application object and attach the context
         val app = Application()
@@ -89,6 +104,8 @@ object App {
             ActivityThread::class.java.getDeclaredField("mInitialApplication")
         mInitialApplicationField.isAccessible = true
         mInitialApplicationField.set(activityThread, app)
+
+        return systemContext
     }
 
     /**

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
@@ -40,11 +43,13 @@ object AttestationBuilder {
         securityLevel: Int,
     ): Extension {
         val keyDescription = buildKeyDescription(params, uid, securityLevel)
-        var formattedString =
+        SystemLogger.verbose {
-            keyDescription.joinToString(separator = ", ") {
+            val formattedString =
-                AttestationPatcher.formatAsn1Primitive(it)
+                keyDescription.joinToString(separator = ", ") {
-            }
+                    AttestationPatcher.formatAsn1Primitive(it)
-        SystemLogger.verbose("Forged attestation data: ${formattedString}")
+                }
+            "Forged attestation data: $formattedString"
+        }
         return Extension(ATTESTATION_OID, false, DEROctetString(keyDescription.encoded))
     }
 
@@ -112,7 +117,9 @@ object AttestationBuilder {
             }
 
         val bootPatch = AndroidDeviceUtils.getBootPatchLevelLong(uid)
-        SystemLogger.info("Attestation patch levels for uid=$uid: os=$osPatch, vendor=$vendorPatch, boot=$bootPatch")
+        SystemLogger.info(
+            "Attestation patch levels for uid=$uid: os=$osPatch, vendor=$vendorPatch, boot=$bootPatch"
+        )
         properties[AttestationConstants.TAG_BOOT_PATCHLEVEL] =
             if (bootPatch != DO_NOT_REPORT) {
                 DERTaggedObject(
@@ -127,33 +134,59 @@ object AttestationBuilder {
         return properties
     }
 
-    /** Constructs the main `KeyDescription` sequence, which is the core of the attestation. */
     private fun buildKeyDescription(
         params: KeyMintAttestation,
         uid: Int,
         securityLevel: Int,
     ): ASN1Sequence {
+        val creationTime = System.currentTimeMillis()
         val teeEnforced = buildTeeEnforcedList(params, uid, securityLevel)
-        val softwareEnforced = buildSoftwareEnforcedList(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(
-                ASN1Integer(
+                ASN1Integer(AndroidDeviceUtils.getAttestVersion(securityLevel).toLong()),
-                    AndroidDeviceUtils.getAttestVersion(securityLevel).toLong()
+                ASN1Enumerated(securityLevel),
-                ), // attestationVersion
+                ASN1Integer(AndroidDeviceUtils.getKeymasterVersion(securityLevel).toLong()),
-                ASN1Enumerated(securityLevel), // attestationSecurityLevel
+                ASN1Enumerated(securityLevel),
-                ASN1Integer(
+                DEROctetString(params.attestationChallenge ?: ByteArray(0)),
-                    AndroidDeviceUtils.getKeymasterVersion(securityLevel).toLong()
+                DEROctetString(uniqueId),
-                ), // keymasterVersion
-                ASN1Enumerated(securityLevel), // keymasterSecurityLevel
-                DEROctetString(params.attestationChallenge ?: ByteArray(0)), // attestationChallenge
-                DEROctetString(ByteArray(0)), // uniqueId
                 softwareEnforced,
                 teeEnforced,
             )
         return DERSequence(fields)
     }
 
+    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)
+                .array()
+        val mac = Mac.getInstance("HmacSHA256")
+        mac.init(SecretKeySpec(hbk, "HmacSHA256"))
+        return mac.doFinal(message).copyOf(16)
+    }
+
+    private val hbk: ByteArray by lazy {
+        val file = java.io.File(ConfigurationManager.CONFIG_PATH, "hbk")
+        if (file.exists() && file.length() == 32L) {
+            file.readBytes()
+        } else {
+            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,
@@ -182,23 +215,126 @@ object AttestationBuilder {
                     AttestationConstants.TAG_DIGEST,
                     DERSet(params.digest.map { ASN1Integer(it.toLong()) }.toTypedArray()),
                 ),
+            )
+
+        if (params.ecCurve != null) {
+            list.add(
                 DERTaggedObject(
                     true,
                     AttestationConstants.TAG_EC_CURVE,
                     ASN1Integer(params.ecCurve.toLong()),
-                ),
+                )
-                DERTaggedObject(true, AttestationConstants.TAG_NO_AUTH_REQUIRED, DERNull.INSTANCE),
+            )
+        }
+
+        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(
+                    true,
+                    AttestationConstants.TAG_PADDING,
+                    DERSet(params.padding.map { ASN1Integer(it.toLong()) }.toTypedArray()),
+                )
+            )
+        }
+
+        if (params.rsaPublicExponent != null) {
+            list.add(
+                DERTaggedObject(
+                    true,
+                    AttestationConstants.TAG_RSA_PUBLIC_EXPONENT,
+                    ASN1Integer(params.rsaPublicExponent.toLong()),
+                )
+            )
+        }
+
+        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(
                     true,
                     AttestationConstants.TAG_ORIGIN,
-                    ASN1Integer(0L),
+                    ASN1Integer((params.origin ?: 0).toLong()),
-                ), // KeyOrigin.GENERATED
+                ),
                 DERTaggedObject(
                     true,
                     AttestationConstants.TAG_ROOT_OF_TRUST,
                     buildRootOfTrust(null),
                 ),
             )
+        )
 
         // Use the same logic as getSimulatedHardwareProperties to conditionally add patch levels.
         val simulatedProperties = getSimulatedHardwareProperties(uid)
@@ -295,20 +431,32 @@ object AttestationBuilder {
      * Builds the `SoftwareEnforced` authorization list. These are properties guaranteed by
      * Keystore.
      */
-    private fun buildSoftwareEnforcedList(uid: Int, securityLevel: Int): DERSequence {
+    private fun buildSoftwareEnforcedList(
-        val list =
+        params: KeyMintAttestation,
-            mutableListOf<ASN1Encodable>(
+        uid: Int,
-                DERTaggedObject(
+        securityLevel: Int,
-                    true,
+        creationTimeMs: Long = System.currentTimeMillis(),
-                    AttestationConstants.TAG_CREATION_DATETIME,
+    ): DERSequence {
-                    ASN1Integer(System.currentTimeMillis()),
+        val list = mutableListOf<ASN1Encodable>()
-                ),
+
+        list.add(
+            DERTaggedObject(
+                true,
+                AttestationConstants.TAG_CREATION_DATETIME,
+                ASN1Integer(creationTimeMs),
+            )
+        )
+
+        if (params.attestationChallenge != null) {
+            list.add(
                 DERTaggedObject(
                     true,
                     AttestationConstants.TAG_ATTESTATION_APPLICATION_ID,
                     createApplicationId(uid),
-                ),
+                )
             )
+        }
+
         if (AndroidDeviceUtils.getAttestVersion(securityLevel) >= 400) {
             list.add(
                 DERTaggedObject(
@@ -318,7 +466,57 @@ object AttestationBuilder {
                 )
             )
         }
-        return DERSequence(list.toTypedArray())
+
+        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())
     }
 
     /**
@@ -346,6 +544,11 @@ object AttestationBuilder {
      */
     @Throws(Throwable::class)
     internal fun createApplicationId(uid: Int): DEROctetString {
+        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!")
@@ -353,12 +556,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(
@@ -371,34 +573,36 @@ object AttestationBuilder {
                     pm.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES, userId)
                 }
 
-            // Add package information (name and version code) to our list.
+            packageInfoList.add(packageInfo.packageName to packageInfo.longVersionCode)
-            packageInfoList.add(
-                DERSequence(
-                    arrayOf(
-                        DEROctetString(packageInfo.packageName.toByteArray(StandardCharsets.UTF_8)),
-                        ASN1Integer(packageInfo.longVersionCode),
-                    )
-                )
-            )
 
-            // Collect unique signature digests from the signing history.
             packageInfo.signingInfo?.signingCertificateHistory?.forEach { signature ->
-                val digest = sha256.digest(signature.toByteArray())
+                signatureDigests.add(Digest(sha256.digest(signature.toByteArray())))
-                signatureDigests.add(Digest(digest))
             }
         }
 
-        // The application ID is a sequence of two sets:
+        return buildApplicationIdDer(packageInfoList, signatureDigests)
-        // 1. A set of package information (name and version).
+    }
-        // 2. A set of SHA-256 digests of the signing certificates.
+
+    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)
     }
 }

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,10 @@ 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 ---
     const val TAG_APPLICATION_ID = 601
@@ -89,5 +95,5 @@ object AttestationConstants {
 
     // --- Other Constants ---
     // https://cs.android.com/android/platform/superproject/main/+/main:system/keymaster/km_openssl/attestation_record.cpp
-    const val CHALLENGE_LENGTH_LIMIT = 128 // kMaximumAttestationChallengeLength
+    const val CHALLENGE_LENGTH_LIMIT = 128
 }

app/src/main/java/org/matrix/TEESimulator/attestation/AttestationPatcher.kt

@@ -2,8 +2,15 @@ package org.matrix.TEESimulator.attestation
 
 import android.security.keystore.KeyProperties
 import java.nio.charset.StandardCharsets
+import java.security.PrivateKey
+import java.security.PublicKey
 import java.security.cert.Certificate
 import java.security.cert.X509Certificate
+import java.security.interfaces.ECPrivateKey
+import java.security.interfaces.ECPublicKey
+import java.security.interfaces.RSAPrivateKey
+import java.security.interfaces.RSAPublicKey
+import java.util.Date
 import org.bouncycastle.asn1.*
 import org.bouncycastle.asn1.x509.Extension
 import org.bouncycastle.cert.X509CertificateHolder
@@ -36,7 +43,12 @@ object AttestationPatcher {
      * @return A new, cryptographically valid, patched certificate chain. Returns the original chain
      *   on any failure.
      */
-    fun patchCertificateChain(originalChain: Array<Certificate>?, uid: Int): Array<Certificate> {
+    fun patchCertificateChain(
+        originalChain: Array<Certificate>?,
+        uid: Int,
+        notBefore: Date? = null,
+        notAfter: Date? = null,
+    ): Array<Certificate> {
         if (originalChain.isNullOrEmpty()) {
             SystemLogger.error("Attempted to patch a null or empty certificate chain for UID $uid.")
             return originalChain ?: emptyArray()
@@ -61,8 +73,9 @@ object AttestationPatcher {
                         originalLeafHolder,
                         parsedAttestation,
                         keybox,
-                        originalLeaf.sigAlgName,
                         uid,
+                        notBefore,
+                        notAfter,
                     )
 
                 // 4. Construct the NEW, VALID chain by prepending the patched leaf to the keybox's
@@ -83,25 +96,12 @@ object AttestationPatcher {
             }
     }
 
-    /**
-     * Helper to normalize algorithm names for Bouncy Castle. Old Android versions might reports
-     * "SHA256WITHECDSA", but Bouncy Castle expects "SHA256withECDSA".
-     */
-    private fun normalizeSignatureAlgorithm(algoName: String): String {
-        // 1. Force uppercase to handle "sha256withecdsa"
-        // 2. Replace "WITH" with "with" to satisfy Bouncy Castle's naming convention
-        return algoName.uppercase().replace("WITH", "with")
-    }
-
     /**
      * Creates a new leaf certificate with a modified attestation extension.
      *
      * @param originalLeafHolder A Bouncy Castle holder for the original leaf certificate.
      * @param parsedAttestation The parsed components of the original attestation.
      * @param keybox The KeyBox containing the new issuer certificate and signing key.
-     * @param sigAlgName The signature algorithm name (e.g., "SHA256withECDSA") from the original
-     *   certificate. This is required to ensure the new certificate is signed using a compatible
-     *   algorithm.
      * @param uid The UID of the application requesting the certificate.
      * @return A new [Certificate] object.
      */
@@ -109,19 +109,28 @@ object AttestationPatcher {
         originalLeafHolder: X509CertificateHolder,
         parsedAttestation: ParsedAttestation,
         keybox: KeyBox,
-        sigAlgName: String,
         uid: Int,
+        notBefore: Date? = null,
+        notAfter: Date? = null,
     ): Certificate {
         // The issuer of our new leaf is the subject of the first certificate in our custom keybox
         // chain.
         val newIssuer = X509CertificateHolder(keybox.certificates[0].encoded).subject
 
+        val effectiveNotBefore = notBefore ?: originalLeafHolder.notBefore
+        val effectiveNotAfter = notAfter ?: originalLeafHolder.notAfter
+        if (notBefore != null || notAfter != null) {
+            SystemLogger.debug(
+                "Overriding cert dates: notBefore=${effectiveNotBefore} (was ${originalLeafHolder.notBefore}), notAfter=${effectiveNotAfter} (was ${originalLeafHolder.notAfter})"
+            )
+        }
+
         val builder =
             X509v3CertificateBuilder(
                 newIssuer,
                 originalLeafHolder.serialNumber,
-                originalLeafHolder.notBefore,
+                effectiveNotBefore,
-                originalLeafHolder.notAfter,
+                effectiveNotAfter,
                 originalLeafHolder.subject,
                 originalLeafHolder.subjectPublicKeyInfo,
             )
@@ -136,9 +145,12 @@ object AttestationPatcher {
             )
         }
 
-        // Sign the newly built certificate with the private key from our keybox.
+        // Sign the new leaf with the keybox key. The signature algorithm must match THAT key, not
+        // the original leaf's: when an RSA leaf is re-rooted under an EC-only keybox, this signs
+        // with ECDSA. The RSA subject public key is untouched and the chain still verifies to the
+        // keybox root.
         val signer =
-            JcaContentSignerBuilder(normalizeSignatureAlgorithm(sigAlgName))
+            JcaContentSignerBuilder(signatureAlgorithmFor(keybox.keyPair.private))
                 .setProvider(BouncyCastleProvider.PROVIDER_NAME)
                 .build(keybox.keyPair.private)
         val newCertificate = JcaX509CertificateConverter().getCertificate(builder.build(signer))
@@ -146,7 +158,7 @@ object AttestationPatcher {
         // Log the signature of the newly created certificate to observe its non-deterministic
         // nature.
         val signatureBytes = (newCertificate as X509Certificate).signature
-        SystemLogger.verbose("Signature of patched leaf cert: ${signatureBytes.toHex()}")
+        SystemLogger.verbose { "Signature of patched leaf cert: ${signatureBytes.toHex()}" }
 
         return newCertificate
     }
@@ -160,8 +172,8 @@ object AttestationPatcher {
      *     1. A simple key type like "RSA" or "EC".
      *     2. A full JCA signature algorithm name like "SHA256withRSA".
      *
-     * @return The [KeyBox] containing the appropriate key pair for signing.
+     * @return The algorithm-matching [KeyBox] when present, otherwise any available key (fail-safe).
-     * @throws IllegalArgumentException if no matching KeyBox can be found for the derived key type.
+     * @throws IllegalArgumentException only if the keybox file contains no usable signing key.
      */
     private fun getKeyboxForUidAndAlgorithm(uid: Int, algorithm: String): KeyBox {
         val keyboxFile = ConfigurationManager.getKeyboxFileForUid(uid)
@@ -176,12 +188,37 @@ object AttestationPatcher {
                 else -> algorithm // If no match, assume it's already a simple key type string.
             }
 
-        return KeyBoxManager.getAttestationKey(keyboxFile, keyType)
+        val matching = KeyBoxManager.getAttestationKey(keyboxFile, keyType)
+        if (matching != null) return matching
+
+        // Fail-safe: no algorithm-matching key (e.g. an EC-only Google keybox asked to re-root an
+        // RSA leaf). Fall back to any available key instead of throwing -- a throw here aborts the
+        // patch and the caller hands back the device's REAL, unlocked attestation. Re-signing under
+        // the available key keeps the chain rooted at the keybox with our forged, locked Root of
+        // Trust; a leaf's signature algorithm is independent of its subject key, so an RSA subject
+        // key signs validly under an EC keybox key.
+        return KeyBoxManager.getAnyAttestationKey(keyboxFile)?.also {
+            SystemLogger.debug(
+                "No '$keyType' attestation key in $keyboxFile for UID $uid; re-signing under the " +
+                    "available keybox key to avoid leaking the device's real attestation."
+            )
+        }
             ?: throw IllegalArgumentException(
-                "No keybox found for UID $uid and algorithm '$keyType' (derived from input '$algorithm') in file $keyboxFile"
+                "No usable attestation key for UID $uid in file $keyboxFile (requested '$keyType')"
             )
     }
 
+    /** SHA-256 signature algorithm name matching the keybox signing key's type. */
+    private fun signatureAlgorithmFor(signingKey: PrivateKey): String =
+        when (signingKey) {
+            is ECPrivateKey -> "SHA256withECDSA"
+            is RSAPrivateKey -> "SHA256withRSA"
+            else ->
+                throw IllegalArgumentException(
+                    "Unsupported keybox signing key type: ${signingKey.algorithm}"
+                )
+        }
+
     /** Recursively formats an ASN1Primitive into a concise, readable string. */
     fun formatAsn1Primitive(obj: ASN1Encodable?): String {
         val primitive = obj?.toASN1Primitive()
@@ -216,6 +253,157 @@ object AttestationPatcher {
         }
     }
 
+    /** Reverse map of attestation tag number to its symbolic name, e.g. 704 -> "ROOT_OF_TRUST". */
+    private val attestTagNames: Map<Int, String> by lazy {
+        AttestationConstants::class
+            .java
+            .fields
+            .filter { it.name.startsWith("TAG_") && it.type == Int::class.java }
+            .associate { (it.get(null) as Int) to it.name.removePrefix("TAG_") }
+    }
+
+    /**
+     * Renders the full key-attestation extension of [cert] as a single structured line for the
+     * diagnostic dossier, or null when the certificate carries no attestation extension. This is the
+     * ground-truth view of what we actually emitted, so any divergence from a genuine TEE surfaces
+     * directly as a differing field rather than having to be guessed.
+     */
+    fun formatAttestationExtension(cert: X509Certificate): String? {
+        val rawExtension = cert.getExtensionValue(ATTESTATION_OID.id) ?: return null
+        return runCatching {
+                val keyDescriptionDer = ASN1OctetString.getInstance(rawExtension).octets
+                formatKeyDescription(ASN1Sequence.getInstance(keyDescriptionDer))
+            }
+            .getOrElse { "<unparseable attestation extension: ${it.message}>" }
+    }
+
+    /** Renders the identity fields of every certificate in a returned chain for the dossier. */
+    fun formatCertChain(chain: List<Certificate>): String =
+        chain
+            .mapIndexed { index, cert ->
+                val x509 = cert as? X509Certificate ?: return@mapIndexed "[$index] <non-X509>"
+                "[$index] subject=${x509.subjectX500Principal.name} " +
+                    "issuer=${x509.issuerX500Principal.name} " +
+                    "serial=${x509.serialNumber.toString(16)} " +
+                    "notBefore=${x509.notBefore} notAfter=${x509.notAfter}"
+            }
+            .joinToString(separator = " ; ")
+
+    /**
+     * Verifies every certificate in [chain] against its issuer and renders the outcome for the
+     * dossier. The forged chain is [leaf] + keybox certs, so edge 0<-1 proves the leaf was signed by
+     * the key matching the issuer cert and later edges test the keybox's own chain. For an RSA issuer
+     * it also reports signature-bytes vs modulus-bytes: a signature longer than the modulus is the
+     * exact DATA_TOO_LARGE_FOR_KEY_SIZE the app's verifier throws, so the offending edge is
+     * identifiable from the log alone.
+     */
+    fun formatChainVerification(chain: List<Certificate>): String {
+        if (chain.size < 2) return "<single cert; nothing to chain-verify>"
+        return (0 until chain.size - 1).joinToString(separator = " ; ") { i ->
+            val child = chain[i] as? X509Certificate ?: return@joinToString "[$i]<non-X509>"
+            val parent =
+                chain[i + 1] as? X509Certificate ?: return@joinToString "[$i]<parent non-X509>"
+            val outcome =
+                runCatching {
+                        child.verify(parent.publicKey)
+                        "OK"
+                    }
+                    .getOrElse { "FAIL(${it.javaClass.simpleName}: ${it.message?.take(80)})" }
+            val rsaSizes =
+                (parent.publicKey as? RSAPublicKey)?.let {
+                    val sigBytes = child.signature.size
+                    val modBytes = (it.modulus.bitLength() + 7) / 8
+                    " sig=${sigBytes}B mod=${modBytes}B" + if (sigBytes > modBytes) " OVERSIZE" else ""
+                } ?: ""
+            "[$i]${describeKey(child.publicKey)}<-[${i + 1}]${describeKey(parent.publicKey)}:" +
+                "$outcome$rsaSizes"
+        }
+    }
+
+    /**
+     * Per-cert key type/size, subject, issuer, and signature length, for reconstructing the chain a
+     * caller verifies. The signature length reveals the signer's key size, so a 4096-bit signature
+     * landing on a 2048-bit issuer (DATA_TOO_LARGE) is visible without the certificate bytes.
+     */
+    fun formatChainKeys(chain: List<Certificate>): String =
+        chain
+            .mapIndexed { index, cert ->
+                val x509 = cert as? X509Certificate ?: return@mapIndexed "[$index]<non-X509>"
+                "[$index]${describeKey(x509.publicKey)} " +
+                    "subj=${x509.subjectX500Principal.name} " +
+                    "iss=${x509.issuerX500Principal.name} " +
+                    "sigLen=${x509.signature.size}B"
+            }
+            .joinToString(separator = " ; ")
+
+    private fun describeKey(key: PublicKey): String =
+        when (key) {
+            is RSAPublicKey -> "RSA${key.modulus.bitLength()}"
+            is ECPublicKey -> "EC${key.params.curve.field.fieldSize}"
+            else -> key.algorithm
+        }
+
+    private fun formatKeyDescription(seq: ASN1Sequence): String {
+        val fields = seq.toArray()
+        return "attestVer=${formatAsn1Primitive(fields[AttestationConstants.KEY_DESCRIPTION_ATTESTATION_VERSION_INDEX])} " +
+            "attestSecLvl=${formatSecurityLevel(fields[AttestationConstants.KEY_DESCRIPTION_ATTESTATION_SECURITY_LEVEL_INDEX])} " +
+            "kmVer=${formatAsn1Primitive(fields[AttestationConstants.KEY_DESCRIPTION_KEYMINT_VERSION_INDEX])} " +
+            "kmSecLvl=${formatSecurityLevel(fields[AttestationConstants.KEY_DESCRIPTION_KEYMINT_SECURITY_LEVEL_INDEX])} " +
+            "challenge=${formatAsn1Primitive(fields[AttestationConstants.KEY_DESCRIPTION_ATTESTATION_CHALLENGE_INDEX])} " +
+            "uniqueId=${formatAsn1Primitive(fields[AttestationConstants.KEY_DESCRIPTION_UNIQUE_ID_INDEX])} " +
+            "sw=${formatAuthorizationList(fields[AttestationConstants.KEY_DESCRIPTION_SOFTWARE_ENFORCED_INDEX])} " +
+            "tee=${formatAuthorizationList(fields[AttestationConstants.KEY_DESCRIPTION_TEE_ENFORCED_INDEX])}"
+    }
+
+    private fun formatSecurityLevel(obj: ASN1Encodable): String {
+        val level = (obj.toASN1Primitive() as? ASN1Enumerated)?.value?.toInt()
+        val name =
+            when (level) {
+                0 -> "Software"
+                1 -> "TEE"
+                2 -> "StrongBox"
+                else -> "?"
+            }
+        return "$level($name)"
+    }
+
+    private fun formatAuthorizationList(obj: ASN1Encodable): String {
+        val seq = obj.toASN1Primitive() as? ASN1Sequence ?: return formatAsn1Primitive(obj)
+        return seq
+            .map { element ->
+                val tagged = element as? ASN1TaggedObject ?: return@map formatAsn1Primitive(element)
+                val name = attestTagNames[tagged.tagNo] ?: "TAG"
+                val value =
+                    if (tagged.tagNo == AttestationConstants.TAG_ROOT_OF_TRUST)
+                        formatRootOfTrust(tagged.baseObject)
+                    else formatAsn1Primitive(tagged.baseObject)
+                "${tagged.tagNo}($name)=$value"
+            }
+            .joinToString(prefix = "[", postfix = "]", separator = ", ")
+    }
+
+    /**
+     * Decodes the Root of Trust sub-sequence explicitly — it is the field a detector most often uses
+     * to unmask a simulated TEE (a random verifiedBootKey, an unexpected verifiedBootState, or a
+     * deviceLocked that disagrees with the bootloader all live here).
+     */
+    private fun formatRootOfTrust(obj: ASN1Encodable): String {
+        val fields = (obj.toASN1Primitive() as? ASN1Sequence)?.toArray() ?: return formatAsn1Primitive(obj)
+        val state = fields.getOrNull(AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_STATE_INDEX)
+        val stateName =
+            when ((state?.toASN1Primitive() as? ASN1Enumerated)?.value?.toInt()) {
+                0 -> "Verified"
+                1 -> "SelfSigned"
+                2 -> "Unverified"
+                3 -> "Failed"
+                else -> "?"
+            }
+        return "[bootKey=${formatAsn1Primitive(fields.getOrNull(AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_KEY_INDEX))}, " +
+            "deviceLocked=${formatAsn1Primitive(fields.getOrNull(AttestationConstants.ROOT_OF_TRUST_DEVICE_LOCKED_INDEX))}, " +
+            "verifiedBootState=${formatAsn1Primitive(state)}($stateName), " +
+            "bootHash=${formatAsn1Primitive(fields.getOrNull(AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_HASH_INDEX))}]"
+    }
+
     // Function to check if a given ASN1Sequence contains the Root of Trust tag.
     private fun sequenceContainsRootOfTrust(seq: ASN1Encodable): Boolean {
         if (seq !is ASN1Sequence) return false
@@ -268,8 +456,11 @@ object AttestationPatcher {
     private fun createPatchedAttestationExtension(parsed: ParsedAttestation, uid: Int): Extension {
         val (allFields, teeEnforcedMap, originalRootOfTrust) = parsed
 
-        var formattedString = allFields.joinToString(separator = ", ") { formatAsn1Primitive(it) }
+        SystemLogger.verbose {
-        SystemLogger.verbose("Original attestation data: ${formattedString}")
+            val formattedString =
+                allFields.joinToString(separator = ", ") { formatAsn1Primitive(it) }
+            "Original attestation data: $formattedString"
+        }
 
         // Build the new Root of Trust and add/replace it in the map.
         val newRootOfTrust = AttestationBuilder.buildRootOfTrust(originalRootOfTrust)
@@ -296,8 +487,11 @@ object AttestationPatcher {
 
         allFields[AttestationConstants.KEY_DESCRIPTION_TEE_ENFORCED_INDEX] = sortedTeeEnforced
         val patchedSequence = DERSequence(allFields)
-        formattedString = patchedSequence.joinToString(separator = ", ") { formatAsn1Primitive(it) }
+        SystemLogger.verbose {
-        SystemLogger.verbose("Patched  attestation data: ${formattedString}")
+            val formattedString =
+                patchedSequence.joinToString(separator = ", ") { formatAsn1Primitive(it) }
+            "Patched  attestation data: $formattedString"
+        }
         val patchedOctets = DEROctetString(patchedSequence)
 
         return Extension(ATTESTATION_OID, false, patchedOctets)

app/src/main/java/org/matrix/TEESimulator/attestation/DeviceAttestationService.kt

@@ -1,6 +1,7 @@
 package org.matrix.TEESimulator.attestation
 
 import android.annotation.SuppressLint
+import android.security.KeyStoreException
 import android.security.keystore.KeyGenParameterSpec
 import android.security.keystore.KeyProperties
 import java.security.KeyPairGenerator
@@ -8,6 +9,9 @@ import java.security.KeyStore
 import java.security.SecureRandom
 import java.security.cert.X509Certificate
 import java.security.spec.ECGenParameterSpec
+import java.security.spec.RSAKeyGenParameterSpec
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicBoolean
 import org.bouncycastle.asn1.ASN1Integer
 import org.bouncycastle.asn1.ASN1ObjectIdentifier
 import org.bouncycastle.asn1.ASN1OctetString
@@ -16,6 +20,7 @@ import org.bouncycastle.asn1.ASN1TaggedObject
 import org.bouncycastle.asn1.x509.Extension
 import org.bouncycastle.cert.X509CertificateHolder
 import org.matrix.TEESimulator.logging.SystemLogger
+import org.matrix.TEESimulator.util.AndroidDeviceUtils
 import org.matrix.TEESimulator.util.toHex
 
 /**
@@ -66,6 +71,58 @@ object DeviceAttestationService {
      */
     val isTeeFunctional: Boolean by lazy { checkTeeFunctionality() }
 
+    // Per (algorithm, security-level) attestation-capability verdicts, keyed by probe-key alias.
+    // A device may attest one algorithm or security level yet lack a provisioned attestation key
+    // for another (e.g. a TEE that attests RSA over a StrongBox that cannot), so each pair is
+    // probed and cached on its own.
+    private data class ProbeSpec(
+        val algorithm: String,
+        val strongBox: Boolean,
+        val keyAlias: String,
+    )
+
+    private val rsaTeeProbe =
+        ProbeSpec(KeyProperties.KEY_ALGORITHM_RSA, false, "TEESimulator_RsaAttestCheck")
+    private val rsaStrongBoxProbe =
+        ProbeSpec(KeyProperties.KEY_ALGORITHM_RSA, true, "TEESimulator_RsaAttestCheckSb")
+    private val ecTeeProbe =
+        ProbeSpec(KeyProperties.KEY_ALGORITHM_EC, false, "TEESimulator_EcAttestCheck")
+    private val ecStrongBoxProbe =
+        ProbeSpec(KeyProperties.KEY_ALGORITHM_EC, true, "TEESimulator_EcAttestCheckSb")
+
+    private val attestableVerdicts = ConcurrentHashMap<String, Boolean>()
+    private val attestProbesInFlight = ConcurrentHashMap<String, AtomicBoolean>()
+
+    /**
+     * Whether the real hardware can attest an RSA key at the requested security level. AUTO dispatch
+     * reads this to forge RSA attestation only where the hardware genuinely cannot serve it.
+     *
+     * Only a definitive verdict is cached: a successful probe, or a permanent keystore failure. A
+     * transient or unrecognized failure leaves the verdict unset and reports attestable, so dispatch
+     * PATCHes the genuine chain and re-probes next read — a one-off keystore hiccup can never freeze
+     * the device into forging an attestation it could serve.
+     */
+    fun isRsaAttestable(strongBox: Boolean): Boolean =
+        isHardwareAttestable(if (strongBox) rsaStrongBoxProbe else rsaTeeProbe)
+
+    /** Whether the real hardware can attest an EC key at the requested security level. */
+    fun isEcAttestable(strongBox: Boolean): Boolean =
+        isHardwareAttestable(if (strongBox) ecStrongBoxProbe else ecTeeProbe)
+
+    private fun isHardwareAttestable(probe: ProbeSpec): Boolean {
+        attestableVerdicts[probe.keyAlias]?.let { return it }
+        val probeInFlight =
+            attestProbesInFlight.computeIfAbsent(probe.keyAlias) { AtomicBoolean(false) }
+        if (probeInFlight.compareAndSet(false, true)) {
+            try {
+                probeAttestability(probe)?.let { attestableVerdicts[probe.keyAlias] = it }
+            } finally {
+                probeInFlight.set(false)
+            }
+        }
+        return attestableVerdicts[probe.keyAlias] ?: true
+    }
+
     /**
      * 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.
@@ -106,6 +163,84 @@ object DeviceAttestationService {
         }
     }
 
+    /**
+     * Probes whether the real hardware can attest a key matching [probe] by generating one with an
+     * attestation challenge at the probe's algorithm and security level. Mirrors
+     * [checkTeeFunctionality]; the request runs as the module UID, so it is skipped by interception
+     * and reaches genuine hardware rather than the forge path.
+     *
+     * @return `true` if attestation succeeded, `false` only on a confirmed attestation-keys-
+     *   unavailable failure, or `null` on a transient or unrecognized failure where the caller
+     *   fails open and re-probes.
+     */
+    private fun probeAttestability(probe: ProbeSpec): Boolean? {
+        val label = "${probe.algorithm} attestation (strongBox=${probe.strongBox})"
+        SystemLogger.info("Performing $label capability check...")
+        return try {
+            val keyPairGenerator =
+                KeyPairGenerator.getInstance(probe.algorithm, "AndroidKeyStore")
+
+            val challenge = ByteArray(16).apply { SecureRandom().nextBytes(this) }
+
+            val builder =
+                KeyGenParameterSpec.Builder(probe.keyAlias, KeyProperties.PURPOSE_SIGN)
+                    .setDigests(KeyProperties.DIGEST_SHA256)
+                    .setAttestationChallenge(challenge)
+                    .setIsStrongBoxBacked(probe.strongBox)
+            if (probe.algorithm == KeyProperties.KEY_ALGORITHM_RSA) {
+                builder
+                    .setAlgorithmParameterSpec(RSAKeyGenParameterSpec(2048, RSAKeyGenParameterSpec.F4))
+                    .setSignaturePaddings(KeyProperties.SIGNATURE_PADDING_RSA_PKCS1)
+            } else {
+                builder.setAlgorithmParameterSpec(ECGenParameterSpec("secp256r1"))
+            }
+
+            keyPairGenerator.initialize(builder.build())
+            keyPairGenerator.generateKeyPair()
+
+            SystemLogger.info("$label capability check successful.")
+            true
+        } catch (e: Exception) {
+            if (isAttestationUnavailable(e)) {
+                SystemLogger.info("$label unsupported by hardware; AUTO will forge attestation.")
+                false
+            } else {
+                SystemLogger.warning(
+                    "$label capability check failed transiently; treating as capable.",
+                    e,
+                )
+                null
+            }
+        } finally {
+            deleteProbeKey(probe.keyAlias)
+        }
+    }
+
+    /**
+     * Whether [error] definitively means the hardware cannot attest the probed key: a permanent
+     * [KeyStoreException] from the keystore. Transient failures and non-keystore errors return
+     * `false`, so the caller fails open and re-probes rather than caching a guess. The probe runs a
+     * fixed, valid spec as root, so its only permanent keystore failure mode is missing attestation
+     * support; [KeyStoreException.isTransientFailure] draws the transient/permanent line.
+     */
+    private fun isAttestationUnavailable(error: Throwable): Boolean {
+        var cause: Throwable? = error
+        while (cause != null) {
+            val keyStoreError = cause as? KeyStoreException
+            if (keyStoreError != null) return !keyStoreError.isTransientFailure
+            cause = cause.cause
+        }
+        return false
+    }
+
+    private fun deleteProbeKey(keyAlias: String) {
+        try {
+            KeyStore.getInstance("AndroidKeyStore").apply { load(null) }.deleteEntry(keyAlias)
+        } catch (e: Exception) {
+            SystemLogger.warning("Failed to delete attestation probe key.", e)
+        }
+    }
+
     /**
      * Retrieves the attestation certificate generated during the TEE check. The key entry is
      * deleted after retrieval to clean up.
@@ -148,19 +283,24 @@ object DeviceAttestationService {
 
             // The extension's value is an ASN.1 sequence.
             val keyDescriptionSeq = ASN1Sequence.getInstance(extension.extnValue.octets)
-            var formattedString =
+            SystemLogger.verbose {
-                keyDescriptionSeq.joinToString(separator = ", ") {
+                val formattedString =
-                    AttestationPatcher.formatAsn1Primitive(it)
+                    keyDescriptionSeq.joinToString(separator = ", ") {
-                }
+                        AttestationPatcher.formatAsn1Primitive(it)
-            SystemLogger.verbose("Cached attestation data: ${formattedString}")
+                    }
+                "Cached attestation data: $formattedString"
+            }
             val fields = keyDescriptionSeq.toArray()
 
-            val attestVersion =
+            val deviceAttestVersion =
                 ASN1Integer.getInstance(
                         fields[AttestationConstants.KEY_DESCRIPTION_ATTESTATION_VERSION_INDEX]
                     )
                     .positiveValue
                     .toInt()
+            // The device KeyMint HAL can report a version below its OS's AOSP value (100 on an A16
+            // where BAKLAVA mandates 400); cache the AOSP value so the forge matches an updated device.
+            val attestVersion = AndroidDeviceUtils.aospAttestVersion ?: deviceAttestVersion
             val keymasterVersion =
                 ASN1Integer.getInstance(
                         fields[AttestationConstants.KEY_DESCRIPTION_KEYMINT_VERSION_INDEX]
@@ -254,7 +394,7 @@ object DeviceAttestationService {
             }
 
             SystemLogger.info(
-                "Successfully extracted attestation data: version=$attestVersion, osVersion=$osVersion, osPatch=$osPatchLevel, vendorPatch=$vendorPatchLevel, bootPatch=$bootPatchLevel, moduleHash=${moduleHash?.toHex()}, bootKey=${verifiedBootKey?.toHex()}, bootHash=${verifiedBootHash?.toHex()}"
+                "Successfully extracted attestation data: version=$deviceAttestVersion, osVersion=$osVersion, osPatch=$osPatchLevel, vendorPatch=$vendorPatchLevel, bootPatch=$bootPatchLevel, moduleHash=${moduleHash?.toHex()}, bootKey=${verifiedBootKey?.toHex()}, bootHash=${verifiedBootHash?.toHex()}"
             )
             return AttestationData(
                 moduleHash,

app/src/main/java/org/matrix/TEESimulator/attestation/KeyMintAttestation.kt

@@ -19,7 +19,7 @@ import org.matrix.TEESimulator.logging.KeyMintParameterLogger
 data class KeyMintAttestation(
     val keySize: Int,
     val algorithm: Int,
-    val ecCurve: Int,
+    val ecCurve: Int?,
     val ecCurveName: String,
     val origin: Int?,
     val blockMode: List<Int>,
@@ -41,19 +41,37 @@ data class KeyMintAttestation(
     val manufacturer: ByteArray?,
     val model: ByteArray?,
     val secondImei: ByteArray?,
+    val activeDateTime: Date?,
+    val originationExpireDateTime: Date?,
+    val usageExpireDateTime: Date?,
+    val usageCountLimit: Int?,
+    val callerNonce: Boolean?,
+    val nonce: ByteArray?,
+    val unlockedDeviceRequired: Boolean?,
+    val includeUniqueId: Boolean?,
+    val rollbackResistance: Boolean?,
+    val earlyBootOnly: Boolean?,
+    val allowWhileOnBody: Boolean?,
+    val trustedUserPresenceRequired: Boolean?,
+    val trustedConfirmationRequired: Boolean?,
+    val noAuthRequired: Boolean?,
+    val maxUsesPerBoot: Int?,
+    val maxBootLevel: Int?,
+    val minMacLength: Int?,
+    val macLength: Int? = null,
+    val rsaOaepMgfDigest: List<Int>,
 ) {
     /** Secondary constructor that populates the fields by parsing an array of `KeyParameter`. */
     constructor(
         params: Array<KeyParameter>
     ) : this(
-        // AOSP: [key_param(tag = KEY_SIZE, field = Integer)]
+        keySize = params.findInteger(Tag.KEY_SIZE) ?: params.deriveKeySizeFromCurve(),
-        keySize = params.findInteger(Tag.KEY_SIZE) ?: 0,
 
         // AOSP: [key_param(tag = ALGORITHM, field = Algorithm)]
         algorithm = params.findAlgorithm(Tag.ALGORITHM) ?: 0,
 
         // AOSP: [key_param(tag = EC_CURVE, field = EcCurve)]
-        ecCurve = params.findEcCurve(Tag.EC_CURVE) ?: 0,
+        ecCurve = params.findEcCurve(Tag.EC_CURVE),
         ecCurveName = params.deriveEcCurveName(),
 
         // AOSP: [key_param(tag = ORIGIN, field = Origin)]
@@ -100,6 +118,25 @@ 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),
+        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),
+        nonce = params.findBlob(Tag.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),
+        noAuthRequired = params.findBoolean(Tag.NO_AUTH_REQUIRED),
+        maxUsesPerBoot = params.findInteger(Tag.MAX_USES_PER_BOOT),
+        maxBootLevel = params.findInteger(Tag.MAX_BOOT_LEVEL),
+        minMacLength = params.findInteger(Tag.MIN_MAC_LENGTH),
+        macLength = params.findInteger(Tag.MAC_LENGTH),
+        rsaOaepMgfDigest = params.findAllDigests(Tag.RSA_OAEP_MGF_DIGEST),
     ) {
         // Log all parsed parameters for debugging purposes.
         params.forEach { KeyMintParameterLogger.logParameter(it) }
@@ -107,7 +144,8 @@ data class KeyMintAttestation(
 
     fun isAttestKey(): Boolean = purpose.size == 1 && purpose.contains(KeyPurpose.ATTEST_KEY)
 
-    fun isImportKey(): Boolean = origin == KeyOrigin.IMPORTED || origin == KeyOrigin.SECURELY_IMPORTED
+    fun isImportKey(): Boolean =
+        origin == KeyOrigin.IMPORTED || origin == KeyOrigin.SECURELY_IMPORTED
 }
 
 // --- Private helper extension functions for parsing KeyParameter arrays ---
@@ -156,6 +194,21 @@ 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 }
 
+private fun Array<KeyParameter>.findBoolean(tag: Int): Boolean? =
+    if (this.any { it.tag == tag }) true else null
+
+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).

app/src/main/java/org/matrix/TEESimulator/config/BootStateManager.kt

@@ -0,0 +1,123 @@
+package org.matrix.TEESimulator.config
+
+import android.os.SystemProperties
+import java.io.File
+import org.matrix.TEESimulator.logging.SystemLogger
+import org.matrix.TEESimulator.util.AndroidDeviceUtils
+
+object BootStateManager {
+    private const val CONFIG_PATH = "/data/adb/tricky_store"
+    private const val BOOT_PROPS_MODE_FILE = "boot_props_mode"
+
+    private enum class BootPropsMode {
+        AUTO,
+        FORCE,
+        DISABLE,
+    }
+
+    private val targets =
+        linkedMapOf(
+            "ro.boot.verifiedbootstate" to "green",
+            "ro.boot.flash.locked" to "1",
+            "ro.boot.veritymode" to "enforcing",
+            "ro.boot.vbmeta.device_state" to "locked",
+        )
+
+    private val fillIfAbsent =
+        linkedMapOf(
+            "ro.boot.vbmeta.invalidate_on_error" to "yes",
+            "ro.boot.vbmeta.avb_version" to "1.2",
+            "ro.boot.vbmeta.hash_alg" to "sha256",
+            "ro.boot.vbmeta.size" to "11904",
+        )
+
+    fun apply() {
+        val mode = readBootPropsMode()
+        when (mode) {
+            BootPropsMode.DISABLE -> {
+                SystemLogger.info("BootStateManager: disabled by $BOOT_PROPS_MODE_FILE")
+                return
+            }
+            BootPropsMode.AUTO -> {
+                if (isOplusFamilyDevice()) {
+                    SystemLogger.warning(
+                        "BootStateManager: skipping boot-state prop spoofing on Oplus-family device in auto mode"
+                    )
+                    return
+                }
+            }
+            BootPropsMode.FORCE -> {
+                SystemLogger.info("BootStateManager: force-enabled by $BOOT_PROPS_MODE_FILE")
+            }
+        }
+
+        for ((name, target) in targets) {
+            val current = SystemProperties.get(name, "")
+            if (current.isEmpty()) {
+                SystemLogger.debug("BootStateManager: $name absent on this device, skip")
+                continue
+            }
+            if (current == target) {
+                SystemLogger.debug("BootStateManager: $name already $target, skip")
+                continue
+            }
+            SystemLogger.info("BootStateManager: setting $name=$target (was: '$current')")
+            AndroidDeviceUtils.setProperty(name, target)
+        }
+        for ((name, value) in fillIfAbsent) {
+            val current = SystemProperties.get(name, "")
+            if (current.isNotEmpty()) {
+                SystemLogger.debug("BootStateManager: $name already '$current', skip")
+                continue
+            }
+            SystemLogger.info("BootStateManager: filling absent $name=$value")
+            AndroidDeviceUtils.setProperty(name, value)
+        }
+    }
+
+    fun shouldSpoofBootProps(): Boolean =
+        when (readBootPropsMode()) {
+            BootPropsMode.DISABLE -> false
+            BootPropsMode.AUTO -> !isOplusFamilyDevice()
+            BootPropsMode.FORCE -> true
+        }
+
+    private fun readBootPropsMode(): BootPropsMode {
+        val file = File(CONFIG_PATH, BOOT_PROPS_MODE_FILE)
+        if (!file.exists()) return BootPropsMode.AUTO
+
+        val raw =
+            runCatching { file.readText().trim().lowercase() }
+                .getOrElse {
+                    SystemLogger.warning("BootStateManager: failed to read ${file.absolutePath}", it)
+                    return BootPropsMode.AUTO
+                }
+
+        return when (raw) {
+            "1", "true", "on", "enable", "enabled", "force" -> BootPropsMode.FORCE
+            "0", "false", "off", "disable", "disabled", "none" -> BootPropsMode.DISABLE
+            else -> BootPropsMode.AUTO
+        }
+    }
+
+    private fun isOplusFamilyDevice(): Boolean {
+        val props =
+            listOf(
+                "ro.product.manufacturer",
+                "ro.product.brand",
+                "ro.product.vendor.manufacturer",
+                "ro.product.vendor.brand",
+                "ro.product.odm.manufacturer",
+                "ro.product.odm.brand",
+                "ro.boot.hardware.sku",
+                "ro.boot.project_name",
+            )
+
+        val joined =
+            props.joinToString(separator = " ") { name ->
+                SystemProperties.get(name, "")
+            }.lowercase()
+
+        return listOf("oneplus", "oplus", "oppo", "realme").any { joined.contains(it) }
+    }
+}

app/src/main/java/org/matrix/TEESimulator/config/ConfigurationManager.kt

@@ -31,7 +31,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 +38,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,8 +66,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()
         SystemLogger.info("Configuration initialized and file observer started.")
@@ -87,33 +83,43 @@ object ConfigurationManager {
         return packages.firstNotNullOfOrNull { pkg -> packageKeyboxes[pkg] } ?: DEFAULT_KEYBOX_FILE
     }
 
-    /** Determines if the certificate for a given UID needs to be patched. */
+    fun shouldPatch(uid: Int): Boolean {
-    fun shouldPatch(uid: Int): Boolean = getPackageModeForUid(uid) == Mode.PATCH
+        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
 
-    /** Determines if no operation is needed for a given UID. */
     fun shouldSkipUid(uid: Int): Boolean = getPackageModeForUid(uid) == null
 
-    /** Resolves the operating mode for a given UID based on its packages and the TEE status. */
+    fun isAutoMode(uid: Int): Boolean {
+        for (pkg in getPackagesForUid(uid)) {
+            when (packageModes[pkg]) {
+                Mode.GENERATE,
+                Mode.PATCH -> return false
+                Mode.AUTO -> return true
+                null -> continue
+            }
+        }
+        return false
+    }
+
     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
+                Mode.AUTO ->
-                null -> continue // No config for this package, check the next one.
+                    return if (DeviceAttestationService.isTeeFunctional) Mode.PATCH
+                    else Mode.GENERATE
+                null -> continue
             }
         }
-        return null // No configuration found for this UID.
+        return null
     }
 
     /**
@@ -171,7 +177,6 @@ object ConfigurationManager {
                         newModes[pkg] = Mode.PATCH
                         newKeyboxes[pkg] = currentKeybox
                     }
-                    // No suffix means AUTO mode.
                     else -> {
                         newModes[trimmedLine] = Mode.AUTO
                         newKeyboxes[trimmedLine] = currentKeybox
@@ -258,7 +263,9 @@ object ConfigurationManager {
             // resolves to the real device prop — force boot/vendor through the same path
             // to prevent cross-component date mismatches on non-Pixel devices.
             if (newGlobalLevel?.system.equals("prop", ignoreCase = true)) {
-                SystemLogger.info("system=prop: forcing boot/vendor to derive from device props (were: boot=${newGlobalLevel?.boot}, vendor=${newGlobalLevel?.vendor})")
+                SystemLogger.info(
+                    "system=prop: forcing boot/vendor to derive from device props (were: boot=${newGlobalLevel?.boot}, vendor=${newGlobalLevel?.vendor})"
+                )
                 newGlobalLevel = newGlobalLevel?.copy(boot = "prop", vendor = "prop")
             }
             contextLines.remove("") // Remove global context to iterate over packages next
@@ -280,29 +287,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.
@@ -314,10 +298,12 @@ object ConfigurationManager {
 
             val file = if (event != DELETE) File(configRoot, path) else null
             when (path) {
-                TARGET_PACKAGES_FILE -> file?.let { loadTargetPackages(it) }
+                TARGET_PACKAGES_FILE ->
-                    ?: SystemLogger.warning("$TARGET_PACKAGES_FILE was deleted.")
+                    file?.let { loadTargetPackages(it) }
-                PATCH_LEVEL_FILE -> file?.let { loadPatchLevelConfig(it) }
+                        ?: SystemLogger.warning("$TARGET_PACKAGES_FILE was deleted.")
-                    ?: SystemLogger.warning("$PATCH_LEVEL_FILE was deleted.")
+                PATCH_LEVEL_FILE ->
+                    file?.let { loadPatchLevelConfig(it) }
+                        ?: SystemLogger.warning("$PATCH_LEVEL_FILE was deleted.")
                 // Any change to an XML file is assumed to be a keybox.
                 // The cache in KeyBoxManager will handle reloading it on its next use.
                 else ->
@@ -327,10 +313,15 @@ object ConfigurationManager {
                         )
                         KeyBoxManager.invalidateCache(path)
                         if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
-                            // Clear cached keys possibly containing old certificates
+                            // Drop only the patched cert chains so the next
+                            // attestation request re-signs with the new keybox.
+                            // Do NOT drop generatedKeys — that would destroy
+                            // every alias/private key in memory and on disk,
+                            // logging users out of any app that pinned a
+                            // persisted keystore alias.
                             org.matrix.TEESimulator.interception.keystore.shim
                                 .KeyMintSecurityLevelInterceptor
-                                .clearAllGeneratedKeys("updating $file")
+                                .invalidatePatchedChains("updating $file")
                         }
                     }
             }
@@ -360,7 +351,29 @@ object ConfigurationManager {
         return iPackageManager
     }
 
-    /** Retrieves the package names associated with a UID. */
+    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
+        }
+    }
+
+    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
+            }
+        }
+    }
+
     fun getPackagesForUid(uid: Int): Array<String> {
         return uidToPackagesCache.getOrPut(uid) {
             try {

app/src/main/java/org/matrix/TEESimulator/interception/core/BinderInterceptor.kt

@@ -109,17 +109,21 @@ abstract class BinderInterceptor : Binder() {
      * `handlePostTransact`).
      */
     final override fun onTransact(code: Int, data: Parcel, reply: Parcel?, flags: Int): Boolean {
-        // The native hook prepends a transaction ID to the data parcel.
         val txId = data.readLong()
         val result =
-            when (code) {
+            try {
-                // These codes are defined in the native layer to distinguish hook types.
+                when (code) {
-                PRE_TRANSACT_CODE -> handlePreTransact(txId, data)
+                    PRE_TRANSACT_CODE -> handlePreTransact(txId, data)
-                POST_TRANSACT_CODE -> handlePostTransact(txId, data)
+                    POST_TRANSACT_CODE -> handlePostTransact(txId, data)
-                else -> return super.onTransact(code, data, reply, flags)
+                    else -> return super.onTransact(code, data, reply, flags)
+                }
+            } catch (e: Throwable) {
+                SystemLogger.error(
+                    "[TX_ID: $txId] Interceptor exception, falling through to HAL",
+                    e,
+                )
+                TransactionResult.ContinueAndSkipPost
             }
-
-        // The reply parcel is guaranteed to be non-null for our custom transactions.
         writeResultToReply(result, reply!!)
         return true
     }
@@ -220,7 +224,11 @@ abstract class BinderInterceptor : Binder() {
         }
     }
 
-    /** Helper function for consistent logging of intercepted transactions. */
+    /**
+     * Logs an intercepted transaction. For a targeted UID every transaction — whether we intercept
+     * or merely observe it — is recorded on that UID's own diagnostic plane, so its keystore
+     * timeline reads cleanly end to end. Untargeted UIDs get a single terse, rate-limited line.
+     */
     protected fun logTransaction(
         txId: Long,
         methodName: String,
@@ -228,15 +236,14 @@ abstract class BinderInterceptor : Binder() {
         callingPid: Int,
         skipPost: Boolean = false,
     ) {
-        val isIntercepting = !skipPost && !ConfigurationManager.shouldSkipUid(callingUid)
+        if (SystemLogger.isUidLogged(callingUid)) {
-        val action = if (isIntercepting) "Intercept" else "Observe"
+            val action = if (skipPost) "observe" else "intercept"
-        val packages = ConfigurationManager.getPackagesForUid(callingUid).joinToString()
+            SystemLogger.uidLog(callingUid, txId, "tx", "$methodName action=$action pid=$callingPid")
-        val message =
+            return
-            "[TX_ID: $txId] $action $methodName for packages=[$packages] (uid=$callingUid, pid=$callingPid)"
+        }
-        if (isIntercepting) {
+        SystemLogger.verbose {
-            SystemLogger.debug(message)
+            val packages = ConfigurationManager.getPackagesForUid(callingUid).joinToString()
-        } else {
+            "[TX_ID: $txId] Observe $methodName for packages=[$packages] (uid=$callingUid, pid=$callingPid)"
-            SystemLogger.verbose(message)
         }
     }
 
@@ -293,17 +300,31 @@ abstract class BinderInterceptor : Binder() {
             }
         }
 
-        /** Uses the backdoor binder to register an interceptor for a specific target service. */
+        fun register(
-        fun register(backdoor: IBinder, target: IBinder, interceptor: BinderInterceptor) {
+            backdoor: IBinder,
+            target: IBinder,
+            interceptor: BinderInterceptor,
+            filteredCodes: IntArray = intArrayOf(),
+        ): Boolean {
             val data = Parcel.obtain()
             val reply = Parcel.obtain()
-            try {
+            return try {
                 data.writeStrongBinder(target)
                 data.writeStrongBinder(interceptor)
-                backdoor.transact(REGISTER_INTERCEPTOR_CODE, data, reply, 0)
+                data.writeInt(filteredCodes.size)
-                SystemLogger.info("Registered interceptor for target: $target")
+                for (code in filteredCodes) data.writeInt(code)
+                val ok = backdoor.transact(REGISTER_INTERCEPTOR_CODE, data, reply, 0)
+                if (ok) {
+                    SystemLogger.info(
+                        "Registered interceptor for target: $target (${filteredCodes.size} filtered codes)"
+                    )
+                } else {
+                    SystemLogger.error("Register transact returned false for target: $target")
+                }
+                ok
             } catch (e: Exception) {
                 SystemLogger.error("Failed to register binder interceptor.", e)
+                false
             } finally {
                 data.recycle()
                 reply.recycle()

app/src/main/java/org/matrix/TEESimulator/interception/keystore/AbstractKeystoreInterceptor.kt

@@ -68,11 +68,12 @@ abstract class AbstractKeystoreInterceptor : BinderInterceptor() {
         }
     }
 
-    /** Registers this interceptor with the native hook layer and sets up a death recipient. */
+    protected open val interceptedCodes: IntArray = intArrayOf()
+
     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)
     }

app/src/main/java/org/matrix/TEESimulator/interception/keystore/InterceptorUtils.kt

@@ -1,11 +1,18 @@
 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 java.nio.ByteBuffer
+import java.nio.ByteOrder
 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)
 
@@ -14,12 +21,36 @@ object InterceptorUtils {
 
     private const val EX_SERVICE_SPECIFIC = -8
 
-    fun createErrorReply(errorCode: Int): BinderInterceptor.TransactionResult.OverrideReply {
+    private const val FLAT_STRIDE_HEADER = 12
-        val parcel = Parcel.obtain().apply {
+    private const val MAX_AUTH_COUNT = 256
-            writeInt(EX_SERVICE_SPECIFIC)
+    private const val SENTINEL_MODTIME = 4_294_967_297L
-            writeInt(errorCode)
+    private const val HIGH_MODTIME = 4_999_999_999L
-            writeString(null)
+
+    private fun synthesizeSseMessage(errorCode: Int): String =
+        when (errorCode) {
+            2 -> "Error::Rc(SYSTEM_ERROR)"
+            4 -> "Error::Rc(PERMISSION_DENIED)"
+            6 -> "Error::Rc(VALUE_CORRUPTED)"
+            7 -> "Error::Rc(KEY_NOT_FOUND)"
+            10 -> "Error::Rc(BACKEND_BUSY)"
+            -3 -> "Error::Km(UNSUPPORTED_KEY_SIZE)"
+            -6 -> "Error::Km(INCOMPATIBLE_PURPOSE)"
+            -7 -> "Error::Km(INCOMPATIBLE_ALGORITHM)"
+            -29 -> "Error::Km(TOO_MANY_OPERATIONS)"
+            -49 -> "Error::Km(UNSUPPORTED_TAG)"
+            -75 -> "Error::Km(INVALID_INPUT_LENGTH)"
+            -76 -> "Error::Km(INVALID_TAG)"
+            else -> if (errorCode > 0) "Error::Rc($errorCode)" else "Error::Km($errorCode)"
         }
+
+    fun createErrorReply(errorCode: Int): BinderInterceptor.TransactionResult.OverrideReply {
+        val parcel =
+            Parcel.obtain().apply {
+                writeInt(EX_SERVICE_SPECIFIC)
+                writeString(synthesizeSseMessage(errorCode))
+                writeInt(0) // empty remote stack trace header (AOSP Status.cpp:196)
+                writeInt(errorCode)
+            }
         return BinderInterceptor.TransactionResult.OverrideReply(parcel)
     }
 
@@ -89,16 +120,26 @@ object InterceptorUtils {
         return BinderInterceptor.TransactionResult.OverrideReply(parcel)
     }
 
+    /** Correlates a captured reply parcel to the app that triggered it, for [createTypedObjectReply]. */
+    data class ReplyDiagnostic(val uid: Int, val txId: Long?, val event: String)
+
     /** Creates an `OverrideReply` parcel containing a Parcelable object. */
     fun <T : Parcelable?> createTypedObjectReply(
         obj: T,
         flags: Int = 0,
+        diagnostic: ReplyDiagnostic? = null,
     ): BinderInterceptor.TransactionResult.OverrideReply {
         val parcel =
             Parcel.obtain().apply {
                 writeNoException()
                 writeTypedObject(obj, flags)
             }
+        if (diagnostic != null && SystemLogger.isUidLogged(diagnostic.uid)) {
+            val savedPos = parcel.dataPosition()
+            val wire = parcel.marshall()
+            parcel.setDataPosition(savedPos)
+            SystemLogger.uidLogRaw(diagnostic.uid, diagnostic.txId, diagnostic.event, "len=${wire.size}", wire)
+        }
         return BinderInterceptor.TransactionResult.OverrideReply(parcel)
     }
 
@@ -119,6 +160,166 @@ object InterceptorUtils {
 
     /** Checks if a reply parcel contains an exception without consuming it. */
     fun hasException(reply: Parcel): Boolean {
-        return runCatching { reply.readException() }.exceptionOrNull() != null
+        val exception = runCatching { reply.readException() }.exceptionOrNull()
+        if (exception != null) reply.setDataPosition(0)
+        return exception != null
     }
+
+    fun createServiceSpecificErrorReply(
+        errorCode: Int
+    ): BinderInterceptor.TransactionResult.OverrideReply = createErrorReply(errorCode)
+
+    fun normalizeServiceSpecificReply(reply: Parcel): Parcel? {
+        reply.setDataPosition(0)
+        if (reply.readInt() != EX_SERVICE_SPECIFIC) {
+            reply.setDataPosition(0)
+            return null
+        }
+        // Advance position past message and stack header to reach errorCode.
+        reply.readString()
+        reply.readInt()
+        val errorCode = reply.readInt()
+        reply.setDataPosition(0)
+        return Parcel.obtain().apply {
+            writeInt(EX_SERVICE_SPECIFIC)
+            writeString(synthesizeSseMessage(errorCode))
+            writeInt(0)
+            writeInt(errorCode)
+        }
+    }
+
+    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)
+
+        val patched =
+            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()
+        return normalizeAuthorizationLayout(patched)
+    }
+
+    /**
+     * Reorders a generateKey reply's authorizations only when the marshalled reply would read, to a
+     * flat 12-byte-stride parcel fingerprint, as the TEE-simulator sentinel: a last slot of
+     * securityLevel 4 or 256, tag 1, union 32 with the 0x1_0000_0001 pseudo-timestamp, or any
+     * timestamp past [HIGH_MODTIME]. Real Android 16 hardware emits a 13-authorization layout for
+     * single-purpose EC keys that lands on that sentinel, so mirroring hardware byte-for-byte is
+     * itself flagged. Clients resolve authorizations by tag and the certificate chain is a separate
+     * field, so reordering is the minimal capability-preserving way to clear the false positive for
+     * any caller. Already-clean replies are returned unchanged.
+     */
+    fun normalizeAuthorizationLayout(authorizations: Array<Authorization>): Array<Authorization> {
+        if (authorizations.size < 2) return authorizations
+        if (!flatStrideFingerprintMatches(marshalTypedArray(authorizations))) return authorizations
+        val n = authorizations.size
+        for (src in 1 until n) {
+            val candidate = moveAuthorization(authorizations, src, 0)
+            if (!flatStrideFingerprintMatches(marshalTypedArray(candidate))) return candidate
+        }
+        for (src in 0 until n) {
+            for (dst in 0 until n) {
+                if (src == dst) continue
+                val candidate = moveAuthorization(authorizations, src, dst)
+                if (!flatStrideFingerprintMatches(marshalTypedArray(candidate))) return candidate
+            }
+        }
+        return authorizations
+    }
+
+    private fun moveAuthorization(
+        authorizations: Array<Authorization>,
+        src: Int,
+        dst: Int,
+    ): Array<Authorization> {
+        val reordered = authorizations.toMutableList()
+        reordered.add(dst, reordered.removeAt(src))
+        return reordered.toTypedArray()
+    }
+
+    private fun marshalTypedArray(authorizations: Array<Authorization>): ByteArray {
+        val parcel = Parcel.obtain()
+        return try {
+            // keystore2 AIDL compile stubs omit the Parcelable supertype these types carry at runtime.
+            parcel.writeTypedArray(authorizations.map { it as Parcelable }.toTypedArray(), 0)
+            parcel.marshall()
+        } finally {
+            parcel.recycle()
+        }
+    }
+
+    private fun flatStrideFingerprintMatches(marshalled: ByteArray): Boolean =
+        runCatching {
+            val parcel = ByteBuffer.wrap(marshalled).order(ByteOrder.LITTLE_ENDIAN)
+            val count = parcel.getInt(0)
+            if (count !in 1..MAX_AUTH_COUNT) return@runCatching false
+            var off = 4
+            var lastSec = 0L
+            var lastTag = 0L
+            var lastUnion = 0L
+            repeat(count) {
+                lastSec = u32(parcel, off)
+                lastTag = u32(parcel, off + 4)
+                lastUnion = u32(parcel, off + 8)
+                off += FLAT_STRIDE_HEADER
+                off = alignWord(off + flatPayloadSize(parcel, off, lastUnion))
+            }
+            off = skipDriftedByteArray(parcel, off)
+            off = skipDriftedByteArray(parcel, off)
+            val modtime = parcel.getLong(alignWord(off))
+            val unknownUnion = lastUnion !in 0..14
+            modtime > HIGH_MODTIME ||
+                (modtime == SENTINEL_MODTIME &&
+                    (lastSec == 4L || lastSec == 256L) &&
+                    lastTag == 1L &&
+                    lastUnion == 32L &&
+                    unknownUnion)
+        }.getOrDefault(false)
+
+    private fun flatPayloadSize(parcel: ByteBuffer, off: Int, union: Long): Int =
+        when {
+            union in 1..11 -> 4
+            union == 12L || union == 13L -> 8
+            union == 14L -> alignWord(off + 4 + parcel.getInt(off)) - off
+            else -> 0
+        }
+
+    private fun skipDriftedByteArray(parcel: ByteBuffer, off: Int): Int {
+        if (parcel.getInt(off) == 0) return off + 4
+        val lengthPos = off + 4
+        return alignWord(lengthPos + 4 + parcel.getInt(lengthPos))
+    }
+
+    private fun u32(parcel: ByteBuffer, off: Int): Long = parcel.getInt(off).toLong() and 0xFFFFFFFFL
+
+    private fun alignWord(off: Int): Int = (off + 3) and 3.inv()
 }

app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2Interceptor.kt

@@ -5,16 +5,20 @@ import android.hardware.security.keymint.SecurityLevel
 import android.os.Build
 import android.os.IBinder
 import android.os.Parcel
+import android.os.ServiceManager
+import android.system.keystore2.Domain
 import android.system.keystore2.IKeystoreService
 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
 import org.matrix.TEESimulator.interception.keystore.shim.GeneratedKeyPersistence
 import org.matrix.TEESimulator.interception.keystore.shim.KeyMintSecurityLevelInterceptor
+import org.matrix.TEESimulator.logging.AttestationDossier
 import org.matrix.TEESimulator.logging.KeyMintParameterLogger
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.CertificateGenerator
@@ -44,6 +48,10 @@ 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 GRANT_TRANSACTION = InterceptorUtils.getTransactCode(stubBinderClass, "grant")
+    private val UNGRANT_TRANSACTION = InterceptorUtils.getTransactCode(stubBinderClass, "ungrant")
 
     private val transactionNames: Map<Int, String> by lazy {
         stubBinderClass.declaredFields
@@ -54,10 +62,42 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
             .associate { field -> (field.get(null) as Int) to field.name.split("_")[1] }
     }
 
+    private const val RESPONSE_KEY_NOT_FOUND = 7
+    private const val RESPONSE_PERMISSION_DENIED = 6
+    private const val KEY_PERMISSION_GET_INFO = 0x4
+    private const val KEY_PERMISSION_UPDATE = 0x80
+
+    // KeyStoreManager.grantKeyAccess() became a public app API in Android 16 (API 36). Before that,
+    // grant was a hidden API and SELinux denied untrusted_app, so a synthetic-key grant must answer
+    // PERMISSION_DENIED pre-36 and a coherent virtualized grant on 36+.
+    private const val GRANT_PUBLIC_API_SDK = 36
+    private val deletedSoftwareKeys: MutableSet<KeyIdentifier> = ConcurrentHashMap.newKeySet()
+    private val userUpdatedKeys = ConcurrentHashMap.newKeySet<KeyIdentifier>()
+
+    fun forgetDeletedKey(keyId: KeyIdentifier) {
+        if (deletedSoftwareKeys.remove(keyId)) {
+            SystemLogger.debug("Cleared deletion marker for ${keyId.alias}")
+        }
+    }
+
     override val serviceName = "android.system.keystore2.IKeystoreService/default"
     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,
+                GET_NUMBER_OF_ENTRIES_TRANSACTION,
+                GRANT_TRANSACTION,
+                UNGRANT_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).
@@ -65,6 +105,30 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
     override fun onInterceptorReady(service: IBinder, backdoor: IBinder) {
         val keystoreInterface = IKeystoreService.Stub.asInterface(service)
         setupSecurityLevelInterceptors(keystoreInterface, backdoor)
+        setupMaintenanceInterceptor(backdoor)
+    }
+
+    /**
+     * Hooks the keystore2 daemon's `android.security.maintenance` binder, which is hosted by the
+     * same process, so synthetic key state follows real key-lifecycle events. Best-effort: if the
+     * service is absent the synthetic plane simply forgoes lifecycle parity.
+     */
+    private fun setupMaintenanceInterceptor(backdoor: IBinder) {
+        runCatching {
+                ServiceManager.getService("android.security.maintenance")?.let { maintenance ->
+                    SystemLogger.info("Found maintenance binder. Registering interceptor...")
+                    register(
+                        backdoor,
+                        maintenance,
+                        Keystore2MaintenanceInterceptor,
+                        Keystore2MaintenanceInterceptor.interceptedCodes,
+                    )
+                }
+                    ?: SystemLogger.warning(
+                        "Maintenance binder not found; skipping lifecycle parity."
+                    )
+            }
+            .onFailure { SystemLogger.error("Failed to intercept maintenance binder.", it) }
     }
 
     private fun setupSecurityLevelInterceptors(service: IKeystoreService, backdoor: IBinder) {
@@ -74,7 +138,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,
+                    )
                     interceptor.loadPersistedKeys()
                 }
             }
@@ -86,7 +155,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,
+                    )
                     interceptor.loadPersistedKeys()
                 }
             }
@@ -102,7 +176,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()
@@ -134,50 +213,209 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         ) {
             logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
 
-            if (ConfigurationManager.shouldSkipUid(callingUid))
+            if (code == UPDATE_SUBCOMPONENT_TRANSACTION) {
-                return TransactionResult.ContinueAndSkipPost
+                if (ConfigurationManager.shouldSkipUid(callingUid))
-
+                    return TransactionResult.ContinueAndSkipPost
-            if (code == UPDATE_SUBCOMPONENT_TRANSACTION)
                 return handleUpdateSubcomponent(callingUid, data)
+            }
 
             data.enforceInterface(IKeystoreService.DESCRIPTOR)
             val descriptor =
                 data.readTypedObject(KeyDescriptor.CREATOR)
                     ?: return TransactionResult.ContinueAndSkipPost
 
-            if (descriptor.alias != null) {
+            // Domain.GRANT read (Android 16+ KeyStoreManager grant). Served for ANY grantee uid —
-                SystemLogger.info("Handling ${transactionNames[code]!!} ${descriptor.alias}")
+            // including isolated services (bindIsolatedService) with no package mapping — so
-            } else {
+            // resolve
-                SystemLogger.info(
+            // it before the package-scoped skip; caller-binding in resolveGrant() is the real
-                    "Skip ${transactionNames[code]!!} for key [alias, blob, domain, nspace]: [${descriptor.alias}, ${descriptor.blob}, ${descriptor.domain}, ${descriptor.nspace}]"
+            // access
-                )
+            // gate. On Android <= 15 no grants are ever issued (grant() denies), so softwareGrants
-                return TransactionResult.ContinueAndSkipPost
+            // is
+            // empty and this falls through to the real keystore2.
+            if (code == GET_KEY_ENTRY_TRANSACTION && descriptor.domain == Domain.GRANT) {
+                val grant =
+                    KeyMintSecurityLevelInterceptor.resolveGrant(descriptor.nspace, callingUid)
+                if (grant == null) {
+                    // Ours but wrong caller -> KEY_NOT_FOUND (caller-binding); not ours -> real
+                    // keystore2.
+                    return if (
+                        KeyMintSecurityLevelInterceptor.softwareGrants.containsKey(
+                            descriptor.nspace
+                        )
+                    )
+                        InterceptorUtils.createErrorReply(RESPONSE_KEY_NOT_FOUND)
+                    else TransactionResult.ContinueAndSkipPost
+                }
+                if ((grant.accessVector and KEY_PERMISSION_GET_INFO) == 0) {
+                    return InterceptorUtils.createErrorReply(RESPONSE_PERMISSION_DENIED)
+                }
+                val response =
+                    KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(grant.ownerKeyId)
+                        ?: return InterceptorUtils.createErrorReply(RESPONSE_KEY_NOT_FOUND)
+                // Same object the owner read returns -> coherent chain across planes.
+                return InterceptorUtils.createTypedObjectReply(response)
             }
-            val keyId = KeyIdentifier(callingUid, descriptor.alias)
+
+            // generateKey force-forges attest/device-id keys even for skipped UIDs; getKeyEntry
+            // must serve them back or the framework's attestKeyAlias lookup gets KEY_NOT_FOUND.
+            if (code != GET_KEY_ENTRY_TRANSACTION && ConfigurationManager.shouldSkipUid(callingUid))
+                return TransactionResult.ContinueAndSkipPost
 
             if (code == DELETE_KEY_TRANSACTION) {
-                if (KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId) != null) {
+                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)
-                    SystemLogger.info(
+                    if (isSoftwareKey) {
-                        "[TX_ID: $txId] Deleted cached keypair ${descriptor.alias}, replying with empty response."
+                        deletedSoftwareKeys.add(keyId)
-                    )
+                        SystemLogger.info(
-                    return InterceptorUtils.createSuccessReply(writeResultCode = false)
+                            "[TX_ID: $txId] Deleted cached keypair ${keyId.alias}, replying with empty response."
+                        )
+                        return InterceptorUtils.createSuccessReply(writeResultCode = false)
+                    }
                 }
                 return TransactionResult.ContinueAndSkipPost
             }
 
-            val response =
+            if (descriptor.alias == null) {
-                KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId)
+                if (descriptor.domain == Domain.KEY_ID) {
-                    ?: return TransactionResult.Continue
+                    // The probe pipeline (and some AOSP callers) switch follow-up
+                    // operations to KEY_ID semantics after generateKey returns a
+                    // KEY_ID descriptor. Without this branch, our software keys
+                    // are invisible to KEY_ID-based getKeyEntry calls and the
+                    // request falls through to the real keystore2 daemon, which
+                    // legitimately responds with KEY_NOT_FOUND. Duck Detector's
+                    // TimingSideChannelProbe captures that exception during its
+                    // warmup phase and surfaces it as
+                    // "Captured private binder exception during timing skip".
+                    // Resolving by KEY_ID and returning the cached response keeps
+                    // the call on the happy path, eliminating the warmup signal.
+                    val info =
+                        KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(
+                            callingUid,
+                            descriptor.nspace,
+                        )
+                    if (info?.response != null) {
+                        SystemLogger.info(
+                            "[TX_ID: $txId] Found generated response via KEY_ID nspace=${descriptor.nspace}"
+                        )
+                        logServedChain(callingUid, txId, "keyid:${descriptor.nspace}", info.response)
+                        return InterceptorUtils.createTypedObjectReply(info.response)
+                    }
+                    val teeResp =
+                        KeyMintSecurityLevelInterceptor.findTeeResponseByKeyId(
+                            callingUid,
+                            descriptor.nspace,
+                        )
+                    if (teeResp != null) {
+                        SystemLogger.info(
+                            "[TX_ID: $txId] Found TEE response via KEY_ID nspace=${descriptor.nspace}"
+                        )
+                        logServedChain(callingUid, txId, "keyid:${descriptor.nspace}", teeResp)
+                        return InterceptorUtils.createTypedObjectReply(teeResp)
+                    }
+                }
+                // Domain.GRANT is handled earlier (before the package-scoped skip); an alias-less
+                // read reaching here is KEY_ID or unknown, so it falls through to the real
+                // keystore2.
+                return TransactionResult.ContinueAndSkipPost
+            }
+            val keyId = KeyIdentifier(callingUid, descriptor.alias)
+
+            val response = KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId)
+            if (response == null) {
+                if (deletedSoftwareKeys.remove(keyId)) {
+                    SystemLogger.info(
+                        "[TX_ID: $txId] Returning KEY_NOT_FOUND for deleted key ${descriptor.alias}"
+                    )
+                    return InterceptorUtils.createErrorReply(RESPONSE_KEY_NOT_FOUND)
+                }
+                // Owned keys were served above; for a skipped UID a non-owned key must still skip
+                // post-processing so we never patch an un-targeted app's real key.
+                return if (ConfigurationManager.shouldSkipUid(callingUid))
+                    TransactionResult.ContinueAndSkipPost
+                else TransactionResult.Continue
+            }
 
             if (KeyMintSecurityLevelInterceptor.isAttestationKey(keyId))
                 SystemLogger.info("${descriptor.alias} was an attestation key")
 
             SystemLogger.info("[TX_ID: $txId] Found generated response for ${descriptor.alias}:")
             response.metadata?.authorizations?.forEach {
-                KeyMintParameterLogger.logParameter(it.keyParameter)
+                KeyMintParameterLogger.logParameter(callingUid, txId, it.keyParameter)
             }
+            logServedChain(callingUid, txId, descriptor.alias, response)
             return InterceptorUtils.createTypedObjectReply(response)
+        } else if (code == GRANT_TRANSACTION) {
+            logTransaction(txId, transactionNames[code] ?: "grant", callingUid, callingPid)
+            data.enforceInterface(IKeystoreService.DESCRIPTOR)
+            val key =
+                data.readTypedObject(KeyDescriptor.CREATOR)
+                    ?: return TransactionResult.ContinueAndSkipPost
+            val granteeUid = data.readInt()
+            val accessVector = data.readInt()
+            // Synthetic (generatedKeys) AND patch-mode (teeResponses) keys are ours; both must
+            // grant
+            // coherently so the Domain.GRANT readback returns the same chain the owner read
+            // returns.
+            // Real hardware keys fall through to the real keystore2, which applies the same SELinux
+            // gate the platform would.
+            val ownerKeyId =
+                resolveOwnerKeyId(key, callingUid)?.takeIf {
+                    KeyMintSecurityLevelInterceptor.ownsKeyResponse(it)
+                } ?: return TransactionResult.ContinueAndSkipPost
+            // Version-gated to mirror the real TEE 1:1. Pre-Android-16, grant was a hidden API and
+            // SELinux denied untrusted_app, so keystore2 returns PERMISSION_DENIED. Android 16
+            // (API 36) exposes KeyStoreManager.grantKeyAccess(), so an app grants its own key:
+            // issue a coherent, caller-bound, access-vector-carrying grant whose Domain.GRANT read
+            // returns the owner's chain.
+            if (Build.VERSION.SDK_INT < GRANT_PUBLIC_API_SDK) {
+                return InterceptorUtils.createErrorReply(RESPONSE_PERMISSION_DENIED)
+            }
+            val grantId =
+                KeyMintSecurityLevelInterceptor.issueGrant(ownerKeyId, granteeUid, accessVector)
+            val reply =
+                KeyDescriptor().apply {
+                    domain = Domain.GRANT
+                    nspace = grantId
+                    alias = null
+                    blob = null
+                }
+            return InterceptorUtils.createTypedObjectReply(reply)
+        } else if (code == UNGRANT_TRANSACTION) {
+            logTransaction(txId, transactionNames[code] ?: "ungrant", callingUid, callingPid)
+            data.enforceInterface(IKeystoreService.DESCRIPTOR)
+            val key =
+                data.readTypedObject(KeyDescriptor.CREATOR)
+                    ?: return TransactionResult.ContinueAndSkipPost
+            val granteeUid = data.readInt()
+            val ownerKeyId =
+                resolveOwnerKeyId(key, callingUid)?.takeIf {
+                    KeyMintSecurityLevelInterceptor.ownsKeyResponse(it)
+                } ?: return TransactionResult.ContinueAndSkipPost
+            // Same version gate as grant(): denied pre-36, revoke the virtualized grant on 36+.
+            if (Build.VERSION.SDK_INT < GRANT_PUBLIC_API_SDK) {
+                return InterceptorUtils.createErrorReply(RESPONSE_PERMISSION_DENIED)
+            }
+            KeyMintSecurityLevelInterceptor.revokeGrant(ownerKeyId, granteeUid)
+            return InterceptorUtils.createSuccessReply(writeResultCode = false)
         } else {
             logTransaction(
                 txId,
@@ -203,10 +441,34 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         reply: Parcel?,
         resultCode: Int,
     ): TransactionResult {
-        if (target != keystoreService || reply == null || InterceptorUtils.hasException(reply))
+        if (target != keystoreService || reply == null) return TransactionResult.SkipTransaction
-            return TransactionResult.SkipTransaction
+        if (InterceptorUtils.hasException(reply)) {
+            val normalized = InterceptorUtils.normalizeServiceSpecificReply(reply)
+            return if (normalized != null) TransactionResult.OverrideReply(normalized)
+            else 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 {
@@ -241,23 +503,63 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                     val response = reply.readTypedObject(KeyEntryResponse.CREATOR)!!
                     val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
 
+                    if (userUpdatedKeys.remove(keyId)) {
+                        SystemLogger.trace {
+                            "[TRACE-$txId] getKeyEntry $keyId: userUpdated=true, skipping patch"
+                        }
+                        SystemLogger.debug(
+                            "[TX_ID: $txId] Skipping cert patch for user-updated key $keyId."
+                        )
+                        return TransactionResult.SkipTransaction
+                    }
+
                     val authorizations = response.metadata.authorizations
                     val parsedParameters =
                         KeyMintAttestation(
                             authorizations?.map { it.keyParameter }?.toTypedArray() ?: emptyArray()
                         )
 
+                    SystemLogger.trace {
+                        "[TRACE-$txId] getKeyEntry $keyId: isImport=${parsedParameters.isImportKey()} origin=${parsedParameters.origin} inImportedKeys=${KeyMintSecurityLevelInterceptor.importedKeys.contains(keyId)} hasPatchedChain=${KeyMintSecurityLevelInterceptor.getPatchedChain(keyId) != null} isAttestKey=${parsedParameters.isAttestKey()}"
+                    }
+
                     if (parsedParameters.isImportKey()) {
                         val retainedChain = KeyMintSecurityLevelInterceptor.getPatchedChain(keyId)
                         if (retainedChain == null) {
-                            SystemLogger.info("[TX_ID: $txId] Skip patching for imported key (no prior attestation).")
+                            SystemLogger.trace {
+                                "[TRACE-$txId] getKeyEntry $keyId: imported, no retained chain, skip"
+                            }
+                            SystemLogger.info(
+                                "[TX_ID: $txId] Skip patching for imported key (no prior attestation)."
+                            )
                             return TransactionResult.SkipTransaction
                         }
-                        SystemLogger.info("[TX_ID: $txId] Imported key overwrote attested alias, serving retained chain for $keyId")
+                        SystemLogger.trace {
-                        CertificateHelper.updateCertificateChain(response.metadata, retainedChain).getOrThrow()
+                            "[TRACE-$txId] getKeyEntry $keyId: imported, SERVING RETAINED CHAIN (detection vector!)"
+                        }
+                        SystemLogger.info(
+                            "[TX_ID: $txId] Imported key overwrote attested alias, serving retained chain for $keyId"
+                        )
+                        CertificateHelper.updateCertificateChain(response.metadata, retainedChain)
+                            .getOrThrow()
+                        response.metadata.authorizations =
+                            InterceptorUtils.patchAuthorizations(
+                                response.metadata.authorizations,
+                                callingUid,
+                            )
                         return InterceptorUtils.createTypedObjectReply(response)
                     }
 
+                    if (KeyMintSecurityLevelInterceptor.importedKeys.contains(keyId)) {
+                        SystemLogger.trace {
+                            "[TRACE-$txId] getKeyEntry $keyId: in importedKeys set, skip"
+                        }
+                        SystemLogger.debug(
+                            "[TX_ID: $txId] Skipping attest-key override for imported key $keyId"
+                        )
+                        return TransactionResult.SkipTransaction
+                    }
+
                     if (parsedParameters.isAttestKey()) {
                         SystemLogger.warning(
                             "[TX_ID: $txId] Found hardware attest key ${keyId.alias} in the reply."
@@ -276,28 +578,54 @@ 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,
+                                null,
+                                newNspace,
                                 response,
+                                parsedParameters,
                             )
                         KeyMintSecurityLevelInterceptor.attestationKeys.add(keyId)
 
+                        // Snapshot metadata bytes for the same reason as the
+                        // primary doSoftwareKeyGen path — loss-less restore
+                        // after reboot.
+                        val metadataBytesForPersist =
+                            response.metadata?.let { md ->
+                                runCatching {
+                                        val parcel = android.os.Parcel.obtain()
+                                        try {
+                                            md.writeToParcel(parcel, 0)
+                                            parcel.marshall()
+                                        } finally {
+                                            parcel.recycle()
+                                        }
+                                    }
+                                    .getOrNull()
+                            }
                         GeneratedKeyPersistence.save(
                             keyId = keyId,
                             keyPair = keyData.first,
-                            nspace = keyDescriptor.nspace,
+                            secretKey = null,
+                            nspace = newNspace,
                             securityLevel = response.metadata.keySecurityLevel,
                             certChain = keyData.second,
                             algorithm = parsedParameters.algorithm,
                             keySize = parsedParameters.keySize,
-                            ecCurve = parsedParameters.ecCurve,
+                            ecCurve = parsedParameters.ecCurve ?: 0,
                             purposes = parsedParameters.purpose,
                             digests = parsedParameters.digest,
                             isAttestationKey = true,
+                            metadataBytes = metadataBytesForPersist,
                         )
 
                         return InterceptorUtils.createTypedObjectReply(response)
@@ -326,10 +654,20 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                         )
                         finalChain =
                             AttestationPatcher.patchCertificateChain(originalChain, callingUid)
+                        KeyMintSecurityLevelInterceptor.patchedChains[keyId] = finalChain
                     }
 
                     CertificateHelper.updateCertificateChain(response.metadata, finalChain)
                         .getOrThrow()
+                    response.metadata.authorizations =
+                        InterceptorUtils.patchAuthorizations(
+                            response.metadata.authorizations,
+                            callingUid,
+                        )
+
+                    // PATCH decode point: the patched chain actually served back to the app on
+                    // getKeyEntry — the ground truth a patch-mode detector reads.
+                    AttestationDossier.log(callingUid, txId, "PATCH", finalChain.asList())
 
                     return InterceptorUtils.createTypedObjectReply(response)
                 }
@@ -344,22 +682,152 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
         return TransactionResult.SkipTransaction
     }
 
+    /**
+     * Resolves the owner [KeyIdentifier] a grant/ungrant call targets. APP/alias keys map directly;
+     * KEY_ID keys are looked up by nspace (mirrors the deleteKey resolver). Returns null for
+     * anything not addressable, so callers fall through to the real keystore2.
+     */
+    private fun resolveOwnerKeyId(descriptor: KeyDescriptor, callingUid: Int): KeyIdentifier? =
+        when {
+            descriptor.alias != null -> KeyIdentifier(callingUid, descriptor.alias)
+            descriptor.domain == Domain.KEY_ID ->
+                KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(
+                        callingUid,
+                        descriptor.nspace,
+                    )
+                    ?.let { info ->
+                        KeyMintSecurityLevelInterceptor.generatedKeys.entries
+                            .firstOrNull {
+                                it.value.nspace == info.nspace && it.key.uid == callingUid
+                            }
+                            ?.key
+                    }
+            else -> null
+        }
+
+    /**
+     * Records the certificate chain actually served back to [uid] on a getKeyEntry, keyed by
+     * [alias]. The app reassembles its final chain from these served chains (the leaf alias plus
+     * the attest-key alias), so logging each one with key sizes and a per-edge verification makes a
+     * verification failure in the app's combined chain reproducible from the log, not inferred.
+     */
+    private fun logServedChain(uid: Int, txId: Long, alias: String, response: KeyEntryResponse?) {
+        if (response == null || !SystemLogger.isUidLogged(uid)) return
+        val chain = CertificateHelper.getCertificateChain(response)?.asList() ?: return
+        SystemLogger.uidLog(uid, txId, "served", "alias=$alias depth=${chain.size}")
+        SystemLogger.uidLog(uid, txId, "served-keys", AttestationPatcher.formatChainKeys(chain))
+        SystemLogger.uidLog(uid, txId, "served-verify", AttestationPatcher.formatChainVerification(chain))
+    }
+
     private fun handleUpdateSubcomponent(callingUid: Int, data: Parcel): TransactionResult {
         data.enforceInterface(IKeystoreService.DESCRIPTOR)
-        val descriptor = data.readTypedObject(KeyDescriptor.CREATOR)
+        val descriptor =
-        val generatedKeyInfo =
+            data.readTypedObject(KeyDescriptor.CREATOR)
-            KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(callingUid, descriptor?.nspace)
                 ?: return TransactionResult.ContinueAndSkipPost
 
-        SystemLogger.info("Updating sub-component with key[${generatedKeyInfo.nspace}]")
+        if (descriptor.domain == Domain.GRANT) {
-        val metadata = generatedKeyInfo.response.metadata
+            val grant =
-        val publicCert = data.createByteArray()
+                KeyMintSecurityLevelInterceptor.resolveGrant(descriptor.nspace, callingUid)
-        val certificateChain = data.createByteArray()
+            if (grant == null) {
+                return if (
+                    KeyMintSecurityLevelInterceptor.softwareGrants.containsKey(descriptor.nspace)
+                )
+                    InterceptorUtils.createErrorReply(RESPONSE_KEY_NOT_FOUND)
+                else TransactionResult.ContinueAndSkipPost
+            }
+            if ((grant.accessVector and KEY_PERMISSION_UPDATE) == 0) {
+                return InterceptorUtils.createErrorReply(RESPONSE_PERMISSION_DENIED)
+            }
 
+            val generatedKeyInfo =
+                KeyMintSecurityLevelInterceptor.generatedKeys[grant.ownerKeyId]
+            val response =
+                generatedKeyInfo?.response
+                    ?: KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(grant.ownerKeyId)
+                    ?: return InterceptorUtils.createErrorReply(RESPONSE_KEY_NOT_FOUND)
+            return updateResponseSubcomponent(
+                response = response,
+                publicCert = data.createByteArray(),
+                certificateChain = data.createByteArray(),
+                persist = {
+                    if (generatedKeyInfo != null) {
+                        GeneratedKeyPersistence.rePersistIfNeeded(
+                            grant.ownerKeyId.uid,
+                            generatedKeyInfo,
+                        )
+                    }
+                },
+                label = "grant[${descriptor.nspace}] -> ${grant.ownerKeyId}",
+            )
+        }
+
+        val generatedKeyInfo =
+            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) {
+            // Patch-mode key (cached in teeResponses, not generatedKeys): the real keystore2
+            // applies
+            // the update, so drop our stale cached chain. Otherwise getKeyEntry replays the
+            // pre-update generated attestation (duck STALE_TEE_RESPONSE_AFTER_KEY_ID_UPDATE).
+            when (descriptor.domain) {
+                Domain.KEY_ID ->
+                    KeyMintSecurityLevelInterceptor.evictTeeResponseByKeyId(
+                        callingUid,
+                        descriptor.nspace,
+                    )
+                Domain.APP ->
+                    descriptor.alias?.let {
+                        KeyMintSecurityLevelInterceptor.evictTeeResponse(
+                            KeyIdentifier(callingUid, it)
+                        )
+                    }
+                else -> {}
+            }
+            descriptor.alias?.let {
+                val kid = KeyIdentifier(callingUid, it)
+                userUpdatedKeys.add(kid)
+                SystemLogger.trace {
+                    "[TRACE] updateSubcomponent $kid: not generated key, added to userUpdatedKeys"
+                }
+            }
+            return TransactionResult.ContinueAndSkipPost
+        }
+
+        return updateResponseSubcomponent(
+            response = generatedKeyInfo.response,
+            publicCert = data.createByteArray(),
+            certificateChain = data.createByteArray(),
+            persist = {
+                GeneratedKeyPersistence.rePersistIfNeeded(callingUid, generatedKeyInfo)
+            },
+            label = "key[${generatedKeyInfo.nspace}]",
+        )
+    }
+
+    private fun updateResponseSubcomponent(
+        response: KeyEntryResponse,
+        publicCert: ByteArray?,
+        certificateChain: ByteArray?,
+        persist: () -> Unit,
+        label: String,
+    ): TransactionResult {
+        SystemLogger.info("Updating sub-component with $label")
+        val metadata = response.metadata
         metadata.certificate = publicCert
         metadata.certificateChain = certificateChain
 
-        GeneratedKeyPersistence.rePersistIfNeeded(callingUid, generatedKeyInfo)
+        persist()
 
         SystemLogger.verbose(
             "Key updated with sizes: [publicCert, certificateChain] = [${publicCert?.size}, ${certificateChain?.size}]"

app/src/main/java/org/matrix/TEESimulator/interception/keystore/Keystore2MaintenanceInterceptor.kt

@@ -0,0 +1,113 @@
+package org.matrix.TEESimulator.interception.keystore
+
+import android.os.IBinder
+import android.os.Parcel
+import android.security.maintenance.IKeystoreMaintenance
+import android.system.keystore2.Domain
+import android.system.keystore2.KeyDescriptor
+import org.matrix.TEESimulator.interception.core.BinderInterceptor
+import org.matrix.TEESimulator.interception.keystore.shim.KeyMintSecurityLevelInterceptor
+
+/**
+ * Intercepts the keystore2 daemon's `android.security.maintenance` binder so our synthetic key
+ * state follows the same lifecycle events the platform applies to real keys.
+ *
+ * This is a pure side-effect hook: every handled transaction mutates only our own synthetic state
+ * and then returns [TransactionResult.ContinueAndSkipPost], so the real keystore2 still performs
+ * the real operation. We never fabricate a maintenance reply, so real key lifecycle is never
+ * disturbed.
+ *
+ * Mounted via `register()` from [Keystore2Interceptor.onInterceptorReady]; the maintenance binder
+ * is hosted by the same keystore2 process, so the already-injected native hook reaches it too.
+ */
+object Keystore2MaintenanceInterceptor : BinderInterceptor() {
+    private val stubClass = IKeystoreMaintenance.Stub::class.java
+
+    private val CLEAR_NAMESPACE_TRANSACTION =
+        InterceptorUtils.getTransactCode(stubClass, "clearNamespace")
+    private val DELETE_ALL_KEYS_TRANSACTION =
+        InterceptorUtils.getTransactCode(stubClass, "deleteAllKeys")
+    private val MIGRATE_KEY_NAMESPACE_TRANSACTION =
+        InterceptorUtils.getTransactCode(stubClass, "migrateKeyNamespace")
+
+    /** Only the lifecycle transactions we mirror; unresolved codes (-1) are dropped. */
+    val interceptedCodes: IntArray by lazy {
+        listOf(
+                CLEAR_NAMESPACE_TRANSACTION,
+                DELETE_ALL_KEYS_TRANSACTION,
+                MIGRATE_KEY_NAMESPACE_TRANSACTION,
+            )
+            .filter { it != -1 }
+            .toIntArray()
+    }
+
+    override fun onPreTransact(
+        txId: Long,
+        target: IBinder,
+        code: Int,
+        flags: Int,
+        callingUid: Int,
+        callingPid: Int,
+        data: Parcel,
+    ): TransactionResult {
+        when (code) {
+            CLEAR_NAMESPACE_TRANSACTION -> handleClearNamespace(data)
+            DELETE_ALL_KEYS_TRANSACTION ->
+                KeyMintSecurityLevelInterceptor.clearAllGeneratedKeys("maintenance.deleteAllKeys")
+            MIGRATE_KEY_NAMESPACE_TRANSACTION -> handleMigrateKeyNamespace(data, callingUid)
+        }
+        // Always let the real keystore2 perform the real lifecycle operation.
+        return TransactionResult.ContinueAndSkipPost
+    }
+
+    private fun handleClearNamespace(data: Parcel) {
+        data.enforceInterface(IKeystoreMaintenance.DESCRIPTOR)
+        val domain = data.readInt()
+        val nspace = data.readLong()
+        // Only Domain.APP namespaces map to our per-uid synthetic keys; nspace is the app uid.
+        if (domain == Domain.APP) {
+            KeyMintSecurityLevelInterceptor.clearNamespaceKeys(nspace.toInt())
+        }
+    }
+
+    private fun handleMigrateKeyNamespace(data: Parcel, callingUid: Int) {
+        data.enforceInterface(IKeystoreMaintenance.DESCRIPTOR)
+        val source = data.readTypedObject(KeyDescriptor.CREATOR) ?: return
+        val destination = data.readTypedObject(KeyDescriptor.CREATOR) ?: return
+        val srcId = resolveSyntheticKeyId(source, callingUid) ?: return
+        if (!KeyMintSecurityLevelInterceptor.generatedKeys.containsKey(srcId)) return // not ours
+
+        val dstId = resolveDestinationKeyId(destination, callingUid)
+        if (dstId == null) {
+            // Migrated out of our trackable (Domain.APP/alias) space -> drop our shadow so reads
+            // fall through to the real keystore2, which now owns it at the new namespace.
+            KeyMintSecurityLevelInterceptor.cleanupKeyData(srcId)
+        } else {
+            KeyMintSecurityLevelInterceptor.migrateGeneratedKey(srcId, dstId)
+        }
+    }
+
+    /** Resolves a synthetic owner key from a source descriptor (Domain.APP alias or KEY_ID). */
+    private fun resolveSyntheticKeyId(descriptor: KeyDescriptor, callingUid: Int): KeyIdentifier? =
+        when {
+            descriptor.alias != null -> KeyIdentifier(callingUid, descriptor.alias)
+            descriptor.domain == Domain.KEY_ID ->
+                KeyMintSecurityLevelInterceptor.generatedKeys.entries
+                    .firstOrNull {
+                        it.key.uid == callingUid && it.value.nspace == descriptor.nspace
+                    }
+                    ?.key
+            else -> null
+        }
+
+    /** Destination must be an addressable Domain.APP alias for us to keep tracking the key. */
+    private fun resolveDestinationKeyId(
+        descriptor: KeyDescriptor,
+        callingUid: Int,
+    ): KeyIdentifier? {
+        val alias = descriptor.alias ?: return null
+        if (descriptor.domain != Domain.APP) return null
+        val uid = if (descriptor.nspace > 0) descriptor.nspace.toInt() else callingUid
+        return KeyIdentifier(uid, alias)
+    }
+}

app/src/main/java/org/matrix/TEESimulator/interception/keystore/KeystoreInterceptor.kt

@@ -431,6 +431,24 @@ private data class LegacyKeygenParameters(
             manufacturer = null,
             model = null,
             secondImei = null,
+            activeDateTime = null,
+            originationExpireDateTime = null,
+            usageExpireDateTime = null,
+            usageCountLimit = null,
+            callerNonce = null,
+            nonce = null,
+            unlockedDeviceRequired = null,
+            includeUniqueId = null,
+            rollbackResistance = null,
+            earlyBootOnly = null,
+            allowWhileOnBody = null,
+            trustedUserPresenceRequired = null,
+            trustedConfirmationRequired = null,
+            noAuthRequired = null,
+            maxUsesPerBoot = null,
+            maxBootLevel = null,
+            minMacLength = null,
+            rsaOaepMgfDigest = emptyList(),
         )
     }
 

app/src/main/java/org/matrix/TEESimulator/interception/keystore/ListEntriesHandler.kt

@@ -129,7 +129,7 @@ object ListEntriesHandler {
         startPastAlias: String?,
     ): List<KeyDescriptor> {
         return KeyMintSecurityLevelInterceptor.generatedKeys.keys
-            .filter { it.uid == uid && (startPastAlias == null || it.alias < startPastAlias) }
+            .filter { it.uid == uid && (startPastAlias == null || it.alias > startPastAlias) }
             .map { keyId ->
                 KeyDescriptor().apply {
                     this.domain = Domain.APP

app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/AuthorizeCreate.kt

@@ -0,0 +1,120 @@
+package org.matrix.TEESimulator.interception.keystore.shim
+
+import android.hardware.security.keymint.Algorithm
+import android.hardware.security.keymint.BlockMode
+import android.hardware.security.keymint.KeyParameter
+import android.hardware.security.keymint.KeyPurpose
+import android.hardware.security.keymint.PaddingMode
+import android.hardware.security.keymint.Tag
+import org.matrix.TEESimulator.attestation.KeyMintAttestation
+
+object AuthorizeCreate {
+
+    fun check(
+        keyParams: KeyMintAttestation?,
+        opParams: KeyMintAttestation,
+        rawOpParams: Array<KeyParameter>? = null,
+    ): Int? {
+        if (keyParams == null) return null
+        val purpose = opParams.purpose.firstOrNull() ?: return null
+        // Algorithm-level rejection runs before purpose-list check (AOSP HAL behavior)
+        return checkAlgorithmPurpose(keyParams, purpose)
+            ?: checkPurpose(keyParams, purpose)
+            ?: checkOperationAuthorizations(keyParams, opParams)
+            ?: checkTemporalValidity(keyParams, purpose)
+            ?: checkCallerNonce(keyParams, purpose, rawOpParams)
+    }
+
+    private fun checkAlgorithmPurpose(keyParams: KeyMintAttestation, purpose: Int): Int? {
+        val algo = keyParams.algorithm
+        if (
+            (algo == Algorithm.EC || algo == Algorithm.RSA) &&
+                (purpose == KeyPurpose.VERIFY || purpose == KeyPurpose.ENCRYPT)
+        ) {
+            return KeystoreErrorCodes.unsupportedPurpose
+        }
+        if (algo == Algorithm.RSA && purpose == KeyPurpose.AGREE_KEY)
+            return KeystoreErrorCodes.unsupportedPurpose
+        return null
+    }
+
+    private fun checkPurpose(keyParams: KeyMintAttestation, purpose: Int): Int? {
+        if (purpose == KeyPurpose.WRAP_KEY) return KeystoreErrorCodes.incompatiblePurpose
+        if (purpose !in keyParams.purpose) return KeystoreErrorCodes.incompatiblePurpose
+        return null
+    }
+
+    private fun checkOperationAuthorizations(
+        keyParams: KeyMintAttestation,
+        opParams: KeyMintAttestation,
+    ): Int? {
+        if (opParams.blockMode.any { it !in keyParams.blockMode }) {
+            return KeystoreErrorCodes.incompatibleBlockMode
+        }
+        if (opParams.padding.any { it !in keyParams.padding }) {
+            return KeystoreErrorCodes.incompatiblePaddingMode
+        }
+        if (opParams.digest.any { it !in keyParams.digest }) {
+            return KeystoreErrorCodes.incompatibleDigest
+        }
+        if (opParams.rsaOaepMgfDigest.any { it !in keyParams.rsaOaepMgfDigest }) {
+            return KeystoreErrorCodes.incompatibleDigest
+        }
+
+        if (keyParams.algorithm == Algorithm.AES && opParams.blockMode.contains(BlockMode.GCM)) {
+            val requestedMacLength = opParams.minMacLength
+            val keyMinMacLength = keyParams.minMacLength
+            if (
+                requestedMacLength != null &&
+                    keyMinMacLength != null &&
+                    requestedMacLength < keyMinMacLength
+            ) {
+                return KeystoreErrorCodes.invalidMacLength
+            }
+        }
+
+        if (
+            keyParams.algorithm == Algorithm.RSA &&
+                opParams.padding.contains(PaddingMode.RSA_OAEP) &&
+                opParams.digest.isEmpty()
+        ) {
+            return KeystoreErrorCodes.incompatibleDigest
+        }
+
+        return null
+    }
+
+    private fun checkTemporalValidity(keyParams: KeyMintAttestation, purpose: Int): Int? {
+        val now = System.currentTimeMillis()
+
+        keyParams.activeDateTime?.let { activeDate ->
+            if (now < activeDate.time) return KeystoreErrorCodes.keyNotYetValid
+        }
+
+        keyParams.originationExpireDateTime?.let { expireDate ->
+            if (purpose == KeyPurpose.SIGN || purpose == KeyPurpose.ENCRYPT) {
+                if (now > expireDate.time) return KeystoreErrorCodes.keyExpired
+            }
+        }
+
+        keyParams.usageExpireDateTime?.let { expireDate ->
+            if (purpose == KeyPurpose.VERIFY || purpose == KeyPurpose.DECRYPT) {
+                if (now > expireDate.time) return KeystoreErrorCodes.keyExpired
+            }
+        }
+
+        return null
+    }
+
+    private fun checkCallerNonce(
+        keyParams: KeyMintAttestation,
+        purpose: Int,
+        rawOpParams: Array<KeyParameter>?,
+    ): Int? {
+        if (purpose != KeyPurpose.SIGN && purpose != KeyPurpose.ENCRYPT) return null
+        if (keyParams.callerNonce == true) return null
+        if (rawOpParams?.any { it.tag == Tag.NONCE } == true)
+            return KeystoreErrorCodes.callerNonceProhibited
+        return null
+    }
+}

app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/GeneratedKeyPersistence.kt

@@ -29,13 +29,40 @@ data class PersistedKeyData(
     val ecCurve: Int,
     val purposes: List<Int>,
     val digests: List<Int>,
+    /** PKCS#8-encoded private key for asymmetric records, empty for symmetric. */
     val privateKeyBytes: ByteArray,
     val certChainBytes: List<ByteArray>,
+    /**
+     * Byte-identical KeyMetadata parcel snapshot. Restoring authorizations directly from these
+     * bytes preserves tag count, order, and exact security-level annotations across reboots — the
+     * kind of structural details apps fingerprint to decide whether the alias is still "the same
+     * key".
+     */
+    val metadataBytes: ByteArray,
+    /**
+     * Raw secret material for symmetric records (AES, HMAC, 3DES). Empty for asymmetric. Critical
+     * for AndroidX security crypto MasterKey (AES-GCM-256) — without this every reboot regenerates
+     * a fresh AES key and EncryptedSharedPreferences becomes undecryptable, which is what banking
+     * apps interpret as session expiry and force a relogin.
+     */
+    val symmetricKeyBytes: ByteArray,
+    val symmetricAlgorithm: String,
 )
 
 object GeneratedKeyPersistence {
 
-    private const val FORMAT_VERSION = 1
+    /**
+     * Single source of truth for the on-disk format. Bump this every time the layout changes; older
+     * numbers are silently skipped on read so stale dev artifacts and pre-fix upstream files can't
+     * be partially rehydrated into broken in-memory state.
+     *
+     * History: 1 — original upstream layout (no metadata snapshot, no symmetric block; restored
+     * keys lose authorization tags and AES master keys altogether — apps relying on persisted
+     * keystore state across reboots get logged out) 2 — transitional dev-only format that added
+     * metadata but still missed the symmetric block; never shipped 3 — current: byte-identical
+     * KeyMetadata snapshot + raw symmetric key material so AES/HMAC keys survive reboots
+     */
+    private const val FORMAT_VERSION = 3
     private val PERSISTENCE_DIR = File(CONFIG_PATH, "persistent_keys")
 
     // Per-filename locks to prevent concurrent writes to the same key file
@@ -47,7 +74,8 @@ object GeneratedKeyPersistence {
 
     fun save(
         keyId: KeyIdentifier,
-        keyPair: KeyPair,
+        keyPair: KeyPair?,
+        secretKey: javax.crypto.SecretKey?,
         nspace: Long,
         securityLevel: Int,
         certChain: List<Certificate>,
@@ -57,7 +85,11 @@ object GeneratedKeyPersistence {
         purposes: List<Int>,
         digests: List<Int>,
         isAttestationKey: Boolean,
+        metadataBytes: ByteArray? = null,
     ) {
+        require(keyPair != null || secretKey != null) {
+            "Either keyPair or secretKey must be provided"
+        }
         val filename = keyFileName(keyId.uid, keyId.alias)
         val lock = getLockForKey(filename)
         SystemLogger.debug("[Persistence] Acquiring lock for $filename")
@@ -65,59 +97,80 @@ object GeneratedKeyPersistence {
         try {
             SystemLogger.debug("[Persistence] Lock acquired for $filename")
             runCatching {
-                PERSISTENCE_DIR.mkdirs()
+                    PERSISTENCE_DIR.mkdirs()
-                val finalFile = File(PERSISTENCE_DIR, filename)
+                    val finalFile = File(PERSISTENCE_DIR, filename)
-                val tmpFile = File(PERSISTENCE_DIR, "$filename.tmp")
+                    val tmpFile = File(PERSISTENCE_DIR, "$filename.tmp")
 
-                try {
+                    try {
-                    DataOutputStream(BufferedOutputStream(FileOutputStream(tmpFile))).use { out ->
+                        DataOutputStream(BufferedOutputStream(FileOutputStream(tmpFile))).use { out
-                        out.writeInt(FORMAT_VERSION)
+                            ->
-                        out.writeInt(securityLevel)
+                            out.writeInt(FORMAT_VERSION)
-                        out.writeInt(keyId.uid)
+                            out.writeInt(securityLevel)
-                        out.writeUTF(keyId.alias)
+                            out.writeInt(keyId.uid)
-                        out.writeLong(nspace)
+                            out.writeUTF(keyId.alias)
-                        out.writeBoolean(isAttestationKey)
+                            out.writeLong(nspace)
-                        out.writeInt(algorithm)
+                            out.writeBoolean(isAttestationKey)
-                        out.writeInt(keySize)
+                            out.writeInt(algorithm)
-                        out.writeInt(ecCurve)
+                            out.writeInt(keySize)
+                            out.writeInt(ecCurve)
 
-                        out.writeInt(purposes.size)
+                            out.writeInt(purposes.size)
-                        purposes.forEach { out.writeInt(it) }
+                            purposes.forEach { out.writeInt(it) }
 
-                        out.writeInt(digests.size)
+                            out.writeInt(digests.size)
-                        digests.forEach { out.writeInt(it) }
+                            digests.forEach { out.writeInt(it) }
 
-                        val pkBytes = keyPair.private.encoded
+                            // Asymmetric key block (empty for symmetric-only).
-                        out.writeInt(pkBytes.size)
+                            val pkBytes = keyPair?.private?.encoded ?: ByteArray(0)
-                        out.write(pkBytes)
+                            out.writeInt(pkBytes.size)
+                            out.write(pkBytes)
 
-                        out.writeInt(certChain.size)
+                            out.writeInt(certChain.size)
-                        certChain.forEach { cert ->
+                            certChain.forEach { cert ->
-                            val encoded = cert.encoded
+                                val encoded = cert.encoded
-                            out.writeInt(encoded.size)
+                                out.writeInt(encoded.size)
-                            out.write(encoded)
+                                out.write(encoded)
+                            }
+
+                            // Metadata snapshot (always present, may be empty
+                            // if the live KeyMetadata could not be marshalled).
+                            val mdBytes = metadataBytes ?: ByteArray(0)
+                            out.writeInt(mdBytes.size)
+                            if (mdBytes.isNotEmpty()) out.write(mdBytes)
+
+                            // Symmetric key block (empty for asymmetric keys).
+                            if (secretKey != null) {
+                                val skBytes = secretKey.encoded
+                                out.writeUTF(secretKey.algorithm)
+                                out.writeInt(skBytes.size)
+                                out.write(skBytes)
+                            } else {
+                                out.writeUTF("")
+                                out.writeInt(0)
+                            }
                         }
+                    } catch (e: Exception) {
+                        tmpFile.delete()
+                        throw e
                     }
-                } catch (e: Exception) {
-                    tmpFile.delete()
-                    throw e
-                }
 
-                // Atomic rename — if this fails the tmp is left behind and cleaned on next deleteAll
+                    // Atomic rename — if this fails the tmp is left behind and cleaned on next
-                if (!tmpFile.renameTo(finalFile)) {
+                    // deleteAll
-                    tmpFile.delete()
+                    if (!tmpFile.renameTo(finalFile)) {
-                    throw IllegalStateException("Failed to atomically rename $tmpFile -> $finalFile")
+                        tmpFile.delete()
-                }
+                        throw IllegalStateException(
+                            "Failed to atomically rename $tmpFile -> $finalFile"
+                        )
+                    }
 
-                // Verify write succeeded - catches disk-full or filesystem errors
+                    // Verify write succeeded - catches disk-full or filesystem errors
-                if (!finalFile.exists() || finalFile.length() < 20) {
+                    if (!finalFile.exists() || finalFile.length() < 20) {
-                    throw IOException("File write verification failed - possible disk full")
+                        throw IOException("File write verification failed - possible disk full")
-                }
+                    }
 
-                SystemLogger.debug("Persisted key: $keyId")
+                    SystemLogger.debug("Persisted key: $keyId")
-            }.onFailure { e ->
+                }
-                SystemLogger.error("Failed to persist key $keyId", e)
+                .onFailure { e -> SystemLogger.error("Failed to persist key $keyId", e) }
-            }
         } finally {
             lock.unlock()
             SystemLogger.debug("[Persistence] Lock released for $filename")
@@ -126,42 +179,42 @@ object GeneratedKeyPersistence {
 
     fun delete(keyId: KeyIdentifier) {
         runCatching {
-            val file = File(PERSISTENCE_DIR, keyFileName(keyId.uid, keyId.alias))
+                val file = File(PERSISTENCE_DIR, keyFileName(keyId.uid, keyId.alias))
-            if (file.exists()) {
+                if (file.exists()) {
-                if (file.delete()) {
+                    if (file.delete()) {
-                    SystemLogger.debug("Deleted persisted key: $keyId")
+                        fileLocks.remove(keyFileName(keyId.uid, keyId.alias))
+                        SystemLogger.debug("Deleted persisted key: $keyId")
+                    } else {
+                        SystemLogger.warning("Failed to delete persisted key file: ${file.name}")
+                    }
                 } else {
-                    SystemLogger.warning("Failed to delete persisted key file: ${file.name}")
+                    SystemLogger.debug("No persisted file to delete for: $keyId")
                 }
-            } else {
-                SystemLogger.debug("No persisted file to delete for: $keyId")
             }
-        }.onFailure { e ->
+            .onFailure { e -> SystemLogger.error("Failed to delete persisted key $keyId", e) }
-            SystemLogger.error("Failed to delete persisted key $keyId", e)
-        }
     }
 
     fun deleteAll() {
         runCatching {
-            if (!PERSISTENCE_DIR.exists()) {
+                if (!PERSISTENCE_DIR.exists()) {
-                SystemLogger.debug("No persistent_keys directory, nothing to delete")
+                    SystemLogger.debug("No persistent_keys directory, nothing to delete")
-                return
+                    return
-            }
-            val files = PERSISTENCE_DIR.listFiles()
-            if (files == null) {
-                SystemLogger.warning("Cannot list persistent_keys directory")
-                return
-            }
-            var count = 0
-            files.forEach { file ->
-                if (file.name.endsWith(".bin") || file.name.endsWith(".tmp")) {
-                    if (file.delete()) count++
                 }
+                val files = PERSISTENCE_DIR.listFiles()
+                if (files == null) {
+                    SystemLogger.warning("Cannot list persistent_keys directory")
+                    return
+                }
+                var count = 0
+                files.forEach { file ->
+                    if (file.name.endsWith(".bin") || file.name.endsWith(".tmp")) {
+                        if (file.delete()) count++
+                    }
+                }
+                fileLocks.clear()
+                SystemLogger.info("Deleted $count persisted key files")
             }
-            SystemLogger.info("Deleted $count persisted key files")
+            .onFailure { e -> SystemLogger.error("Failed to delete all persisted keys", e) }
-        }.onFailure { e ->
-            SystemLogger.error("Failed to delete all persisted keys", e)
-        }
     }
 
     fun loadAll(securityLevel: Int): List<PersistedKeyData> {
@@ -184,64 +237,86 @@ object GeneratedKeyPersistence {
 
         for (file in files) {
             runCatching {
-                DataInputStream(BufferedInputStream(FileInputStream(file))).use { input ->
+                    DataInputStream(BufferedInputStream(FileInputStream(file))).use { input ->
-                    val version = input.readInt()
+                        val version = input.readInt()
-                    if (version != FORMAT_VERSION) {
+                        if (version != FORMAT_VERSION) {
-                        SystemLogger.warning(
+                            // Old upstream files (v1) and dev-only intermediate
-                            "Skipping ${file.name}: unknown format version $version"
+                            // files (v2) are missing the metadata snapshot
-                        )
+                            // and/or symmetric key block — restoring them
-                        return@runCatching
+                            // would put broken state in memory (apps relying
-                    }
+                            // on those records get logged out). Skip and let
-
+                            // the next generateKey re-create cleanly with the
-                    val storedSecLevel = input.readInt()
+                            // new format. Affected apps re-login once after
-                    val uid = input.readInt()
+                            // upgrade, then never again.
-                    val alias = input.readUTF()
+                            SystemLogger.info(
-                    val nspace = input.readLong()
+                                "Skipping ${file.name}: legacy format version $version. " +
-                    val isAttestKey = input.readBoolean()
+                                    "It will be replaced on next generateKey for this alias."
-                    val algo = input.readInt()
-                    val kSize = input.readInt()
-                    val curve = input.readInt()
-
-                    val purposeCount = requireBounds(input.readInt(), 64, "purposeCount")
-                    val purposes = (0 until purposeCount).map { input.readInt() }
-
-                    val digestCount = requireBounds(input.readInt(), 64, "digestCount")
-                    val digests = (0 until digestCount).map { input.readInt() }
-
-                    val pkLen = requireBounds(input.readInt(), 8192, "pkLen")
-                    val pkBytes = ByteArray(pkLen)
-                    input.readFully(pkBytes)
-
-                    val certCount = requireBounds(input.readInt(), 10, "certCount")
-                    val certChainBytes = (0 until certCount).map {
-                        val certLen = requireBounds(input.readInt(), 65536, "certLen")
-                        val certBytes = ByteArray(certLen)
-                        input.readFully(certBytes)
-                        certBytes
-                    }
-
-                    if (storedSecLevel == securityLevel) {
-                        result.add(
-                            PersistedKeyData(
-                                uid = uid,
-                                alias = alias,
-                                nspace = nspace,
-                                securityLevel = storedSecLevel,
-                                isAttestationKey = isAttestKey,
-                                algorithm = algo,
-                                keySize = kSize,
-                                ecCurve = curve,
-                                purposes = purposes,
-                                digests = digests,
-                                privateKeyBytes = pkBytes,
-                                certChainBytes = certChainBytes,
                             )
-                        )
+                            return@runCatching
+                        }
+
+                        val storedSecLevel = input.readInt()
+                        val uid = input.readInt()
+                        val alias = input.readUTF()
+                        val nspace = input.readLong()
+                        val isAttestKey = input.readBoolean()
+                        val algo = input.readInt()
+                        val kSize = input.readInt()
+                        val curve = input.readInt()
+
+                        val purposeCount = requireBounds(input.readInt(), 64, "purposeCount")
+                        val purposes = (0 until purposeCount).map { input.readInt() }
+
+                        val digestCount = requireBounds(input.readInt(), 64, "digestCount")
+                        val digests = (0 until digestCount).map { input.readInt() }
+
+                        val pkLen = requireBounds(input.readInt(), 8192, "pkLen")
+                        val pkBytes = ByteArray(pkLen)
+                        if (pkLen > 0) input.readFully(pkBytes)
+
+                        val certCount = requireBounds(input.readInt(), 10, "certCount")
+                        val certChainBytes =
+                            (0 until certCount).map {
+                                val certLen = requireBounds(input.readInt(), 65536, "certLen")
+                                val certBytes = ByteArray(certLen)
+                                input.readFully(certBytes)
+                                certBytes
+                            }
+
+                        val metaLen = requireBounds(input.readInt(), 256 * 1024, "metaLen")
+                        val metadataBytes =
+                            ByteArray(metaLen).also { if (metaLen > 0) input.readFully(it) }
+
+                        val skAlgo = input.readUTF()
+                        val skLen = requireBounds(input.readInt(), 8192, "skLen")
+                        val skBytes = ByteArray(skLen).also { if (skLen > 0) input.readFully(it) }
+
+                        if (storedSecLevel == securityLevel) {
+                            result.add(
+                                PersistedKeyData(
+                                    uid = uid,
+                                    alias = alias,
+                                    nspace = nspace,
+                                    securityLevel = storedSecLevel,
+                                    isAttestationKey = isAttestKey,
+                                    algorithm = algo,
+                                    keySize = kSize,
+                                    ecCurve = curve,
+                                    purposes = purposes,
+                                    digests = digests,
+                                    privateKeyBytes = pkBytes,
+                                    certChainBytes = certChainBytes,
+                                    metadataBytes = metadataBytes,
+                                    symmetricKeyBytes = skBytes,
+                                    symmetricAlgorithm = skAlgo,
+                                )
+                            )
+                        }
                     }
                 }
-            }.onFailure { e ->
+                .onFailure { e ->
-                SystemLogger.warning("Skipping corrupted persisted key file: ${file.name}", e)
+                    SystemLogger.warning("Skipping corrupted persisted key file: ${file.name}", e)
-            }
+                }
         }
 
         SystemLogger.info("Loaded ${result.size} persisted keys for security level $securityLevel")
@@ -263,11 +338,14 @@ object GeneratedKeyPersistence {
         }
         val secLevel = metadata.keySecurityLevel
 
-        val entry = KeyMintSecurityLevelInterceptor.generatedKeys.entries.find { (id, info) ->
+        val entry =
-            id.uid == callingUid && info.nspace == generatedKeyInfo.nspace
+            KeyMintSecurityLevelInterceptor.generatedKeys.entries.find { (id, info) ->
-        }
+                id.uid == callingUid && info.nspace == generatedKeyInfo.nspace
+            }
         if (entry == null) {
-            SystemLogger.debug("rePersist: key not found in map for uid=$callingUid nspace=${generatedKeyInfo.nspace}")
+            SystemLogger.debug(
+                "rePersist: key not found in map for uid=$callingUid nspace=${generatedKeyInfo.nspace}"
+            )
             return
         }
 
@@ -286,24 +364,50 @@ object GeneratedKeyPersistence {
             return
         }
 
-        val persisted = runCatching {
+        val persisted =
-            DataInputStream(BufferedInputStream(FileInputStream(existing))).use { input ->
+            runCatching {
-                val version = input.readInt()
+                    DataInputStream(BufferedInputStream(FileInputStream(existing))).use { input ->
-                if (version != FORMAT_VERSION) {
+                        val version = input.readInt()
-                    SystemLogger.warning("rePersist: unknown format version $version for $keyId")
+                        if (version != FORMAT_VERSION) {
-                    return
+                            SystemLogger.warning(
+                                "rePersist: legacy format version $version for $keyId, will not re-persist (next generateKey replaces it)"
+                            )
+                            return
+                        }
+                        readPersistedKeyData(input)
+                    }
                 }
-                readPersistedKeyData(input)
+                .getOrNull()
-            }
-        }.getOrNull()
         if (persisted == null) {
             SystemLogger.warning("rePersist: failed to read existing data for $keyId")
             return
         }
 
+        val keyPair = generatedKeyInfo.keyPair
+        val secretKey = generatedKeyInfo.secretKey
+        if (keyPair == null && secretKey == null) {
+            SystemLogger.warning("rePersist: no key material for $keyId")
+            return
+        }
+        // Serialize the live KeyMetadata (now contains the user-installed cert
+        // chain via updateSubcomponent) so the next boot restores byte-identical
+        // metadata. KeyMetadata is binder-free, so marshall() is safe here.
+        val metadataBytes =
+            runCatching {
+                    android.os.Parcel.obtain().let { parcel ->
+                        try {
+                            metadata.writeToParcel(parcel, 0)
+                            parcel.marshall()
+                        } finally {
+                            parcel.recycle()
+                        }
+                    }
+                }
+                .getOrNull()
         save(
             keyId = keyId,
-            keyPair = generatedKeyInfo.keyPair,
+            keyPair = keyPair,
+            secretKey = secretKey,
             nspace = generatedKeyInfo.nspace,
             securityLevel = secLevel,
             certChain = newChain.toList(),
@@ -313,6 +417,7 @@ object GeneratedKeyPersistence {
             purposes = persisted.purposes,
             digests = persisted.digests,
             isAttestationKey = persisted.isAttestationKey,
+            metadataBytes = metadataBytes,
         )
         SystemLogger.debug("Re-persisted key $keyId with updated cert chain")
     }
@@ -324,12 +429,13 @@ object GeneratedKeyPersistence {
     }
 
     private fun keyFileName(uid: Int, alias: String): String {
-        val digest = MessageDigest.getInstance("SHA-256")
+        val digest =
-            .digest("$uid:$alias".toByteArray(Charsets.UTF_8))
+            MessageDigest.getInstance("SHA-256").digest("$uid:$alias".toByteArray(Charsets.UTF_8))
         return digest.joinToString("") { "%02x".format(it) } + ".bin"
     }
 
-    // Reads all fields after version has already been consumed
+    // Reads all fields after the version int has already been consumed
+    // and validated by the caller.
     private fun readPersistedKeyData(input: DataInputStream): PersistedKeyData {
         val secLevel = input.readInt()
         val uid = input.readInt()
@@ -348,15 +454,23 @@ object GeneratedKeyPersistence {
 
         val pkLen = requireBounds(input.readInt(), 8192, "pkLen")
         val pkBytes = ByteArray(pkLen)
-        input.readFully(pkBytes)
+        if (pkLen > 0) input.readFully(pkBytes)
 
         val certCount = requireBounds(input.readInt(), 10, "certCount")
-        val certChainBytes = (0 until certCount).map {
+        val certChainBytes =
-            val certLen = requireBounds(input.readInt(), 65536, "certLen")
+            (0 until certCount).map {
-            val certBytes = ByteArray(certLen)
+                val certLen = requireBounds(input.readInt(), 65536, "certLen")
-            input.readFully(certBytes)
+                val certBytes = ByteArray(certLen)
-            certBytes
+                input.readFully(certBytes)
-        }
+                certBytes
+            }
+
+        val metaLen = requireBounds(input.readInt(), 256 * 1024, "metaLen")
+        val metadataBytes = ByteArray(metaLen).also { if (metaLen > 0) input.readFully(it) }
+
+        val skAlgo = input.readUTF()
+        val skLen = requireBounds(input.readInt(), 8192, "skLen")
+        val skBytes = ByteArray(skLen).also { if (skLen > 0) input.readFully(it) }
 
         return PersistedKeyData(
             uid = uid,
@@ -371,6 +485,9 @@ object GeneratedKeyPersistence {
             digests = digests,
             privateKeyBytes = pkBytes,
             certChainBytes = certChainBytes,
+            metadataBytes = metadataBytes,
+            symmetricKeyBytes = skBytes,
+            symmetricAlgorithm = skAlgo,
         )
     }
 }

app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/OperationInterceptor.kt

@@ -13,6 +13,7 @@ import org.matrix.TEESimulator.interception.keystore.InterceptorUtils
 class OperationInterceptor(
     private val original: IKeystoreOperation,
     private val backdoor: IBinder,
+    private val isAead: Boolean,
 ) : BinderInterceptor() {
 
     override fun onPreTransact(
@@ -27,6 +28,17 @@ class OperationInterceptor(
         val methodName = transactionNames[code] ?: "unknown code=$code"
         logTransaction(txId, methodName, callingUid, callingPid, true)
 
+        // Mirror SoftwareOperation's vendor gate: a real-key op must answer non-AEAD updateAad
+        // exactly as the forged-key path does. Samsung and Xiaomi-MTK TEEs accept it; rejecting
+        // here while the forged path accepts diverges the two and fingerprints the injection.
+        if (code == UPDATE_AAD_TRANSACTION && !isAead) {
+            return if (VendorQuirks.nonAeadUpdateAadSucceeds()) {
+                InterceptorUtils.createSuccessReply(writeResultCode = false)
+            } else {
+                InterceptorUtils.createServiceSpecificErrorReply(KeystoreErrorCodes.invalidTag)
+            }
+        }
+
         if (code == FINISH_TRANSACTION || code == ABORT_TRANSACTION) {
             KeyMintSecurityLevelInterceptor.removeOperationInterceptor(target, backdoor)
         }
@@ -44,6 +56,9 @@ class OperationInterceptor(
         private val ABORT_TRANSACTION =
             InterceptorUtils.getTransactCode(IKeystoreOperation.Stub::class.java, "abort")
 
+        val INTERCEPTED_CODES =
+            intArrayOf(UPDATE_AAD_TRANSACTION, FINISH_TRANSACTION, ABORT_TRANSACTION)
+
         private val transactionNames: Map<Int, String> by lazy {
             IKeystoreOperation.Stub::class
                 .java

app/src/main/java/org/matrix/TEESimulator/interception/keystore/shim/SoftwareOperation.kt

@@ -3,28 +3,69 @@ 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.os.RemoteException
+import android.hardware.security.keymint.Tag
+import android.os.Build
+import android.os.ServiceSpecificException
+import android.os.SystemProperties
 import android.system.keystore2.IKeystoreOperation
+import android.system.keystore2.KeyParameters
 import java.security.KeyPair
 import java.security.Signature
 import java.security.SignatureException
+import java.util.concurrent.locks.LockSupport
 import javax.crypto.Cipher
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.logging.KeyMintParameterLogger
 import org.matrix.TEESimulator.logging.SystemLogger
 
-// A sealed interface to represent the different cryptographic operations we can perform.
+/**
+ * Mirrors the per-vendor TEE quirk that Duck Detector's OperationErrorPathProbe checks: real
+ * Samsung and Xiaomi-MTK TrustZone return success for updateAad on a non-AEAD operation, while
+ * every other vendor rejects it with a service-specific INVALID_TAG. The module reads the same
+ * device-identity fields the probe reads, so a forged software operation answers exactly as that
+ * vendor's real TEE would.
+ */
+internal object VendorQuirks {
+    private val UPDATE_AAD_ALLOWS_SUCCESS = setOf("samsung")
+    private val XIAOMI_BRANDS = setOf("xiaomi", "redmi", "poco")
+
+    fun nonAeadUpdateAadSucceeds(): Boolean {
+        val manufacturer = Build.MANUFACTURER.lowercase()
+        val brand = Build.BRAND.lowercase()
+        if (manufacturer in UPDATE_AAD_ALLOWS_SUCCESS || brand in UPDATE_AAD_ALLOWS_SUCCESS) {
+            return true
+        }
+        if (manufacturer != "xiaomi" && brand !in XIAOMI_BRANDS) return false
+        return isMediaTek()
+    }
+
+    private fun isMediaTek(): Boolean {
+        val roHardware = SystemProperties.get("ro.hardware", "")
+        return roHardware.startsWith("mt") || Build.HARDWARE.startsWith("mt", ignoreCase = true)
+    }
+}
+
 private sealed interface CryptoPrimitive {
+    fun updateAad(aadInput: ByteArray?) {
+        // Real Samsung / Xiaomi-MTK TEEs accept updateAad on non-AEAD ops; others reject it.
+        if (!VendorQuirks.nonAeadUpdateAadSucceeds()) {
+            throw ServiceSpecificException(KeystoreErrorCodes.invalidTag)
+        }
+    }
+
     fun update(data: ByteArray?): ByteArray?
 
     fun finish(data: ByteArray?, signature: ByteArray?): ByteArray?
 
     fun abort()
+
+    fun getBeginParameters(): Array<KeyParameter>? = null
 }
 
-// Helper object to map KeyMint constants to JCA algorithm strings.
 private object JcaAlgorithmMapper {
     fun mapSignatureAlgorithm(params: KeyMintAttestation): String {
         val digest =
@@ -34,16 +75,18 @@ private object JcaAlgorithmMapper {
                 Digest.SHA_2_512 -> "SHA512"
                 else -> "NONE"
             }
-        val keyAlgo =
+        return when (params.algorithm) {
-            when (params.algorithm) {
+            Algorithm.EC -> "${digest}withECDSA"
-                Algorithm.EC -> "ECDSA"
+            Algorithm.RSA -> {
-                Algorithm.RSA -> "RSA"
+                val isPss = params.padding.firstOrNull() == PaddingMode.RSA_PSS
-                else ->
+                if (isPss) "${digest}withRSA/PSS" else "${digest}withRSA"
-                    throw IllegalArgumentException(
-                        "Unsupported signature algorithm: ${params.algorithm}"
-                    )
             }
-        return "${digest}with${keyAlgo}"
+            else ->
+                throw ServiceSpecificException(
+                    KeystoreErrorCodes.incompatibleAlgorithm,
+                    "Unsupported signature algorithm: ${params.algorithm}",
+                )
+        }
     }
 
     fun mapCipherAlgorithm(params: KeyMintAttestation): String {
@@ -52,30 +95,50 @@ private object JcaAlgorithmMapper {
                 Algorithm.RSA -> "RSA"
                 Algorithm.AES -> "AES"
                 else ->
-                    throw IllegalArgumentException(
+                    throw ServiceSpecificException(
-                        "Unsupported cipher algorithm: ${params.algorithm}"
+                        KeystoreErrorCodes.incompatibleAlgorithm,
+                        "Unsupported cipher algorithm: ${params.algorithm}",
                     )
             }
         val blockMode =
             when (params.blockMode.firstOrNull()) {
                 BlockMode.ECB -> "ECB"
                 BlockMode.CBC -> "CBC"
+                BlockMode.CTR -> "CTR"
                 BlockMode.GCM -> "GCM"
-                else -> "ECB" // Default for RSA
+                else -> "ECB"
             }
         val padding =
             when (params.padding.firstOrNull()) {
                 PaddingMode.NONE -> "NoPadding"
                 PaddingMode.PKCS7 -> "PKCS7Padding"
                 PaddingMode.RSA_PKCS1_1_5_ENCRYPT -> "PKCS1Padding"
+                PaddingMode.RSA_PKCS1_1_5_SIGN -> "PKCS1Padding"
                 PaddingMode.RSA_OAEP -> "OAEPPadding"
-                else -> "NoPadding" // Default for GCM
+                else -> "NoPadding"
             }
         return "$keyAlgo/$blockMode/$padding"
     }
+
+    fun mapOaepDigest(digest: Int?): String =
+        when (digest) {
+            Digest.SHA1 -> "SHA-1"
+            Digest.SHA_2_224 -> "SHA-224"
+            Digest.SHA_2_256 -> "SHA-256"
+            Digest.SHA_2_384 -> "SHA-384"
+            Digest.SHA_2_512 -> "SHA-512"
+            else -> "SHA-256"
+        }
+
+    fun mapMacAlgorithm(params: KeyMintAttestation): String =
+        when (params.digest.firstOrNull()) {
+            Digest.SHA_2_256 -> "HmacSHA256"
+            Digest.SHA_2_384 -> "HmacSHA384"
+            Digest.SHA_2_512 -> "HmacSHA512"
+            else -> "HmacSHA256"
+        }
 }
 
-// Concrete implementation for Signing.
 private class Signer(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPrimitive {
     private val signature: Signature =
         Signature.getInstance(JcaAlgorithmMapper.mapSignatureAlgorithm(params)).apply {
@@ -95,7 +158,6 @@ private class Signer(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPrimi
     override fun abort() {}
 }
 
-// Concrete implementation for Verification.
 private class Verifier(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPrimitive {
     private val signature: Signature =
         Signature.getInstance(JcaAlgorithmMapper.mapSignatureAlgorithm(params)).apply {
@@ -109,107 +171,493 @@ 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(
+                KeystoreErrorCodes.verificationFailed,
+                "Signature to verify is null",
+            )
+        }
         if (!this.signature.verify(signature)) {
-            // Throwing an exception is how Keystore signals verification failure.
+            throw ServiceSpecificException(
-            throw SignatureException("Signature verification failed")
+                KeystoreErrorCodes.verificationFailed,
+                "Signature verification failed",
+            )
         }
-        // A successful verification returns no data.
         return null
     }
 
     override fun abort() {}
 }
 
-// Concrete implementation for Encryption/Decryption.
 private class CipherPrimitive(
-    keyPair: KeyPair,
+    cryptoKey: java.security.Key,
     params: KeyMintAttestation,
     private val opMode: Int,
+    txId: Long,
 ) : CryptoPrimitive {
+    private val isAead = params.blockMode.firstOrNull() == BlockMode.GCM
     private val cipher: Cipher =
         Cipher.getInstance(JcaAlgorithmMapper.mapCipherAlgorithm(params)).apply {
-            val key = if (opMode == Cipher.ENCRYPT_MODE) keyPair.public else keyPair.private
+            val nonce = params.nonce
-            init(opMode, key)
+            if (nonce != null && isAead) {
+                init(opMode, cryptoKey, javax.crypto.spec.GCMParameterSpec(128, nonce))
+            } else if (nonce != null) {
+                init(opMode, cryptoKey, javax.crypto.spec.IvParameterSpec(nonce))
+            } else if (params.padding.firstOrNull() == PaddingMode.RSA_OAEP) {
+                val mainDigest = JcaAlgorithmMapper.mapOaepDigest(params.digest.firstOrNull())
+                val mgfDigest =
+                    params.rsaOaepMgfDigest.firstOrNull()?.let {
+                        JcaAlgorithmMapper.mapOaepDigest(it)
+                    } ?: mainDigest
+                init(
+                    opMode,
+                    cryptoKey,
+                    javax.crypto.spec.OAEPParameterSpec(
+                        mainDigest,
+                        "MGF1",
+                        java.security.spec.MGF1ParameterSpec(mgfDigest),
+                        javax.crypto.spec.PSource.PSpecified.DEFAULT,
+                    ),
+                )
+                SystemLogger.debug {
+                    "[SoftwareOp TX_ID: $txId] oaep-op main=$mainDigest mgf=$mgfDigest " +
+                        "mode=${if (opMode == Cipher.DECRYPT_MODE) "decrypt" else "encrypt"}"
+                }
+            } else {
+                init(opMode, cryptoKey)
+            }
         }
 
+    override fun updateAad(aadInput: ByteArray?) {
+        if (!isAead) {
+            if (!VendorQuirks.nonAeadUpdateAadSucceeds()) {
+                throw ServiceSpecificException(KeystoreErrorCodes.invalidTag)
+            }
+            return
+        }
+        if (aadInput != null) cipher.updateAAD(aadInput)
+    }
+
     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 getBeginParameters(): Array<KeyParameter>? {
+        val iv = cipher.iv ?: return null
+        return arrayOf(
+            KeyParameter().apply {
+                tag = Tag.NONCE
+                value = KeyParameterValue.blob(iv)
+            }
+        )
+    }
+
     override fun abort() {}
 }
 
-/**
+private class KeyAgreementPrimitive(keyPair: KeyPair) : CryptoPrimitive {
- * A software-only implementation of a cryptographic operation. This class acts as a controller,
+    private val agreement: javax.crypto.KeyAgreement =
- * delegating to a specific cryptographic primitive based on the operation's purpose.
+        javax.crypto.KeyAgreement.getInstance("ECDH").apply { init(keyPair.private) }
- */
+
-class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMintAttestation) {
+    override fun update(data: ByteArray?): ByteArray? = null
-    // This now holds the specific strategy object (Signer, Verifier, etc.)
+
+    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
+        if (data == null)
+            throw ServiceSpecificException(
+                KeystoreErrorCodes.invalidArgument,
+                "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() {}
+}
+
+private class MacPrimitive(
+    secretKey: javax.crypto.SecretKey,
+    private val params: KeyMintAttestation,
+    private val txId: Long,
+) : CryptoPrimitive {
+    private val mac: javax.crypto.Mac =
+        javax.crypto.Mac.getInstance(JcaAlgorithmMapper.mapMacAlgorithm(params)).apply {
+            init(secretKey)
+        }
+
+    override fun update(data: ByteArray?): ByteArray? {
+        if (data != null) mac.update(data)
+        return null
+    }
+
+    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
+        if (data != null) mac.update(data)
+        val full = mac.doFinal()
+        // Tag.MAC_LENGTH is optional on the AndroidKeyStore Mac SPI; default to the
+        // full digest length so real Mac use keeps working when it is omitted.
+        val tagBytes = (params.macLength ?: (full.size * 8)) / 8
+        val tag = full.copyOf(tagBytes)
+        if (params.purpose.firstOrNull() == KeyPurpose.VERIFY) {
+            if (signature == null) {
+                throw ServiceSpecificException(
+                    KeystoreErrorCodes.verificationFailed,
+                    "MAC to verify is null",
+                )
+            }
+            if (!java.security.MessageDigest.isEqual(tag, signature)) {
+                throw ServiceSpecificException(
+                    KeystoreErrorCodes.verificationFailed,
+                    "MAC verification failed",
+                )
+            }
+            return null
+        }
+        SystemLogger.debug {
+            "[SoftwareOp TX_ID: $txId] hmac-op digest=${params.digest.firstOrNull()} " +
+                "macLen=${params.macLength} tag=${tag.size}B result=ok"
+        }
+        return tag
+    }
+
+    override fun abort() {}
+}
+
+class SoftwareOperation(
+    private val txId: Long,
+    keyPair: KeyPair?,
+    secretKey: javax.crypto.SecretKey?,
+    params: KeyMintAttestation,
+    private val latencyFloorMs: Long = 0L,
+) {
     private val primitive: CryptoPrimitive
+    @Volatile
+    var finalized = false
+        private set
+
+    var onFinishCallback: (() -> Unit)? = null
+
+    val beginParameters: KeyParameters?
+        get() {
+            val params = primitive.getBeginParameters() ?: return null
+            if (params.isEmpty()) return null
+            return KeyParameters().apply { keyParameter = params }
+        }
 
     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.")
 
+        if (purpose == null) {
+            // Defensive: if params somehow restored without a PURPOSE tag
+            // (corrupt v2 metadata, mismatched authorizations array on load,
+            // or future format drift) the original code crashed with NPE
+            // because Signer/Verifier/Cipher all dereference keyPair!!
+            // before checking purpose. Surface a clean keystore error
+            // instead so callers see a normal-looking operation failure
+            // they can recover from rather than the process appearing to
+            // silently corrupt their session.
+            SystemLogger.warning(
+                "[SoftwareOp TX_ID: $txId] Purpose missing on restored key " +
+                    "(authorizations=${params.purpose}, keyPair=${if (keyPair != null) "present" else "null"}, " +
+                    "secretKey=${if (secretKey != null) "present" else "null"}). " +
+                    "Returning unsupportedPurpose."
+            )
+            throw ServiceSpecificException(
+                KeystoreErrorCodes.unsupportedPurpose,
+                "Restored key has no PURPOSE authorization",
+            )
+        }
+
         primitive =
-            when (purpose) {
+            if (params.algorithm == Algorithm.HMAC) {
-                KeyPurpose.SIGN -> Signer(keyPair, params)
+                // An HMAC key is symmetric (secretKey set, keyPair null), so it must
-                KeyPurpose.VERIFY -> Verifier(keyPair, params)
+                // not fall through to the purpose-keyed Signer/Verifier paths, which
-                KeyPurpose.ENCRYPT -> CipherPrimitive(keyPair, params, Cipher.ENCRYPT_MODE)
+                // require a keyPair. secretKey is populated at HMAC keygen and restore,
-                KeyPurpose.DECRYPT -> CipherPrimitive(keyPair, params, Cipher.DECRYPT_MODE)
+                // so the throw is a defensive floor, not a live path.
-                else ->
+                MacPrimitive(
-                    throw UnsupportedOperationException("Unsupported operation purpose: $purpose")
+                    secretKey
+                        ?: throw ServiceSpecificException(
+                            KeystoreErrorCodes.invalidArgument,
+                            "[SoftwareOp TX_ID: $txId] HMAC op but secretKey null",
+                        ),
+                    params,
+                    txId,
+                )
+            } else {
+                when (purpose) {
+                    KeyPurpose.SIGN -> {
+                        val kp =
+                            keyPair
+                                ?: throw ServiceSpecificException(
+                                    KeystoreErrorCodes.invalidArgument,
+                                    "[SoftwareOp TX_ID: $txId] SIGN requested but keyPair is null",
+                                )
+                        Signer(kp, params)
+                    }
+                    KeyPurpose.VERIFY -> {
+                        val kp =
+                            keyPair
+                                ?: throw ServiceSpecificException(
+                                    KeystoreErrorCodes.invalidArgument,
+                                    "[SoftwareOp TX_ID: $txId] VERIFY requested but keyPair is null",
+                                )
+                        Verifier(kp, params)
+                    }
+                    KeyPurpose.ENCRYPT -> {
+                        val key: java.security.Key =
+                            secretKey
+                                ?: keyPair?.public
+                                ?: throw ServiceSpecificException(
+                                    KeystoreErrorCodes.unsupportedPurpose,
+                                    "[SoftwareOp TX_ID: $txId] ENCRYPT requires either secretKey or keyPair.public",
+                                )
+                        CipherPrimitive(key, params, Cipher.ENCRYPT_MODE, txId)
+                    }
+                    KeyPurpose.DECRYPT -> {
+                        val key: java.security.Key =
+                            secretKey
+                                ?: keyPair?.private
+                                ?: throw ServiceSpecificException(
+                                    KeystoreErrorCodes.unsupportedPurpose,
+                                    "[SoftwareOp TX_ID: $txId] DECRYPT requires either secretKey or keyPair.private",
+                                )
+                        CipherPrimitive(key, params, Cipher.DECRYPT_MODE, txId)
+                    }
+                    KeyPurpose.AGREE_KEY -> {
+                        val kp =
+                            keyPair
+                                ?: throw ServiceSpecificException(
+                                    KeystoreErrorCodes.invalidArgument,
+                                    "[SoftwareOp TX_ID: $txId] AGREE_KEY requested but keyPair is null",
+                                )
+                        KeyAgreementPrimitive(kp)
+                    }
+                    else ->
+                        throw ServiceSpecificException(
+                            KeystoreErrorCodes.unsupportedPurpose,
+                            "Unsupported operation purpose: $purpose",
+                        )
+                }
             }
     }
 
+    private fun checkActive() {
+        if (finalized) {
+            SystemLogger.debug(
+                "[SoftwareOp TX_ID: $txId] Rejected: operation already finalized (pruned or completed)"
+            )
+            throw ServiceSpecificException(KeystoreErrorCodes.invalidOperationHandle)
+        }
+    }
+
+    private fun checkInputLength(data: ByteArray?) {
+        if (data != null && data.size > MAX_RECEIVE_DATA) {
+            SystemLogger.info(
+                "[SoftwareOp TX_ID: $txId] Input too large: ${data.size} > $MAX_RECEIVE_DATA, throwing TOO_MUCH_DATA(${KeystoreErrorCodes.tooMuchData})"
+            )
+            throw ServiceSpecificException(KeystoreErrorCodes.tooMuchData)
+        }
+    }
+
+    fun updateAad(aadInput: ByteArray?) {
+        SystemLogger.info(
+            "[SoftwareOp TX_ID: $txId] updateAad() ENTRY inputSize=${aadInput?.size ?: 0} primitive=${primitive::class.simpleName}"
+        )
+        checkActive()
+        checkInputLength(aadInput)
+        try {
+            primitive.updateAad(aadInput)
+            SystemLogger.info(
+                "[SoftwareOp TX_ID: $txId] updateAad() RETURNED_NORMALLY (unexpected for non-AEAD)"
+            )
+        } catch (throwable: Throwable) {
+            val top = throwable.stackTrace.firstOrNull()?.toString() ?: "<no-frame>"
+            val code = (throwable as? ServiceSpecificException)?.errorCode
+            SystemLogger.info(
+                "[SoftwareOp TX_ID: $txId] updateAad() THREW class=${throwable::class.java.name} code=$code msg=${throwable.message} top=$top"
+            )
+            throw throwable
+        }
+    }
+
     fun update(data: ByteArray?): ByteArray? {
+        SystemLogger.debug("[SoftwareOp TX_ID: $txId] update() inputSize=${data?.size ?: 0}")
+        checkActive()
+        checkInputLength(data)
         try {
             return primitive.update(data)
+        } catch (e: ServiceSpecificException) {
+            throw e
         } catch (e: Exception) {
             SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to update operation.", e)
-            throw e
+            throw mapToServiceSpecificException(e)
         }
     }
 
     fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
+        checkActive()
+        checkInputLength(data)
         try {
+            val startNs = if (latencyFloorMs > 0) System.nanoTime() else 0L
             val result = primitive.finish(data, signature)
+            if (latencyFloorMs > 0) {
+                val elapsedMs = (System.nanoTime() - startNs) / 1_000_000
+                val delayMs = latencyFloorMs - elapsedMs
+                if (delayMs > 0) LockSupport.parkNanos(delayMs * 1_000_000)
+            }
+            finalized = true
+            onFinishCallback?.invoke()
             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)
-            // Re-throw the exception so the binder can report it to the client.
+            throw mapToServiceSpecificException(e)
-            throw e
         }
     }
 
     fun abort() {
+        finalized = true
         primitive.abort()
         SystemLogger.debug("[SoftwareOp TX_ID: $txId] Operation aborted.")
     }
+
+    private fun mapToServiceSpecificException(e: Exception): ServiceSpecificException =
+        when (e) {
+            is SignatureException ->
+                ServiceSpecificException(KeystoreErrorCodes.verificationFailed, e.message)
+            is javax.crypto.BadPaddingException ->
+                ServiceSpecificException(KeystoreErrorCodes.invalidArgument, e.message)
+            is javax.crypto.IllegalBlockSizeException ->
+                ServiceSpecificException(KeystoreErrorCodes.invalidInputLength, e.message)
+            is java.security.InvalidKeyException ->
+                ServiceSpecificException(KeystoreErrorCodes.incompatibleKey, e.message)
+            else -> ServiceSpecificException(KeystoreErrorCodes.unknownError, e.message)
+        }
+
+    companion object {
+        private const val MAX_RECEIVE_DATA = 0x8000
+    }
+}
+
+internal object KeystoreErrorCodes {
+    val tooMuchData: Int by lazy {
+        resolveField("android.system.keystore2.ResponseCode", "TOO_MUCH_DATA", 21)
+    }
+
+    val invalidOperationHandle: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INVALID_OPERATION_HANDLE", -28)
+    }
+
+    val invalidTag: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INVALID_TAG", -76)
+    }
+
+    val verificationFailed: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "VERIFICATION_FAILED", -30)
+    }
+
+    val invalidArgument: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INVALID_ARGUMENT", -38)
+    }
+
+    val invalidInputLength: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INVALID_INPUT_LENGTH", -21)
+    }
+
+    val incompatibleKey: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INCOMPATIBLE_KEY", -31)
+    }
+
+    val incompatiblePurpose: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INCOMPATIBLE_PURPOSE", -13)
+    }
+
+    val unsupportedPurpose: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "UNSUPPORTED_PURPOSE", -14)
+    }
+
+    val incompatibleAlgorithm: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INCOMPATIBLE_ALGORITHM", -18)
+    }
+
+    val keyNotYetValid: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "KEY_NOT_YET_VALID", -39)
+    }
+
+    val keyExpired: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "KEY_EXPIRED", -40)
+    }
+
+    val callerNonceProhibited: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "CALLER_NONCE_PROHIBITED", -55)
+    }
+
+    val unknownError: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "UNKNOWN_ERROR", -1000)
+    }
+
+    val incompatibleBlockMode: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INCOMPATIBLE_BLOCK_MODE", -8)
+    }
+
+    val incompatiblePaddingMode: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INCOMPATIBLE_PADDING_MODE", -11)
+    }
+
+    val incompatibleDigest: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INCOMPATIBLE_DIGEST", -13)
+    }
+
+    val invalidMacLength: Int by lazy {
+        resolveField("android.hardware.security.keymint.ErrorCode", "INVALID_MAC_LENGTH", -57)
+    }
+
+    fun resolveField(className: String, fieldName: String, fallback: Int): Int =
+        runCatching { Class.forName(className).getField(fieldName).getInt(null) }
+            .getOrElse {
+                SystemLogger.debug("Resolved $className.$fieldName via fallback: $fallback")
+                fallback
+            }
 }
 
-/** The Binder interface for our [SoftwareOperation]. */
 class SoftwareOperationBinder(private val operation: SoftwareOperation) :
     IKeystoreOperation.Stub() {
 
-    @Throws(RemoteException::class)
+    @Synchronized
+    override fun updateAad(aadInput: ByteArray?) {
+        SystemLogger.info(
+            "[SoftwareOpBinder] updateAad() ENTRY callingUid=${android.os.Binder.getCallingUid()} size=${aadInput?.size ?: 0}"
+        )
+        try {
+            operation.updateAad(aadInput)
+            SystemLogger.info("[SoftwareOpBinder] updateAad() RETURNED_NORMALLY")
+        } catch (throwable: Throwable) {
+            val code = (throwable as? ServiceSpecificException)?.errorCode
+            SystemLogger.info(
+                "[SoftwareOpBinder] updateAad() PROPAGATING class=${throwable::class.java.name} code=$code msg=${throwable.message}"
+            )
+            throw throwable
+        }
+    }
+
+    @Synchronized
     override fun update(input: ByteArray?): ByteArray? {
         return operation.update(input)
     }
 
-    @Throws(RemoteException::class)
+    @Synchronized
     override fun finish(input: ByteArray?, signature: ByteArray?): ByteArray? {
         return operation.finish(input, signature)
     }
 
-    @Throws(RemoteException::class)
+    @Synchronized
     override fun abort() {
         operation.abort()
     }

app/src/main/java/org/matrix/TEESimulator/interception/soter/SoterProcessSupervisor.kt

@@ -0,0 +1,170 @@
+package org.matrix.TEESimulator.interception.soter
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.IBinder
+import java.util.concurrent.Executor
+import java.util.concurrent.atomic.AtomicBoolean
+import org.matrix.TEESimulator.interception.core.BinderInterceptor
+import org.matrix.TEESimulator.logging.SystemLogger
+
+/**
+ * Keeps [SoterServiceInterceptor] mounted on the on-demand, restartable
+ * `com.tencent.soter.soterserver` process.
+ *
+ * `AbstractKeystoreInterceptor` injects `keystore2` exactly once: it is always alive and
+ * servicemanager-published, so the daemon gets its binder from `ServiceManager` and may
+ * `exitProcess` on failure. soterserver inverts both — it is Intent-bound (NOT in
+ * `ServiceManager`) and may die and respawn. This supervisor therefore *binds* the SOTER
+ * service, which both triggers its on-demand start AND yields the `ISoterService` binder
+ * (the target the native MITM registry keys on); injects `libTEESimulator.so` on every
+ * (re)start; confirms the landing with the `0xdeadbeef` backdoor handshake; then registers
+ * the forge. It re-binds — re-poking, re-injecting, re-registering — whenever the process
+ * dies, never exiting.
+ *
+ * The bind recipe (action = the interface descriptor, package, `BIND_AUTO_CREATE`) and the
+ * rebind-on-death lifecycle mirror the SOTER SDK's own `SoterCoreTreble`, so the daemon
+ * connects exactly as a real client would. Everything runs on a dedicated [HandlerThread]
+ * so it never stalls keystore init or `Looper.loop()` in [org.matrix.TEESimulator.App].
+ *
+ * Observability (the checkpoint's mandatory gate): every lifecycle event — bind, connect,
+ * inject ok/fail, handshake, respawn — is logged via [SystemLogger], debug-gated. It never
+ * gates the forge.
+ */
+object SoterProcessSupervisor {
+
+    /** soterserver hosts the package's own process (recon 2026-06-26: process == package). */
+    private const val SOTER_PACKAGE = "com.tencent.soter.soterserver"
+
+    /** Reuses the daemon's native injector + `entry`, PID-resolved by the target package. */
+    private const val INJECTION_COMMAND =
+        "exec ./inject `pidof $SOTER_PACKAGE` libTEESimulator.so entry"
+
+    private const val REBIND_DELAY_MS = 1000L
+    private const val REBIND_MAX_MS = 30_000L
+
+    private val started = AtomicBoolean(false)
+
+    /** Re-bind backoff; doubles each failed (re)bind up to [REBIND_MAX_MS], resets on a clean mount. Handler-thread-confined. */
+    private var rebindDelay = REBIND_DELAY_MS
+
+    private lateinit var context: Context
+    private lateinit var handler: Handler
+
+    /** Delivers bind callbacks onto the supervisor thread so nothing touches the main looper. */
+    private val executor = Executor { command -> handler.post(command) }
+
+    /**
+     * Starts supervising on a dedicated thread and returns immediately. Idempotent. [context]
+     * must be able to bind services (the daemon's system context); supplied by the App wiring.
+     */
+    fun start(context: Context) {
+        if (!started.compareAndSet(false, true)) return
+        this.context = context
+        handler = Handler(HandlerThread("soter-supervisor").apply { start() }.looper)
+        handler.post { bind() }
+    }
+
+    private val connection =
+        object : ServiceConnection {
+            override fun onServiceConnected(name: ComponentName?, service: IBinder?) {
+                SystemLogger.debug("SOTER service connected; mounting forge")
+                service?.let(::mount)
+            }
+
+            override fun onServiceDisconnected(name: ComponentName?) {
+                SystemLogger.debug("SOTER service disconnected (process died); rebinding")
+                scheduleRetry()
+            }
+
+            override fun onBindingDied(name: ComponentName?) {
+                SystemLogger.debug("SOTER binding died; rebinding")
+                scheduleRetry()
+            }
+
+            override fun onNullBinding(name: ComponentName?) {
+                SystemLogger.debug("SOTER onBind returned null; rebinding")
+                scheduleRetry()
+            }
+        }
+
+    private fun bind() {
+        val intent = Intent(SoterServiceInterceptor.DESCRIPTOR).setPackage(SOTER_PACKAGE)
+        val bound =
+            runCatching {
+                    context.bindService(intent, Context.BIND_AUTO_CREATE, executor, connection)
+                }
+                .getOrElse {
+                    SystemLogger.debug { "SOTER bindService threw: $it" }
+                    false
+                }
+        if (bound) {
+            SystemLogger.debug("SOTER bind requested (on-demand poke)")
+        } else {
+            SystemLogger.debug("SOTER bindService returned false; retrying")
+            scheduleRetry()
+        }
+    }
+
+    private fun rebind() {
+        runCatching { context.unbindService(connection) }
+        bind()
+    }
+
+    /**
+     * Re-attempts the bind after the current backoff, then widens it (capped at [REBIND_MAX_MS]).
+     * Every path that fails to leave the forge mounted routes here, so a live-but-uninjected
+     * binding is re-attempted instead of stranding the forge. A clean [mount] resets the backoff.
+     */
+    private fun scheduleRetry() {
+        val delay = rebindDelay
+        rebindDelay = (rebindDelay * 2).coerceAtMost(REBIND_MAX_MS)
+        handler.postDelayed({ rebind() }, delay)
+    }
+
+    /** Confirms injection via the `0xdeadbeef` handshake, injecting first if absent, then registers. */
+    private fun mount(soterBinder: IBinder) {
+        var backdoor = BinderInterceptor.getBackdoor(soterBinder)
+        if (backdoor == null) {
+            SystemLogger.debug("SOTER backdoor absent; injecting libTEESimulator.so")
+            if (!injectLibrary()) {
+                SystemLogger.debug("SOTER injection failed; scheduling re-bind")
+                scheduleRetry()
+                return
+            }
+            backdoor = BinderInterceptor.getBackdoor(soterBinder)
+        }
+        if (backdoor == null) {
+            SystemLogger.debug("SOTER backdoor handshake failed after injection; scheduling re-bind")
+            scheduleRetry()
+            return
+        }
+        val registered =
+            BinderInterceptor.register(
+                backdoor,
+                soterBinder,
+                SoterServiceInterceptor,
+                SoterServiceInterceptor.interceptedCodes,
+            )
+        if (!registered) {
+            SystemLogger.debug("SOTER register failed; scheduling re-bind")
+            scheduleRetry()
+            return
+        }
+        rebindDelay = REBIND_DELAY_MS
+        SystemLogger.debug("SOTER forge mounted; handshake ok")
+    }
+
+    private fun injectLibrary(): Boolean =
+        runCatching {
+                Runtime.getRuntime().exec(arrayOf("/system/bin/sh", "-c", INJECTION_COMMAND)).waitFor() == 0
+            }
+            .getOrElse {
+                SystemLogger.debug { "SOTER inject exec failed: $it" }
+                false
+            }
+}

app/src/main/java/org/matrix/TEESimulator/interception/soter/SoterServiceInterceptor.kt

@@ -0,0 +1,229 @@
+package org.matrix.TEESimulator.interception.soter
+
+import android.os.IBinder
+import android.os.Parcel
+import android.util.Base64
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.security.KeyPairGenerator
+import org.matrix.TEESimulator.interception.core.BinderInterceptor
+import org.matrix.TEESimulator.logging.SystemLogger
+
+/**
+ * Forges healthy `com.tencent.soter.soterserver.ISoterService` (Layer A: AIDL over
+ * `/dev/binder`) replies from inside the injected soterserver app process, so the SOTER
+ * capability probe (春秋 / DuckDetector `SoterCapabilityProbe`) reads `available = true`
+ * / `damaged = false` on a bootloader-unlocked device whose SOTER TA can no longer use
+ * its factory ATTK. Replaces the external SoterFixer loop + the Hail freeze.
+ *
+ * Unconditional by design: the forge decision never consults `ConfigurationManager` /
+ * `target.txt` (Phase 10 spec §Decision, gate G). It is mounted by the SOTER process
+ * supervisor (10.B/10.W) against the ISoterService binder, so `onPreTransact` only sees
+ * transactions on that binder — matching the raw transaction code is therefore enough.
+ *
+ * Diagnostics follow the module's standard three-layer capture (debug-gated, per-UID
+ * NDJSON via [SystemLogger]; see `logging/SystemLogger.kt`): a `tx` line for every
+ * transaction ([logTransaction]), the raw inbound request parcel, and the raw forged
+ * reply wire. Capture is scoped to targeted UIDs (`isUidLogged`) exactly like the
+ * keystore lane — it does NOT make the forge conditional; the forge still fires for all.
+ *
+ * Transaction codes are HARDCODED 1..13 in AIDL declaration order, NOT resolved via
+ * [org.matrix.TEESimulator.interception.keystore.InterceptorUtils.getTransactCode]: the
+ * shipped soterserver build is R8/ProGuard obfuscated — there is no `ISoterService$Stub`
+ * class and no `TRANSACTION_*` fields (recon 2026-06-26, `a$a.smali` packed-switch). The
+ * codes are fixed by Tencent's `ISoterService.aidl` and are obfuscation-independent.
+ *
+ * Scope boundary (10.A vs 10.M): the seven primitive-returning methods are fully forged
+ * here. The six parcelable-returning methods emit the correct AIDL envelope + the
+ * recon-verified `writeToParcel` field order; 10.M fills the payloads with
+ * detector-satisfying values — a framed SOTER pubkey envelope the SDK's
+ * `retrieveJsonFromExportedData` parses to a non-null `SoterPubKeyModel`, a non-zero sign
+ * session, and a 256-byte signature.
+ */
+object SoterServiceInterceptor : BinderInterceptor() {
+
+    /** The surviving, obfuscation-stable interface identifier (used by the 10.B/10.W mount). */
+    const val DESCRIPTOR = "com.tencent.soter.soterserver.ISoterService"
+
+    // AIDL transaction codes = FIRST_CALL_TRANSACTION (1) + declaration index, verified
+    // against the obfuscated `a$a.smali` packed-switch (recon 2026-06-26). NOTE the 5/6
+    // order: removeAuthKey precedes getAuthKey in the real .aidl (the spec prose had it
+    // reversed). Comments record each method's return shape.
+    private const val TX_GENERATE_APP_SECURE_KEY = 1 // int
+    private const val TX_GET_APP_SECURE_KEY = 2 // SoterExportResult
+    private const val TX_HAS_ASK_ALREADY = 3 // boolean
+    private const val TX_GENERATE_AUTH_KEY = 4 // int
+    private const val TX_REMOVE_AUTH_KEY = 5 // int   (NOT getAuthKey)
+    private const val TX_GET_AUTH_KEY = 6 // SoterExportResult   (NOT removeAuthKey)
+    private const val TX_REMOVE_ALL_AUTH_KEY = 7 // int
+    private const val TX_HAS_AUTH_KEY = 8 // boolean
+    private const val TX_INIT_SIGH = 9 // SoterSessionResult   (sic: Tencent's spelling)
+    private const val TX_FINISH_SIGN = 10 // SoterSignResult
+    private const val TX_GET_DEVICE_ID = 11 // SoterDeviceResult
+    private const val TX_GET_VERSION = 12 // int   (real service returns 1)
+    private const val TX_GET_EXTRA_PARAM = 13 // SoterExtraParam
+
+    /** SOTER success result code (`SoterCoreResult` ERR_OK). */
+    private const val SOTER_OK = 0
+
+    /** finishSign signature length the probe expects. */
+    private const val SIGNATURE_LEN = 256
+
+    /** `cpu_id` placeholder in the export envelope; the local probe never reads its value
+     *  (the backend pins the real per-`cpu_id` ATTK, which the forge cannot satisfy). */
+    private const val CPU_ID = "0000000000000000"
+
+    /** Code -> Tencent method name, for the `tx` diagnostic line. Names from the recon decompile. */
+    private val methodNames =
+        mapOf(
+            TX_GENERATE_APP_SECURE_KEY to "generateAppSecureKey",
+            TX_GET_APP_SECURE_KEY to "getAppSecureKey",
+            TX_HAS_ASK_ALREADY to "hasAskAlready",
+            TX_GENERATE_AUTH_KEY to "generateAuthKey",
+            TX_REMOVE_AUTH_KEY to "removeAuthKey",
+            TX_GET_AUTH_KEY to "getAuthKey",
+            TX_REMOVE_ALL_AUTH_KEY to "removeAllAuthKey",
+            TX_HAS_AUTH_KEY to "hasAuthKey",
+            TX_INIT_SIGH to "initSigh",
+            TX_FINISH_SIGN to "finishSign",
+            TX_GET_DEVICE_ID to "getDeviceId",
+            TX_GET_VERSION to "getVersion",
+            TX_GET_EXTRA_PARAM to "getExtraParam",
+        )
+
+    /** The codes this interceptor forges; consumed by the supervisor's registration (10.B/10.W). */
+    val interceptedCodes: IntArray = methodNames.keys.toIntArray()
+
+    /**
+     * Payload of [SoterExportResult.exportData] for getAppSecureKey (txn 2) and getAuthKey
+     * (txn 6). The detector's capability probe gates `damaged=false` on
+     * `SoterCore.getApp/AuthKeyModel() != null`, and the SDK's `retrieveJsonFromExportedData`
+     * (`SoterCoreBase`) returns a non-null `SoterPubKeyModel` only when this exact framing
+     * parses: `[4-byte LITTLE-ENDIAN json length][UTF-8 json][signature bytes]`. A
+     * non-empty-but-unframed blob throws inside the SDK and is read as `damaged` silently.
+     * The JSON parser swallows every exception, so only the framing is load-bearing; the
+     * `pub_key` is a genuine RSA-2048 SubjectPublicKeyInfo so a probe that base64/X.509-parses
+     * the field locally still succeeds. Lazily built — keygen runs once, off the mount path.
+     */
+    private val exportBlob: ByteArray by lazy { buildExportBlob() }
+
+    /** getDeviceId (txn 11) payload — well-formed, non-empty; the probe never parses it. */
+    private val deviceIdBlob = "TEESIM-SOTER-0001".toByteArray(Charsets.UTF_8)
+
+    /** finishSign (txn 10) signature payload — [SIGNATURE_LEN] bytes. */
+    private val signatureBlob = ByteArray(SIGNATURE_LEN)
+
+    private fun buildExportBlob(): ByteArray {
+        val pubKey =
+            runCatching {
+                    val generator = KeyPairGenerator.getInstance("RSA").apply { initialize(2048) }
+                    Base64.encodeToString(generator.generateKeyPair().public.encoded, Base64.NO_WRAP)
+                }
+                .getOrDefault("")
+        val json =
+            """{"pub_key":"$pubKey","counter":0,"cpu_id":"$CPU_ID","uid":0}"""
+                .toByteArray(Charsets.UTF_8)
+        val lengthPrefix = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(json.size).array()
+        return lengthPrefix + json + signatureBlob
+    }
+
+    override fun onPreTransact(
+        txId: Long,
+        target: IBinder,
+        code: Int,
+        flags: Int,
+        callingUid: Int,
+        callingPid: Int,
+        data: Parcel,
+    ): TransactionResult {
+        val method = methodNames[code]
+        if (method == null) {
+            // Not an ISoterService method we forge — record it as observed, then pass through.
+            logTransaction(txId, "code=$code", callingUid, callingPid, skipPost = true)
+            return TransactionResult.ContinueAndSkipPost
+        }
+        logTransaction(txId, method, callingUid, callingPid)
+        captureRequest(callingUid, txId, method, data)
+
+        return when (code) {
+            // Primitive returns — fully forged here.
+            TX_GENERATE_APP_SECURE_KEY,
+            TX_GENERATE_AUTH_KEY,
+            TX_REMOVE_AUTH_KEY,
+            TX_REMOVE_ALL_AUTH_KEY -> forgedReply(callingUid, txId, method) { writeInt(SOTER_OK) }
+            TX_GET_VERSION -> forgedReply(callingUid, txId, method) { writeInt(1) }
+            TX_HAS_ASK_ALREADY,
+            TX_HAS_AUTH_KEY -> forgedReply(callingUid, txId, method) { writeInt(1) } // boolean true
+
+            // Parcelable returns — correct envelope + recon field order, payloads filled (10.M).
+            TX_GET_APP_SECURE_KEY,
+            TX_GET_AUTH_KEY ->
+                forgedReply(callingUid, txId, method) {
+                    writeInt(1) // non-null marker
+                    writeInt(SOTER_OK) // resultCode
+                    writeByteArray(exportBlob) // exportData — framed SOTER pubkey envelope
+                    writeInt(exportBlob.size) // exportDataLength
+                }
+            TX_INIT_SIGH ->
+                forgedReply(callingUid, txId, method) {
+                    writeInt(1)
+                    writeLong(1L) // session — any non-zero satisfies the probe
+                    writeInt(SOTER_OK) // resultCode — probe requires == 0 (SoterCapabilityProbe.kt:107)
+                }
+            TX_FINISH_SIGN ->
+                forgedReply(callingUid, txId, method) {
+                    writeInt(1)
+                    writeInt(SOTER_OK) // resultCode — finishSign throws on != 0
+                    writeByteArray(signatureBlob) // exportData = signature
+                    writeInt(signatureBlob.size) // exportDataLength
+                }
+            TX_GET_DEVICE_ID ->
+                forgedReply(callingUid, txId, method) {
+                    writeInt(1)
+                    writeInt(SOTER_OK) // resultCode
+                    writeByteArray(deviceIdBlob) // exportData = device id
+                    writeInt(deviceIdBlob.size) // exportDataLength
+                }
+            TX_GET_EXTRA_PARAM ->
+                forgedReply(callingUid, txId, method) {
+                    writeInt(1)
+                    writeValue("optical") // SoterExtraParam.result = fingerprint sensor type
+                }
+
+            // Unreachable: method != null means code is one of the 13 above.
+            else -> TransactionResult.ContinueAndSkipPost
+        }
+    }
+
+    /** Snapshots the inbound request parcel to the per-UID NDJSON plane (debug + targeted only). */
+    private fun captureRequest(uid: Int, txId: Long, method: String, data: Parcel) {
+        if (!SystemLogger.isUidLogged(uid)) return
+        runCatching { data.marshall() }
+            .onSuccess { raw ->
+                SystemLogger.uidLogRaw(uid, txId, "$method-request", "len=${raw.size}", raw)
+            }
+    }
+
+    /**
+     * Builds an AIDL reply (`writeNoException()` then [body]) and snapshots its wire bytes to the
+     * per-UID NDJSON plane before handing it to the native hook. Parcelable bodies write their own
+     * `writeInt(1)` non-null marker; the native hook recycles the parcel after use.
+     */
+    private fun forgedReply(
+        uid: Int,
+        txId: Long,
+        method: String,
+        body: Parcel.() -> Unit,
+    ): TransactionResult.OverrideReply {
+        val reply = Parcel.obtain()
+        reply.writeNoException()
+        reply.body()
+        if (SystemLogger.isUidLogged(uid)) {
+            runCatching { reply.marshall() }
+                .onSuccess { raw ->
+                    SystemLogger.uidLogRaw(uid, txId, "$method-reply", "len=${raw.size}", raw)
+                }
+        }
+        return TransactionResult.OverrideReply(reply)
+    }
+}

app/src/main/java/org/matrix/TEESimulator/logging/AttestationDossier.kt

@@ -0,0 +1,74 @@
+package org.matrix.TEESimulator.logging
+
+import android.hardware.security.keymint.Tag
+import android.system.keystore2.Authorization
+import java.security.cert.Certificate
+import java.security.cert.X509Certificate
+import org.matrix.TEESimulator.attestation.AttestationPatcher
+import org.matrix.TEESimulator.config.ConfigurationManager
+import org.matrix.TEESimulator.util.AndroidDeviceUtils
+
+/**
+ * Assembles the per-UID "attestation dossier": for a targeted app, the full decoded attestation we
+ * actually hand it, the identity of every certificate in the returned chain, and the source of each
+ * device value that fed that attestation. Emitting all three where a chain is produced turns "the
+ * app rejects us" into a field-by-field record that can be diffed against a genuine TEE.
+ */
+object AttestationDossier {
+
+    /**
+     * Records the dossier for [chain] under [uid], tagged with the [path] that produced it
+     * (`FORGE-rust`, `FORGE-bouncycastle`, or `PATCH`). No-op for untargeted UIDs and release
+     * builds; the expensive decoding is skipped entirely when the UID is out of scope.
+     */
+    fun log(uid: Int, txId: Long, path: String, chain: List<Certificate>) {
+        if (!SystemLogger.isUidLogged(uid)) return
+        val leaf = chain.firstOrNull() as? X509Certificate
+        val extension =
+            leaf?.let { AttestationPatcher.formatAttestationExtension(it) }
+                ?: "<no attestation extension>"
+        SystemLogger.uidLog(uid, txId, "attest", "path=$path depth=${chain.size} $extension")
+        SystemLogger.uidLog(uid, txId, "keybox", "file=${ConfigurationManager.getKeyboxFileForUid(uid)}")
+        SystemLogger.uidLog(uid, txId, "chain", AttestationPatcher.formatCertChain(chain))
+        SystemLogger.uidLog(uid, txId, "chain-verify", AttestationPatcher.formatChainVerification(chain))
+        SystemLogger.uidLog(uid, txId, "props", AndroidDeviceUtils.describeSources(uid))
+    }
+
+    /**
+     * Records the *shape* of the emitted authorization list — count, ordered tags, and per-auth
+     * securityLevel. This is the exact surface the duck detector's generate-mode parcel fingerprint
+     * stride-walks, so logging it readably lets a "fingerprint" detection be compared against the
+     * known genuine-TEE shape without decoding the marshalled reply offline.
+     */
+    fun logAuthShape(uid: Int, txId: Long, authorizations: Array<Authorization>?) {
+        if (!SystemLogger.isUidLogged(uid)) return
+        val auths = authorizations ?: return
+        val shape = auths.joinToString(",") { "${tagName(it.keyParameter.tag)}/${it.securityLevel}" }
+        SystemLogger.uidLog(uid, txId, "auth-shape", "n=${auths.size} [$shape]")
+    }
+
+    /** Names the authorization tags that occur in generate-mode replies; others render as numbers. */
+    private fun tagName(tag: Int): String =
+        when (tag) {
+            Tag.PURPOSE -> "PURPOSE"
+            Tag.ALGORITHM -> "ALGORITHM"
+            Tag.KEY_SIZE -> "KEY_SIZE"
+            Tag.DIGEST -> "DIGEST"
+            Tag.PADDING -> "PADDING"
+            Tag.EC_CURVE -> "EC_CURVE"
+            Tag.RSA_PUBLIC_EXPONENT -> "RSA_PUBLIC_EXPONENT"
+            Tag.NO_AUTH_REQUIRED -> "NO_AUTH_REQUIRED"
+            Tag.ORIGIN -> "ORIGIN"
+            Tag.OS_VERSION -> "OS_VERSION"
+            Tag.OS_PATCHLEVEL -> "OS_PATCHLEVEL"
+            Tag.VENDOR_PATCHLEVEL -> "VENDOR_PATCHLEVEL"
+            Tag.BOOT_PATCHLEVEL -> "BOOT_PATCHLEVEL"
+            Tag.CREATION_DATETIME -> "CREATION_DATETIME"
+            Tag.ROOT_OF_TRUST -> "ROOT_OF_TRUST"
+            Tag.USER_ID -> "USER_ID"
+            Tag.USAGE_COUNT_LIMIT -> "USAGE_COUNT_LIMIT"
+            Tag.UNLOCKED_DEVICE_REQUIRED -> "UNLOCKED_DEVICE_REQUIRED"
+            Tag.ACTIVE_DATETIME -> "ACTIVE_DATETIME"
+            else -> "tag${tag and 0x0FFFFFFF}"
+        }
+}

app/src/main/java/org/matrix/TEESimulator/logging/KeyMintParameterLogger.kt

@@ -69,12 +69,23 @@ object KeyMintParameterLogger {
             .associate { field -> (field.get(null) as Int) to field.name }
     }
 
-    /**
+    /** Logs a single KeyParameter to the shared debug stream (used for un-scoped param dumps). */
-     * Logs a single KeyParameter in a formatted, readable way.
-     *
-     * @param param The KeyParameter to log.
-     */
     fun logParameter(param: KeyParameter) {
+        SystemLogger.debug("KeyParam: ${describe(param)}")
+    }
+
+    /** Logs a single KeyParameter onto a targeted UID's diagnostic plane as a `param` record. */
+    fun logParameter(uid: Int, txId: Long, param: KeyParameter) {
+        SystemLogger.uidLog(uid, txId, "param", describe(param))
+    }
+
+    /**
+     * Formats a single KeyParameter into a readable `tag | Value` string. Shared by both
+     * [logParameter] overloads so the two logging planes render parameters identically.
+     *
+     * @param param The KeyParameter to format.
+     */
+    private fun describe(param: KeyParameter): String {
         val tagName = tagNames[param.tag] ?: "UNKNOWN_TAG"
         val value = param.value
         val formattedValue: String =
@@ -110,7 +121,7 @@ object KeyMintParameterLogger {
                 else -> "<raw>"
             } ?: "Unknown Value"
 
-        SystemLogger.debug("KeyParam: %-25s | Value: %s".format(tagName, formattedValue))
+        return "%-25s | Value: %s".format(tagName, formattedValue)
     }
 
     private fun ByteArray.toReadableString(): String {

app/src/main/java/org/matrix/TEESimulator/logging/SystemLogger.kt

@@ -1,42 +1,95 @@
 package org.matrix.TEESimulator.logging
 
+import android.util.Base64
 import android.util.Log
+import java.io.BufferedWriter
+import java.io.File
+import java.io.FileWriter
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
+import java.util.concurrent.atomic.AtomicLong
+import org.json.JSONObject
 import org.matrix.TEESimulator.BuildConfig
+import org.matrix.TEESimulator.config.ConfigurationManager
 
 /**
  * A centralized logging utility for the TEESimulator application. This object provides a consistent
  * logging tag and format for all application logs, making it easier to filter and debug in Logcat.
+ *
+ * Includes a rate limiter that caps logd syscalls during binder stress to prevent thread pool
+ * contention. The first [RATE_LIMIT_BURST] messages per [RATE_LIMIT_WINDOW_MS] window are logged
+ * normally; subsequent messages are suppressed and a summary is emitted when the window resets.
  */
 object SystemLogger {
-    // The tag used for all log messages from this application.
+    @PublishedApi internal const val TAG = "TEESimulator"
-    private const val TAG = "TEESimulator"
 
-    private val isDebugBuild = BuildConfig.DEBUG
+    @PublishedApi internal val isDebugBuild = BuildConfig.DEBUG
+
+    // Rate limiter: allow BURST messages per WINDOW, then suppress until window resets.
+    private const val RATE_LIMIT_BURST = 15
+    private const val RATE_LIMIT_WINDOW_MS = 1000L
+    private val windowStart = AtomicLong(System.currentTimeMillis())
+    private val windowCount = AtomicInteger(0)
+    private val suppressedCount = AtomicInteger(0)
 
     /**
-     * Logs a debug message. Use this for fine-grained information that is useful for debugging.
+     * Returns true if this message should be emitted. Resets the window if expired and emits a
-     *
+     * suppression summary for the previous window.
-     * @param message The message to log.
      */
+    @PublishedApi
+    internal fun acquireLogPermit(): Boolean {
+        val now = System.currentTimeMillis()
+        val start = windowStart.get()
+        if (now - start > RATE_LIMIT_WINDOW_MS) {
+            // Window expired: reset and emit suppression summary if needed.
+            if (windowStart.compareAndSet(start, now)) {
+                val suppressed = suppressedCount.getAndSet(0)
+                windowCount.set(1) // this call counts as #1 in the new window
+                if (suppressed > 0) {
+                    Log.i(
+                        TAG,
+                        "[rate-limit] suppressed $suppressed log messages in previous window",
+                    )
+                }
+                return true
+            }
+        }
+        val count = windowCount.incrementAndGet()
+        if (count <= RATE_LIMIT_BURST) return true
+        suppressedCount.incrementAndGet()
+        return false
+    }
+
+    /** Logs a debug message. Use this for fine-grained information that is useful for debugging. */
     fun debug(message: String) {
+        if (!isDebugBuild) return
+        if (!acquireLogPermit()) return
         Log.d(TAG, message)
     }
 
-    /**
+    /** Lazy debug: lambda only evaluates if message will be logged. */
-     * Logs an informational message. Use this to report major application lifecycle events.
+    inline fun debug(message: () -> String) {
-     *
+        if (!isDebugBuild) return
-     * @param message The message to log.
+        if (!acquireLogPermit()) return
-     */
+        Log.d(TAG, message())
+    }
+
+    /** Logs an informational message. Use this to report major application lifecycle events. */
     fun info(message: String) {
+        if (!acquireLogPermit()) return
         Log.i(TAG, message)
     }
 
-    /**
+    /** Lazy info: lambda only evaluates if message will be logged. */
-     * Logs a warning message. Use this to report unexpected but non-fatal issues.
+    inline fun info(message: () -> String) {
-     *
+        if (!acquireLogPermit()) return
-     * @param message The message to log.
+        Log.i(TAG, message())
-     * @param throwable An optional exception to log with the message.
+    }
-     */
+
+    /** Logs a warning message. Warnings are never rate-limited. */
     fun warning(message: String, throwable: Throwable? = null) {
         if (throwable != null) {
             Log.w(TAG, message, throwable)
@@ -45,13 +98,7 @@ object SystemLogger {
         }
     }
 
-    /**
+    /** Logs an error message. Errors are never rate-limited. */
-     * Logs an error message. Use this to report fatal errors or exceptions that disrupt
-     * functionality.
-     *
-     * @param message The message to log.
-     * @param throwable An optional exception to log with the message.
-     */
     fun error(message: String, throwable: Throwable? = null) {
         if (throwable != null) {
             Log.e(TAG, message, throwable)
@@ -63,11 +110,163 @@ object SystemLogger {
     /**
      * Logs a verbose message. This level is for highly detailed logs that are generally not needed
      * unless tracking a very specific issue.
-     *
-     * @param message The message to log.
      */
     fun verbose(message: String) {
         if (!isDebugBuild) return
+        if (!acquireLogPermit()) return
         Log.v(TAG, message)
     }
+
+    /** Lazy verbose: lambda only evaluates if message will be logged. */
+    inline fun verbose(message: () -> String) {
+        if (!isDebugBuild) return
+        if (!acquireLogPermit()) return
+        Log.v(TAG, message())
+    }
+
+    inline fun trace(message: () -> String) {
+        if (!isDebugBuild) return
+        Log.w(TAG, message())
+    }
+
+    // --- UID-keyed diagnostic plane (debug builds only) -------------------------------------
+
+    /**
+     * True when [uid] should receive deep, per-UID diagnostic logging: a debug build AND the UID is
+     * targeted in `target.txt`. This is the single scope gate for the diagnostic plane; it reuses
+     * the existing activation set, so no new configuration surface is introduced.
+     */
+    fun isUidLogged(uid: Int): Boolean = isDebugBuild && !ConfigurationManager.shouldSkipUid(uid)
+
+    /** Resolves a UID to its primary package name for log labelling, falling back to `uid:N`. */
+    private fun label(uid: Int): String =
+        ConfigurationManager.getPackagesForUid(uid).firstOrNull() ?: "uid:$uid"
+
+    /**
+     * Emits one structured diagnostic record for a targeted [uid]. The human form
+     * `[<pkg> tx=<txId>] <event>: <detail>` goes to logcat; the file sink receives one NDJSON object
+     * per line under that UID's own file. In-scope records bypass the global rate limiter: a
+     * targeted app's traffic is already volume-bounded, and dropping a line mid-probe would corrupt
+     * the very trace we are trying to read. No-op for untargeted UIDs and in release builds.
+     */
+    fun uidLog(uid: Int, txId: Long?, event: String, detail: String) {
+        if (!isUidLogged(uid)) return
+        val correlation = txId?.let { " tx=$it" } ?: ""
+        Log.d(TAG, "[${label(uid)}$correlation] $event: $detail")
+        runCatching { uidWriter(uid).append(jsonRecord(uid, txId, event, detail, null)) }
+    }
+
+    /** Lazy [uidLog]: [detail] is only built for targeted UIDs in debug builds. */
+    inline fun uidLog(uid: Int, txId: Long?, event: String, detail: () -> String) {
+        if (!isUidLogged(uid)) return
+        uidLog(uid, txId, event, detail())
+    }
+
+    /**
+     * [uidLog] plus the exact wire bytes that produced the event, base64 (NO_WRAP) in a `raw_b64`
+     * field. This is the structured replacement for the per-call `.bin` parcel dumps: one NDJSON
+     * line on the per-UID file instead of a fresh undecodable file per transaction, with the raw
+     * parcel still recoverable for offline parsers.
+     */
+    fun uidLogRaw(uid: Int, txId: Long?, event: String, detail: String, raw: ByteArray) {
+        if (!isUidLogged(uid)) return
+        val correlation = txId?.let { " tx=$it" } ?: ""
+        Log.d(TAG, "[${label(uid)}$correlation] $event: $detail (raw ${raw.size}B)")
+        runCatching {
+            val encoded = Base64.encodeToString(raw, Base64.NO_WRAP)
+            uidWriter(uid).append(jsonRecord(uid, txId, event, detail, encoded))
+        }
+    }
+
+    /**
+     * External-storage root for every debug diagnostic. `/data/media/0/TEESimulator` is the
+     * in-namespace backing path the keystore domain can reach; a normal file manager sees the same
+     * files at `/sdcard/TEESimulator`. Release builds never write here and purge it on boot
+     * (App.purgeDebugDiagnostics). The domain reaches it via a debug-only media_rw_data_file
+     * sepolicy grant, and service.sh pre-creates the directory.
+     */
+    const val DIAGNOSTIC_DIR = "/data/media/0/TEESimulator"
+
+    private val uidLogDir = File(DIAGNOSTIC_DIR)
+    private const val UID_LOG_MAX_BYTES = 4L * 1024 * 1024
+    private val uidWriters = ConcurrentHashMap<Int, UidLogFile>()
+
+    private val recordClock =
+        DateTimeFormatter.ofPattern("MM-dd HH:mm:ss.SSS").withZone(ZoneId.systemDefault())
+
+    private fun jsonRecord(
+        uid: Int,
+        txId: Long?,
+        event: String,
+        detail: String,
+        rawB64: String?,
+    ): String =
+        JSONObject()
+            .apply {
+                put("ts", recordClock.format(Instant.now()))
+                put("uid", uid)
+                put("pkg", label(uid))
+                txId?.let { put("tx", it) }
+                put("event", event)
+                put("detail", detail)
+                rawB64?.let { put("raw_b64", it) }
+            }
+            .toString()
+
+    private fun uidWriter(uid: Int): UidLogFile =
+        uidWriters.computeIfAbsent(uid) { key ->
+            UidLogFile(key, uidLogDir).also { file ->
+                val packages =
+                    ConfigurationManager.getPackagesForUid(key).joinToString().ifEmpty { "<unresolved>" }
+                runCatching {
+                    file.append(jsonRecord(key, null, "session", "packages=[$packages]", null))
+                }
+            }
+        }
+
+    /**
+     * Append-only NDJSON sink for a single UID at `<logDir>/teesim-uid-<uid>.ndjson`, rotated once
+     * to `.ndjson.1` at [UID_LOG_MAX_BYTES]; one JSON object per line. Writes are synchronised
+     * because the keystore binder pool is multi-threaded, and every operation is wrapped so a
+     * logging fault can never propagate into the daemon. Created only on the debug-gated path.
+     */
+    private class UidLogFile(uid: Int, private val logDir: File) {
+        private val primary = File(logDir, "teesim-uid-$uid.ndjson")
+        private val rotated = File(logDir, "teesim-uid-$uid.ndjson.1")
+        private var writer: BufferedWriter? = null
+        private var size = 0L
+
+        @Synchronized
+        fun append(jsonLine: String) {
+            runCatching {
+                val out = writer ?: open()
+                out.write(jsonLine)
+                out.write("\n")
+                out.flush()
+                size += jsonLine.length + 1
+                if (size >= UID_LOG_MAX_BYTES) rotate()
+            }
+        }
+
+        private fun open(): BufferedWriter {
+            logDir.mkdirs()
+            val out = BufferedWriter(FileWriter(primary, /* append = */ true))
+            writer = out
+            size = primary.length()
+            return out
+        }
+
+        private fun rotate() {
+            runCatching {
+                writer?.flush()
+                writer?.close()
+            }
+            writer = null
+            runCatching {
+                if (rotated.exists()) rotated.delete()
+                primary.renameTo(rotated)
+            }
+            size = 0L
+        }
+    }
 }

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,8 @@ import org.matrix.TEESimulator.logging.SystemLogger
  */
 object CertificateGenerator {
 
+    private const val UNDEFINED_NOT_AFTER = 253402300799000L
+
     /**
      * Generates a software-based cryptographic key pair.
      *
@@ -49,7 +50,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}"
@@ -88,33 +92,54 @@ object CertificateGenerator {
                 "Attestation challenge exceeds length limit (${challenge.size} > ${AttestationConstants.CHALLENGE_LENGTH_LIMIT})"
             )
 
-        return runCatching {
+        return try {
-                val keybox = getKeyboxForAlgorithm(uid, params.algorithm)
+            // AOSP ta/src/keys.rs:451-478: no challenge + no attestKey = self-signed, depth 1
-
+            if (challenge == null && attestKeyAlias == null) {
-                // Determine the signing key and issuer. If an attestKey is provided, use it.
+                SystemLogger.trace {
-                // Otherwise, fall back to the root key from the keybox.
+                    "[certgen] no-challenge key: self-signed, depth=1, purposes=${params.purpose}"
-                val (signingKey, issuer) =
-                    if (attestKeyAlias != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
-                        getAttestationKeyInfo(uid, attestKeyAlias)?.let { it.first to it.second }
-                            ?: (keybox.keyPair to getIssuerFromKeybox(keybox))
-                    } else {
-                        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
                 }
+                return listOf(buildSelfSignedCertificate(subjectKeyPair, params))
             }
-            .onFailure { SystemLogger.error("Failed to generate certificate chain.", it) }
+
-            .getOrNull()
+            val keybox = getKeyboxForAlgorithm(uid, params.algorithm)
+
+            val wantsAttestKey =
+                attestKeyAlias != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+            val attestKeyInfo =
+                if (wantsAttestKey) getAttestationKeyInfo(uid, attestKeyAlias) else null
+
+            // When the caller designates an attest key, the leaf MUST be signed by it and returned
+            // alone (the caller appends the attest key's own chain). Re-rooting under the keybox
+            // here instead yields a self-rooted leaf that, concatenated with the attest key chain,
+            // double-roots and fails verification (WRONG_PUBLIC_KEY_TYPE). Refuse rather than emit
+            // a
+            // broken chain.
+            if (wantsAttestKey && attestKeyInfo == null) {
+                SystemLogger.error(
+                    "Designated attest key '$attestKeyAlias' not found for uid $uid; refusing to " +
+                        "emit a keybox-rooted leaf that would break the caller's chain."
+                )
+                return null
+            }
+
+            val (signingKey, issuer) =
+                attestKeyInfo?.let { it.first to it.second }
+                    ?: (keybox.keyPair to getIssuerFromKeybox(keybox))
+
+            val leafCert =
+                buildCertificate(subjectKeyPair, signingKey, issuer, params, uid, securityLevel)
+
+            if (attestKeyInfo != 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
+        }
     }
 
     /**
@@ -128,27 +153,24 @@ object CertificateGenerator {
         params: KeyMintAttestation,
         securityLevel: Int,
     ): Pair<KeyPair, List<Certificate>>? {
-        return runCatching {
+        return try {
-                SystemLogger.info(
+            SystemLogger.info("Generating new attested key pair for alias: '$alias' (UID: $uid)")
-                    "Generating new attested key pair for alias: '$alias' (UID: $uid)"
+            val newKeyPair =
-                )
+                generateSoftwareKeyPair(params)
-                val newKeyPair =
+                    ?: throw Exception("Failed to generate underlying software key pair.")
-                    generateSoftwareKeyPair(params)
-                        ?: throw Exception("Failed to generate underlying software key pair.")
 
-                val chain =
+            val chain =
-                    generateCertificateChain(uid, newKeyPair, attestKeyAlias, params, securityLevel)
+                generateCertificateChain(uid, newKeyPair, attestKeyAlias, params, securityLevel)
-                        ?: throw Exception("Failed to generate certificate chain for new key pair.")
+                    ?: throw Exception("Failed to generate certificate chain for new key pair.")
 
-                SystemLogger.info(
+            SystemLogger.info("Successfully generated new certificate chain for alias: '$alias'.")
-                    "Successfully generated new certificate chain for alias: '$alias'."
+            Pair(newKeyPair, chain)
-                )
+        } catch (e: android.os.ServiceSpecificException) {
-                Pair(newKeyPair, chain)
+            throw e
-            }
+        } catch (e: Exception) {
-            .onFailure {
+            SystemLogger.error("Failed to generate attested key pair for alias '$alias'.", e)
-                SystemLogger.error("Failed to generate attested key pair for alias '$alias'.", it)
+            null
-            }
+        }
-            .getOrNull()
     }
 
     fun getIssuerFromKeybox(keybox: KeyBox) =
@@ -162,8 +184,28 @@ object CertificateGenerator {
                 Algorithm.RSA -> "RSA"
                 else -> throw IllegalArgumentException("Unsupported algorithm ID: $algorithm")
             }
-        return KeyBoxManager.getAttestationKey(keyboxFile, algorithmName)
+        // Prefer the algorithm-matching keybox, but fall back to any usable key (EC preferred) when
-            ?: throw Exception("Could not load keybox for UID $uid and algorithm $algorithmName")
+        // none exists. An EC attestation key validly ECDSA-signs a leaf carrying an RSA subject key,
+        // so an EC-only keybox can still root an RSA forge. Without this fallback an RSA ATTEST_KEY
+        // request on an EC-only keybox throws -75 and the caller's chain never roots ("unknown
+        // certificate"). Mirrors the patch path's fail-safe
+        // (AttestationPatcher.getKeyboxForUidAndAlgorithm) and the RSA-leaf-under-EC-keybox handling
+        // in commit e6d5e4d.
+        val matched = KeyBoxManager.getAttestationKey(keyboxFile, algorithmName)
+        val keybox =
+            matched
+                ?: KeyBoxManager.getAnyAttestationKey(keyboxFile)
+                ?: throw android.os.ServiceSpecificException(
+                    -75, // ATTESTATION_KEYS_NOT_PROVISIONED
+                    "No usable attestation key in $keyboxFile",
+                )
+        // Surface which keybox actually signs the forge, so an EC-only-keybox fallback (an RSA leaf
+        // rooted under the EC key) is visible on the per-UID plane instead of silent.
+        SystemLogger.uidLog(uid, null, "keybox-pick") {
+            "req=$algorithmName ${if (matched != null) "matched" else "fellback-to-any"} " +
+                "signer=${getIssuerFromKeybox(keybox)}"
+        }
+        return keybox
     }
 
     /** Retrieves the key pair and issuer name for a given attestation key alias. */
@@ -176,6 +218,15 @@ object CertificateGenerator {
             val certChain = CertificateHelper.getCertificateChain(keyInfo.response)
             if (!certChain.isNullOrEmpty()) {
                 val issuer = X509CertificateHolder(certChain[0].encoded).subject
+                // The leaf is signed by keyInfo.keyPair, but the caller verifies it against the
+                // public key of the chain getCertChain(attestKeyAlias) serves. A two-rooted EC chain
+                // (DATA_TOO_LARGE_FOR_MODULUS) is exactly those two disagreeing on algorithm; log
+                // both at the signing instant so an EC attest-key run pins the mismatched edge.
+                SystemLogger.uidLog(uid, null, "attest-sign") {
+                    "alias=$attestKeyAlias signerKey=${keyInfo.keyPair?.public?.algorithm} " +
+                        "servedLeafKey=${certChain[0].publicKey.algorithm} " +
+                        "depth=${certChain.size} issuer=$issuer"
+                }
                 Pair(keyInfo.keyPair, issuer)
             } else {
                 null
@@ -192,14 +243,16 @@ object CertificateGenerator {
     private fun buildKeyUsageFromPurposes(purposes: List<Int>): Int {
         var bits = 0
         for (purpose in purposes) {
-            bits = bits or when (purpose) {
+            bits =
-                KeyPurpose.SIGN -> KeyUsage.digitalSignature
+                bits or
-                KeyPurpose.DECRYPT -> KeyUsage.dataEncipherment
+                    when (purpose) {
-                KeyPurpose.WRAP_KEY -> KeyUsage.keyEncipherment
+                        KeyPurpose.SIGN -> KeyUsage.digitalSignature
-                KeyPurpose.AGREE_KEY -> KeyUsage.keyAgreement
+                        KeyPurpose.DECRYPT -> KeyUsage.dataEncipherment
-                KeyPurpose.ATTEST_KEY -> KeyUsage.keyCertSign
+                        KeyPurpose.WRAP_KEY -> KeyUsage.keyEncipherment
-                else -> 0
+                        KeyPurpose.AGREE_KEY -> KeyUsage.keyAgreement
-            }
+                        KeyPurpose.ATTEST_KEY -> KeyUsage.keyCertSign
+                        else -> 0
+                    }
         }
         return bits
     }
@@ -213,17 +266,16 @@ 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 =
+        val notBefore = params.certificateNotBefore ?: Date(0)
-            (signingKeyPair.public as? X509Certificate)?.notAfter
+        val notAfter = params.certificateNotAfter ?: Date(UNDEFINED_NOT_AFTER)
-                ?: Date(System.currentTimeMillis() + 31536000000L)
 
         val builder =
             JcaX509v3CertificateBuilder(
                 issuer,
                 params.certificateSerial ?: BigInteger.ONE,
-                params.certificateNotBefore ?: Date(),
+                notBefore,
-                params.certificateNotAfter ?: leafNotAfter,
+                notAfter,
                 subject,
                 subjectKeyPair.public,
             )
@@ -233,16 +285,21 @@ object CertificateGenerator {
         if (keyUsageBits != 0) {
             builder.addExtension(Extension.keyUsage, true, KeyUsage(keyUsageBits))
         }
-        // Add our custom, simulated attestation extension.
+        if (params.attestationChallenge != null) {
-        builder.addExtension(
+            builder.addExtension(
-            AttestationBuilder.buildAttestationExtension(params, uid, securityLevel)
+                AttestationBuilder.buildAttestationExtension(params, uid, securityLevel)
-        )
+            )
+        }
 
         val signerAlgorithm =
-            when (params.algorithm) {
+            when (signingKeyPair.private.algorithm) {
-                Algorithm.EC -> "SHA256withECDSA"
+                "EC",
-                Algorithm.RSA -> "SHA256withRSA"
+                "ECDSA" -> "SHA256withECDSA"
-                else -> throw IllegalArgumentException("Unsupported algorithm: ${params.algorithm}")
+                "RSA" -> "SHA256withRSA"
+                else ->
+                    throw IllegalArgumentException(
+                        "Unsupported signing key: ${signingKeyPair.private.algorithm}"
+                    )
             }
         val contentSigner =
             JcaContentSignerBuilder(signerAlgorithm)
@@ -251,4 +308,44 @@ object CertificateGenerator {
 
         return JcaX509CertificateConverter().getCertificate(builder.build(contentSigner))
     }
+
+    // AOSP ta/src/keys.rs:452-478, ta/src/cert.rs:111-114
+    private fun buildSelfSignedCertificate(
+        keyPair: KeyPair,
+        params: KeyMintAttestation,
+    ): Certificate {
+        val subject = params.certificateSubject ?: X500Name("CN=Android Keystore Key")
+        val notBefore = params.certificateNotBefore ?: Date(0)
+        val notAfter = params.certificateNotAfter ?: Date(UNDEFINED_NOT_AFTER)
+
+        val builder =
+            JcaX509v3CertificateBuilder(
+                subject,
+                params.certificateSerial ?: BigInteger.ONE,
+                notBefore,
+                notAfter,
+                subject,
+                keyPair.public,
+            )
+
+        val keyUsageBits = buildKeyUsageFromPurposes(params.purpose)
+        if (keyUsageBits != 0) {
+            builder.addExtension(Extension.keyUsage, true, KeyUsage(keyUsageBits))
+        }
+
+        val signerAlgorithm =
+            when (keyPair.private.algorithm) {
+                "EC",
+                "ECDSA" -> "SHA256withECDSA"
+                "RSA" -> "SHA256withRSA"
+                else ->
+                    throw IllegalArgumentException("Unsupported key: ${keyPair.private.algorithm}")
+            }
+        val contentSigner =
+            JcaContentSignerBuilder(signerAlgorithm)
+                .setProvider(BouncyCastleProvider.PROVIDER_NAME)
+                .build(keyPair.private)
+
+        return JcaX509CertificateConverter().getCertificate(builder.build(contentSigner))
+    }
 }

app/src/main/java/org/matrix/TEESimulator/pki/KeyBoxManager.kt

@@ -3,6 +3,7 @@ package org.matrix.TEESimulator.pki
 import android.security.keystore.KeyProperties
 import java.io.File
 import java.io.StringReader
+import java.security.cert.X509Certificate
 import java.security.interfaces.ECPrivateKey
 import java.security.interfaces.RSAPrivateKey
 import java.util.concurrent.ConcurrentHashMap
@@ -53,10 +54,38 @@ object KeyBoxManager {
         // If it's not in the cache, the `getOrPut` block is executed to parse and store it.
         val keyMap =
             keyStoreCache.getOrPut(keyStoreFileName) { parseKeyStoreFile(keyStoreFileName) }
-        SystemLogger.verbose(
+        val keyBox = keyMap[algorithm]
-            "Fetching attestation key in $keyStoreFileName with $algorithm algorithm."
+        if (keyBox != null) {
-        )
+            // Surface attestation cert serials on every fetch so a revoked/leaked keybox is
-        return keyMap[algorithm]
+            // obvious from logcat alone -- Google's CRL and Duck's "mass abuse" check both match
+            // by certificate serial (lowercase hex). Logged here rather than at parse time because
+            // the parse is cached and would emit at most once per boot.
+            val serials =
+                keyBox.certificates.joinToString(", ") { cert ->
+                    (cert as? X509Certificate)?.serialNumber?.toString(16) ?: "?"
+                }
+            SystemLogger.info(
+                "Using $algorithm keybox $keyStoreFileName; attestation cert serials (hex): $serials"
+            )
+        }
+        return keyBox
+    }
+
+    /**
+     * Retrieves any usable attestation key from a key store file, preferring EC.
+     *
+     * EC is the modern device-attestation key type and validly signs a leaf carrying either an EC
+     * or an RSA subject key. This is the fail-safe used when no algorithm-matching key exists, so
+     * patching can still re-root the chain under the keybox instead of leaking the device's real
+     * attestation.
+     *
+     * @param keyStoreFileName The name of the XML file (e.g., "keybox.xml").
+     * @return The preferred [KeyBox], or `null` if the file contains no usable key.
+     */
+    fun getAnyAttestationKey(keyStoreFileName: String): KeyBox? {
+        val keyMap =
+            keyStoreCache.getOrPut(keyStoreFileName) { parseKeyStoreFile(keyStoreFileName) }
+        return keyMap[KeyProperties.KEY_ALGORITHM_EC] ?: keyMap.values.firstOrNull()
     }
 
     /**

app/src/main/java/org/matrix/TEESimulator/pki/NativeCertGen.kt

@@ -45,6 +45,17 @@ data class CertGenConfig(
     val idManufacturer: ByteArray?,
     val idModel: ByteArray?,
     val idSecondImei: ByteArray?,
+    val activeDatetime: Long = -1L,
+    val originationExpireDatetime: Long = -1L,
+    val usageExpireDatetime: Long = -1L,
+    val usageCountLimit: Int = -1,
+    val callerNonce: Boolean = false,
+    val unlockedDeviceRequired: Boolean = false,
+    val noAuthRequired: Boolean = true,
+    // Diagnostic plane: the calling app UID keys the native log lines, and debugLogging mirrors the
+    // APK debug variant so the native extension dump is silent in release.
+    val uid: Int,
+    val debugLogging: Boolean,
 )
 
 object NativeCertGen {
@@ -62,7 +73,10 @@ object NativeCertGen {
             isAvailable = true
             SystemLogger.info("NativeCertGen: loaded libcertgen.so successfully")
         } catch (e: UnsatisfiedLinkError) {
-            SystemLogger.error("NativeCertGen: failed to load libcertgen.so, falling back to BouncyCastle", e)
+            SystemLogger.error(
+                "NativeCertGen: failed to load libcertgen.so, falling back to BouncyCastle",
+                e,
+            )
         }
     }
 
@@ -70,10 +84,6 @@ object NativeCertGen {
 
     private external fun initLogging(verbose: Boolean, logDir: String): Boolean
 
-    private external fun dumpLogs(): String?
-
-    fun dump(): String? = if (isAvailable) dumpLogs() else null
-
     fun parseNativeResult(bytes: ByteArray): Pair<KeyPair, List<Certificate>> {
         val buf = ByteBuffer.wrap(bytes).order(ByteOrder.BIG_ENDIAN)
 
@@ -104,11 +114,13 @@ object NativeCertGen {
             throw IllegalStateException("No certificates in native result")
         }
 
-        val algorithmName = when (certs[0].publicKey.algorithm) {
+        val algorithmName =
-            "EC" -> "EC"
+            when (certs[0].publicKey.algorithm) {
-            "RSA" -> "RSA"
+                "EC",
-            else -> certs[0].publicKey.algorithm
+                "ECDSA" -> "EC"
-        }
+                "RSA" -> "RSA"
+                else -> certs[0].publicKey.algorithm
+            }
         val keyFactory = KeyFactory.getInstance(algorithmName)
         val privateKey = keyFactory.generatePrivate(PKCS8EncodedKeySpec(pkBytes))
         val publicKey = certs[0].publicKey

app/src/main/java/org/matrix/TEESimulator/util/AndroidDeviceUtils.kt

@@ -1,6 +1,5 @@
 package org.matrix.TEESimulator.util
 
-import android.hardware.security.keymint.SecurityLevel
 import android.os.Build
 import android.os.SystemProperties
 import java.io.ByteArrayOutputStream
@@ -9,13 +8,16 @@ import java.io.FileInputStream
 import java.security.MessageDigest
 import java.time.LocalDate
 import java.util.concurrent.ThreadLocalRandom
+import javax.xml.parsers.DocumentBuilderFactory
 import org.bouncycastle.asn1.ASN1EncodableVector
 import org.bouncycastle.asn1.ASN1Integer
 import org.bouncycastle.asn1.DEROctetString
 import org.bouncycastle.asn1.DERSequence
 import org.matrix.TEESimulator.attestation.DeviceAttestationService
+import org.matrix.TEESimulator.config.BootStateManager
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.logging.SystemLogger
+import org.w3c.dom.Element
 
 /**
  * Provides utility functions for accessing Android system properties and device-specific
@@ -44,6 +46,7 @@ object AndroidDeviceUtils {
                 DeviceAttestationService.CachedAttestationData?.verifiedBootKey
             },
             expectedSize = 32,
+            recordSource = { bootKeySource = it },
         )
     }
 
@@ -61,9 +64,16 @@ object AndroidDeviceUtils {
                 DeviceAttestationService.CachedAttestationData?.verifiedBootHash
             },
             expectedSize = 32,
+            recordSource = { bootHashSource = it },
         )
     }
 
+    // Records which fallback tier supplied bootKey/bootHash so the diagnostic dossier can flag a
+    // random-fallback value — a real verifiedBootKey that resolves to random bytes is a textbook
+    // simulated-TEE tell. Populated by initializeBootProperty on first access.
+    @Volatile private var bootKeySource: String = "uninitialized"
+    @Volatile private var bootHashSource: String = "uninitialized"
+
     /**
      * Public function to explicitly trigger the initialization of the boot key and hash. Accessing
      * these properties here ensures they are set up before they might be needed elsewhere.
@@ -90,28 +100,39 @@ object AndroidDeviceUtils {
         propertyName: String,
         attestationValueProvider: () -> ByteArray?,
         expectedSize: Int,
+        recordSource: (String) -> Unit,
     ): ByteArray {
-        // 1. Attempt to get the value from the system property.
         getProperty(propertyName, expectedSize)?.let {
             SystemLogger.debug("Using $propertyName from system property: ${it.toHex()}")
+            recordSource("system-prop")
+            persistToFile(propertyName, it)
             return it
         }
 
-        // 2. Fallback to the value from a cached TEE attestation.
         try {
             attestationValueProvider()?.let {
                 SystemLogger.debug("Using $propertyName from TEE attestation: ${it.toHex()}")
-                setProperty(propertyName, it) // Persist for consistency
+                recordSource("tee-attestation")
+                setBootProperty(propertyName, it)
+                persistToFile(propertyName, it)
                 return it
             }
         } catch (e: Exception) {
             SystemLogger.error("Failed to get $propertyName from attestation.", e)
         }
 
-        // 3. As a final fallback, generate a random value.
+        readFromFile(propertyName, expectedSize)?.let {
+            SystemLogger.debug("Using $propertyName from persistent file: ${it.toHex()}")
+            recordSource("persistent-file")
+            setBootProperty(propertyName, it)
+            return it
+        }
+
         return generateRandomBytes(expectedSize).also {
             SystemLogger.debug("Using randomly generated $propertyName: ${it.toHex()}")
-            setProperty(propertyName, it)
+            recordSource("random-fallback")
+            setBootProperty(propertyName, it)
+            persistToFile(propertyName, it)
         }
     }
 
@@ -158,10 +179,64 @@ object AndroidDeviceUtils {
         }
     }
 
-    /** Generates a cryptographically random byte array of a specified length. */
+    private fun setBootProperty(name: String, bytes: ByteArray) {
+        if (!BootStateManager.shouldSpoofBootProps()) {
+            SystemLogger.info("Skipping system property '$name' because boot prop spoofing is disabled")
+            return
+        }
+        setProperty(name, bytes)
+    }
+
+    internal fun setProperty(name: String, value: String) {
+        try {
+            SystemLogger.debug("Setting system property '$name' to: $value")
+            val command = arrayOf("resetprop", name, value)
+            val process = Runtime.getRuntime().exec(command)
+            val exitCode = process.waitFor()
+
+            if (exitCode != 0) {
+                val errorOutput = process.errorStream.bufferedReader().readText()
+                SystemLogger.error(
+                    "resetprop for '$name' failed with exit code $exitCode: $errorOutput"
+                )
+            }
+        } catch (e: Exception) {
+            SystemLogger.error("Failed to set '$name' property via resetprop.", e)
+        }
+    }
+
     private fun generateRandomBytes(size: Int): ByteArray =
         ByteArray(size).also { ThreadLocalRandom.current().nextBytes(it) }
 
+    private val PERSIST_DIR = File("/data/adb/tricky_store")
+
+    private fun fileForProperty(propertyName: String): File =
+        when (propertyName) {
+            "ro.boot.vbmeta.digest" -> File(PERSIST_DIR, "boot_hash.bin")
+            "ro.boot.vbmeta.public_key_digest" -> File(PERSIST_DIR, "boot_key.bin")
+            else -> File(PERSIST_DIR, "${propertyName.replace('.', '_')}.bin")
+        }
+
+    private fun persistToFile(propertyName: String, bytes: ByteArray) {
+        try {
+            fileForProperty(propertyName).writeBytes(bytes)
+        } catch (e: Exception) {
+            SystemLogger.error("Failed to persist $propertyName to file.", e)
+        }
+    }
+
+    private fun readFromFile(propertyName: String, expectedSize: Int): ByteArray? {
+        return try {
+            val file = fileForProperty(propertyName)
+            if (!file.exists()) return null
+            val bytes = file.readBytes()
+            if (bytes.size == expectedSize) bytes else null
+        } catch (e: Exception) {
+            SystemLogger.error("Failed to read $propertyName from file.", e)
+            null
+        }
+    }
+
     // --- Patch Level Properties ---
 
     fun getPatchLevel(uid: Int): Int {
@@ -179,6 +254,23 @@ object AndroidDeviceUtils {
         return custom ?: getRealDevicePatchLevelInt("boot", isLong = true)
     }
 
+    /**
+     * Summarises, for a targeted [uid], the device values that feed attestation and where each came
+     * from. This is what exposes attested-versus-live mismatches: a random-fallback verifiedBootKey,
+     * a patch level overridden away from the live prop, or an OS version pulled from a stale cache.
+     */
+    fun describeSources(uid: Int): String {
+        val customPatchLevel = ConfigurationManager.getPatchLevelForUid(uid) != null
+        val osVersionSource =
+            if (DeviceAttestationService.CachedAttestationData?.osVersion != null) "cache" else "map"
+        return "osVersion=$osVersion(src=$osVersionSource) " +
+            "osPatch=${getPatchLevel(uid)} vendorPatch=${getVendorPatchLevelLong(uid)} " +
+            "bootPatch=${getBootPatchLevelLong(uid)} customPatchLevel=$customPatchLevel " +
+            "bootKey=${bootKey.toHex()}(src=$bootKeySource) " +
+            "bootHash=${bootHash.toHex()}(src=$bootHashSource) " +
+            "teeCacheData=${DeviceAttestationService.CachedAttestationData != null}"
+    }
+
     /**
      * Retrieves the definitive device patch level integer for a given component. This function
      * encapsulates the entire fallback chain and guarantees a non-null return.
@@ -244,7 +336,10 @@ object AndroidDeviceUtils {
             // Resolve from live system prop — matches what detectors see via getprop,
             // even when PIF has spoofed ro.build.version.security_patch via resetprop
             resolvedValue.equals("prop", ignoreCase = true) ->
-                parsePatchLevelValue(SystemProperties.get("ro.build.version.security_patch", ""), isLong)
+                parsePatchLevelValue(
+                    SystemProperties.get("ro.build.version.security_patch", ""),
+                    isLong,
+                )
             resolvedValue.equals("no", ignoreCase = true) -> DO_NOT_REPORT
             else -> parsePatchLevelValue(resolvedValue, isLong)
         }
@@ -295,7 +390,9 @@ object AndroidDeviceUtils {
                 6 -> { // YYYYMM
                     val year = normalized.substring(0, 4).toInt()
                     val month = normalized.substring(4, 6).toInt()
-                    if (isLong) year * 10000 + month * 100 + 1 else year * 100 + month
+                    // Synthesizing day=01 from YYYY-MM disagrees with real device bulletins;
+                    // propagate null so callers fall back to a YYYY-MM-DD source.
+                    if (isLong) null else year * 100 + month
                 }
                 else -> null
             }
@@ -342,34 +439,254 @@ object AndroidDeviceUtils {
             Build.VERSION_CODES.BAKLAVA to 400, // KeyMint 4.0
         )
 
+    /** AOSP-mandated attestation version for the running OS, or null when the SDK is unmapped. */
+    internal val aospAttestVersion: Int?
+        get() = attestVersionMap[Build.VERSION.SDK_INT]
+
     /**
-     * Retrieves the attestation version based on security level and OS version. StrongBox (level 2)
+     * Retrieves the attestation version for the given security level. A readable KeyMint VINTF
-     * requires version 300.
+     * declaration wins first, so local probes that compare the attested version against the
+     * device's manifest see a coherent pair. Otherwise the legacy chain applies: cached attestation
+     * data, then attestVersionMap[SDK_INT], then 400 as last resort.
      *
      * @param securityLevel The security level of the attestation (1 for TEE, 2 for StrongBox).
      * @return The appropriate attestation version number.
      */
     fun getAttestVersion(securityLevel: Int): Int {
-        // StrongBox security level requires an attestation version of at least 300.
+        vintfKeyMintVersion?.let { version ->
-        if (securityLevel == SecurityLevel.STRONGBOX) {
+            SystemLogger.debug(
-            return 300
+                "attestVersion=${version.attestationVersion} source=vintf securityLevel=$securityLevel"
+            )
+            return version.attestationVersion
         }
-        return DeviceAttestationService.CachedAttestationData?.attestVersion
+
-            ?: attestVersionMap[Build.VERSION.SDK_INT]
+        val cached = DeviceAttestationService.CachedAttestationData?.attestVersion
-            ?: 400 // Default to a recent version
+        val version =
+            cached ?: attestVersionMap[Build.VERSION.SDK_INT] ?: 400 // Default to a recent version
+        val source =
+            when {
+                cached != null -> "cache"
+                attestVersionMap.containsKey(Build.VERSION.SDK_INT) -> "map"
+                else -> "default"
+            }
+        SystemLogger.debug("attestVersion=$version source=$source securityLevel=$securityLevel")
+        SystemLogger.debug(
+            "vintf-version attest=$version keymaster=$version source=$source securityLevel=$securityLevel"
+        )
+        return version
     }
 
     /**
-     * Retrieves the Keymaster/KeyMint version based on the attestation version.
+     * Retrieves the Keymaster/KeyMint version. A readable KeyMint VINTF declaration is
+     * authoritative because recent local detectors compare the attested version directly against
+     * the manifest declaration.
      *
      * @param securityLevel The security level, used to determine the correct attestation version.
      * @return The appropriate Keymaster or KeyMint version number.
      */
     fun getKeymasterVersion(securityLevel: Int): Int {
-        val attestVersion = getAttestVersion(securityLevel)
+        vintfKeyMintVersion?.let { version ->
-        return if (attestVersion >= 100) attestVersion else 41 // Keymaster 4.1 for older versions
+            SystemLogger.debug(
+                "keymasterVersion=${version.keymasterVersion} source=vintf securityLevel=$securityLevel"
+            )
+            return version.keymasterVersion
+        }
+        return getAttestVersion(securityLevel)
     }
 
+    /**
+     * KeyMint/Keymaster version pair resolved from a device VINTF manifest. [attestationVersion] is
+     * the value written into the attestation record; [keymasterVersion] is the HAL version field.
+     * They coincide for AIDL KeyMint and diverge only for legacy HIDL Keymaster.
+     */
+    private data class VintfKeyMintVersion(
+        val attestationVersion: Int,
+        val keymasterVersion: Int,
+        val sourcePath: String,
+    )
+
+    /**
+     * KeyMint version derived from the device's VINTF manifests, or null when none is readable.
+     * Resolved lazily so the manifest scan happens once, off the attestation hot path.
+     */
+    private val vintfKeyMintVersion: VintfKeyMintVersion? by lazy {
+        readVintfKeyMintVersion().also { version ->
+            if (version != null) {
+                SystemLogger.info(
+                    "Using KeyMint version from VINTF: attestation=${version.attestationVersion}, " +
+                        "keymaster=${version.keymasterVersion}, source=${version.sourcePath}"
+                )
+            } else {
+                SystemLogger.debug(
+                    "No usable KeyMint VINTF declaration found; using attestation fallback"
+                )
+            }
+        }
+    }
+
+    private fun readVintfKeyMintVersion(): VintfKeyMintVersion? {
+        val files = linkedMapOf<String, File>()
+
+        VINTF_MANIFEST_DIRS.forEach { path ->
+            val dir = File(path)
+            if (!dir.exists() || !dir.isDirectory) return@forEach
+            val listed =
+                runCatching {
+                        dir.listFiles { file ->
+                            file.isFile && file.name.endsWith(".xml", ignoreCase = true)
+                        }
+                    }
+                    .getOrElse { throwable ->
+                        SystemLogger.debug("Unable to list VINTF dir $path: ${throwable.message}")
+                        null
+                    }
+            listed?.forEach { file -> files[file.absolutePath] = file }
+        }
+
+        VINTF_MANIFEST_FILES.forEach { path ->
+            val file = File(path)
+            if (file.exists() && file.isFile) {
+                files[file.absolutePath] = file
+            }
+        }
+
+        return files.values
+            .flatMap { file ->
+                runCatching { parseKeyMintVersions(file) }
+                    .getOrElse { throwable ->
+                        SystemLogger.debug(
+                            "Unable to parse KeyMint VINTF ${file.absolutePath}: ${throwable.message}"
+                        )
+                        emptyList()
+                    }
+            }
+            .maxByOrNull { it.attestationVersion }
+    }
+
+    private fun parseKeyMintVersions(file: File): List<VintfKeyMintVersion> {
+        val document = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(file)
+        val root = document.documentElement ?: return emptyList()
+
+        return directChildElements(root, "hal").flatMap { hal ->
+            val halName = directChildTexts(hal, "name").firstOrNull().orEmpty()
+            val versions = directChildTexts(hal, "version")
+            val fqnames = directChildTexts(hal, "fqname")
+            val interfaces =
+                directChildElements(hal, "interface").associate { interfaceElement ->
+                    val name = directChildTexts(interfaceElement, "name").firstOrNull().orEmpty()
+                    val instances = directChildTexts(interfaceElement, "instance").toSet()
+                    name to instances
+                }
+
+            when (halName) {
+                KEYMINT_HAL_NAME ->
+                    if (hasDefaultInstance(fqnames, interfaces, KEYMINT_INTERFACE_NAME)) {
+                        versions.mapNotNull { version ->
+                            version
+                                .toIntOrNull()
+                                ?.takeIf { it > 0 }
+                                ?.let { aidlVersion ->
+                                    val attestationVersion = aidlVersion * 100
+                                    VintfKeyMintVersion(
+                                        attestationVersion = attestationVersion,
+                                        keymasterVersion = attestationVersion,
+                                        sourcePath = file.absolutePath,
+                                    )
+                                }
+                        }
+                    } else {
+                        emptyList()
+                    }
+                KEYMASTER_HAL_NAME ->
+                    if (hasDefaultInstance(fqnames, interfaces, KEYMASTER_INTERFACE_NAME)) {
+                        (versions.flatMap(::expandHidlVersions) +
+                                fqnames.mapNotNull(::versionFromFqname))
+                            .distinct()
+                            .mapNotNull { version ->
+                                expectedLegacyVersions(version)?.let { expected ->
+                                    VintfKeyMintVersion(
+                                        attestationVersion = expected.second,
+                                        keymasterVersion = expected.first,
+                                        sourcePath = file.absolutePath,
+                                    )
+                                }
+                            }
+                    } else {
+                        emptyList()
+                    }
+                else -> emptyList()
+            }
+        }
+    }
+
+    private fun directChildElements(parent: Element, tagName: String): List<Element> = buildList {
+        val children = parent.childNodes
+        for (index in 0 until children.length) {
+            val child = children.item(index)
+            if (child is Element && child.tagName == tagName) {
+                add(child)
+            }
+        }
+    }
+
+    private fun directChildTexts(parent: Element, tagName: String): List<String> =
+        directChildElements(parent, tagName)
+            .map { it.textContent.trim() }
+            .filter { it.isNotEmpty() }
+
+    private fun hasDefaultInstance(
+        fqnames: List<String>,
+        interfaces: Map<String, Set<String>>,
+        interfaceName: String,
+    ): Boolean =
+        fqnames.any { fqname ->
+            fqname.substringAfter("::", fqname).substringBefore("/") == interfaceName &&
+                fqname.substringAfter("/", "") == DEFAULT_INSTANCE
+        } || interfaces[interfaceName]?.contains(DEFAULT_INSTANCE) == true
+
+    private fun versionFromFqname(fqname: String): String? =
+        FQNAME_VERSION_REGEX.find(fqname)?.groupValues?.getOrNull(1)
+
+    private fun expectedLegacyVersions(version: String): Pair<Int, Int>? =
+        when (version) {
+            "3.0" -> 3 to 2
+            "4.0" -> 4 to 3
+            "4.1" -> 41 to 4
+            else -> null
+        }
+
+    private fun expandHidlVersions(version: String): List<String> {
+        val range = HIDL_VERSION_RANGE_REGEX.matchEntire(version) ?: return listOf(version)
+        val major = range.groupValues[1]
+        val firstMinor = range.groupValues[2].toInt()
+        val lastMinor = range.groupValues[3].toInt()
+        return (firstMinor..lastMinor).map { minor -> "$major.$minor" }
+    }
+
+    private val VINTF_MANIFEST_DIRS =
+        listOf(
+            "/system/etc/vintf/manifest",
+            "/system_ext/etc/vintf/manifest",
+            "/product/etc/vintf/manifest",
+            "/vendor/etc/vintf/manifest",
+            "/odm/etc/vintf/manifest",
+        )
+    private val VINTF_MANIFEST_FILES =
+        listOf(
+            "/system/etc/vintf/manifest.xml",
+            "/system_ext/etc/vintf/manifest.xml",
+            "/product/etc/vintf/manifest.xml",
+            "/vendor/etc/vintf/manifest.xml",
+            "/odm/etc/vintf/manifest.xml",
+        )
+    private const val KEYMINT_HAL_NAME = "android.hardware.security.keymint"
+    private const val KEYMASTER_HAL_NAME = "android.hardware.keymaster"
+    private const val KEYMINT_INTERFACE_NAME = "IKeyMintDevice"
+    private const val KEYMASTER_INTERFACE_NAME = "IKeymasterDevice"
+    private const val DEFAULT_INSTANCE = "default"
+    private val FQNAME_VERSION_REGEX = Regex("^@([0-9]+(?:\\.[0-9]+)?)::")
+    private val HIDL_VERSION_RANGE_REGEX = Regex("^([0-9]+)\\.([0-9]+)-([0-9]+)$")
+
     // --- APEX and Module Hash Properties ---
 
     // Minimal protobuf parser for apex_manifest.pb (field 1: name, field 2: version)
@@ -463,11 +780,12 @@ object AndroidDeviceUtils {
 
     val moduleHash: ByteArray by lazy {
         DeviceAttestationService.CachedAttestationData?.moduleHash
+            ?.also { SystemLogger.debug { "module-hash source=cache hash=${it.toHex().take(8)}" } }
+            ?: supplementaryModuleHash()?.also {
+                SystemLogger.debug { "module-hash source=framework-api hash=${it.toHex().take(8)}" }
+            }
             ?: runCatching {
-                    data class ModuleEntry(
+                    data class ModuleEntry(val nameEncoded: ByteArray, val fullEncoded: ByteArray)
-                        val nameEncoded: ByteArray,
-                        val fullEncoded: ByteArray,
-                    )
 
                     val modules =
                         apexInfos.map { (packageName, versionCode) ->
@@ -500,12 +818,38 @@ object AndroidDeviceUtils {
 
                     MessageDigest.getInstance("SHA-256").digest(finalDerSet)
                 }
+                .onSuccess {
+                    SystemLogger.debug { "module-hash source=rederive hash=${it.toHex().take(8)}" }
+                }
+                .onFailure { SystemLogger.debug { "module-hash source=zero hash=00000000" } }
                 .getOrElse {
                     SystemLogger.error("Failed to compute module hash.", it)
                     ByteArray(32)
                 }
     }
 
+    /**
+     * Reads the module-hash DER pre-image straight from the framework's own KeyStoreManager and
+     * SHA-256's it, so the value byte-matches what a verifier derives from the same
+     * getSupplementaryAttestationInfo call. Returns null on any failure (e.g. the API is
+     * unreachable from this process) so the caller falls back to local re-derivation.
+     */
+    private fun supplementaryModuleHash(): ByteArray? =
+        runCatching {
+                // @SystemApi surface added in Android 16, absent from the compile SDK, so reflect.
+                val managerClass = Class.forName("android.security.keystore.KeyStoreManager")
+                val manager = managerClass.getMethod("getInstance").invoke(null)
+                // MODULE_HASH is the KeyMint tag (TagType.BYTES | 724 = 0x900002D4), read from the
+                // framework so it matches the verifier's argument exactly.
+                val moduleHashTag = managerClass.getField("MODULE_HASH").getInt(null)
+                val derPreImage =
+                    managerClass
+                        .getMethod("getSupplementaryAttestationInfo", Int::class.java)
+                        .invoke(manager, moduleHashTag) as ByteArray
+                MessageDigest.getInstance("SHA-256").digest(derPreImage)
+            }
+            .getOrNull()
+
     private fun compareByteArrays(a: ByteArray, b: ByteArray): Int {
         val length = minOf(a.size, b.size)
         for (i in 0 until length) {

app/src/main/java/org/matrix/TEESimulator/util/AndroidPermissionUtils.kt

@@ -0,0 +1,77 @@
+package org.matrix.TEESimulator.util
+
+import android.annotation.SuppressLint
+import android.content.Context
+import android.content.pm.PackageManager
+import org.matrix.TEESimulator.logging.SystemLogger
+
+object AndroidPermissionUtils {
+
+    @SuppressLint("PrivateApi", "DiscouragedPrivateApi")
+    private fun getGlobalContext(): Context? {
+        return try {
+            // 1. Get the hidden ActivityThread class via reflection
+            val activityThreadClass = Class.forName("android.app.ActivityThread")
+
+            // 2. Invoke the static currentActivityThread() method
+            val currentActivityThreadMethod =
+                activityThreadClass.getDeclaredMethod("currentActivityThread")
+            currentActivityThreadMethod.isAccessible = true
+            val activityThread = currentActivityThreadMethod.invoke(null)
+
+            if (activityThread == null) {
+                SystemLogger.warning(
+                    "Reflection: ActivityThread.currentActivityThread() returned null"
+                )
+                return null
+            }
+
+            // 3. Try to get the application context
+            val getApplicationMethod = activityThreadClass.getDeclaredMethod("getApplication")
+            getApplicationMethod.isAccessible = true
+            val application = getApplicationMethod.invoke(activityThread) as? Context
+
+            if (application != null) return application
+
+            // 4. Fallback to getSystemContext() if application is null (often happens in
+            // system_server)
+            val getSystemContextMethod = activityThreadClass.getDeclaredMethod("getSystemContext")
+            getSystemContextMethod.isAccessible = true
+            getSystemContextMethod.invoke(activityThread) as? Context
+        } catch (e: Exception) {
+            SystemLogger.error("Reflection failed to get global context for permission check", e)
+            null
+        }
+    }
+
+    /** Core permission check. */
+    fun hasPermission(uid: Int, permission: String): Boolean {
+        val context =
+            getGlobalContext()
+                ?: run {
+                    SystemLogger.warning(
+                        "AndroidPermissionUtils: Context is null, failing permission check safely."
+                    )
+                    return false
+                }
+
+        val result = context.checkPermission(permission, -1, uid)
+        return result == PackageManager.PERMISSION_GRANTED
+    }
+
+    fun hasDeviceAttestationPermission(uid: Int): Boolean {
+        return hasPermission(uid, "android.permission.READ_PRIVILEGED_PHONE_STATE")
+    }
+
+    fun hasUniqueIdAttestationPermission(uid: Int): Boolean {
+        return hasPermission(uid, "android.permission.REQUEST_UNIQUE_ID_ATTESTATION")
+    }
+
+    fun hasManageUsersPermission(uid: Int): Boolean {
+        return hasPermission(uid, "android.permission.MANAGE_USERS")
+    }
+
+    fun hasDumpPermission(uid: Int): Boolean {
+        return hasPermission(uid, "android.permission.DUMP")
+    }
+}

app/src/main/java/org/matrix/TEESimulator/util/Extensions.kt

@@ -7,10 +7,7 @@ package org.matrix.TEESimulator.util
  * @return A new string with each line individually trimmed.
  */
 fun String.trimLines(): String =
-    this.trim()
+    this.trim().lines().filter { !it.trim().startsWith("<!--") }.joinToString("\n") { it.trim() }
-        .lines()
-        .filter { !it.trim().startsWith("<!--") }
-        .joinToString("\n") { it.trim() }
 
 /**
  * Converts a ByteArray to its hexadecimal string representation.

app/src/main/java/org/matrix/TEESimulator/util/TeeLatencySimulator.kt

@@ -0,0 +1,64 @@
+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
+
+object TeeLatencySimulator {
+
+    private val rng = SecureRandom()
+
+    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
+
+    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(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)
+    }
+
+    private fun sampleBaseCryptoDelay(algorithm: Int): Double {
+        val (mu, sigma) =
+            when (algorithm) {
+                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)
+    }
+
+    private fun sampleLogNormal(mu: Double, sigma: Double): Double {
+        return exp(mu + sigma * rng.nextGaussian())
+    }
+
+    private fun sampleExponential(mean: Double): Double {
+        var u = rng.nextDouble()
+        while (u == 0.0) u = rng.nextDouble()
+        return -mean * ln(u)
+    }
+}

module/action.sh

@@ -2,10 +2,59 @@
 MODDIR=${0%/*}
 CONFIG_DIR=/data/adb/tricky_store
 
+. "$MODDIR/action_i18n.sh"
+
+confirm() {
+    # Sample getevent in 1s bursts; a piped stream block-buffers and misses
+    # a single key-press before the timeout.
+    deadline=$(( $(date +%s) + 10 ))
+    while [ "$(date +%s)" -lt "$deadline" ]; do
+        events=$(/system/bin/timeout 1 /system/bin/getevent -l 2>/dev/null)
+        case "$events" in
+            *KEY_VOLUMEUP*)   return 0 ;;
+            *KEY_VOLUMEDOWN*) return 1 ;;
+        esac
+    done
+    return 1
+}
+
+# Debug builds ship diag.sh, adding a one-tap log export before the destructive clear-keys action.
+if [ -f "$MODDIR/diag.sh" ]; then
+    . "$MODDIR/diag.sh"
+    echo " "
+    echo "  📦 Export diagnostic logs to /sdcard/Download?"
+    echo "  🔊  Vol-Up = export logs"
+    echo "  🔉  Vol-Down = skip to clear keys"
+    echo " "
+    if confirm; then
+        diag_export
+        exit 0
+    fi
+fi
+
+echo "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo "  ⚠️  $(_msg confirm_header)"
+echo "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+echo " "
+echo "  $(_msg confirm_warning_1)"
+echo "  $(_msg confirm_warning_2)"
+echo " "
+echo "  🔊  $(_msg confirm_vol_up)"
+echo "  🔉  $(_msg confirm_vol_down)"
+echo " "
+
+if ! confirm; then
+    echo " "
+    echo "  ❌ $(_msg confirm_cancelled)"
+    exit 0
+fi
+
 if [ -d "$CONFIG_DIR/persistent_keys" ]; then
     rm -rf "$CONFIG_DIR/persistent_keys"
     mkdir -p "$CONFIG_DIR/persistent_keys"
-    echo "Persistent key storage cleared"
+    echo " "
+    echo "  ✅ $(_msg confirm_cleared)"
 else
-    echo "No persistent key storage found"
+    echo " "
+    echo "  ℹ️  $(_msg confirm_not_found)"
 fi

module/action_i18n.sh

@@ -0,0 +1,255 @@
+ACTION_LANG="en"
+_detect_lang() {
+    local raw
+    raw=$(getprop persist.sys.locale 2>/dev/null)
+    [ -z "$raw" ] && raw=$(getprop ro.product.locale 2>/dev/null)
+    [ -z "$raw" ] && raw=$(getprop ro.system.locale 2>/dev/null)
+    local code=$(printf '%s' "$raw" | sed 's/_/-/g')
+    case "$code" in
+        zh-Hans*|zh-CN*) code="zh-CN" ;;
+        zh-Hant*|zh-TW*|zh-HK*) code="zh-TW" ;;
+        pt-BR*) code="pt-BR" ;;
+        pt*) code="pt-BR" ;;
+        es-ES*|es*) code="es-ES" ;;
+        *-*) code="${code%%-*}" ;;
+    esac
+    case "$code" in
+        ar|az|bn|de|el|es-ES|fa|fr|id|it|ja|ko|pl|pt-BR|ru|th|tl|tr|uk|vi|zh-CN|zh-TW) ACTION_LANG="$code" ;;
+    esac
+}
+_detect_lang
+
+_msg() {
+    case "$ACTION_LANG" in
+    zh-CN) case "$1" in
+        confirm_header)     echo "清除持久化密钥存储" ;;
+        confirm_warning_1)  echo "这将删除所有缓存的证明密钥。" ;;
+        confirm_warning_2)  echo "使用证明的应用将在下次使用时重新注册。" ;;
+        confirm_vol_up)     echo "音量+ = 确认清除" ;;
+        confirm_vol_down)   echo "音量- = 取消（10秒后默认）" ;;
+        confirm_cancelled)  echo "已取消 - 密钥已保留" ;;
+        confirm_cleared)    echo "持久化密钥存储已清除" ;;
+        confirm_not_found)  echo "未找到持久化密钥存储" ;;
+    esac ;;
+    zh-TW) case "$1" in
+        confirm_header)     echo "清除持久化金鑰儲存" ;;
+        confirm_warning_1)  echo "這將刪除所有快取的證明金鑰。" ;;
+        confirm_warning_2)  echo "使用證明的應用程式將在下次使用時重新註冊。" ;;
+        confirm_vol_up)     echo "音量+ = 確認清除" ;;
+        confirm_vol_down)   echo "音量- = 取消（10秒後預設）" ;;
+        confirm_cancelled)  echo "已取消 - 金鑰已保留" ;;
+        confirm_cleared)    echo "持久化金鑰儲存已清除" ;;
+        confirm_not_found)  echo "未找到持久化金鑰儲存" ;;
+    esac ;;
+    ja) case "$1" in
+        confirm_header)     echo "永続キーストレージを消去" ;;
+        confirm_warning_1)  echo "キャッシュされた証明キーをすべて削除します。" ;;
+        confirm_warning_2)  echo "証明を使用するアプリは次回使用時に再登録されます。" ;;
+        confirm_vol_up)     echo "音量+ = 消去を確認" ;;
+        confirm_vol_down)   echo "音量- = キャンセル（10秒後デフォルト）" ;;
+        confirm_cancelled)  echo "キャンセルされました - キーは保持されます" ;;
+        confirm_cleared)    echo "永続キーストレージを消去しました" ;;
+        confirm_not_found)  echo "永続キーストレージが見つかりません" ;;
+    esac ;;
+    ko) case "$1" in
+        confirm_header)     echo "영구 키 저장소 지우기" ;;
+        confirm_warning_1)  echo "캐시된 모든 증명 키를 삭제합니다." ;;
+        confirm_warning_2)  echo "증명을 사용하는 앱은 다음 사용 시 재등록됩니다." ;;
+        confirm_vol_up)     echo "볼륨+ = 지우기 확인" ;;
+        confirm_vol_down)   echo "볼륨- = 취소 (10초 후 기본값)" ;;
+        confirm_cancelled)  echo "취소됨 - 키 유지됨" ;;
+        confirm_cleared)    echo "영구 키 저장소가 지워졌습니다" ;;
+        confirm_not_found)  echo "영구 키 저장소를 찾을 수 없습니다" ;;
+    esac ;;
+    ru) case "$1" in
+        confirm_header)     echo "Очистить постоянное хранилище ключей" ;;
+        confirm_warning_1)  echo "Это удалит все кэшированные ключи аттестации." ;;
+        confirm_warning_2)  echo "Приложения, использующие аттестацию, перерегистрируются при следующем использовании." ;;
+        confirm_vol_up)     echo "Громкость+ = Подтвердить очистку" ;;
+        confirm_vol_down)   echo "Громкость- = Отмена (по умолчанию через 10с)" ;;
+        confirm_cancelled)  echo "Отменено - ключи сохранены" ;;
+        confirm_cleared)    echo "Постоянное хранилище ключей очищено" ;;
+        confirm_not_found)  echo "Постоянное хранилище ключей не найдено" ;;
+    esac ;;
+    de) case "$1" in
+        confirm_header)     echo "Persistenten Schlüsselspeicher löschen" ;;
+        confirm_warning_1)  echo "Dies löscht alle zwischengespeicherten Attestierungsschlüssel." ;;
+        confirm_warning_2)  echo "Apps mit Attestierung registrieren sich bei der nächsten Nutzung neu." ;;
+        confirm_vol_up)     echo "Laut+ = Löschen bestätigen" ;;
+        confirm_vol_down)   echo "Leise- = Abbrechen (Standard nach 10s)" ;;
+        confirm_cancelled)  echo "Abgebrochen - Schlüssel beibehalten" ;;
+        confirm_cleared)    echo "Persistenter Schlüsselspeicher gelöscht" ;;
+        confirm_not_found)  echo "Kein persistenter Schlüsselspeicher gefunden" ;;
+    esac ;;
+    fr) case "$1" in
+        confirm_header)     echo "Effacer le stockage de clés persistant" ;;
+        confirm_warning_1)  echo "Ceci supprime toutes les clés d'attestation en cache." ;;
+        confirm_warning_2)  echo "Les apps utilisant l'attestation se réinscriront à la prochaine utilisation." ;;
+        confirm_vol_up)     echo "Vol+ = Confirmer l'effacement" ;;
+        confirm_vol_down)   echo "Vol- = Annuler (par défaut après 10s)" ;;
+        confirm_cancelled)  echo "Annulé - clés conservées" ;;
+        confirm_cleared)    echo "Stockage de clés persistant effacé" ;;
+        confirm_not_found)  echo "Aucun stockage de clés persistant trouvé" ;;
+    esac ;;
+    es-ES) case "$1" in
+        confirm_header)     echo "Borrar almacenamiento persistente de claves" ;;
+        confirm_warning_1)  echo "Esto elimina todas las claves de atestación en caché." ;;
+        confirm_warning_2)  echo "Las apps que usan atestación se volverán a registrar en el próximo uso." ;;
+        confirm_vol_up)     echo "Vol+ = Confirmar borrado" ;;
+        confirm_vol_down)   echo "Vol- = Cancelar (predeterminado tras 10s)" ;;
+        confirm_cancelled)  echo "Cancelado - claves conservadas" ;;
+        confirm_cleared)    echo "Almacenamiento persistente de claves borrado" ;;
+        confirm_not_found)  echo "No se encontró almacenamiento persistente de claves" ;;
+    esac ;;
+    pt-BR) case "$1" in
+        confirm_header)     echo "Limpar armazenamento persistente de chaves" ;;
+        confirm_warning_1)  echo "Isso exclui todas as chaves de atestação em cache." ;;
+        confirm_warning_2)  echo "Apps que usam atestação serão re-registrados no próximo uso." ;;
+        confirm_vol_up)     echo "Vol+ = Confirmar limpeza" ;;
+        confirm_vol_down)   echo "Vol- = Cancelar (padrão após 10s)" ;;
+        confirm_cancelled)  echo "Cancelado - chaves preservadas" ;;
+        confirm_cleared)    echo "Armazenamento persistente de chaves limpo" ;;
+        confirm_not_found)  echo "Nenhum armazenamento persistente de chaves encontrado" ;;
+    esac ;;
+    it) case "$1" in
+        confirm_header)     echo "Cancella archivio chiavi persistente" ;;
+        confirm_warning_1)  echo "Questo elimina tutte le chiavi di attestazione in cache." ;;
+        confirm_warning_2)  echo "Le app che usano l'attestazione si re-registreranno al prossimo utilizzo." ;;
+        confirm_vol_up)     echo "Vol+ = Conferma cancellazione" ;;
+        confirm_vol_down)   echo "Vol- = Annulla (predefinito dopo 10s)" ;;
+        confirm_cancelled)  echo "Annullato - chiavi conservate" ;;
+        confirm_cleared)    echo "Archivio chiavi persistente cancellato" ;;
+        confirm_not_found)  echo "Nessun archivio chiavi persistente trovato" ;;
+    esac ;;
+    tr) case "$1" in
+        confirm_header)     echo "Kalıcı Anahtar Deposunu Temizle" ;;
+        confirm_warning_1)  echo "Bu, önbelleğe alınmış tüm doğrulama anahtarlarını siler." ;;
+        confirm_warning_2)  echo "Doğrulama kullanan uygulamalar bir sonraki kullanımda yeniden kaydolacak." ;;
+        confirm_vol_up)     echo "Ses+ = Temizlemeyi onayla" ;;
+        confirm_vol_down)   echo "Ses- = İptal (10sn sonra varsayılan)" ;;
+        confirm_cancelled)  echo "İptal edildi - anahtarlar korundu" ;;
+        confirm_cleared)    echo "Kalıcı anahtar deposu temizlendi" ;;
+        confirm_not_found)  echo "Kalıcı anahtar deposu bulunamadı" ;;
+    esac ;;
+    id) case "$1" in
+        confirm_header)     echo "Hapus Penyimpanan Kunci Persisten" ;;
+        confirm_warning_1)  echo "Ini menghapus semua kunci atestasi yang di-cache." ;;
+        confirm_warning_2)  echo "Aplikasi yang menggunakan atestasi akan mendaftar ulang saat digunakan." ;;
+        confirm_vol_up)     echo "Vol+ = Konfirmasi hapus" ;;
+        confirm_vol_down)   echo "Vol- = Batal (default setelah 10 detik)" ;;
+        confirm_cancelled)  echo "Dibatalkan - kunci dipertahankan" ;;
+        confirm_cleared)    echo "Penyimpanan kunci persisten dihapus" ;;
+        confirm_not_found)  echo "Penyimpanan kunci persisten tidak ditemukan" ;;
+    esac ;;
+    vi) case "$1" in
+        confirm_header)     echo "Xóa lưu trữ khóa cố định" ;;
+        confirm_warning_1)  echo "Thao tác này xóa tất cả khóa chứng thực được lưu cache." ;;
+        confirm_warning_2)  echo "Các ứng dụng dùng chứng thực sẽ đăng ký lại khi sử dụng tiếp theo." ;;
+        confirm_vol_up)     echo "Vol+ = Xác nhận xóa" ;;
+        confirm_vol_down)   echo "Vol- = Hủy (mặc định sau 10s)" ;;
+        confirm_cancelled)  echo "Đã hủy - giữ nguyên khóa" ;;
+        confirm_cleared)    echo "Đã xóa lưu trữ khóa cố định" ;;
+        confirm_not_found)  echo "Không tìm thấy lưu trữ khóa cố định" ;;
+    esac ;;
+    ar) case "$1" in
+        confirm_header)     echo "مسح تخزين المفاتيح الدائم" ;;
+        confirm_warning_1)  echo "يؤدي هذا إلى حذف جميع مفاتيح التصديق المخزنة مؤقتاً." ;;
+        confirm_warning_2)  echo "التطبيقات التي تستخدم التصديق ستعيد التسجيل في الاستخدام التالي." ;;
+        confirm_vol_up)     echo "رفع الصوت = تأكيد المسح" ;;
+        confirm_vol_down)   echo "خفض الصوت = إلغاء (افتراضي بعد 10 ثوانٍ)" ;;
+        confirm_cancelled)  echo "تم الإلغاء - تم الاحتفاظ بالمفاتيح" ;;
+        confirm_cleared)    echo "تم مسح تخزين المفاتيح الدائم" ;;
+        confirm_not_found)  echo "لم يتم العثور على تخزين مفاتيح دائم" ;;
+    esac ;;
+    th) case "$1" in
+        confirm_header)     echo "ล้างที่จัดเก็บคีย์ถาวร" ;;
+        confirm_warning_1)  echo "การดำเนินการนี้จะลบคีย์การรับรองที่แคชไว้ทั้งหมด" ;;
+        confirm_warning_2)  echo "แอปที่ใช้การรับรองจะลงทะเบียนใหม่ในการใช้งานครั้งถัดไป" ;;
+        confirm_vol_up)     echo "เพิ่มเสียง = ยืนยันการล้าง" ;;
+        confirm_vol_down)   echo "ลดเสียง = ยกเลิก (ค่าเริ่มต้นหลัง 10 วินาที)" ;;
+        confirm_cancelled)  echo "ยกเลิกแล้ว - คีย์ยังคงอยู่" ;;
+        confirm_cleared)    echo "ล้างที่จัดเก็บคีย์ถาวรแล้ว" ;;
+        confirm_not_found)  echo "ไม่พบที่จัดเก็บคีย์ถาวร" ;;
+    esac ;;
+    uk) case "$1" in
+        confirm_header)     echo "Очистити постійне сховище ключів" ;;
+        confirm_warning_1)  echo "Це видаляє всі кешовані ключі атестації." ;;
+        confirm_warning_2)  echo "Програми, що використовують атестацію, повторно зареєструються при наступному використанні." ;;
+        confirm_vol_up)     echo "Гучність+ = Підтвердити очищення" ;;
+        confirm_vol_down)   echo "Гучність- = Скасувати (за замовчуванням через 10с)" ;;
+        confirm_cancelled)  echo "Скасовано - ключі збережено" ;;
+        confirm_cleared)    echo "Постійне сховище ключів очищено" ;;
+        confirm_not_found)  echo "Постійне сховище ключів не знайдено" ;;
+    esac ;;
+    pl) case "$1" in
+        confirm_header)     echo "Wyczyść trwały magazyn kluczy" ;;
+        confirm_warning_1)  echo "To usuwa wszystkie buforowane klucze atestacji." ;;
+        confirm_warning_2)  echo "Aplikacje używające atestacji zarejestrują się ponownie przy następnym użyciu." ;;
+        confirm_vol_up)     echo "Głośność+ = Potwierdź czyszczenie" ;;
+        confirm_vol_down)   echo "Głośność- = Anuluj (domyślnie po 10s)" ;;
+        confirm_cancelled)  echo "Anulowano - klucze zachowane" ;;
+        confirm_cleared)    echo "Trwały magazyn kluczy wyczyszczony" ;;
+        confirm_not_found)  echo "Nie znaleziono trwałego magazynu kluczy" ;;
+    esac ;;
+    az) case "$1" in
+        confirm_header)     echo "Davamlı Açar Yaddaşını Təmizlə" ;;
+        confirm_warning_1)  echo "Bu, keşlənmiş bütün təsdiqləmə açarlarını silir." ;;
+        confirm_warning_2)  echo "Təsdiqləmədən istifadə edən tətbiqlər növbəti istifadədə yenidən qeydiyyatdan keçəcək." ;;
+        confirm_vol_up)     echo "Səs+ = Təmizləməni təsdiqlə" ;;
+        confirm_vol_down)   echo "Səs- = Ləğv et (10 saniyə sonra defolt)" ;;
+        confirm_cancelled)  echo "Ləğv edildi - açarlar saxlanıldı" ;;
+        confirm_cleared)    echo "Davamlı açar yaddaşı təmizləndi" ;;
+        confirm_not_found)  echo "Davamlı açar yaddaşı tapılmadı" ;;
+    esac ;;
+    bn) case "$1" in
+        confirm_header)     echo "স্থায়ী কী সংরক্ষণ পরিষ্কার করুন" ;;
+        confirm_warning_1)  echo "এটি সমস্ত ক্যাশড অ্যাটেস্টেশন কী মুছে ফেলে।" ;;
+        confirm_warning_2)  echo "অ্যাটেস্টেশন ব্যবহারকারী অ্যাপগুলি পরবর্তী ব্যবহারে পুনরায় নিবন্ধন করবে।" ;;
+        confirm_vol_up)     echo "ভলিউম+ = পরিষ্কার নিশ্চিত করুন" ;;
+        confirm_vol_down)   echo "ভলিউম- = বাতিল (১০ সেকেন্ডে ডিফল্ট)" ;;
+        confirm_cancelled)  echo "বাতিল করা হয়েছে - কী সংরক্ষিত" ;;
+        confirm_cleared)    echo "স্থায়ী কী সংরক্ষণ পরিষ্কার করা হয়েছে" ;;
+        confirm_not_found)  echo "কোনো স্থায়ী কী সংরক্ষণ পাওয়া যায়নি" ;;
+    esac ;;
+    el) case "$1" in
+        confirm_header)     echo "Εκκαθάριση Μόνιμου Αποθηκευτικού Χώρου Κλειδιών" ;;
+        confirm_warning_1)  echo "Διαγράφει όλα τα προσωρινά αποθηκευμένα κλειδιά πιστοποίησης." ;;
+        confirm_warning_2)  echo "Οι εφαρμογές που χρησιμοποιούν πιστοποίηση θα επανεγγραφούν στην επόμενη χρήση." ;;
+        confirm_vol_up)     echo "Ένταση+ = Επιβεβαίωση εκκαθάρισης" ;;
+        confirm_vol_down)   echo "Ένταση- = Ακύρωση (προεπιλογή μετά από 10 δευτ)" ;;
+        confirm_cancelled)  echo "Ακυρώθηκε - τα κλειδιά διατηρήθηκαν" ;;
+        confirm_cleared)    echo "Ο μόνιμος αποθηκευτικός χώρος κλειδιών εκκαθαρίστηκε" ;;
+        confirm_not_found)  echo "Δεν βρέθηκε μόνιμος αποθηκευτικός χώρος κλειδιών" ;;
+    esac ;;
+    fa) case "$1" in
+        confirm_header)     echo "پاک کردن ذخیره‌سازی دائمی کلید" ;;
+        confirm_warning_1)  echo "این کار همه کلیدهای تأیید کش‌شده را حذف می‌کند." ;;
+        confirm_warning_2)  echo "برنامه‌های استفاده‌کننده از تأیید در استفاده بعدی دوباره ثبت‌نام می‌کنند." ;;
+        confirm_vol_up)     echo "صدا+ = تأیید پاک کردن" ;;
+        confirm_vol_down)   echo "صدا- = لغو (پیش‌فرض پس از ۱۰ ثانیه)" ;;
+        confirm_cancelled)  echo "لغو شد - کلیدها حفظ شدند" ;;
+        confirm_cleared)    echo "ذخیره‌سازی دائمی کلید پاک شد" ;;
+        confirm_not_found)  echo "ذخیره‌سازی دائمی کلید یافت نشد" ;;
+    esac ;;
+    tl) case "$1" in
+        confirm_header)     echo "Burahin ang Persistent Key Storage" ;;
+        confirm_warning_1)  echo "Buburahin nito ang lahat ng naka-cache na attestation keys." ;;
+        confirm_warning_2)  echo "Magre-rehistro muli ang mga app na gumagamit ng attestation sa susunod na paggamit." ;;
+        confirm_vol_up)     echo "Vol+ = Kumpirmahin ang pagbura" ;;
+        confirm_vol_down)   echo "Vol- = Kanselahin (default pagkatapos ng 10s)" ;;
+        confirm_cancelled)  echo "Nakansela - napanatili ang mga key" ;;
+        confirm_cleared)    echo "Nabura ang persistent key storage" ;;
+        confirm_not_found)  echo "Walang nahanap na persistent key storage" ;;
+    esac ;;
+    *) case "$1" in
+        confirm_header)     echo "Clear Persistent Key Storage" ;;
+        confirm_warning_1)  echo "This deletes all cached attestation keys." ;;
+        confirm_warning_2)  echo "Apps using attestation will re-enroll on next use." ;;
+        confirm_vol_up)     echo "Vol+  = Confirm clear" ;;
+        confirm_vol_down)   echo "Vol-  = Cancel (default after 10s)" ;;
+        confirm_cancelled)  echo "Cancelled - keys preserved" ;;
+        confirm_cleared)    echo "Persistent key storage cleared" ;;
+        confirm_not_found)  echo "No persistent key storage found" ;;
+    esac ;;
+    esac
+}

module/changelog.md

@@ -1,18 +1,374 @@
+> [!NOTE]
+> The project is going through a heavy refactor at the moment, so public commits may lag behind for a while.
+
+---
+
+## TEESimulator-RS v6.0.1-307
+
+Fixes five gaps in the module's TEE key-operation and attestation emulation. Two of them fix crashes in real app crypto on a broken-TEE device: any app using an AndroidKeyStore HMAC key or an RSA-OAEP-SHA256 key was throwing. This is a beta; the confirmation logs are in the debug build only, and nothing is field-verified yet.
+
+### App crypto correctness
+- HMAC operations now run instead of throwing. An AndroidKeyStore HMAC key is symmetric, so an HMAC SIGN fell into the asymmetric SIGN path and failed on a null key pair, and no MAC primitive existed. SIGN and VERIFY now work: the tag is computed with Mac (HmacSHA256/384/512), truncated to the requested MAC_LENGTH (full digest when unspecified), and checked with a constant-time compare.
+- RSA-OAEP-SHA256 decrypt no longer fails with BadPaddingException. The cipher ran with no OAEPParameterSpec, so JCA fell back to SHA-1 and rejected SHA-256 ciphertext. It now applies the correct main and MGF1 digests. A key that authorizes several MGF1 digests uses the one the operation requested, not the key's first.
+- Grant-domain attestation keys now resolve. A self-granted PURPOSE_ATTEST_KEY (a Domain.GRANT descriptor) could not resolve its signer alias, so generateKey failed and the subject key was never stored, returning KEY_NOT_FOUND on readback. The grant now resolves to the owner key's alias, and the subject key stays readable under Domain.APP.
+
+### Supplementary attestation
+- MODULE_HASH now comes from the framework's own getSupplementaryAttestationInfo, so it matches the value a verifier computes. It falls back to local re-derivation when that API is unreachable.
+
+### Diagnostics (debug builds only)
+- New per-operation (oaep-op, hmac-op, attest-grant) and device-level (module-hash, vintf-version) source logs. R8 strips them from release builds.
+
+### 中文说明
+
+修复本模块在 TEE 密钥操作与证明模拟中的五处缺陷。其中两处修复的是真实应用在 TEE 损坏设备上的加密崩溃：任何使用 AndroidKeyStore HMAC 密钥或 RSA-OAEP-SHA256 密钥的应用此前都会抛出异常。本版本为测试版；确认日志仅存在于 debug 构建中，且尚未经过真机验证。
+
+**应用加密正确性**
+- HMAC 操作现在可正常执行，不再抛出异常。AndroidKeyStore 的 HMAC 密钥是对称密钥，因此 HMAC SIGN 此前落入了非对称的 SIGN 分支，并因 key pair 为空而失败，当时也没有 MAC 原语。现在 SIGN 与 VERIFY 均可工作：用 Mac (HmacSHA256/384/512) 计算标签，按请求的 MAC_LENGTH 截断（未指定时取完整摘要长度），并用恒定时间比较进行校验。
+- RSA-OAEP-SHA256 解密不再抛出 BadPaddingException。此前 cipher 未传入 OAEPParameterSpec，JCA 因而回退到 SHA-1 并拒绝 SHA-256 密文。现在会应用正确的主摘要与 MGF1 摘要。若密钥授权了多个 MGF1 摘要，将使用本次操作请求的那个，而非密钥的第一个。
+- Grant 域证明密钥现在可以解析。自授权的 PURPOSE_ATTEST_KEY（Domain.GRANT 描述符）此前无法解析其签名者别名，导致 generateKey 失败且从不存储主体密钥，读取时返回 KEY_NOT_FOUND。现在该 grant 会解析为属主密钥的别名，主体密钥在 Domain.APP 下仍可读取。
+
+**补充证明**
+- MODULE_HASH 现在取自框架自带的 getSupplementaryAttestationInfo，因而与验证方计算出的值一致。当该 API 不可用时，回退到本地重新推导。
+
+**诊断（仅 debug 构建）**
+- 新增按操作 (oaep-op、hmac-op、attest-grant) 与设备级 (module-hash、vintf-version) 的来源日志。R8 会在 release 构建中将其剥离。
+
+---
+
+## TEESimulator-RS v6.0.1-282
+
+AUTO-mode key attestation now forges plain attestation from the keybox instead of deferring to the real TEE.
+
+### Detection coverage
+- AUTO dispatch probed the device with `checkTeeFunctionality`, which only proves the TEE can mint one EC key. It says nothing about RSA attestation, device-ID attestation, or whether a patched chain survives RSA verify. Plain attestation requests (attest-key OFF, challenge present) were routed to PATCH and deferred to hardware, so devices that can't back that surfaced KeyAttestation reds: `ATTESTATION_KEYS_NOT_PROVISIONED` (-49) and `BLOCK_TYPE_IS_NOT_01`.
+- AUTO targets carrying an attestation challenge now take the FORGE path, the same one attest-key-ON already used: a synthetic chain built from the keybox and rooted under the Google root key. Requests with no challenge still pass through to real hardware, so KeyDetector's hardware-backed checks are unaffected.
+
+### Verified
+- Offline conformance against real FORGE captures: uid10389 and uid10154 chains are GREEN; the root SPKI byte-matches `GOOGLE_ROOT_PUBLIC_KEY`.
+
+---
+
+## TEESimulator-RS v6.0.1-280
+
+Clears the Duck Detector generate-mode parcel fingerprint that real Android 16 hardware also trips, fixes RSA attestation under an EC-only keybox, and restores device-property attestation for Play Integrity hardware apps such as BHIM and UPI. Generate-mode fix field-confirmed on Android 16.
+
+### Detection coverage
+- Generate-mode fingerprint: Duck reads the reply at a flat 12-byte stride and flags the sentinel tuple at positions 12 and 13 that the device's native ALGORITHM-first authorization order lands on. Real A16 silicon trips the same probe, so faithful mirroring stayed flagged. `normalizeAuthorizationLayout` marshals the auth array, runs Duck's exact predicate, and applies a minimal deterministic reorder only when it would match. Count, values, security levels, and the cert chain are untouched, and the reorder keys on the byte condition, never on a package. Applied on both the patch and forge reply paths. (#33)
+- `updateAad` on a non-AEAD operation now answers per vendor: Samsung and Xiaomi-MTK TEEs return success, others return INVALID_TAG, matching Duck's OperationErrorPathProbe on both the sign/verify and cipher paths.
+
+### Attestation correctness (Android 16, EC and RSA)
+- RSA leaf under an EC-only keybox: patching used to catch the no-RSA-key throw and return the chain untouched, leaking the device's real unlocked Root of Trust for RSA keys while EC keys patched cleanly. It now falls back to any keybox key (EC preferred) and signs the patched leaf with the keybox key's own algorithm, so the RSA leaf re-roots to the Google keybox under a forged locked RoT.
+- RSA attest-key forge on an EC-only keybox: the forge path matched the algorithm exactly and threw -75 ATTESTATION_KEYS_NOT_PROVISIONED on a miss, so an RSA ATTEST_KEY request never rooted and verifiers reported an unknown certificate. It now falls back to any attestation key, since an EC key validly ECDSA-signs an RSA-subject leaf. No-op on a dual keybox.
+- A16 attestVersion: the device's KeyMint reports version 100 and the lazy cache shadowed the BAKLAVA-to-400 map, so the forge presented 100. It now caches the AOSP value per SDK and presents the correct 400.
+- Algorithm-split key on restore: a persisted record holding an EC private key under an RSA leaf failed every signature as DATA_TOO_LARGE_FOR_MODULUS. Restore now drops the record when the private key and served leaf disagree, so the next generateKey rebuilds a coherent key.
+- Stale chain on regenerate: reusing an alias in generateKey now evicts the cached chain, matching keystore2, so getKeyEntry serves the current key instead of a stale forge from an earlier generation.
+
+### App compatibility
+- Device-property attestation (BRAND, MODEL, and the rest) now forges unconditionally. The old gate probed the live TEE, which is dead on every device the module serves, so it rejected GMS Play Integrity's hardware path and broke BHIM and other UPI and Play-Integrity apps. Device-ID attestation (IMEI, serial) stays governed by the real KeyMint caller-permission rule: privileged callers get it, ordinary apps do not.
+- getKeyEntry now reaches the owned-key lookup for skipped privileged UIDs, so framework attestKeyAlias resolution no longer returns "Invalid attestKeyAlias" for Key Attestation over Shizuku. Non-owned keys still skip post-processing, so a real app's key is never patched.
+- Device-ID attestation over Shizuku (a privileged UID absent from target.txt) now takes the forge path instead of hitting the real TEE's CANNOT_ATTEST_IDS (-66). "Use attest key" no longer double-roots: a reused persistent attest key is resolved by KEY_ID as well as alias, and an unresolved designated attest key refuses to emit a leaf rather than silently re-rooting under the keybox.
+
+### Diagnostics (debug builds only)
+- Per-UID attestation dossier for targeted UIDs at /data/local/tmp/teesim/, recording the decoded chain on both forge and patch paths, key params, the keybox pick (including EC fail-safe), prop sources, forge failures, the emitted authorization shape, and served-versus-verified chains. Release builds strip this through R8 and stay silent. Keybox certificate serials log on every fetch for revocation triage.
+
+### Verified
+- Android 16: generate-mode fingerprint signal gone, confirmed on device 2026-06-19.
+
+---
+
+## TEESimulator-RS v6.0.1-251
+
+14 commits since v6.0.0-235. Clears the remaining Duck Detector grant-domain rows (incl. the Android 16 OnePlus report), restores Google Wallet and fingerprint compatibility, and removes the in-module patch-level/bulletin resolvers. Test device (SDK 35) TEE tamper score 28 → 8.
+
+### Detection coverage
+- Grant plane virtualized: owner read and cross-app `Domain.GRANT` read return one identical chain. 6 RED rows cleared. (28 → 18)
+- Generate-mode fingerprint: dropped 2 surplus authorizations (both patchlevels), USER_ID moved to SOFTWARE to mirror a captured device. (18 → 8)
+- Android 16 grant: patch-mode keys now served on the grant plane, so owner and grant reads match, fixes CHAIN_SPLIT.
+- Grant gated to SDK ≥ 36: Android 15 answers PERMISSION_DENIED, no synthetic over-capability.
+- Stale-chain eviction: import and updateSubcomponent drop the cached attestation; no pre-mutation chain replays.
+- Lifecycle coherence: clearNamespace / deleteAllKeys / migrateKeyNamespace mirror synthetic key and grant state, defeats delete-then-read probes.
+- Device-ID attestation mirrors the real TEE: returns CANNOT_ATTEST_IDS where silicon can't attest, instead of forging it.
+
+### App compatibility
+- Google Wallet: INCLUDE_UNIQUE_ID stripped (not rejected) when the caller lacks the permission; card binding works. (PR #27)
+- Fingerprint / vendor keys: KEY_ID miss skips the post-handler, so real HAL operations are no longer wrapped and broken. (PR #26)
+
+### Removed
+- PatchLevelManager, auto-resolved the security-patch date from an installed PlayIntegrityFix module (with hot-reload) and applied it to props.
+- BulletinPoller, scheduled security-bulletin refresh.
+
+### Other
+- Release builds purge stale `teesim-*.bin` diagnostics from `/data/local/tmp` at boot.
+- Vol-key confirmation rewritten to 1s `getevent` bursts (piped stream missed single presses on Magisk).
+
+### Verified
+- SDK 35, Xiaomi 23106RN0DA: tamper 28 → 8; generate-mode signal gone; 4 grant rows UNAVAILABLE (correct for Android 15); no regressions.
+- Android 16 grant fix built but unconfirmed on SDK 36, needs an affected OnePlus user to confirm the grant rows clear.
+
+---
+
+## TEESimulator-RS v6.0.0-235
+
+11 commits since v6.0.0-224. Duck Detector generate-mode fingerprint cleared. Shizuku-routed BYO attestation fixed. Vol-key confirmation restored on Magisk.
+
+### Detection Coverage
+- Duck Detector "TEE Simulator generate-mode fingerprint" cleared. `toAuthorizations` reordered to AOSP keymint reference order; KEY_SIZE moves from auth#4 to auth#2, breaking the byte-224 anchor the probe relied on. 0/31 matches on fresh self-probes (was 15/36).
+- `persist.logd.size` variants blanked at boot via `service.sh`. Removes a logd-tuning side-channel.
+
+### BYO & Shizuku Routing
+- Shizuku-routed BYO attestation no longer fails with `-49 UNSUPPORTED_TAG`. `shouldSkipUid` moved into `handleGenerateKey`, evaluated after BYO parameters are parsed.
+- `createOperation` parallel fix: outer UID gate removed; the cache-or-forward lookup is the sole gate. BYO keys created under Shizuku UID can now be used for signing under the same UID.
+- `forceGenerate` simplified: any attest-key or BYO request routes to software unconditionally.
+- BYO attest-key miss returns the full keybox chain instead of a malformed depth-1 chain.
+- AUTO TEE race dispatch removed. Resolution uses `DeviceAttestationService.isTeeFunctional` only.
+- Symmetric gen rejects `attestationKey != null` early with `INVALID_ARGUMENT`. Unsupported-algorithm branch returns `-38` instead of `-49`.
+
+### Action Button
+- Vol+ / Vol- confirmation restored on Magisk. Streaming `getevent -lq` matched inline against `KEY_VOLUMEUP DOWN` / `KEY_VOLUMEDOWN DOWN`, wrapped in `/system/bin/timeout 10`. The prior polled approach timed out on six-events-per-keypress kernels.
+
+### Verified
+- Android 15 (SDK 35), daemon PID 1466.
+- Cross-device confirmation pending on OnePlus PKX110 and Samsung SM-S928B.
+
+---
+
+## TEESimulator-RS v6.0.0-224
+
+59 commits since v6.0.0-162. Self-sufficient spoofing infrastructure, Duck Detector TamperScore-4 cleared on Xiaomi A16, persistent symmetric key storage (PR #22), 22-language action button hardening.
+
+### Detection Coverage
+- Duck Detector TimingSideChannelProbe cleared on Xiaomi A16 (SDK 35). Timing ratio dropped 1.555x to 1.055x, verdict WARNING to CLEAR. Threshold is > 1.1x.
+- `KEY_ID` resolved from `teeResponses` instead of synthesized, matching real KeyMint binder behavior.
+- Non-attested key cache mirrors attested path for byte-level metadata parity.
+- `KEY_SIZE` emitted for EC keys; omitted when `ecCurve` is present, matching AOSP attestation_record.h.
+- SSE messages synthesized canonically on non-AEAD `updateAad`; passthrough shape normalized.
+- StrongBox attest version no longer hardcoded; resolved from device context.
+- TEE op latency floor enforced to defeat micro-timing probes.
+- Attest key resolution restored to nspace-aware lookup after revert/restore cycle.
+
+### Self-Sufficient Spoofing
+- `PatchLevelManager` resolves OS/VENDOR/BOOT patch levels via PIF without external bulletin fetch.
+- `BulletinPoller` refreshes bulletin data on a schedule, isolated from boot path via umbrella `try/catch`.
+- Bootloader-lock props pushed via `resetprop` at boot; absent vbmeta complement props filled; `vbmeta.device_state` included.
+- PIF hot-reload via `FileObserver`; empty source files skipped; future patch dates bounded by `MAX_FUTURE_DAYS`.
+- Default `security_patch.txt` dropped at install time.
+- `sepolicy.rule` allows UDP egress for DNS resolution.
+
+### Key Persistence (PR #22)
+- Symmetric keys persist across reboots with byte-identical metadata.
+- Keybox edits no longer wipe stored keys.
+- Delete marker dropped on key regeneration to prevent stale state.
+- Defensive symmetric fallback path with clean error codes.
+
+### Reliability
+- `atomicWrite` preserves `[pkg]` sections; errors guarded in `updateTo`.
+- `applyToProps` serialized against concurrent callers.
+- `pollOnce` wrapped in umbrella `try/catch`; `BulletinPoller.start` failure isolated from spoofer init.
+- Spoofer ordering fixed: runs before keystore hook to prevent attest-time prop drift.
+- `isAutoMode` reads raw package mode; `system=prop` passive default respected.
+- `mergedContents` propagates read errors instead of swallowing them.
+- Date regex validation on `currentPatch`; YYYY-MM input skips day synthesis.
+- Global key-assignment check requires `=` delimiter (no more partial matches).
+- `validation_rejected` status emitted on invalid spoof input.
+
+### Action Button UX
+- Vol+ required to clear `persistent_keys`. Vol- cancels. 10-second timeout defaults to cancel.
+- Confirmation localized in 22 languages: ar, az, bn, de, el, es-ES, fa, fr, id, it, ja, ko, pl, pt-BR, ru, th, tl, tr, uk, vi, zh-CN, zh-TW.
+- Every echoed string resolves through `_msg()` against device locale.
+
+### Build & Ops
+- Kotlin `jvmTarget` raised to JVM 21.
+- Gradle auto-rewrites `module/update.json` on packaging.
+- `scripts/package.sh` locates user-local cargo; rust task receives cargo bin path.
+- Verified on Xiaomi Android 16 (SDK 35) `v6.0.0-224-Release`. Daemon alive PID 1392. Pending cross-device confirm on OnePlus PKX110 (qcom sun) and Samsung SM-S928B (pineapple).
+
+---
+
+## TEESimulator-RS v6.0.0
+
+Repository consolidation release. All tee-rebuild work merged as the new main branch.
+
+### AOSP Self-Signed Cert Compliance
+- No-challenge keys now generate self-signed certs (subject == issuer, depth 1), matching AOSP `ta/src/keys.rs:451-478`
+- Both Kotlin (BouncyCastle) and Rust (native-certgen) paths corrected
+- Eliminates attestation behavioral probes that detect keybox issuer on non-attested keys
+
+### Stability
+- Binder stress crash hardening for concurrent generateKey calls
+- AUTO mode TEE race for consistent attestation on devices with working G10
+- Oversized transactions routed to software gen instead of crashing
+- Operation-time params (BLOCK_MODE, PADDING, DIGEST) passed through to CipherPrimitive
+
+### Banking App Compatibility
+- Bare `target.txt` entries now default to AUTO mode, resolved at config level to PATCH (working TEE) or GENERATE (broken TEE)
+- Fixes BHIM and similar banking apps that require TEE-backed attestation keys
+- Restores v5.0 behavior where AUTO was resolved before the interceptor dispatch, avoiding the non-deterministic `raceTeePatch` path
+
+### Infrastructure
+- Version scheme changed to semver (v6.0.0)
+- Repository moved to TEESimulator-RS as canonical source
+
+---
+
+## TEESimulator-RS v5.0: AOSP Compliance Overhaul
+
+Major release integrating 30+ AOSP compliance improvements from upstream PR #157 analysis, layered on top of our StrongBox hardening and native cert gen architecture.
+
+### Attestation Extension Alignment
+- 17 enforcement tags added to KeyMintAttestation (ACTIVE_DATETIME, ORIGINATION_EXPIRE, USAGE_EXPIRE, USAGE_COUNT_LIMIT, CALLER_NONCE, UNLOCKED_DEVICE_REQUIRED, INCLUDE_UNIQUE_ID, ROLLBACK_RESISTANCE, EARLY_BOOT_ONLY, ALLOW_WHILE_ON_BODY, TRUSTED_USER_PRESENCE_REQUIRED, TRUSTED_CONFIRMATION_REQUIRED, NO_AUTH_REQUIRED, MAX_USES_PER_BOOT, MAX_BOOT_LEVEL, MIN_MAC_LENGTH, RSA_OAEP_MGF_DIGEST)
+- BLOCK_MODE encoded as SET OF INTEGER per AOSP attestation_record.h
+- Version-guarded tags (RSA_OAEP_MGF_DIGEST >=100, ROLLBACK_RESISTANCE >=3, EARLY_BOOT_ONLY >=4)
+- INCLUDE_UNIQUE_ID computed via HMAC-SHA256 per KeyMint HAL spec using device HBK
+- AAID gated on attestation challenge presence
+- Certificate validity defaults aligned with AOSP (epoch notBefore, 9999-12-31 notAfter)
+
+### Binder Infrastructure
+- Native transaction code filtering at C++ level, skipping JNI for non-intercepted codes
+- getNumberOfEntries includes software-generated key count
+- deleteKey resolves KEY_ID domain via generatedKeys lookup
+- patchAuthorizations for OS/VENDOR/BOOT patch levels in authorization arrays
+
+### Software Operation AOSP Conformance
+- updateAad on non-AEAD operations returns INVALID_TAG (-76), matching AOSP operation.rs
+- All crypto exceptions wrapped as ServiceSpecificException with correct KeyMint error codes
+- GCM IV returned in CreateOperationResponse.parameters for encrypt operations
+- SoftwareOperationBinder methods @Synchronized, matching AOSP Mutex per operation
+- authorize_create enforcement: PURPOSE validation, algorithm-purpose compatibility, temporal constraints, CALLER_NONCE prohibition, WRAP_KEY rejection
+
+### Security and Configuration
+- SELinux permission checks via /proc/pid/attr/current
+- Per-UID permission verification through IPackageManager.checkPermission
+- Imported key tracking prevents stale attest-key overrides in getKeyEntry
+- nspace consistency fix in attest-key override path
+- TeeLatencySimulator with log-normal distribution matching real hardware profiles
+- Device-unique HBK seed generated on install (32 bytes from /dev/random)
+
+### Preserved from v4.8
+- StrongBox op limits (4 concurrent max, TOO_MANY_OPERATIONS rejection)
+- LRU operation pruning per security level
+- Hardware keygen rate limiting (2/30s sliding window, 2 concurrent cap)
+- Native Rust cert generation with BouncyCastle fallback
+- Key persistence across reboots
+
+---
+
+## TEESimulator-RS v4.8.1: StrongBox Op Rejection Fix
+
+- **StrongBox op limit gate fix**, `trackAndEnforceOpLimit` was only called in the `Domain.KEY_ID` not-found path, so software-generated keys (found via `Domain.APP`) bypassed `STRONGBOX_MAX_CONCURRENT_OPS=4` entirely. DuckDetector's concurrent signing handles test created 24+ operations that all succeeded via LRU pruning instead of being rejected with `TOO_MANY_OPERATIONS (-29)`. Now enforced for all StrongBox createOperation paths.
+
+---
+
+## TEESimulator-RS v4.8: StrongBox Hardening & LRU Pruning
+
+Tested against DuckDetector on OnePlus (Android 16, KSU). Tamper score dropped from 32 to 8.
+
+- **LRU operation pruning**, Concurrent software operations capped at 15 per UID (TEE) and 4 per UID (StrongBox), with oldest-first eviction. Pruned operations return `INVALID_OPERATION_HANDLE (-28)`, matching AOSP keystore2 malus-based pruning.
+- **StrongBox param guard**, Unsupported StrongBox params (RSA >2048-bit, non-P256 EC curves) forwarded to real HAL for proper rejection instead of generating in software.
+- **StrongBox timing**, Key generation floors at 250ms, signing at 80ms on StrongBox security level to match real secure element latency.
+- **StrongBox op limit**, Sliding-window enforcer caps concurrent StrongBox operations for both software and hardware key paths, returning `TOO_MANY_OPERATIONS (-29)` when exceeded.
+- **ECDSA algorithm alias**, Accept "ECDSA" in addition to "EC" as JCA private key algorithm name. Fixes SIGSEGV crash on Android 10 devices where the provider reports EC keys as "ECDSA". Closes #4.
+- **createOperation domain handling**, Software-generated keys now found via both `Domain.APP` (alias) and `Domain.KEY_ID` (nspace) lookup paths.
+- **Permission guards**, Device ID attestation tags (IMEI, MEID, serial) require caller permission checks.
+
+---
+
+## TEESimulator-RS v4.7: Operation & Attestation Fixes
+
+Tested against [KeyDetector](https://github.com/XiaoTong6666/KeyDetector) and [Key Attestation](https://github.com/nickel-lang/nickel) on OnePlus (Android 16) and Xiaomi Redmi 14C (Android 14).
+
+- **PADDING encoding**, Fixed ASN.1 encoding of PADDING tag in attestation extension from individual `[6] INTEGER` entries to `[6] SET OF INTEGER`, matching AOSP `attestation_record.h` schema. Broke all RSA key attestation since v4.6.
+- **Operation error-path conformance**, Software operations now track finalized state and return `INVALID_OPERATION_HANDLE (-28)` on post-abort calls. Input length guard (32KB) returns `TOO_MUCH_DATA` matching AOSP `operation.rs`. Passes KeyDetector's OperationErrorPathChecker.
+- **updateAad support**, Added `updateAad` to `SoftwareOperationBinder`, fixing `AbstractMethodError` on Android 16 where the runtime Stub declares it abstract.
+- **Algorithm inference**, `createOperation` now infers algorithm from the stored key pair when operation params omit the ALGORITHM tag, matching AOSP behavior.
+
+---
+
+## TEESimulator-RS v4.6: Rebrand & Detection Fix
+
+- **RTT normalization rework**, Replaced Gaussian sleep (mean=55ms) with a 15ms floor fence. The old approach triggered Chunqiu Native Check 2.8 timing analysis; the floor-only approach satisfies the minimum RTT threshold without creating a detectable delay pattern.
+- **Cross-algorithm attestation**, Signing algorithm now derived from the attestation key's actual type, not the generated key's algorithm. Fixes BouncyCastle crash when signing RSA keys with EC attestation keys (Shizuku attestation flow).
+- **Device ID attestation**, Serial/IMEI/MEID/secondImei tags now flow through to software cert gen instead of blanket rejection. Only DEVICE_UNIQUE_ATTESTATION is rejected, matching AOSP keystore2 policy.
+- **Rebrand to TEESimulator-RS**, Distinguishes this fork from upstream. Version scheme simplified to v{major}.{minor}-{commitCount}.
+- **CI streamlined**, Release pipeline uses Gradle-generated filenames directly, eliminating the rename step.
+
+---
+
+## TEESimulator v4.5: Detection Hardening
+
+Tested against [KeyDetector](https://github.com/XiaoTong6666/KeyDetector) (23-check attestation validator). All keystore-level checks now pass.
+
+- **Key deletion consistency**, After deleting a software-generated key, `getKeyEntry` now correctly returns `KEY_NOT_FOUND` instead of falling through to a stale live-patch fallback. Fixes binder consistency checks that detect ghost key responses.
+- **generateKey timing normalization**, Software key generation RTT now matches real TEE latency profile (Gaussian distribution, mean=55ms, floor=15ms). Previously completed in ~4ms, which is an immediate timing side-channel.
+- **Delete cleanup scope**, `deleteKey` now clears all cached state (patched chains, attestation keys) regardless of whether the key was software or hardware-generated.
+
+---
+
+## TEESimulator v4.4: AOSP Conformance
+
+- **Binder error reply format**, Aligned EX_SERVICE_SPECIFIC wire layout with AOSP Status.cpp, including the remote stack trace header field.
+- **Key enumeration**, Corrected list_past_alias pagination order to match AOSP database.rs semantics.
+- **KeyMetadata fields**, Generated key responses now include modificationTimeMs, Tag.ORIGIN, and normalized KeyDescriptor fields per AOSP Keystore2.
+- **Parcel handling**, hasException() preserves reply position for downstream consumers.
+
+---
+
+## TEESimulator v4.3: Performance & Reliability
+
+- **Debug log gating**, `SystemLogger.debug()` now skipped entirely in release builds, eliminating unnecessary logcat syscalls on every intercepted transaction.
+- **Supervisor backoff**, Exponential restart delay (500ms → 30s cap) prevents CPU spin if the daemon crashes repeatedly. Resets automatically once stable.
+- **Process priority**, Daemon runs at nice=10, yielding CPU to foreground apps on constrained devices.
+- **Map eviction**, Rate limiter and file lock maps now evict stale entries instead of growing unbounded.
+- **CI pipeline**, Single-trigger build→release pipeline with proper changelog extraction and correctly sized artifacts.
+
+---
+
+## TEESimulator v4.2: Detection Evasion Hardening
+
+Fixes 6 detection vectors flagged by attestation validator apps.
+
+### Attestation Policy Enforcement
+
+Replicate AOSP keystore2's `add_required_parameters()` validation that our software keygen path was bypassing:
+
+- **CREATION_DATETIME**, Reject caller-provided input with `INVALID_ARGUMENT (20)`, matching `security_level.rs:424`. Our cert gen still adds its own timestamp, same as real keystore2.
+- **Device ID attestation**, Reject ATTESTATION_ID_SERIAL, IMEI, MEID, SECOND_IMEI, and DEVICE_UNIQUE_ATTESTATION with `CANNOT_ATTEST_IDS (-66)`. No consumer app has READ_PRIVILEGED_PHONE_STATE.
+- **Error reply format**, Fixed AIDL ServiceSpecificException parcel write order (was errorCode→message, now message→errorCode).
+
+### Certificate Fix
+
+Leaf certificate Subject CN corrected from "Android KeyStore Key" to "Android Keystore Key" (lowercase s), matching AOSP `KeyGenParameterSpec.java:282`. Both Kotlin and Rust paths.
+
+### Binder Timing
+
+Skip interception for system transaction codes (PING, INTERFACE, DUMP) above LAST_CALL_TRANSACTION. Eliminates the JNI round-trip that inflated binder ping ratio to 3.85x (detector threshold: 3.0x).
+
+---
+
+## TEESimulator v4.1: Boot Identity Persistence
+
+Bugfix release. The vbmeta boot key digest was randomizing on every reboot, producing a different RootOfTrust in attestation certificates each boot.
+
+On devices where the kernel doesn't set `ro.boot.vbmeta.public_key_digest`, the fallback chain hit random generation every boot because `resetprop` overrides for `ro.boot.*` props don't survive reboots. Added file-based persistence (`boot_hash.bin`, `boot_key.bin`) between the TEE cache and random fallback. Once determined, boot identity values persist across reboots.
+
+Verified on Redmi 14C: second boot reads from persistent file instead of regenerating.
+
+---
+
 ## TEESimulator v4.0: Native Rust Cert Generation
 
 Major release. Certificate chain generation rebuilt from the ground up in Rust, replacing the BouncyCastle Java path for EC and RSA keys. Hardened against every known detector app.
 
 ### Native Cert Generation
 
-The headline feature. `libcertgen.so` generates X.509 certificate chains using `ring` (EC-P256/P384) and `rsa` (RSA-2048/4096) with manual DER assembly. No more BouncyCastle quirks — issuer/subject DN bytes are injected directly from the keybox, ensuring byte-perfect chain linkage. BouncyCastle remains as fallback for unsupported curves (P-224, P-521, Curve25519).
+The headline feature. `libcertgen.so` generates X.509 certificate chains using `ring` (EC-P256/P384) and `rsa` (RSA-2048/4096) with manual DER assembly. No more BouncyCastle quirks, issuer/subject DN bytes are injected directly from the keybox, ensuring byte-perfect chain linkage. BouncyCastle remains as fallback for unsupported curves (P-224, P-521, Curve25519).
 
 ### Anti-Detection Hardening
 
-- **Challenge validation** — Oversized attestation challenges (>128 bytes) now return `INVALID_INPUT_LENGTH (-21)`, matching real KeyMint behavior. Previously accepted silently — DuckDetector exploited this.
+- **Challenge validation**, Oversized attestation challenges (>128 bytes) now return `INVALID_INPUT_LENGTH (-21)`, matching real KeyMint behavior. Previously accepted silently, DuckDetector exploited this.
-- **Per-UID rate limiter** — 2 hardware keygens per 30s burst, 2 concurrent max. Overflow falls back to software certs. Blocks DuckDetector-style keygen flooding that starves GMS.
+- **Per-UID rate limiter**, 2 hardware keygens per 30s burst, 2 concurrent max. Overflow falls back to software certs. Blocks DuckDetector-style keygen flooding that starves GMS.
-- **importKey eviction guard** — Retained patch chains prevent generate-then-import attacks that evict cached attestation data.
+- **importKey eviction guard**, Retained patch chains prevent generate-then-import attacks that evict cached attestation data.
-- **256KB native payload cap** — Oversized binder payloads bypass interception cleanly instead of stalling threads.
+- **256KB native payload cap**, Oversized binder payloads bypass interception cleanly instead of stalling threads.
-- **Alias size rejection** — Oversized key aliases rejected before they hit the binder buffer.
+- **Alias size rejection**, Oversized key aliases rejected before they hit the binder buffer.
 
 ### Key Persistence
 
@@ -24,7 +380,7 @@ Generated keys now survive reboots. File-backed storage with file-level locking,
 - Correct `module_hash` field to match AOSP Keystore2 format
 - Override pre-existing attest keys instead of skipping them
 - Strip HTML comments from PEM blocks in keybox parsing
-- Security patch consistency — `system=prop` forces boot/vendor to match
+- Security patch consistency, `system=prop` forces boot/vendor to match
 
 ### Module Lifecycle
 
@@ -35,9 +391,9 @@ Generated keys now survive reboots. File-backed storage with file-level locking,
 ### Stability
 
 - FileObserver NPE on config deletion fixed
-- Global uncaught exception handler — daemon stays alive on unexpected errors
+- Global uncaught exception handler, daemon stays alive on unexpected errors
 - PEM parsing hardened against malformed keybox files
 
 ### Tested Against
 
-DuckDetector, Luna, Play Integrity, Key Attestation Demo — all passing on Redmi 14C (Android 14, Beanpod KeyMaster, KSU).
+DuckDetector, Luna, Play Integrity, Key Attestation Demo, all passing on Redmi 14C (Android 14, Beanpod KeyMaster, KSU).

module/customize.sh

@@ -15,7 +15,7 @@ fi
 
 # --- Version Info ---
 VERSION=$(grep_prop version "${TMPDIR}/module.prop")
-ui_print "- Installing TEESimulator $VERSION"
+ui_print "- Installing TEESimulator-RS $VERSION"
 ui_print ""
 
 # --- Architecture Handling ---
@@ -48,7 +48,7 @@ install_file() {
 
 # --- Installation ---
 ui_print "- Extracting module files"
-for file in customize.sh module.prop service.sh sepolicy.rule daemon action.sh uninstall.sh; do
+for file in customize.sh module.prop service.sh sepolicy.rule daemon action.sh action_i18n.sh uninstall.sh; do
   install_file "$file" "$MODPATH"
 done
 
@@ -76,6 +76,20 @@ mv "$MODPATH/libsupervisor.so" "$MODPATH/supervisor"
 chmod 755 "$MODPATH/inject"
 chmod 755 "$MODPATH/supervisor"
 
+# Debug builds carry diag.sh (the diagnostic plane); release builds do not. Extract it when
+# present; otherwise sweep any external-storage diagnostics a prior debug install left behind,
+# since the release keystore domain has no grant to remove them itself.
+# Detect presence by the extracted FILE, not unzip's exit code: the busybox/toybox unzip in
+# the install environment exits 0 even when the entry is absent, so the sweep never ran.
+unzip -qqjo "$ZIPFILE" "diag.sh" -d "$MODPATH" 2>/dev/null
+if [ -f "$MODPATH/diag.sh" ]; then
+  chmod 644 "$MODPATH/diag.sh"
+  ui_print "- Debug diagnostic plane enabled"
+else
+  rm -rf /data/media/0/TEESimulator /data/local/tmp/teesim
+  ui_print "- Release build: swept stale diagnostics"
+fi
+
 # --- Configuration Files ---
 if [ ! -d "$CONFIG_DIR" ]; then
   ui_print "- Creating configuration directory"
@@ -91,3 +105,21 @@ if [ ! -f "$CONFIG_DIR/target.txt" ]; then
   ui_print "- Adding default target scope"
   install_file "target.txt" "$CONFIG_DIR"
 fi
+
+if [ ! -f "$CONFIG_DIR/security_patch.txt" ]; then
+  ui_print "- Adding default security patch config (mirror device props)"
+  printf '%s\n' \
+    '# TEESimulator default: mirror live device props.' \
+    '# system=prop reads ro.build.version.security_patch at cert-gen time;' \
+    '# boot and vendor are auto-forced to prop too (ConfigurationManager.kt:253-256).' \
+    '# Override with explicit YYYY-MM-DD dates if you want active spoofing.' \
+    'system=prop' > "$CONFIG_DIR/security_patch.txt"
+  chmod 644 "$CONFIG_DIR/security_patch.txt"
+fi
+
+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"
+fi

module/diag.sh

@@ -0,0 +1,20 @@
+#!/system/bin/sh
+# Debug-only diagnostic plane. Shipped solely in debug ZIPs; its presence is the gate that
+# service.sh (setup) and action.sh (export) test before touching external storage.
+DIAG_DIR=/data/media/0/TEESimulator
+
+diag_setup() {
+    mkdir -p "$DIAG_DIR"
+    chmod 0777 "$DIAG_DIR"
+    chcon u:object_r:media_rw_data_file:s0 "$DIAG_DIR" 2>/dev/null
+}
+
+diag_export() {
+    _ts=$(date +%Y%m%d-%H%M%S)
+    _dest=/sdcard/Download/teesim-logs-$_ts
+    mkdir -p "$_dest"
+    cp -f "$DIAG_DIR"/teesim-uid-* "$_dest"/ 2>/dev/null
+    cp -f /data/adb/tricky_store/logs/certgen.log* "$_dest"/ 2>/dev/null
+    logcat -d -s TEESimulator > "$_dest/logcat.txt" 2>/dev/null
+    echo "  ✅ Saved to $_dest"
+}

module/module.prop

@@ -1,7 +1,7 @@
 id=tricky_store
-name=TEESimulator
+name=TEESimulator-RS
 version=${REPLACEMEVER}
 versionCode=${REPLACEMEVERCODE}
 author=JingMatrix, Enginex0
 description=Software simulation for Android hardware-backed key pairs with key attestation
-updateJson=https://raw.githubusercontent.com/Enginex0/TEESimulator/main/module/update.json
+updateJson=https://raw.githubusercontent.com/Enginex0/TEESimulator-RS/main/module/update.json

module/sepolicy.rule

@@ -1,2 +1,20 @@
 allow keystore {adb_data_file shell_data_file} file *
 allow crash_dump keystore process *
+
+# SOTER Layer-A (10.C): ptrace inject into soterserver (platform_app). The debug NDJSON
+# media_rw_data_file grant is debug-only — appended for debug builds in app/build.gradle.kts.
+allow crash_dump platform_app process *
+
+allow ksu self:tcp_socket { create connect read write getopt setopt }
+allow ksu node:tcp_socket node_bind
+allow ksu port:tcp_socket name_connect
+allow magisk self:tcp_socket { create connect read write getopt setopt }
+allow magisk node:tcp_socket node_bind
+allow magisk port:tcp_socket name_connect
+
+allow ksu self:udp_socket { create connect read write getopt setopt }
+allow ksu node:udp_socket node_bind
+allow ksu port:udp_socket name_connect
+allow magisk self:udp_socket { create connect read write getopt setopt }
+allow magisk node:udp_socket node_bind
+allow magisk port:udp_socket name_connect

module/service.sh

@@ -3,3 +3,20 @@ cd $MODDIR
 
 # Fork-based supervisor for instant restart
 ./supervisor ./daemon "$MODDIR" &
+
+# Debug builds ship diag.sh; its presence enables the external-storage diagnostic plane.
+if [ -f "$MODDIR/diag.sh" ]; then
+  . "$MODDIR/diag.sh"
+  diag_setup
+fi
+
+# Clear logd size persist properties once boot completes
+(
+  until [ "$(getprop sys.boot_completed)" = "1" ]; do
+    sleep 1
+  done
+  setprop persist.logd.size ""
+  setprop persist.logd.size.crash ""
+  setprop persist.logd.size.system ""
+  setprop persist.logd.size.main ""
+) &

module/uninstall.sh

@@ -9,3 +9,8 @@ done
 
 rm -rf "$CONFIG_DIR/persistent_keys"
 rm -f "$CONFIG_DIR/tee_status.txt"
+rm -f "$CONFIG_DIR/boot_hash.bin" "$CONFIG_DIR/boot_key.bin"
+rm -f "$CONFIG_DIR/security_patch.txt" "$CONFIG_DIR/security_patch.txt.next" "$CONFIG_DIR/last_bulletin_fetch.json"
+
+# Debug diagnostics live on external storage; remove them on uninstall.
+rm -rf /data/media/0/TEESimulator

module/update.json

@@ -1,6 +1,6 @@
 {
-	"version": "v4.0",
+  "version": "v6.0.1-307",
-	"versionCode": 90,
+  "versionCode": 307,
-	"zipUrl": "https://github.com/Enginex0/TEESimulator/releases/download/v4.0/TEESimulator-v4.0-Release.zip",
+  "zipUrl": "https://github.com/Enginex0/TEESimulator-RS/releases/download/v6.0.1-307/TEESimulator-RS-v6.0.1-307-Release.zip",
-	"changelog": "https://raw.githubusercontent.com/Enginex0/TEESimulator/main/module/changelog.md"
+  "changelog": "https://raw.githubusercontent.com/Enginex0/TEESimulator-RS/main/module/changelog.md"
 }

native-certgen/Cargo.lock

@@ -2,12 +2,6 @@
 # It is not intended for manual editing.
 version = 4
 
-[[package]]
-name = "adler2"
-version = "2.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.4"
@@ -23,15 +17,6 @@ version = "1.0.102"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
 
-[[package]]
-name = "arbitrary"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3d036a3c4ab069c7b410a2ce876bd74808d2d0888a82667669f8e783a898bf1"
-dependencies = [
- "derive_arbitrary",
-]
-
 [[package]]
 name = "autocfg"
 version = "1.5.0"
@@ -53,12 +38,6 @@ dependencies = [
  "generic-array",
 ]
 
-[[package]]
-name = "bumpalo"
-version = "3.20.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d20789868f4b01b2f2caec9f5c4e0213b41e3e5702a50157d699ae31ced2fcb"
-
 [[package]]
 name = "bytes"
 version = "1.11.1"
@@ -83,7 +62,6 @@ dependencies = [
  "const-oid",
  "der",
  "jni",
- "libc",
  "pkcs8",
  "rand",
  "ring",
@@ -93,7 +71,6 @@ dependencies = [
  "tracing",
  "tracing-subscriber",
  "x509-cert",
- "zip",
 ]
 
 [[package]]
@@ -133,21 +110,6 @@ dependencies = [
  "libc",
 ]
 
-[[package]]
-name = "crc32fast"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
-dependencies = [
- "cfg-if",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.8.21"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
-
 [[package]]
 name = "crypto-common"
 version = "0.1.7"
@@ -191,17 +153,6 @@ dependencies = [
  "powerfmt",
 ]
 
-[[package]]
-name = "derive_arbitrary"
-version = "1.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e567bd82dcff979e4b03460c307b3cdc9e96fde3d73bed1496d2bc75d9dd62a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -213,23 +164,6 @@ dependencies = [
  "crypto-common",
 ]
 
-[[package]]
-name = "displaydoc"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
-[[package]]
-name = "equivalent"
-version = "1.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
-
 [[package]]
 name = "find-msvc-tools"
 version = "0.1.9"
@@ -242,16 +176,6 @@ version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7ac824320a75a52197e8f2d787f6a38b6718bb6897a35142d749af3c0e8f4fe"
 
-[[package]]
-name = "flate2"
-version = "1.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "843fba2746e448b37e26a819579957415c8cef339bf08564fe8b7ddbd959573c"
-dependencies = [
- "crc32fast",
- "miniz_oxide",
-]
-
 [[package]]
 name = "generic-array"
 version = "0.14.7"
@@ -273,22 +197,6 @@ dependencies = [
  "wasi",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
-
-[[package]]
-name = "indexmap"
-version = "2.13.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7714e70437a7dc3ac8eb7e6f8df75fd8eb422675fc7678aff7364301092b1017"
-dependencies = [
- "equivalent",
- "hashbrown",
-]
-
 [[package]]
 name = "itoa"
 version = "1.0.17"
@@ -306,7 +214,7 @@ dependencies = [
  "combine",
  "jni-sys",
  "log",
- "thiserror 1.0.69",
+ "thiserror",
  "walkdir",
  "windows-sys 0.45.0",
 ]
@@ -359,16 +267,6 @@ version = "2.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
 
-[[package]]
-name = "miniz_oxide"
-version = "0.8.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
-dependencies = [
- "adler2",
- "simd-adler32",
-]
-
 [[package]]
 name = "nu-ansi-term"
 version = "0.50.3"
@@ -674,12 +572,6 @@ dependencies = [
  "rand_core",
 ]
 
-[[package]]
-name = "simd-adler32"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e320a6c5ad31d271ad523dcf3ad13e2767ad8b1cb8f047f75a8aeaf8da139da2"
-
 [[package]]
 name = "smallvec"
 version = "1.15.1"
@@ -725,16 +617,7 @@ version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "thiserror-impl 1.0.69",
+ "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4288b5bcbc7920c07a1149a35cf9590a2aa808e0bc1eafaade0b80947865fbc4"
-dependencies = [
- "thiserror-impl 2.0.18",
 ]
 
 [[package]]
@@ -748,17 +631,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "thiserror-impl"
-version = "2.0.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "thread_local"
 version = "1.1.9"
@@ -1130,37 +1002,8 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "zip"
-version = "2.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fabe6324e908f85a1c52063ce7aa26b68dcb7eb6dbc83a2d148403c9bc3eba50"
-dependencies = [
- "arbitrary",
- "crc32fast",
- "crossbeam-utils",
- "displaydoc",
- "flate2",
- "indexmap",
- "memchr",
- "thiserror 2.0.18",
- "zopfli",
-]
-
 [[package]]
 name = "zmij"
 version = "1.0.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"
-
-[[package]]
-name = "zopfli"
-version = "0.8.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f05cd8797d63865425ff89b5c4a48804f35ba0ce8d125800027ad6017d2b5249"
-dependencies = [
- "bumpalo",
- "crc32fast",
- "log",
- "simd-adler32",
-]

native-certgen/Cargo.toml

@@ -20,8 +20,6 @@ time = { version = "0.3", features = ["std"] }
 anyhow = "1.0"
 tracing = "0.1"
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
-libc = "0.2"
-zip = { version = "2.2", default-features = false, features = ["deflate"] }
 serde_json = "1.0"
 
 [profile.release]

native-certgen/src/attestation.rs

@@ -33,6 +33,36 @@ pub fn build_attestation_extension(params: &CertGenParams) -> Result<Vec<u8>> {
 fn build_software_enforced(params: &CertGenParams) -> Result<Vec<u8>> {
     let mut fields: Vec<(u32, Vec<u8>)> = Vec::new();
 
+    // Tag 303: CALLER_NONCE — NULL (presence = true)
+    if params.caller_nonce {
+        fields.push((303, enc_null()));
+    }
+
+    // Tag 400: ACTIVE_DATETIME — INTEGER (milliseconds)
+    if params.active_datetime >= 0 {
+        fields.push((400, enc_integer(params.active_datetime)));
+    }
+
+    // Tag 401: ORIGINATION_EXPIRE_DATETIME — INTEGER (milliseconds)
+    if params.origination_expire_datetime >= 0 {
+        fields.push((401, enc_integer(params.origination_expire_datetime)));
+    }
+
+    // Tag 402: USAGE_EXPIRE_DATETIME — INTEGER (milliseconds)
+    if params.usage_expire_datetime >= 0 {
+        fields.push((402, enc_integer(params.usage_expire_datetime)));
+    }
+
+    // Tag 405: USAGE_COUNT_LIMIT — INTEGER
+    if params.usage_count_limit >= 0 {
+        fields.push((405, enc_integer(params.usage_count_limit as i64)));
+    }
+
+    // Tag 509: UNLOCKED_DEVICE_REQUIRED — NULL
+    if params.unlocked_device_required {
+        fields.push((509, enc_null()));
+    }
+
     // Tag 701: CREATION_DATETIME — INTEGER (milliseconds)
     fields.push((701, enc_integer(params.creation_datetime)));
 
@@ -77,8 +107,10 @@ fn build_tee_enforced(params: &CertGenParams) -> Result<Vec<u8>> {
         fields.push((10, enc_integer(curve as i32 as i64)));
     }
 
-    // Tag 503: NO_AUTH_REQUIRED — NULL (presence = true)
+    // Tag 503: NO_AUTH_REQUIRED — NULL (conditional)
-    fields.push((503, enc_null()));
+    if params.no_auth_required {
+        fields.push((503, enc_null()));
+    }
 
     // Tag 702: ORIGIN — INTEGER 0 (GENERATED)
     fields.push((702, enc_integer(0)));
@@ -519,6 +551,44 @@ mod tests {
         assert_eq!(tags, sorted, "AuthorizationList fields must be sorted by tag number");
     }
 
+    #[test]
+    fn test_enforcement_tags_in_software_enforced() {
+        let mut params = make_test_params();
+        params.usage_count_limit = 3;
+        params.unlocked_device_required = true;
+        params.caller_nonce = true;
+        params.active_datetime = 1709913600000;
+        let sw = build_software_enforced(&params).unwrap();
+        let inner = skip_tlv_header(&sw);
+        let tags = extract_tag_numbers(inner);
+        assert!(tags.contains(&303), "CALLER_NONCE (303) must be in softwareEnforced");
+        assert!(tags.contains(&400), "ACTIVE_DATETIME (400) must be in softwareEnforced");
+        assert!(tags.contains(&405), "USAGE_COUNT_LIMIT (405) must be in softwareEnforced");
+        assert!(tags.contains(&509), "UNLOCKED_DEVICE_REQUIRED (509) must be in softwareEnforced");
+    }
+
+    #[test]
+    fn test_no_auth_required_conditional() {
+        let mut params = make_test_params();
+        params.no_auth_required = false;
+        let tee = build_tee_enforced(&params).unwrap();
+        let inner = skip_tlv_header(&tee);
+        let tags = extract_tag_numbers(inner);
+        assert!(!tags.contains(&503), "NO_AUTH_REQUIRED (503) must be absent when false");
+    }
+
+    #[test]
+    fn test_enforcement_tags_omitted_when_unset() {
+        let params = make_test_params();
+        let sw = build_software_enforced(&params).unwrap();
+        let inner = skip_tlv_header(&sw);
+        let tags = extract_tag_numbers(inner);
+        assert!(!tags.contains(&303), "CALLER_NONCE should be absent when false");
+        assert!(!tags.contains(&400), "ACTIVE_DATETIME should be absent when -1");
+        assert!(!tags.contains(&405), "USAGE_COUNT_LIMIT should be absent when -1");
+        assert!(!tags.contains(&509), "UNLOCKED_DEVICE_REQUIRED should be absent when false");
+    }
+
     #[test]
     fn test_full_extension_roundtrip() {
         let params = make_test_params();
@@ -568,6 +638,13 @@ mod tests {
             id_manufacturer: None,
             id_model: None,
             id_second_imei: None,
+            active_datetime: -1,
+            origination_expire_datetime: -1,
+            usage_expire_datetime: -1,
+            usage_count_limit: -1,
+            caller_nonce: false,
+            unlocked_device_required: false,
+            no_auth_required: true,
         }
     }
 

native-certgen/src/certbuilder.rs

@@ -14,9 +14,69 @@ const OID_SHA256_WITH_RSA: &[u64] = &[1, 2, 840, 113549, 1, 1, 11];
 // Extension OIDs
 const OID_KEY_USAGE: &[u64] = &[2, 5, 29, 15];
 
+// AOSP ta/src/keys.rs:451-478: no challenge = self-signed leaf, chain depth 1
+pub fn build_self_signed_cert(
+    key_pair: &GeneratedKeyPair,
+    params: &CertGenParams,
+) -> Result<Vec<Vec<u8>>> {
+    let spki_der = extract_spki_from_pkcs8(&key_pair.private_key_pkcs8)?;
+    let sig_alg_der = signature_algorithm_for_signing_key(&key_pair.private_key_pkcs8, params.algorithm)?;
+
+    let serial_bytes = if let Some(ref serial) = params.cert_serial {
+        serial.clone()
+    } else {
+        vec![1u8]
+    };
+
+    let subject_dn_der = if let Some(ref subject) = params.cert_subject {
+        subject.clone()
+    } else {
+        encode_simple_cn_dn("Android Keystore Key")
+    };
+
+    let not_before = timestamp_to_datetime(params.cert_not_before)?;
+    let not_after = if params.cert_not_after == -1 {
+        // No keybox fallback available; use far-future (year 9999)
+        OffsetDateTime::from_unix_timestamp(253402300799)
+            .unwrap_or_else(|_| OffsetDateTime::now_utc() + time::Duration::days(365 * 30))
+    } else {
+        timestamp_to_datetime(params.cert_not_after)?
+    };
+
+    let extensions_der = build_extensions(None, &params.purposes)?;
+
+    let version_der = encode_der_explicit_tag(0, &encode_der_integer(&[2]));
+    let serial_der = encode_der_integer(&serial_bytes);
+    let validity_der = encode_validity(&not_before, &not_after);
+    let extensions_tagged = encode_der_explicit_tag(3, &extensions_der);
+
+    // issuer == subject (self-signed, per AOSP ta/src/cert.rs:111-114)
+    let tbs_der = encode_der_sequence(&[
+        &version_der,
+        &serial_der,
+        &sig_alg_der,
+        &subject_dn_der,
+        &validity_der,
+        &subject_dn_der,
+        &spki_der,
+        &extensions_tagged,
+    ]);
+
+    let signature_bytes = sign_tbs(&tbs_der, &key_pair.private_key_pkcs8, params.algorithm)?;
+    let signature_bit_string = encode_der_bit_string(&signature_bytes);
+
+    let cert_der = encode_der_sequence(&[
+        &tbs_der,
+        &sig_alg_der,
+        &signature_bit_string,
+    ]);
+
+    Ok(vec![cert_der])
+}
+
 pub fn build_certificate_chain(
     key_pair: &GeneratedKeyPair,
-    attestation_ext_der: &[u8],
+    attestation_ext_der: Option<&[u8]>,
     keybox: &ParsedKeybox,
     params: &CertGenParams,
 ) -> Result<Vec<Vec<u8>>> {
@@ -33,7 +93,7 @@ pub fn build_certificate_chain(
 
 fn build_leaf_cert(
     key_pair: &GeneratedKeyPair,
-    attestation_ext_der: &[u8],
+    attestation_ext_der: Option<&[u8]>,
     keybox: &ParsedKeybox,
     params: &CertGenParams,
 ) -> Result<Vec<u8>> {
@@ -51,7 +111,7 @@ fn build_leaf_cert(
     let subject_dn_der = if let Some(ref subject) = params.cert_subject {
         subject.clone()
     } else {
-        encode_simple_cn_dn("Android KeyStore Key")
+        encode_simple_cn_dn("Android Keystore Key")
     };
 
     // Validity
@@ -63,7 +123,6 @@ fn build_leaf_cert(
         timestamp_to_datetime(params.cert_not_after)?
     };
 
-    // Extensions
     let extensions_der = build_extensions(attestation_ext_der, &params.purposes)?;
 
     // TBS Certificate
@@ -256,19 +315,19 @@ fn extract_rsa_spki(pkcs8_der: &[u8]) -> Result<Vec<u8>> {
     Ok(encode_der_sequence(&[&alg_id, &pub_key_bits]))
 }
 
-fn build_extensions(attestation_ext_der: &[u8], purposes: &[i32]) -> Result<Vec<u8>> {
+fn build_extensions(attestation_ext_der: Option<&[u8]>, purposes: &[i32]) -> Result<Vec<u8>> {
     let mut extensions: Vec<Vec<u8>> = Vec::new();
 
-    // KeyUsage extension (critical)
     let ku_byte = map_key_usage_byte(purposes);
     if ku_byte != 0 {
         let ku_ext = build_key_usage_extension(ku_byte);
         extensions.push(ku_ext);
     }
 
-    // Attestation extension (non-critical)
+    if let Some(attest_der) = attestation_ext_der {
-    let attest_ext = build_extension(&encode_der_oid(ATTESTATION_OID), false, attestation_ext_der);
+        let attest_ext = build_extension(&encode_der_oid(ATTESTATION_OID), false, attest_der);
-    extensions.push(attest_ext);
+        extensions.push(attest_ext);
+    }
 
     Ok(encode_der_sequence_of(&extensions))
 }

native-certgen/src/lib.rs

@@ -9,7 +9,7 @@ pub mod certbuilder;
 pub mod logging;
 
 use jni::objects::{JByteArray, JClass, JIntArray, JObject, JString};
-use jni::sys::{jboolean, jbyteArray, jstring};
+use jni::sys::{jboolean, jbyteArray};
 use jni::JNIEnv;
 
 use crate::error::{CertGenError, Result};
@@ -62,21 +62,43 @@ fn generate_attested_inner(env: &mut JNIEnv, config: &JObject) -> Result<jbyteAr
 
     let keybox = keybox::parse_keybox(&params.keybox_cert_chain, &params.keybox_private_key)?;
 
-    let attest_ext = attestation::build_attestation_extension(&params)?;
+    let cert_chain = if params.attestation_challenge.is_some() {
-
+        let attest_ext = attestation::build_attestation_extension(&params)?;
-    let cert_chain = certbuilder::build_certificate_chain(
+        // Ground truth of what the Rust forger emitted, keyed to the app. Gated on the APK debug
-        &key_pair,
+        // variant so release builds never dump the extension.
-        &attest_ext,
+        if params.debug_logging {
-        &keybox,
+            tracing::info!(
-        &params,
+                uid = params.uid,
-    )?;
+                ext_hex = %hex_encode(&attest_ext),
+                "produced attestation extension"
+            );
+        }
+        certbuilder::build_certificate_chain(&key_pair, Some(&attest_ext), &keybox, &params)?
+    } else {
+        tracing::info!(
+            uid = params.uid,
+            "no attestation challenge, generating self-signed cert (depth 1)"
+        );
+        certbuilder::build_self_signed_cert(&key_pair, &params)?
+    };
 
     let blob = assemble_result(&key_pair.private_key_pkcs8, &cert_chain);
+    tracing::info!(uid = params.uid, certs = cert_chain.len(), "assembled native cert result");
 
     let out = env.byte_array_from_slice(&blob)?;
     Ok(out.into_raw())
 }
 
+/// Lowercase hex of a byte slice for diagnostic dumps; the crate has no `hex` dependency.
+fn hex_encode(bytes: &[u8]) -> String {
+    use std::fmt::Write as _;
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for b in bytes {
+        let _ = write!(out, "{:02x}", b);
+    }
+    out
+}
+
 // ---------------------------------------------------------------------------
 // JNI entry: initLogging
 // ---------------------------------------------------------------------------
@@ -118,44 +140,6 @@ fn init_logging_inner(env: &mut JNIEnv, verbose: jboolean, log_dir: &JString) ->
     Ok(())
 }
 
-// ---------------------------------------------------------------------------
-// JNI entry: dumpLogs
-// ---------------------------------------------------------------------------
-
-#[no_mangle]
-pub extern "system" fn Java_org_matrix_TEESimulator_pki_NativeCertGen_dumpLogs(
-    mut env: JNIEnv,
-    _class: JClass,
-) -> jstring {
-    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
-        dump_logs_inner(&mut env)
-    }));
-
-    match result {
-        Ok(Ok(raw)) => raw,
-        Ok(Err(e)) => {
-            tracing::error!(%e, "dumpLogs failed");
-            std::ptr::null_mut()
-        }
-        Err(_) => {
-            tracing::error!("dumpLogs panicked");
-            std::ptr::null_mut()
-        }
-    }
-}
-
-fn dump_logs_inner(env: &mut JNIEnv) -> Result<jstring> {
-    logging::dump::execute_dump()
-        .map_err(|e| CertGenError::Jni(format!("dump failed: {e}")))?;
-
-    // Read the dump path written by execute_dump
-    let path = std::fs::read_to_string("/data/adb/tricky_store/.dump_path")
-        .map_err(|e| CertGenError::Jni(format!("read dump path: {e}")))?;
-
-    let jpath = env.new_string(&path)?;
-    Ok(jpath.into_raw())
-}
-
 // ---------------------------------------------------------------------------
 // Config extraction from Java CertGenConfig object
 // ---------------------------------------------------------------------------
@@ -199,6 +183,16 @@ fn extract_config(env: &mut JNIEnv, config: &JObject) -> Result<CertGenParams> {
     let id_model = get_nullable_byte_array(env, config, "idModel")?;
     let id_second_imei = get_nullable_byte_array(env, config, "idSecondImei")?;
 
+    let active_datetime = get_long(env, config, "activeDatetime")?;
+    let origination_expire_datetime = get_long(env, config, "originationExpireDatetime")?;
+    let usage_expire_datetime = get_long(env, config, "usageExpireDatetime")?;
+    let usage_count_limit = get_int(env, config, "usageCountLimit")?;
+    let caller_nonce = get_boolean(env, config, "callerNonce")?;
+    let unlocked_device_required = get_boolean(env, config, "unlockedDeviceRequired")?;
+    let no_auth_required = get_boolean(env, config, "noAuthRequired")?;
+    let uid = get_int(env, config, "uid")?;
+    let debug_logging = get_boolean(env, config, "debugLogging")?;
+
     Ok(CertGenParams {
         algorithm: Algorithm::try_from(algorithm)?,
         key_size: key_size as u32,
@@ -238,6 +232,15 @@ fn extract_config(env: &mut JNIEnv, config: &JObject) -> Result<CertGenParams> {
         id_manufacturer,
         id_model,
         id_second_imei,
+        active_datetime,
+        origination_expire_datetime,
+        usage_expire_datetime,
+        usage_count_limit,
+        caller_nonce,
+        unlocked_device_required,
+        no_auth_required,
+        uid,
+        debug_logging,
     })
 }
 
@@ -253,6 +256,10 @@ fn get_long(env: &mut JNIEnv, obj: &JObject, name: &str) -> Result<i64> {
     Ok(env.get_field(obj, name, "J")?.j()?)
 }
 
+fn get_boolean(env: &mut JNIEnv, obj: &JObject, name: &str) -> Result<bool> {
+    Ok(env.get_field(obj, name, "Z")?.z()?)
+}
+
 fn get_byte_array(env: &mut JNIEnv, obj: &JObject, name: &'static str) -> Result<Vec<u8>> {
     let field = env.get_field(obj, name, "[B")?.l()?;
     if field.is_null() {

native-certgen/src/logging/dump.rs

@@ -1,208 +0,0 @@
-use std::fs::{self, File};
-use std::io::{Read, Write};
-use std::path::Path;
-use std::process::Command;
-use std::time::{SystemTime, UNIX_EPOCH};
-
-const DUMP_DIR: &str = "/sdcard/Download";
-const LOCK_PATH: &str = "/data/adb/tricky_store/.dump_lock";
-const DUMP_PATH_FILE: &str = "/data/adb/tricky_store/.dump_path";
-const LOG_DIR: &str = "/data/adb/tricky_store/logs";
-const BASE_DIR: &str = "/data/adb/tricky_store";
-const LOGCAT_SIZE_LIMIT: usize = 2 * 1024 * 1024;
-
-struct FlockGuard {
-    _file: File,
-}
-
-impl FlockGuard {
-    fn acquire() -> Result<Self, Box<dyn std::error::Error>> {
-        if let Some(parent) = Path::new(LOCK_PATH).parent() {
-            fs::create_dir_all(parent)?;
-        }
-        let file = File::create(LOCK_PATH)?;
-        let fd = {
-            use std::os::unix::io::AsRawFd;
-            file.as_raw_fd()
-        };
-        let ret = unsafe { libc::flock(fd, libc::LOCK_EX | libc::LOCK_NB) };
-        if ret != 0 {
-            return Err("dump already in progress".into());
-        }
-        Ok(Self { _file: file })
-    }
-}
-
-impl Drop for FlockGuard {
-    fn drop(&mut self) {
-        // flock released automatically when file descriptor closes
-    }
-}
-
-fn random_name(len: usize) -> String {
-    use rand::Rng;
-    let mut rng = rand::thread_rng();
-    (0..len)
-        .map(|_| {
-            let idx = rng.gen_range(0..36u8);
-            if idx < 10 {
-                (b'0' + idx) as char
-            } else {
-                (b'a' + idx - 10) as char
-            }
-        })
-        .collect()
-}
-
-fn collect_logcat(tag: &str) -> Vec<u8> {
-    let output = Command::new("logcat")
-        .args(["-d", "-s", tag])
-        .output();
-
-    match output {
-        Ok(o) => {
-            let mut data = o.stdout;
-            data.truncate(LOGCAT_SIZE_LIMIT);
-            data
-        }
-        Err(_) => Vec::new(),
-    }
-}
-
-fn collect_device_info() -> String {
-    let mut info = String::new();
-
-    if let Ok(output) = Command::new("uname").arg("-a").output() {
-        info.push_str(&format!(
-            "uname={}\n",
-            String::from_utf8_lossy(&output.stdout).trim()
-        ));
-    }
-
-    for (key, prop) in [
-        ("device", "ro.product.device"),
-        ("build", "ro.build.display.id"),
-        ("android", "ro.build.version.release"),
-    ] {
-        if let Ok(output) = Command::new("getprop").arg(prop).output() {
-            info.push_str(&format!(
-                "{}={}\n",
-                key,
-                String::from_utf8_lossy(&output.stdout).trim()
-            ));
-        }
-    }
-
-    // KSU version
-    if let Ok(ver) = fs::read_to_string("/data/adb/ksu/version") {
-        info.push_str(&format!("ksu={}\n", ver.trim()));
-    }
-
-    // Module version from module.prop
-    if let Ok(prop) = fs::read_to_string("/data/adb/modules/tricky_store/module.prop") {
-        for line in prop.lines() {
-            if let Some(ver) = line.strip_prefix("version=") {
-                info.push_str(&format!("module={}\n", ver.trim()));
-                break;
-            }
-        }
-    }
-
-    info
-}
-
-fn read_file_bytes(path: &str) -> Option<Vec<u8>> {
-    let mut buf = Vec::new();
-    File::open(path).ok()?.read_to_end(&mut buf).ok()?;
-    Some(buf)
-}
-
-fn epoch_millis() -> u64 {
-    SystemTime::now()
-        .duration_since(UNIX_EPOCH)
-        .map(|d| d.as_millis() as u64)
-        .unwrap_or(0)
-}
-
-pub fn execute_dump() -> Result<(), Box<dyn std::error::Error>> {
-    let _lock = FlockGuard::acquire()?;
-
-    let _ = fs::create_dir_all(DUMP_DIR);
-    let zip_name = format!("{}.zip", random_name(8));
-    let zip_path = format!("{}/{}", DUMP_DIR, zip_name);
-
-    let zip_file = File::create(&zip_path)?;
-    let mut zip = zip::ZipWriter::new(zip_file);
-    let options =
-        zip::write::SimpleFileOptions::default().compression_method(zip::CompressionMethod::Deflated);
-
-    let mut file_count = 0u32;
-
-    // Log files
-    let log_files = [
-        "certgen.log",
-        "certgen.log.1",
-        "certgen.log.2",
-        "certgen.log.3",
-        "certgen.log.4",
-    ];
-    for name in &log_files {
-        let path = format!("{}/{}", LOG_DIR, name);
-        if let Some(data) = read_file_bytes(&path) {
-            zip.start_file(*name, options)?;
-            zip.write_all(&data)?;
-            file_count += 1;
-        }
-    }
-
-    // Logcat
-    let logcat = collect_logcat("TEESimulator");
-    if !logcat.is_empty() {
-        zip.start_file("logcat-teesimulator.log", options)?;
-        zip.write_all(&logcat)?;
-        file_count += 1;
-    }
-
-    // Config files
-    for name in ["tee_status.txt", "security_patch.txt"] {
-        let path = format!("{}/{}", BASE_DIR, name);
-        if let Some(data) = read_file_bytes(&path) {
-            zip.start_file(name, options)?;
-            zip.write_all(&data)?;
-            file_count += 1;
-        }
-    }
-
-    // Device info
-    let device_info = collect_device_info();
-    if !device_info.is_empty() {
-        zip.start_file("device-info.txt", options)?;
-        zip.write_all(device_info.as_bytes())?;
-        file_count += 1;
-    }
-
-    // Manifest
-    let manifest = serde_json::json!({
-        "timestamp": epoch_millis(),
-        "version": env!("CARGO_PKG_VERSION"),
-        "files": file_count,
-    });
-    zip.start_file("manifest.json", options)?;
-    zip.write_all(manifest.to_string().as_bytes())?;
-
-    zip.finish()?;
-
-    let zip_size = fs::metadata(&zip_path).map(|m| m.len()).unwrap_or(0);
-    fs::write(DUMP_PATH_FILE, &zip_path)?;
-
-    let result = serde_json::json!({
-        "zip": zip_path,
-        "size": zip_size,
-        "files": file_count + 1, // +1 for manifest
-    });
-    println!("{}", result);
-
-    tracing::info!(path = %zip_path, size = zip_size, "diagnostic dump created");
-
-    Ok(())
-}

native-certgen/src/logging/mod.rs

@@ -1,7 +1,5 @@
 mod kmsg;
 mod rotating;
-pub mod sysfs;
-pub mod dump;
 
 use std::path::Path;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};

native-certgen/src/logging/sysfs.rs

@@ -1,38 +0,0 @@
-use std::fs;
-use std::path::Path;
-
-const VERBOSE_MARKER: &str = "/data/adb/tricky_store/.verbose";
-
-pub fn is_verbose() -> bool {
-    Path::new(VERBOSE_MARKER).exists()
-}
-
-pub fn set_verbose_marker(enabled: bool) -> Result<(), Box<dyn std::error::Error>> {
-    if enabled {
-        if let Some(parent) = Path::new(VERBOSE_MARKER).parent() {
-            fs::create_dir_all(parent)?;
-        }
-        fs::write(VERBOSE_MARKER, "")?;
-    } else if Path::new(VERBOSE_MARKER).exists() {
-        fs::remove_file(VERBOSE_MARKER)?;
-    }
-    Ok(())
-}
-
-pub fn enable() -> Result<(), Box<dyn std::error::Error>> {
-    set_verbose_marker(true)?;
-    tracing::info!("verbose logging enabled via marker file");
-    Ok(())
-}
-
-pub fn disable() -> Result<(), Box<dyn std::error::Error>> {
-    set_verbose_marker(false)?;
-    tracing::info!("verbose logging disabled, marker file removed");
-    Ok(())
-}
-
-pub fn status() -> Result<(), Box<dyn std::error::Error>> {
-    let state = if is_verbose() { "enabled" } else { "disabled" };
-    tracing::info!(verbose = state, "verbose marker status");
-    Ok(())
-}

native-certgen/src/types.rs

@@ -42,35 +42,6 @@ impl TryFrom<i32> for EcCurve {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(i32)]
-pub enum KeyPurpose {
-    Encrypt = 0,
-    Decrypt = 1,
-    Sign = 2,
-    Verify = 3,
-    WrapKey = 5,
-    AgreeKey = 6,
-    AttestKey = 7,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(i32)]
-pub enum SecurityLevel {
-    Software = 0,
-    TrustedEnvironment = 1,
-    StrongBox = 2,
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-#[repr(i32)]
-pub enum VerifiedBootState {
-    Verified = 0,
-    SelfSigned = 1,
-    Unverified = 2,
-    Failed = 3,
-}
-
 pub struct CertGenParams {
     pub algorithm: Algorithm,
     pub key_size: u32,
@@ -114,6 +85,19 @@ pub struct CertGenParams {
     pub id_manufacturer: Option<Vec<u8>>,
     pub id_model: Option<Vec<u8>>,
     pub id_second_imei: Option<Vec<u8>>,
+
+    pub active_datetime: i64,
+    pub origination_expire_datetime: i64,
+    pub usage_expire_datetime: i64,
+    pub usage_count_limit: i32,
+    pub caller_nonce: bool,
+    pub unlocked_device_required: bool,
+    pub no_auth_required: bool,
+
+    /// Calling app UID, used only to key diagnostic log lines to the requesting app.
+    pub uid: i32,
+    /// Mirrors the APK debug variant; gates the produced-extension dump so release stays quiet.
+    pub debug_logging: bool,
 }
 
 pub struct GeneratedKeyPair {

scripts/package.sh

@@ -10,6 +10,12 @@
 #   ./scripts/package.sh --rust --release             # build Rust crate first, then release
 set -euo pipefail
 
+# Gradle's buildRustCertgen resolves `cargo` against the daemon's inherited PATH,
+# not the env we inject via gradle's Exec.environment(). Prepend the per-user
+# rustup install so non-login shells (CI, IDE-launched terminals, fresh tmux)
+# still find it without sourcing /etc/profile.d/cargo-path.sh.
+[ -d "$HOME/.cargo/bin" ] && PATH="$HOME/.cargo/bin:$PATH"
+
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 OUT_DIR="$PROJECT_ROOT/out"
@@ -21,6 +27,7 @@ REBOOT=false
 VERIFY=false
 BUILD_RUST=false
 CLEAR_KEYS=false
+CLEAR_LOGS=false
 TRACE=false
 ROOT_PROVIDER="ksu"
 
@@ -46,6 +53,7 @@ Deploy options:
   --deploy           Push ZIP to device and install
   --reboot           Reboot device after install
   --clear-keys       Clear persistent_keys before deploy
+  --clear-logs       Clear per-UID diagnostic logs before deploy
   --verify           Run logcat verification after deploy
   --root PROVIDER    Root provider: ksu (default), magisk, apatch
 
@@ -67,6 +75,7 @@ while [[ $# -gt 0 ]]; do
         --verify)     VERIFY=true; shift ;;
         --rust)       BUILD_RUST=true; shift ;;
         --clear-keys) CLEAR_KEYS=true; shift ;;
+        --clear-logs) CLEAR_LOGS=true; shift ;;
         -v|--verbose) TRACE=true; shift ;;
         --root)       ROOT_PROVIDER="$2"; shift 2 ;;
         --help|-h)    usage ;;
@@ -147,6 +156,11 @@ deploy_zip() {
         adb shell "rm -rf /data/adb/tricky_store/persistent_keys/*" 2>/dev/null || true
     fi
 
+    if [[ "$CLEAR_LOGS" == true ]]; then
+        bold "==> Clearing per-UID diagnostic logs"
+        adb shell "rm -rf /data/media/0/TEESimulator /data/local/tmp/teesim" 2>/dev/null || true
+    fi
+
     bold "==> Deploying $name"
     adb push "$zip" /data/local/tmp/module.zip
     adb shell "su -c '$INSTALL_CMD /data/local/tmp/module.zip'"
@@ -235,7 +249,7 @@ print_summary() {
 
 # --- Main ---
 echo ""
-bold "TEESimulator package pipeline"
+bold "TEESimulator-RS package pipeline"
 echo ""
 
 [[ "$BUILD_RUST" == true ]] && build_rust

settings.gradle.kts

@@ -14,7 +14,7 @@ dependencyResolutionManagement {
     }
 }
 
-rootProject.name = "TEESimulator"
+rootProject.name = "TEESimulator-RS"
 
 include(":stub")
 

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!");

stub/src/main/java/android/os/SELinux.java

@@ -0,0 +1,8 @@
+package android.os;
+
+public class SELinux {
+    public static boolean checkSELinuxAccess(
+            String scon, String tcon, String tclass, String perm) {
+        throw new UnsupportedOperationException("STUB!");
+    }
+}

stub/src/main/java/android/os/ServiceManager.java

@@ -17,6 +17,10 @@ public class ServiceManager {
         throw new UnsupportedOperationException("STUB!");
     }
 
+    public static boolean isDeclared(String name) {
+        throw new UnsupportedOperationException("STUB!");
+    }
+
     public static String[] listServices() {
         throw new UnsupportedOperationException("STUB!");
     }

stub/src/main/java/android/os/ServiceSpecificException.java

@@ -0,0 +1,14 @@
+package android.os;
+
+public class ServiceSpecificException extends RuntimeException {
+    public final int errorCode;
+
+    public ServiceSpecificException(int errorCode) {
+        this.errorCode = errorCode;
+    }
+
+    public ServiceSpecificException(int errorCode, String message) {
+        super(message);
+        this.errorCode = errorCode;
+    }
+}

stub/src/main/java/android/security/maintenance/IKeystoreMaintenance.java

@@ -0,0 +1,22 @@
+package android.security.maintenance;
+
+import android.os.IBinder;
+
+/**
+ * Compile-time stub for the hidden keystore2 maintenance binder
+ * ({@code android.security.maintenance.IKeystoreMaintenance}).
+ *
+ * <p>This module is a {@code compileOnly} dependency, so the real framework class
+ * (which carries the actual {@code TRANSACTION_*} codes) is loaded at runtime. We
+ * only need the {@link #DESCRIPTOR} token to parse the transaction parcel and the
+ * inner {@code Stub} class so {@code getTransactCode} can reflect the real codes.
+ */
+public interface IKeystoreMaintenance {
+    String DESCRIPTOR = "android.security.maintenance.IKeystoreMaintenance";
+
+    class Stub {
+        public static IKeystoreMaintenance asInterface(IBinder b) {
+            throw new UnsupportedOperationException("STUB!");
+        }
+    }
+}