Tauri 2.0 Multi-IPC Protocol Isolation and Origin Sandbox Standard

--- description: Tauri 2.0 Multi-IPC Protocol Isolation and Origin Sandbox Standard - Enforces strict origin isolation, explicit capability ACL scoping, and hardware-backed cryptographic boundary validation between embedded mobile webview contexts and native Rust IPC endpoints. Prevents privilege escalation and cross-origin command hijacking in Android and iOS Tauri 2.0 runtimes. globs: src-tauri/capabilities/**/*.json, src-tauri/src/**/*.rs, src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri2-mobile-ipc-crypto-boundary-standard" --- # Tauri 2.0 Multi-IPC Protocol Isolation and Origin Sandbox Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Wildcard IPC Capability Scoping and Tokenless Privileged Invocations ## System Constraints You are a Principal Security Architect enforcing the Tauri 2.0 Multi-IPC Protocol Isolation and Origin Sandbox Standard on mobile platforms (Android/iOS). You must mandate zero-trust IPC isolation, granular capability access control lists (ACLs), explicit webview label routing, and cryptographic verification of callers invoking privileged native hardware endpoints (Secure Enclave, Keystore, Biometrics, Secure Storage). ## Strict Guidelines - Engineers MUST ALWAYS isolate mobile WebViews by defining discrete capabilities in `src-tauri/capabilities/*.json` with explicit `windows` and `platforms` constraints instead of using `*` wildcards. - Engineers MUST NOT grant default core permissions (`core:default`, `fs:default`, `shell:default`) to non-isolated or dynamic mobile webview origins. - Code SHOULD enforce hardware-backed cryptographic payload signatures (e.g., Secure Enclave or Android KeyStore session tokens) on privileged Tauri command handlers before executing sensitive host operations. - Services MUST validate the IPC caller identity, origin header, and webview label inside Rust command handlers using `tauri::ipc::Request` or `tauri::Webview` context inspection. - Components NEVER execute raw dynamic string invocations via `invoke(variableCommand)` on mobile webviews without client-side schema validation and compile-time command bindings. ## Bad vs Good Implementations ### Tauri 2.0 Capability Scoping (JSON) #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Assigning global wildcards (`*`) to windows and combining broad core defaults with high-privilege biometric and filesystem permissions allows any iframe, embedded webview, or compromised origin to trigger native hardware APIs. ```json { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "mobile-capability-all", "description": "Broad access capability for mobile webviews", "windows": ["*"], "permissions": [ "core:default", "fs:allow-read-text-file", "biometric:allow-authenticate" ] } ``` #### Production Standard (Correct) > **Standard**: Explicitly restricts the capability to the verified 'main' window label on targeted mobile platforms, implementing the principle of least privilege without wildcard exposure. ```json { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "mobile-auth-secure", "description": "Scoped biometric execution for isolated main mobile window", "windows": ["main"], "platforms": ["android", "iOS"], "permissions": [ "biometric:allow-authenticate" ] } ``` ### Rust IPC Host-Side Cryptographic Boundary Verification #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Lacks origin validation, webview label verification, and cryptographic session proof. Any script capable of calling `invoke('decrypt_vault_entry')` can extract secure enclave payloads. ```rust #[tauri::command] pub async fn decrypt_vault_entry( entry_id: String, ) -> Result<String, String> { // Insecure: Invoked directly from webview without validating origin or session token native_keystore::read_secret(&entry_id) .map_err(|e| e.to_string()) } ``` #### Production Standard (Correct) > **Standard**: Validates the calling Webview's explicit identity and performs constant-time cryptographic boundary verification before granting access to hardware keystores. ```rust use tauri::{command, Webview, Runtime}; use subtle::ConstantTimeEq; #[command] pub async fn decrypt_vault_entry<R: Runtime>( webview: Webview<R>, entry_id: String, auth_token: String, expected_hash: String, ) -> Result<String, String> { // 1. Invariant: Restrict caller strictly to verified main mobile webview if webview.label() != "main" { return Err("Unauthorized caller webview label".into()); } // 2. Invariant: Validate hardware-backed attestation / constant-time token check let is_valid = auth_token.as_bytes().ct_eq(expected_hash.as_bytes()).into(); if !is_valid { return Err("Cryptographic session boundary check failed".into()); } native_keystore::read_secret(&entry_id) .map_err(|e| e.to_string()) } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Multi-IPC Protocol Isolation and Origin Sandbox Standard

Tauri 2.0 Multi-IPC Protocol Isolation and Origin Sandbox Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces strict origin isolation, explicit capability ACL scoping, and hardware-backed cryptographic boundary validation between embedded mobile webview contexts and native Rust IPC endpoints. Prevents privilege escalation and cross-origin command hijacking in Android and iOS Tauri 2.0 runtimes. 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: Wildcard IPC Capability Scoping and Tokenless Privileged Invocations 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	Wildcard IPC Capability Scoping and Tokenless Privileged Invocations	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 isolate mobile WebViews by defining discrete capabilities in `src-tauri/capabilities/.json` with explicit `windows` and `platforms` constraints instead of using `` wildcards.

Engineers MUST ALWAYS isolate mobile WebViews by defining discrete capabilities in `src-tauri/capabilities/*.json` with explicit `windows` and `platforms` constraints instead of using `*` wildcards.

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.