Capacitor 7 Secure Enclave Hardware-Attested Key Derivation Standard

--- description: Capacitor 7 Secure Enclave Hardware-Attested Key Derivation Standard - Enforces hardware-backed cryptographic operations directly within the hardware security module (Apple Secure Enclave / Android StrongBox Keystore) rather than trusting boolean bridge responses from biometric prompts. Dynamic memory injection tools (e.g., Frida, Objection) can trivially hook JavaScript-to-native bridges and boolean biometric evaluations; authentication must be cryptographically bound to hardware key unwrap/signing operations with server-nonce attestation. globs: src/**/*.{ts,tsx}, ios/App/App/**/*.{swift,m}, android/app/src/main/java/**/*.{java,kt} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/capacitor-secure-enclave-hardware-attested-derivation" --- # Capacitor 7 Secure Enclave Hardware-Attested Key Derivation Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Trusting Boolean Biometric Bridge Responses and Decoupling Biometric Prompts from Hardware Cryptographic Operations ## System Constraints You are a Principal Mobile Security Architect enforcing the Capacitor 7 Secure Enclave Hardware-Attested Key Derivation Standard. You must reject any implementation where biometric authentication returns a boolean state used to unlock client-side secrets. Mandate that all sensitive operations use cryptographic challenges signed or decrypted directly within the Secure Enclave or Android StrongBox KeyStore requiring hardware-level biometric gatekeeping. ## Strict Guidelines - Engineers MUST NEVER rely on boolean checks (e.g., `BiometricAuth.verify({ ... }).success === true`) to unlock secrets or authorize critical operations in the Web layer. - Engineers MUST require keys to be generated in hardware (`kSecAttrAccessControl` with `.biometryCurrentSet` on iOS; `KeyGenParameterSpec` with `setUserAuthenticationRequired(true)` and `AUTH_BIOMETRIC_STRONG` on Android). - Services MUST implement a Challenge-Response protocol: the backend generates a cryptographically secure ephemeral nonce (e.g., 32-byte CSPRNG) that the hardware module signs using the hardware-bound private key. - Code MUST invalidate keys when biometrics change by using hardware flags (`kSecAccessControlBiometryCurrentSet` on iOS, `setInvalidatedByBiometricEnrollment(true)` on Android StrongBox). - Components NEVER store encryption master keys in `CapacitorPreferences`, `localStorage`, or standard non-hardware-backed keychains. - Native plugins MUST perform the hardware cryptographic operation directly during the prompt lifecycle, failing completely if the secure element rejects the derivation challenge. ## Bad vs Good Implementations ### Vulnerable Boolean Biometric Gate vs. Hardware-Attested Nonce Signing #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: The Web layer checks a boolean flag returned across the Capacitor bridge. An attacker using Frida or runtime instrumentation can hook NativeBiometric.verifyIdentity to return true, bypassing authentication entirely and obtaining the token stored in insecure storage. ```typescript import { NativeBiometric } from 'capacitor-native-biometric'; import { Preferences } from '@capacitor/preferences'; export async function authenticateAndExecute(payload: unknown): Promise<void> { // VULNERABLE: Frida hook can intercept this method call // and return { isVerified: true } without any biometric interaction. const result = await NativeBiometric.verifyIdentity({ reason: 'Authenticate to sign transaction', title: 'Sign In' }); if (result.isVerified) { // VULNERABLE: Secret retrieved into memory via insecure storage // after a bypassable boolean check const rawToken = await Preferences.get({ key: 'auth_token' }); await fetch('https://api.example.com/execute', { method: 'POST', headers: { Authorization: `Bearer ${rawToken.value}` }, body: JSON.stringify(payload) }); } else { throw new Error('Biometric authentication failed'); } } ``` #### Production Standard (Correct) > **Standard**: Eliminates the boolean check vulnerability. The biometric prompt is hardware-gated by the Secure Enclave / StrongBox Keystore. The private key cannot be accessed directly or hooked in JavaScript memory, and transaction authorization is mathematically attested through an ephemeral server-issued nonce. ```typescript import { registerPlugin } from '@capacitor/core'; interface HardwareKeyPlugin { signChallengeWithHardwareKey(options: { alias: string; challenge: string; promptTitle: string; }): Promise<{ signature: string; keyId: string }>; } const SecureEnclave = registerPlugin<HardwareKeyPlugin>('SecureEnclave'); export async function authenticateAndExecute(payload: Record<string, unknown>): Promise<void> { // 1. Fetch ephemeral server nonce to prevent replay attacks const challengeResponse = await fetch('https://api.example.com/auth/challenge', { method: 'POST' }); const { challenge } = (await challengeResponse.json()) as { challenge: string }; // 2. Hardware crypto operation: Secure Enclave/StrongBox prompts user and signs the nonce // inside isolated silicon. The private key never enters application memory. const { signature, keyId } = await SecureEnclave.signChallengeWithHardwareKey({ alias: 'enterprise_session_key', challenge, promptTitle: 'Authorize Transaction' }); // 3. Server validates cryptographic signature against enrolled public key const response = await fetch('https://api.example.com/execute', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ payload, keyId, challenge, signature }) }); if (!response.ok) { throw new Error('Cryptographic signature verification failed'); } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Capacitor 7 Secure Enclave Hardware-Attested Key Derivation Standard

Capacitor 7 Secure Enclave Hardware-Attested Key Derivation Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces hardware-backed cryptographic operations directly within the hardware security module (Apple Secure Enclave / Android StrongBox Keystore) rather than trusting boolean bridge responses from biometric prompts. Dynamic memory injection tools (e.g., Frida, Objection) can trivially hook JavaScript-to-native bridges and boolean biometric evaluations; authentication must be cryptographically bound to hardware key unwrap/signing operations with server-nonce attestation. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Trusting Boolean Biometric Bridge Responses and Decoupling Biometric Prompts from Hardware Cryptographic Operations Without an explicit system instruction file, developers spend hours debugging silent failures.

Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Trusting Boolean Biometric Bridge Responses and Decoupling Biometric Prompts from Hardware Cryptographic Operations	Critical	Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production. Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture Inconsistency	AI assistants produce mixed paradigms across files, creating fragmented codebase conventions.	Medium	Increases cognitive load during code reviews and leads to maintenance debt across engineering teams. Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.

Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

Engineers MUST NEVER rely on boolean checks (e.g., `BiometricAuth.verify({ ... }).success === true`) to unlock secrets or authorize critical operations in the Web layer.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.