Tauri 2.0 Mobile Capability-Based IPC Permission Sandboxing

--- description: Tauri 2.0 Mobile Capability-Based IPC Permission Sandboxing - Enforces granular capability manifests and explicit permission sandboxing for Tauri 2.0 iOS and Android targets. Prevents WebView-to-native privilege escalation by isolating IPC commands, disabling wildcard permissions, and enforcing origin-bound native capabilities. globs: src-tauri/capabilities/**/*.json, src-tauri/tauri.conf.json, src-tauri/src/**/*.rs, src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-mobile-capability-ipc-sandboxing" --- # Tauri 2.0 Mobile Capability-Based IPC Permission Sandboxing > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Over-Privileged Wildcard IPC Permissions and Unscoped Native Commands in Mobile WebViews ## System Constraints You are a Principal Security Architect enforcing Tauri 2.0 Mobile Capability-Based IPC Sandboxing. In Tauri 2.0, mobile platforms (iOS WKWebView and Android WebView) operate under elevated injection risks where an XSS or untrusted remote resource can compromise native device subsystems. You must strictly forbid default wildcard permissions (such as core:default or fs:allow-all), mandate cryptographically vetted or local-origin-restricted capability manifests in `src-tauri/capabilities/`, require fine-grained path scopes for filesystem/store access, and enforce type-safe, validated IPC invoke invocations in the frontend client layer. ## Strict Guidelines - Engineers MUST ALWAYS isolate mobile capabilities into dedicated capability JSON files (e.g., `src-tauri/capabilities/mobile.json`) targeting explicit window and webview labels. - Engineers MUST NOT grant blanket plugin access (e.g., `fs:default`, `shell:default`, `core:default`) in mobile environments; permissions MUST be declared with least privilege (e.g., `fs:allow-read-text-file` scoped to `$APP_DATA/*`). - Code MUST validate and sanitize all command arguments natively in Rust command handlers using typed structs derived with `serde::Deserialize`, never trusting frontend-provided paths or parameters implicitly. - Services MUST restrict mobile capabilities to local application bundles (`tauri://localhost` on Android and `tauri.localhost` / custom schema on iOS) and NEVER expose native IPC commands to arbitrary remote URLs. - Components NEVER invoke unmapped dynamic IPC calls with `invoke(variableName)`; all command strings MUST be string literals or mapped through a strongly-typed API boundary. ## Bad vs Good Implementations ### Tauri 2.0 Mobile Capability Manifest (Least Privilege vs Wildcard) #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Grants global wildcard window access and uses coarse default permission groups. Compromised WebViews can exploit `fs:default` to access arbitrary local storage and abuse `shell:allow-open` to execute arbitrary URI schemes or shell processes on the host mobile OS. ```json { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "mobile-capability", "description": "Insecure permissive capability for mobile", "windows": ["*"], "permissions": [ "core:default", "fs:default", "shell:allow-open" ] } ``` #### Production Standard (Correct) > **Standard**: Targets strictly the 'main' window, disallows shell and blanket file access, and limits read/write capabilities strictly to the sandboxed `$APPDATA/secure_cache/` path hierarchy. ```json { "$schema": "../gen/schemas/mobile-schema.json", "identifier": "mobile-capability-isolated", "description": "Hardened sandboxed mobile capability manifest", "windows": ["main"], "permissions": [ "core:event:allow-listen", "core:event:allow-emit", { "identifier": "fs:allow-read-text-file", "allow": [{ "path": "$APPDATA/secure_cache/**" }] }, { "identifier": "fs:allow-write-text-file", "allow": [{ "path": "$APPDATA/secure_cache/**" }] } ] } ``` ### Type-Safe Sandboxed IPC Invocation in Mobile Frontend #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Permits arbitrary command dispatch and unchecked filesystem traversal inputs through dynamic string parameters, bypassing capability constraints if misconfigured. ```typescript import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Dynamically passing raw user paths and unconstrained command names export async function loadUserPayload(cmdName: string, targetPath: string): Promise<unknown> { return await invoke(cmdName, { path: targetPath }); } ``` #### Production Standard (Correct) > **Standard**: Restricts invoke to a hardcoded command identifier, performs path sanitization to prevent traversal, and statically types both the request and response shapes. ```typescript import { invoke } from '@tauri-apps/api/core'; interface SecureDocumentRequest { readonly filename: string; } interface SecureDocumentResponse { readonly content: string; } // Safe: Bounded command literal with constrained payload structure export async function loadSecureDocument(filename: string): Promise<SecureDocumentResponse> { const sanitizedName = filename.replace(/[^a-zA-Z0-9._-]/g, ''); if (!sanitizedName || sanitizedName.includes('..')) { throw new Error('Invalid filename specified for sandboxed retrieval.'); } return await invoke<SecureDocumentResponse>('read_sandboxed_document', { payload: { filename: sanitizedName } satisfies SecureDocumentRequest, }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile Capability-Based IPC Permission Sandboxing

Tauri 2.0 Mobile Capability-Based IPC Permission Sandboxing defines an industrial-grade behavioral standard for mobile engineering. Enforces granular capability manifests and explicit permission sandboxing for Tauri 2.0 iOS and Android targets. Prevents WebView-to-native privilege escalation by isolating IPC commands, disabling wildcard permissions, and enforcing origin-bound native capabilities. 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: Over-Privileged Wildcard IPC Permissions and Unscoped Native Commands in Mobile WebViews 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	Over-Privileged Wildcard IPC Permissions and Unscoped Native Commands in Mobile WebViews	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 capabilities into dedicated capability JSON files (e.g., `src-tauri/capabilities/mobile.json`) targeting explicit window and webview labels.

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.