Capacitor 7 Hardware-Backed KeyStore & App Attest Integrity Validation

Cryptographic key pairs generated on mobile devices must reside strictly within hardware-isolated boundaries (iOS Secure Enclave and Android StrongBox/TEE) and possess verifiable server-validated attestations. Capacitor applications must never store unencrypted or software-backed credentials in WebView storage or execute client-only root/jailbreak checks. All high-privilege operations must enforce Apple DCAppAttest or Google Play Integrity cryptographic challenge-response handshakes validated server-side.

--- description: Capacitor 7 Hardware-Backed KeyStore & App Attest Integrity Validation - Cryptographic key pairs generated on mobile devices must reside strictly within hardware-isolated boundaries (iOS Secure Enclave and Android StrongBox/TEE) and possess verifiable server-validated attestations. Capacitor applications must never store unencrypted or software-backed credentials in WebView storage or execute client-only root/jailbreak checks. All high-privilege operations must enforce Apple DCAppAttest or Google Play Integrity cryptographic challenge-response handshakes validated server-side. globs: src/**/*.{ts,tsx}, ios/App/App/**/*.swift, android/app/src/main/java/**/*.kt alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/capacitor7-secure-enclave-app-attest-integrity-validation" --- # Capacitor 7 Hardware-Backed KeyStore & App Attest Integrity Validation > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Trusting Client-Side Integrity Flags and Software Keystores for Private Key Material ## System Constraints You are a Principal Mobile Security Architect enforcing zero-trust hardware boundaries on Capacitor 7 hybrid applications. You strictly prohibit storing private cryptographic material in WebView local storage, IndexedDB, or standard software keychains. You mandate that key generation binds directly to Secure Enclave or Android StrongBox KeyStore instances, coupled with Apple DCAppAttestService or Google Play Integrity cryptographic attestation verified strictly by the backend before enrolling device keys. ## Strict Guidelines - Engineers MUST ALWAYS generate private keys exclusively within hardware-backed security modules (iOS Secure Enclave using `kSecAttrAccessControl` with biometric constraints; Android KeyStore using `setIsStrongBoxBacked(true)` fallback to TEE). - Engineers MUST NOT trust client-side jailbreak or root detection results alone to gate access; integrity MUST be cryptographically proven to the server via signed attestation objects. - Code MUST transmit server-generated cryptographic nonces (challenges) to the native layer for inclusion in Apple App Attest or Android Play Integrity requests to eliminate replay attacks. - Services MUST verify attestation statements, certificate chains, receipt data, and counter increments strictly on the backend before associating public keys with user accounts. - Components NEVER store sensitive tokens or signing keys in WebView storage (`localStorage`, `sessionStorage`, or unencrypted SQLite). ## Bad vs Good Implementations ### Hardware Attestation vs Software Key Storage #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Private keys are generated in the Web runtime and stored in unencrypted Capacitor Preferences. There is zero hardware-backed isolation, no proof of OS integrity, and reliance on easily hookable client-side checks. ```typescript // BAD: Software-generated keys stored in insecure Capacitor Preferences // and client-side root check that can be hooked via Frida import { Preferences } from '@capacitor/preferences'; import { Device } from '@capacitor/device'; export async function registerDeviceKey(userId: string): Promise<void> { const info = await Device.getInfo(); // Flaw: Client-side verification easily bypassed if (info.isVirtual) { throw new Error('Virtual devices not permitted'); } // Flaw: Key generated in JS memory and stored in plaintext preferences/keystore const softwareKeyPair = await window.crypto.subtle.generateKey( { name: 'RSASSA-PKCS1-v1_5', modulusLength: 2048, publicExponent: new Uint8Array([1, 0, 1]), hash: 'SHA-256' }, true, ['sign', 'verify'] ); const exportedKey = await window.crypto.subtle.exportKey('jwk', softwareKeyPair.privateKey); await Preferences.set({ key: `privKey_${userId}`, value: JSON.stringify(exportedKey) }); } ``` #### Production Standard (Correct) > **Standard**: Private keys are created directly in native hardware (Secure Enclave/StrongBox) and never enter JavaScript memory. The integrity of the key is bound to a backend-issued nonce and cryptographically attested before being trusted. ```typescript // GOOD: Native bridge delegation requiring Secure Enclave/TEE and Server Nonce Attestation import { registerPlugin } from '@capacitor/core'; interface SecureEnclavePlugin { generateAttestedKey(options: { challengeNonce: string }): Promise<{ keyId: string; attestationObject: string; // Base64 DER-encoded attestation }>; signAssertion(options: { keyId: string; clientDataHash: string }): Promise<{ assertion: string; }>; } const SecureEnclave = registerPlugin<SecureEnclavePlugin>('SecureEnclave'); export async function enrollDeviceKey(apiClient: { getChallenge: () => Promise<string>; verifyAttestation: (payload: unknown) => Promise<boolean> }): Promise<string> { // 1. Obtain ephemeral cryptographic challenge from backend const challengeNonce = await apiClient.getChallenge(); // 2. Hardware creates non-exportable key and generates Apple App Attest / Play Integrity cert const { keyId, attestationObject } = await SecureEnclave.generateAttestedKey({ challengeNonce }); // 3. Attestation statement must be validated exclusively by the server const isVerified = await apiClient.verifyAttestation({ keyId, attestationObject, challengeNonce }); if (!isVerified) { throw new Error('Hardware attestation validation failed on secure backend'); } return keyId; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Capacitor 7 Hardware-Backed KeyStore & App Attest Integrity Validation

Capacitor 7 Hardware-Backed KeyStore & App Attest Integrity Validation defines an industrial-grade behavioral standard for mobile engineering. Cryptographic key pairs generated on mobile devices must reside strictly within hardware-isolated boundaries (iOS Secure Enclave and Android StrongBox/TEE) and possess verifiable server-validated attestations. Capacitor applications must never store unencrypted or software-backed credentials in WebView storage or execute client-only root/jailbreak checks. All high-privilege operations must enforce Apple DCAppAttest or Google Play Integrity cryptographic challenge-response handshakes validated server-side. 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 Client-Side Integrity Flags and Software Keystores for Private Key Material 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 Client-Side Integrity Flags and Software Keystores for Private Key Material	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 ALWAYS generate private keys exclusively within hardware-backed security modules (iOS Secure Enclave using `kSecAttrAccessControl` with biometric constraints

Engineers MUST ALWAYS generate private keys exclusively within hardware-backed security modules (iOS Secure Enclave using `kSecAttrAccessControl` with biometric constraints; Android KeyStore using `setIsStrongBoxBacked(true)` fallback to TEE).

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.