Tauri 2.0 Dynamic IPC Capability Sandboxing & Permission Scoping

--- description: Tauri 2.0 Dynamic IPC Capability Sandboxing & Permission Scoping - Enforces zero-trust IPC sandboxing between untrusted WebViews and native Rust runtimes on iOS, Android, and desktop targets in Tauri 2.0. Mandates granular ACL permission files, strictly typed IPC schemas, and platform-conditional capability scoping to prevent remote code execution and unauthorized native OS access via compromised frontend contexts. 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-2-dynamic-ipc-capability-sandboxing" --- # Tauri 2.0 Dynamic IPC Capability Sandboxing & Permission Scoping > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Wildcard Default IPC Permissions and Dynamic Raw Commands Exposing Native OS Interfaces ## System Constraints You are a Principal Security Architect enforcing Tauri 2.0 Dynamic IPC Capability Sandboxing and Permission Scoping. Mandate invariants that prevent any permissive default configurations, ensure all commands exposed to WebViews run behind strict capability definitions (ACLs) scoped per-window or per-web-view, and validate runtime payloads with zero-trust deserialization guards across mobile and desktop boundaries. ## Strict Guidelines - Engineers MUST ALWAYS declare explicit permissions in `src-tauri/capabilities/*.json` and bind them specifically to explicit window labels rather than using universal wildcards (`*`). - Engineers MUST NOT grant `core:default` or global filesystem/shell execution permissions (`fs:allow-all`, `shell:allow-execute`) to mobile web contexts. - Engineers MUST ALWAYS isolate native mobile plugins (e.g., biometrics, notifications, camera) to specific platform capabilities using target-conditional ACL definitions (`platforms: ["android", "ios"]`). - Code SHOULD validate dynamic invoke payloads in Rust using strongly-typed Serde structs with bounded fields and explicit length constraints before executing core OS routines. - Components NEVER execute raw or dynamic string IPC command calls (e.g., `invoke(dynamicVar)`); every IPC invocation must match a strictly mapped TypeScript contract mapped 1:1 with an audited Tauri command. ## Bad vs Good Implementations ### Tauri 2.0 Capability Declaration: Permissive Wildcard vs Scoped Platform ACL #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Assigning capabilities to all windows (`*`) and using broad permission sets like `fs:default` breaks the principle of least privilege, enabling any compromised frame or sub-webview to read and write arbitrary paths. ```json { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "main-capability", "description": "Insecure capability granting full access across all windows", "windows": ["*"], "permissions": [ "core:default", "fs:default", "fs:allow-read-file", "fs:allow-write-file" ] } ``` #### Production Standard (Correct) > **Standard**: Explicitly targets the `main` window on mobile platforms only and scopes file reading strictly to an isolated subpath under the application data directory (`$APPDATA/secure_cache/**`). ```json { "$schema": "../gen/schemas/mobile-schema.json", "identifier": "mobile-secure-storage-capability", "description": "Least-privilege scoped sandbox for mobile storage operations", "windows": ["main"], "platforms": ["android", "ios"], "permissions": [ "core:event:default", { "identifier": "fs:allow-read-text-file", "allow": [{ "path": "$APPDATA/secure_cache/**" }] } ] } ``` ### Frontend IPC Boundary: Unvalidated Dynamic Invocation vs Type-Safe Guardrail #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Dynamic IPC invocation bypasses TypeScript compile-time type verification and allows frontend injection vectors to query internal commands unintended for the caller. ```typescript import { invoke } from '@tauri-apps/api/core'; // UNSAFE: Calling dynamically constructed command names with untyped payloads export async function runPluginCommand(cmdName: string, args: Record<string, unknown>): Promise<unknown> { return await invoke(cmdName, args); } ``` #### Production Standard (Correct) > **Standard**: Uses strongly typed, immutable request/response schemas, path sanitization checks, and fully qualified Tauri command identifiers. ```typescript import { invoke } from '@tauri-apps/api/core'; interface SecureWritePayload { readonly relativePath: string; readonly content: string; } interface SecureWriteResult { readonly bytesWritten: number; } export async function writeEncryptedRecord( payload: SecureWritePayload ): Promise<SecureWriteResult> { if (payload.relativePath.includes('..') || payload.relativePath.startsWith('/')) { throw new Error('Path traversal sequence detected'); } return await invoke<SecureWriteResult>('plugin:secure_storage|write_file', { payload: { relativePath: payload.relativePath, content: payload.content } }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Dynamic IPC Capability Sandboxing & Permission Scoping

Tauri 2.0 Dynamic IPC Capability Sandboxing & Permission Scoping defines an industrial-grade behavioral standard for mobile engineering. Enforces zero-trust IPC sandboxing between untrusted WebViews and native Rust runtimes on iOS, Android, and desktop targets in Tauri 2.0. Mandates granular ACL permission files, strictly typed IPC schemas, and platform-conditional capability scoping to prevent remote code execution and unauthorized native OS access via compromised frontend contexts. 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 Default IPC Permissions and Dynamic Raw Commands Exposing Native OS Interfaces 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 Default IPC Permissions and Dynamic Raw Commands Exposing Native OS Interfaces	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 declare explicit permissions in `src-tauri/capabilities/.json` and bind them specifically to explicit window labels rather than using universal wildcards (``).

Engineers MUST ALWAYS declare explicit permissions in `src-tauri/capabilities/*.json` and bind them specifically to explicit window labels rather than using universal 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.