Tauri 2.0 Mobile IPC Capability Scoping and Payload Validation Standard

--- description: Tauri 2.0 Mobile IPC Capability Scoping and Payload Validation Standard - Enforces zero-trust isolation between mobile WebViews and native Rust runtimes under Tauri 2.0. Mandates granular capability scoping via capability files and strict bidirectional schema validation to prevent privilege escalation from compromised WebView contexts. globs: src/**/*.{ts,tsx}, src-tauri/capabilities/**/*.json, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-mobile-ipc-capability-scoping-standard" --- # Tauri 2.0 Mobile IPC Capability Scoping and Payload Validation Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Wildcard Capability Grants and Untyped IPC Invocation with Unsanitized Structs ## System Constraints You are a Principal Security Architect enforcing Tauri 2.0 Mobile IPC Security Invariants. Mobile WebView contexts are considered untrusted execution boundaries. You must enforce explicit capability definitions, disallow global wildcards, mandate strict schema-driven parameter validation on both TypeScript and Rust surfaces, and reject untyped serde deserialization. ## Strict Guidelines - Engineers MUST ALWAYS define fine-grained capability sets in `src-tauri/capabilities/` scoped strictly to target mobile platforms (iOS/Android) and designated window labels. - Engineers MUST NOT grant wildcard permissions (`*`) or unrestricted core plugin access (e.g., `fs:default`, `shell:default`) in mobile capabilities. - Rust command handlers MUST deserialize incoming IPC arguments into concrete, strongly typed structs deriving `serde::Deserialize` and implementing boundary validation checks; untyped `serde_json::Value` arguments are strictly forbidden. - Frontend IPC invocations via `@tauri-apps/api/core::invoke` MUST ALWAYS pass data validated against runtime schemas (e.g., Zod) with strict typing matching the Rust command contract. - All file system paths or external resource identifiers supplied through IPC payloads MUST be canonicalized and checked against an allowlisted base directory scope inside the Rust host before native execution. ## Bad vs Good Implementations ### Tauri 2.0 IPC Contract Validation (TypeScript & Rust) #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: The frontend invokes native IPC with unvalidated inputs, permitting path traversal (`../../sensitive_file`) and arbitrary JSON blobs. The Rust command accepts an arbitrary path without canonicalization or directory scoping, exposing the mobile sandbox to unauthorized file overwrites. ```typescript // BAD: Blind IPC dispatch with untyped arguments and unconstrained Rust receiver import { invoke } from '@tauri-apps/api/core'; export async function writeDocument(path: string, content: any): Promise<void> { // Anti-pattern: Untrusted path and unvalidated payload dispatched across boundary await invoke('save_user_document', { path, content }); } /* In Rust (src-tauri/src/commands.rs): #[tauri::command] pub async fn save_user_document(path: String, content: serde_json::Value) -> Result<(), String> { // Anti-pattern: Raw string path execution and untyped JSON payload without validation std::fs::write(path, content.to_string()).map_err(|e| e.to_string())?; Ok(()) } */ ``` #### Production Standard (Correct) > **Standard**: The payload is validated via Zod on the frontend and deserialized into rigid, strongly typed structs in Rust. Path traversal is mathematically eliminated by resolving strictly within `app_data_dir()` and verifying the prefix, honoring the Tauri 2.0 mobile zero-trust boundary. ```typescript // GOOD: Runtime schema validation prior to invoke, paired with typed Rust contract import { invoke } from '@tauri-apps/api/core'; import { z } from 'zod'; const DocumentPayloadSchema = z.object({ fileName: z.string().regex(/^[a-zA-Z0-9_-]+\.json$/), content: z.object({ version: z.number().int().positive(), data: z.record(z.string(), z.unknown()) }) }); type DocumentPayload = z.infer<typeof DocumentPayloadSchema>; export async function writeDocument(rawInput: unknown): Promise<void> { const payload = DocumentPayloadSchema.parse(rawInput); await invoke<void>('save_user_document', { payload }); } /* In Rust (src-tauri/src/commands.rs): use tauri::{AppHandle, Manager}; use serde::Deserialize; use std::path::PathBuf; #[derive(Deserialize)] pub struct ValidatedDocument { #[serde(rename = "fileName")] file_name: String, content: DocumentContent, } #[derive(Deserialize)] pub struct DocumentContent { version: u32, data: serde_json::Map<String, serde_json::Value>, } #[tauri::command] pub async fn save_user_document( app: AppHandle, payload: ValidatedDocument, ) -> Result<(), String> { // Invariant: Enforce scope resolution via secure app data directory let app_dir = app.path().app_data_dir().map_err(|e| e.to_string())?; let secure_path: PathBuf = app_dir.join(&payload.file_name); if !secure_path.starts_with(&app_dir) { return Err("Path traversal detected".into()); } let serialized = serde_json::to_string(&payload.content).map_err(|e| e.to_string())?; tokio::fs::write(secure_path, serialized).await.map_err(|e| e.to_string())?; Ok(()) } */ ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Capability Scoping and Payload Validation Standard

Tauri 2.0 Mobile IPC Capability Scoping and Payload Validation Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces zero-trust isolation between mobile WebViews and native Rust runtimes under Tauri 2.0. Mandates granular capability scoping via capability files and strict bidirectional schema validation to prevent privilege escalation from compromised WebView 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 Capability Grants and Untyped IPC Invocation with Unsanitized Structs 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 Capability Grants and Untyped IPC Invocation with Unsanitized Structs	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 define fine-grained capability sets in `src-tauri/capabilities/` scoped strictly to target mobile platforms (iOS/Android) and designated window 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.