docs(release): bump to v4.1 with changelog and update metadata

versionCode=94 matches post-commit count.
fix(attestation): persist vbmeta boot key and hash across reboots
2026-03-10 13:00:57 +01:00 · 2026-03-10 12:58:49 +01:00 · 2026-03-10 04:40:53 +01:00 · 2026-03-09 22:48:20 +01:00 · 2026-03-09 22:17:38 +01:00 · 2026-03-09 21:52:06 +01:00
79 changed files with 8652 additions and 737 deletions
@@ -60,7 +60,8 @@ jobs:
      - name: Build with Gradle
        run: |
          chmod +x ./gradlew
-          ./gradlew --parallel zipRelease zipDebug --stacktrace
+
          ./gradlew zipRelease zipDebug -Porg.gradle.parallel=true -Porg.gradle.vfs.watch=true -Dorg.gradle.jvmargs=-Xmx2048m
      - name: Prepare artifact
        if: success()
@@ -1,32 +1,124 @@
-# TEESimulator – A Full TEE Emulation Framework
+<p align="center">
  <h1 align="center">🔐 TEESimulator</h1>
  <p align="center"><b>Full TEE Emulation for Rooted Android</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">
    <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/Telegram-community-blue?style=for-the-badge&logo=telegram" alt="Telegram">
  </p>
 </p>
-**TEESimulator** is a system module designed to create a complete, software-based simulation of a hardware-backed Trusted Execution Environment ([TEE](https://source.android.com/docs/security/features/trusty)) for [Key Attestation](https://developer.android.com/privacy-and-security/security-key-attestation).
+---
-The project's goal is to move beyond simple certificate patching and build a robust framework that can create and manage virtual, self-consistent cryptographic keys.
+> [!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.
-## ✨ Core Principles
+---
-*   **Bypass Hardware-Backed Attestation:** The primary goal of this project is to defeat Key Attestation, a security mechanism that allows apps to verify that they are running on a secure, unmodified device. This module provides the tools to bypass these checks on rooted or modified devices.
+## 🧬 What is TEESimulator?
 *   **Stateful Emulation:** Instead of patching responses from the real TEE, the ultimate goal is to create and manage virtual keys entirely in a simulated software environment. Any request concerning a virtual key will be handled by the simulator, ensuring perfect consistency without ever touching the real hardware.
 *   **Architectural Interception:** By hooking low-level Binder IPC calls to the Keystore, the framework can transparently redirect requests for virtual keys to the software-based simulator, while allowing requests for real keys to pass through to the hardware TEE.
 *   **100% FOSS:** Licensed under GPLv3, ensuring it stays free, auditable, and compliant with open-source laws.
-## 📱 Requirements
+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.
 - Android 10 or above
-## 📦 Installation & Configuration
+The result: **apps that verify hardware attestation see a legitimate, unmodified device** — even on rooted hardware with an unlocked bootloader.
-1.  Flash this module via (Magisk / KernelSU / APatch) and reboot. It will replace [TrickyStore](https://github.com/5ec1cff/TrickyStore), [TrickyStoreOSS](https://github.com/beakthoven/TrickyStoreOSS) and their forks.
+> **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.
 2.  (Optional) Place a hardware-backed `keybox.xml` at `/data/adb/tricky_store/keybox.xml`. This provides the cryptographic "root of trust" for the simulator.
 3.  (Optional) Customize target packages in `/data/adb/tricky_store/target.txt`.
 4.  (Optional) Customize the simulated security patch level in `/data/adb/tricky_store/security_patch.txt`.
 5.  Enjoy!
-**All configuration files are monitored and will take effect immediately upon saving.**
+---
 ## 🔥 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:**
 1. Android 10 or above
 2. A supported root manager (KernelSU, Magisk, or APatch)
 3. A hardware-backed `keybox.xml` placed at `/data/adb/tricky_store/keybox.xml`
 ---
 ## 📱 Compatibility
 ### Root Managers
 | Manager | Status | Notes |
 |---|---|---|
 | KernelSU | ✅ Tested | Full support including Action button and lifecycle scripts |
 | Magisk | ✅ Supported | Standard module install |
 | APatch | ✅ Supported | Standard module install |
 ### Tested Devices
 | Device | Android | TEE | Status |
 |---|---|---|---|
 | Redmi 14C (2409BRN2CA) | 14 (SDK 34) | Beanpod KeyMaster | ✅ Daily driver |
 > 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.
 ---
 ## 🚀 Quick Start
 1. **Download** the latest release ZIP from [Releases](https://github.com/Enginex0/TEESimulator/releases)
 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.
 ---
 ## ⚙️ Configuration
 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 for the simulator. It contains a private key and a valid, hardware-backed certificate chain from a real device. The simulator uses this to sign the virtual certificates it generates, making them appear legitimate to verifiers.
+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"?>
@@ -40,48 +132,106 @@ This file provides the master cryptographic identity for the simulator. It conta
 </AndroidAttestation>
 ```
-### Mode and Keybox Configuration (`target.txt`)
+### Target Packages (`target.txt`)
-TEESimulator currently operates in two primary modes as it transitions towards full emulation.
+Controls which apps get intercepted and what simulation mode to use.
 You can control the simulation mode and the specific keybox.xml file used on a per-package basis.
 #### Mode Suffixes
-*   **`!` → Force Generation Mode:** Creates a complete, software-based virtual key. This is the foundation of the full TEE simulation.
+*   **`!` → Force Generation** — Creates a complete software-based virtual key. Full TEE simulation.
-*   **`?` → Force Leaf Hacking Mode:** A legacy mode where a real TEE key is generated, but its attestation certificate is intercepted and modified.
+*   **`?` → Force Leaf Hacking** — Real TEE key generated, but its attestation certificate is intercepted and patched.
-*   **No symbol → Automatic Mode:** The module selects the most appropriate mode for the device.
+*   **No symbol → Automatic** — Module selects the best mode for your device.
-#### Multi-Keybox Configuration
+#### Multi-Keybox
-You can specify different keybox files for different groups of applications. This is done by adding a line with the filename in square brackets (e.g., [demo_keybox.xml]).
+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`.
 All applications listed after this line will use the specified keybox file, until a new keybox is declared. Applications listed before any custom keybox declaration will use the default `keybox.xml`.
 For example:
 ```
-# These two apps will use the default /data/adb/tricky_store/keybox.xml
+# Default keybox
 com.google.android.gms!
 io.github.vvb2060.keyattestation?
-# Switch to a different keybox for the following apps.
+# Switch to a different keybox for the following apps
 # The file must be located at /data/adb/tricky_store/aosp_keybox.xml
 [aosp_keybox.xml]
 com.google.android.gsf
-# Switch again to another keybox.
+# Another keybox
 # The file must be located at /data/adb/tricky_store/demo_keybox.xml
 [demo_keybox.xml]
 org.matrix.demo
 ```
 ### Security Patch Level (`security_patch.txt`)
-This allows you to configure the security patch level that the simulator will report in its forged attestation certificates.
+Configure the `osPatchLevel`, `vendorPatchLevel`, and `bootPatchLevel` reported in attestation certificates. This only affects attestation data — it does not change actual system properties.
 #### Global and Per-Package
 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 |
 | `all` | Shorthand — sets all three at once |
 #### Special Keywords
 | 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
 ```
-# Advanced Configuration
+# Global — default for all apps
-system=2025-11
+system=YYYY-MM-05
-boot=no        # Do not report a boot patch level
+vendor=device_default
-vendor=20251101 # Report a specific vendor patch level
+boot=no
 # Override for GMS
 [com.google.android.gms]
 system=2024-10-01
 # Custom config for a demo app
 [org.matrix.demo]
 all=2025-09-15
 boot=device_default
 ```
-**Note:** This only affects the Key Attestation data generated by the simulator. It does not change system properties.
+
 ---
 ## 💬 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">
  </a>
 </p>
 ---
 ## 🙏 Credits
 - **[JingMatrix](https://github.com/JingMatrix/TEESimulator)** — original author of TEESimulator and the interception architecture
 - **[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
 ---
 ## 📄 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>
@@ -29,7 +29,7 @@ val gitExecutor = objects.newInstance(GitExecutor::class.java)
 val gitCommitCount = gitExecutor.execute("git rev-list HEAD --count", rootDir).toInt()
 val gitCommitHash = gitExecutor.execute("git rev-parse --verify --short HEAD", rootDir)
-val verName = "v2.0"
+val verName = "v4.1"
 android {
    namespace = "org.matrix.TEESimulator"
@@ -56,6 +56,7 @@ android {
        sourceCompatibility = JavaVersion.VERSION_21
        targetCompatibility = JavaVersion.VERSION_21
    }
    buildFeatures { buildConfig = true }
    externalNativeBuild {
        cmake {
            path = file("src/main/cpp/CMakeLists.txt")
@@ -70,6 +71,35 @@ dependencies {
    implementation(libs.bcpkix)
 }
 // --- Rust native cert gen build task ---
 val buildRustCertgen by tasks.registering(Exec::class) {
    group = "TEESimulator Native Build"
    description = "Builds libcertgen.so via cargo-ndk for arm64-v8a."
    workingDir = rootProject.projectDir.resolve("native-certgen")
    commandLine(
        "cargo", "ndk",
        "-t", "arm64-v8a",
        "-o", rootProject.projectDir.resolve("app/src/main/jniLibs").absolutePath,
        "build", "--release"
    )
    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.lock"))
    outputs.dir(rootProject.projectDir.resolve("app/src/main/jniLibs"))
    environment("ANDROID_NDK_HOME", android.ndkDirectory.absolutePath)
 }
 // AGP auto-detects jniLibs/ as an input to mergeJniLibFolders — wire the dependency
 tasks.configureEach {
    if (name.endsWith("JniLibFolders") && name.startsWith("merge")) {
        dependsOn(buildRustCertgen)
    }
 }
 androidComponents {
    onVariants(selector().all()) { variant ->
        val capitalized = variant.name.replaceFirstChar { it.uppercase() }
@@ -93,6 +123,7 @@ androidComponents {
                    dependsOn("minify${capitalized}WithR8")
                }
                dependsOn("strip${capitalized}DebugSymbols")
                dependsOn(buildRustCertgen)
                if (isDebug) {
                    from(variant.artifacts.get(SingleArtifact.APK)) {
@@ -115,7 +146,7 @@ androidComponents {
                    )
                ) {
                    into("lib") // Place them in the 'lib' subfolder of the staging directory.
-                    include("**/libinject.so", "**/libTEESimulator.so")
+                    include("**/libinject.so", "**/libTEESimulator.so", "**/libsupervisor.so", "**/libcertgen.so")
                }
                // Now, copy and process the files from 'module' directory.
@@ -7,3 +7,9 @@
 -keepclasseswithmembers class org.matrix.TEESimulator.App {
    public static void main(java.lang.String[]);
 }
 -keepclasseswithmembers class org.matrix.TEESimulator.pki.NativeCertGen {
    native <methods>;
    *;
 }
 -keep class org.matrix.TEESimulator.pki.CertGenConfig { *; }
@@ -22,6 +22,9 @@ add_executable(libinject.so inject/main.cpp inject/utils.cpp)
 target_include_directories(libinject.so PUBLIC include)
 target_link_libraries(libinject.so PRIVATE lsplt_static)
 add_executable(libsupervisor.so supervisor.cpp)
 target_link_libraries(libsupervisor.so PRIVATE log)
 add_library(${CMAKE_PROJECT_NAME} SHARED binder_interceptor.cpp)
 target_include_directories(${CMAKE_PROJECT_NAME} PUBLIC external/linux-kernel/include include)
 target_link_libraries(${CMAKE_PROJECT_NAME} PRIVATE binder lsplt_static utils)
@@ -276,6 +276,12 @@ static sp<BinderInterceptor> g_interceptor_instance = nullptr;
 // =============================================================================================
 class BinderStub : public BBinder {
 public:
    const String16& getInterfaceDescriptor() const override {
        static const String16 kDescriptor("org.matrix.TEESimulator.BinderStub");
        return kDescriptor;
    }
 protected:
    status_t onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) override {
        if (code != intercept::kBackdoorCode) {
@@ -342,15 +348,16 @@ static sp<BinderStub> g_stub_instance = nullptr;
 namespace {
-/**
+constexpr binder_size_t kMaxInterceptableDataSize = 256 * 1024;
- * @brief Analyses a binder transaction. If the target is monitored,
+
 *        hijacks the transaction by rewriting its destination to our BinderStub.
 * @param txn_data Pointer to the transaction data within the ioctl buffer.
 */
 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
    if (txn_data->data_size > kMaxInterceptableDataSize)
        return;
    bool hijack = false;
    ThreadTransactionInfo info;
@@ -359,9 +366,15 @@ void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
        info.transaction_code = intercept::kBackdoorCode;
        info.target_binder = nullptr;
        hijack = true;
-    }
+    // Check 2: Spoof uid of KeyStore requests from the daemon to bypass permission check
-    // Check 2: Normal interception based on registry of monitored binders
+    } else if (txn_data->sender_euid == 0) {
-    else {
+        // The kernel driver fills sender_euid.
        // libbinder.so trusts this value to populate IPCThreadState.
        txn_data->sender_euid = 1000;
        LOGV("[Hook] Spoofing UID for transaction: 0 -> %d", txn_data->sender_euid);
        hijack = false; // Never hijack to avoid recursion
    // Check 3: Normal interception based on registry of monitored binders
    } else {
        // Safe casting based on Binder driver ABI
        RefBase::weakref_type *weak_ref = reinterpret_cast<RefBase::weakref_type *>(txn_data->target.ptr);
@@ -370,18 +383,17 @@ void inspectAndRewriteTransaction(binder_transaction_data *txn_data) {
            // The raw pointer to the binder object itself is stored in the cookie
            BBinder *target_binder_ptr = reinterpret_cast<BBinder *>(txn_data->cookie);
-            // This is safe ONLY because we successfully called attemptIncStrong().
+            // Create a weak pointer for the lookup and to store in our context map.
-            // The sp<> constructor will not increment the ref count again, it just adopts the one we have.
+            // This is safe because we are holding a strong reference.
-            // When sp_target goes out of scope, it will call decStrong(), releasing our temporary reference.
+            wp<BBinder> wp_target = target_binder_ptr;
            sp<BBinder> sp_target = sp<BBinder>::fromExisting(target_binder_ptr);
-            // Now we can safely use sp_target (which implicitly converts to a wp) for the lookup.
+            if (g_interceptor_instance->isBinderIntercepted(wp_target)) {
            if (g_interceptor_instance->isBinderIntercepted(sp_target)) {
                info.transaction_code = txn_data->code;
-                info.target_binder = sp_target; // Assign the valid weak pointer
+                info.target_binder = wp_target; // Assign the valid weak pointer
                hijack = true;
            }
-            // No need to manually call decStrong(); the sp destructor handles it.
+            // Manually release the temporary strong reference we acquired at the start.
            target_binder_ptr->decStrong(nullptr);
        }
    }
@@ -581,9 +593,16 @@ bool BinderInterceptor::processInterceptedTransaction(uint64_t tx_id, sp<BBinder
    Parcel pre_req, pre_resp;
    writeTransactionData(pre_req, tx_id, target, code, flags, request);
-    if (callback->transact(intercept::kPreTransact, pre_req, &pre_resp) != OK) {
+    status_t pre_status = callback->transact(intercept::kPreTransact, pre_req, &pre_resp);
-        LOGW("[TX_ID: %" PRIu64 "] Pre-transaction callback failed. Forwarding original call.", tx_id);
+    if (pre_status != OK) {
-        return false; // Callback failed, proceed as if not intercepted
+        // Block when interceptor is dead to prevent privacy leak to third-party apps
        if (callback->pingBinder() != OK) {
            LOGE("[TX_ID: %" PRIu64 "] Interceptor DEAD. Blocking to prevent attestation leak.", tx_id);
            result = DEAD_OBJECT;
            return true;
        }
        LOGW("[TX_ID: %" PRIu64 "] Pre-transaction callback failed (not dead). Forwarding.", tx_id);
        return false;
    }
    int32_t action = pre_resp.readInt32();
@@ -636,7 +655,8 @@ bool BinderInterceptor::processInterceptedTransaction(uint64_t tx_id, sp<BBinder
        VALIDATE_STATUS(tx_id, post_req.appendFrom(reply, 0, reply_size));
    }
-    if (callback->transact(intercept::kPostTransact, post_req, &post_resp) == OK) {
+    status_t post_status = callback->transact(intercept::kPostTransact, post_req, &post_resp);
    if (post_status == OK) {
        int32_t post_action = post_resp.readInt32();
        if (post_action == intercept::kActionOverrideReply && reply) {
            result = post_resp.readInt32(); // Read new status
@@ -7,6 +7,7 @@
 #include <sys/mman.h>
 #include <sys/ptrace.h>
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/system_properties.h>
 #include <sys/uio.h>
 #include <sys/un.h>
@@ -17,6 +18,7 @@
 #include <csignal>
 #include <cstdio>
 #include <cstdlib>
 #include <fstream>
 #include <optional>
 #include <string>
 #include <vector>
@@ -95,10 +97,6 @@ constexpr size_t kMagicLength = 16;
 constexpr size_t kMaxPathLength = PATH_MAX;
 // Maximum length for file paths.
 constexpr const char *kSystemFileContext = "u:object_r:system_file:s0";
 // SELinux context for system files,
 // used for socket creation and library file context.
 constexpr const char *kLibcModule = "libc.so";
 // Name of the C standard library.
@@ -215,8 +213,8 @@ private:
 * @brief Transfers a file descriptor from the injector process to the remote process.
 *
 * This function uses Unix domain sockets with SCM_RIGHTS to send a file descriptor.
- * It involves setting SELinux contexts, creating local and remote sockets, binding,
+ * It involves creating local and remote sockets, binding, and then coordinating
- * and then coordinating sendmsg/recvmsg calls using ptrace.
+ * sendmsg/recvmsg calls using ptrace.
 *
 * @param pid The target process ID.
 * @param lib_path The path to the library file being transferred.
@@ -233,29 +231,14 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
                                                uintptr_t libc_return_addr) {
    LOGD("Attempting to transfer file descriptor for library: %s", lib_path);
-    // 1. Set SELinux context for socket creation in the injector process.
+    // Create a local Unix domain socket for FD transfer.
    // This is crucial for Android where SELinux might prevent socket operations.
    if (!set_sockcreate_con(constants::kSystemFileContext)) {
        LOGE("Failed to set socket creation context.");
        return std::nullopt;
    }
    // 2. Create a local Unix domain socket for FD transfer.
    UniqueFd local_socket = socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0);
    if (local_socket == -1) {
        PLOGE("Failed to create local Unix domain socket.");
        return std::nullopt;
    }
-    // 3. Set SELinux context for the library file if possible.
+    // Open the local library file to get a file descriptor.
    // This might be required for the target process to open/access it later if directly opening by path.
    // For FD transfer, this is less critical as the FD's context is inherited, but good practice.
    if (setfilecon(lib_path, constants::kSystemFileContext) == -1) {
        // Log a warning, but don't fail, as FD transfer might still work.
        PLOGE("Failed to set context of library file: %s. This might cause issues.", lib_path);
    }
    // 4. Open the local library file to get a file descriptor.
    UniqueFd local_lib_fd = open(lib_path, O_RDONLY | O_CLOEXEC);
    if (local_lib_fd == -1) {
        PLOGE("Failed to open library file: %s", lib_path);
@@ -271,7 +254,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
        void *errno_addr; // Address of __errno for getting remote errno.
    } funcs{};
-    // 5. Resolve required libc functions in the remote process.
+    // Resolve required libc functions in the remote process.
    funcs.socket_addr = find_func_addr(local_map, remote_map, constants::kLibcModule, "socket");
    funcs.bind_addr = find_func_addr(local_map, remote_map, constants::kLibcModule, "bind");
    funcs.recvmsg_addr = find_func_addr(local_map, remote_map, constants::kLibcModule, "recvmsg");
@@ -306,25 +289,28 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
        }
    };
-    // 6. Create a Unix domain socket in the remote process.
+    // Create a Unix domain socket in the remote process.
    std::vector<uintptr_t> args = {AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0};
    int remote_fd = static_cast<int>(
        remote_call(pid, regs, reinterpret_cast<uintptr_t>(funcs.socket_addr), libc_return_addr, args));
-    if (remote_fd == -1) {
+    if (remote_fd <= 0) {
        // remote_call returns 0 on failure.
        // socket() returning 0 is technically possible (if stdin closed),
        // but highly unlikely for a daemon. We treat 0 as failure here to catch the injection error.
        errno = get_remote_errno(); // Set local errno for PLOGE.
-        PLOGE("Failed to create remote socket.");
+        PLOGE("Failed to create remote socket (returned %d).", remote_fd);
        return std::nullopt;
    }
    LOGD("Successfully created remote socket with FD: %d", remote_fd);
-    // 7. Generate a unique magic string for the abstract Unix domain socket path.
+    // Generate a unique magic string for the abstract Unix domain socket path.
    auto magic = generateMagic(constants::kMagicLength);
    struct sockaddr_un sock_addr{.sun_family = AF_UNIX, .sun_path = {0}};
    // Abstract Unix domain sockets have sun_path[0] as null, and the name starts from sun_path[1].
    memcpy(sock_addr.sun_path + 1, magic.c_str(), magic.size());
    socklen_t addr_len = sizeof(sock_addr.sun_family) + 1 + magic.size(); // Length includes null byte and magic.
-    // 8. Push the sockaddr_un structure to the remote process's stack.
+    // Push the sockaddr_un structure to the remote process's stack.
    auto remote_addr = push_memory(pid, regs, &sock_addr, sizeof(sock_addr));
    if (remote_addr == 0) {
        LOGE("Failed to push socket address to remote memory.");
@@ -332,7 +318,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
        return std::nullopt;
    }
-    // 9. Bind the remote socket to the abstract Unix domain socket path.
+    // Bind the remote socket to the abstract Unix domain socket path.
    args = {static_cast<uintptr_t>(remote_fd), remote_addr, static_cast<uintptr_t>(addr_len)};
    auto bind_result = remote_call(pid, regs, reinterpret_cast<uintptr_t>(funcs.bind_addr), libc_return_addr, args);
    if (bind_result == static_cast<uintptr_t>(-1)) {
@@ -346,7 +332,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
    // Prepare control message buffer for SCM_RIGHTS (file descriptor passing).
    char cmsgbuf[CMSG_SPACE(sizeof(int))] = {0};
-    // 10. Push the control message buffer to the remote process's stack.
+    // Push the control message buffer to the remote process's stack.
    auto remote_cmsgbuf = push_memory(pid, regs, &cmsgbuf, sizeof(cmsgbuf));
    if (remote_cmsgbuf == 0) {
        LOGE("Failed to push control message buffer to remote memory.");
@@ -359,7 +345,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
    msg_hdr.msg_control = reinterpret_cast<void *>(remote_cmsgbuf);
    msg_hdr.msg_controllen = sizeof(cmsgbuf);
-    // 11. Push the msghdr structure to the remote process's stack.
+    // Push the msghdr structure to the remote process's stack.
    auto remote_hdr = push_memory(pid, regs, &msg_hdr, sizeof(msg_hdr));
    if (remote_hdr == 0) {
        LOGE("Failed to push message header to remote memory.");
@@ -367,16 +353,16 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
        return std::nullopt;
    }
-    // 12. Initiate the remote recvmsg call. This will block the remote process.
+    // Initiate the remote recvmsg call. This will block the remote process.
    args = {static_cast<uintptr_t>(remote_fd), remote_hdr, MSG_WAITALL};
-    if (!remote_pre_call(pid, regs, reinterpret_cast<uintptr_t>(funcs.recvmsg_addr), 0, args)) {
+    if (!remote_pre_call(pid, regs, reinterpret_cast<uintptr_t>(funcs.recvmsg_addr), libc_return_addr, args)) {
        LOGE("Failed to initiate remote recvmsg call.");
        close_remote(remote_fd);
        return std::nullopt;
    }
    LOGD("Remote recvmsg initiated, waiting for FD transfer...");
-    // 13. Prepare the local msghdr for sending the file descriptor.
+    // Prepare the local msghdr for sending the file descriptor.
    // The msg_control and msg_name fields of the local msghdr are set up.
    msg_hdr.msg_control = &cmsgbuf; // Use local cmsgbuf for sending.
    msg_hdr.msg_name = &sock_addr;
@@ -396,7 +382,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
        *reinterpret_cast<int *>(CMSG_DATA(cmsg)) = local_lib_fd; // The FD to send.
    }
-    // 14. Send the file descriptor from the injector to the remote process.
+    // Send the file descriptor from the injector to the remote process.
    if (sendmsg(local_socket, &msg_hdr, 0) == -1) {
        PLOGE("Failed to send file descriptor to remote process.");
        // We do not close local_lib_fd here as it might be transferred even if
@@ -407,9 +393,9 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
    }
    LOGD("Local FD %d sent to remote process.", local_lib_fd.operator const int &());
-    // 15. Complete the remote recvmsg call. This will retrieve the return value.
+    // Complete the remote recvmsg call. This will retrieve the return value.
    auto recvmsg_result =
-        static_cast<ssize_t>(remote_post_call(pid, regs, 0)); // No specific expected return address for recvmsg
+        static_cast<ssize_t>(remote_post_call(pid, regs, libc_return_addr));
    if (recvmsg_result == -1) {
        errno = get_remote_errno();
        PLOGE("Remote recvmsg call failed.");
@@ -418,7 +404,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
    }
    LOGD("Remote recvmsg completed with result: %zd", recvmsg_result);
-    // 16. Read the control message buffer back from the remote process to extract the FD.
+    // Read the control message buffer back from the remote process to extract the FD.
    if (read_proc(pid, remote_cmsgbuf, &cmsgbuf, sizeof(cmsgbuf)) != sizeof(cmsgbuf)) {
        LOGE("Failed to read control message buffer from remote process.");
        close_remote(remote_fd);
@@ -439,7 +425,7 @@ static std::optional<int> transfer_fd_to_remote(int pid, const char *lib_path, s
    LOGI("Successfully transferred FD %d to remote process, new remote FD: %d", local_lib_fd.operator const int &(),
         transferred_fd);
-    // 17. Close the remote socket.
+    // Close the remote socket.
    close_remote(remote_fd);
    return transferred_fd;
@@ -642,6 +628,130 @@ static bool remote_call_entry(int pid, struct user_regs_struct &regs, uintptr_t
    return true; // Return true if the call itself completed, regardless of its return value.
 }
 /**
 * @brief RAII wrapper to ensure a temporary file is deleted (unlinked)
 * when the object goes out of scope.
 *
 * This is crucial for stealth: we want the library to exist on the filesystem
 * for the shortest time possible.
 */
 class ScopedFileDeleter {
 public:
    explicit ScopedFileDeleter(std::string path) : path_(std::move(path)) {}
    ~ScopedFileDeleter() {
        if (!path_.empty()) {
            LOGD("Cleaning up staged file: %s", path_.c_str());
            unlink(path_.c_str());
        }
    }
    // Disable copy to prevent double-deletion issues
    ScopedFileDeleter(const ScopedFileDeleter&) = delete;
    ScopedFileDeleter& operator=(const ScopedFileDeleter&) = delete;
 private:
    std::string path_;
 };
 /**
 * @brief Copies a file from source to destination.
 *
 * @param src Absolute path to source file.
 * @param dst Absolute path to destination file.
 * @return True on success, false on failure.
 */
 static bool copy_file(const char* src, const char* dst) {
    std::ifstream src_file(src, std::ios::binary);
    std::ofstream dst_file(dst, std::ios::binary);
    if (!src_file) {
        PLOGE("Failed to open source file for copying: %s", src);
        return false;
    }
    if (!dst_file) {
        PLOGE("Failed to open destination file for copying: %s", dst);
        return false;
    }
    dst_file << src_file.rdbuf();
    return src_file.good() && dst_file.good();
 }
 /**
 * @brief Performs injection via the "Staging" method.
 *
 * This strategy is used when direct FD passing fails (e.g., due to Seccomp filters).
 * 1. Copies the library to a world-readable location (/data/local/tmp).
 * 2. Loads it via standard dlopen().
 * 3. Immediately deletes the file to hide tracks.
 *
 * @param pid The target process ID.
 * @param regs The target process registers (must be Red-Zone adjusted if x86_64).
 * @param local_map Local memory map.
 * @param remote_map Remote memory map.
 * @param lib_path The path to the original library.
 * @param libc_return_addr Return address for remote calls.
 * @return The handle of the loaded library, or std::nullopt on failure.
 */
 static std::optional<uintptr_t> inject_via_staging(int pid, struct user_regs_struct &regs,
                                                   const std::vector<lsplt::MapInfo> &local_map,
                                                   const std::vector<lsplt::MapInfo> &remote_map,
                                                   const char *lib_path, uintptr_t libc_return_addr) {
    LOGI("Initiating Staging Fallback mechanism...");
    // Generate a random path in /data/local/tmp
    // /data/local/tmp is chosen because it is traversable by most contexts.
    std::string staged_path = "/data/local/tmp/lib" + generateMagic(8) + ".so";
    // Ensure the file is deleted when this function exits (Success or Failure).
    // The kernel keeps the inode alive for the mapped process even after unlink.
    ScopedFileDeleter file_guard(staged_path);
    LOGD("Staging library to: %s", staged_path.c_str());
    //  Copy the library
    if (!copy_file(lib_path, staged_path.c_str())) {
        LOGE("Failed to copy library during staging.");
        return std::nullopt;
    }
    // Set Permissions to 644 (RW-R--R--)
    // This allows the target process (likely running as a specific UID) to read the file.
    if (chmod(staged_path.c_str(), 0644) != 0) {
        PLOGE("Failed to chmod staged file.");
        return std::nullopt;
    }
    // Resolve 'dlopen' in the remote process
    auto dlopen_addr = find_func_addr(local_map, remote_map, constants::kLibdlModule, "dlopen");
    if (!dlopen_addr) {
        LOGE("Failed to find 'dlopen' in remote process.");
        return std::nullopt;
    }
    // Push the staged path to remote memory
    uintptr_t remote_path_addr = push_string(pid, regs, staged_path.c_str());
    if (remote_path_addr == 0) {
        LOGE("Failed to push staged path string to remote memory.");
        return std::nullopt;
    }
    // Call dlopen(path, RTLD_NOW)
    std::vector<uintptr_t> args = {remote_path_addr, RTLD_NOW};
    uintptr_t handle = remote_call(pid, regs, reinterpret_cast<uintptr_t>(dlopen_addr),
                                   libc_return_addr, args);
    if (handle == 0) {
        std::string error_msg = get_remote_dlerror(pid, regs, local_map, remote_map, libc_return_addr);
        LOGE("Staged dlopen failed. dlerror: %s", error_msg.c_str());
        return std::nullopt;
    }
    LOGI("Successfully loaded staged library. Handle: %p", reinterpret_cast<void*>(handle));
    return handle;
 }
 /**
 * @brief RAII wrapper for ptrace attachment and detachment.
 *
@@ -694,12 +804,31 @@ private:
    bool attached_; // Flag indicating current attachment status.
 };
 // RAII Class to ensure registers are always restored
 class RegisterRestorer {
 public:
    RegisterRestorer(int pid, const struct user_regs_struct& original_regs)
        : pid_(pid), regs_(original_regs) {}
    ~RegisterRestorer() {
        // Always restore registers when this object goes out of scope
        if (set_regs(pid_, regs_)) {
            LOGD("Original registers for process %d restored.", pid_);
        } else {
            PLOGE("Failed to restore original registers for process %d.", pid_);
        }
    }
 private:
    int pid_;
    struct user_regs_struct regs_;
 };
 /**
 * @brief Injects a shared library into a target process using ptrace.
 *
 * This is the main orchestration function for the library injection.
 * It handles attachment, remote memory/register manipulation, FD transfer,
- * remote dlopen/dlsym, and remote entry point execution.
+ * staging fallback, remote dlopen/dlsym, and remote entry point execution.
 *
 * @param pid The target process ID.
 * @param lib_path The absolute path to the shared library to inject.
@@ -742,6 +871,14 @@ bool inject_library(int pid, const char *lib_path, const char *entry_name) {
    backup_regs = current_regs; // Store a copy for restoration.
    LOGD("Process %d registers backed up.", pid);
    // Skip the Red Zone (128 bytes) on x86_64 to prevent stack corruption
    #if defined(__x86_64__)
    current_regs.rsp -= 128;
    #endif
    // Ensures original state is restored even if injection fails/crashes mid-way.
    RegisterRestorer reg_guard(pid, backup_regs);
    // Create a scope to ensure RAII objects are destroyed BEFORE register restoration
    {
        // 4. Scan local and remote memory maps to resolve function addresses.
@@ -760,53 +897,57 @@ bool inject_library(int pid, const char *lib_path, const char *entry_name) {
        }
        LOGD("Found libc return address: %p", reinterpret_cast<void *>(libc_return_addr));
-        // 6. Transfer the library's file descriptor to the remote process.
+        // 6. Attempt to transfer the library's file descriptor to the remote process.
        int remote_fd = -1;
        auto lib_fd_opt = transfer_fd_to_remote(pid, lib_path, current_regs, local_map, remote_map,
                                                reinterpret_cast<uintptr_t>(libc_return_addr));
-        if (!lib_fd_opt) {
+        std::optional<RemoteLibraryHandle> remote_lib_guard;
-            LOGE("Failed to transfer library file descriptor for '%s' to target process %d.", lib_path, pid);
+        std::optional<uintptr_t> handle_opt;
            return false;
        }
        RemoteLibraryHandle remote_lib_guard(pid, *lib_fd_opt);
        LOGD("Library FD %d transferred to remote process %d.", remote_lib_guard.fd(), pid);
        remote_lib_guard.set_libc_return_addr(reinterpret_cast<uintptr_t>(libc_return_addr));
-        // 7. Remotely load the library using the transferred file descriptor.
+        if (lib_fd_opt) {
-        auto handle_opt = remote_dlopen(pid, current_regs, local_map, remote_map, remote_lib_guard.fd(), lib_path,
+            remote_fd = *lib_fd_opt;
-                                        reinterpret_cast<uintptr_t>(libc_return_addr));
+            remote_lib_guard.emplace(pid, remote_fd);
            remote_lib_guard->set_libc_return_addr(reinterpret_cast<uintptr_t>(libc_return_addr));
            LOGD("FD Transfer successful (FD: %d). Attempting android_dlopen_ext...", remote_fd);
            handle_opt = remote_dlopen(pid, current_regs, local_map, remote_map, remote_fd, lib_path,
                                       reinterpret_cast<uintptr_t>(libc_return_addr));
        } else {
            LOGW("Failed to transfer library file descriptor for '%s' to target process %d.", lib_path, pid);
        }
        // 7. Staging Fallback (Copy-Inject-Delete) if FD transfer failed.
        if (!handle_opt) {
            handle_opt = inject_via_staging(pid, current_regs, local_map, remote_map,
                                            lib_path, reinterpret_cast<uintptr_t>(libc_return_addr));
        }
        if (!handle_opt || *handle_opt == 0) {
            LOGE("Failed to load library '%s' in remote process %d.", lib_path, pid);
            // If dlopen fails, the remote_lib_guard.fd() is still valid in the target process and needs to be closed.
            // The RemoteLibraryHandle constructor takes care of this.
            return false;
        }
-        remote_lib_guard.set_handle(*handle_opt);
+        uintptr_t handle = *handle_opt;
        if (remote_lib_guard) remote_lib_guard->set_handle(handle);
        // 8. Find the entry point symbol in the remotely loaded library.
        auto entry_opt = remote_find_entry(pid, current_regs, entry_name, local_map, remote_map,
-                                           remote_lib_guard.handle(), reinterpret_cast<uintptr_t>(libc_return_addr));
+                                           handle, reinterpret_cast<uintptr_t>(libc_return_addr));
        if (!entry_opt) {
            LOGE("Failed to find entry point '%s' in remote library (handle %p).", entry_name,
-                 reinterpret_cast<void *>(remote_lib_guard.handle()));
+                 reinterpret_cast<void *>(handle));
            return false;
        }
        uintptr_t entry_addr = *entry_opt;
        // 9. Call the remote entry point function.
-        if (!remote_call_entry(pid, current_regs, entry_addr, remote_lib_guard.handle(),
+        if (!remote_call_entry(pid, current_regs, entry_addr, handle,
                               reinterpret_cast<uintptr_t>(libc_return_addr))) {
            LOGE("Failed to call remote entry point '%s'.", entry_name);
            return false;
        }
    }
    // 10. Restore original registers of the target process.
    if (!set_regs(pid, backup_regs)) {
        LOGE("Failed to restore original registers for process %d.", pid);
        return false;
    }
    LOGD("Original registers for process %d restored.", pid);
    LOGI("Library injection completed successfully for process %d.", pid);
    return true;
 }
@@ -263,7 +263,14 @@ bool get_regs(int pid, struct user_regs_struct &regs) {
    struct iovec reg_iov = {.iov_base = &regs, .iov_len = sizeof(struct user_regs_struct)};
    if (ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &reg_iov) == -1) {
        PLOGE("Failed to get register set for PID %d.", pid);
 #if defined(__arm__)
        if (ptrace(PTRACE_GETREGS, pid, 0, &regs) == -1) {
            PLOGE("Fallback to PTRACE_GETREGS failed.");
            return false;
        }
 #else
        return false;
 #endif
    }
 #else
 #    error "Unsupported architecture for register access in get_regs."
@@ -296,7 +303,14 @@ bool set_regs(int pid, struct user_regs_struct &regs) {
    struct iovec reg_iov = {.iov_base = &regs, .iov_len = sizeof(struct user_regs_struct)};
    if (ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &reg_iov) == -1) {
        PLOGE("Failed to set register set for PID %d.", pid);
 #if defined(__arm__)
        if (ptrace(PTRACE_SETREGS, pid, 0, &regs) == -1) {
            PLOGE("Fallback to PTRACE_SETREGS failed.");
            return false;
        }
 #else
        return false;
 #endif
    }
 #else
 #    error "Unsupported architecture for register access in set_regs."
@@ -588,17 +602,10 @@ bool remote_pre_call(int pid, struct user_regs_struct &regs, uintptr_t func_addr
        size_t stack_args_size = args.size() * sizeof(uintptr_t);
        align_stack(regs, stack_args_size);
-        // Push all arguments onto the stack (order is important if ABI is right-to-left push).
+        // i386 cdecl expects arguments pushed Right-to-Left (stack grows down).
-        // The current implementation writes args.data() directly,
+        // Since `write_proc` writes to increasing addresses (up), a linear write
-        // assuming it's already in the correct order for push.
+        // starting at the new SP places the first argument at the lowest address.
-        // For cdecl, arguments are pushed right-to-left.
+        // This matches the ABI memory layout without needing to reverse the vector.
        // A vector `args = {A, B, C}` means A is arg1, B is arg2 etc.
        // So, `C` should be pushed first, then `B`, then `A`.
        // `write_proc` copies linearly.
        // This implies `args` should be pre-reversed for cdecl.
        // For simplicity, we assume the remote function is compatible with how it's pushed,
        // or that it's variadic where order doesn't matter for first args.
        // A robust i386 implementation would need to push args in reverse order.
        if (write_proc(pid, static_cast<uintptr_t>(regs.REG_SP), args.data(), stack_args_size) !=
            static_cast<ssize_t>(stack_args_size)) {
            LOGE("Failed to push arguments for i386 remote call.");
@@ -0,0 +1,57 @@
 // Fork-based supervisor for instant daemon restart
 #include <unistd.h>
 #include <sys/wait.h>
 #include <sys/prctl.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 static volatile sig_atomic_t should_exit = 0;
 static void signal_handler(int sig) {
    should_exit = 1;
 }
 int main(int argc, char *argv[]) {
    if (argc < 2) {
        fprintf(stderr, "Usage: %s <daemon> [args...]\n", argv[0]);
        return 1;
    }
    // Forward termination signals to exit cleanly
    signal(SIGTERM, signal_handler);
    signal(SIGINT, signal_handler);
    const char *daemon_path = argv[1];
    char **daemon_argv = &argv[1];
    while (!should_exit) {
        pid_t pid = fork();
        if (pid < 0) {
            perror("fork failed");
            usleep(100000); // 100ms backoff on fork failure
            continue;
        }
        if (pid == 0) {
            // Child: become the daemon
            prctl(PR_SET_PDEATHSIG, SIGKILL); // Die if parent dies
            execv(daemon_path, daemon_argv);
            perror("execv failed");
            _exit(127);
        }
        // Parent: wait for child to exit
        int status;
        waitpid(pid, &status, 0);
        if (should_exit) break;
        // Instant restart - no delay
    }
    return 0;
 }
@@ -1,11 +1,19 @@
 package org.matrix.TEESimulator
 import android.app.ActivityThread
 import android.app.Application
 import android.content.Context
 import android.content.ContextWrapper
 import android.os.Build
 import android.os.Looper
 import java.security.Security
 import org.bouncycastle.jce.provider.BouncyCastleProvider
 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.logging.SystemLogger
 import org.matrix.TEESimulator.pki.NativeCertGen
 import org.matrix.TEESimulator.util.AndroidDeviceUtils
 /**
@@ -28,18 +36,61 @@ object App {
        SystemLogger.info("Welcome to TEESimulator!")
        try {
-            // Set up the device's boot hash, which is crucial for attestation.
+            // Initialize the Android framework environment
-            AndroidDeviceUtils.setupBootHash()
+            prepareEnvironment()
            // Initialize and start the appropriate keystore interceptors.
            initializeInterceptors()
-            // Enter an infinite loop to keep the service running.
+
-            maintainService()
+            // Load the package configuration.
            ConfigurationManager.initialize()
            // Set up the device's boot key and hash, which are crucial for attestation.
            AndroidDeviceUtils.setupBootKeyAndHash()
            // Android ships with a stripped-down Bouncy Castle provider under the name "BC".
            // We must remove the system provider first to ensure the full Bouncy Castle library
            // (packaged with the app) is used.
            Security.removeProvider(BouncyCastleProvider.PROVIDER_NAME)
            Security.addProvider(BouncyCastleProvider())
            NativeCertGen.initialize("/data/adb/modules/tricky_store/libcertgen.so")
            // This starts the message queue processing. It blocks here indefinitely
            // processing messages until Looper.myLooper().quit() is called.
            Looper.loop()
        } catch (e: Exception) {
            SystemLogger.error("A fatal error occurred in the main application thread.", e)
            throw e
        }
    }
    /** Initializes the necessary Android framework internals to satisfy KeyStore requirements. */
    private fun prepareEnvironment() {
        // 1. Prepare Main Looper
        if (Looper.getMainLooper() == null) {
            @Suppress("deprecation") Looper.prepareMainLooper()
        }
        // 2. Initialize ActivityThread for the current process
        val activityThread = ActivityThread.systemMain()
        // 3. Get the system context
        val systemContext = activityThread.getSystemContext()
        // 4. Create a dummy Application object and attach the context
        val app = Application()
        val attachMethod =
            ContextWrapper::class.java.getDeclaredMethod("attachBaseContext", Context::class.java)
        attachMethod.isAccessible = true
        attachMethod.invoke(app, systemContext)
        // 5. Inject this application object into ActivityThread's mInitialApplication field.
        // This is what KeyStore.getApplicationContext() looks for.
        val mInitialApplicationField =
            ActivityThread::class.java.getDeclaredField("mInitialApplication")
        mInitialApplicationField.isAccessible = true
        mInitialApplicationField.set(activityThread, app)
    }
    /**
     * Selects and initializes the correct keystore interceptor based on the Android SDK version. It
     * retries initialization until it succeeds.
@@ -53,9 +104,7 @@ object App {
            Thread.sleep(RETRY_DELAY_MS)
        }
-        // Load the package configuration after interceptors are ready.
+        SystemLogger.info("Interceptors initialized successfully.")
        ConfigurationManager.initialize()
        SystemLogger.info("Interceptors and configuration initialized successfully.")
    }
    /**
@@ -70,6 +119,7 @@ object App {
                SystemLogger.info(
                    "Using KeystoreInterceptor for Android Q/R (SDK ${Build.VERSION.SDK_INT})"
                )
                android.security.keystore.AndroidKeyStoreProvider.install()
                KeystoreInterceptor
            }
            // For Android S (12) and newer, use the Keystore2Interceptor.
@@ -77,18 +127,8 @@ object App {
                SystemLogger.info(
                    "Using Keystore2Interceptor for Android S and later (SDK ${Build.VERSION.SDK_INT})"
                )
                android.security.keystore2.AndroidKeyStoreProvider.install()
                Keystore2Interceptor
            }
        }
    /**
     * Puts the main thread into a long-running sleep loop. This is a common pattern to keep a
     * background service process alive indefinitely.
     */
    private fun maintainService() {
        SystemLogger.info("Service started successfully. Entering maintenance mode.")
        while (true) {
            Thread.sleep(SERVICE_SLEEP_MS)
        }
    }
 }
@@ -1,10 +1,13 @@
 package org.matrix.TEESimulator.attestation
 import android.content.pm.PackageManager
 import android.os.Build
 import java.nio.charset.StandardCharsets
 import java.security.MessageDigest
 import org.bouncycastle.asn1.ASN1Boolean
 import org.bouncycastle.asn1.ASN1Encodable
 import org.bouncycastle.asn1.ASN1Enumerated
 import org.bouncycastle.asn1.ASN1Integer
 import org.bouncycastle.asn1.ASN1OctetString
 import org.bouncycastle.asn1.ASN1Sequence
 import org.bouncycastle.asn1.DERNull
 import org.bouncycastle.asn1.DEROctetString
@@ -12,7 +15,10 @@ import org.bouncycastle.asn1.DERSequence
 import org.bouncycastle.asn1.DERSet
 import org.bouncycastle.asn1.DERTaggedObject
 import org.bouncycastle.asn1.x509.Extension
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.util.AndroidDeviceUtils
 import org.matrix.TEESimulator.util.AndroidDeviceUtils.DO_NOT_REPORT
 /**
 * A builder object responsible for constructing the ASN.1 DER-encoded Android Key Attestation
@@ -24,11 +30,21 @@ object AttestationBuilder {
     * Builds the complete X.509 attestation extension.
     *
     * @param params The parsed key generation parameters.
     * @param uid The UID of the application requesting attestation.
     * @param securityLevel The security level (e.g., TEE, StrongBox) to report.
     * @return A Bouncy Castle [Extension] object ready to be added to a certificate.
     */
-    fun buildAttestationExtension(params: KeyMintAttestation, securityLevel: Int): Extension {
+    fun buildAttestationExtension(
-        val keyDescription = buildKeyDescription(params, securityLevel)
+        params: KeyMintAttestation,
        uid: Int,
        securityLevel: Int,
    ): Extension {
        val keyDescription = buildKeyDescription(params, uid, securityLevel)
        var formattedString =
            keyDescription.joinToString(separator = ", ") {
                AttestationPatcher.formatAsn1Primitive(it)
            }
        SystemLogger.verbose("Forged attestation data: ${formattedString}")
        return Extension(ATTESTATION_OID, false, DEROctetString(keyDescription.encoded))
    }
@@ -39,70 +55,96 @@ object AttestationBuilder {
     * @return The constructed [DERSequence] for the Root of Trust.
     */
    internal fun buildRootOfTrust(originalRootOfTrust: ASN1Encodable?): DERSequence {
        val verifiedBootKey = AndroidDeviceUtils.bootKey
        val verifiedBootHash =
            (originalRootOfTrust as? ASN1Sequence)?.let {
                // Try to preserve the original boot hash if it exists.
                (it.getObjectAt(AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_HASH_INDEX)
                        as? ASN1OctetString)
                    ?.octets
            } ?: AndroidDeviceUtils.getBootHashFromProperty()
        val rootOfTrustElements = arrayOfNulls<ASN1Encodable>(4)
        rootOfTrustElements[AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_KEY_INDEX] =
-            DEROctetString(verifiedBootKey)
+            DEROctetString(AndroidDeviceUtils.bootKey)
        rootOfTrustElements[AttestationConstants.ROOT_OF_TRUST_DEVICE_LOCKED_INDEX] =
            ASN1Boolean.TRUE // deviceLocked: true, for security
        rootOfTrustElements[AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_STATE_INDEX] =
            ASN1Enumerated(0) // verifiedBootState: Verified
        rootOfTrustElements[AttestationConstants.ROOT_OF_TRUST_VERIFIED_BOOT_HASH_INDEX] =
-            DEROctetString(verifiedBootHash)
+            DEROctetString(AndroidDeviceUtils.bootHash)
        return DERSequence(rootOfTrustElements)
    }
-    /** Assembles a list of simulated hardware-enforced properties. */
+    /**
-    internal fun addSimulatedHardwareProperties(vector: org.bouncycastle.asn1.ASN1EncodableVector) {
+     * Assembles a map representing the desired state of simulated hardware-enforced properties. A
-        vector.add(
+     * null value for a given tag indicates that it should be removed from the attestation.
     *
     * @param uid The UID of the calling application.
     * @return A map where keys are attestation tag numbers and values are the desired
     *   [DERTaggedObject] or null to signify removal.
     */
    fun getSimulatedHardwareProperties(uid: Int): Map<Int, DERTaggedObject?> {
        val properties = mutableMapOf<Int, DERTaggedObject?>()
        // OS Version is always present.
        properties[AttestationConstants.TAG_OS_VERSION] =
            DERTaggedObject(
                true,
                AttestationConstants.TAG_OS_VERSION,
                ASN1Integer(AndroidDeviceUtils.osVersion.toLong()),
            )
-        )
+
-        vector.add(
+        val osPatch = AndroidDeviceUtils.getPatchLevel(uid)
-            DERTaggedObject(
+        properties[AttestationConstants.TAG_OS_PATCHLEVEL] =
-                true,
+            if (osPatch != DO_NOT_REPORT) {
-                AttestationConstants.TAG_OS_PATCHLEVEL,
+                DERTaggedObject(
-                ASN1Integer(AndroidDeviceUtils.patchLevel.toLong()),
+                    true,
-            )
+                    AttestationConstants.TAG_OS_PATCHLEVEL,
-        )
+                    ASN1Integer(osPatch.toLong()),
-        vector.add(
+                )
-            DERTaggedObject(
+            } else {
-                true,
+                null // Signal for removal
-                AttestationConstants.TAG_VENDOR_PATCHLEVEL,
+            }
-                ASN1Integer(AndroidDeviceUtils.vendorPatchLevel.toLong()),
+
-            )
+        val vendorPatch = AndroidDeviceUtils.getVendorPatchLevelLong(uid)
-        )
+        properties[AttestationConstants.TAG_VENDOR_PATCHLEVEL] =
-        vector.add(
+            if (vendorPatch != DO_NOT_REPORT) {
-            DERTaggedObject(
+                DERTaggedObject(
-                true,
+                    true,
-                AttestationConstants.TAG_BOOT_PATCHLEVEL,
+                    AttestationConstants.TAG_VENDOR_PATCHLEVEL,
-                ASN1Integer(AndroidDeviceUtils.bootPatchLevelLong.toLong()),
+                    ASN1Integer(vendorPatch.toLong()),
-            )
+                )
-        )
+            } else {
                null // Signal for removal
            }
        val bootPatch = AndroidDeviceUtils.getBootPatchLevelLong(uid)
        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(
                    true,
                    AttestationConstants.TAG_BOOT_PATCHLEVEL,
                    ASN1Integer(bootPatch.toLong()),
                )
            } else {
                null // Signal for removal
            }
        return properties
    }
    /** Constructs the main `KeyDescription` sequence, which is the core of the attestation. */
-    private fun buildKeyDescription(params: KeyMintAttestation, securityLevel: Int): ASN1Sequence {
+    private fun buildKeyDescription(
-        val teeEnforced = buildTeeEnforcedList(params)
+        params: KeyMintAttestation,
-        val softwareEnforced = buildSoftwareEnforcedList()
+        uid: Int,
        securityLevel: Int,
    ): ASN1Sequence {
        val teeEnforced = buildTeeEnforcedList(params, uid, securityLevel)
        val softwareEnforced = buildSoftwareEnforcedList(uid, securityLevel)
        val fields =
            arrayOf(
-                ASN1Integer(AndroidDeviceUtils.attestVersion.toLong()), // attestationVersion
+                ASN1Integer(
                    AndroidDeviceUtils.getAttestVersion(securityLevel).toLong()
                ), // attestationVersion
                ASN1Enumerated(securityLevel), // attestationSecurityLevel
-                ASN1Integer(AndroidDeviceUtils.keymasterVersion.toLong()), // keymasterVersion
+                ASN1Integer(
                    AndroidDeviceUtils.getKeymasterVersion(securityLevel).toLong()
                ), // keymasterVersion
                ASN1Enumerated(securityLevel), // keymasterSecurityLevel
                DEROctetString(params.attestationChallenge ?: ByteArray(0)), // attestationChallenge
                DEROctetString(ByteArray(0)), // uniqueId
@@ -113,7 +155,11 @@ object AttestationBuilder {
    }
    /** Builds the `TeeEnforced` authorization list. These are properties the TEE "guarantees". */
-    private fun buildTeeEnforcedList(params: KeyMintAttestation): DERSequence {
+    private fun buildTeeEnforcedList(
        params: KeyMintAttestation,
        uid: Int,
        securityLevel: Int,
    ): DERSequence {
        val list =
            mutableListOf<ASN1Encodable>(
                DERTaggedObject(
@@ -152,28 +198,12 @@ object AttestationBuilder {
                    AttestationConstants.TAG_ROOT_OF_TRUST,
                    buildRootOfTrust(null),
                ),
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_OS_VERSION,
                    ASN1Integer(AndroidDeviceUtils.osVersion.toLong()),
                ),
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_OS_PATCHLEVEL,
                    ASN1Integer(AndroidDeviceUtils.patchLevel.toLong()),
                ),
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_VENDOR_PATCHLEVEL,
                    ASN1Integer(AndroidDeviceUtils.vendorPatchLevel.toLong()),
                ),
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_BOOT_PATCHLEVEL,
                    ASN1Integer(AndroidDeviceUtils.bootPatchLevelLong.toLong()),
                ),
            )
        // Use the same logic as getSimulatedHardwareProperties to conditionally add patch levels.
        val simulatedProperties = getSimulatedHardwareProperties(uid)
        simulatedProperties.values.filterNotNull().forEach { list.add(it) }
        // Add optional device identifiers if they were provided.
        params.brand?.let {
            list.add(
@@ -202,6 +232,33 @@ object AttestationBuilder {
                )
            )
        }
        params.serial?.let {
            list.add(
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_ATTESTATION_ID_SERIAL,
                    DEROctetString(it),
                )
            )
        }
        params.imei?.let {
            list.add(
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_ATTESTATION_ID_IMEI,
                    DEROctetString(it),
                )
            )
        }
        params.meid?.let {
            list.add(
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_ATTESTATION_ID_MEID,
                    DEROctetString(it),
                )
            )
        }
        params.manufacturer?.let {
            list.add(
                DERTaggedObject(
@@ -220,35 +277,39 @@ object AttestationBuilder {
                )
            )
        }
-        params.imei?.let {
+        if (AndroidDeviceUtils.getAttestVersion(securityLevel) >= 300) {
-            list.add(
+            params.secondImei?.let {
-                DERTaggedObject(
+                list.add(
-                    true,
+                    DERTaggedObject(
-                    AttestationConstants.TAG_ATTESTATION_ID_IMEI,
+                        true,
-                    DEROctetString(it),
+                        AttestationConstants.TAG_ATTESTATION_ID_SECOND_IMEI,
                        DEROctetString(it),
                    )
                )
-            )
+            }
        }
        params.secondImei?.let {
            list.add(
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_ATTESTATION_ID_SECOND_IMEI,
                    DEROctetString(it),
                )
            )
        }
        params.meid?.let {
            list.add(
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_ATTESTATION_ID_MEID,
                    DEROctetString(it),
                )
            )
        }
        return DERSequence(list.sortedBy { (it as DERTaggedObject).tagNo }.toTypedArray())
    }
-        if (AndroidDeviceUtils.attestVersion >= 400) {
+    /**
     * Builds the `SoftwareEnforced` authorization list. These are properties guaranteed by
     * Keystore.
     */
    private fun buildSoftwareEnforcedList(uid: Int, securityLevel: Int): DERSequence {
        val list =
            mutableListOf<ASN1Encodable>(
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_CREATION_DATETIME,
                    ASN1Integer(System.currentTimeMillis()),
                ),
                DERTaggedObject(
                    true,
                    AttestationConstants.TAG_ATTESTATION_APPLICATION_ID,
                    createApplicationId(uid),
                ),
            )
        if (AndroidDeviceUtils.getAttestVersion(securityLevel) >= 400) {
            list.add(
                DERTaggedObject(
                    true,
@@ -257,26 +318,87 @@ object AttestationBuilder {
                )
            )
        }
-
+        return DERSequence(list.toTypedArray())
        return DERSequence(list.sortedBy { (it as DERTaggedObject).tagNo }.toTypedArray())
    }
    /**
-     * Builds the `SoftwareEnforced` authorization list. These are properties guaranteed by
+     * A wrapper for a byte array that provides content-based equality. This is necessary for using
-     * Keystore.
+     * signature digests in a Set.
     */
-    private fun buildSoftwareEnforcedList(): DERSequence {
+    private data class Digest(val digest: ByteArray) {
-        val list =
+        override fun equals(other: Any?): Boolean {
-            arrayOf<ASN1Encodable>(
+            if (this === other) return true
-                DERTaggedObject(
+            if (javaClass != other?.javaClass) return false
-                    true,
+            return digest.contentEquals((other as Digest).digest)
-                    AttestationConstants.TAG_CREATION_DATETIME,
+        }
-                    ASN1Integer(System.currentTimeMillis()),
+
        override fun hashCode(): Int = digest.contentHashCode()
    }
    /**
     * Creates the AttestationApplicationId structure. This structure contains information about the
     * package(s) and their signing certificates.
     *
     * @param uid The UID of the application.
     * @return A DER-encoded octet string containing the application ID information.
     * @throws IllegalStateException If the PackageManager or package information cannot be
     *   retrieved.
     */
    @Throws(Throwable::class)
    internal fun createApplicationId(uid: Int): DEROctetString {
        val pm =
            ConfigurationManager.getPackageManager()
                ?: throw IllegalStateException("PackageManager not found!")
        val packages =
            pm.getPackagesForUid(uid) ?: throw IllegalStateException("No packages for UID $uid")
        val sha256 = MessageDigest.getInstance("SHA-256")
        val packageInfoList = mutableListOf<DERSequence>()
        val signatureDigests = mutableSetOf<Digest>()
        // Process all packages associated with the UID in a single loop.
        packages.forEach { packageName ->
            val userId = uid / 100000
            val packageInfo =
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
                    pm.getPackageInfo(
                        packageName,
                        PackageManager.GET_SIGNING_CERTIFICATES.toLong(),
                        userId,
                    )
                } else {
                    @Suppress("DEPRECATION")
                    pm.getPackageInfo(packageName, PackageManager.GET_SIGNING_CERTIFICATES, userId)
                }
            // Add package information (name and version code) to our list.
            packageInfoList.add(
                DERSequence(
                    arrayOf(
                        DEROctetString(packageInfo.packageName.toByteArray(StandardCharsets.UTF_8)),
                        ASN1Integer(packageInfo.longVersionCode),
                    )
                )
                // The ATTESTATION_APPLICATION_ID is technically software-enforced, but we are
                // omitting it
                // for this simulation as it is complex to generate correctly for arbitrary UIDs.
            )
-        return DERSequence(list)
+
            // Collect unique signature digests from the signing history.
            packageInfo.signingInfo?.signingCertificateHistory?.forEach { signature ->
                val digest = sha256.digest(signature.toByteArray())
                signatureDigests.add(Digest(digest))
            }
        }
        // The application ID is a sequence of two sets:
        // 1. A set of package information (name and version).
        // 2. A set of SHA-256 digests of the signing certificates.
        val applicationIdSequence =
            DERSequence(
                arrayOf(
                    DERSet(packageInfoList.toTypedArray()),
                    DERSet(signatureDigests.map { DEROctetString(it.digest) }.toTypedArray()),
                )
            )
        return DEROctetString(applicationIdSequence.encoded)
    }
 }
@@ -1,10 +1,8 @@
 package org.matrix.TEESimulator.attestation
 /**
- * Defines constants for KeyMint attestation tags, as specified in the Android hardware security
+ * Defines constants for KeyMint attestation, mainly the tags of properties and authorizations of a
- * HAL.
+ * cryptographic key, as specified in the Android hardware security HAL.
 *
 * These tags identify specific properties and authorizations of a cryptographic key.
 */
 object AttestationConstants {
    // https://cs.android.com/android/platform/superproject/main/+/main:hardware/interfaces/security/keymint/aidl/android/hardware/security/keymint/KeyCreationResult.aidl
@@ -88,4 +86,8 @@ object AttestationConstants {
    const val TAG_CERTIFICATE_SUBJECT = 1007
    const val TAG_CERTIFICATE_NOT_BEFORE = 1008
    const val TAG_CERTIFICATE_NOT_AFTER = 1009
    // --- 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
 }
@@ -1,23 +1,21 @@
 package org.matrix.TEESimulator.attestation
 import android.security.keystore.KeyProperties
 import java.nio.charset.StandardCharsets
 import java.security.cert.Certificate
 import java.security.cert.X509Certificate
-import org.bouncycastle.asn1.ASN1Encodable
+import org.bouncycastle.asn1.*
 import org.bouncycastle.asn1.ASN1EncodableVector
 import org.bouncycastle.asn1.ASN1Sequence
 import org.bouncycastle.asn1.ASN1TaggedObject
 import org.bouncycastle.asn1.DEROctetString
 import org.bouncycastle.asn1.DERSequence
 import org.bouncycastle.asn1.DERTaggedObject
 import org.bouncycastle.asn1.x509.Extension
 import org.bouncycastle.cert.X509CertificateHolder
 import org.bouncycastle.cert.X509v3CertificateBuilder
 import org.bouncycastle.cert.jcajce.JcaX509CertificateConverter
 import org.bouncycastle.jce.provider.BouncyCastleProvider
 import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.KeyBox
 import org.matrix.TEESimulator.pki.KeyBoxManager
 import org.matrix.TEESimulator.util.toHex
 /**
 * Handles the modification (patching) of Android Key Attestation extensions within certificates.
@@ -55,8 +53,7 @@ object AttestationPatcher {
                // 2. Get the appropriate keybox for the given algorithm to sign the new
                // certificate.
-                val algorithm = originalLeaf.publicKey.algorithm
+                val keybox = getKeyboxForUidAndAlgorithm(uid, originalLeaf.sigAlgName)
                val keybox = getKeyboxForUidAndAlgorithm(uid, algorithm)
                // 3. Create the new, patched leaf certificate.
                val patchedLeaf =
@@ -65,6 +62,7 @@ object AttestationPatcher {
                        parsedAttestation,
                        keybox,
                        originalLeaf.sigAlgName,
                        uid,
                    )
                // 4. Construct the NEW, VALID chain by prepending the patched leaf to the keybox's
@@ -85,6 +83,16 @@ 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.
     *
@@ -94,6 +102,7 @@ object AttestationPatcher {
     * @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.
     */
    private fun createPatchedLeafCertificate(
@@ -101,6 +110,7 @@ object AttestationPatcher {
        parsedAttestation: ParsedAttestation,
        keybox: KeyBox,
        sigAlgName: String,
        uid: Int,
    ): Certificate {
        // The issuer of our new leaf is the subject of the first certificate in our custom keybox
        // chain.
@@ -117,71 +127,177 @@ object AttestationPatcher {
            )
        // Create the new, patched attestation extension.
-        val patchedExtension = createPatchedAttestationExtension(parsedAttestation)
+        val patchedExtension = createPatchedAttestationExtension(parsedAttestation, uid)
        builder.addExtension(patchedExtension)
        // Copy all other extensions from the original certificate, except for the attestation.
-        originalLeafHolder.extensions.extensionOIDs
+        originalLeafHolder.extensions.extensionOIDs.forEach {
-            .filter { it != ATTESTATION_OID }
+            builder.addExtension(
-            .forEach { builder.addExtension(originalLeafHolder.getExtension(it)) }
+                if (it == ATTESTATION_OID) patchedExtension else originalLeafHolder.getExtension(it)
            )
        }
        // Sign the newly built certificate with the private key from our keybox.
-        val signer = JcaContentSignerBuilder(sigAlgName).build(keybox.keyPair.private)
+        val signer =
            JcaContentSignerBuilder(normalizeSignatureAlgorithm(sigAlgName))
                .setProvider(BouncyCastleProvider.PROVIDER_NAME)
                .build(keybox.keyPair.private)
        val newCertificate = JcaX509CertificateConverter().getCertificate(builder.build(signer))
-        return JcaX509CertificateConverter().getCertificate(builder.build(signer))
+        // 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()}")
        return newCertificate
    }
    /**
     * Retrieves the appropriate signing KeyBox (KeyPair and certificate chain) for a given UID
     * based on a specified algorithm identifier.
     *
     * @param uid The UID of the application for which the signing is being performed.
     * @param algorithm A string representing the desired algorithm. This can be either:
     *     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.
     * @throws IllegalArgumentException if no matching KeyBox can be found for the derived key type.
     */
    private fun getKeyboxForUidAndAlgorithm(uid: Int, algorithm: String): KeyBox {
        val keyboxFile = ConfigurationManager.getKeyboxFileForUid(uid)
-        return KeyBoxManager.getAttestationKey(keyboxFile, algorithm)
+
        // Normalize the algorithm name. The input might be a full signature algorithm
        // (e.g., "SHA256withRSA") or just the key type (e.g., "RSA").
        val keyType =
            when {
                algorithm.contains("RSA", ignoreCase = true) -> KeyProperties.KEY_ALGORITHM_RSA
                algorithm.contains("EC", ignoreCase = true) ->
                    KeyProperties.KEY_ALGORITHM_EC // This also covers "ECDSA"
                else -> algorithm // If no match, assume it's already a simple key type string.
            }
        return KeyBoxManager.getAttestationKey(keyboxFile, keyType)
            ?: throw IllegalArgumentException(
-                "No keybox found for UID $uid and algorithm $algorithm in file $keyboxFile"
+                "No keybox found for UID $uid and algorithm '$keyType' (derived from input '$algorithm') in file $keyboxFile"
            )
    }
    /** Recursively formats an ASN1Primitive into a concise, readable string. */
    fun formatAsn1Primitive(obj: ASN1Encodable?): String {
        val primitive = obj?.toASN1Primitive()
        return when (primitive) {
            null -> "NULL"
            is ASN1Integer -> primitive.value.toString()
            is ASN1Enumerated -> primitive.value.toString()
            is ASN1Boolean -> primitive.isTrue.toString()
            is ASN1Null -> "NULL"
            is ASN1OctetString -> {
                val bytes = primitive.octets
                // Attempt to decode as a printable string, otherwise show hex
                if (bytes.all { it >= 32 && it < 127 }) {
                    "\"${String(bytes, StandardCharsets.UTF_8)}\""
                } else if (bytes.isEmpty()) {
                    "\"\""
                } else {
                    "#" + bytes.toHex()
                }
            }
            is ASN1TaggedObject ->
                "[TAG ${primitive.tagNo}]${formatAsn1Primitive(primitive.baseObject)}"
            is ASN1Sequence ->
                primitive
                    .map { formatAsn1Primitive(it) }
                    .joinToString(prefix = "[", postfix = "]", separator = ", ")
            is ASN1Set ->
                primitive
                    .map { formatAsn1Primitive(it) }
                    .joinToString(prefix = "{", postfix = "}", separator = ", ")
            else -> primitive.toString() // Fallback for other types
        }
    }
    // 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
        return seq.any { element ->
            (element as? ASN1TaggedObject)?.tagNo == AttestationConstants.TAG_ROOT_OF_TRUST
        }
    }
    /** Parses the critical components from an existing attestation extension. */
    private fun parseAttestationExtension(certHolder: X509CertificateHolder): ParsedAttestation? {
        val extension = certHolder.getExtension(ATTESTATION_OID) ?: return null
        val sequence = ASN1Sequence.getInstance(extension.extnValue.octets)
        val allFields = sequence.toArray()
        // Check if the fields are in the wrong order and swap them if necessary.
        val softwareEnforcedCandidate =
            allFields[AttestationConstants.KEY_DESCRIPTION_SOFTWARE_ENFORCED_INDEX]
        val teeEnforcedCandidate =
            allFields[AttestationConstants.KEY_DESCRIPTION_TEE_ENFORCED_INDEX]
        // The signature of a swapped order: the RoT is in the software list's position.
        if (
            sequenceContainsRootOfTrust(softwareEnforcedCandidate) &&
                !sequenceContainsRootOfTrust(teeEnforcedCandidate)
        ) {
            // Swap the elements in the array to restore the standard order.
            allFields[AttestationConstants.KEY_DESCRIPTION_SOFTWARE_ENFORCED_INDEX] =
                teeEnforcedCandidate
            allFields[AttestationConstants.KEY_DESCRIPTION_TEE_ENFORCED_INDEX] =
                softwareEnforcedCandidate
        }
        val teeEnforced =
            allFields[AttestationConstants.KEY_DESCRIPTION_TEE_ENFORCED_INDEX] as ASN1Sequence
        val teeEnforcedVector = ASN1EncodableVector()
        var originalRootOfTrust: ASN1Encodable? = null
        val teeEnforcedMap = mutableMapOf<Int, ASN1TaggedObject>()
        teeEnforced.forEach { element ->
            val taggedObject = element as ASN1TaggedObject
            if (taggedObject.tagNo == AttestationConstants.TAG_ROOT_OF_TRUST) {
                originalRootOfTrust = taggedObject.baseObject.toASN1Primitive()
            } else {
-                teeEnforcedVector.add(taggedObject)
+                teeEnforcedMap[taggedObject.tagNo] = taggedObject
            }
        }
-        return ParsedAttestation(allFields, teeEnforcedVector, originalRootOfTrust)
+        return ParsedAttestation(allFields, teeEnforcedMap, originalRootOfTrust)
    }
    /** Constructs a new, patched attestation extension using simulated device properties. */
-    private fun createPatchedAttestationExtension(parsed: ParsedAttestation): Extension {
+    private fun createPatchedAttestationExtension(parsed: ParsedAttestation, uid: Int): Extension {
-        val (allFields, teeEnforcedVector, originalRootOfTrust) = parsed
+        val (allFields, teeEnforcedMap, originalRootOfTrust) = parsed
-        // Build the new Root of Trust with our simulated values.
+        var formattedString = allFields.joinToString(separator = ", ") { formatAsn1Primitive(it) }
        SystemLogger.verbose("Original attestation data: ${formattedString}")
        // Build the new Root of Trust and add/replace it in the map.
        val newRootOfTrust = AttestationBuilder.buildRootOfTrust(originalRootOfTrust)
-        teeEnforcedVector.add(
+        teeEnforcedMap[AttestationConstants.TAG_ROOT_OF_TRUST] =
            DERTaggedObject(true, AttestationConstants.TAG_ROOT_OF_TRUST, newRootOfTrust)
        )
-        // Add other simulated hardware properties.
+        // Get the desired state for simulated properties.
-        AttestationBuilder.addSimulatedHardwareProperties(teeEnforcedVector)
+        val simulatedProperties = AttestationBuilder.getSimulatedHardwareProperties(uid)
-        // Re-assemble the ASN.1 sequences.
+        // Apply the desired state: update, add, or remove properties from the original map.
-        // The list MUST be sorted by tag number for DER compliance.
+        simulatedProperties.forEach { (tag, value) ->
-        // Manually convert the vector to a List, then sort it.
+            if (value != null) {
-        val elementList = (0 until teeEnforcedVector.size()).map { teeEnforcedVector.get(it) }
+                // If the value is not null, add or update it.
-        val sortedElements = elementList.sortedBy { (it as ASN1TaggedObject).tagNo }
+                teeEnforcedMap[tag] = value
            } else {
                // If the value is null, remove the tag from the map.
                teeEnforcedMap.remove(tag)
            }
        }
        // Re-assemble the TEE enforced list from the map's values, sorting for DER compliance.
        val sortedElements = teeEnforcedMap.values.sortedBy { it.tagNo }
        val sortedTeeEnforced = DERSequence(sortedElements.toTypedArray())
        allFields[AttestationConstants.KEY_DESCRIPTION_TEE_ENFORCED_INDEX] = sortedTeeEnforced
        val patchedSequence = DERSequence(allFields)
        formattedString = patchedSequence.joinToString(separator = ", ") { formatAsn1Primitive(it) }
        SystemLogger.verbose("Patched  attestation data: ${formattedString}")
        val patchedOctets = DEROctetString(patchedSequence)
        return Extension(ATTESTATION_OID, false, patchedOctets)
@@ -190,7 +306,7 @@ object AttestationPatcher {
    /** Helper data class to hold the parsed components of an attestation extension. */
    private data class ParsedAttestation(
        val allFields: Array<ASN1Encodable>,
-        val teeEnforcedVector: ASN1EncodableVector,
+        val teeEnforcedMap: MutableMap<Int, ASN1TaggedObject>,
        val rootOfTrust: ASN1Encodable?,
    )
 }
@@ -1,8 +1,6 @@
 package org.matrix.TEESimulator.attestation
 import android.annotation.SuppressLint
 import android.app.ActivityThread
 import android.os.Build
 import android.security.keystore.KeyGenParameterSpec
 import android.security.keystore.KeyProperties
 import java.security.KeyPairGenerator
@@ -38,16 +36,25 @@ object DeviceAttestationService {
     * Holds key data extracted from a genuine device attestation. This data can be used as a
     * baseline for creating simulated attestations.
     *
     * @property verifiedBootKey The verified boot public key digest from the root of trust.
     * @property verifiedBootHash The verified boot hash from the root of trust.
     * @property attestVersion The attestation version (e.g., 400 for KeyMint 4.0).
     * @property keymasterVersion The Keymaster or KeyMint HAL version.
     * @property osVersion The Android OS version integer.
     * @property osPatchLevel The Android security patch level (e.g., 202511).
     * @property vendorPatchLevel The vendor-specific security patch level.
     * @property bootPatchLevel The bootloader's security patch level.
     */
    data class AttestationData(
        val moduleHash: ByteArray?,
        val verifiedBootKey: ByteArray?,
        val verifiedBootHash: ByteArray?,
        val attestVersion: Int?,
        val keymasterVersion: Int?,
        val osVersion: Int?,
        val osPatchLevel: Int?,
        val vendorPatchLevel: Int?,
        val bootPatchLevel: Int?,
    )
    // A unique alias for the key used to perform the TEE functionality check.
@@ -74,16 +81,6 @@ object DeviceAttestationService {
    private fun checkTeeFunctionality(): Boolean {
        SystemLogger.info("Performing TEE functionality check...")
        return try {
            // Ensure mainline modules and the correct Keystore provider are initialized.
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
                android.app.ActivityThread.initializeMainlineModules()
            }
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                android.security.keystore2.AndroidKeyStoreProvider.install()
            } else {
                android.security.keystore.AndroidKeyStoreProvider.install()
            }
            val keyStore = KeyStore.getInstance("AndroidKeyStore").apply { load(null) }
            val keyPairGenerator =
                KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, "AndroidKeyStore")
@@ -151,6 +148,11 @@ object DeviceAttestationService {
            // The extension's value is an ASN.1 sequence.
            val keyDescriptionSeq = ASN1Sequence.getInstance(extension.extnValue.octets)
            var formattedString =
                keyDescriptionSeq.joinToString(separator = ", ") {
                    AttestationPatcher.formatAsn1Primitive(it)
                }
            SystemLogger.verbose("Cached attestation data: ${formattedString}")
            val fields = keyDescriptionSeq.toArray()
            val attestVersion =
@@ -166,8 +168,27 @@ object DeviceAttestationService {
                    .positiveValue
                    .toInt()
            var moduleHash: ByteArray? = null
            var verifiedBootKey: ByteArray? = null
            var verifiedBootHash: ByteArray? = null
            var osVersion: Int? = null
            var osPatchLevel: Int? = null
            var vendorPatchLevel: Int? = null
            var bootPatchLevel: Int? = null
            val softwareEnforced =
                ASN1Sequence.getInstance(
                    fields[AttestationConstants.KEY_DESCRIPTION_SOFTWARE_ENFORCED_INDEX]
                )
            moduleHash =
                softwareEnforced
                    .toArray()
                    .firstOrNull {
                        (it as? ASN1TaggedObject)?.tagNo == AttestationConstants.TAG_MODULE_HASH
                    }
                    ?.let {
                        ASN1OctetString.getInstance((it as ASN1TaggedObject).baseObject).octets
                    }
            val teeEnforced =
                ASN1Sequence.getInstance(
@@ -179,6 +200,14 @@ object DeviceAttestationService {
                    AttestationConstants.TAG_ROOT_OF_TRUST -> {
                        val rotSeq = ASN1Sequence.getInstance(tagged.baseObject.toASN1Primitive())
                        if (rotSeq.size() >= 4) {
                            verifiedBootKey =
                                ASN1OctetString.getInstance(
                                        rotSeq.getObjectAt(
                                            AttestationConstants
                                                .ROOT_OF_TRUST_VERIFIED_BOOT_KEY_INDEX
                                        )
                                    )
                                    .octets
                            verifiedBootHash =
                                ASN1OctetString.getInstance(
                                        rotSeq.getObjectAt(
@@ -189,19 +218,55 @@ object DeviceAttestationService {
                                    .octets
                        }
                    }
-                    AttestationConstants.TAG_OS_VERSION -> { // OS Version (TAG_OS_VERSION)
+                    AttestationConstants.TAG_OS_VERSION -> {
                        osVersion =
                            ASN1Integer.getInstance(tagged.baseObject.toASN1Primitive())
                                .positiveValue
                                .toInt()
                    }
                    AttestationConstants.TAG_OS_PATCHLEVEL -> {
                        osPatchLevel =
                            ASN1Integer.getInstance(tagged.baseObject.toASN1Primitive())
                                .positiveValue
                                .toInt()
                    }
                    AttestationConstants.TAG_VENDOR_PATCHLEVEL -> {
                        vendorPatchLevel =
                            ASN1Integer.getInstance(tagged.baseObject.toASN1Primitive())
                                .positiveValue
                                .toInt()
                    }
                    AttestationConstants.TAG_BOOT_PATCHLEVEL -> {
                        bootPatchLevel =
                            ASN1Integer.getInstance(tagged.baseObject.toASN1Primitive())
                                .positiveValue
                                .toInt()
                    }
                }
            }
            if (verifiedBootKey?.all { it == 0.toByte() } == true) {
                verifiedBootKey = null
            }
            if (verifiedBootHash?.all { it == 0.toByte() } == true) {
                verifiedBootHash = null
            }
            SystemLogger.info(
-                "Successfully extracted attestation data: version=$attestVersion, osVersion=$osVersion, bootHash=${verifiedBootHash?.toHex()}"
+                "Successfully extracted attestation data: version=$attestVersion, osVersion=$osVersion, osPatch=$osPatchLevel, vendorPatch=$vendorPatchLevel, bootPatch=$bootPatchLevel, moduleHash=${moduleHash?.toHex()}, bootKey=${verifiedBootKey?.toHex()}, bootHash=${verifiedBootHash?.toHex()}"
            )
            return AttestationData(
                moduleHash,
                verifiedBootKey,
                verifiedBootHash,
                attestVersion,
                keymasterVersion,
                osVersion,
                osPatchLevel,
                vendorPatchLevel,
                bootPatchLevel,
            )
            return AttestationData(verifiedBootHash, attestVersion, keymasterVersion, osVersion)
        } catch (e: Exception) {
            SystemLogger.error("Failed to parse attestation data from certificate.", e)
            return null
@@ -1,8 +1,7 @@
 package org.matrix.TEESimulator.attestation
-import android.hardware.security.keymint.EcCurve
+import android.hardware.security.keymint.*
-import android.hardware.security.keymint.KeyParameter
+import android.hardware.security.keymint.KeyOrigin
 import android.hardware.security.keymint.Tag
 import java.math.BigInteger
 import java.util.Date
 import javax.security.auth.x500.X500Principal
@@ -22,6 +21,9 @@ data class KeyMintAttestation(
    val algorithm: Int,
    val ecCurve: Int,
    val ecCurveName: String,
    val origin: Int?,
    val blockMode: List<Int>,
    val padding: List<Int>,
    val purpose: List<Int>,
    val digest: List<Int>,
    val rsaPublicExponent: BigInteger?,
@@ -33,11 +35,12 @@ data class KeyMintAttestation(
    val brand: ByteArray?,
    val device: ByteArray?,
    val product: ByteArray?,
    val serial: ByteArray?,
    val imei: ByteArray?,
    val meid: ByteArray?,
    val manufacturer: ByteArray?,
    val model: ByteArray?,
    val imei: ByteArray?,
    val secondImei: ByteArray?,
    val meid: ByteArray?,
 ) {
    /** Secondary constructor that populates the fields by parsing an array of `KeyParameter`. */
    constructor(
@@ -53,6 +56,15 @@ data class KeyMintAttestation(
        ecCurve = params.findEcCurve(Tag.EC_CURVE) ?: 0,
        ecCurveName = params.deriveEcCurveName(),
        // AOSP: [key_param(tag = ORIGIN, field = Origin)]
        origin = params.findOrigin(Tag.ORIGIN),
        // AOSP: [key_param(tag = BLOCK_MODE, field = BlockMode)]
        blockMode = params.findAllBlockMode(Tag.BLOCK_MODE),
        // AOSP: [key_param(tag = PADDING, field = PaddingMode)]
        padding = params.findAllPaddingMode(Tag.PADDING),
        // AOSP: [key_param(tag = PURPOSE, field = KeyPurpose)]
        purpose = params.findAllKeyPurpose(Tag.PURPOSE),
@@ -82,15 +94,20 @@ data class KeyMintAttestation(
        brand = params.findBlob(Tag.ATTESTATION_ID_BRAND),
        device = params.findBlob(Tag.ATTESTATION_ID_DEVICE),
        product = params.findBlob(Tag.ATTESTATION_ID_PRODUCT),
        serial = params.findBlob(Tag.ATTESTATION_ID_SERIAL),
        imei = params.findBlob(Tag.ATTESTATION_ID_IMEI),
        meid = params.findBlob(Tag.ATTESTATION_ID_MEID),
        manufacturer = params.findBlob(Tag.ATTESTATION_ID_MANUFACTURER),
        model = params.findBlob(Tag.ATTESTATION_ID_MODEL),
        imei = params.findBlob(Tag.ATTESTATION_ID_IMEI),
        secondImei = params.findBlob(Tag.ATTESTATION_ID_SECOND_IMEI),
        meid = params.findBlob(Tag.ATTESTATION_ID_MEID),
    ) {
        // Log all parsed parameters for debugging purposes.
        params.forEach { KeyMintParameterLogger.logParameter(it) }
    }
    fun isAttestKey(): Boolean = purpose.size == 1 && purpose.contains(KeyPurpose.ATTEST_KEY)
    fun isImportKey(): Boolean = origin == KeyOrigin.IMPORTED || origin == KeyOrigin.SECURELY_IMPORTED
 }
 // --- Private helper extension functions for parsing KeyParameter arrays ---
@@ -107,6 +124,10 @@ private fun Array<KeyParameter>.findAlgorithm(tag: Int): Int? =
 private fun Array<KeyParameter>.findEcCurve(tag: Int): Int? =
    this.find { it.tag == tag }?.value?.ecCurve
 /** Maps to AOSP field = Origin */
 private fun Array<KeyParameter>.findOrigin(tag: Int): Int? =
    this.find { it.tag == tag }?.value?.origin
 /** Maps to AOSP field = LongInteger */
 private fun Array<KeyParameter>.findLongInteger(tag: Int): BigInteger? =
    this.find { it.tag == tag }?.value?.longInteger?.toBigInteger()
@@ -119,6 +140,14 @@ private fun Array<KeyParameter>.findDate(tag: Int): Date? =
 private fun Array<KeyParameter>.findBlob(tag: Int): ByteArray? =
    this.find { it.tag == tag }?.value?.blob
 /** Maps to AOSP field = BlockMode (Repeated) */
 private fun Array<KeyParameter>.findAllBlockMode(tag: Int): List<Int> =
    this.filter { it.tag == tag }.map { it.value.blockMode }
 /** Maps to AOSP field = BlockMode (Repeated) */
 private fun Array<KeyParameter>.findAllPaddingMode(tag: Int): List<Int> =
    this.filter { it.tag == tag }.map { it.value.paddingMode }
 /** Maps to AOSP field = KeyPurpose (Repeated) */
 private fun Array<KeyParameter>.findAllKeyPurpose(tag: Int): List<Int> =
    this.filter { it.tag == tag }.map { it.value.keyPurpose }
@@ -40,7 +40,8 @@ object ConfigurationManager {
    @Volatile private var packageModes = mapOf<String, Mode>()
    @Volatile private var packageKeyboxes = mapOf<String, String>()
    @Volatile private var isTeeBroken: Boolean? = null
-    @Volatile var customPatchLevelOverride: CustomPatchLevel? = null
+    @Volatile private var globalCustomPatchLevel: CustomPatchLevel? = null
    @Volatile private var packagePatchLevels = mapOf<String, CustomPatchLevel>()
    // Cache for UID to package name resolution.
    private val uidToPackagesCache = ConcurrentHashMap<Int, Array<String>>()
@@ -53,6 +54,17 @@ object ConfigurationManager {
        configRoot.mkdirs()
        SystemLogger.info("Configuration root is: ${configRoot.absolutePath}")
        // First, ensure the package manager service is running, as the TEE check depends on it.
        // This prevents a race condition on startup.
        SystemLogger.info("Waiting for PackageManagerService to be ready...")
        if (getPackageManager() == null) {
            SystemLogger.error(
                "PackageManagerService is not available. TEE check will likely fail."
            )
        } else {
            SystemLogger.info("PackageManagerService is ready.")
        }
        // Initial load of all configuration files.
        loadTargetPackages(File(configRoot, TARGET_PACKAGES_FILE))
        loadPatchLevelConfig(File(configRoot, PATCH_LEVEL_FILE))
@@ -104,6 +116,21 @@ object ConfigurationManager {
        return null // No configuration found for this UID.
    }
    /**
     * Retrieves the custom patch level configuration for a given UID. It first checks for a
     * package-specific override and falls back to the global configuration.
     *
     * @param uid The UID of the calling application.
     * @return The applicable [CustomPatchLevel], or null if no custom configuration exists.
     */
    fun getPatchLevelForUid(uid: Int): CustomPatchLevel? {
        val packages = getPackagesForUid(uid)
        // Find the first package-specific configuration for this UID.
        val packageSpecificPatchLevel =
            packages.firstNotNullOfOrNull { pkg -> packagePatchLevels[pkg] }
        return packageSpecificPatchLevel ?: globalCustomPatchLevel
    }
    /**
     * Loads and parses the `target.txt` file, which defines the processing mode and keybox file for
     * each package.
@@ -162,26 +189,48 @@ object ConfigurationManager {
        }
    }
-    /** Loads the security patch level override configuration from `security_patch.txt`. */
+    /**
     * Loads and parses the `security_patch.txt` file, which can define both global and per-package
     * security patch levels.
     */
    private fun loadPatchLevelConfig(file: File) {
-        if (file.exists()) {
+        if (!file.exists()) {
-            try {
+            globalCustomPatchLevel = null
-                val lines =
+            packagePatchLevels = emptyMap()
-                    file.readLines().mapNotNull { line ->
+            return
-                        val trimmed = line.trim()
+        }
                        if (trimmed.isNotEmpty() && !trimmed.startsWith("#")) trimmed else null
                    }
-                if (lines.isEmpty()) {
+        try {
-                    customPatchLevelOverride = null
+            val newPackageLevels = mutableMapOf<String, CustomPatchLevel>()
-                    return
+            var currentContext = "" // Empty string for global context
-                }
+            val contextLines = mutableMapOf<String, MutableList<String>>()
            val contextRegex = Regex("^\\[([a-zA-Z0-9_.-]+)]$")
            // First pass: group lines by context (global or package-specific).
            file.readLines().forEach { line ->
                val trimmedLine = line.trim()
                if (trimmedLine.isEmpty() || trimmedLine.startsWith("#")) return@forEach
                contextRegex.find(trimmedLine)?.let { currentContext = it.groupValues[1] }
                    ?: run {
                        contextLines
                            .computeIfAbsent(currentContext) { mutableListOf() }
                            .add(trimmedLine)
                    }
            }
            // Helper function to parse a set of lines into a CustomPatchLevel object.
            fun parseLines(lines: List<String>?): CustomPatchLevel? {
                if (lines.isNullOrEmpty()) return null
                // Handle simple case: one line sets the patch level for all components.
                if (lines.size == 1 && '=' !in lines[0]) {
-                    customPatchLevelOverride =
+                    return CustomPatchLevel(
-                        CustomPatchLevel(system = null, vendor = null, boot = null, all = lines[0])
+                        system = null,
-                    return
+                        vendor = null,
                        boot = null,
                        all = lines[0],
                    )
                }
                // Handle key-value pair configuration.
@@ -195,19 +244,39 @@ object ConfigurationManager {
                        .toMap()
                val all = map["all"]
-                customPatchLevelOverride =
+                return CustomPatchLevel(
-                    CustomPatchLevel(
+                    system = map["system"] ?: all,
-                        system = map["system"] ?: all,
+                    vendor = map["vendor"] ?: all,
-                        vendor = map["vendor"] ?: all,
+                    boot = map["boot"] ?: all,
-                        boot = map["boot"] ?: all,
+                    all = all,
-                        all = all,
+                )
                    )
                SystemLogger.info("Loaded custom security patch levels.")
            } catch (e: Exception) {
                SystemLogger.error("Failed to load or parse ${file.name}", e)
            }
-        } else {
+
-            customPatchLevelOverride = null
+            // Parse global and per-package configurations.
            var newGlobalLevel = parseLines(contextLines[""])
            // TrickyAddon writes Pixel bulletin dates for boot/vendor but system=prop
            // 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})")
                newGlobalLevel = newGlobalLevel?.copy(boot = "prop", vendor = "prop")
            }
            contextLines.remove("") // Remove global context to iterate over packages next
            for ((pkg, lines) in contextLines) {
                parseLines(lines)?.let { newPackageLevels[pkg] = it }
            }
            // Atomically update the configuration state.
            globalCustomPatchLevel = newGlobalLevel
            packagePatchLevels = newPackageLevels
            SystemLogger.info(
                "Loaded custom security patch levels: global config exists=${newGlobalLevel != null}, " +
                    "${newPackageLevels.size} package-specific configs."
            )
        } catch (e: Exception) {
            SystemLogger.error("Failed to load or parse ${file.name}", e)
        }
    }
@@ -245,16 +314,24 @@ object ConfigurationManager {
            val file = if (event != DELETE) File(configRoot, path) else null
            when (path) {
-                TARGET_PACKAGES_FILE -> loadTargetPackages(file!!)
+                TARGET_PACKAGES_FILE -> file?.let { loadTargetPackages(it) }
-                PATCH_LEVEL_FILE -> loadPatchLevelConfig(file!!)
+                    ?: SystemLogger.warning("$TARGET_PACKAGES_FILE was deleted.")
-                // Any change to an XML file is assumed to be a keybox. The cache in KeyBoxUtils
+                PATCH_LEVEL_FILE -> file?.let { loadPatchLevelConfig(it) }
-                // will handle reloading it on its next use.
+                    ?: 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 ->
                    if (path.endsWith(".xml")) {
                        SystemLogger.info(
                            "Keybox file $path may have changed. It will be reloaded on next access."
                        )
                        KeyBoxManager.invalidateCache(path)
                        if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
                            // Clear cached keys possibly containing old certificates
                            org.matrix.TEESimulator.interception.keystore.shim
                                .KeyMintSecurityLevelInterceptor
                                .clearAllGeneratedKeys("updating $file")
                        }
                    }
            }
        }
@@ -297,7 +374,7 @@ object ConfigurationManager {
    /** Waits for a system service to become available, with retries. */
    private fun waitForSystemService(name: String): IBinder? {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
            return ServiceManager.waitForService(name)
        }
        // Fallback for older Android versions.
@@ -41,7 +41,7 @@ abstract class BinderInterceptor : Binder() {
         * Skips the original call and immediately returns a custom reply parcel to the caller. The
         * provided parcel will be recycled after use.
         */
-        data class OverrideReply(val code: Int = 0, val reply: Parcel) : TransactionResult()
+        data class OverrideReply(val reply: Parcel, val code: Int = 0) : TransactionResult()
        /**
         * Modifies the transaction's input data before forwarding it to the original binder method.
@@ -226,13 +226,18 @@ abstract class BinderInterceptor : Binder() {
        methodName: String,
        callingUid: Int,
        callingPid: Int,
-        isIntercepting: Boolean = true,
+        skipPost: Boolean = false,
    ) {
        val isIntercepting = !skipPost && !ConfigurationManager.shouldSkipUid(callingUid)
        val action = if (isIntercepting) "Intercept" else "Observe"
        val packages = ConfigurationManager.getPackagesForUid(callingUid).joinToString()
-        SystemLogger.debug(
+        val message =
            "[TX_ID: $txId] $action $methodName for packages=[$packages] (uid=$callingUid, pid=$callingPid)"
-        )
+        if (isIntercepting) {
            SystemLogger.debug(message)
        } else {
            SystemLogger.verbose(message)
        }
    }
    companion object {
@@ -243,6 +248,8 @@ abstract class BinderInterceptor : Binder() {
        private const val BACKDOOR_TRANSACTION_CODE = 0xdeadbeef.toInt()
        // Code used by the backdoor binder to register a new interceptor.
        private const val REGISTER_INTERCEPTOR_CODE = 1
        // Code used by the backdoor binder to unregister an interceptor.
        private const val UNREGISTER_INTERCEPTOR_CODE = 2
        // --- Hook Type Codes ---
        // Indicates that the call is for a pre-transaction hook.
@@ -302,5 +309,21 @@ abstract class BinderInterceptor : Binder() {
                reply.recycle()
            }
        }
        /** Uses the backdoor binder to unregister an interceptor for a specific target service. */
        fun unregister(backdoor: IBinder, target: IBinder) {
            val data = Parcel.obtain()
            val reply = Parcel.obtain()
            try {
                data.writeStrongBinder(target)
                backdoor.transact(UNREGISTER_INTERCEPTOR_CODE, data, reply, 0)
                SystemLogger.info("Unregistered interceptor for target: $target")
            } catch (e: Exception) {
                SystemLogger.error("Failed to unregister binder interceptor.", e)
            } finally {
                data.recycle()
                reply.recycle()
            }
        }
    }
 }
@@ -3,6 +3,7 @@ package org.matrix.TEESimulator.interception.keystore
 import android.os.Parcel
 import android.os.Parcelable
 import android.security.KeyStore
 import android.security.keystore.KeystoreResponse
 import org.matrix.TEESimulator.interception.core.BinderInterceptor
 import org.matrix.TEESimulator.logging.SystemLogger
@@ -11,6 +12,17 @@ data class KeyIdentifier(val uid: Int, val alias: String)
 /** A collection of utility functions to support binder interception. */
 object InterceptorUtils {
    private const val EX_SERVICE_SPECIFIC = -8
    fun createErrorReply(errorCode: Int): BinderInterceptor.TransactionResult.OverrideReply {
        val parcel = Parcel.obtain().apply {
            writeInt(EX_SERVICE_SPECIFIC)
            writeInt(errorCode)
            writeString(null)
        }
        return BinderInterceptor.TransactionResult.OverrideReply(parcel)
    }
    /**
     * Uses reflection to get the integer transaction code for a given method name from a Stub
     * class. This is necessary for older Android versions where codes are not public constants.
@@ -27,14 +39,31 @@ object InterceptorUtils {
        }
    }
    /** Creates an `KeystoreResponse` parcel that indicates success with no data. */
    fun createSuccessKeystoreResponse(): KeystoreResponse {
        val parcel = Parcel.obtain()
        try {
            parcel.writeInt(KeyStore.NO_ERROR)
            parcel.writeString("")
            parcel.setDataPosition(0)
            return KeystoreResponse.CREATOR.createFromParcel(parcel)
        } finally {
            parcel.recycle()
        }
    }
    /** Creates an `OverrideReply` parcel that indicates success with no data. */
-    fun createSuccessReply(): BinderInterceptor.TransactionResult.OverrideReply {
+    fun createSuccessReply(
        writeResultCode: Boolean = true
    ): BinderInterceptor.TransactionResult.OverrideReply {
        val parcel =
            Parcel.obtain().apply {
                writeNoException()
-                writeInt(KeyStore.NO_ERROR)
+                if (writeResultCode) {
                    writeInt(KeyStore.NO_ERROR)
                }
            }
-        return BinderInterceptor.TransactionResult.OverrideReply(0, parcel)
+        return BinderInterceptor.TransactionResult.OverrideReply(parcel)
    }
    /** Creates an `OverrideReply` parcel containing a raw byte array. */
@@ -44,7 +73,20 @@ object InterceptorUtils {
                writeNoException()
                writeByteArray(data)
            }
-        return BinderInterceptor.TransactionResult.OverrideReply(KeyStore.NO_ERROR, parcel)
+        return BinderInterceptor.TransactionResult.OverrideReply(parcel)
    }
    /** Creates an `OverrideReply` parcel containing a typed array. */
    fun <T : Parcelable> createTypedArrayReply(
        array: Array<T>,
        flags: Int = 0,
    ): BinderInterceptor.TransactionResult.OverrideReply {
        val parcel =
            Parcel.obtain().apply {
                writeNoException()
                writeTypedArray(array, flags)
            }
        return BinderInterceptor.TransactionResult.OverrideReply(parcel)
    }
    /** Creates an `OverrideReply` parcel containing a Parcelable object. */
@@ -57,19 +99,20 @@ object InterceptorUtils {
                writeNoException()
                writeTypedObject(obj, flags)
            }
-        return BinderInterceptor.TransactionResult.OverrideReply(0, parcel)
+        return BinderInterceptor.TransactionResult.OverrideReply(parcel)
    }
    /**
-     * Extracts the true key alias from the keystore-prefixed string (e.g., "user_cert_my-alias" ->
+     * Extracts the base alias from a potentially prefixed alias string. For example, it converts
-     * "my-alias").
+     * "USRCERT_my_key" to "my_key".
     */
    fun extractAlias(prefixedAlias: String): String {
        val underscoreIndex = prefixedAlias.indexOf('_')
-        val secondUnderscoreIndex = prefixedAlias.indexOf('_', underscoreIndex + 1)
+        return if (underscoreIndex != -1) {
-        return if (secondUnderscoreIndex != -1) {
+            // Return the part of the string after the first underscore.
-            prefixedAlias.substring(secondUnderscoreIndex + 1)
+            prefixedAlias.substring(underscoreIndex + 1)
        } else {
            // If there's no underscore, return the original string.
            prefixedAlias
        }
    }
@@ -1,19 +1,23 @@
 package org.matrix.TEESimulator.interception.keystore
 import android.annotation.SuppressLint
 import android.hardware.security.keymint.KeyOrigin
 import android.hardware.security.keymint.SecurityLevel
-import android.hardware.security.keymint.Tag
+import android.os.Build
 import android.os.IBinder
 import android.os.Parcel
 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 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.KeyMintParameterLogger
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.CertificateGenerator
 import org.matrix.TEESimulator.pki.CertificateHelper
 /**
@@ -25,16 +29,24 @@ import org.matrix.TEESimulator.pki.CertificateHelper
 */
@SuppressLint("BlockedPrivateApi")
 object Keystore2Interceptor : AbstractKeystoreInterceptor() {
    private val stubBinderClass = IKeystoreService.Stub::class.java
    // Transaction codes for the IKeystoreService interface methods we are interested in.
    private val GET_KEY_ENTRY_TRANSACTION =
-        InterceptorUtils.getTransactCode(IKeystoreService.Stub::class.java, "getKeyEntry")
+        InterceptorUtils.getTransactCode(stubBinderClass, "getKeyEntry")
    private val DELETE_KEY_TRANSACTION =
-        InterceptorUtils.getTransactCode(IKeystoreService.Stub::class.java, "deleteKey")
+        InterceptorUtils.getTransactCode(stubBinderClass, "deleteKey")
    private val UPDATE_SUBCOMPONENT_TRANSACTION =
        InterceptorUtils.getTransactCode(stubBinderClass, "updateSubcomponent")
    private val LIST_ENTRIES_TRANSACTION =
        InterceptorUtils.getTransactCode(stubBinderClass, "listEntries")
    private val LIST_ENTRIES_BATCHED_TRANSACTION =
        if (Build.VERSION.SDK_INT >= 34)
            InterceptorUtils.getTransactCode(stubBinderClass, "listEntriesBatched")
        else null
    private val transactionNames: Map<Int, String> by lazy {
-        IKeystoreService.Stub::class
+        stubBinderClass.declaredFields
            .java
            .declaredFields
            .filter {
                it.isAccessible = true
                it.type == Int::class.java && it.name.startsWith("TRANSACTION_")
@@ -63,6 +75,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                    val interceptor =
                        KeyMintSecurityLevelInterceptor(tee, SecurityLevel.TRUSTED_ENVIRONMENT)
                    register(backdoor, tee.asBinder(), interceptor)
                    interceptor.loadPersistedKeys()
                }
            }
            .onFailure { SystemLogger.error("Failed to intercept TEE SecurityLevel.", it) }
@@ -74,6 +87,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                    val interceptor =
                        KeyMintSecurityLevelInterceptor(strongbox, SecurityLevel.STRONGBOX)
                    register(backdoor, strongbox.asBinder(), interceptor)
                    interceptor.loadPersistedKeys()
                }
            }
            .onFailure { SystemLogger.error("Failed to intercept StrongBox SecurityLevel.", it) }
@@ -88,29 +102,67 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
        callingPid: Int,
        data: Parcel,
    ): TransactionResult {
-        if (code == GET_KEY_ENTRY_TRANSACTION || code == DELETE_KEY_TRANSACTION) {
+        if (code == LIST_ENTRIES_TRANSACTION || code == LIST_ENTRIES_BATCHED_TRANSACTION) {
-            data.enforceInterface(IKeystoreService.DESCRIPTOR)
+            logTransaction(txId, transactionNames[code]!!, callingUid, callingPid, true)
            val descriptor =
                data.readTypedObject(KeyDescriptor.CREATOR)
                    ?: return TransactionResult.SkipTransaction
            logTransaction(
                txId,
                "${transactionNames[code]} (alias=${descriptor.alias})",
                callingUid,
                callingPid,
            )
-            if (ConfigurationManager.shouldSkipUid(callingUid)) {
+            val packages = ConfigurationManager.getPackagesForUid(callingUid).joinToString()
-                SystemLogger.debug(
+            val isGMS = packages.contains("com.google.android.gms")
-                    "[TX_ID: $txId] Skip post-transaction hook for UID=${callingUid}"
+
-                )
+            if (isGMS || ConfigurationManager.shouldSkipUid(callingUid)) {
                return TransactionResult.ContinueAndSkipPost
            }
            return runCatching {
                    val isBatchMode = code == LIST_ENTRIES_BATCHED_TRANSACTION
                    if (ListEntriesHandler.cacheParameters(txId, data, isBatchMode)) {
                        TransactionResult.Continue
                    } else {
                        TransactionResult.ContinueAndSkipPost
                    }
                }
                .getOrElse {
                    SystemLogger.error(
                        "[TX_ID: $txId] Failed to parse parameters for ${transactionNames[code]!!}",
                        it,
                    )
                    TransactionResult.ContinueAndSkipPost
                }
        } else if (
            code == GET_KEY_ENTRY_TRANSACTION ||
                code == DELETE_KEY_TRANSACTION ||
                code == UPDATE_SUBCOMPONENT_TRANSACTION
        ) {
            logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
            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) {
                SystemLogger.info("Handling ${transactionNames[code]!!} ${descriptor.alias}")
            } else {
                SystemLogger.info(
                    "Skip ${transactionNames[code]!!} for key [alias, blob, domain, nspace]: [${descriptor.alias}, ${descriptor.blob}, ${descriptor.domain}, ${descriptor.nspace}]"
                )
                return TransactionResult.ContinueAndSkipPost
            }
            val keyId = KeyIdentifier(callingUid, descriptor.alias)
            if (code == DELETE_KEY_TRANSACTION) {
-                KeyMintSecurityLevelInterceptor.cleanupKeyData(keyId)
+                if (KeyMintSecurityLevelInterceptor.getGeneratedKeyResponse(keyId) != null) {
                    KeyMintSecurityLevelInterceptor.cleanupKeyData(keyId)
                    SystemLogger.info(
                        "[TX_ID: $txId] Deleted cached keypair ${descriptor.alias}, replying with empty response."
                    )
                    return InterceptorUtils.createSuccessReply(writeResultCode = false)
                }
                return TransactionResult.ContinueAndSkipPost
            }
@@ -119,7 +171,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                    ?: return TransactionResult.Continue
            if (KeyMintSecurityLevelInterceptor.isAttestationKey(keyId))
-                SystemLogger.debug("${descriptor.alias} was an attestation key")
+                SystemLogger.info("${descriptor.alias} was an attestation key")
            SystemLogger.info("[TX_ID: $txId] Found generated response for ${descriptor.alias}:")
            response.metadata?.authorizations?.forEach {
@@ -132,7 +184,7 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
                transactionNames[code] ?: "unknown code=$code",
                callingUid,
                callingPid,
-                false,
+                true,
            )
        }
@@ -154,56 +206,165 @@ object Keystore2Interceptor : AbstractKeystoreInterceptor() {
        if (target != keystoreService || reply == null || InterceptorUtils.hasException(reply))
            return TransactionResult.SkipTransaction
-        if (code == GET_KEY_ENTRY_TRANSACTION) {
+        if (code == LIST_ENTRIES_TRANSACTION || code == LIST_ENTRIES_BATCHED_TRANSACTION) {
            logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
            return runCatching {
                    val updatedKeyDescriptors =
                        ListEntriesHandler.injectGeneratedKeys(txId, callingUid, reply)
                    InterceptorUtils.createTypedArrayReply(updatedKeyDescriptors)
                }
                .getOrElse {
                    SystemLogger.error(
                        "[TX_ID: $txId] Failed to update the result of ${transactionNames[code]!!}.",
                        it,
                    )
                    TransactionResult.SkipTransaction
                }
        } else if (code == GET_KEY_ENTRY_TRANSACTION) {
            data.enforceInterface(IKeystoreService.DESCRIPTOR)
            val keyDescriptor =
                data.readTypedObject(KeyDescriptor.CREATOR)
                    ?: return TransactionResult.SkipTransaction
            logTransaction(
                txId,
-                "post-getKeyEntry (alias=${keyDescriptor.alias})",
+                "post-${transactionNames[code]!!} ${keyDescriptor.alias}",
                callingUid,
                callingPid,
            )
            if (!ConfigurationManager.shouldPatch(callingUid))
                return TransactionResult.SkipTransaction
-            return try {
+            runCatching {
-                val response =
+                    val response = reply.readTypedObject(KeyEntryResponse.CREATOR)!!
-                    reply.readTypedObject(KeyEntryResponse.CREATOR)
+                    val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                        ?: return TransactionResult.SkipTransaction
                reply.setDataPosition(0) // Reset for potential reuse.
-                val originalChain = CertificateHelper.getCertificateChain(response)
+                    val authorizations = response.metadata.authorizations
-                val authorizations = response.metadata?.authorizations
+                    val parsedParameters =
-                val origin =
+                        KeyMintAttestation(
-                    authorizations
+                            authorizations?.map { it.keyParameter }?.toTypedArray() ?: emptyArray()
-                        ?.find { it.keyParameter.tag == Tag.ORIGIN }
+                        )
                        ?.let { it.keyParameter.value.origin }
-                if (origin == KeyOrigin.IMPORTED || origin == KeyOrigin.SECURELY_IMPORTED) {
+                    if (parsedParameters.isImportKey()) {
-                    SystemLogger.info("[TX_ID: $txId] Skip patching for imported keys.")
+                        val retainedChain = KeyMintSecurityLevelInterceptor.getPatchedChain(keyId)
-                    return TransactionResult.SkipTransaction
+                        if (retainedChain == null) {
                            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")
                        CertificateHelper.updateCertificateChain(response.metadata, retainedChain).getOrThrow()
                        return InterceptorUtils.createTypedObjectReply(response)
                    }
                    if (parsedParameters.isAttestKey()) {
                        SystemLogger.warning(
                            "[TX_ID: $txId] Found hardware attest key ${keyId.alias} in the reply."
                        )
                        val keyData =
                            CertificateGenerator.generateAttestedKeyPair(
                                callingUid,
                                keyId.alias,
                                null,
                                parsedParameters,
                                response.metadata.keySecurityLevel,
                            ) ?: throw Exception("Failed to create overriding attest key pair.")
                        CertificateHelper.updateCertificateChain(
                                response.metadata,
                                keyData.second.toTypedArray(),
                            )
                            .getOrThrow()
                        keyDescriptor.nspace = SecureRandom().nextLong()
                        KeyMintSecurityLevelInterceptor.generatedKeys[keyId] =
                            KeyMintSecurityLevelInterceptor.GeneratedKeyInfo(
                                keyData.first,
                                keyDescriptor.nspace,
                                response,
                            )
                        KeyMintSecurityLevelInterceptor.attestationKeys.add(keyId)
                        GeneratedKeyPersistence.save(
                            keyId = keyId,
                            keyPair = keyData.first,
                            nspace = keyDescriptor.nspace,
                            securityLevel = response.metadata.keySecurityLevel,
                            certChain = keyData.second,
                            algorithm = parsedParameters.algorithm,
                            keySize = parsedParameters.keySize,
                            ecCurve = parsedParameters.ecCurve,
                            purposes = parsedParameters.purpose,
                            digests = parsedParameters.digest,
                            isAttestationKey = true,
                        )
                        return InterceptorUtils.createTypedObjectReply(response)
                    }
                    val originalChain = CertificateHelper.getCertificateChain(response)
                    if (originalChain == null || originalChain.size < 2) {
                        SystemLogger.info(
                            "[TX_ID: $txId] Skip patching short certificate chain of length ${originalChain?.size}."
                        )
                        return TransactionResult.SkipTransaction
                    }
                    val cachedChain = KeyMintSecurityLevelInterceptor.getPatchedChain(keyId)
                    val finalChain: Array<Certificate>
                    if (cachedChain != null) {
                        SystemLogger.debug(
                            "[TX_ID: $txId] Using cached patched certificate chain for $keyId."
                        )
                        finalChain = cachedChain
                    } else {
                        SystemLogger.info(
                            "[TX_ID: $txId] No cached chain for $keyId. Performing live patch as a fallback."
                        )
                        finalChain =
                            AttestationPatcher.patchCertificateChain(originalChain, callingUid)
                    }
                    CertificateHelper.updateCertificateChain(response.metadata, finalChain)
                        .getOrThrow()
                    return InterceptorUtils.createTypedObjectReply(response)
                }
-
+                .onFailure {
-                if (originalChain == null || originalChain.size < 2) {
+                    SystemLogger.error(
-                    SystemLogger.info(
+                        "[TX_ID: $txId] Failed to modify hardware KeyEntryResponse.",
-                        "[TX_ID: $txId] Skip patching short certificate chain of length ${originalChain?.size}."
+                        it,
                    )
                    return TransactionResult.SkipTransaction
                }
                // Perform the attestation patch.
                val newChain = AttestationPatcher.patchCertificateChain(originalChain, callingUid)
                CertificateHelper.updateCertificateChain(response.metadata, newChain).getOrThrow()
                InterceptorUtils.createTypedObjectReply(response)
            } catch (e: Exception) {
                SystemLogger.error("[TX_ID: $txId] Failed to patch certificate chain.", e)
                TransactionResult.SkipTransaction
            }
        }
        return TransactionResult.SkipTransaction
    }
    private fun handleUpdateSubcomponent(callingUid: Int, data: Parcel): TransactionResult {
        data.enforceInterface(IKeystoreService.DESCRIPTOR)
        val descriptor = data.readTypedObject(KeyDescriptor.CREATOR)
        val generatedKeyInfo =
            KeyMintSecurityLevelInterceptor.findGeneratedKeyByKeyId(callingUid, descriptor?.nspace)
                ?: return TransactionResult.ContinueAndSkipPost
        SystemLogger.info("Updating sub-component with key[${generatedKeyInfo.nspace}]")
        val metadata = generatedKeyInfo.response.metadata
        val publicCert = data.createByteArray()
        val certificateChain = data.createByteArray()
        metadata.certificate = publicCert
        metadata.certificateChain = certificateChain
        GeneratedKeyPersistence.rePersistIfNeeded(callingUid, generatedKeyInfo)
        SystemLogger.verbose(
            "Key updated with sizes: [publicCert, certificateChain] = [${publicCert?.size}, ${certificateChain?.size}]"
        )
        return InterceptorUtils.createSuccessReply(writeResultCode = false)
    }
 }
@@ -4,12 +4,28 @@ import android.annotation.SuppressLint
 import android.os.IBinder
 import android.os.Parcel
 import android.security.Credentials
 import android.security.KeyStore
 import android.security.keymaster.ExportResult
 import android.security.keymaster.KeyCharacteristics
 import android.security.keymaster.KeymasterArguments
 import android.security.keymaster.KeymasterCertificateChain
 import android.security.keymaster.KeymasterDefs
 import android.security.keystore.IKeystoreCertificateChainCallback
 import android.security.keystore.IKeystoreExportKeyCallback
 import android.security.keystore.IKeystoreKeyCharacteristicsCallback
 import android.security.keystore.IKeystoreService
 import java.math.BigInteger
 import java.security.KeyPair
 import java.security.cert.Certificate
 import java.util.Date
 import java.util.concurrent.ConcurrentHashMap
 import org.matrix.TEESimulator.attestation.AttestationBuilder
 import org.matrix.TEESimulator.attestation.AttestationPatcher
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.interception.keystore.InterceptorUtils.extractAlias
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.CertificateGenerator
 import org.matrix.TEESimulator.pki.CertificateHelper
 /**
@@ -39,11 +55,35 @@ object KeystoreInterceptor : AbstractKeystoreInterceptor() {
        InterceptorUtils.getTransactCode(IKeystoreService.Stub::class.java, "attestKey")
    }
    private val transactionNames: Map<Int, String> by lazy {
        IKeystoreService.Stub::class
            .java
            .declaredFields
            .filter {
                it.isAccessible = true
                it.type == Int::class.java && it.name.startsWith("TRANSACTION_")
            }
            .associate { field -> (field.get(null) as Int) to field.name.split("_")[1] }
    }
    // A map to dispatch transaction handling for software key generation.
    private val generateKeyHandlers:
        Map<Int, (Long, Int, Int, Parcel) -> TransactionResult> by lazy {
        mapOf(
            GENERATE_KEY_TRANSACTION to ::handleGenerateKey,
            GET_KEY_CHARACTERISTICS_TRANSACTION to ::handleGetKeyCharacteristics,
            EXPORT_KEY_TRANSACTION to ::handleExportKey,
            ATTEST_KEY_TRANSACTION to ::handleAttestKey,
        )
    }
    override val serviceName = "android.security.keystore"
    override val processName = "keystore"
    override val injectionCommand = "exec ./inject `pidof keystore` libTEESimulator.so entry"
-    private const val SERVICE_DESCRIPTOR = "android.security.keystore.IKeystoreService"
+    // State management for the multi-step key generation process.
    private val keygenParameters = ConcurrentHashMap<KeyIdentifier, LegacyKeygenParameters>()
    private val generatedKeyPairs = ConcurrentHashMap<KeyIdentifier, KeyPair>()
    // Cache to store the fully patched chain after the leaf is requested.
    private val patchedChainCache = ConcurrentHashMap<KeyIdentifier, Array<Certificate>>()
@@ -58,24 +98,187 @@ object KeystoreInterceptor : AbstractKeystoreInterceptor() {
        data: Parcel,
    ): TransactionResult {
        // This interceptor only needs to act on pre-transaction for software key generation.
        // Handle 'generate' mode interceptions using the handler map.
        if (ConfigurationManager.shouldGenerate(callingUid)) {
-            when (code) {
+            generateKeyHandlers[code]?.let { handler ->
-                GENERATE_KEY_TRANSACTION,
+                logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
-                GET_KEY_CHARACTERISTICS_TRANSACTION,
+                return handler(txId, callingUid, callingPid, data)
                EXPORT_KEY_TRANSACTION,
                ATTEST_KEY_TRANSACTION -> {
                    // TODO: Implement the full software simulation logic.
                    logTransaction(txId, "unimplemented-generate-flow", callingUid, callingPid)
                    return InterceptorUtils.createSuccessReply()
                }
            }
        } else if (ConfigurationManager.shouldGenerate(callingUid)) {
            if (code == GET_TRANSACTION) return TransactionResult.Continue
        }
        // Handle 'patch' mode interceptions for the 'get' transaction.
        if (ConfigurationManager.shouldPatch(callingUid) && code == GET_TRANSACTION) {
            logTransaction(txId, transactionNames[code]!!, callingUid, callingPid, true)
            return TransactionResult.Continue
        }
        // Default behavior for all other transactions.
        logTransaction(
            txId,
            transactionNames[code] ?: "unknown code=$code",
            callingUid,
            callingPid,
            true,
        )
        return TransactionResult.ContinueAndSkipPost
    }
    private fun handleGenerateKey(txId: Long, uid: Int, pid: Int, data: Parcel): TransactionResult {
        return runCatching {
                data.enforceInterface(IKeystoreService.DESCRIPTOR)
                val callback =
                    IKeystoreKeyCharacteristicsCallback.Stub.asInterface(data.readStrongBinder())
                val alias = InterceptorUtils.extractAlias(data.readString()!!)
                val keyId = KeyIdentifier(uid, alias)
                // Read and parse the key generation arguments.
                val keymasterArgs = KeymasterArguments()
                if (data.readInt() == 1) {
                    keymasterArgs.readFromParcel(data)
                }
                keygenParameters[keyId] =
                    LegacyKeygenParameters.fromKeymasterArguments(keymasterArgs)
                // Create a fake successful response for the callback.
                val characteristics = KeyCharacteristics()
                characteristics.swEnforced = KeymasterArguments()
                characteristics.hwEnforced = keymasterArgs
                val keystoreResponse = InterceptorUtils.createSuccessKeystoreResponse()
                callback.onFinished(keystoreResponse, characteristics)
                InterceptorUtils.createSuccessReply()
            }
            .getOrElse {
                SystemLogger.error("[TX_ID: $txId] Failed during handleGenerateKey.", it)
                TransactionResult.ContinueAndSkipPost
            }
    }
    private fun handleGetKeyCharacteristics(
        txId: Long,
        uid: Int,
        pid: Int,
        data: Parcel,
    ): TransactionResult {
        return runCatching {
                data.enforceInterface(IKeystoreService.DESCRIPTOR)
                val callback =
                    IKeystoreKeyCharacteristicsCallback.Stub.asInterface(data.readStrongBinder())
                val alias = InterceptorUtils.extractAlias(data.readString()!!)
                val keyId = KeyIdentifier(uid, alias)
                val params =
                    keygenParameters[keyId]
                        ?: throw IllegalStateException("No params found for $keyId")
                val characteristics =
                    KeyCharacteristics().apply {
                        swEnforced = KeymasterArguments()
                        hwEnforced =
                            KeymasterArguments().apply {
                                addEnum(KeymasterDefs.KM_TAG_ALGORITHM, params.algorithm)
                            }
                    }
                callback.onFinished(
                    InterceptorUtils.createSuccessKeystoreResponse(),
                    characteristics,
                )
                InterceptorUtils.createSuccessReply()
            }
            .getOrElse {
                SystemLogger.error("[TX_ID: $txId] Failed during handleGetKeyCharacteristics.", it)
                TransactionResult.ContinueAndSkipPost
            }
    }
    private fun handleExportKey(txId: Long, uid: Int, pid: Int, data: Parcel): TransactionResult {
        return runCatching {
                data.enforceInterface(IKeystoreService.DESCRIPTOR)
                val callback = IKeystoreExportKeyCallback.Stub.asInterface(data.readStrongBinder())
                val alias = InterceptorUtils.extractAlias(data.readString()!!)
                val keyId = KeyIdentifier(uid, alias)
                val params =
                    keygenParameters[keyId]
                        ?: throw IllegalStateException("No params found for $keyId")
                // Generate a software key pair using the new generator.
                val keyPair =
                    CertificateGenerator.generateSoftwareKeyPair(params.toKeyMintAttestation())
                        ?: throw Exception("Failed to generate software key pair.")
                generatedKeyPairs[keyId] = keyPair
                // Create a successful ExportResult containing the public key.
                val exportResultParcel =
                    Parcel.obtain().apply {
                        writeInt(KeyStore.NO_ERROR)
                        writeByteArray(keyPair.public.encoded)
                        setDataPosition(0)
                    }
                val exportResult = ExportResult.CREATOR.createFromParcel(exportResultParcel)
                exportResultParcel.recycle()
                callback.onFinished(exportResult)
                InterceptorUtils.createSuccessReply()
            }
            .getOrElse {
                SystemLogger.error("[TX_ID: $txId] Failed during handleExportKey.", it)
                TransactionResult.ContinueAndSkipPost
            }
    }
    private fun handleAttestKey(txId: Long, uid: Int, pid: Int, data: Parcel): TransactionResult {
        return runCatching {
                data.enforceInterface(IKeystoreService.DESCRIPTOR)
                val callback =
                    IKeystoreCertificateChainCallback.Stub.asInterface(data.readStrongBinder())
                val alias = InterceptorUtils.extractAlias(data.readString()!!)
                val keyId = KeyIdentifier(uid, alias)
                // Get the attestation challenge from the arguments.
                val params =
                    keygenParameters[keyId]
                        ?: throw IllegalStateException("No params found for $keyId")
                val keyPair =
                    generatedKeyPairs[keyId]
                        ?: throw IllegalStateException("No keypair found for $keyId")
                val attestationArgs = KeymasterArguments()
                if (data.readInt() == 1) {
                    attestationArgs.readFromParcel(data)
                    val challenge =
                        attestationArgs.getBytes(
                            KeymasterDefs.KM_TAG_ATTESTATION_CHALLENGE,
                            ByteArray(0),
                        )
                    params.attestationChallenge = challenge
                }
                val certificateChain =
                    CertificateGenerator.generateCertificateChain(
                        uid,
                        keyPair,
                        null, // No attestKeyAlias in legacy flow
                        params.toKeyMintAttestation(), // Convert to modern format
                        1, // SecurityLevel.TRUSTED_ENVIRONMENT
                    ) ?: throw Exception("CertificateGenerator failed to create attested key pair.")
                val chainAsByteList = certificateChain.map { it.encoded }
                val certChain = KeymasterCertificateChain(chainAsByteList)
                callback.onFinished(InterceptorUtils.createSuccessKeystoreResponse(), certChain)
                InterceptorUtils.createSuccessReply()
            }
            .getOrElse {
                SystemLogger.error("[TX_ID: $txId] Failed during handleAttestKey.", it)
                TransactionResult.ContinueAndSkipPost
            }
    }
    override fun onPostTransact(
        txId: Long,
        target: IBinder,
@@ -93,16 +296,22 @@ object KeystoreInterceptor : AbstractKeystoreInterceptor() {
                reply == null ||
                InterceptorUtils.hasException(reply)
        ) {
            SystemLogger.debug(
                "[TX_ID: $txId] Skip parsing post-transaction for [target, code, reply]: [$target, $code, $reply]"
            )
            return TransactionResult.SkipTransaction
        }
        if (!ConfigurationManager.shouldPatch(callingUid)) return TransactionResult.SkipTransaction
        return try {
-            data.enforceInterface(SERVICE_DESCRIPTOR)
+            data.enforceInterface(IKeystoreService.DESCRIPTOR)
            val alias = data.readString() ?: ""
            val extractedAlias = InterceptorUtils.extractAlias(alias)
            val keyId = KeyIdentifier(callingUid, extractedAlias)
            SystemLogger.debug(
                "[TX_ID: $txId] Parsed $keyId during post-transaction of ${transactionNames[code]}"
            )
            when {
                // Case 1: The app is requesting the leaf certificate.
@@ -111,13 +320,11 @@ object KeystoreInterceptor : AbstractKeystoreInterceptor() {
                    val originalLeafBytes =
                        reply.createByteArray() ?: return TransactionResult.SkipTransaction
-                    // The original chain is not available,
+                    val originalLeafCertResult = CertificateHelper.toCertificate(originalLeafBytes)
-                    // so we must pass a temporary one to the patcher.
+                    if (originalLeafCertResult !is CertificateHelper.OperationResult.Success) {
-                    // The patcher only needs the original leaf to extract details.
+                        return TransactionResult.SkipTransaction
-                    val originalLeafCert =
+                    }
-                        (CertificateHelper.toCertificate(originalLeafBytes)
+                    val originalLeafCert = originalLeafCertResult.data
                                as CertificateHelper.OperationResult.Success)
                            .data
                    val tempChain = arrayOf<Certificate>(originalLeafCert)
                    // Perform the COMPLETE patch and rebuild operation.
@@ -157,11 +364,6 @@ object KeystoreInterceptor : AbstractKeystoreInterceptor() {
                        )
                        InterceptorUtils.createByteArrayReply(caCertsBytes!!)
                    } else {
                        // We have no cached chain.
                        // This could mean the app requested the CA without requesting the leaf
                        // first, or patching failed.
                        // In this case, we cannot safely intervene.
                        // Let the original reply pass through.
                        SystemLogger.warning(
                            "[TX_ID: $txId] No cached chain found for CA request on alias '$extractedAlias'. Skipping."
                        )
@@ -177,3 +379,118 @@ object KeystoreInterceptor : AbstractKeystoreInterceptor() {
        }
    }
 }
 /**
 * A data class to hold key generation parameters parsed from the legacy IKeystoreService's
 * KeymasterArguments. It is used exclusively by the KeystoreInterceptor to manage state during the
 * software key generation flow.
 */
 private data class LegacyKeygenParameters(
    val algorithm: Int,
    val keySize: Int,
    val purpose: List<Int>,
    val digest: List<Int>,
    val certificateNotBefore: Date?,
    val rsaPublicExponent: BigInteger?,
    val ecCurveName: String?, // Derived from keySize
 ) {
    // The challenge is provided in a separate transaction (attestKey), so it must be mutable.
    var attestationChallenge: ByteArray? = null
    /**
     * Converts the legacy parameters into the modern [KeyMintAttestation] data structure, which is
     * required by the refactored [AttestationBuilder] and [CertificateGenerator].
     */
    fun toKeyMintAttestation(): KeyMintAttestation {
        // This conversion acts as a bridge, allowing our new generic components
        // to be used by the legacy interceptor.
        return KeyMintAttestation(
            keySize = this.keySize,
            algorithm = this.algorithm,
            ecCurve = 0,
            ecCurveName = this.ecCurveName ?: "",
            origin = null,
            blockMode = listOf<Int>(),
            padding = listOf<Int>(),
            purpose = this.purpose,
            digest = this.digest,
            rsaPublicExponent = this.rsaPublicExponent,
            certificateSerial = null, // Not provided in legacy generateKey
            certificateSubject = null, // Not provided in legacy generateKey
            certificateNotBefore = this.certificateNotBefore,
            certificateNotAfter = null, // Not provided in legacy generateKey
            attestationChallenge = this.attestationChallenge,
            // Device identifiers are not passed in legacy args;
            // AttestationBuilder will fetch them from system properties.
            brand = null,
            device = null,
            product = null,
            serial = null,
            imei = null,
            meid = null,
            manufacturer = null,
            model = null,
            secondImei = null,
        )
    }
    companion object {
        /** Factory method to create an instance from a [KeymasterArguments] object. */
        fun fromKeymasterArguments(args: KeymasterArguments): LegacyKeygenParameters {
            val algorithm = args.getEnum(KeymasterDefs.KM_TAG_ALGORITHM, 0)
            val keySize = args.getUnsignedInt(KeymasterDefs.KM_TAG_KEY_SIZE, 0).toInt()
            return LegacyKeygenParameters(
                algorithm = algorithm,
                keySize = keySize,
                purpose = args.getEnums(KeymasterDefs.KM_TAG_PURPOSE),
                digest = args.getEnums(KeymasterDefs.KM_TAG_DIGEST),
                certificateNotBefore = args.getDate(KeymasterDefs.KM_TAG_ACTIVE_DATETIME, Date()),
                rsaPublicExponent =
                    if (algorithm == KeymasterDefs.KM_ALGORITHM_RSA) getRsaExponent(args) else null,
                ecCurveName =
                    if (algorithm == KeymasterDefs.KM_ALGORITHM_EC) deriveEcCurveName(keySize)
                    else null,
            )
        }
        private fun deriveEcCurveName(keySize: Int): String =
            when (keySize) {
                224 -> "secp224r1"
                256 -> "secp256r1"
                384 -> "secp384r1"
                521 -> "secp521r1"
                else -> "secp256r1" // Default fallback
            }
        /**
         * The RSA public exponent is not accessible via a public API in KeymasterArguments, so we
         * must use reflection to extract it.
         */
        private fun getRsaExponent(args: KeymasterArguments): BigInteger? {
            return runCatching {
                    val getArgumentByTag =
                        KeymasterArguments::class
                            .java
                            .getDeclaredMethod("getArgumentByTag", Int::class.java)
                    getArgumentByTag.isAccessible = true
                    val rsaArgument =
                        getArgumentByTag.invoke(args, KeymasterDefs.KM_TAG_RSA_PUBLIC_EXPONENT)
                    val getLongTagValue =
                        KeymasterArguments::class
                            .java
                            .getDeclaredMethod(
                                "getLongTagValue",
                                Class.forName("android.security.keymaster.KeymasterArgument"),
                            )
                    getLongTagValue.isAccessible = true
                    getLongTagValue.invoke(args, rsaArgument) as BigInteger
                }
                .onFailure {
                    SystemLogger.error("Failed to read rsaPublicExponent via reflection.", it)
                }
                .getOrNull()
        }
    }
 }
@@ -0,0 +1,142 @@
 package org.matrix.TEESimulator.interception.keystore
 import android.os.Parcel
 import android.system.keystore2.Domain
 import android.system.keystore2.IKeystoreService
 import android.system.keystore2.KeyDescriptor
 import java.util.TreeMap
 import java.util.concurrent.ConcurrentHashMap
 import org.matrix.TEESimulator.interception.keystore.shim.KeyMintSecurityLevelInterceptor
 import org.matrix.TEESimulator.logging.SystemLogger
 /**
 * Handler to intercept listEntries and listEntriesBatched transactions.
 *
 * References for all mentioned functions in AOSP:
 * https://cs.android.com/android/platform/superproject/main/+/main:system/security/keystore2/src/database.rs
 * https://cs.android.com/android/platform/superproject/main/+/main:system/security/keystore2/src/service.rs
 * https://cs.android.com/android/platform/superproject/main/+/main:system/security/keystore2/src/utils.rs
 */
 object ListEntriesHandler {
    // Estimate for maximum size of a Binder response in bytes.
    private const val RESPONSE_SIZE_LIMIT = 358400
    // Parameters of AOSP function `list_key_entries` in utils.rs.
    private data class ListEntriesParams(
        val domain: Int,
        val namespace: Long,
        val startPastAlias: String?,
    )
    private val pendingParams = ConcurrentHashMap<Long, ListEntriesParams>()
    // Based on AOSP function `estimate_safe_amount_to_return` in utils.rs.
    private fun estimateSafeAmountToReturn(
        keyDescriptors: Array<KeyDescriptor>,
        responseSizeLimit: Int,
    ): Int {
        var itemsToReturn = 0
        var returnedBytes = 0
        for (kd in keyDescriptors) {
            // 4 bytes for the Domain enum
            // 8 bytes for the Namespace long
            returnedBytes += 4 + 8
            kd.alias?.let { returnedBytes += 4 + it.toByteArray(Charsets.UTF_8).size }
            kd.blob?.let { returnedBytes += 4 + it.size }
            if (returnedBytes > responseSizeLimit) {
                SystemLogger.warning(
                    "Key descriptors list (${keyDescriptors.size} items) may exceed binder size limit, returning $itemsToReturn items with estimated size: $returnedBytes bytes."
                )
                break
            }
            itemsToReturn++
        }
        return itemsToReturn
    }
    // Parse and store parameters for later use (in post-transaction).
    fun cacheParameters(txId: Long, data: Parcel, isBatchMode: Boolean): Boolean {
        data.enforceInterface(IKeystoreService.DESCRIPTOR)
        val domain = data.readInt()
        val namespace = data.readLong()
        val startPastAlias = if (isBatchMode) data.readString() else null
        // List entries is only supported for Domain::APP and Domain::SELINUX.
        // See AOSP function `get_key_descriptor_for_lookup` in service.rs.
        // Note that all generated keys belong to Domain::APP.
        if (domain == Domain.APP) {
            pendingParams[txId] = ListEntriesParams(domain, namespace, startPastAlias)
            SystemLogger.debug("[TX_ID: $txId] Cached ${pendingParams[txId]}.")
            return true
        }
        return false
    }
    // Merge software-backed keys with hardware-backed keys in the reply parcel.
    fun injectGeneratedKeys(txId: Long, callingUid: Int, reply: Parcel): Array<KeyDescriptor> {
        val params =
            pendingParams.remove(txId)
                ?: throw IllegalStateException("No params found for listing entries")
        // By default we use the calling uid as namespace if domain is Domain::APP.
        // The namespace parameter is thus ignored for non-privileged applications.
        // See AOSP function `get_key_descriptor_for_lookup` in service.rs.
        val keysToInject =
            extractGeneratedKeyDescriptors(callingUid, callingUid.toLong(), params.startPastAlias)
        val originalList = reply.createTypedArray(KeyDescriptor.CREATOR)!!
        val mergedArray = mergeKeyDescriptors(originalList, keysToInject)
        // Limit response size to avoid binder buffer overflow.
        // See AOSP function `list_key_entries` in utils.rs.
        val safeAmountToReturn = estimateSafeAmountToReturn(mergedArray, RESPONSE_SIZE_LIMIT)
        return if (safeAmountToReturn < mergedArray.size) {
            SystemLogger.debug(
                "[TX_ID: $txId] Listing entries are truncated [${mergedArray.size} -> $safeAmountToReturn] to avoid transaction overflow."
            )
            mergedArray.copyOfRange(0, safeAmountToReturn)
        } else {
            SystemLogger.debug(
                "[TX_ID: $txId] Listing entries returns ${mergedArray.size} [injected: ${keysToInject.size}] keys."
            )
            mergedArray
        }
    }
    // Merge hardware and software key descriptors into a single sorted array.
    private fun mergeKeyDescriptors(
        hardwareKeys: Array<KeyDescriptor>,
        keysToInject: List<KeyDescriptor>,
    ): Array<KeyDescriptor> {
        // Uses TreeMap to ensure alphabetical ordering and uniqueness (prefer injected keys).
        val combinedMap = TreeMap<String, KeyDescriptor>()
        hardwareKeys.forEach { key -> key.alias?.let { combinedMap[it] = key } }
        keysToInject.forEach { key -> key.alias?.let { combinedMap[it] = key } }
        return combinedMap.values.toTypedArray()
    }
    // Based on AOSP function `list_past_alias` in database.rs
    private fun extractGeneratedKeyDescriptors(
        uid: Int,
        namespace: Long,
        startPastAlias: String?,
    ): List<KeyDescriptor> {
        return KeyMintSecurityLevelInterceptor.generatedKeys.keys
            .filter { it.uid == uid && (startPastAlias == null || it.alias < startPastAlias) }
            .map { keyId ->
                KeyDescriptor().apply {
                    this.domain = Domain.APP
                    this.nspace = namespace
                    this.alias = keyId.alias
                    this.blob = null
                }
            }
    }
 }
@@ -0,0 +1,376 @@
 package org.matrix.TEESimulator.interception.keystore.shim
 import java.io.BufferedInputStream
 import java.io.BufferedOutputStream
 import java.io.DataInputStream
 import java.io.DataOutputStream
 import java.io.File
 import java.io.FileInputStream
 import java.io.FileOutputStream
 import java.io.IOException
 import java.security.KeyPair
 import java.security.MessageDigest
 import java.security.cert.Certificate
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.locks.ReentrantLock
 import org.matrix.TEESimulator.config.ConfigurationManager.CONFIG_PATH
 import org.matrix.TEESimulator.interception.keystore.KeyIdentifier
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.CertificateHelper
 data class PersistedKeyData(
    val uid: Int,
    val alias: String,
    val nspace: Long,
    val securityLevel: Int,
    val isAttestationKey: Boolean,
    val algorithm: Int,
    val keySize: Int,
    val ecCurve: Int,
    val purposes: List<Int>,
    val digests: List<Int>,
    val privateKeyBytes: ByteArray,
    val certChainBytes: List<ByteArray>,
 )
 object GeneratedKeyPersistence {
    private const val FORMAT_VERSION = 1
    private val PERSISTENCE_DIR = File(CONFIG_PATH, "persistent_keys")
    // Per-filename locks to prevent concurrent writes to the same key file
    private val fileLocks = ConcurrentHashMap<String, ReentrantLock>()
    private fun getLockForKey(filename: String): ReentrantLock {
        return fileLocks.computeIfAbsent(filename) { ReentrantLock() }
    }
    fun save(
        keyId: KeyIdentifier,
        keyPair: KeyPair,
        nspace: Long,
        securityLevel: Int,
        certChain: List<Certificate>,
        algorithm: Int,
        keySize: Int,
        ecCurve: Int,
        purposes: List<Int>,
        digests: List<Int>,
        isAttestationKey: Boolean,
    ) {
        val filename = keyFileName(keyId.uid, keyId.alias)
        val lock = getLockForKey(filename)
        SystemLogger.debug("[Persistence] Acquiring lock for $filename")
        lock.lock()
        try {
            SystemLogger.debug("[Persistence] Lock acquired for $filename")
            runCatching {
                PERSISTENCE_DIR.mkdirs()
                val finalFile = File(PERSISTENCE_DIR, filename)
                val tmpFile = File(PERSISTENCE_DIR, "$filename.tmp")
                try {
                    DataOutputStream(BufferedOutputStream(FileOutputStream(tmpFile))).use { out ->
                        out.writeInt(FORMAT_VERSION)
                        out.writeInt(securityLevel)
                        out.writeInt(keyId.uid)
                        out.writeUTF(keyId.alias)
                        out.writeLong(nspace)
                        out.writeBoolean(isAttestationKey)
                        out.writeInt(algorithm)
                        out.writeInt(keySize)
                        out.writeInt(ecCurve)
                        out.writeInt(purposes.size)
                        purposes.forEach { out.writeInt(it) }
                        out.writeInt(digests.size)
                        digests.forEach { out.writeInt(it) }
                        val pkBytes = keyPair.private.encoded
                        out.writeInt(pkBytes.size)
                        out.write(pkBytes)
                        out.writeInt(certChain.size)
                        certChain.forEach { cert ->
                            val encoded = cert.encoded
                            out.writeInt(encoded.size)
                            out.write(encoded)
                        }
                    }
                } catch (e: Exception) {
                    tmpFile.delete()
                    throw e
                }
                // Atomic rename — if this fails the tmp is left behind and cleaned on next deleteAll
                if (!tmpFile.renameTo(finalFile)) {
                    tmpFile.delete()
                    throw IllegalStateException("Failed to atomically rename $tmpFile -> $finalFile")
                }
                // Verify write succeeded - catches disk-full or filesystem errors
                if (!finalFile.exists() || finalFile.length() < 20) {
                    throw IOException("File write verification failed - possible disk full")
                }
                SystemLogger.debug("Persisted key: $keyId")
            }.onFailure { e ->
                SystemLogger.error("Failed to persist key $keyId", e)
            }
        } finally {
            lock.unlock()
            SystemLogger.debug("[Persistence] Lock released for $filename")
        }
    }
    fun delete(keyId: KeyIdentifier) {
        runCatching {
            val file = File(PERSISTENCE_DIR, keyFileName(keyId.uid, keyId.alias))
            if (file.exists()) {
                if (file.delete()) {
                    SystemLogger.debug("Deleted persisted key: $keyId")
                } else {
                    SystemLogger.warning("Failed to delete persisted key file: ${file.name}")
                }
            } else {
                SystemLogger.debug("No persisted file to delete for: $keyId")
            }
        }.onFailure { e ->
            SystemLogger.error("Failed to delete persisted key $keyId", e)
        }
    }
    fun deleteAll() {
        runCatching {
            if (!PERSISTENCE_DIR.exists()) {
                SystemLogger.debug("No persistent_keys directory, nothing to delete")
                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++
                }
            }
            SystemLogger.info("Deleted $count persisted key files")
        }.onFailure { e ->
            SystemLogger.error("Failed to delete all persisted keys", e)
        }
    }
    fun loadAll(securityLevel: Int): List<PersistedKeyData> {
        if (!PERSISTENCE_DIR.exists()) {
            SystemLogger.debug("No persistent_keys directory, nothing to load")
            return emptyList()
        }
        val files = PERSISTENCE_DIR.listFiles { _, name -> name.endsWith(".bin") }
        if (files == null) {
            SystemLogger.warning("Cannot read persistent_keys directory")
            return emptyList()
        }
        if (files.isEmpty()) {
            SystemLogger.debug("No persisted key files found")
            return emptyList()
        }
        SystemLogger.info("Found ${files.size} persisted key files to process")
        val result = mutableListOf<PersistedKeyData>()
        for (file in files) {
            runCatching {
                DataInputStream(BufferedInputStream(FileInputStream(file))).use { input ->
                    val version = input.readInt()
                    if (version != FORMAT_VERSION) {
                        SystemLogger.warning(
                            "Skipping ${file.name}: unknown format version $version"
                        )
                        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)
                    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,
                            )
                        )
                    }
                }
            }.onFailure { e ->
                SystemLogger.warning("Skipping corrupted persisted key file: ${file.name}", e)
            }
        }
        SystemLogger.info("Loaded ${result.size} persisted keys for security level $securityLevel")
        return result
    }
    // Re-persist updates the cert chain for an already-persisted key without
    // reconstructing authorization parameters from the response. This avoids
    // pulling keymint Tag dependencies into this file and is correct because
    // the only field that changes post-generation is the patched cert chain.
    fun rePersistIfNeeded(
        callingUid: Int,
        generatedKeyInfo: KeyMintSecurityLevelInterceptor.GeneratedKeyInfo,
    ) {
        val metadata = generatedKeyInfo.response.metadata
        if (metadata == null) {
            SystemLogger.debug("rePersist: no metadata, skipping")
            return
        }
        val secLevel = metadata.keySecurityLevel
        val entry = 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}")
            return
        }
        val keyId = entry.key
        val filename = keyFileName(keyId.uid, keyId.alias)
        val existing = File(PERSISTENCE_DIR, filename)
        if (!existing.exists()) {
            SystemLogger.debug("rePersist: no existing file for $keyId, skipping")
            return
        }
        val newChain = CertificateHelper.getCertificateChain(metadata)
        if (newChain == null) {
            SystemLogger.warning("rePersist: could not extract cert chain for $keyId")
            return
        }
        val persisted = runCatching {
            DataInputStream(BufferedInputStream(FileInputStream(existing))).use { input ->
                val version = input.readInt()
                if (version != FORMAT_VERSION) {
                    SystemLogger.warning("rePersist: unknown format version $version for $keyId")
                    return
                }
                readPersistedKeyData(input)
            }
        }.getOrNull()
        if (persisted == null) {
            SystemLogger.warning("rePersist: failed to read existing data for $keyId")
            return
        }
        save(
            keyId = keyId,
            keyPair = generatedKeyInfo.keyPair,
            nspace = generatedKeyInfo.nspace,
            securityLevel = secLevel,
            certChain = newChain.toList(),
            algorithm = persisted.algorithm,
            keySize = persisted.keySize,
            ecCurve = persisted.ecCurve,
            purposes = persisted.purposes,
            digests = persisted.digests,
            isAttestationKey = persisted.isAttestationKey,
        )
        SystemLogger.debug("Re-persisted key $keyId with updated cert chain")
    }
    // Corrupted binary files can have arbitrary length fields — cap allocations
    private fun requireBounds(value: Int, max: Int, name: String): Int {
        require(value in 0..max) { "$name out of bounds: $value (max $max)" }
        return value
    }
    private fun keyFileName(uid: Int, alias: String): String {
        val digest = 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
    private fun readPersistedKeyData(input: DataInputStream): PersistedKeyData {
        val secLevel = 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)
        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
        }
        return PersistedKeyData(
            uid = uid,
            alias = alias,
            nspace = nspace,
            securityLevel = secLevel,
            isAttestationKey = isAttestKey,
            algorithm = algo,
            keySize = kSize,
            ecCurve = curve,
            purposes = purposes,
            digests = digests,
            privateKeyBytes = pkBytes,
            certChainBytes = certChainBytes,
        )
    }
 }
@@ -1,35 +1,48 @@
 package org.matrix.TEESimulator.interception.keystore.shim
 import android.hardware.security.keymint.Algorithm
 import android.hardware.security.keymint.KeyParameter
 import android.hardware.security.keymint.KeyParameterValue
 import android.hardware.security.keymint.KeyPurpose
 import android.hardware.security.keymint.Tag
 import android.os.IBinder
 import android.os.Parcel
 import android.system.keystore2.*
 import android.util.Pair as AndroidPair
 import java.io.ByteArrayInputStream
 import java.security.KeyFactory
 import java.security.KeyPair
 import java.security.SecureRandom
 import java.security.cert.Certificate
 import java.security.cert.CertificateFactory
 import java.security.spec.PKCS8EncodedKeySpec
 import java.util.concurrent.ConcurrentHashMap
 import java.util.concurrent.atomic.AtomicInteger
 import org.matrix.TEESimulator.attestation.AttestationBuilder
 import org.matrix.TEESimulator.attestation.AttestationConstants
 import org.matrix.TEESimulator.attestation.AttestationPatcher
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.interception.core.BinderInterceptor
 import org.matrix.TEESimulator.interception.keystore.InterceptorUtils
 import org.matrix.TEESimulator.interception.keystore.KeyIdentifier
 import org.matrix.TEESimulator.logging.SystemLogger
 import org.matrix.TEESimulator.pki.CertGenConfig
 import org.matrix.TEESimulator.pki.CertificateGenerator
 import org.matrix.TEESimulator.pki.CertificateHelper
 import org.matrix.TEESimulator.pki.KeyBoxManager
 import org.matrix.TEESimulator.pki.NativeCertGen
 import org.matrix.TEESimulator.util.AndroidDeviceUtils
 /**
 * Intercepts calls to an `IKeystoreSecurityLevel` service (e.g., TEE or StrongBox). This is where
 * the core logic for key generation and import handling for modern Android resides.
 */
 class KeyMintSecurityLevelInterceptor(
    private val original: IKeystoreSecurityLevel,
    private val securityLevel: Int,
 ) : BinderInterceptor() {
-    // --- Data Structures for State Management ---
+    data class GeneratedKeyInfo(
-    data class GeneratedKeyInfo(val keyPair: KeyPair, val response: KeyEntryResponse)
+        val keyPair: KeyPair,
        val nspace: Long,
        val response: KeyEntryResponse,
    )
    override fun onPreTransact(
        txId: Long,
@@ -40,43 +53,210 @@ class KeyMintSecurityLevelInterceptor(
        callingPid: Int,
        data: Parcel,
    ): TransactionResult {
-        // This interceptor only handles the 'generateKey' transaction directly.
+        val shouldSkip = ConfigurationManager.shouldSkipUid(callingUid)
-        if (code == GENERATE_KEY_TRANSACTION) {
+
-            logTransaction(txId, "generateKey", callingUid, callingPid)
+        when (code) {
-            data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
+            GENERATE_KEY_TRANSACTION -> {
-            return handleGenerateKey(callingUid, data)
+                logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
-        } else {
+
-            logTransaction(
+                if (!shouldSkip) return handleGenerateKey(txId, callingUid, data)
-                txId,
+            }
-                transactionNames[code] ?: "unknown code=$code",
+            CREATE_OPERATION_TRANSACTION -> {
-                callingUid,
+                logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
-                callingPid,
+
-                false,
+                if (!shouldSkip) return handleCreateOperation(txId, callingUid, data)
-            )
+            }
            IMPORT_KEY_TRANSACTION -> {
                logTransaction(txId, transactionNames[code]!!, callingUid, callingPid)
                data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
                val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
                SystemLogger.info(
                    "[TX_ID: $txId] Forward to post-importKey hook for ${keyDescriptor.alias}[${keyDescriptor.nspace}]"
                )
                return TransactionResult.Continue
            }
        }
        logTransaction(
            txId,
            transactionNames[code] ?: "unknown code=$code",
            callingUid,
            callingPid,
            true,
        )
        return TransactionResult.ContinueAndSkipPost
    }
-    /**
+    override fun onPostTransact(
-     * Handles the `generateKey` transaction. Based on the configuration for the calling UID, it
+        txId: Long,
-     * either generates a key in software or lets the call pass through to the hardware.
+        target: IBinder,
-     */
+        code: Int,
-    private fun handleGenerateKey(callingUid: Int, data: Parcel): TransactionResult {
+        flags: Int,
        callingUid: Int,
        callingPid: Int,
        data: Parcel,
        reply: Parcel?,
        resultCode: Int,
    ): TransactionResult {
        if (code == GENERATE_KEY_TRANSACTION && hardwareKeygenTxIds.remove(txId)) {
            val remaining = hardwareKeygenCount(callingUid).decrementAndGet()
            SystemLogger.info("[TX_ID: $txId] PERMIT_RELEASED uid=$callingUid concurrent_remaining=$remaining result=${if (resultCode == 0) "OK" else "ERROR($resultCode)"}")
        }
        // We only care about successful transactions.
        if (resultCode != 0 || reply == null || InterceptorUtils.hasException(reply))
            return TransactionResult.SkipTransaction
        if (code == IMPORT_KEY_TRANSACTION) {
            logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
            data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
            val keyDescriptor =
                data.readTypedObject(KeyDescriptor.CREATOR)
                    ?: return TransactionResult.SkipTransaction
            // Evict generated key data but retain patched chains so detectors
            // can't use importKey to force unpatched getKeyEntry responses.
            val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
            if (generatedKeys.remove(keyId) != null) {
                SystemLogger.debug("Remove generated key on importKey $keyId")
                GeneratedKeyPersistence.delete(keyId)
            }
            attestationKeys.remove(keyId)
        } else if (code == CREATE_OPERATION_TRANSACTION) {
            logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
            data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
            val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
            val params = data.createTypedArray(KeyParameter.CREATOR)!!
            val parsedParams = KeyMintAttestation(params)
            val forced = data.readBoolean()
            if (forced)
                SystemLogger.verbose(
                    "[TX_ID: $txId] Current operation has a very high pruning power."
                )
            val response: CreateOperationResponse =
                reply.readTypedObject(CreateOperationResponse.CREATOR)!!
            SystemLogger.verbose(
                "[TX_ID: $txId] CreateOperationResponse: ${response.iOperation} ${response.operationChallenge}"
            )
            // Intercept the IKeystoreOperation binder
            response.iOperation?.let { operation ->
                val operationBinder = operation.asBinder()
                if (!interceptedOperations.containsKey(operationBinder)) {
                    SystemLogger.info("Found new IKeystoreOperation. Registering interceptor...")
                    val backdoor = getBackdoor(target)
                    if (backdoor != null) {
                        val interceptor = OperationInterceptor(operation, backdoor)
                        register(backdoor, operationBinder, interceptor)
                        interceptedOperations[operationBinder] = interceptor
                    } else {
                        SystemLogger.error(
                            "Failed to get backdoor to register OperationInterceptor."
                        )
                    }
                }
            }
        } else if (code == GENERATE_KEY_TRANSACTION) {
            logTransaction(txId, "post-${transactionNames[code]!!}", callingUid, callingPid)
            val metadata: KeyMetadata =
                reply.readTypedObject(KeyMetadata.CREATOR)
                    ?: return TransactionResult.SkipTransaction
            val originalChain =
                CertificateHelper.getCertificateChain(metadata)
                    ?: return TransactionResult.SkipTransaction
            if (originalChain.size > 1) {
                val newChain = AttestationPatcher.patchCertificateChain(originalChain, callingUid)
                // Cache the newly patched chain to ensure consistency across subsequent API calls.
                data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
                val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
                val key = metadata.key!!
                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                CertificateHelper.updateCertificateChain(metadata, newChain).getOrThrow()
                // We must clean up cached generated keys before storing the patched chain
                cleanupKeyData(keyId)
                patchedChains[keyId] = newChain
                SystemLogger.debug(
                    "Cached patched certificate chain for $keyId. (${key.alias} [${key.domain}, ${key.nspace}])"
                )
                return InterceptorUtils.createTypedObjectReply(metadata)
            }
        }
        return TransactionResult.SkipTransaction
    }
    private fun handleCreateOperation(
        txId: Long,
        callingUid: Int,
        data: Parcel,
    ): TransactionResult {
        data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
        val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
        // An operation must use the KEY_ID domain.
        if (keyDescriptor.domain != Domain.KEY_ID) {
            return TransactionResult.ContinueAndSkipPost
        }
        val nspace = keyDescriptor.nspace
        val generatedKeyInfo = findGeneratedKeyByKeyId(callingUid, nspace)
        if (generatedKeyInfo == null) {
            SystemLogger.debug(
                "[TX_ID: $txId] Operation for unknown/hardware KeyId ($nspace). Forwarding."
            )
            return TransactionResult.Continue
        }
        SystemLogger.info("[TX_ID: $txId] Creating SOFTWARE operation for KeyId $nspace.")
        val params = data.createTypedArray(KeyParameter.CREATOR)!!
        val parsedParams = KeyMintAttestation(params)
        val softwareOperation = SoftwareOperation(txId, generatedKeyInfo.keyPair, parsedParams)
        val operationBinder = SoftwareOperationBinder(softwareOperation)
        val response =
            CreateOperationResponse().apply {
                iOperation = operationBinder
                operationChallenge = null
            }
        return InterceptorUtils.createTypedObjectReply(response)
    }
    private fun handleGenerateKey(txId: Long, callingUid: Int, data: Parcel): TransactionResult {
        if (data.dataSize() > MAX_ALIAS_LENGTH) {
            SystemLogger.warning("Skipping oversized transaction: ${data.dataSize()} bytes")
            return TransactionResult.ContinueAndSkipPost
        }
        return runCatching {
                data.enforceInterface(IKeystoreSecurityLevel.DESCRIPTOR)
                val keyDescriptor = data.readTypedObject(KeyDescriptor.CREATOR)!!
                val attestationKey = data.readTypedObject(KeyDescriptor.CREATOR)
                SystemLogger.debug(
-                    "[key, attestationKey]: ${keyDescriptor.alias}, ${attestationKey?.alias}"
+                    "Handling generateKey ${keyDescriptor.alias}, attestKey=${attestationKey?.alias}"
                )
                val params = data.createTypedArray(KeyParameter.CREATOR)!!
                val parsedParams = KeyMintAttestation(params)
                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                val isAttestKeyRequest =
                    parsedParams.purpose.size == 1 &&
                        parsedParams.purpose.contains(KeyPurpose.ATTEST_KEY)
-                // Determine if we need to generate a key based on config or
+                val challenge = parsedParams.attestationChallenge
-                // if it's an attestation request in patch mode.
+                if (challenge != null && challenge.size > AttestationConstants.CHALLENGE_LENGTH_LIMIT) {
                    SystemLogger.warning("[TX_ID: $txId] Rejecting oversized attestation challenge: ${challenge.size} bytes (max ${AttestationConstants.CHALLENGE_LENGTH_LIMIT})")
                    return InterceptorUtils.createErrorReply(KEYMINT_INVALID_INPUT_LENGTH)
                }
                val keyId = KeyIdentifier(callingUid, keyDescriptor.alias)
                val isAttestKeyRequest = parsedParams.isAttestKey()
                val needsSoftwareGeneration =
                    ConfigurationManager.shouldGenerate(callingUid) ||
                        (ConfigurationManager.shouldPatch(callingUid) && isAttestKeyRequest) ||
@@ -84,49 +264,150 @@ class KeyMintSecurityLevelInterceptor(
                            isAttestationKey(KeyIdentifier(callingUid, attestationKey.alias)))
                if (needsSoftwareGeneration) {
-                    SystemLogger.info(
+                    return doSoftwareKeyGen(callingUid, keyDescriptor, attestationKey, parsedParams, keyId, isAttestKeyRequest)
-                        "Generating software key for alias '${keyDescriptor.alias}' (UID: $callingUid)."
+                } else if (parsedParams.attestationChallenge != null) {
-                    )
+                    val windowUsed = hardwareKeygenWindowCount(callingUid)
                    val concurrentUsed = hardwareKeygenCount(callingUid).get()
-                    // Generate the key pair and certificate chain.
+                    // Sliding window rate limit
-                    val keyData =
+                    if (windowUsed >= MAX_HW_KEYGEN_PER_WINDOW) {
-                        CertificateGenerator.generateAttestedKeyPair(
+                        SystemLogger.info("[TX_ID: $txId] RATE_LIMITED uid=$callingUid window=$windowUsed/$MAX_HW_KEYGEN_PER_WINDOW concurrent=$concurrentUsed → software fallback")
-                            callingUid,
+                        return doSoftwareKeyGen(callingUid, keyDescriptor, attestationKey, parsedParams, keyId, isAttestKeyRequest)
-                            keyDescriptor.alias,
+                    }
-                            attestationKey?.alias,
+                    // Concurrent cap
-                            parsedParams,
+                    if (hardwareKeygenCount(callingUid).incrementAndGet() > MAX_CONCURRENT_HW_KEYGEN_PER_UID) {
-                            securityLevel,
+                        hardwareKeygenCount(callingUid).decrementAndGet()
-                        ) ?: throw Exception("CertificateGenerator failed to create key pair.")
+                        SystemLogger.info("[TX_ID: $txId] CONCURRENT_LIMITED uid=$callingUid window=$windowUsed/$MAX_HW_KEYGEN_PER_WINDOW concurrent=${concurrentUsed + 1}/$MAX_CONCURRENT_HW_KEYGEN_PER_UID → software fallback")
-
+                        return doSoftwareKeyGen(callingUid, keyDescriptor, attestationKey, parsedParams, keyId, isAttestKeyRequest)
-                    // Store the generated key data.
+                    }
-                    val response =
+                    // Both checks passed — commit the window permit and forward to hardware TEE
-                        buildKeyEntryResponse(keyData.second, parsedParams, keyDescriptor)
+                    recordHardwareKeygen(callingUid)
-
+                    hardwareKeygenTxIds.add(txId)
-                    generatedKeys[keyId] = GeneratedKeyInfo(keyData.first, response)
+                    SystemLogger.info("[TX_ID: $txId] HARDWARE_KEYGEN uid=$callingUid window=${windowUsed + 1}/$MAX_HW_KEYGEN_PER_WINDOW concurrent=${concurrentUsed + 1}/$MAX_CONCURRENT_HW_KEYGEN_PER_UID → forwarding to TEE")
-                    if (isAttestKeyRequest) attestationKeys.add(keyId)
+                    return TransactionResult.Continue
                    // Return the metadata of our generated key, skipping the real hardware call.
                    val resultParcel =
                        Parcel.obtain().apply {
                            writeNoException()
                            writeTypedObject(response.metadata, 0)
                        }
                    return TransactionResult.OverrideReply(0, resultParcel)
                }
                // If not generating, clear any stale state for this alias and let the call proceed.
                cleanupKeyData(keyId)
-                TransactionResult.Continue
+                TransactionResult.ContinueAndSkipPost
            }
            .getOrElse {
                SystemLogger.error("Error during generateKey handling for UID $callingUid.", it)
-                TransactionResult.Continue // Fallback to original service on error.
+                TransactionResult.ContinueAndSkipPost
            }
    }
-    /**
+    private fun doSoftwareKeyGen(
-     * Constructs a fake `KeyEntryResponse` that mimics a real response from the Keystore service.
+        callingUid: Int,
-     */
+        keyDescriptor: KeyDescriptor,
        attestationKey: KeyDescriptor?,
        parsedParams: KeyMintAttestation,
        keyId: KeyIdentifier,
        isAttestKeyRequest: Boolean,
    ): TransactionResult {
        keyDescriptor.nspace = secureRandom.nextLong()
        SystemLogger.info("Generating software key for ${keyDescriptor.alias}[${keyDescriptor.nspace}].")
        val keyData = if (NativeCertGen.isAvailable && attestationKey == null) {
            generateAttestedKeyPairNative(callingUid, parsedParams)
                ?: CertificateGenerator.generateAttestedKeyPair(
                    callingUid, keyDescriptor.alias, attestationKey?.alias, parsedParams, securityLevel,
                )
        } else {
            CertificateGenerator.generateAttestedKeyPair(
                callingUid, keyDescriptor.alias, attestationKey?.alias, parsedParams, securityLevel,
            )
        } ?: throw Exception("Both native and BouncyCastle cert gen failed.")
        cleanupKeyData(keyId)
        val response = buildKeyEntryResponse(keyData.second, parsedParams, keyDescriptor)
        generatedKeys[keyId] = GeneratedKeyInfo(keyData.first, keyDescriptor.nspace, response)
        if (isAttestKeyRequest) attestationKeys.add(keyId)
        GeneratedKeyPersistence.save(
            keyId = keyId,
            keyPair = keyData.first,
            nspace = keyDescriptor.nspace,
            securityLevel = securityLevel,
            certChain = keyData.second.toList(),
            algorithm = parsedParams.algorithm,
            keySize = parsedParams.keySize,
            ecCurve = parsedParams.ecCurve,
            purposes = parsedParams.purpose,
            digests = parsedParams.digest,
            isAttestationKey = isAttestKeyRequest,
        )
        return InterceptorUtils.createTypedObjectReply(response.metadata)
    }
    private fun generateAttestedKeyPairNative(
        callingUid: Int,
        params: KeyMintAttestation,
    ): AndroidPair<KeyPair, List<Certificate>>? {
        return runCatching {
            val algorithmName = when (params.algorithm) {
                Algorithm.EC -> "EC"
                Algorithm.RSA -> "RSA"
                else -> return null
            }
            val keyboxFile = ConfigurationManager.getKeyboxFileForUid(callingUid)
            val keybox = KeyBoxManager.getAttestationKey(keyboxFile, algorithmName) ?: return null
            val keyboxPrivateKeyBytes = keybox.keyPair.private.encoded
            val keyboxCertChainBytes = keybox.certificates
                .map { it.encoded }
                .fold(ByteArray(0)) { acc, der -> acc + der }
            val attestVersion = AndroidDeviceUtils.getAttestVersion(securityLevel)
            val keymasterVersion = AndroidDeviceUtils.getKeymasterVersion(securityLevel)
            val appId = AttestationBuilder.createApplicationId(callingUid)
            val config = CertGenConfig(
                algorithm = params.algorithm,
                keySize = params.keySize,
                ecCurve = params.ecCurve,
                rsaPublicExponent = params.rsaPublicExponent?.toLong() ?: 65537L,
                attestationChallenge = params.attestationChallenge,
                purposes = params.purpose.toIntArray(),
                digests = params.digest.toIntArray(),
                certSerial = params.certificateSerial?.toByteArray(),
                certSubject = params.certificateSubject?.encoded,
                certNotBefore = params.certificateNotBefore?.time ?: -1L,
                certNotAfter = params.certificateNotAfter?.time ?: -1L,
                keyboxPrivateKey = keyboxPrivateKeyBytes,
                keyboxCertChain = keyboxCertChainBytes,
                securityLevel = securityLevel,
                attestVersion = attestVersion,
                keymasterVersion = keymasterVersion,
                osVersion = AndroidDeviceUtils.osVersion,
                osPatchLevel = AndroidDeviceUtils.getPatchLevel(callingUid),
                vendorPatchLevel = AndroidDeviceUtils.getVendorPatchLevelLong(callingUid),
                bootPatchLevel = AndroidDeviceUtils.getBootPatchLevelLong(callingUid),
                bootKey = AndroidDeviceUtils.bootKey,
                bootHash = AndroidDeviceUtils.bootHash,
                creationDatetime = System.currentTimeMillis(),
                attestationApplicationId = appId.octets,
                moduleHash = if (attestVersion >= 400) AndroidDeviceUtils.moduleHash else null,
                idBrand = params.brand,
                idDevice = params.device,
                idProduct = params.product,
                idSerial = params.serial,
                idImei = params.imei,
                idMeid = params.meid,
                idManufacturer = params.manufacturer,
                idModel = params.model,
                idSecondImei = if (attestVersion >= 300) params.secondImei else null,
            )
            val resultBytes = NativeCertGen.generateAttestedKeyPair(config) ?: return null
            val (keyPair, certs) = NativeCertGen.parseNativeResult(resultBytes)
            SystemLogger.info("NativeCertGen: generated key pair successfully (${certs.size} certs)")
            AndroidPair(keyPair, certs)
        }.onFailure {
            SystemLogger.error("NativeCertGen: generation failed, falling back to BouncyCastle", it)
        }.getOrNull()
    }
    private fun buildKeyEntryResponse(
        chain: List<Certificate>,
        params: KeyMintAttestation,
@@ -145,12 +426,132 @@ class KeyMintSecurityLevelInterceptor(
        }
    }
    fun loadPersistedKeys() {
        val records = GeneratedKeyPersistence.loadAll(securityLevel)
        if (records.isEmpty()) {
            SystemLogger.debug("No persisted keys to restore for security level $securityLevel")
            return
        }
        SystemLogger.info("Restoring ${records.size} persisted keys for security level $securityLevel")
        for (record in records) {
            runCatching {
                val keyId = KeyIdentifier(record.uid, record.alias)
                if (generatedKeys.containsKey(keyId)) {
                    SystemLogger.debug("Skipping already-loaded key: $keyId")
                    return@runCatching
                }
                val algorithmName = when (record.algorithm) {
                    Algorithm.EC -> "EC"
                    Algorithm.RSA -> "RSA"
                    else -> throw IllegalArgumentException("Unknown algorithm: ${record.algorithm}")
                }
                val keyFactory = KeyFactory.getInstance(algorithmName)
                val privateKey = keyFactory.generatePrivate(PKCS8EncodedKeySpec(record.privateKeyBytes))
                val certFactory = CertificateFactory.getInstance("X.509")
                val certChain = record.certChainBytes.map { bytes ->
                    certFactory.generateCertificate(ByteArrayInputStream(bytes))
                }
                require(certChain.isNotEmpty()) { "Persisted key has empty certificate chain" }
                val publicKey = certChain[0].publicKey
                val keyPair = KeyPair(publicKey, privateKey)
                val descriptor = KeyDescriptor().apply {
                    domain = Domain.APP
                    nspace = record.nspace
                    alias = record.alias
                    blob = null
                }
                val attestation = KeyMintAttestation(
                    keySize = record.keySize,
                    algorithm = record.algorithm,
                    ecCurve = record.ecCurve,
                    ecCurveName = "",
                    origin = null,
                    blockMode = emptyList(),
                    padding = emptyList(),
                    purpose = record.purposes,
                    digest = record.digests,
                    rsaPublicExponent = null,
                    certificateSerial = null,
                    certificateSubject = null,
                    certificateNotBefore = null,
                    certificateNotAfter = null,
                    attestationChallenge = null,
                    brand = null,
                    device = null,
                    product = null,
                    serial = null,
                    imei = null,
                    meid = null,
                    manufacturer = null,
                    model = null,
                    secondImei = null,
                )
                val response = buildKeyEntryResponse(certChain, attestation, descriptor)
                generatedKeys[keyId] = GeneratedKeyInfo(keyPair, record.nspace, response)
                if (record.isAttestationKey) attestationKeys.add(keyId)
                SystemLogger.debug("Restored persisted key: $keyId")
            }.onFailure {
                SystemLogger.error("Failed to restore key: uid=${record.uid} alias=${record.alias}", it)
            }
        }
        SystemLogger.info("Key restoration complete. Total in memory: ${generatedKeys.size}")
    }
    companion object {
-        // Transaction codes for IKeystoreSecurityLevel interface.
+        private val secureRandom = SecureRandom()
        // Maximum alias length to prevent binder buffer exhaustion (Issue #109)
        // Binder buffer is ~1MB; 256KB provides 4x safety margin for transaction overhead
        private const val MAX_ALIAS_LENGTH = 256 * 1024
        private const val KEYMINT_INVALID_INPUT_LENGTH = -21
        private const val MAX_CONCURRENT_HW_KEYGEN_PER_UID = 2
        // Sliding window: max hardware keygen permits per UID within the burst window
        private const val MAX_HW_KEYGEN_PER_WINDOW = 2
        private const val BURST_WINDOW_MS = 30_000L
        private val uidHardwareKeygenCount = ConcurrentHashMap<Int, AtomicInteger>()
        private val hardwareKeygenTxIds = ConcurrentHashMap.newKeySet<Long>()
        private val uidKeygenTimestamps = ConcurrentHashMap<Int, MutableList<Long>>()
        private fun hardwareKeygenCount(uid: Int): AtomicInteger =
            uidHardwareKeygenCount.computeIfAbsent(uid) { AtomicInteger(0) }
        private fun hardwareKeygenWindowCount(uid: Int): Int {
            val now = System.currentTimeMillis()
            val timestamps = uidKeygenTimestamps.computeIfAbsent(uid) { mutableListOf() }
            synchronized(timestamps) {
                timestamps.removeAll { now - it > BURST_WINDOW_MS }
                return timestamps.size
            }
        }
        private fun recordHardwareKeygen(uid: Int) {
            val timestamps = uidKeygenTimestamps.computeIfAbsent(uid) { mutableListOf() }
            synchronized(timestamps) {
                timestamps.add(System.currentTimeMillis())
            }
        }
        private val GENERATE_KEY_TRANSACTION =
            InterceptorUtils.getTransactCode(IKeystoreSecurityLevel.Stub::class.java, "generateKey")
        private val IMPORT_KEY_TRANSACTION =
            InterceptorUtils.getTransactCode(IKeystoreSecurityLevel.Stub::class.java, "importKey")
        private val CREATE_OPERATION_TRANSACTION =
            InterceptorUtils.getTransactCode(
                IKeystoreSecurityLevel.Stub::class.java,
                "createOperation",
            )
        private val transactionNames: Map<Int, String> by lazy {
            IKeystoreSecurityLevel.Stub::class
@@ -163,39 +564,71 @@ class KeyMintSecurityLevelInterceptor(
                .associate { field -> (field.get(null) as Int) to field.name.split("_")[1] }
        }
        // Stores keys generated entirely in software.
        val generatedKeys = ConcurrentHashMap<KeyIdentifier, GeneratedKeyInfo>()
-        // A set to quickly identify keys that were generated for attestation purposes.
+        // Caches patched chains to prevent re-generation and signature inconsistencies
-        private val attestationKeys = ConcurrentHashMap.newKeySet<KeyIdentifier>()
+        private val patchedChains = ConcurrentHashMap<KeyIdentifier, Array<Certificate>>()
        val attestationKeys: MutableSet<KeyIdentifier> = ConcurrentHashMap.newKeySet()
        private val interceptedOperations = ConcurrentHashMap<IBinder, OperationInterceptor>()
        // --- Public Accessors for Other Interceptors ---
        fun getGeneratedKeyResponse(keyId: KeyIdentifier): KeyEntryResponse? =
            generatedKeys[keyId]?.response
        fun findGeneratedKeyByKeyId(callingUid: Int, nspace: Long?): GeneratedKeyInfo? {
            if (nspace == null || nspace == 0L) return null
            return generatedKeys.entries
                .filter { (keyIdentifier, _) -> keyIdentifier.uid == callingUid }
                .find { (_, info) -> info.nspace == nspace }
                ?.value
        }
        fun getPatchedChain(keyId: KeyIdentifier): Array<Certificate>? = patchedChains[keyId]
        fun isAttestationKey(keyId: KeyIdentifier): Boolean = attestationKeys.contains(keyId)
        fun cleanupKeyData(keyId: KeyIdentifier) {
-            generatedKeys.remove(keyId)
+            if (generatedKeys.remove(keyId) != null) {
-            attestationKeys.remove(keyId)
+                SystemLogger.debug("Remove generated key ${keyId}")
                GeneratedKeyPersistence.delete(keyId)
            }
            if (patchedChains.remove(keyId) != null) {
                SystemLogger.debug("Remove patched chain for ${keyId}")
            }
            if (attestationKeys.remove(keyId)) {
                SystemLogger.debug("Remove cached attestaion key ${keyId}")
            }
        }
        fun removeOperationInterceptor(operationBinder: IBinder, backdoor: IBinder) {
            unregister(backdoor, operationBinder)
            if (interceptedOperations.remove(operationBinder) != null) {
                SystemLogger.debug("Removed operation interceptor for binder: $operationBinder")
            }
        }
        fun invalidatePatchedChains(reason: String? = null) {
            val count = patchedChains.size
            if (count == 0) return
            val reasonMessage = reason?.let { " due to $it" } ?: ""
            patchedChains.clear()
            SystemLogger.info("Invalidated $count patched cert chains$reasonMessage.")
        }
        fun clearAllGeneratedKeys(reason: String? = null) {
            val count = generatedKeys.size
            val reasonMessage = reason?.let { " due to $it" } ?: ""
            generatedKeys.clear()
            patchedChains.clear()
            attestationKeys.clear()
            GeneratedKeyPersistence.deleteAll()
            SystemLogger.info("Cleared all cached keys ($count entries)$reasonMessage.")
        }
    }
 }
 /**
 * Extension function to convert parsed `KeyMintAttestation` parameters back into an array of
 * `Authorization` objects for the fake `KeyMetadata`. This version correctly handles the
 * instantiation of Authorization objects.
 */
 private fun KeyMintAttestation.toAuthorizations(securityLevel: Int): Array<Authorization> {
    val authList = mutableListOf<Authorization>()
    /**
     * Helper function to create a fully-formed Authorization object.
     *
     * @param tag The KeyMint tag (e.g., Tag.ALGORITHM).
     * @param value The value for the tag, wrapped in a KeyParameterValue.
     * @return A populated Authorization object.
     */
    fun createAuth(tag: Int, value: KeyParameterValue): Authorization {
        val param =
            KeyParameter().apply {
@@ -208,7 +641,6 @@ private fun KeyMintAttestation.toAuthorizations(securityLevel: Int): Array<Autho
        }
    }
    // Use the helper to add each authorization entry cleanly.
    this.purpose.forEach { authList.add(createAuth(Tag.PURPOSE, KeyParameterValue.keyPurpose(it))) }
    this.digest.forEach { authList.add(createAuth(Tag.DIGEST, KeyParameterValue.digest(it))) }
@@ -0,0 +1,58 @@
 package org.matrix.TEESimulator.interception.keystore.shim
 import android.os.IBinder
 import android.os.Parcel
 import android.system.keystore2.IKeystoreOperation
 import org.matrix.TEESimulator.interception.core.BinderInterceptor
 import org.matrix.TEESimulator.interception.keystore.InterceptorUtils
 /**
 * Intercepts calls to an `IKeystoreOperation` service. This is used to log the data manipulation
 * methods of a cryptographic operation.
 */
 class OperationInterceptor(
    private val original: IKeystoreOperation,
    private val backdoor: IBinder,
 ) : BinderInterceptor() {
    override fun onPreTransact(
        txId: Long,
        target: IBinder,
        code: Int,
        flags: Int,
        callingUid: Int,
        callingPid: Int,
        data: Parcel,
    ): TransactionResult {
        val methodName = transactionNames[code] ?: "unknown code=$code"
        logTransaction(txId, methodName, callingUid, callingPid, true)
        if (code == FINISH_TRANSACTION || code == ABORT_TRANSACTION) {
            KeyMintSecurityLevelInterceptor.removeOperationInterceptor(target, backdoor)
        }
        return TransactionResult.ContinueAndSkipPost
    }
    companion object {
        private val UPDATE_AAD_TRANSACTION =
            InterceptorUtils.getTransactCode(IKeystoreOperation.Stub::class.java, "updateAad")
        private val UPDATE_TRANSACTION =
            InterceptorUtils.getTransactCode(IKeystoreOperation.Stub::class.java, "update")
        private val FINISH_TRANSACTION =
            InterceptorUtils.getTransactCode(IKeystoreOperation.Stub::class.java, "finish")
        private val ABORT_TRANSACTION =
            InterceptorUtils.getTransactCode(IKeystoreOperation.Stub::class.java, "abort")
        private val transactionNames: Map<Int, String> by lazy {
            IKeystoreOperation.Stub::class
                .java
                .declaredFields
                .filter {
                    it.isAccessible = true
                    it.type == Int::class.java && it.name.startsWith("TRANSACTION_")
                }
                .associate { field -> (field.get(null) as Int) to field.name.split("_")[1] }
        }
    }
 }
@@ -0,0 +1,216 @@
 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.KeyPurpose
 import android.hardware.security.keymint.PaddingMode
 import android.os.RemoteException
 import android.system.keystore2.IKeystoreOperation
 import java.security.KeyPair
 import java.security.Signature
 import java.security.SignatureException
 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.
 private sealed interface CryptoPrimitive {
    fun update(data: ByteArray?): ByteArray?
    fun finish(data: ByteArray?, signature: ByteArray?): ByteArray?
    fun abort()
 }
 // Helper object to map KeyMint constants to JCA algorithm strings.
 private object JcaAlgorithmMapper {
    fun mapSignatureAlgorithm(params: KeyMintAttestation): String {
        val digest =
            when (params.digest.firstOrNull()) {
                Digest.SHA_2_256 -> "SHA256"
                Digest.SHA_2_384 -> "SHA384"
                Digest.SHA_2_512 -> "SHA512"
                else -> "NONE"
            }
        val keyAlgo =
            when (params.algorithm) {
                Algorithm.EC -> "ECDSA"
                Algorithm.RSA -> "RSA"
                else ->
                    throw IllegalArgumentException(
                        "Unsupported signature algorithm: ${params.algorithm}"
                    )
            }
        return "${digest}with${keyAlgo}"
    }
    fun mapCipherAlgorithm(params: KeyMintAttestation): String {
        val keyAlgo =
            when (params.algorithm) {
                Algorithm.RSA -> "RSA"
                Algorithm.AES -> "AES"
                else ->
                    throw IllegalArgumentException(
                        "Unsupported cipher algorithm: ${params.algorithm}"
                    )
            }
        val blockMode =
            when (params.blockMode.firstOrNull()) {
                BlockMode.ECB -> "ECB"
                BlockMode.CBC -> "CBC"
                BlockMode.GCM -> "GCM"
                else -> "ECB" // Default for RSA
            }
        val padding =
            when (params.padding.firstOrNull()) {
                PaddingMode.NONE -> "NoPadding"
                PaddingMode.PKCS7 -> "PKCS7Padding"
                PaddingMode.RSA_PKCS1_1_5_ENCRYPT -> "PKCS1Padding"
                PaddingMode.RSA_OAEP -> "OAEPPadding"
                else -> "NoPadding" // Default for GCM
            }
        return "$keyAlgo/$blockMode/$padding"
    }
 }
 // Concrete implementation for Signing.
 private class Signer(keyPair: KeyPair, params: KeyMintAttestation) : CryptoPrimitive {
    private val signature: Signature =
        Signature.getInstance(JcaAlgorithmMapper.mapSignatureAlgorithm(params)).apply {
            initSign(keyPair.private)
        }
    override fun update(data: ByteArray?): ByteArray? {
        if (data != null) signature.update(data)
        return null
    }
    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray {
        if (data != null) update(data)
        return this.signature.sign()
    }
    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 {
            initVerify(keyPair.public)
        }
    override fun update(data: ByteArray?): ByteArray? {
        if (data != null) signature.update(data)
        return null
    }
    override fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
        if (data != null) update(data)
        if (signature == null) throw SignatureException("Signature to verify is null")
        if (!this.signature.verify(signature)) {
            // Throwing an exception is how Keystore signals verification failure.
            throw SignatureException("Signature verification failed")
        }
        // A successful verification returns no data.
        return null
    }
    override fun abort() {}
 }
 // Concrete implementation for Encryption/Decryption.
 private class CipherPrimitive(
    keyPair: KeyPair,
    params: KeyMintAttestation,
    private val opMode: Int,
 ) : CryptoPrimitive {
    private val cipher: Cipher =
        Cipher.getInstance(JcaAlgorithmMapper.mapCipherAlgorithm(params)).apply {
            val key = if (opMode == Cipher.ENCRYPT_MODE) keyPair.public else keyPair.private
            init(opMode, key)
        }
    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 abort() {}
 }
 /**
 * A software-only implementation of a cryptographic operation. This class acts as a controller,
 * delegating to a specific cryptographic primitive based on the operation's purpose.
 */
 class SoftwareOperation(private val txId: Long, keyPair: KeyPair, params: KeyMintAttestation) {
    // This now holds the specific strategy object (Signer, Verifier, etc.)
    private val primitive: CryptoPrimitive
    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.")
        primitive =
            when (purpose) {
                KeyPurpose.SIGN -> Signer(keyPair, params)
                KeyPurpose.VERIFY -> Verifier(keyPair, params)
                KeyPurpose.ENCRYPT -> CipherPrimitive(keyPair, params, Cipher.ENCRYPT_MODE)
                KeyPurpose.DECRYPT -> CipherPrimitive(keyPair, params, Cipher.DECRYPT_MODE)
                else ->
                    throw UnsupportedOperationException("Unsupported operation purpose: $purpose")
            }
    }
    fun update(data: ByteArray?): ByteArray? {
        try {
            return primitive.update(data)
        } catch (e: Exception) {
            SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to update operation.", e)
            throw e
        }
    }
    fun finish(data: ByteArray?, signature: ByteArray?): ByteArray? {
        try {
            val result = primitive.finish(data, signature)
            SystemLogger.info("[SoftwareOp TX_ID: $txId] Finished operation successfully.")
            return result
        } catch (e: Exception) {
            SystemLogger.error("[SoftwareOp TX_ID: $txId] Failed to finish operation.", e)
            // Re-throw the exception so the binder can report it to the client.
            throw e
        }
    }
    fun abort() {
        primitive.abort()
        SystemLogger.debug("[SoftwareOp TX_ID: $txId] Operation aborted.")
    }
 }
 /** The Binder interface for our [SoftwareOperation]. */
 class SoftwareOperationBinder(private val operation: SoftwareOperation) :
    IKeystoreOperation.Stub() {
    @Throws(RemoteException::class)
    override fun update(input: ByteArray?): ByteArray? {
        return operation.update(input)
    }
    @Throws(RemoteException::class)
    override fun finish(input: ByteArray?, signature: ByteArray?): ByteArray? {
        return operation.finish(input, signature)
    }
    @Throws(RemoteException::class)
    override fun abort() {
        operation.abort()
    }
 }
@@ -1,11 +1,6 @@
 package org.matrix.TEESimulator.logging
-import android.hardware.security.keymint.Algorithm
+import android.hardware.security.keymint.*
 import android.hardware.security.keymint.Digest
 import android.hardware.security.keymint.EcCurve
 import android.hardware.security.keymint.KeyParameter
 import android.hardware.security.keymint.KeyPurpose
 import android.hardware.security.keymint.Tag
 import java.math.BigInteger
 import java.nio.charset.StandardCharsets
 import java.util.Date
@@ -34,7 +29,23 @@ object KeyMintParameterLogger {
            .associate { field -> (field.get(null) as Int) to field.name }
    }
-    private val purposeNames: Map<Int, String> by lazy {
+    val blockModeNames: Map<Int, String> by lazy {
        BlockMode::class
            .java
            .fields
            .filter { it.type == Int::class.java }
            .associate { field -> (field.get(null) as Int) to field.name }
    }
    val paddingNames: Map<Int, String> by lazy {
        PaddingMode::class
            .java
            .fields
            .filter { it.type == Int::class.java }
            .associate { field -> (field.get(null) as Int) to field.name }
    }
    val purposeNames: Map<Int, String> by lazy {
        KeyPurpose::class
            .java
            .fields
@@ -69,7 +80,9 @@ object KeyMintParameterLogger {
        val formattedValue: String =
            when (param.tag) {
                Tag.ALGORITHM -> algorithmNames[value.algorithm]
                Tag.BLOCK_MODE -> blockModeNames[value.blockMode]
                Tag.EC_CURVE -> ecCurveNames[value.ecCurve]
                Tag.PADDING -> paddingNames[value.paddingMode]
                Tag.PURPOSE -> purposeNames[value.keyPurpose]
                Tag.DIGEST -> digestNames[value.digest]
                Tag.AUTH_TIMEOUT,
@@ -1,6 +1,7 @@
 package org.matrix.TEESimulator.logging
 import android.util.Log
 import org.matrix.TEESimulator.BuildConfig
 /**
 * A centralized logging utility for the TEESimulator application. This object provides a consistent
@@ -10,6 +11,8 @@ object SystemLogger {
    // The tag used for all log messages from this application.
    private const val TAG = "TEESimulator"
    private val isDebugBuild = BuildConfig.DEBUG
    /**
     * Logs a debug message. Use this for fine-grained information that is useful for debugging.
     *
@@ -64,6 +67,7 @@ object SystemLogger {
     * @param message The message to log.
     */
    fun verbose(message: String) {
        if (!isDebugBuild) return
        Log.v(TAG, message)
    }
 }
@@ -1,12 +1,12 @@
 package org.matrix.TEESimulator.pki
 import android.hardware.security.keymint.Algorithm
 import android.hardware.security.keymint.KeyPurpose
 import android.os.Build
 import android.util.Pair
 import java.math.BigInteger
 import java.security.KeyPair
 import java.security.KeyPairGenerator
 import java.security.Security
 import java.security.cert.Certificate
 import java.security.cert.X509Certificate
 import java.security.spec.ECGenParameterSpec
@@ -21,6 +21,7 @@ import org.bouncycastle.cert.jcajce.JcaX509v3CertificateBuilder
 import org.bouncycastle.jce.provider.BouncyCastleProvider
 import org.bouncycastle.operator.jcajce.JcaContentSignerBuilder
 import org.matrix.TEESimulator.attestation.AttestationBuilder
 import org.matrix.TEESimulator.attestation.AttestationConstants
 import org.matrix.TEESimulator.attestation.KeyMintAttestation
 import org.matrix.TEESimulator.config.ConfigurationManager
 import org.matrix.TEESimulator.interception.keystore.KeyIdentifier
@@ -35,14 +36,6 @@ import org.matrix.TEESimulator.logging.SystemLogger
 */
 object CertificateGenerator {
    init {
        // Android ships with a stripped-down Bouncy Castle provider under the name "BC".
        // We must remove the system provider first to ensure the full Bouncy Castle library
        // (packaged with the app) is used.
        Security.removeProvider(BouncyCastleProvider.PROVIDER_NAME)
        Security.addProvider(BouncyCastleProvider())
    }
    /**
     * Generates a software-based cryptographic key pair.
     *
@@ -72,16 +65,61 @@ object CertificateGenerator {
    }
    /**
-     * Generates a new key pair and a corresponding certificate chain containing a simulated
+     * Generates a certificate chain for a given key pair. This is the primary function for creating
-     * attestation.
+     * attested certificates.
     *
     * @param uid The UID of the application requesting the key.
-     * @param alias The alias for the new key.
+     * @param subjectKeyPair The key pair for which the certificate will be generated.
     * @param attestKeyAlias Optional alias of a key to use for attestation signing.
     * @param params The parameters for the new key and its attestation.
     * @param securityLevel The security level to embed in the attestation.
-     * @return A [Pair] containing the new [KeyPair] and its certificate chain, or `null` on
+     * @return A [List] of [Certificate] forming the new chain, or `null` on failure.
-     *   failure.
+     */
    fun generateCertificateChain(
        uid: Int,
        subjectKeyPair: KeyPair,
        attestKeyAlias: String?,
        params: KeyMintAttestation,
        securityLevel: Int,
    ): List<Certificate>? {
        val challenge = params.attestationChallenge
        if (challenge != null && challenge.size > AttestationConstants.CHALLENGE_LENGTH_LIMIT)
            throw IllegalArgumentException(
                "Attestation challenge exceeds length limit (${challenge.size} > ${AttestationConstants.CHALLENGE_LENGTH_LIMIT})"
            )
        return runCatching {
                val keybox = getKeyboxForAlgorithm(uid, params.algorithm)
                // Determine the signing key and issuer. If an attestKey is provided, use it.
                // Otherwise, fall back to the root key from the keybox.
                val (signingKey, issuer) =
                    if (attestKeyAlias != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                        getAttestationKeyInfo(uid, attestKeyAlias)?.let { it.first to it.second }
                            ?: (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
                }
            }
            .onFailure { SystemLogger.error("Failed to generate certificate chain.", it) }
            .getOrNull()
    }
    /**
     * A convenience function that combines key pair generation and certificate chain generation.
     * Primarily used by the modern Keystore2 interceptor where generation is a single step.
     */
    fun generateAttestedKeyPair(
        uid: Int,
@@ -98,30 +136,9 @@ object CertificateGenerator {
                    generateSoftwareKeyPair(params)
                        ?: throw Exception("Failed to generate underlying software key pair.")
                val keybox = getKeyboxForAlgorithm(uid, params.algorithm)
                // Determine the signing key and issuer. If an attestKey is provided, use it.
                // Otherwise, fall back to the root key from the keybox.
                val (signingKey, issuer) =
                    if (attestKeyAlias != null && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
                        getAttestationKeyInfo(uid, attestKeyAlias)?.let { it.first to it.second }
                            ?: (keybox.keyPair to getIssuerFromKeybox(keybox))
                    } else {
                        keybox.keyPair to getIssuerFromKeybox(keybox)
                    }
                // Build the new leaf certificate with the simulated attestation.
                val leafCert =
                    buildCertificate(newKeyPair, signingKey, issuer, params, securityLevel)
                // If not self-attesting, the chain is just the leaf. Otherwise, append the keybox
                // chain.
                val chain =
-                    if (attestKeyAlias != null) {
+                    generateCertificateChain(uid, newKeyPair, attestKeyAlias, params, securityLevel)
-                        listOf(leafCert)
+                        ?: throw Exception("Failed to generate certificate chain for new key pair.")
                    } else {
                        listOf(leafCert) + keybox.certificates
                    }
                SystemLogger.info(
                    "Successfully generated new certificate chain for alias: '$alias'."
@@ -134,7 +151,7 @@ object CertificateGenerator {
            .getOrNull()
    }
-    private fun getIssuerFromKeybox(keybox: KeyBox) =
+    fun getIssuerFromKeybox(keybox: KeyBox) =
        X509CertificateHolder(keybox.certificates[0].encoded).subject
    private fun getKeyboxForAlgorithm(uid: Int, algorithm: Int): KeyBox {
@@ -171,12 +188,29 @@ object CertificateGenerator {
        }
    }
    /** Maps KeyPurpose values to X.509 KeyUsage bits per KeyCreationResult.aidl spec */
    private fun buildKeyUsageFromPurposes(purposes: List<Int>): Int {
        var bits = 0
        for (purpose in purposes) {
            bits = bits or when (purpose) {
                KeyPurpose.SIGN -> KeyUsage.digitalSignature
                KeyPurpose.DECRYPT -> KeyUsage.dataEncipherment
                KeyPurpose.WRAP_KEY -> KeyUsage.keyEncipherment
                KeyPurpose.AGREE_KEY -> KeyUsage.keyAgreement
                KeyPurpose.ATTEST_KEY -> KeyUsage.keyCertSign
                else -> 0
            }
        }
        return bits
    }
    /** Constructs a new X.509 certificate with a simulated attestation extension. */
    private fun buildCertificate(
        subjectKeyPair: KeyPair,
        signingKeyPair: KeyPair,
        issuer: X500Name,
        params: KeyMintAttestation,
        uid: Int,
        securityLevel: Int,
    ): Certificate {
        val subject = params.certificateSubject ?: X500Name("CN=Android KeyStore Key")
@@ -194,10 +228,15 @@ object CertificateGenerator {
                subjectKeyPair.public,
            )
-        // Add standard extensions.
+        // Add KeyUsage extension only if purposes map to valid bits
-        builder.addExtension(Extension.keyUsage, true, KeyUsage(KeyUsage.keyCertSign))
+        val keyUsageBits = buildKeyUsageFromPurposes(params.purpose)
        if (keyUsageBits != 0) {
            builder.addExtension(Extension.keyUsage, true, KeyUsage(keyUsageBits))
        }
        // Add our custom, simulated attestation extension.
-        builder.addExtension(AttestationBuilder.buildAttestationExtension(params, securityLevel))
+        builder.addExtension(
            AttestationBuilder.buildAttestationExtension(params, uid, securityLevel)
        )
        val signerAlgorithm =
            when (params.algorithm) {
@@ -205,7 +244,10 @@ object CertificateGenerator {
                Algorithm.RSA -> "SHA256withRSA"
                else -> throw IllegalArgumentException("Unsupported algorithm: ${params.algorithm}")
            }
-        val contentSigner = JcaContentSignerBuilder(signerAlgorithm).build(signingKeyPair.private)
+        val contentSigner =
            JcaContentSignerBuilder(signerAlgorithm)
                .setProvider(BouncyCastleProvider.PROVIDER_NAME)
                .build(signingKeyPair.private)
        return JcaX509CertificateConverter().getCertificate(builder.build(contentSigner))
    }
@@ -3,6 +3,8 @@ package org.matrix.TEESimulator.pki
 import android.security.keystore.KeyProperties
 import java.io.File
 import java.io.StringReader
 import java.security.interfaces.ECPrivateKey
 import java.security.interfaces.RSAPrivateKey
 import java.util.concurrent.ConcurrentHashMap
 import org.matrix.TEESimulator.config.ConfigurationManager.CONFIG_PATH
 import org.matrix.TEESimulator.logging.SystemLogger
@@ -51,6 +53,9 @@ 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(
            "Fetching attestation key in $keyStoreFileName with $algorithm algorithm."
        )
        return keyMap[algorithm]
    }
@@ -157,10 +162,10 @@ object KeyBoxManager {
                            // Use runCatching to ensure one malformed key doesn't stop the whole
                            // process.
                            runCatching {
-                                    val algorithm = currentAlgorithm
+                                    val xmlAlgorithm = currentAlgorithm
                                    val keyPem = currentPrivateKeyPem
                                    if (
-                                        algorithm != null &&
+                                        xmlAlgorithm != null &&
                                            keyPem != null &&
                                            currentCertificatePems.isNotEmpty()
                                    ) {
@@ -176,21 +181,42 @@ object KeyBoxManager {
                                                    .data
                                            }
-                                        // Normalize the algorithm name for consistent lookups.
+                                        // Derive the TRUE algorithm from the key object itself.
-                                        val normalizedAlgorithm =
+                                        // This is our source of truth.
-                                            when (algorithm.lowercase()) {
+                                        val derivedAlgorithm =
-                                                "ecdsa" -> KeyProperties.KEY_ALGORITHM_EC
+                                            when (keyPair.private) {
-                                                "rsa" -> KeyProperties.KEY_ALGORITHM_RSA
+                                                is RSAPrivateKey -> KeyProperties.KEY_ALGORITHM_RSA
-                                                else -> algorithm
+                                                is ECPrivateKey -> KeyProperties.KEY_ALGORITHM_EC
                                                else ->
                                                    throw IllegalArgumentException(
                                                        "Unsupported key type found: ${keyPair.private.javaClass.name}"
                                                    )
                                            }
-                                        if (foundKeys.containsKey(normalizedAlgorithm)) {
+                                        // Normalize the algorithm from the XML tag to compare it
                                        // fairly with the derived algorithm.
                                        val normalizedXmlAlgorithm =
                                            when {
                                                xmlAlgorithm.contains("RSA", ignoreCase = true) ==
                                                    true -> KeyProperties.KEY_ALGORITHM_RSA
                                                xmlAlgorithm.contains("EC", ignoreCase = true) ==
                                                    true -> KeyProperties.KEY_ALGORITHM_EC
                                                else -> xmlAlgorithm
                                            }
                                        // Warn the user if the XML tag was misleading.
                                        if (normalizedXmlAlgorithm != derivedAlgorithm) {
                                            SystemLogger.warning(
-                                                "Duplicate key found for algorithm '$normalizedAlgorithm'. The later one in the file will be used."
+                                                "Key algorithm mismatch in XML file. Tag said '$xmlAlgorithm' but key is actually '$derivedAlgorithm'. Using the correct derived algorithm."
                                            )
                                        }
-                                        foundKeys[normalizedAlgorithm] =
+
-                                            KeyBox(keyPair, certificates)
+                                        if (foundKeys.containsKey(derivedAlgorithm)) {
                                            SystemLogger.warning(
                                                "Duplicate key found for algorithm '$derivedAlgorithm'. The later one in the file will be used."
                                            )
                                        }
                                        foundKeys[derivedAlgorithm] = KeyBox(keyPair, certificates)
                                    }
                                }
                                .onFailure {
@@ -0,0 +1,117 @@
 package org.matrix.TEESimulator.pki
 import java.io.ByteArrayInputStream
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
 import java.security.KeyFactory
 import java.security.KeyPair
 import java.security.cert.Certificate
 import java.security.cert.CertificateFactory
 import java.security.spec.PKCS8EncodedKeySpec
 import org.matrix.TEESimulator.logging.SystemLogger
 data class CertGenConfig(
    val algorithm: Int,
    val keySize: Int,
    val ecCurve: Int,
    val rsaPublicExponent: Long,
    val attestationChallenge: ByteArray?,
    val purposes: IntArray,
    val digests: IntArray,
    val certSerial: ByteArray?,
    val certSubject: ByteArray?,
    val certNotBefore: Long,
    val certNotAfter: Long,
    val keyboxPrivateKey: ByteArray,
    val keyboxCertChain: ByteArray,
    val securityLevel: Int,
    val attestVersion: Int,
    val keymasterVersion: Int,
    val osVersion: Int,
    val osPatchLevel: Int,
    val vendorPatchLevel: Int,
    val bootPatchLevel: Int,
    val bootKey: ByteArray,
    val bootHash: ByteArray,
    val creationDatetime: Long,
    val attestationApplicationId: ByteArray,
    val moduleHash: ByteArray?,
    val idBrand: ByteArray?,
    val idDevice: ByteArray?,
    val idProduct: ByteArray?,
    val idSerial: ByteArray?,
    val idImei: ByteArray?,
    val idMeid: ByteArray?,
    val idManufacturer: ByteArray?,
    val idModel: ByteArray?,
    val idSecondImei: ByteArray?,
 )
 object NativeCertGen {
    private const val LOG_DIR = "/data/adb/tricky_store/logs"
    @Volatile
    var isAvailable: Boolean = false
        private set
    fun initialize(libraryPath: String) {
        try {
            System.load(libraryPath)
            initLogging(false, LOG_DIR)
            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)
        }
    }
    external fun generateAttestedKeyPair(config: CertGenConfig): ByteArray?
    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)
        val pkLen = buf.getInt()
        if (pkLen < 0 || pkLen > buf.remaining()) {
            throw IllegalStateException("Invalid private key length: $pkLen")
        }
        val pkBytes = ByteArray(pkLen)
        buf.get(pkBytes)
        val numCerts = buf.getInt()
        if (numCerts < 0 || numCerts > buf.remaining()) {
            throw IllegalStateException("Invalid cert count: $numCerts")
        }
        val certs = mutableListOf<Certificate>()
        val certFactory = CertificateFactory.getInstance("X.509")
        repeat(numCerts) {
            val certLen = buf.getInt()
            if (certLen < 0 || certLen > buf.remaining()) {
                throw IllegalStateException("Invalid cert length: $certLen")
            }
            val certBytes = ByteArray(certLen)
            buf.get(certBytes)
            certs.add(certFactory.generateCertificate(ByteArrayInputStream(certBytes)))
        }
        if (certs.isEmpty()) {
            throw IllegalStateException("No certificates in native result")
        }
        val algorithmName = when (certs[0].publicKey.algorithm) {
            "EC" -> "EC"
            "RSA" -> "RSA"
            else -> certs[0].publicKey.algorithm
        }
        val keyFactory = KeyFactory.getInstance(algorithmName)
        val privateKey = keyFactory.generatePrivate(PKCS8EncodedKeySpec(pkBytes))
        val publicKey = certs[0].publicKey
        return Pair(KeyPair(publicKey, privateKey), certs)
    }
 }
@@ -1,10 +1,15 @@
 package org.matrix.TEESimulator.util
-import android.content.pm.PackageManager
+import android.hardware.security.keymint.SecurityLevel
 import android.os.Build
 import android.os.SystemProperties
 import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileInputStream
 import java.security.MessageDigest
 import java.time.LocalDate
 import java.util.concurrent.ThreadLocalRandom
 import org.bouncycastle.asn1.ASN1EncodableVector
 import org.bouncycastle.asn1.ASN1Integer
 import org.bouncycastle.asn1.DEROctetString
 import org.bouncycastle.asn1.DERSequence
@@ -18,102 +23,244 @@ import org.matrix.TEESimulator.logging.SystemLogger
 */
 object AndroidDeviceUtils {
-    /** A randomly generated boot key, used as a fallback for attestation. */
+    /**
-    val bootKey: ByteArray by lazy { generateRandomBytes(32) }
+     * Internal constant to signify that a patch level should not be included in the attestation.
     */
    internal const val DO_NOT_REPORT = -1
    // --- Boot Key and Verified Boot Hash ---
    /**
-     * Initializes the verified boot hash (`ro.boot.vbmeta.digest`). It attempts to read from system
+     * Lazily initializes and retrieves the verified boot key digest. The value is sourced in the
-     * properties first, then from a real TEE attestation, and finally falls back to a random value
+     * following order:
-     * if neither is available.
+     * 1. From the `ro.boot.vbmeta.public_key_digest` system property.
     * 2. From a cached TEE attestation record.
     * 3. As a randomly generated 32-byte value (fallback).
     */
-    fun setupBootHash() {
+    val bootKey: ByteArray by lazy {
-        getBootHashFromProperty()?.also {
+        initializeBootProperty(
-            SystemLogger.debug("Using boot hash from system property: ${it.toHex()}")
+            propertyName = "ro.boot.vbmeta.public_key_digest",
-        }
+            attestationValueProvider = {
-            ?: getBootHashFromAttestation()?.also {
+                DeviceAttestationService.CachedAttestationData?.verifiedBootKey
-                SystemLogger.debug("Using boot hash from TEE attestation: ${it.toHex()}")
+            },
-                setBootHashProperty(it)
+            expectedSize = 32,
-            }
+        )
            ?: generateRandomBytes(32).also {
                SystemLogger.debug("Using randomly generated boot hash: ${it.toHex()}")
                setBootHashProperty(it)
            }
    }
    /**
-     * Retrieves the verified boot meta digest from system properties.
+     * Lazily initializes and retrieves the verified boot hash (vbmeta digest). The value is sourced
     * in the following order:
     * 1. From the `ro.boot.vbmeta.digest` system property.
     * 2. From a cached TEE attestation record.
     * 3. As a randomly generated 32-byte value (fallback).
     */
    val bootHash: ByteArray by lazy {
        initializeBootProperty(
            propertyName = "ro.boot.vbmeta.digest",
            attestationValueProvider = {
                DeviceAttestationService.CachedAttestationData?.verifiedBootHash
            },
            expectedSize = 32,
        )
    }
    /**
     * 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.
     */
    fun setupBootKeyAndHash() {
        SystemLogger.debug("Triggering initialization of boot key and hash...")
        // Accessing the properties will trigger their `lazy` initialization logic.
        bootKey
        bootHash
        SystemLogger.debug("Boot key and hash initialization complete.")
    }
    /**
     * Generic initializer for boot properties like the key and hash. It attempts to read from a
     * system property first, then from a TEE attestation, and finally falls back to a random value
     * if neither is available.
     *
-     * @return The boot hash as a ByteArray, or null if not found or invalid.
+     * @param propertyName The name of the system property (e.g., "ro.boot.vbmeta.digest").
     * @param attestationValueProvider A function that supplies the value from a cached attestation.
     * @param expectedSize The expected length of the byte array (e.g., 32 for a SHA-256 digest).
     * @return The resulting byte array for the property.
     */
    private fun initializeBootProperty(
        propertyName: String,
        attestationValueProvider: () -> ByteArray?,
        expectedSize: Int,
    ): ByteArray {
        getProperty(propertyName, expectedSize)?.let {
            SystemLogger.debug("Using $propertyName from system property: ${it.toHex()}")
            persistToFile(propertyName, it)
            return it
        }
        try {
            attestationValueProvider()?.let {
                SystemLogger.debug("Using $propertyName from TEE attestation: ${it.toHex()}")
                setProperty(propertyName, it)
                persistToFile(propertyName, it)
                return it
            }
        } catch (e: Exception) {
            SystemLogger.error("Failed to get $propertyName from attestation.", e)
        }
        readFromFile(propertyName, expectedSize)?.let {
            SystemLogger.debug("Using $propertyName from persistent file: ${it.toHex()}")
            setProperty(propertyName, it)
            return it
        }
        return generateRandomBytes(expectedSize).also {
            SystemLogger.debug("Using randomly generated $propertyName: ${it.toHex()}")
            setProperty(propertyName, it)
            persistToFile(propertyName, it)
        }
    }
    /**
     * Retrieves a system property and validates its format.
     *
     * @param name The name of the system property.
     * @param expectedSize The expected byte length of the property (e.g., 32 for a 64-char hex
     *   string).
     * @return The property value as a ByteArray, or null if not found or invalid.
     */
    @OptIn(ExperimentalStdlibApi::class)
-    fun getBootHashFromProperty(): ByteArray? {
+    private fun getProperty(name: String, expectedSize: Int): ByteArray? {
-        val digest = SystemProperties.get("ro.boot.vbmeta.digest", null)
+        val value = SystemProperties.get(name, null)
-        if (digest.isNullOrBlank()) {
+        if (value.isNullOrBlank()) {
            return null
        }
-        // A valid digest is 64 hex characters (32 bytes).
+        // A valid digest is (2 * size) hex characters.
-        return if (digest.length == 64) digest.hexToByteArray() else null
+        return if (value.length == expectedSize * 2) value.hexToByteArray() else null
    }
    /**
-     * Retrieves the verified boot hash from a cached TEE attestation record.
+     * Sets a system property using the `resetprop` command.
     *
-     * @return The verified boot hash, or null if not available.
+     * @param name The name of the property to set.
     * @param bytes The value to set, which will be converted to a hex string.
     */
-    private fun getBootHashFromAttestation(): ByteArray? {
+    private fun setProperty(name: String, bytes: ByteArray) {
-        return try {
+        val hex = bytes.toHex()
-            DeviceAttestationService.CachedAttestationData?.verifiedBootHash
+        try {
            SystemLogger.debug("Setting system property '$name' to: $hex")
            val command = arrayOf("resetprop", name, hex)
            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 get boot hash from attestation.", e)
+            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
        }
    }
    /**
     * Sets the `ro.boot.vbmeta.digest` system property.
     *
     * @param bytes The 32-byte digest to set.
     */
    private fun setBootHashProperty(bytes: ByteArray) {
        val hex = bytes.toHex()
        try {
            SystemLogger.debug("Setting system property 'ro.boot.vbmeta.digest' to: $hex")
            SystemProperties.set("ro.boot.vbmeta.digest", hex)
        } catch (e: Exception) {
            SystemLogger.error("Failed to set vbmeta digest property.", e)
        }
    }
    /** Generates a cryptographically random byte array of a specified length. */
    private fun generateRandomBytes(size: Int): ByteArray =
        ByteArray(size).also { ThreadLocalRandom.current().nextBytes(it) }
    // --- Patch Level Properties ---
-    val patchLevel: Int
+    fun getPatchLevel(uid: Int): Int {
-        get() =
+        val custom = getCustomPatchLevelFor(uid, "system", isLong = false)
-            getCustomPatchLevelFor("system", isLong = false)
+        return custom ?: getRealDevicePatchLevelInt("system", isLong = false)
-                ?: Build.VERSION.SECURITY_PATCH.toPatchLevelInt(isLong = false)
+    }
-    val vendorPatchLevel: Int
+    fun getVendorPatchLevelLong(uid: Int): Int {
-        get() =
+        val custom = getCustomPatchLevelFor(uid, "vendor", isLong = true)
-            getCustomPatchLevelFor("vendor", isLong = false)
+        return custom ?: getRealDevicePatchLevelInt("vendor", isLong = true)
-                ?: Build.VERSION.SECURITY_PATCH.toPatchLevelInt(isLong = false)
+    }
-    val bootPatchLevelLong: Int
+    fun getBootPatchLevelLong(uid: Int): Int {
-        get() =
+        val custom = getCustomPatchLevelFor(uid, "boot", isLong = true)
-            getCustomPatchLevelFor("boot", isLong = true)
+        return custom ?: getRealDevicePatchLevelInt("boot", isLong = true)
-                ?: Build.VERSION.SECURITY_PATCH.toPatchLevelInt(isLong = true)
+    }
    /**
-     * Retrieves a custom patch level from the configuration if available.
+     * Retrieves the definitive device patch level integer for a given component. This function
     * encapsulates the entire fallback chain and guarantees a non-null return.
     *
     * Fallback Priority:
     * 1. Cached TEE attestation data.
     * 2. Specific system property (e.g., ro.vendor.build.security_patch).
     * 3. Default system patch level from Build.VERSION.SECURITY_PATCH.
     *
     * @param component The component ("system", "vendor", "boot").
     * @param isLong Whether the final integer should be in YYYYMMDD format.
     * @return The patch level as a guaranteed non-null Integer.
     */
    private fun getRealDevicePatchLevelInt(component: String, isLong: Boolean): Int {
        // Get value from cached TEE attestation data
        DeviceAttestationService.CachedAttestationData?.let { data ->
            val value =
                when (component) {
                    "system" -> data.osPatchLevel
                    "vendor" -> data.vendorPatchLevel
                    "boot" -> data.bootPatchLevel
                    else -> null
                }
            if (value != null) return value
        }
        // We only check the specific vendor property, as the boot one is non-existent.
        if (component == "vendor") {
            val propValue = SystemProperties.get("ro.vendor.build.security_patch", "")
            if (!propValue.isNullOrBlank()) {
                parsePatchLevelValue(propValue, isLong)?.let { parsedValue ->
                    return parsedValue
                }
            }
        }
        return Build.VERSION.SECURITY_PATCH.toPatchLevelInt(isLong)
    }
    /**
     * Retrieves a custom patch level from the configuration if available for a specific UID.
     *
     * @param uid The UID of the calling application.
     * @param component The component to get the patch level for ("system", "vendor", "boot").
     * @param isLong Whether to return the patch level in `YYYYMMDD` or `YYYYMM` format.
     * @return The custom patch level, or null if not configured.
     */
-    private fun getCustomPatchLevelFor(component: String, isLong: Boolean): Int? {
+    private fun getCustomPatchLevelFor(uid: Int, component: String, isLong: Boolean): Int? {
-        val config = ConfigurationManager.customPatchLevelOverride ?: return null
+        val config = ConfigurationManager.getPatchLevelForUid(uid) ?: return null
        val value =
            when (component) {
                "system" -> config.system ?: config.all
@@ -122,11 +269,49 @@ object AndroidDeviceUtils {
                else -> config.all
            } ?: return null
-        // "prop" or "no" indicates falling back to the system default.
+        // First, resolve dynamic keywords and templates into a concrete date string.
-        if (value.equals("no", ignoreCase = true) || value.equals("prop", ignoreCase = true)) {
+        val resolvedValue = resolveDateKeywords(value)
-            return null
+
        return when {
            resolvedValue.equals("device_default", ignoreCase = true) -> null
            // 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)
            resolvedValue.equals("no", ignoreCase = true) -> DO_NOT_REPORT
            else -> parsePatchLevelValue(resolvedValue, isLong)
        }
-        return parsePatchLevelValue(value, isLong)
+    }
    /**
     * Resolves special date keywords and templates into a concrete "YYYY-MM-DD" date string.
     *
     * @param value The configuration value string (e.g., "today", "YYYY-MM-01").
     * @return A concrete date string, or the original value if it's not a dynamic date keyword.
     */
    private fun resolveDateKeywords(value: String): String {
        // Handle the "today" keyword.
        if (value.equals("today", ignoreCase = true)) {
            return LocalDate.now().toString() // Returns "YYYY-MM-DD" format
        }
        // Handle date templates like "YYYY-MM-01" or "2025-MM-DD".
        if (
            value.contains("YYYY", ignoreCase = true) ||
                value.contains("MM", ignoreCase = true) ||
                value.contains("DD", ignoreCase = true)
        ) {
            val now = LocalDate.now()
            // Chain replacements for YYYY, MM, and DD placeholders.
            return value
                .replace("YYYY", now.year.toString(), ignoreCase = true)
                .replace("MM", String.format("%02d", now.monthValue), ignoreCase = true)
                .replace("DD", String.format("%02d", now.dayOfMonth), ignoreCase = true)
        }
        // If it's not a dynamic keyword or template, return the original value.
        return value
    }
    /** Parses a patch level string (e.g., "2025-11-01") into an integer format. */
@@ -190,54 +375,204 @@ object AndroidDeviceUtils {
            Build.VERSION_CODES.BAKLAVA to 400, // KeyMint 4.0
        )
-    val attestVersion: Int
+    /**
-        get() =
+     * Retrieves the attestation version based on security level and OS version. StrongBox (level 2)
-            DeviceAttestationService.CachedAttestationData?.attestVersion
+     * requires version 300.
-                ?: attestVersionMap[Build.VERSION.SDK_INT]
+     *
-                ?: 400 // Default to a recent version
+     * @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.
        if (securityLevel == SecurityLevel.STRONGBOX) {
            return 300
        }
        return DeviceAttestationService.CachedAttestationData?.attestVersion
            ?: attestVersionMap[Build.VERSION.SDK_INT]
            ?: 400 // Default to a recent version
    }
-    val keymasterVersion: Int
+    /**
-        get() =
+     * Retrieves the Keymaster/KeyMint version based on the attestation version.
-            DeviceAttestationService.CachedAttestationData?.keymasterVersion
+     *
-                ?: if (attestVersion >= 100) attestVersion
+     * @param securityLevel The security level, used to determine the correct attestation version.
-                else 41 // Keymaster 4.1 for older versions
+     * @return The appropriate Keymaster or KeyMint version number.
     */
    fun getKeymasterVersion(securityLevel: Int): Int {
        val attestVersion = getAttestVersion(securityLevel)
        return if (attestVersion >= 100) attestVersion else 41 // Keymaster 4.1 for older versions
    }
    // --- APEX and Module Hash Properties ---
-    private val apexInfos: List<Pair<String, Long>> by lazy {
+    // Minimal protobuf parser for apex_manifest.pb (field 1: name, field 2: version)
-        runCatching {
+    private class MinimalApexManifestParser(private val data: ByteArray) {
-                val pm = ConfigurationManager.getPackageManager()
+        var pos = 0
-                val packages =
+
-                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+        fun parse(): Pair<String, Long>? {
-                        pm?.getInstalledPackages(PackageManager.MATCH_APEX.toLong(), 0)
+            var name: String? = null
-                    } else {
+            var version: Long? = null
-                        @Suppress("DEPRECATION")
+
-                        pm?.getInstalledPackages(PackageManager.MATCH_APEX, 0)
+            while (pos < data.size) {
                val tag = readVarint()
                val fieldNum = tag ushr 3
                val wireType = (tag and 0x07).toInt()
                when (fieldNum) {
                    1L -> {
                        val length = readVarint().toInt()
                        if (pos + length > data.size) return null
                        name = String(data, pos, length, Charsets.UTF_8)
                        pos += length
                    }
-                packages
+                    2L -> {
-                    ?.list
+                        version = readVarint()
-                    .orEmpty()
+                    }
-                    .map { it.packageName to it.longVersionCode }
+                    else -> skipField(wireType)
-                    .sortedBy { it.first }
+                }
            }
-            .getOrElse {
+
-                SystemLogger.error("Failed to get APEX package information.", it)
+            return if (name != null && version != null) {
-                emptyList()
+                name to version
            } else {
                null
            }
        }
        private fun readVarint(): Long {
            var value = 0L
            var shift = 0
            while (pos < data.size) {
                val b = data[pos++].toInt()
                value = value or ((b and 0x7F).toLong() shl shift)
                if ((b and 0x80) == 0) return value
                shift += 7
            }
            return value
        }
        private fun skipField(wireType: Int) {
            when (wireType) {
                0 -> readVarint()
                1 -> pos += 8
                2 -> {
                    val len = readVarint().toInt()
                    pos += len
                }
                5 -> pos += 4
                else -> throw IllegalStateException("Unknown wire type $wireType")
            }
        }
    }
    private val apexInfos: List<Pair<String, Long>> by lazy {
        val results = mutableListOf<Pair<String, Long>>()
        val apexRoot = File("/apex")
        if (!apexRoot.exists() || !apexRoot.isDirectory) {
            return@lazy emptyList()
        }
        apexRoot.listFiles()?.forEach { file ->
            if (!file.isDirectory) return@forEach
            val name = file.name
            if (name.startsWith(".")) return@forEach
            if (name.contains("@")) return@forEach
            if (name == "sharedlibs") return@forEach
            val manifestFile = File(file, "apex_manifest.pb")
            if (manifestFile.exists()) {
                runCatching {
                    val bytes = FileInputStream(manifestFile).use { it.readBytes() }
                    val parser = MinimalApexManifestParser(bytes)
                    parser.parse()?.let { (pkgName, version) -> results.add(pkgName to version) }
                }
            }
        }
        results.distinctBy { it.first }
    }
    val moduleHash: ByteArray by lazy {
-        runCatching {
+        DeviceAttestationService.CachedAttestationData?.moduleHash
-                val encodables =
+            ?: runCatching {
-                    apexInfos.flatMap { (packageName, versionCode) ->
+                    data class ModuleEntry(
-                        listOf(DEROctetString(packageName.toByteArray()), ASN1Integer(versionCode))
+                        val nameEncoded: ByteArray,
-                    }
+                        val fullEncoded: ByteArray,
-                val sequence = DERSequence(encodables.toTypedArray())
+                    )
-                MessageDigest.getInstance("SHA-256").digest(sequence.encoded)
+
                    val modules =
                        apexInfos.map { (packageName, versionCode) ->
                            val nameOctet = DEROctetString(packageName.toByteArray(Charsets.UTF_8))
                            val versionInt = ASN1Integer(versionCode)
                            val vec = ASN1EncodableVector()
                            vec.add(nameOctet)
                            vec.add(versionInt)
                            val sequence = DERSequence(vec)
                            // AOSP sorts by encoded name only, not full sequence
                            ModuleEntry(
                                nameEncoded = nameOctet.encoded,
                                fullEncoded = sequence.encoded,
                            )
                        }
                    val sortedModules =
                        modules.sortedWith { m1, m2 ->
                            compareByteArrays(m1.nameEncoded, m2.nameEncoded)
                        }
                    val payloadStream = ByteArrayOutputStream()
                    sortedModules.forEach { payloadStream.write(it.fullEncoded) }
                    val payload = payloadStream.toByteArray()
                    // Wrap in DER SET tag manually — DERSet() re-sorts by full encoding
                    val finalDerSet = encodeAsDerSet(payload)
                    MessageDigest.getInstance("SHA-256").digest(finalDerSet)
                }
                .getOrElse {
                    SystemLogger.error("Failed to compute module hash.", it)
                    ByteArray(32)
                }
    }
    private fun compareByteArrays(a: ByteArray, b: ByteArray): Int {
        val length = minOf(a.size, b.size)
        for (i in 0 until length) {
            val byteA = a[i].toInt() and 0xFF
            val byteB = b[i].toInt() and 0xFF
            if (byteA != byteB) {
                return byteA - byteB
            }
-            .getOrElse {
+        }
-                SystemLogger.error("Failed to compute module hash.", it)
+        return a.size - b.size
-                ByteArray(32) // Return empty hash on failure
+    }
    private fun encodeAsDerSet(payload: ByteArray): ByteArray {
        val out = ByteArrayOutputStream()
        out.write(0x31)
        writeDerLength(out, payload.size)
        out.write(payload)
        return out.toByteArray()
    }
    private fun writeDerLength(out: ByteArrayOutputStream, length: Int) {
        if (length < 128) {
            out.write(length)
        } else {
            var size = length
            val bytes = ArrayList<Byte>()
            while (size > 0) {
                bytes.add((size and 0xFF).toByte())
                size = size ushr 8
            }
            out.write(0x80 or bytes.size)
            for (i in bytes.indices.reversed()) {
                out.write(bytes[i].toInt())
            }
        }
    }
 }
@@ -6,7 +6,11 @@ package org.matrix.TEESimulator.util
 *
 * @return A new string with each line individually trimmed.
 */
-fun String.trimLines(): String = this.trim().lines().joinToString("\n") { it.trim() }
+fun String.trimLines(): String =
    this.trim()
        .lines()
        .filter { !it.trim().startsWith("<!--") }
        .joinToString("\n") { it.trim() }
 /**
 * Converts a ByteArray to its hexadecimal string representation.
@@ -1,8 +1,8 @@
 [versions]
-agp = "8.13.1"
+agp = "8.13.2"
 annotation = "1.9.1"
-jdk18on = "1.82"
+jdk18on = "1.83"
-kotlin = "2.2.21"
+kotlin = "2.3.0"
 ktfmt = "0.25.0"
 [libraries]
@@ -0,0 +1,11 @@
 #!/system/bin/sh
 MODDIR=${0%/*}
 CONFIG_DIR=/data/adb/tricky_store
 if [ -d "$CONFIG_DIR/persistent_keys" ]; then
    rm -rf "$CONFIG_DIR/persistent_keys"
    mkdir -p "$CONFIG_DIR/persistent_keys"
    echo "Persistent key storage cleared"
 else
    echo "No persistent key storage found"
 fi
@@ -1,19 +1,53 @@
-**Key Highlights:**
+## TEESimulator v4.1: Boot Identity Persistence
-*   🚀 **Complete Refactoring:** TEESimulator v2.0 has been entirely rebuilt and is no longer based on its predecessors, [TrickyStore](https://github.com/5ec1cff/TrickyStore) and [TrickyStoreOSS](https://github.com/beakthoven/TrickyStoreOSS), resulting in a more streamlined and maintainable codebase.
+Bugfix release. The vbmeta boot key digest was randomizing on every reboot, producing a different RootOfTrust in attestation certificates each boot.
-*   🛡️ **Enhanced Bypass Capabilities:** The simulator now successfully bypasses well-known detection mechanisms, including [TamperedAttestation](https://github.com/JingMatrix/TamperedAttestation) and [KeyAttestation](https://github.com/JingMatrix/KeyAttestation).
+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.
-*   💳 **Revolut Detection Bypass:** With a valid keybox, users can now circumvent the detection measures implemented in the [Revolut](https://play.google.com/store/apps/details?id=com.revolut.revolut) application.
+Verified on Redmi 14C: second boot reads from persistent file instead of regenerating.
-**Current Limitations:**
+---
-*   ⚠️ **Google Play Verdict:** Bypassing the detections within the Google Play verdict remains an unresolved challenge. We are actively seeking solutions and welcome any insights from the community regarding potential system module-based bypasses.
+## TEESimulator v4.0: Native Rust Cert Generation
-**Platform Support:**
+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.
-*   📱 **Android 10 & 11:** TEESimulator v2.0 has not yet been tested on Android 10 or 11. We encourage users on these platforms to report any issues and provide logs to help us improve compatibility.
+### Native Cert Generation
-**Contributing:**
+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).
-*   🤝 We welcome and encourage community contributions. Please feel free to submit issues and pull requests to help improve the project.
+### 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.
 - **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.
 - **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.
 ### Key Persistence
 Generated keys now survive reboots. File-backed storage with file-level locking, preserved across keybox rotations. Banking and biometric apps that cache attestation keys no longer break after restart.
 ### Attestation Fixes
 - Null out all-zero `verifiedBootHash` from TEE cache (fingerprinting vector)
 - 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
 ### Module Lifecycle
 - Supervisor daemon keeps the interceptor alive
 - KSU Action button clears persistent key cache
 - Clean uninstall removes all traces (persistent keys, TEE status, daemon)
 ### Stability
 - FileObserver NPE on config deletion fixed
 - 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).
@@ -48,7 +48,7 @@ install_file() {
 # --- Installation ---
 ui_print "- Extracting module files"
-for file in customize.sh module.prop service.sh sepolicy.rule daemon; do
+for file in customize.sh module.prop service.sh sepolicy.rule daemon action.sh uninstall.sh; do
  install_file "$file" "$MODPATH"
 done
@@ -67,10 +67,14 @@ ui_print ""
 ui_print "- Extracting $ARCH libraries"
 install_file "lib/$ABI_DIR/libTEESimulator.so" "$MODPATH"
 install_file "lib/$ABI_DIR/libinject.so" "$MODPATH"
 install_file "lib/$ABI_DIR/libsupervisor.so" "$MODPATH"
 install_file "lib/$ABI_DIR/libcertgen.so" "$MODPATH"
 ui_print ""
 mv "$MODPATH/libinject.so" "$MODPATH/inject"
 mv "$MODPATH/libsupervisor.so" "$MODPATH/supervisor"
 chmod 755 "$MODPATH/inject"
 chmod 755 "$MODPATH/supervisor"
 # --- Configuration Files ---
 if [ ! -d "$CONFIG_DIR" ]; then
@@ -2,6 +2,6 @@ id=tricky_store
 name=TEESimulator
 version=${REPLACEMEVER}
 versionCode=${REPLACEMEVERCODE}
-author=JingMatrix
+author=JingMatrix, Enginex0
 description=Software simulation for Android hardware-backed key pairs with key attestation
-updateJson=https://raw.githubusercontent.com/JingMatrix/TEESimulator/main/module/update.json
+updateJson=https://raw.githubusercontent.com/Enginex0/TEESimulator/main/module/update.json
@@ -1,4 +1,2 @@
-allow keystore system_file unix_dgram_socket *
+allow keystore {adb_data_file shell_data_file} file *
 allow system_file keystore unix_dgram_socket *
 allow keystore system_file file *
 allow crash_dump keystore process *
@@ -1,11 +1,5 @@
 DEBUG=false
 MODDIR=${0%/*}
 cd $MODDIR
-while true; do
+# Fork-based supervisor for instant restart
-  ./daemon "$MODDIR" || exit 1
+./supervisor ./daemon "$MODDIR" &
  # ensure keystore initialized
  sleep 2
 done &
@@ -0,0 +1,12 @@
 #!/system/bin/sh
 MODDIR=${0%/*}
 CONFIG_DIR=/data/adb/tricky_store
 # Kill daemon and supervisor
 for pid in $(pidof TEESimulator) $(pidof supervisor) $(pidof daemon); do
    kill -9 "$pid" 2>/dev/null
 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"
@@ -1,6 +1,6 @@
 {
-	"version": "v2.0",
+	"version": "v4.1",
-	"versionCode": 14,
+	"versionCode": 94,
-	"zipUrl": "https://github.com/JingMatrix/TEESimulator/releases/download/v2.0/TEESimulator-v2.0-14-release.zip",
+	"zipUrl": "https://github.com/Enginex0/TEESimulator/releases/download/v4.1/TEESimulator-v4.1-Release.zip",
-	"changelog": "https://raw.githubusercontent.com/JingMatrix/TEESimulator/main/module/changelog.md"
+	"changelog": "https://raw.githubusercontent.com/Enginex0/TEESimulator/main/module/changelog.md"
 }
@@ -0,0 +1,11 @@
 [target.aarch64-linux-android]
 linker = "aarch64-linux-android29-clang"
 [target.armv7-linux-androideabi]
 linker = "armv7a-linux-androideabi29-clang"
 [target.i686-linux-android]
 linker = "i686-linux-android29-clang"
 [target.x86_64-linux-android]
 linker = "x86_64-linux-android29-clang"
@@ -0,0 +1,32 @@
 [package]
 name = "certgen"
 version = "0.1.0"
 edition = "2021"
 publish = false
 [lib]
 crate-type = ["cdylib"]
 [dependencies]
 jni = { version = "0.21.1", default-features = false }
 ring = "0.17.14"
 rsa = { version = "0.9", features = ["sha2"] }
 pkcs8 = { version = "0.10", features = ["alloc"] }
 rand = "0.8"
 der = { version = "0.7.10", features = ["alloc", "oid"] }
 const-oid = "0.9.6"
 x509-cert = { version = "0.2.5", features = ["pem"] }
 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]
 opt-level = "z"
 lto = true
 codegen-units = 1
 strip = "symbols"
 panic = "abort"
@@ -0,0 +1,8 @@
 [toolchain]
 channel = "stable"
 targets = [
  "aarch64-linux-android",
  "armv7-linux-androideabi",
  "i686-linux-android",
  "x86_64-linux-android",
 ]
@@ -0,0 +1,644 @@
 use crate::error::Result;
 use crate::types::CertGenParams;
 const DO_NOT_REPORT: i32 = -1;
 pub fn build_attestation_extension(params: &CertGenParams) -> Result<Vec<u8>> {
    let sw = build_software_enforced(params)?;
    let tee = build_tee_enforced(params)?;
    let mut inner = Vec::new();
    // attestationVersion — INTEGER
    inner.extend_from_slice(&enc_integer(params.attest_version as i64));
    // attestationSecurityLevel — ENUMERATED, not INTEGER
    inner.extend_from_slice(&enc_enumerated(params.security_level));
    // keymintVersion — INTEGER
    inner.extend_from_slice(&enc_integer(params.keymaster_version as i64));
    // keymintSecurityLevel — ENUMERATED, not INTEGER
    inner.extend_from_slice(&enc_enumerated(params.security_level));
    // attestationChallenge — OCTET STRING
    inner.extend_from_slice(&enc_octet_string(
        params.attestation_challenge.as_deref().unwrap_or(&[]),
    ));
    // uniqueId — OCTET STRING (always empty)
    inner.extend_from_slice(&enc_octet_string(&[]));
    // softwareEnforced
    inner.extend_from_slice(&sw);
    // teeEnforced
    inner.extend_from_slice(&tee);
    Ok(enc_sequence(&inner))
 }
 fn build_software_enforced(params: &CertGenParams) -> Result<Vec<u8>> {
    let mut fields: Vec<(u32, Vec<u8>)> = Vec::new();
    // Tag 701: CREATION_DATETIME — INTEGER (milliseconds)
    fields.push((701, enc_integer(params.creation_datetime)));
    // Tag 709: ATTESTATION_APPLICATION_ID — OCTET STRING
    // The bytes are already the DER-encoded AttestationApplicationId wrapped in OCTET STRING
    // by the Kotlin layer. We wrap them in an EXPLICIT tag.
    if !params.attestation_application_id.is_empty() {
        fields.push((709, enc_octet_string(&params.attestation_application_id)));
    }
    // Tag 724: MODULE_HASH — OCTET STRING (only if attestVersion >= 400)
    if params.attest_version >= 400 {
        if let Some(ref hash) = params.module_hash {
            fields.push((724, enc_octet_string(hash)));
        }
    }
    Ok(build_authorization_list(&mut fields))
 }
 fn build_tee_enforced(params: &CertGenParams) -> Result<Vec<u8>> {
    let mut fields: Vec<(u32, Vec<u8>)> = Vec::new();
    // Tag 1: PURPOSE — SET OF INTEGER
    if !params.purposes.is_empty() {
        fields.push((1, build_set_of_integer(&params.purposes)));
    }
    // Tag 2: ALGORITHM — INTEGER
    fields.push((2, enc_integer(params.algorithm as i32 as i64)));
    // Tag 3: KEY_SIZE — INTEGER
    fields.push((3, enc_integer(params.key_size as i64)));
    // Tag 5: DIGEST — SET OF INTEGER
    if !params.digests.is_empty() {
        fields.push((5, build_set_of_integer(&params.digests)));
    }
    // Tag 10: EC_CURVE — INTEGER (only for EC keys)
    if let Some(curve) = params.ec_curve {
        fields.push((10, enc_integer(curve as i32 as i64)));
    }
    // Tag 503: NO_AUTH_REQUIRED — NULL (presence = true)
    fields.push((503, enc_null()));
    // Tag 702: ORIGIN — INTEGER 0 (GENERATED)
    fields.push((702, enc_integer(0)));
    // Tag 704: ROOT_OF_TRUST — SEQUENCE
    fields.push((704, build_root_of_trust(params)));
    // Tag 705: OS_VERSION — INTEGER
    if params.os_version != DO_NOT_REPORT {
        fields.push((705, enc_integer(params.os_version as i64)));
    }
    // Tag 706: OS_PATCHLEVEL — INTEGER
    if params.os_patch_level != DO_NOT_REPORT {
        fields.push((706, enc_integer(params.os_patch_level as i64)));
    }
    // Tags 710-717: ATTESTATION_ID_* — OCTET STRING (optional)
    if let Some(ref v) = params.id_brand {
        fields.push((710, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_device {
        fields.push((711, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_product {
        fields.push((712, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_serial {
        fields.push((713, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_imei {
        fields.push((714, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_meid {
        fields.push((715, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_manufacturer {
        fields.push((716, enc_octet_string(v)));
    }
    if let Some(ref v) = params.id_model {
        fields.push((717, enc_octet_string(v)));
    }
    // Tag 718: VENDOR_PATCHLEVEL — INTEGER
    if params.vendor_patch_level != DO_NOT_REPORT {
        fields.push((718, enc_integer(params.vendor_patch_level as i64)));
    }
    // Tag 719: BOOT_PATCHLEVEL — INTEGER
    if params.boot_patch_level != DO_NOT_REPORT {
        fields.push((719, enc_integer(params.boot_patch_level as i64)));
    }
    // Tag 723: ATTESTATION_ID_SECOND_IMEI — OCTET STRING (only if attestVersion >= 300)
    if params.attest_version >= 300 {
        if let Some(ref v) = params.id_second_imei {
            fields.push((723, enc_octet_string(v)));
        }
    }
    Ok(build_authorization_list(&mut fields))
 }
 fn build_root_of_trust(params: &CertGenParams) -> Vec<u8> {
    let mut inner = Vec::new();
    // verifiedBootKey — OCTET STRING (32 bytes)
    inner.extend_from_slice(&enc_octet_string(&params.boot_key));
    // deviceLocked — BOOLEAN TRUE (0xFF, not 0x01)
    inner.extend_from_slice(&enc_boolean(true));
    // verifiedBootState — ENUMERATED 0 (Verified), not INTEGER
    inner.extend_from_slice(&enc_enumerated(0));
    // verifiedBootHash — OCTET STRING (32 bytes)
    inner.extend_from_slice(&enc_octet_string(&params.boot_hash));
    enc_sequence(&inner)
 }
 fn build_authorization_list(fields: &mut Vec<(u32, Vec<u8>)>) -> Vec<u8> {
    fields.sort_by_key(|(tag, _)| *tag);
    let mut inner = Vec::new();
    for (tag, value) in fields.iter() {
        inner.extend_from_slice(&enc_explicit_tag(*tag, value));
    }
    enc_sequence(&inner)
 }
 fn build_set_of_integer(values: &[i32]) -> Vec<u8> {
    // DER SET OF: elements sorted by encoded byte value
    let mut encoded: Vec<Vec<u8>> = values.iter().map(|v| enc_integer(*v as i64)).collect();
    encoded.sort();
    let mut inner = Vec::new();
    for e in &encoded {
        inner.extend_from_slice(e);
    }
    enc_set(&inner)
 }
 // --- DER primitives ---
 fn enc_length(len: usize) -> Vec<u8> {
    if len < 0x80 {
        vec![len as u8]
    } else if len <= 0xFF {
        vec![0x81, len as u8]
    } else if len <= 0xFFFF {
        vec![0x82, (len >> 8) as u8, len as u8]
    } else if len <= 0xFF_FFFF {
        vec![0x83, (len >> 16) as u8, (len >> 8) as u8, len as u8]
    } else {
        vec![
            0x84,
            (len >> 24) as u8,
            (len >> 16) as u8,
            (len >> 8) as u8,
            len as u8,
        ]
    }
 }
 fn enc_integer(value: i64) -> Vec<u8> {
    // DER INTEGER: tag 0x02, minimal two's complement big-endian
    let bytes = integer_bytes(value);
    let mut out = vec![0x02];
    out.extend_from_slice(&enc_length(bytes.len()));
    out.extend_from_slice(&bytes);
    out
 }
 fn integer_bytes(value: i64) -> Vec<u8> {
    if value == 0 {
        return vec![0x00];
    }
    let raw = value.to_be_bytes();
    // Find first significant byte
    let mut start = 0;
    if value > 0 {
        while start < 7 && raw[start] == 0x00 {
            start += 1;
        }
        // If high bit set, need leading 0x00 to keep positive
        if raw[start] & 0x80 != 0 {
            let mut out = vec![0x00];
            out.extend_from_slice(&raw[start..]);
            return out;
        }
    } else {
        while start < 7 && raw[start] == 0xFF {
            start += 1;
        }
        // If high bit clear, need leading 0xFF to keep negative
        if raw[start] & 0x80 == 0 {
            let mut out = vec![0xFF];
            out.extend_from_slice(&raw[start..]);
            return out;
        }
    }
    raw[start..].to_vec()
 }
 fn enc_enumerated(value: i32) -> Vec<u8> {
    // DER ENUMERATED: tag 0x0A, same value encoding as INTEGER
    let bytes = integer_bytes(value as i64);
    let mut out = vec![0x0A];
    out.extend_from_slice(&enc_length(bytes.len()));
    out.extend_from_slice(&bytes);
    out
 }
 fn enc_octet_string(data: &[u8]) -> Vec<u8> {
    let mut out = vec![0x04];
    out.extend_from_slice(&enc_length(data.len()));
    out.extend_from_slice(data);
    out
 }
 fn enc_null() -> Vec<u8> {
    vec![0x05, 0x00]
 }
 fn enc_boolean(value: bool) -> Vec<u8> {
    // DER BOOLEAN: TRUE = 0xFF, FALSE = 0x00
    vec![0x01, 0x01, if value { 0xFF } else { 0x00 }]
 }
 fn enc_sequence(contents: &[u8]) -> Vec<u8> {
    let mut out = vec![0x30];
    out.extend_from_slice(&enc_length(contents.len()));
    out.extend_from_slice(contents);
    out
 }
 fn enc_set(contents: &[u8]) -> Vec<u8> {
    let mut out = vec![0x31];
    out.extend_from_slice(&enc_length(contents.len()));
    out.extend_from_slice(contents);
    out
 }
 fn enc_explicit_tag(tag_number: u32, inner: &[u8]) -> Vec<u8> {
    // EXPLICIT context-specific constructed tag
    let mut out = Vec::new();
    if tag_number < 31 {
        // Short form: single byte 0xA0 | tag_number
        out.push(0xA0 | tag_number as u8);
    } else {
        // Long form: 0xBF followed by base-128 encoding of tag number
        out.push(0xBF);
        enc_base128_tag(&mut out, tag_number);
    }
    out.extend_from_slice(&enc_length(inner.len()));
    out.extend_from_slice(inner);
    out
 }
 fn enc_base128_tag(out: &mut Vec<u8>, tag: u32) {
    // Base-128 with continuation bits: MSB first, bit 7 set on all but last byte
    let mut digits = Vec::new();
    let mut val = tag;
    digits.push((val & 0x7F) as u8);
    val >>= 7;
    while val > 0 {
        digits.push((val & 0x7F) as u8 | 0x80);
        val >>= 7;
    }
    // Written MSB first
    for b in digits.iter().rev() {
        out.push(*b);
    }
 }
 #[cfg(test)]
 mod tests {
    use super::*;
    use crate::types::{Algorithm, EcCurve};
    #[test]
    fn test_enc_integer_zero() {
        assert_eq!(enc_integer(0), vec![0x02, 0x01, 0x00]);
    }
    #[test]
    fn test_enc_integer_small_positive() {
        assert_eq!(enc_integer(3), vec![0x02, 0x01, 0x03]);
        assert_eq!(enc_integer(127), vec![0x02, 0x01, 0x7F]);
    }
    #[test]
    fn test_enc_integer_needs_leading_zero() {
        // 128 = 0x80, high bit set so needs 0x00 prefix
        assert_eq!(enc_integer(128), vec![0x02, 0x02, 0x00, 0x80]);
        assert_eq!(enc_integer(256), vec![0x02, 0x02, 0x01, 0x00]);
    }
    #[test]
    fn test_enc_integer_multi_byte() {
        // 140000 = 0x02_22_E0
        assert_eq!(enc_integer(140000), vec![0x02, 0x03, 0x02, 0x22, 0xE0]);
    }
    #[test]
    fn test_enc_integer_large() {
        // 20250301 = 0x01_34_FE_BD
        assert_eq!(
            enc_integer(20250301),
            vec![0x02, 0x04, 0x01, 0x34, 0xFE, 0xBD]
        );
    }
    #[test]
    fn test_enc_enumerated() {
        // SecurityLevel TEE = 1
        assert_eq!(enc_enumerated(1), vec![0x0A, 0x01, 0x01]);
        // VerifiedBootState Verified = 0
        assert_eq!(enc_enumerated(0), vec![0x0A, 0x01, 0x00]);
    }
    #[test]
    fn test_enc_boolean_true() {
        // DER: TRUE = 0xFF
        assert_eq!(enc_boolean(true), vec![0x01, 0x01, 0xFF]);
    }
    #[test]
    fn test_enc_null() {
        assert_eq!(enc_null(), vec![0x05, 0x00]);
    }
    #[test]
    fn test_enc_octet_string_empty() {
        assert_eq!(enc_octet_string(&[]), vec![0x04, 0x00]);
    }
    #[test]
    fn test_enc_explicit_tag_short() {
        // Tag 1 wrapping INTEGER 2: A1 03 02 01 02
        let inner = enc_integer(2);
        let tagged = enc_explicit_tag(1, &inner);
        assert_eq!(tagged, vec![0xA1, 0x03, 0x02, 0x01, 0x02]);
    }
    #[test]
    fn test_enc_explicit_tag_10() {
        // Tag 10: 0xAA
        let inner = enc_integer(1);
        let tagged = enc_explicit_tag(10, &inner);
        assert_eq!(tagged[0], 0xAA);
    }
    #[test]
    fn test_enc_explicit_tag_503() {
        // Tag 503: 0xBF 0x83 0x77
        // 503 = 3*128 + 119 => 0x83 0x77
        let inner = enc_null();
        let tagged = enc_explicit_tag(503, &inner);
        assert_eq!(&tagged[..3], &[0xBF, 0x83, 0x77]);
    }
    #[test]
    fn test_enc_explicit_tag_704() {
        // Tag 704: 0xBF 0x85 0x40
        // 704 = 5*128 + 64 => 0x85 0x40
        let inner = enc_sequence(&[]);
        let tagged = enc_explicit_tag(704, &inner);
        assert_eq!(&tagged[..3], &[0xBF, 0x85, 0x40]);
    }
    #[test]
    fn test_enc_explicit_tag_718() {
        // Tag 718: 0xBF 0x85 0x4E
        let inner = enc_integer(20250301);
        let tagged = enc_explicit_tag(718, &inner);
        assert_eq!(&tagged[..3], &[0xBF, 0x85, 0x4E]);
    }
    #[test]
    fn test_enc_explicit_tag_719() {
        // Tag 719: 0xBF 0x85 0x4F
        let inner = enc_integer(20250301);
        let tagged = enc_explicit_tag(719, &inner);
        assert_eq!(&tagged[..3], &[0xBF, 0x85, 0x4F]);
    }
    #[test]
    fn test_enc_explicit_tag_701() {
        // Tag 701: 0xBF 0x85 0x3D
        let inner = enc_integer(1000);
        let tagged = enc_explicit_tag(701, &inner);
        assert_eq!(&tagged[..3], &[0xBF, 0x85, 0x3D]);
    }
    #[test]
    fn test_enc_explicit_tag_709() {
        // Tag 709: 0xBF 0x85 0x45
        let inner = enc_octet_string(&[0x01]);
        let tagged = enc_explicit_tag(709, &inner);
        assert_eq!(&tagged[..3], &[0xBF, 0x85, 0x45]);
    }
    #[test]
    fn test_build_set_of_integer_sorted() {
        // SET OF INTEGER must sort by encoded bytes
        let result = build_set_of_integer(&[3, 2]);
        // Expect sorted: INTEGER 2 before INTEGER 3
        let expected = enc_set(&[0x02, 0x01, 0x02, 0x02, 0x01, 0x03]);
        assert_eq!(result, expected);
    }
    #[test]
    fn test_root_of_trust_structure() {
        let params = make_test_params();
        let rot = build_root_of_trust(&params);
        // Should be a SEQUENCE (0x30)
        assert_eq!(rot[0], 0x30);
        // Find BOOLEAN TRUE inside
        let rot_inner = &rot[2..]; // skip tag+length
        // First: OCTET STRING (32 bytes boot key)
        assert_eq!(rot_inner[0], 0x04);
        assert_eq!(rot_inner[1], 0x20); // 32 bytes
        // After boot key (34 bytes): BOOLEAN TRUE
        assert_eq!(rot_inner[34], 0x01); // BOOLEAN tag
        assert_eq!(rot_inner[35], 0x01); // length 1
        assert_eq!(rot_inner[36], 0xFF); // TRUE = 0xFF
        // Then ENUMERATED 0 (verifiedBootState)
        assert_eq!(rot_inner[37], 0x0A); // ENUMERATED tag, not 0x02
        assert_eq!(rot_inner[38], 0x01);
        assert_eq!(rot_inner[39], 0x00);
    }
    #[test]
    fn test_do_not_report_omits_fields() {
        let mut params = make_test_params();
        params.os_patch_level = DO_NOT_REPORT;
        params.vendor_patch_level = DO_NOT_REPORT;
        params.boot_patch_level = DO_NOT_REPORT;
        let tee = build_tee_enforced(&params).unwrap();
        let hex = hex_string(&tee);
        // Tags 706, 718, 719 should not appear
        // Tag 706 = BF 85 42, 718 = BF 85 4E, 719 = BF 85 4F
        assert!(!hex.contains("bf8542"), "os_patch_level should be omitted");
        assert!(
            !hex.contains("bf854e"),
            "vendor_patch_level should be omitted"
        );
        assert!(
            !hex.contains("bf854f"),
            "boot_patch_level should be omitted"
        );
    }
    #[test]
    fn test_key_description_security_level_is_enumerated() {
        let params = make_test_params();
        let ext = build_attestation_extension(&params).unwrap();
        // KeyDescription is a SEQUENCE: 0x30 ...
        assert_eq!(ext[0], 0x30);
        // Skip SEQUENCE tag + length to get to inner fields
        let inner = skip_tlv_header(&ext);
        // Field 0: attestationVersion — INTEGER (0x02)
        assert_eq!(inner[0], 0x02);
        let (_, rest) = skip_one_tlv(inner);
        // Field 1: attestationSecurityLevel — ENUMERATED (0x0A)
        assert_eq!(rest[0], 0x0A, "attestationSecurityLevel must be ENUMERATED");
        let (_, rest) = skip_one_tlv(rest);
        // Field 2: keymintVersion — INTEGER (0x02)
        assert_eq!(rest[0], 0x02);
        let (_, rest) = skip_one_tlv(rest);
        // Field 3: keymintSecurityLevel — ENUMERATED (0x0A)
        assert_eq!(rest[0], 0x0A, "keymintSecurityLevel must be ENUMERATED");
    }
    #[test]
    fn test_authorization_list_sorted_by_tag() {
        let params = make_test_params();
        let tee = build_tee_enforced(&params).unwrap();
        let inner = skip_tlv_header(&tee);
        let tags = extract_tag_numbers(inner);
        let mut sorted = tags.clone();
        sorted.sort();
        assert_eq!(tags, sorted, "AuthorizationList fields must be sorted by tag number");
    }
    #[test]
    fn test_full_extension_roundtrip() {
        let params = make_test_params();
        let ext = build_attestation_extension(&params).unwrap();
        // Must be valid DER: starts with SEQUENCE tag
        assert_eq!(ext[0], 0x30);
        // Length must account for all inner bytes
        let (header_len, total_content_len) = parse_tlv_lengths(&ext);
        assert_eq!(ext.len(), header_len + total_content_len);
    }
    // --- test helpers ---
    fn make_test_params() -> CertGenParams {
        CertGenParams {
            algorithm: Algorithm::Ec,
            key_size: 256,
            ec_curve: Some(EcCurve::P256),
            rsa_public_exponent: 0,
            attestation_challenge: Some(vec![0xAB; 32]),
            purposes: vec![2, 3],
            digests: vec![4],
            cert_serial: None,
            cert_subject: None,
            cert_not_before: -1,
            cert_not_after: -1,
            keybox_private_key: vec![],
            keybox_cert_chain: vec![],
            security_level: 1,
            attest_version: 200,
            keymaster_version: 200,
            os_version: 140000,
            os_patch_level: 202503,
            vendor_patch_level: 20250301,
            boot_patch_level: 20250301,
            boot_key: vec![0x01; 32],
            boot_hash: vec![0x02; 32],
            creation_datetime: 1709913600000,
            attestation_application_id: vec![0xDE, 0xAD],
            module_hash: None,
            id_brand: None,
            id_device: None,
            id_product: None,
            id_serial: None,
            id_imei: None,
            id_meid: None,
            id_manufacturer: None,
            id_model: None,
            id_second_imei: None,
        }
    }
    fn hex_string(data: &[u8]) -> String {
        data.iter().map(|b| format!("{:02x}", b)).collect()
    }
    fn skip_tlv_header(data: &[u8]) -> &[u8] {
        let (header_len, _) = parse_tlv_lengths(data);
        &data[header_len..]
    }
    fn skip_one_tlv(data: &[u8]) -> (usize, &[u8]) {
        let (header_len, content_len) = parse_tlv_lengths(data);
        let total = header_len + content_len;
        (total, &data[total..])
    }
    fn parse_tlv_lengths(data: &[u8]) -> (usize, usize) {
        // Returns (header_bytes, content_bytes)
        let tag_len = tag_byte_len(data);
        let len_start = tag_len;
        if data[len_start] < 0x80 {
            (len_start + 1, data[len_start] as usize)
        } else {
            let num_len_bytes = (data[len_start] & 0x7F) as usize;
            let mut content_len = 0usize;
            for i in 0..num_len_bytes {
                content_len = (content_len << 8) | data[len_start + 1 + i] as usize;
            }
            (len_start + 1 + num_len_bytes, content_len)
        }
    }
    fn tag_byte_len(data: &[u8]) -> usize {
        if data[0] & 0x1F != 0x1F {
            1
        } else {
            let mut i = 1;
            while data[i] & 0x80 != 0 {
                i += 1;
            }
            i + 1
        }
    }
    fn extract_tag_numbers(mut data: &[u8]) -> Vec<u32> {
        let mut tags = Vec::new();
        while !data.is_empty() {
            let tag = read_tag_number(data);
            tags.push(tag);
            let (_, rest) = skip_one_tlv(data);
            data = rest;
        }
        tags
    }
    fn read_tag_number(data: &[u8]) -> u32 {
        if data[0] & 0x1F != 0x1F {
            (data[0] & 0x1F) as u32
        } else {
            let mut val = 0u32;
            let mut i = 1;
            loop {
                val = (val << 7) | (data[i] & 0x7F) as u32;
                if data[i] & 0x80 == 0 {
                    break;
                }
                i += 1;
            }
            val
        }
    }
 }
@@ -0,0 +1,523 @@
 use crate::error::{CertGenError, Result};
 use crate::keybox::ParsedKeybox;
 use crate::types::{Algorithm, CertGenParams, GeneratedKeyPair};
 use time::OffsetDateTime;
 const ATTESTATION_OID: &[u64] = &[1, 3, 6, 1, 4, 1, 11129, 2, 1, 17];
 // Signature algorithm OIDs
 const OID_SHA256_WITH_ECDSA: &[u64] = &[1, 2, 840, 10045, 4, 3, 2];
 const OID_SHA384_WITH_ECDSA: &[u64] = &[1, 2, 840, 10045, 4, 3, 3];
 const OID_SHA256_WITH_RSA: &[u64] = &[1, 2, 840, 113549, 1, 1, 11];
 // Extension OIDs
 const OID_KEY_USAGE: &[u64] = &[2, 5, 29, 15];
 pub fn build_certificate_chain(
    key_pair: &GeneratedKeyPair,
    attestation_ext_der: &[u8],
    keybox: &ParsedKeybox,
    params: &CertGenParams,
 ) -> Result<Vec<Vec<u8>>> {
    let leaf_der = build_leaf_cert(key_pair, attestation_ext_der, keybox, params)?;
    let mut chain = Vec::with_capacity(1 + keybox.cert_chain_ders.len());
    chain.push(leaf_der);
    for cert_der in &keybox.cert_chain_ders {
        chain.push(cert_der.clone());
    }
    Ok(chain)
 }
 fn build_leaf_cert(
    key_pair: &GeneratedKeyPair,
    attestation_ext_der: &[u8],
    keybox: &ParsedKeybox,
    params: &CertGenParams,
 ) -> Result<Vec<u8>> {
    let spki_der = extract_spki_from_pkcs8(&key_pair.private_key_pkcs8)?;
    let sig_alg_der = signature_algorithm_for_signing_key(&keybox.signing_key_der, params.algorithm)?;
    // Serial number
    let serial_bytes = if let Some(ref serial) = params.cert_serial {
        serial.clone()
    } else {
        vec![1u8]
    };
    // Subject DN
    let subject_dn_der = if let Some(ref subject) = params.cert_subject {
        subject.clone()
    } else {
        encode_simple_cn_dn("Android KeyStore Key")
    };
    // Validity
    let not_before = timestamp_to_datetime(params.cert_not_before)?;
    let not_after = if params.cert_not_after == -1 {
        OffsetDateTime::from_unix_timestamp(keybox.leaf_not_after)
            .unwrap_or_else(|_| OffsetDateTime::now_utc() + time::Duration::days(365))
    } else {
        timestamp_to_datetime(params.cert_not_after)?
    };
    // Extensions
    let extensions_der = build_extensions(attestation_ext_der, &params.purposes)?;
    // TBS Certificate
    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);
    let tbs_der = encode_der_sequence(&[
        &version_der,
        &serial_der,
        &sig_alg_der,
        &keybox.issuer_dn_der, // RAW bytes — no re-encoding
        &validity_der,
        &subject_dn_der,
        &spki_der,
        &extensions_tagged,
    ]);
    // Sign the TBS
    let signature_bytes = sign_tbs(&tbs_der, &keybox.signing_key_der, params.algorithm)?;
    let signature_bit_string = encode_der_bit_string(&signature_bytes);
    // Final certificate: SEQUENCE { TBS, sigAlgorithm, signature }
    let cert_der = encode_der_sequence(&[
        &tbs_der,
        &sig_alg_der,
        &signature_bit_string,
    ]);
    Ok(cert_der)
 }
 fn sign_tbs(tbs_der: &[u8], signing_key_der: &[u8], algorithm: Algorithm) -> Result<Vec<u8>> {
    match algorithm {
        Algorithm::Ec => sign_tbs_ec(tbs_der, signing_key_der),
        Algorithm::Rsa => sign_tbs_rsa(tbs_der, signing_key_der),
    }
 }
 fn sign_tbs_ec(tbs_der: &[u8], signing_key_der: &[u8]) -> Result<Vec<u8>> {
    // Determine EC curve from the signing key's PKCS8 AlgorithmIdentifier
    let alg = detect_ec_signing_algorithm(signing_key_der)?;
    let key_pair = ring::signature::EcdsaKeyPair::from_pkcs8(alg, signing_key_der, &ring::rand::SystemRandom::new())
        .map_err(|e| CertGenError::SigningFailed(format!("EC key parse: {e}")))?;
    let rng = ring::rand::SystemRandom::new();
    let sig = key_pair.sign(&rng, tbs_der)
        .map_err(|e| CertGenError::SigningFailed(format!("EC sign: {e}")))?;
    Ok(sig.as_ref().to_vec())
 }
 fn detect_ec_signing_algorithm(pkcs8_der: &[u8]) -> Result<&'static ring::signature::EcdsaSigningAlgorithm> {
    use der::Decode;
    let info = pkcs8::PrivateKeyInfo::from_der(pkcs8_der)
        .map_err(|e| CertGenError::SigningFailed(format!("PKCS8 parse: {e}")))?;
    let params_oid = info.algorithm.parameters_oid()
        .map_err(|e| CertGenError::SigningFailed(format!("EC curve OID: {e}")))?;
    let p256_oid: const_oid::ObjectIdentifier = "1.2.840.10045.3.1.7".parse()
        .map_err(|_| CertGenError::SigningFailed("OID parse".into()))?;
    let p384_oid: const_oid::ObjectIdentifier = "1.3.132.0.34".parse()
        .map_err(|_| CertGenError::SigningFailed("OID parse".into()))?;
    if params_oid == p256_oid {
        Ok(&ring::signature::ECDSA_P256_SHA256_ASN1_SIGNING)
    } else if params_oid == p384_oid {
        Ok(&ring::signature::ECDSA_P384_SHA384_ASN1_SIGNING)
    } else {
        Err(CertGenError::SigningFailed(format!("unsupported EC curve OID: {params_oid}")))
    }
 }
 fn sign_tbs_rsa(tbs_der: &[u8], signing_key_der: &[u8]) -> Result<Vec<u8>> {
    use rsa::pkcs8::DecodePrivateKey;
    use rsa::signature::{SignatureEncoding, SignerMut};
    use rsa::pkcs1v15::SigningKey;
    use rsa::sha2::Sha256;
    let private_key = rsa::RsaPrivateKey::from_pkcs8_der(signing_key_der)
        .map_err(|e| CertGenError::SigningFailed(format!("RSA key parse: {e}")))?;
    let mut signing_key = SigningKey::<Sha256>::new(private_key);
    let signature = signing_key.sign(tbs_der);
    Ok(signature.to_vec())
 }
 fn signature_algorithm_for_signing_key(signing_key_der: &[u8], algorithm: Algorithm) -> Result<Vec<u8>> {
    match algorithm {
        Algorithm::Ec => {
            let ring_alg = detect_ec_signing_algorithm(signing_key_der)?;
            // Determine OID from the algorithm used
            let oid = if std::ptr::eq(ring_alg, &ring::signature::ECDSA_P384_SHA384_ASN1_SIGNING) {
                OID_SHA384_WITH_ECDSA
            } else {
                OID_SHA256_WITH_ECDSA
            };
            let oid_der = encode_der_oid(oid);
            Ok(encode_der_sequence(&[&oid_der]))
        }
        Algorithm::Rsa => {
            let oid_der = encode_der_oid(OID_SHA256_WITH_RSA);
            let null_der = vec![0x05, 0x00];
            Ok(encode_der_sequence(&[&oid_der, &null_der]))
        }
    }
 }
 fn extract_spki_from_pkcs8(pkcs8_der: &[u8]) -> Result<Vec<u8>> {
    use der::Decode;
    let info = pkcs8::PrivateKeyInfo::from_der(pkcs8_der)
        .map_err(|e| CertGenError::CertBuildFailed(format!("PKCS8 parse for SPKI: {e}")))?;
    // Reconstruct SPKI from AlgorithmIdentifier + public key
    // For EC: derive public key from private key via ring
    // For RSA: derive from rsa crate
    let alg_id_oid = info.algorithm.oid;
    let ec_oid: const_oid::ObjectIdentifier = "1.2.840.10045.2.1".parse()
        .map_err(|_| CertGenError::CertBuildFailed("OID parse".into()))?;
    if alg_id_oid == ec_oid {
        extract_ec_spki(pkcs8_der, &info)
    } else {
        extract_rsa_spki(pkcs8_der)
    }
 }
 fn extract_ec_spki(pkcs8_der: &[u8], info: &pkcs8::PrivateKeyInfo) -> Result<Vec<u8>> {
    use ring::signature::KeyPair as _;
    let params_oid = info.algorithm.parameters_oid()
        .map_err(|e| CertGenError::CertBuildFailed(format!("EC curve OID: {e}")))?;
    let p256_oid: const_oid::ObjectIdentifier = "1.2.840.10045.3.1.7".parse()
        .map_err(|_| CertGenError::CertBuildFailed("OID parse".into()))?;
    let p384_oid: const_oid::ObjectIdentifier = "1.3.132.0.34".parse()
        .map_err(|_| CertGenError::CertBuildFailed("OID parse".into()))?;
    let (ring_alg, curve_oid_der): (&ring::signature::EcdsaSigningAlgorithm, Vec<u8>) = if params_oid == p256_oid {
        (&ring::signature::ECDSA_P256_SHA256_ASN1_SIGNING, encode_der_oid(&[1, 2, 840, 10045, 3, 1, 7]))
    } else if params_oid == p384_oid {
        (&ring::signature::ECDSA_P384_SHA384_ASN1_SIGNING, encode_der_oid(&[1, 3, 132, 0, 34]))
    } else {
        return Err(CertGenError::CertBuildFailed(format!("unsupported EC curve: {params_oid}")));
    };
    let kp = ring::signature::EcdsaKeyPair::from_pkcs8(
        ring_alg,
        pkcs8_der,
        &ring::rand::SystemRandom::new(),
    ).map_err(|e| CertGenError::CertBuildFailed(format!("EC key parse: {e}")))?;
    let ec_kp = kp.public_key().as_ref().to_vec();
    // SPKI = SEQUENCE { AlgorithmIdentifier, BIT STRING (public key) }
    // AlgorithmIdentifier = SEQUENCE { ecPublicKey OID, curve OID }
    let ec_oid_der = encode_der_oid(&[1, 2, 840, 10045, 2, 1]);
    let alg_id = encode_der_sequence(&[&ec_oid_der, &curve_oid_der]);
    let pub_key_bits = encode_der_bit_string(&ec_kp);
    Ok(encode_der_sequence(&[&alg_id, &pub_key_bits]))
 }
 fn extract_rsa_spki(pkcs8_der: &[u8]) -> Result<Vec<u8>> {
    use rsa::pkcs8::DecodePrivateKey;
    let private_key = rsa::RsaPrivateKey::from_pkcs8_der(pkcs8_der)
        .map_err(|e| CertGenError::CertBuildFailed(format!("RSA key parse: {e}")))?;
    let public_key = rsa::RsaPublicKey::from(&private_key);
    // Encode RSA public key as DER: SEQUENCE { n INTEGER, e INTEGER }
    use rsa::traits::PublicKeyParts;
    let n_bytes = public_key.n().to_bytes_be();
    let e_bytes = public_key.e().to_bytes_be();
    let rsa_pub_der = encode_der_sequence(&[
        &encode_der_integer(&n_bytes),
        &encode_der_integer(&e_bytes),
    ]);
    // SPKI = SEQUENCE { AlgorithmIdentifier, BIT STRING (DER-encoded RSAPublicKey) }
    let rsa_oid_der = encode_der_oid(&[1, 2, 840, 113549, 1, 1, 1]);
    let null_der = vec![0x05, 0x00];
    let alg_id = encode_der_sequence(&[&rsa_oid_der, &null_der]);
    let pub_key_bits = encode_der_bit_string(&rsa_pub_der);
    Ok(encode_der_sequence(&[&alg_id, &pub_key_bits]))
 }
 fn build_extensions(attestation_ext_der: &[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)
    let attest_ext = build_extension(&encode_der_oid(ATTESTATION_OID), false, attestation_ext_der);
    extensions.push(attest_ext);
    Ok(encode_der_sequence_of(&extensions))
 }
 fn build_extension(oid_der: &[u8], critical: bool, value_der: &[u8]) -> Vec<u8> {
    let value_octet_string = encode_der_octet_string(value_der);
    if critical {
        let critical_der = encode_der_boolean(true);
        encode_der_sequence(&[oid_der, &critical_der, &value_octet_string])
    } else {
        encode_der_sequence(&[oid_der, &value_octet_string])
    }
 }
 fn build_key_usage_extension(ku_byte: u8) -> Vec<u8> {
    // DER BIT STRING: minimal encoding requires trimming trailing zero bits
    let unused_bits = ku_byte.trailing_zeros().min(7) as u8;
    // BIT STRING = tag (0x03) + length(2) + unused_bits + byte
    let bit_string = vec![0x03, 0x02, unused_bits, ku_byte];
    let oid_der = encode_der_oid(OID_KEY_USAGE);
    let value_octet_string = encode_der_octet_string(&bit_string);
    let critical_der = encode_der_boolean(true);
    encode_der_sequence(&[&oid_der, &critical_der, &value_octet_string])
 }
 // KeyUsage BIT STRING byte layout (RFC 5280):
 //   byte[0] bit 7 = digitalSignature (0x80)
 //   byte[0] bit 6 = nonRepudiation   (0x40)
 //   byte[0] bit 5 = keyEncipherment  (0x20)
 //   byte[0] bit 4 = dataEncipherment (0x10)
 //   byte[0] bit 3 = keyAgreement     (0x08)
 //   byte[0] bit 2 = keyCertSign      (0x04)
 //   byte[0] bit 1 = cRLSign          (0x02)
 //   byte[0] bit 0 = encipherOnly     (0x01)
 //   byte[1] bit 7 = decipherOnly     (0x80)
 fn map_key_usage_byte(purposes: &[i32]) -> u8 {
    let mut bits: u8 = 0;
    for &purpose in purposes {
        match purpose {
            2 => bits |= 0x80, // SIGN -> digitalSignature
            1 => bits |= 0x10, // DECRYPT -> dataEncipherment
            5 => bits |= 0x20, // WRAP_KEY -> keyEncipherment
            6 => bits |= 0x08, // AGREE_KEY -> keyAgreement
            7 => bits |= 0x04, // ATTEST_KEY -> keyCertSign
            _ => {}
        }
    }
    bits
 }
 fn encode_validity(not_before: &OffsetDateTime, not_after: &OffsetDateTime) -> Vec<u8> {
    let nb = encode_time(not_before);
    let na = encode_time(not_after);
    encode_der_sequence(&[&nb, &na])
 }
 fn encode_time(dt: &OffsetDateTime) -> Vec<u8> {
    let year = dt.year();
    if (1950..2050).contains(&year) {
        encode_utctime(dt)
    } else {
        encode_gentime(dt)
    }
 }
 fn encode_utctime(dt: &OffsetDateTime) -> Vec<u8> {
    // UTCTime: YYMMDDHHMMSSZ
    let year = dt.year() % 100;
    let s = format!(
        "{:02}{:02}{:02}{:02}{:02}{:02}Z",
        year, dt.month() as u8, dt.day(), dt.hour(), dt.minute(), dt.second()
    );
    let mut out = Vec::with_capacity(2 + s.len());
    out.push(0x17); // UTCTime tag
    out.extend_from_slice(&encode_der_length_bytes(s.len()));
    out.extend_from_slice(s.as_bytes());
    out
 }
 fn encode_gentime(dt: &OffsetDateTime) -> Vec<u8> {
    // GeneralizedTime: YYYYMMDDHHMMSSZ
    let s = format!(
        "{:04}{:02}{:02}{:02}{:02}{:02}Z",
        dt.year(), dt.month() as u8, dt.day(), dt.hour(), dt.minute(), dt.second()
    );
    let mut out = Vec::with_capacity(2 + s.len());
    out.push(0x18); // GeneralizedTime tag
    out.extend_from_slice(&encode_der_length_bytes(s.len()));
    out.extend_from_slice(s.as_bytes());
    out
 }
 fn encode_simple_cn_dn(cn: &str) -> Vec<u8> {
    // Name = SEQUENCE OF RelativeDistinguishedName
    // RDN = SET OF AttributeTypeAndValue
    // ATV = SEQUENCE { OID, UTF8String }
    let cn_oid = encode_der_oid(&[2, 5, 4, 3]);
    let cn_value = encode_der_utf8string(cn);
    let atv = encode_der_sequence(&[&cn_oid, &cn_value]);
    let rdn = encode_der_set(&[&atv]);
    encode_der_sequence(&[&rdn])
 }
 fn timestamp_to_datetime(ts: i64) -> Result<OffsetDateTime> {
    if ts == -1 {
        return Ok(OffsetDateTime::now_utc());
    }
    OffsetDateTime::from_unix_timestamp(ts / 1000)
        .map_err(|e| CertGenError::CertBuildFailed(format!("invalid timestamp {ts}: {e}")))
 }
 // ---------------------------------------------------------------------------
 // DER encoding primitives
 // ---------------------------------------------------------------------------
 fn encode_der_length_bytes(len: usize) -> Vec<u8> {
    if len < 0x80 {
        vec![len as u8]
    } else if len <= 0xFF {
        vec![0x81, len as u8]
    } else if len <= 0xFFFF {
        vec![0x82, (len >> 8) as u8, len as u8]
    } else if len <= 0xFF_FFFF {
        vec![0x83, (len >> 16) as u8, (len >> 8) as u8, len as u8]
    } else {
        vec![0x84, (len >> 24) as u8, (len >> 16) as u8, (len >> 8) as u8, len as u8]
    }
 }
 fn encode_der_tag_length_value(tag: u8, content: &[u8]) -> Vec<u8> {
    let mut out = Vec::with_capacity(1 + 4 + content.len());
    out.push(tag);
    out.extend_from_slice(&encode_der_length_bytes(content.len()));
    out.extend_from_slice(content);
    out
 }
 fn encode_der_sequence(items: &[&[u8]]) -> Vec<u8> {
    let total: usize = items.iter().map(|i| i.len()).sum();
    let mut content = Vec::with_capacity(total);
    for item in items {
        content.extend_from_slice(item);
    }
    encode_der_tag_length_value(0x30, &content)
 }
 fn encode_der_sequence_of(items: &[Vec<u8>]) -> Vec<u8> {
    let total: usize = items.iter().map(|i| i.len()).sum();
    let mut content = Vec::with_capacity(total);
    for item in items {
        content.extend_from_slice(item);
    }
    encode_der_tag_length_value(0x30, &content)
 }
 fn encode_der_set(items: &[&[u8]]) -> Vec<u8> {
    let total: usize = items.iter().map(|i| i.len()).sum();
    let mut content = Vec::with_capacity(total);
    for item in items {
        content.extend_from_slice(item);
    }
    encode_der_tag_length_value(0x31, &content)
 }
 fn encode_der_explicit_tag(tag_num: u8, content: &[u8]) -> Vec<u8> {
    encode_der_tag_length_value(0xA0 | tag_num, content)
 }
 fn encode_der_integer(value: &[u8]) -> Vec<u8> {
    // DER INTEGER must have minimal encoding and leading 0x00 if high bit set
    if value.is_empty() {
        return encode_der_tag_length_value(0x02, &[0x00]);
    }
    // Strip leading zeros (but keep at least one byte)
    let mut start = 0;
    while start < value.len() - 1 && value[start] == 0 {
        start += 1;
    }
    let trimmed = &value[start..];
    // Add leading 0x00 if high bit is set (positive integer)
    if trimmed[0] & 0x80 != 0 {
        let mut padded = Vec::with_capacity(1 + trimmed.len());
        padded.push(0x00);
        padded.extend_from_slice(trimmed);
        encode_der_tag_length_value(0x02, &padded)
    } else {
        encode_der_tag_length_value(0x02, trimmed)
    }
 }
 fn encode_der_bit_string(bits: &[u8]) -> Vec<u8> {
    // BIT STRING: tag 0x03, length, unused_bits (0), content
    let mut content = Vec::with_capacity(1 + bits.len());
    content.push(0x00); // 0 unused bits
    content.extend_from_slice(bits);
    encode_der_tag_length_value(0x03, &content)
 }
 fn encode_der_octet_string(content: &[u8]) -> Vec<u8> {
    encode_der_tag_length_value(0x04, content)
 }
 fn encode_der_utf8string(s: &str) -> Vec<u8> {
    encode_der_tag_length_value(0x0C, s.as_bytes())
 }
 fn encode_der_boolean(val: bool) -> Vec<u8> {
    encode_der_tag_length_value(0x01, &[if val { 0xFF } else { 0x00 }])
 }
 fn encode_der_oid(components: &[u64]) -> Vec<u8> {
    if components.len() < 2 {
        return encode_der_tag_length_value(0x06, &[]);
    }
    let mut content = Vec::new();
    // First two components encoded as 40 * c[0] + c[1]
    content.push((components[0] * 40 + components[1]) as u8);
    for &c in &components[2..] {
        encode_oid_subidentifier(&mut content, c);
    }
    encode_der_tag_length_value(0x06, &content)
 }
 fn encode_oid_subidentifier(buf: &mut Vec<u8>, mut value: u64) {
    if value == 0 {
        buf.push(0);
        return;
    }
    // Encode in base-128 with continuation bits
    let mut bytes = Vec::new();
    while value > 0 {
        bytes.push((value & 0x7F) as u8);
        value >>= 7;
    }
    bytes.reverse();
    // Set high bit on all but the last byte
    for i in 0..bytes.len() - 1 {
        bytes[i] |= 0x80;
    }
    buf.extend_from_slice(&bytes);
 }
@@ -0,0 +1,75 @@
 use std::fmt;
 #[derive(Debug)]
 pub enum CertGenError {
    Jni(String),
    NullParam(&'static str),
    UnsupportedAlgorithm(i32),
    UnsupportedEcCurve(i32),
    KeyGenFailed(String),
    CertBuildFailed(String),
    KeyboxParseFailed(String),
    AttestationBuildFailed(String),
    DerError(der::Error),
    EmptyKeyboxChain,
    ChallengeTooLong(usize),
    InvalidParameter(String),
    SigningFailed(String),
    SerializationFailed(String),
 }
 impl fmt::Display for CertGenError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::Jni(msg) => write!(f, "JNI error: {}", msg),
            Self::NullParam(name) => write!(f, "null required parameter: {}", name),
            Self::UnsupportedAlgorithm(v) => write!(f, "unsupported algorithm: {}", v),
            Self::UnsupportedEcCurve(v) => write!(f, "unsupported EC curve: {}", v),
            Self::KeyGenFailed(msg) => write!(f, "key generation failed: {}", msg),
            Self::CertBuildFailed(msg) => write!(f, "certificate build failed: {}", msg),
            Self::KeyboxParseFailed(msg) => write!(f, "keybox parse failed: {}", msg),
            Self::AttestationBuildFailed(msg) => write!(f, "attestation build failed: {}", msg),
            Self::DerError(e) => write!(f, "DER error: {}", e),
            Self::EmptyKeyboxChain => write!(f, "keybox certificate chain is empty"),
            Self::ChallengeTooLong(len) => write!(f, "attestation challenge too long: {} bytes (max 128)", len),
            Self::InvalidParameter(msg) => write!(f, "invalid parameter: {}", msg),
            Self::SigningFailed(msg) => write!(f, "signing failed: {}", msg),
            Self::SerializationFailed(msg) => write!(f, "serialization failed: {}", msg),
        }
    }
 }
 impl std::error::Error for CertGenError {}
 impl From<jni::errors::Error> for CertGenError {
    fn from(e: jni::errors::Error) -> Self {
        Self::Jni(e.to_string())
    }
 }
 impl From<der::Error> for CertGenError {
    fn from(e: der::Error) -> Self {
        Self::DerError(e)
    }
 }
 impl From<ring::error::Unspecified> for CertGenError {
    fn from(e: ring::error::Unspecified) -> Self {
        Self::KeyGenFailed(e.to_string())
    }
 }
 impl From<ring::error::KeyRejected> for CertGenError {
    fn from(e: ring::error::KeyRejected) -> Self {
        Self::KeyGenFailed(e.to_string())
    }
 }
 impl From<rsa::Error> for CertGenError {
    fn from(e: rsa::Error) -> Self {
        Self::KeyGenFailed(e.to_string())
    }
 }
 pub type Result<T> = std::result::Result<T, CertGenError>;
@@ -0,0 +1,96 @@
 use crate::error::{CertGenError, Result};
 use der::{Decode, Encode};
 use x509_cert::Certificate;
 pub struct ParsedKeybox {
    pub signing_key_der: Vec<u8>,
    pub issuer_dn_der: Vec<u8>,
    pub cert_chain_ders: Vec<Vec<u8>>,
    pub leaf_not_after: i64,
 }
 pub fn parse_keybox(cert_chain_bytes: &[u8], private_key_bytes: &[u8]) -> Result<ParsedKeybox> {
    let certs = split_der_certificates(cert_chain_bytes)?;
    if certs.is_empty() {
        return Err(CertGenError::KeyboxParseFailed("no certificates found".into()));
    }
    let leaf = Certificate::from_der(&certs[0])
        .map_err(|e| CertGenError::KeyboxParseFailed(format!("leaf cert parse: {e}")))?;
    let issuer_dn_der = leaf.tbs_certificate.subject.to_der()
        .map_err(|e| CertGenError::KeyboxParseFailed(format!("subject DN encode: {e}")))?;
    let not_after = leaf.tbs_certificate.validity.not_after;
    let leaf_not_after = not_after.to_unix_duration().as_secs() as i64;
    Ok(ParsedKeybox {
        signing_key_der: private_key_bytes.to_vec(),
        issuer_dn_der,
        cert_chain_ders: certs,
        leaf_not_after,
    })
 }
 fn split_der_certificates(data: &[u8]) -> Result<Vec<Vec<u8>>> {
    let mut certs = Vec::new();
    let mut offset = 0;
    while offset < data.len() {
        if data[offset] != 0x30 {
            return Err(CertGenError::KeyboxParseFailed(
                format!("expected SEQUENCE tag 0x30 at offset {offset}, got 0x{:02x}", data[offset])
            ));
        }
        let (content_len, header_len) = parse_der_length(&data[offset + 1..])?;
        let total_len = 1 + header_len + content_len;
        if offset + total_len > data.len() {
            return Err(CertGenError::KeyboxParseFailed(
                format!("cert at offset {offset} extends beyond buffer: need {total_len}, have {}", data.len() - offset)
            ));
        }
        certs.push(data[offset..offset + total_len].to_vec());
        offset += total_len;
    }
    if certs.is_empty() {
        return Err(CertGenError::KeyboxParseFailed("no certificates in chain".into()));
    }
    Ok(certs)
 }
 // Returns (content_length, number_of_length_bytes_consumed)
 fn parse_der_length(data: &[u8]) -> Result<(usize, usize)> {
    if data.is_empty() {
        return Err(CertGenError::KeyboxParseFailed("truncated DER length".into()));
    }
    let first = data[0];
    if first < 0x80 {
        // Short form: length is the byte itself
        return Ok((first as usize, 1));
    }
    // Long form: low 7 bits = number of subsequent length bytes
    let num_bytes = (first & 0x7f) as usize;
    if num_bytes == 0 || num_bytes > 4 {
        return Err(CertGenError::KeyboxParseFailed(
            format!("unsupported DER length encoding: 0x{first:02x}")
        ));
    }
    if 1 + num_bytes > data.len() {
        return Err(CertGenError::KeyboxParseFailed("truncated multi-byte DER length".into()));
    }
    let mut len: usize = 0;
    for i in 0..num_bytes {
        len = (len << 8) | (data[1 + i] as usize);
    }
    Ok((len, 1 + num_bytes))
 }
@@ -0,0 +1,59 @@
 use crate::error::{CertGenError, Result};
 use crate::types::{Algorithm, EcCurve, GeneratedKeyPair};
 pub fn generate_key_pair(
    algorithm: Algorithm,
    key_size: u32,
    ec_curve: Option<EcCurve>,
    rsa_public_exponent: u64,
 ) -> Result<GeneratedKeyPair> {
    match algorithm {
        Algorithm::Ec => {
            let curve = ec_curve.ok_or_else(|| CertGenError::InvalidParameter("ec_curve required for EC".into()))?;
            generate_ec_key_pair(curve)
        }
        Algorithm::Rsa => generate_rsa_key_pair(key_size, rsa_public_exponent),
    }
 }
 fn generate_ec_key_pair(curve: EcCurve) -> Result<GeneratedKeyPair> {
    let alg = match curve {
        EcCurve::P256 => &ring::signature::ECDSA_P256_SHA256_ASN1_SIGNING,
        EcCurve::P384 => &ring::signature::ECDSA_P384_SHA384_ASN1_SIGNING,
        _ => return Err(CertGenError::UnsupportedEcCurve(curve as i32)),
    };
    let rng = ring::rand::SystemRandom::new();
    let pkcs8_doc = ring::signature::EcdsaKeyPair::generate_pkcs8(alg, &rng)?;
    Ok(GeneratedKeyPair {
        private_key_pkcs8: pkcs8_doc.as_ref().to_vec(),
    })
 }
 fn generate_rsa_key_pair(key_size: u32, rsa_public_exponent: u64) -> Result<GeneratedKeyPair> {
    use pkcs8::EncodePrivateKey;
    if !matches!(key_size, 2048 | 3072 | 4096) {
        return Err(CertGenError::InvalidParameter(
            format!("RSA key size must be 2048, 3072, or 4096; got {key_size}")
        ));
    }
    let exp = if rsa_public_exponent == 0 {
        rsa::BigUint::from(65537u64)
    } else {
        rsa::BigUint::from(rsa_public_exponent)
    };
    let mut rng = rand::thread_rng();
    let private_key = rsa::RsaPrivateKey::new_with_exp(&mut rng, key_size as usize, &exp)
        .map_err(|e| CertGenError::KeyGenFailed(e.to_string()))?;
    let pkcs8_der = private_key.to_pkcs8_der()
        .map_err(|e| CertGenError::SerializationFailed(e.to_string()))?;
    Ok(GeneratedKeyPair {
        private_key_pkcs8: pkcs8_der.as_bytes().to_vec(),
    })
 }
@@ -0,0 +1,324 @@
 #![deny(clippy::unwrap_used, clippy::expect_used)]
 mod error;
 mod types;
 mod keygen;
 pub mod keybox;
 pub mod attestation;
 pub mod certbuilder;
 pub mod logging;
 use jni::objects::{JByteArray, JClass, JIntArray, JObject, JString};
 use jni::sys::{jboolean, jbyteArray, jstring};
 use jni::JNIEnv;
 use crate::error::{CertGenError, Result};
 use crate::types::{Algorithm, CertGenParams, EcCurve};
 // ---------------------------------------------------------------------------
 // JNI entry: generateAttestedKeyPair
 // ---------------------------------------------------------------------------
 #[no_mangle]
 pub extern "system" fn Java_org_matrix_TEESimulator_pki_NativeCertGen_generateAttestedKeyPair(
    mut env: JNIEnv,
    _class: JClass,
    config: JObject,
 ) -> jbyteArray {
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        generate_attested_inner(&mut env, &config)
    }));
    match result {
        Ok(Ok(raw)) => raw,
        Ok(Err(e)) => {
            tracing::error!(%e, "generateAttestedKeyPair failed");
            let _ = env.throw_new(
                "java/lang/RuntimeException",
                format!("NativeCertGen: {e}"),
            );
            std::ptr::null_mut()
        }
        Err(_) => {
            tracing::error!("generateAttestedKeyPair panicked");
            let _ = env.throw_new(
                "java/lang/RuntimeException",
                "NativeCertGen: internal panic",
            );
            std::ptr::null_mut()
        }
    }
 }
 fn generate_attested_inner(env: &mut JNIEnv, config: &JObject) -> Result<jbyteArray> {
    let params = extract_config(env, config)?;
    let key_pair = keygen::generate_key_pair(
        params.algorithm,
        params.key_size,
        params.ec_curve,
        params.rsa_public_exponent,
    )?;
    let keybox = keybox::parse_keybox(&params.keybox_cert_chain, &params.keybox_private_key)?;
    let attest_ext = attestation::build_attestation_extension(&params)?;
    let cert_chain = certbuilder::build_certificate_chain(
        &key_pair,
        &attest_ext,
        &keybox,
        &params,
    )?;
    let blob = assemble_result(&key_pair.private_key_pkcs8, &cert_chain);
    let out = env.byte_array_from_slice(&blob)?;
    Ok(out.into_raw())
 }
 // ---------------------------------------------------------------------------
 // JNI entry: initLogging
 // ---------------------------------------------------------------------------
 #[no_mangle]
 pub extern "system" fn Java_org_matrix_TEESimulator_pki_NativeCertGen_initLogging(
    mut env: JNIEnv,
    _class: JClass,
    verbose: jboolean,
    log_dir: JString,
 ) -> jboolean {
    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        init_logging_inner(&mut env, verbose, &log_dir)
    }));
    match result {
        Ok(Ok(())) => 1,
        Ok(Err(e)) => {
            let _ = env.throw_new(
                "java/lang/RuntimeException",
                format!("NativeCertGen initLogging: {e}"),
            );
            0
        }
        Err(_) => {
            let _ = env.throw_new(
                "java/lang/RuntimeException",
                "NativeCertGen initLogging: internal panic",
            );
            0
        }
    }
 }
 fn init_logging_inner(env: &mut JNIEnv, verbose: jboolean, log_dir: &JString) -> Result<()> {
    let dir: String = env.get_string(log_dir)?.into();
    logging::init(verbose != 0, &dir, 2, 3)
        .map_err(|e| CertGenError::Jni(format!("logging init failed: {e}")))?;
    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
 // ---------------------------------------------------------------------------
 fn extract_config(env: &mut JNIEnv, config: &JObject) -> Result<CertGenParams> {
    let algorithm = get_int(env, config, "algorithm")?;
    let key_size = get_int(env, config, "keySize")?;
    let ec_curve_raw = get_int(env, config, "ecCurve")?;
    let rsa_pub_exp = get_long(env, config, "rsaPublicExponent")?;
    let cert_not_before = get_long(env, config, "certNotBefore")?;
    let cert_not_after = get_long(env, config, "certNotAfter")?;
    let security_level = get_int(env, config, "securityLevel")?;
    let attest_version = get_int(env, config, "attestVersion")?;
    let keymaster_version = get_int(env, config, "keymasterVersion")?;
    let os_version = get_int(env, config, "osVersion")?;
    let os_patch_level = get_int(env, config, "osPatchLevel")?;
    let vendor_patch_level = get_int(env, config, "vendorPatchLevel")?;
    let boot_patch_level = get_int(env, config, "bootPatchLevel")?;
    let creation_datetime = get_long(env, config, "creationDatetime")?;
    let attestation_challenge = get_nullable_byte_array(env, config, "attestationChallenge")?;
    let purposes = get_int_array(env, config, "purposes")?;
    let digests = get_int_array(env, config, "digests")?;
    let cert_serial = get_nullable_byte_array(env, config, "certSerial")?;
    let cert_subject = get_nullable_byte_array(env, config, "certSubject")?;
    let keybox_private_key = get_byte_array(env, config, "keyboxPrivateKey")?;
    let keybox_cert_chain = get_byte_array(env, config, "keyboxCertChain")?;
    let boot_key = get_byte_array(env, config, "bootKey")?;
    let boot_hash = get_byte_array(env, config, "bootHash")?;
    let attestation_app_id = get_byte_array(env, config, "attestationApplicationId")?;
    let module_hash = get_nullable_byte_array(env, config, "moduleHash")?;
    let id_brand = get_nullable_byte_array(env, config, "idBrand")?;
    let id_device = get_nullable_byte_array(env, config, "idDevice")?;
    let id_product = get_nullable_byte_array(env, config, "idProduct")?;
    let id_serial = get_nullable_byte_array(env, config, "idSerial")?;
    let id_imei = get_nullable_byte_array(env, config, "idImei")?;
    let id_meid = get_nullable_byte_array(env, config, "idMeid")?;
    let id_manufacturer = get_nullable_byte_array(env, config, "idManufacturer")?;
    let id_model = get_nullable_byte_array(env, config, "idModel")?;
    let id_second_imei = get_nullable_byte_array(env, config, "idSecondImei")?;
    Ok(CertGenParams {
        algorithm: Algorithm::try_from(algorithm)?,
        key_size: key_size as u32,
        ec_curve: if algorithm == 3 {
            Some(EcCurve::try_from(ec_curve_raw)?)
        } else {
            None
        },
        rsa_public_exponent: rsa_pub_exp as u64,
        attestation_challenge,
        purposes,
        digests,
        cert_serial,
        cert_subject,
        cert_not_before,
        cert_not_after,
        keybox_private_key,
        keybox_cert_chain,
        security_level,
        attest_version,
        keymaster_version,
        os_version,
        os_patch_level,
        vendor_patch_level,
        boot_patch_level,
        boot_key,
        boot_hash,
        creation_datetime,
        attestation_application_id: attestation_app_id,
        module_hash,
        id_brand,
        id_device,
        id_product,
        id_serial,
        id_imei,
        id_meid,
        id_manufacturer,
        id_model,
        id_second_imei,
    })
 }
 // ---------------------------------------------------------------------------
 // JNI field accessor helpers — called 35+ times, justifies the abstraction
 // ---------------------------------------------------------------------------
 fn get_int(env: &mut JNIEnv, obj: &JObject, name: &str) -> Result<i32> {
    Ok(env.get_field(obj, name, "I")?.i()?)
 }
 fn get_long(env: &mut JNIEnv, obj: &JObject, name: &str) -> Result<i64> {
    Ok(env.get_field(obj, name, "J")?.j()?)
 }
 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() {
        return Err(CertGenError::NullParam(name));
    }
    let arr: JByteArray = field.into();
    let len = env.get_array_length(&arr)?;
    let mut buf = vec![0i8; len as usize];
    env.get_byte_array_region(&arr, 0, &mut buf)?;
    env.delete_local_ref(arr)?;
    Ok(buf.into_iter().map(|b| b as u8).collect())
 }
 fn get_nullable_byte_array(
    env: &mut JNIEnv,
    obj: &JObject,
    name: &str,
 ) -> Result<Option<Vec<u8>>> {
    let field = env.get_field(obj, name, "[B")?.l()?;
    if field.is_null() {
        return Ok(None);
    }
    let arr: JByteArray = field.into();
    let len = env.get_array_length(&arr)?;
    let mut buf = vec![0i8; len as usize];
    env.get_byte_array_region(&arr, 0, &mut buf)?;
    env.delete_local_ref(arr)?;
    Ok(Some(buf.into_iter().map(|b| b as u8).collect()))
 }
 fn get_int_array(env: &mut JNIEnv, obj: &JObject, name: &str) -> Result<Vec<i32>> {
    let field = env.get_field(obj, name, "[I")?.l()?;
    if field.is_null() {
        return Ok(vec![]);
    }
    let arr: JIntArray = field.into();
    let len = env.get_array_length(&arr)?;
    let mut buf = vec![0i32; len as usize];
    env.get_int_array_region(&arr, 0, &mut buf)?;
    env.delete_local_ref(arr)?;
    Ok(buf)
 }
 // ---------------------------------------------------------------------------
 // Binary result assembly (doc 09 section 4.1)
 // ---------------------------------------------------------------------------
 fn assemble_result(private_key: &[u8], cert_chain: &[Vec<u8>]) -> Vec<u8> {
    let total = 4 + private_key.len()
        + 4
        + cert_chain.iter().map(|c| 4 + c.len()).sum::<usize>();
    let mut buf = Vec::with_capacity(total);
    // Private key segment
    buf.extend_from_slice(&(private_key.len() as u32).to_be_bytes());
    buf.extend_from_slice(private_key);
    // Cert count
    buf.extend_from_slice(&(cert_chain.len() as u32).to_be_bytes());
    // Each cert: length-prefixed DER
    for cert in cert_chain {
        buf.extend_from_slice(&(cert.len() as u32).to_be_bytes());
        buf.extend_from_slice(cert);
    }
    buf
 }
@@ -0,0 +1,208 @@
 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(())
 }
@@ -0,0 +1,93 @@
 use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::sync::Mutex;
 use tracing::field::{Field, Visit};
 use tracing::{Event, Level, Subscriber};
 use tracing_subscriber::layer::Context;
 use tracing_subscriber::Layer;
 const KMSG_PATH: &str = "/dev/kmsg";
 const TAG: &str = "TEESimulator";
 pub struct KmsgLayer {
    writer: Mutex<Option<File>>,
 }
 impl KmsgLayer {
    pub fn new() -> Self {
        let file = OpenOptions::new().write(true).open(KMSG_PATH).ok();
        Self {
            writer: Mutex::new(file),
        }
    }
 }
 fn syslog_priority(level: &Level) -> u8 {
    match *level {
        Level::ERROR => 3,
        Level::WARN => 4,
        Level::INFO => 6,
        Level::DEBUG | Level::TRACE => 7,
    }
 }
 struct MessageVisitor {
    message: String,
    fields: String,
 }
 impl MessageVisitor {
    fn new() -> Self {
        Self {
            message: String::new(),
            fields: String::new(),
        }
    }
 }
 impl Visit for MessageVisitor {
    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
        if field.name() == "message" {
            let raw = format!("{:?}", value);
            // Strip surrounding debug quotes if present
            self.message = raw
                .strip_prefix('"')
                .and_then(|s| s.strip_suffix('"'))
                .unwrap_or(&raw)
                .to_string();
        } else {
            if !self.fields.is_empty() {
                self.fields.push(' ');
            }
            self.fields.push_str(&format!("{}={:?}", field.name(), value));
        }
    }
 }
 impl<S: Subscriber> Layer<S> for KmsgLayer {
    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
        let mut guard = match self.writer.lock() {
            Ok(g) => g,
            Err(_) => return,
        };
        let file = match guard.as_mut() {
            Some(f) => f,
            None => return,
        };
        let priority = syslog_priority(event.metadata().level());
        let mut visitor = MessageVisitor::new();
        event.record(&mut visitor);
        let line = if visitor.fields.is_empty() {
            format!("<{}>{}: {}\n", priority, TAG, visitor.message)
        } else {
            format!(
                "<{}>{}: {} {}\n",
                priority, TAG, visitor.message, visitor.fields
            )
        };
        let _ = file.write_all(line.as_bytes());
    }
 }
@@ -0,0 +1,41 @@
 mod kmsg;
 mod rotating;
 pub mod sysfs;
 pub mod dump;
 use std::path::Path;
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
 const VERBOSE_MARKER: &str = "/data/adb/tricky_store/.verbose";
 pub fn init(
    verbose_flag: bool,
    log_dir: &str,
    max_size_mb: u64,
    max_files: usize,
 ) -> Result<(), Box<dyn std::error::Error>> {
    let verbose = verbose_flag || Path::new(VERBOSE_MARKER).exists();
    let (max_size, max_files) = if verbose {
        (5 * 1024 * 1024, 5)
    } else {
        (max_size_mb * 1024 * 1024, max_files)
    };
    let level = if verbose { "trace" } else { "info" };
    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new(level));
    let kmsg_layer = kmsg::KmsgLayer::new();
    let rotating_layer = rotating::RotatingFileLayer::new(log_dir, max_size, max_files);
    let stderr_layer = tracing_subscriber::fmt::layer().with_writer(std::io::stderr);
    // Idempotent — second call returns Ok instead of propagating SetGlobalDefaultError
    let _ = tracing_subscriber::registry()
        .with(filter)
        .with(kmsg_layer)
        .with(rotating_layer)
        .with(stderr_layer)
        .try_init();
    Ok(())
 }
@@ -0,0 +1,166 @@
 use std::fs::{self, File, OpenOptions};
 use std::io::Write;
 use std::path::{Path, PathBuf};
 use std::sync::Mutex;
 use std::time::{SystemTime, UNIX_EPOCH};
 use tracing::field::{Field, Visit};
 use tracing::{Event, Level, Subscriber};
 use tracing_subscriber::layer::Context;
 use tracing_subscriber::Layer;
 struct RotatingState {
    dir: PathBuf,
    current: Option<File>,
    current_size: u64,
    max_size: u64,
    max_files: usize,
 }
 pub struct RotatingFileLayer {
    state: Mutex<RotatingState>,
 }
 impl RotatingFileLayer {
    pub fn new(dir: &str, max_size: u64, max_files: usize) -> Self {
        let dir = PathBuf::from(dir);
        let _ = fs::create_dir_all(&dir);
        let (file, size) = open_current_log(&dir);
        Self {
            state: Mutex::new(RotatingState {
                dir,
                current: file,
                current_size: size,
                max_size,
                max_files,
            }),
        }
    }
 }
 fn open_current_log(dir: &Path) -> (Option<File>, u64) {
    let path = dir.join("certgen.log");
    let size = fs::metadata(&path).map(|m| m.len()).unwrap_or(0);
    let file = OpenOptions::new()
        .create(true)
        .append(true)
        .open(&path)
        .ok();
    (file, size)
 }
 fn rotate(state: &mut RotatingState) {
    // Close current handle before renaming
    state.current.take();
    let dir = &state.dir;
    // Delete the oldest rotated file before shifting
    let oldest = dir.join(format!("certgen.log.{}", state.max_files));
    if oldest.exists() {
        let _ = fs::remove_file(&oldest);
    }
    // Shift older files up: .{N} -> .{N+1}
    for i in (1..state.max_files).rev() {
        let from = dir.join(format!("certgen.log.{}", i));
        let to = dir.join(format!("certgen.log.{}", i + 1));
        if from.exists() {
            let _ = fs::rename(&from, &to);
        }
    }
    // Current -> .1
    let current_path = dir.join("certgen.log");
    let first_rotated = dir.join("certgen.log.1");
    if current_path.exists() {
        let _ = fs::rename(&current_path, &first_rotated);
    }
    let (file, size) = open_current_log(dir);
    state.current = file;
    state.current_size = size;
 }
 fn epoch_secs() -> u64 {
    SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .map(|d| d.as_secs())
        .unwrap_or(0)
 }
 fn level_str(level: &Level) -> &'static str {
    match *level {
        Level::ERROR => "ERROR",
        Level::WARN => "WARN",
        Level::INFO => "INFO",
        Level::DEBUG => "DEBUG",
        Level::TRACE => "TRACE",
    }
 }
 struct LogVisitor {
    message: String,
    fields: String,
 }
 impl LogVisitor {
    fn new() -> Self {
        Self {
            message: String::new(),
            fields: String::new(),
        }
    }
 }
 impl Visit for LogVisitor {
    fn record_debug(&mut self, field: &Field, value: &dyn std::fmt::Debug) {
        if field.name() == "message" {
            let raw = format!("{:?}", value);
            self.message = raw
                .strip_prefix('"')
                .and_then(|s| s.strip_suffix('"'))
                .unwrap_or(&raw)
                .to_string();
        } else {
            if !self.fields.is_empty() {
                self.fields.push(' ');
            }
            self.fields.push_str(&format!("{}={:?}", field.name(), value));
        }
    }
 }
 impl<S: Subscriber> Layer<S> for RotatingFileLayer {
    fn on_event(&self, event: &Event<'_>, _ctx: Context<'_, S>) {
        let mut state = match self.state.lock() {
            Ok(s) => s,
            Err(_) => return,
        };
        if state.current_size >= state.max_size {
            rotate(&mut state);
        }
        let file = match state.current.as_mut() {
            Some(f) => f,
            None => return,
        };
        let ts = epoch_secs();
        let lvl = level_str(event.metadata().level());
        let target = event.metadata().target();
        let mut visitor = LogVisitor::new();
        event.record(&mut visitor);
        let line = if visitor.fields.is_empty() {
            format!("{} [{}] {}: {}\n", ts, lvl, target, visitor.message)
        } else {
            format!(
                "{} [{}] {}: {} {}\n",
                ts, lvl, target, visitor.message, visitor.fields
            )
        };
        if file.write_all(line.as_bytes()).is_ok() {
            state.current_size += line.len() as u64;
        }
    }
 }
@@ -0,0 +1,38 @@
 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(())
 }
@@ -0,0 +1,121 @@
 use crate::error::CertGenError;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(i32)]
 pub enum Algorithm {
    Rsa = 1,
    Ec = 3,
 }
 impl TryFrom<i32> for Algorithm {
    type Error = CertGenError;
    fn try_from(value: i32) -> Result<Self, Self::Error> {
        match value {
            1 => Ok(Self::Rsa),
            3 => Ok(Self::Ec),
            _ => Err(CertGenError::UnsupportedAlgorithm(value)),
        }
    }
 }
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 #[repr(i32)]
 pub enum EcCurve {
    P224 = 0,
    P256 = 1,
    P384 = 2,
    P521 = 3,
    Curve25519 = 4,
 }
 impl TryFrom<i32> for EcCurve {
    type Error = CertGenError;
    fn try_from(value: i32) -> Result<Self, Self::Error> {
        match value {
            0 => Ok(Self::P224),
            1 => Ok(Self::P256),
            2 => Ok(Self::P384),
            3 => Ok(Self::P521),
            4 => Ok(Self::Curve25519),
            _ => Err(CertGenError::UnsupportedEcCurve(value)),
        }
    }
 }
 #[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,
    pub ec_curve: Option<EcCurve>,
    pub rsa_public_exponent: u64,
    pub attestation_challenge: Option<Vec<u8>>,
    pub purposes: Vec<i32>,
    pub digests: Vec<i32>,
    pub cert_serial: Option<Vec<u8>>,
    pub cert_subject: Option<Vec<u8>>,
    pub cert_not_before: i64,
    pub cert_not_after: i64,
    pub keybox_private_key: Vec<u8>,
    pub keybox_cert_chain: Vec<u8>,
    pub security_level: i32,
    pub attest_version: i32,
    pub keymaster_version: i32,
    pub os_version: i32,
    pub os_patch_level: i32,
    pub vendor_patch_level: i32,
    pub boot_patch_level: i32,
    pub boot_key: Vec<u8>,
    pub boot_hash: Vec<u8>,
    pub creation_datetime: i64,
    pub attestation_application_id: Vec<u8>,
    pub module_hash: Option<Vec<u8>>,
    pub id_brand: Option<Vec<u8>>,
    pub id_device: Option<Vec<u8>>,
    pub id_product: Option<Vec<u8>>,
    pub id_serial: Option<Vec<u8>>,
    pub id_imei: Option<Vec<u8>>,
    pub id_meid: Option<Vec<u8>>,
    pub id_manufacturer: Option<Vec<u8>>,
    pub id_model: Option<Vec<u8>>,
    pub id_second_imei: Option<Vec<u8>>,
 }
 pub struct GeneratedKeyPair {
    pub private_key_pkcs8: Vec<u8>,
 }
@@ -0,0 +1,262 @@
 #!/usr/bin/env bash
 # Build, package, deploy, and verify TEESimulator module ZIPs.
 # Usage: ./scripts/package.sh [flags]
 #
 # Examples:
 #   ./scripts/package.sh --release                    # build release ZIP
 #   ./scripts/package.sh --all --clean                # clean build, both variants
 #   ./scripts/package.sh --release --deploy --reboot  # build, push, install, reboot
 #   ./scripts/package.sh --deploy --verify            # deploy latest ZIP + verify via logcat
 #   ./scripts/package.sh --rust --release             # build Rust crate first, then release
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 PROJECT_ROOT="$(cd "$SCRIPT_DIR/.." && pwd)"
 OUT_DIR="$PROJECT_ROOT/out"
 VARIANT=""
 CLEAN=false
 DEPLOY=false
 REBOOT=false
 VERIFY=false
 BUILD_RUST=false
 CLEAR_KEYS=false
 TRACE=false
 ROOT_PROVIDER="ksu"
 red()    { printf '\033[0;31m%s\033[0m\n' "$*"; }
 green()  { printf '\033[0;32m%s\033[0m\n' "$*"; }
 yellow() { printf '\033[0;33m%s\033[0m\n' "$*"; }
 bold()   { printf '\033[1m%s\033[0m\n' "$*"; }
 usage() {
    cat <<EOF
 Usage: $(basename "$0") [options]
 Build variants (pick one, or --all):
  --release          Build release variant (default if none specified)
  --debug            Build debug variant
  --all              Build both debug and release
 Build options:
  --clean            Run gradle clean before building
  --rust             Build native-certgen Rust crate before Gradle
 Deploy options:
  --deploy           Push ZIP to device and install
  --reboot           Reboot device after install
  --clear-keys       Clear persistent_keys before deploy
  --verify           Run logcat verification after deploy
  --root PROVIDER    Root provider: ksu (default), magisk, apatch
 Misc:
  -v, --verbose      Print every command as it runs (set -x)
  --help             Show this help
 EOF
    exit 0
 }
 while [[ $# -gt 0 ]]; do
    case "$1" in
        --release)    VARIANT="release"; shift ;;
        --debug)      VARIANT="debug"; shift ;;
        --all)        VARIANT="all"; shift ;;
        --clean)      CLEAN=true; shift ;;
        --deploy)     DEPLOY=true; shift ;;
        --reboot)     REBOOT=true; shift ;;
        --verify)     VERIFY=true; shift ;;
        --rust)       BUILD_RUST=true; shift ;;
        --clear-keys) CLEAR_KEYS=true; shift ;;
        -v|--verbose) TRACE=true; shift ;;
        --root)       ROOT_PROVIDER="$2"; shift 2 ;;
        --help|-h)    usage ;;
        *)            red "Unknown flag: $1"; usage ;;
    esac
 done
 [[ -z "$VARIANT" ]] && VARIANT="release"
 [[ "$TRACE" == true ]] && set -x
 case "$ROOT_PROVIDER" in
    ksu)     INSTALL_CMD="ksud module install" ;;
    magisk)  INSTALL_CMD="magisk --install-module" ;;
    apatch)  INSTALL_CMD="/data/adb/apd module install" ;;
    *)       red "Unknown root provider: $ROOT_PROVIDER"; exit 1 ;;
 esac
 build_rust() {
    local cargo_toml="$PROJECT_ROOT/native-certgen/Cargo.toml"
    if [[ ! -f "$cargo_toml" ]]; then
        red "native-certgen/Cargo.toml not found — skipping Rust build"
        return 0
    fi
    bold "==> Building native-certgen (aarch64)"
    if ! command -v cargo-ndk &>/dev/null; then
        red "cargo-ndk not found. Install: cargo install cargo-ndk"
        exit 1
    fi
    (cd "$PROJECT_ROOT/native-certgen" && \
        cargo ndk -t arm64-v8a --platform 29 -- build --release)
    local so="$PROJECT_ROOT/native-certgen/target/aarch64-linux-android/release/libcertgen.so"
    if [[ -f "$so" ]]; then
        local size
        size=$(du -h "$so" | cut -f1)
        green "    libcertgen.so built ($size)"
    else
        red "    libcertgen.so not found after build"
        exit 1
    fi
 }
 gradle_build() {
    local tasks=()
    [[ "$CLEAN" == true ]] && tasks+=(clean)
    case "$VARIANT" in
        release) tasks+=(zipRelease) ;;
        debug)   tasks+=(zipDebug) ;;
        all)     tasks+=(zipDebug zipRelease) ;;
    esac
    bold "==> Gradle: ${tasks[*]}"
    (cd "$PROJECT_ROOT" && ./gradlew "${tasks[@]}")
 }
 find_latest_zip() {
    local pattern="$1"
    ls -t "$OUT_DIR"/$pattern 2>/dev/null | head -1
 }
 deploy_zip() {
    local zip="$1"
    local name
    name=$(basename "$zip")
    if ! adb get-state &>/dev/null; then
        red "No ADB device connected"
        exit 1
    fi
    if [[ "$CLEAR_KEYS" == true ]]; then
        bold "==> Clearing persistent_keys"
        adb shell "rm -rf /data/adb/tricky_store/persistent_keys/*" 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'"
    green "    Installed via $ROOT_PROVIDER"
    if [[ "$REBOOT" == true ]]; then
        bold "==> Rebooting"
        adb reboot
        echo "    Waiting for device..."
        adb wait-for-device
        sleep 10
        local pid
        pid=$(adb shell "pidof TEESimulator" 2>/dev/null || true)
        if [[ -n "$pid" ]]; then
            green "    Daemon alive (PID $pid)"
        else
            yellow "    Daemon not yet started — check logcat"
        fi
    fi
 }
 verify_device() {
    bold "==> Verification"
    if ! adb get-state &>/dev/null; then
        red "No ADB device connected"
        exit 1
    fi
    local pid
    pid=$(adb shell "pidof TEESimulator" 2>/dev/null || true)
    if [[ -n "$pid" ]]; then
        green "    Daemon: running (PID $pid)"
    else
        red "    Daemon: not running"
    fi
    local tee_status
    tee_status=$(adb shell "cat /data/adb/tricky_store/tee_status.txt" 2>/dev/null || echo "N/A")
    echo "    TEE status: $tee_status"
    local sec_patch
    sec_patch=$(adb shell "cat /data/adb/tricky_store/security_patch.txt" 2>/dev/null || echo "N/A")
    echo "    Security patch config: $(echo "$sec_patch" | head -1)"
    local errors
    errors=$(adb logcat -d -s TEESimulator 2>/dev/null | \
        grep -iE "error|exception" | \
        grep -v "StrongBox\|SurfaceRuntime\|ClassLoader\|HARDWARE_TYPE_UNAVAILABLE" | \
        wc -l)
    if [[ "$errors" -eq 0 ]]; then
        green "    Logcat errors: 0"
    else
        yellow "    Logcat errors: $errors (run: adb logcat -d -s TEESimulator | grep -iE 'error|exception')"
    fi
    local throttle_events
    throttle_events=$(adb logcat -d -s TEESimulator 2>/dev/null | \
        grep -cE "RATE_LIMITED|CONCURRENT_LIMITED" || true)
    echo "    Rate limit events: $throttle_events"
 }
 print_summary() {
    echo ""
    bold "==> Build Summary"
    local variants=()
    case "$VARIANT" in
        release) variants=(Release) ;;
        debug)   variants=(Debug) ;;
        all)     variants=(Debug Release) ;;
    esac
    for v in "${variants[@]}"; do
        local zip
        zip=$(find_latest_zip "*-${v}.zip")
        if [[ -n "$zip" ]]; then
            local size
            size=$(du -h "$zip" | cut -f1)
            green "    $v: $(basename "$zip") ($size)"
        else
            red "    $v: ZIP not found"
        fi
    done
 }
 # --- Main ---
 echo ""
 bold "TEESimulator package pipeline"
 echo ""
 [[ "$BUILD_RUST" == true ]] && build_rust
 gradle_build
 print_summary
 if [[ "$DEPLOY" == true ]]; then
    local_variant="$VARIANT"
    [[ "$local_variant" == "all" ]] && local_variant="release"
    cap="${local_variant^}"
    zip=$(find_latest_zip "*-${cap}.zip")
    if [[ -z "$zip" ]]; then
        red "No $cap ZIP found to deploy"
        exit 1
    fi
    deploy_zip "$zip"
 fi
 [[ "$VERIFY" == true ]] && verify_device
 echo ""
 green "Done."
@@ -4,4 +4,12 @@ public class ActivityThread {
    public static void initializeMainlineModules() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static ActivityThread systemMain() {
        throw new UnsupportedOperationException("STUB!");
    }
    public ContextImpl getSystemContext() {
        throw new UnsupportedOperationException("STUB!");
    }
 }
@@ -0,0 +1,4 @@
 package android.app;
 public class ContextImpl {
 }
@@ -0,0 +1,8 @@
 package android.hardware.security.keymint;
 public @interface BlockMode {
    public static final int ECB = 1;
    public static final int CBC = 2;
    public static final int CTR = 3;
    public static final int GCM = 32;
 }
@@ -0,0 +1,10 @@
 package android.hardware.security.keymint;
 public @interface PaddingMode {
    public static final int NONE = 1;
    public static final int RSA_OAEP = 2;
    public static final int RSA_PSS = 3;
    public static final int RSA_PKCS1_1_5_ENCRYPT = 4;
    public static final int RSA_PKCS1_1_5_SIGN = 5;
    public static final int PKCS7 = 64;
 }
@@ -4,8 +4,4 @@ public class SystemProperties {
    public static String get(String key, String def) {
        throw new UnsupportedOperationException("STUB!");
    }
    public static String set(String key, String val) {
        throw new UnsupportedOperationException("STUB!");
    }
 }
@@ -0,0 +1,38 @@
 package android.security.keymaster;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 public class ExportResult implements Parcelable {
    public final byte[] exportData;
    public final int resultCode;
    public ExportResult(int resultCode) {
        this.resultCode = resultCode;
        this.exportData = new byte[0];
    }
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static final Creator<ExportResult> CREATOR = new Creator<ExportResult>() {
        @Override
        public ExportResult createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public ExportResult[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
 }
@@ -0,0 +1,33 @@
 package android.security.keymaster;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 public class KeyCharacteristics implements Parcelable {
    public KeymasterArguments hwEnforced;
    public KeymasterArguments swEnforced;
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static final Creator<KeyCharacteristics> CREATOR = new Creator<KeyCharacteristics>() {
        @Override
        public KeyCharacteristics createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public KeyCharacteristics[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
 }
@@ -0,0 +1,36 @@
 package android.security.keymaster;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 abstract class KeymasterArgument implements Parcelable {
    public final int tag;
    protected KeymasterArgument(int tag) {
        this.tag = tag;
    }
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static final Creator<KeymasterArgument> CREATOR = new Creator<KeymasterArgument>() {
        @Override
        public KeymasterArgument createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public KeymasterArgument[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
 }
@@ -0,0 +1,147 @@
 package android.security.keymaster;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 import java.math.BigInteger;
 import java.util.Date;
 import java.util.List;
 public class KeymasterArguments implements Parcelable {
    private static final long UINT32_RANGE = 1L << 32;
    public static final long UINT32_MAX_VALUE = UINT32_RANGE - 1;
    private static final BigInteger UINT64_RANGE = BigInteger.ONE.shiftLeft(64);
    public static final BigInteger UINT64_MAX_VALUE = UINT64_RANGE.subtract(BigInteger.ONE);
    private List<KeymasterArgument> mArguments;
    public static final @NonNull Parcelable.Creator<KeymasterArguments> CREATOR = new Parcelable.Creator<KeymasterArguments>() {
        @Override
        public KeymasterArguments createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public KeymasterArguments[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
    public KeymasterArguments() {
        throw new UnsupportedOperationException("STUB!");
    }
    private KeymasterArguments(Parcel in) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addEnum(int tag, int value) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addEnums(int tag, int... values) {
        throw new UnsupportedOperationException("STUB!");
    }
    public int getEnum(int tag, int defaultValue) {
        throw new UnsupportedOperationException("STUB!");
    }
    public List<Integer> getEnums(int tag) {
        throw new UnsupportedOperationException("STUB!");
    }
    private void addEnumTag(int tag, int value) {
        throw new UnsupportedOperationException("STUB!");
    }
    private int getEnumTagValue(KeymasterArgument arg) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addUnsignedInt(int tag, long value) {
        throw new UnsupportedOperationException("STUB!");
    }
    public long getUnsignedInt(int tag, long defaultValue) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addUnsignedLong(int tag, BigInteger value) {
        throw new UnsupportedOperationException("STUB!");
    }
    public List<BigInteger> getUnsignedLongs(int tag) {
        throw new UnsupportedOperationException("STUB!");
    }
    private void addLongTag(int tag, BigInteger value) {
        throw new UnsupportedOperationException("STUB!");
    }
    private BigInteger getLongTagValue(KeymasterArgument arg) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addBoolean(int tag) {
        throw new UnsupportedOperationException("STUB!");
    }
    public boolean getBoolean(int tag) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addBytes(int tag, byte[] value) {
        throw new UnsupportedOperationException("STUB!");
    }
    public byte[] getBytes(int tag, byte[] defaultValue) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addDate(int tag, Date value) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void addDateIfNotNull(int tag, Date value) {
        throw new UnsupportedOperationException("STUB!");
    }
    public Date getDate(int tag, Date defaultValue) {
        throw new UnsupportedOperationException("STUB!");
    }
    private KeymasterArgument getArgumentByTag(int tag) {
        throw new UnsupportedOperationException("STUB!");
    }
    public boolean containsTag(int tag) {
        throw new UnsupportedOperationException("STUB!");
    }
    public int size() {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public void writeToParcel(Parcel out, int flags) {
        throw new UnsupportedOperationException("STUB!");
    }
    public void readFromParcel(Parcel in) {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static BigInteger toUint64(long value) {
        throw new UnsupportedOperationException("STUB!");
    }
 }
@@ -0,0 +1,42 @@
 package android.security.keymaster;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 import java.util.List;
 public class KeymasterCertificateChain implements Parcelable {
    private List<byte[]> mCertificates;
    public KeymasterCertificateChain() {
        this.mCertificates = null;
    }
    public KeymasterCertificateChain(List<byte[]> mCertificates) {
        this.mCertificates = mCertificates;
    }
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static final Creator<KeymasterCertificateChain> CREATOR = new Creator<KeymasterCertificateChain>() {
        @Override
        public KeymasterCertificateChain createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public KeymasterCertificateChain[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
 }
@@ -0,0 +1,263 @@
 package android.security.keymaster;
 import java.util.HashMap;
 import java.util.Map;
 public final class KeymasterDefs {
    private KeymasterDefs() {
    }
    // Tag types.
    public static final int KM_INVALID = 0 << 28;
    public static final int KM_ENUM = 1 << 28;
    public static final int KM_ENUM_REP = 2 << 28;
    public static final int KM_UINT = 3 << 28;
    public static final int KM_UINT_REP = 4 << 28;
    public static final int KM_ULONG = 5 << 28;
    public static final int KM_DATE = 6 << 28;
    public static final int KM_BOOL = 7 << 28;
    public static final int KM_BIGNUM = 8 << 28;
    public static final int KM_BYTES = 9 << 28;
    public static final int KM_ULONG_REP = 10 << 28;
    // Tag values.
    public static final int KM_TAG_INVALID = KM_INVALID | 0;
    public static final int KM_TAG_PURPOSE = KM_ENUM_REP | 1;
    public static final int KM_TAG_ALGORITHM = KM_ENUM | 2;
    public static final int KM_TAG_KEY_SIZE = KM_UINT | 3;
    public static final int KM_TAG_BLOCK_MODE = KM_ENUM_REP | 4;
    public static final int KM_TAG_DIGEST = KM_ENUM_REP | 5;
    public static final int KM_TAG_PADDING = KM_ENUM_REP | 6;
    public static final int KM_TAG_CALLER_NONCE = KM_BOOL | 7;
    public static final int KM_TAG_MIN_MAC_LENGTH = KM_UINT | 8;
    public static final int KM_TAG_RESCOPING_ADD = KM_ENUM_REP | 101;
    public static final int KM_TAG_RESCOPING_DEL = KM_ENUM_REP | 102;
    public static final int KM_TAG_BLOB_USAGE_REQUIREMENTS = KM_ENUM | 705;
    public static final int KM_TAG_RSA_PUBLIC_EXPONENT = KM_ULONG | 200;
    public static final int KM_TAG_INCLUDE_UNIQUE_ID = KM_BOOL | 202;
    public static final int KM_TAG_ACTIVE_DATETIME = KM_DATE | 400;
    public static final int KM_TAG_ORIGINATION_EXPIRE_DATETIME = KM_DATE | 401;
    public static final int KM_TAG_USAGE_EXPIRE_DATETIME = KM_DATE | 402;
    public static final int KM_TAG_MIN_SECONDS_BETWEEN_OPS = KM_UINT | 403;
    public static final int KM_TAG_MAX_USES_PER_BOOT = KM_UINT | 404;
    public static final int KM_TAG_ALL_USERS = KM_BOOL | 500;
    public static final int KM_TAG_USER_ID = KM_UINT | 501;
    public static final int KM_TAG_USER_SECURE_ID = KM_ULONG_REP | 502;
    public static final int KM_TAG_NO_AUTH_REQUIRED = KM_BOOL | 503;
    public static final int KM_TAG_USER_AUTH_TYPE = KM_ENUM | 504;
    public static final int KM_TAG_AUTH_TIMEOUT = KM_UINT | 505;
    public static final int KM_TAG_ALLOW_WHILE_ON_BODY = KM_BOOL | 506;
    public static final int KM_TAG_TRUSTED_USER_PRESENCE_REQUIRED = KM_BOOL | 507;
    public static final int KM_TAG_TRUSTED_CONFIRMATION_REQUIRED = KM_BOOL | 508;
    public static final int KM_TAG_UNLOCKED_DEVICE_REQUIRED = KM_BOOL | 509;
    public static final int KM_TAG_ALL_APPLICATIONS = KM_BOOL | 600;
    public static final int KM_TAG_APPLICATION_ID = KM_BYTES | 601;
    public static final int KM_TAG_CREATION_DATETIME = KM_DATE | 701;
    public static final int KM_TAG_ORIGIN = KM_ENUM | 702;
    public static final int KM_TAG_ROLLBACK_RESISTANT = KM_BOOL | 703;
    public static final int KM_TAG_ROOT_OF_TRUST = KM_BYTES | 704;
    public static final int KM_TAG_UNIQUE_ID = KM_BYTES | 707;
    public static final int KM_TAG_ATTESTATION_CHALLENGE = KM_BYTES | 708;
    public static final int KM_TAG_ATTESTATION_ID_BRAND = KM_BYTES | 710;
    public static final int KM_TAG_ATTESTATION_ID_DEVICE = KM_BYTES | 711;
    public static final int KM_TAG_ATTESTATION_ID_PRODUCT = KM_BYTES | 712;
    public static final int KM_TAG_ATTESTATION_ID_SERIAL = KM_BYTES | 713;
    public static final int KM_TAG_ATTESTATION_ID_IMEI = KM_BYTES | 714;
    public static final int KM_TAG_ATTESTATION_ID_MEID = KM_BYTES | 715;
    public static final int KM_TAG_ATTESTATION_ID_MANUFACTURER = KM_BYTES | 716;
    public static final int KM_TAG_ATTESTATION_ID_MODEL = KM_BYTES | 717;
    public static final int KM_TAG_DEVICE_UNIQUE_ATTESTATION = KM_BOOL | 720;
    public static final int KM_TAG_ASSOCIATED_DATA = KM_BYTES | 1000;
    public static final int KM_TAG_NONCE = KM_BYTES | 1001;
    public static final int KM_TAG_AUTH_TOKEN = KM_BYTES | 1002;
    public static final int KM_TAG_MAC_LENGTH = KM_UINT | 1003;
    // Algorithm values.
    public static final int KM_ALGORITHM_RSA = 1;
    public static final int KM_ALGORITHM_EC = 3;
    public static final int KM_ALGORITHM_AES = 32;
    public static final int KM_ALGORITHM_3DES = 33;
    public static final int KM_ALGORITHM_HMAC = 128;
    // Block modes.
    public static final int KM_MODE_ECB = 1;
    public static final int KM_MODE_CBC = 2;
    public static final int KM_MODE_CTR = 3;
    public static final int KM_MODE_GCM = 32;
    // Padding modes.
    public static final int KM_PAD_NONE = 1;
    public static final int KM_PAD_RSA_OAEP = 2;
    public static final int KM_PAD_RSA_PSS = 3;
    public static final int KM_PAD_RSA_PKCS1_1_5_ENCRYPT = 4;
    public static final int KM_PAD_RSA_PKCS1_1_5_SIGN = 5;
    public static final int KM_PAD_PKCS7 = 64;
    // Digest modes.
    public static final int KM_DIGEST_NONE = 0;
    public static final int KM_DIGEST_MD5 = 1;
    public static final int KM_DIGEST_SHA1 = 2;
    public static final int KM_DIGEST_SHA_2_224 = 3;
    public static final int KM_DIGEST_SHA_2_256 = 4;
    public static final int KM_DIGEST_SHA_2_384 = 5;
    public static final int KM_DIGEST_SHA_2_512 = 6;
    // Key origins.
    public static final int KM_ORIGIN_GENERATED = 0;
    public static final int KM_ORIGIN_IMPORTED = 2;
    public static final int KM_ORIGIN_UNKNOWN = 3;
    public static final int KM_ORIGIN_SECURELY_IMPORTED = 4;
    // Key usability requirements.
    public static final int KM_BLOB_STANDALONE = 0;
    public static final int KM_BLOB_REQUIRES_FILE_SYSTEM = 1;
    // Operation Purposes.
    public static final int KM_PURPOSE_ENCRYPT = 0;
    public static final int KM_PURPOSE_DECRYPT = 1;
    public static final int KM_PURPOSE_SIGN = 2;
    public static final int KM_PURPOSE_VERIFY = 3;
    public static final int KM_PURPOSE_WRAP = 5;
    // Key formats.
    public static final int KM_KEY_FORMAT_X509 = 0;
    public static final int KM_KEY_FORMAT_PKCS8 = 1;
    public static final int KM_KEY_FORMAT_RAW = 3;
    // User authenticators.
    public static final int HW_AUTH_PASSWORD = 1 << 0;
    public static final int HW_AUTH_BIOMETRIC = 1 << 1;
    // Error codes.
    public static final int KM_ERROR_OK = 0;
    public static final int KM_ERROR_ROOT_OF_TRUST_ALREADY_SET = -1;
    public static final int KM_ERROR_UNSUPPORTED_PURPOSE = -2;
    public static final int KM_ERROR_INCOMPATIBLE_PURPOSE = -3;
    public static final int KM_ERROR_UNSUPPORTED_ALGORITHM = -4;
    public static final int KM_ERROR_INCOMPATIBLE_ALGORITHM = -5;
    public static final int KM_ERROR_UNSUPPORTED_KEY_SIZE = -6;
    public static final int KM_ERROR_UNSUPPORTED_BLOCK_MODE = -7;
    public static final int KM_ERROR_INCOMPATIBLE_BLOCK_MODE = -8;
    public static final int KM_ERROR_UNSUPPORTED_MAC_LENGTH = -9;
    public static final int KM_ERROR_UNSUPPORTED_PADDING_MODE = -10;
    public static final int KM_ERROR_INCOMPATIBLE_PADDING_MODE = -11;
    public static final int KM_ERROR_UNSUPPORTED_DIGEST = -12;
    public static final int KM_ERROR_INCOMPATIBLE_DIGEST = -13;
    public static final int KM_ERROR_INVALID_EXPIRATION_TIME = -14;
    public static final int KM_ERROR_INVALID_USER_ID = -15;
    public static final int KM_ERROR_INVALID_AUTHORIZATION_TIMEOUT = -16;
    public static final int KM_ERROR_UNSUPPORTED_KEY_FORMAT = -17;
    public static final int KM_ERROR_INCOMPATIBLE_KEY_FORMAT = -18;
    public static final int KM_ERROR_UNSUPPORTED_KEY_ENCRYPTION_ALGORITHM = -19;
    public static final int KM_ERROR_UNSUPPORTED_KEY_VERIFICATION_ALGORITHM = -20;
    public static final int KM_ERROR_INVALID_INPUT_LENGTH = -21;
    public static final int KM_ERROR_KEY_EXPORT_OPTIONS_INVALID = -22;
    public static final int KM_ERROR_DELEGATION_NOT_ALLOWED = -23;
    public static final int KM_ERROR_KEY_NOT_YET_VALID = -24;
    public static final int KM_ERROR_KEY_EXPIRED = -25;
    public static final int KM_ERROR_KEY_USER_NOT_AUTHENTICATED = -26;
    public static final int KM_ERROR_OUTPUT_PARAMETER_NULL = -27;
    public static final int KM_ERROR_INVALID_OPERATION_HANDLE = -28;
    public static final int KM_ERROR_INSUFFICIENT_BUFFER_SPACE = -29;
    public static final int KM_ERROR_VERIFICATION_FAILED = -30;
    public static final int KM_ERROR_TOO_MANY_OPERATIONS = -31;
    public static final int KM_ERROR_UNEXPECTED_NULL_POINTER = -32;
    public static final int KM_ERROR_INVALID_KEY_BLOB = -33;
    public static final int KM_ERROR_IMPORTED_KEY_NOT_ENCRYPTED = -34;
    public static final int KM_ERROR_IMPORTED_KEY_DECRYPTION_FAILED = -35;
    public static final int KM_ERROR_IMPORTED_KEY_NOT_SIGNED = -36;
    public static final int KM_ERROR_IMPORTED_KEY_VERIFICATION_FAILED = -37;
    public static final int KM_ERROR_INVALID_ARGUMENT = -38;
    public static final int KM_ERROR_UNSUPPORTED_TAG = -39;
    public static final int KM_ERROR_INVALID_TAG = -40;
    public static final int KM_ERROR_MEMORY_ALLOCATION_FAILED = -41;
    public static final int KM_ERROR_INVALID_RESCOPING = -42;
    public static final int KM_ERROR_IMPORT_PARAMETER_MISMATCH = -44;
    public static final int KM_ERROR_SECURE_HW_ACCESS_DENIED = -45;
    public static final int KM_ERROR_OPERATION_CANCELLED = -46;
    public static final int KM_ERROR_CONCURRENT_ACCESS_CONFLICT = -47;
    public static final int KM_ERROR_SECURE_HW_BUSY = -48;
    public static final int KM_ERROR_SECURE_HW_COMMUNICATION_FAILED = -49;
    public static final int KM_ERROR_UNSUPPORTED_EC_FIELD = -50;
    public static final int KM_ERROR_MISSING_NONCE = -51;
    public static final int KM_ERROR_INVALID_NONCE = -52;
    public static final int KM_ERROR_MISSING_MAC_LENGTH = -53;
    public static final int KM_ERROR_KEY_RATE_LIMIT_EXCEEDED = -54;
    public static final int KM_ERROR_CALLER_NONCE_PROHIBITED = -55;
    public static final int KM_ERROR_KEY_MAX_OPS_EXCEEDED = -56;
    public static final int KM_ERROR_INVALID_MAC_LENGTH = -57;
    public static final int KM_ERROR_MISSING_MIN_MAC_LENGTH = -58;
    public static final int KM_ERROR_UNSUPPORTED_MIN_MAC_LENGTH = -59;
    public static final int KM_ERROR_CANNOT_ATTEST_IDS = -66;
    public static final int KM_ERROR_DEVICE_LOCKED = -72;
    public static final int KM_ERROR_UNIMPLEMENTED = -100;
    public static final int KM_ERROR_VERSION_MISMATCH = -101;
    public static final int KM_ERROR_UNKNOWN_ERROR = -1000;
    public static final Map<Integer, String> sErrorCodeToString = new HashMap<Integer, String>();
    static {
        sErrorCodeToString.put(KM_ERROR_OK, "OK");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_PURPOSE, "Unsupported purpose");
        sErrorCodeToString.put(KM_ERROR_INCOMPATIBLE_PURPOSE, "Incompatible purpose");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_ALGORITHM, "Unsupported algorithm");
        sErrorCodeToString.put(KM_ERROR_INCOMPATIBLE_ALGORITHM, "Incompatible algorithm");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_KEY_SIZE, "Unsupported key size");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_BLOCK_MODE, "Unsupported block mode");
        sErrorCodeToString.put(KM_ERROR_INCOMPATIBLE_BLOCK_MODE, "Incompatible block mode");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_MAC_LENGTH,
                "Unsupported MAC or authentication tag length");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_PADDING_MODE, "Unsupported padding mode");
        sErrorCodeToString.put(KM_ERROR_INCOMPATIBLE_PADDING_MODE, "Incompatible padding mode");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_DIGEST, "Unsupported digest");
        sErrorCodeToString.put(KM_ERROR_INCOMPATIBLE_DIGEST, "Incompatible digest");
        sErrorCodeToString.put(KM_ERROR_INVALID_EXPIRATION_TIME, "Invalid expiration time");
        sErrorCodeToString.put(KM_ERROR_INVALID_USER_ID, "Invalid user ID");
        sErrorCodeToString.put(KM_ERROR_INVALID_AUTHORIZATION_TIMEOUT,
                "Invalid user authorization timeout");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_KEY_FORMAT, "Unsupported key format");
        sErrorCodeToString.put(KM_ERROR_INCOMPATIBLE_KEY_FORMAT, "Incompatible key format");
        sErrorCodeToString.put(KM_ERROR_INVALID_INPUT_LENGTH, "Invalid input length");
        sErrorCodeToString.put(KM_ERROR_KEY_NOT_YET_VALID, "Key not yet valid");
        sErrorCodeToString.put(KM_ERROR_KEY_EXPIRED, "Key expired");
        sErrorCodeToString.put(KM_ERROR_KEY_USER_NOT_AUTHENTICATED, "Key user not authenticated");
        sErrorCodeToString.put(KM_ERROR_INVALID_OPERATION_HANDLE, "Invalid operation handle");
        sErrorCodeToString.put(KM_ERROR_VERIFICATION_FAILED, "Signature/MAC verification failed");
        sErrorCodeToString.put(KM_ERROR_TOO_MANY_OPERATIONS, "Too many operations");
        sErrorCodeToString.put(KM_ERROR_INVALID_KEY_BLOB, "Invalid key blob");
        sErrorCodeToString.put(KM_ERROR_INVALID_ARGUMENT, "Invalid argument");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_TAG, "Unsupported tag");
        sErrorCodeToString.put(KM_ERROR_INVALID_TAG, "Invalid tag");
        sErrorCodeToString.put(KM_ERROR_MEMORY_ALLOCATION_FAILED, "Memory allocation failed");
        sErrorCodeToString.put(KM_ERROR_UNSUPPORTED_EC_FIELD, "Unsupported EC field");
        sErrorCodeToString.put(KM_ERROR_MISSING_NONCE, "Required IV missing");
        sErrorCodeToString.put(KM_ERROR_INVALID_NONCE, "Invalid IV");
        sErrorCodeToString.put(KM_ERROR_CALLER_NONCE_PROHIBITED,
                "Caller-provided IV not permitted");
        sErrorCodeToString.put(KM_ERROR_INVALID_MAC_LENGTH,
                "Invalid MAC or authentication tag length");
        sErrorCodeToString.put(KM_ERROR_CANNOT_ATTEST_IDS, "Unable to attest device ids");
        sErrorCodeToString.put(KM_ERROR_DEVICE_LOCKED, "Device locked");
        sErrorCodeToString.put(KM_ERROR_UNIMPLEMENTED, "Not implemented");
        sErrorCodeToString.put(KM_ERROR_UNKNOWN_ERROR, "Unknown error");
    }
    public static int getTagType(int tag) {
        return tag & (0xF << 28);
    }
    public static String getErrorMessage(int errorCode) {
        String result = sErrorCodeToString.get(errorCode);
        if (result != null) {
            return result;
        }
        return String.valueOf(errorCode);
    }
 }
@@ -0,0 +1,16 @@
 package android.security.keystore;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.security.keymaster.KeymasterCertificateChain;
 public interface IKeystoreCertificateChainCallback {
    void onFinished(KeystoreResponse keystoreResponse, KeymasterCertificateChain keymasterCertificateChain)
            throws RemoteException;
    public static abstract class Stub {
        public static IKeystoreCertificateChainCallback asInterface(IBinder b) {
            throw new UnsupportedOperationException("STUB!");
        }
    }
 }
@@ -0,0 +1,15 @@
 package android.security.keystore;
 import android.os.IBinder;
 import android.os.RemoteException;
 import android.security.keymaster.ExportResult;
 public interface IKeystoreExportKeyCallback {
    void onFinished(ExportResult exportResult) throws RemoteException;
    public static abstract class Stub {
        public static IKeystoreExportKeyCallback asInterface(IBinder b) {
            throw new UnsupportedOperationException("STUB!");
        }
    }
 }
@@ -0,0 +1,16 @@
 package android.security.keystore;
 import android.os.IBinder;
 import android.os.IInterface;
 import android.os.RemoteException;
 import android.security.keymaster.KeyCharacteristics;
 public interface IKeystoreKeyCharacteristicsCallback extends IInterface {
    void onFinished(KeystoreResponse keystoreResponse, KeyCharacteristics keyCharacteristics) throws RemoteException;
    public static abstract class Stub {
        public static IKeystoreKeyCharacteristicsCallback asInterface(IBinder b) {
            throw new UnsupportedOperationException("STUB!");
        }
    }
 }
@@ -1,7 +1,10 @@
 package android.security.keystore;
 import java.lang.String;
 public interface IKeystoreService {
    public static final String DESCRIPTOR = "android.security.keystore.IKeystoreService";
    class Stub {
    }
 }
@@ -0,0 +1,38 @@
 package android.security.keystore;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 public class KeystoreResponse implements Parcelable {
    public final int error_code_;
    public final String error_msg_;
    protected KeystoreResponse(int error_code, String error_msg) {
        this.error_code_ = error_code;
        this.error_msg_ = error_msg;
    }
    @Override
    public void writeToParcel(@NonNull Parcel dest, int flags) {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    public static final Creator<KeystoreResponse> CREATOR = new Creator<KeystoreResponse>() {
        @Override
        public KeystoreResponse createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public KeystoreResponse[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
 }
@@ -0,0 +1,38 @@
 package android.system.keystore2;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 public class CreateOperationResponse implements Parcelable {
    public IKeystoreOperation iOperation;
    public OperationChallenge operationChallenge;
    public KeyParameters parameters;
    public byte[] upgradedBlob;
    public static final Creator<CreateOperationResponse> CREATOR = new Creator<CreateOperationResponse>() {
        @Override
        public CreateOperationResponse createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public CreateOperationResponse[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public void writeToParcel(@NonNull Parcel parcel, int i) {
        throw new UnsupportedOperationException("STUB!");
    }
 }
@@ -0,0 +1,9 @@
 package android.system.keystore2;
 public @interface Domain {
    public static final int APP = 0;
    public static final int GRANT = 1;
    public static final int SELINUX = 2;
    public static final int BLOB = 3;
    public static final int KEY_ID = 4;
 }
@@ -0,0 +1,33 @@
 package android.system.keystore2;
 import android.os.IBinder;
 import android.os.Binder;
 import android.os.IInterface;
 public interface IKeystoreOperation extends IInterface {
    public static final java.lang.String DESCRIPTOR = "android.system.keystore2.IKeystoreOperation";
    public void updateAad(byte[] aadInput);
    public byte[] update(byte[] input);
    public byte[] finish(byte[] input, byte[] signature);
    public void abort() throws android.os.RemoteException;
    abstract class Stub extends Binder implements IKeystoreOperation {
        public static IKeystoreOperation asInterface(IBinder b) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public IBinder asBinder() {
            return this;
        }
        @Override
        public void updateAad(byte[] aadInput) {
            throw new UnsupportedOperationException("STUB!");
        }
    }
 }
@@ -0,0 +1,34 @@
 package android.system.keystore2;
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.hardware.security.keymint.KeyParameter;
 import androidx.annotation.NonNull;
 public class KeyParameters implements Parcelable {
    public KeyParameter[] keyParameter;
    public static final Creator<KeyParameters> CREATOR = new Creator<KeyParameters>() {
        @Override
        public KeyParameters createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public KeyParameters[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public void writeToParcel(@NonNull Parcel parcel, int i) {
        throw new UnsupportedOperationException("STUB!");
    }
 }
@@ -0,0 +1,32 @@
 package android.system.keystore2;
 import android.os.Parcel;
 import android.os.Parcelable;
 import androidx.annotation.NonNull;
 public class OperationChallenge implements Parcelable {
    public long challenge = 0L;
    public static final Creator<OperationChallenge> CREATOR = new Creator<OperationChallenge>() {
        @Override
        public OperationChallenge createFromParcel(Parcel in) {
            throw new UnsupportedOperationException("STUB!");
        }
        @Override
        public OperationChallenge[] newArray(int size) {
            throw new UnsupportedOperationException("STUB!");
        }
    };
    @Override
    public int describeContents() {
        throw new UnsupportedOperationException("STUB!");
    }
    @Override
    public void writeToParcel(@NonNull Parcel parcel, int i) {
        throw new UnsupportedOperationException("STUB!");
    }
 }