Tauri 2.0 Granular Capability-Scoped IPC Permission Shield and Origin Guardrail

--- description: Tauri 2.0 Granular Capability-Scoped IPC Permission Shield and Origin Guardrail - Enforces Tauri 2.0 compile-time JSON capability contracts and cryptographic IPC boundary isolation for hybrid mobile platforms. Eliminates wildcards in permission files, enforces window-level capability isolation, and mandates origin validation to prevent arbitrary native command execution from compromised webview 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-v2-capability-scoped-ipc-permission-shield" --- # Tauri 2.0 Granular Capability-Scoped IPC Permission Shield and Origin Guardrail > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Unrestricted IPC Access via Wildcard Permissions and Unscoped Window Capabilities ## System Constraints You are a Principal Mobile Security Architect enforcing Tauri 2.0 Granular Capability-Scoped IPC Permission Shields. Tauri 2.0 strictly supersedes the v1 allowlist with an explicit capability and permission model. You must reject any wildcard permission scopes, unvalidated remote origins, or unrestricted custom IPC commands. Enforce compile-time capability schemas, window-isolated command bindings, and cryptographic origin verification for all hybrid webview-to-native execution boundaries. ## Strict Guidelines - Engineers MUST ALWAYS declare capabilities in granular JSON files inside 'src-tauri/capabilities/' with explicit window targets and granular permissions rather than global wildcards. - Engineers MUST NOT grant default 'core:*' or wildcard plugin permissions (such as 'fs:default' or 'shell:all') to any window capability set. - Engineers MUST ALWAYS bind custom native Rust commands to explicit custom permissions defined via Tauri 2.0 permission manifests rather than leaving commands unprotected. - Webview callers MUST validate target command existence and payload schemas using strongly typed wrappers before invoking 'invoke()' over the IPC bridge. - Components NEVER allow remote URLs or third-party web contexts to inherit mobile native execution capabilities without signed origin pinning and explicit capability restriction. ## Bad vs Good Implementations ### Capability Definition: Wildcard Permissions vs Explicit Scoped Invariants #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Using '*' for target windows and high-privilege wildcards like 'fs:all' grants any webview context unrestricted file-system and shell access, violating the principle of least privilege. ```json { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "mobile-capability", "description": "Insecure wildcard capability grant", "windows": ["*"], "permissions": [ "core:default", "fs:all", "shell:allow-open" ] } ``` #### Production Standard (Correct) > **Standard**: Pins the capability explicitly to the 'main' window and limits file system operations strictly to a path-scoped read operation within the designated application data cache directory. ```json { "$schema": "../gen/schemas/desktop-schema.json", "identifier": "mobile-capability-main", "description": "Hardened scoped capability for the primary mobile window", "windows": ["main"], "permissions": [ "core:event:default", "core:window:allow-set-title", { "identifier": "fs:allow-read-text-file", "allow": [{ "path": "$APP_DATA_DIR/secure_cache/**" }] } ] } ``` ### Rust Command Registration and IPC Validation #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: The command performs raw path traversal without checking caller window capabilities, app-directory scoping, or path sanitization. ```rust // Insecure custom command without capability enforcement or parameter validation #[tauri::command] pub fn execute_vault_read(file_name: String) -> Result<String, String> { let path = std::path::PathBuf::from("/secret/vault").join(file_name); std::fs::read_to_string(path).map_err(|e| e.to_string()) } ``` #### Production Standard (Correct) > **Standard**: Validates the caller context, enforces directory boundary constraints using standard path resolution, and prevents directory traversal attacks. ```rust use tauri::{ipc::Request, Manager, Runtime}; use std::path::{Path, PathBuf}; #[tauri::command] pub async fn execute_vault_read<R: Runtime>( app: tauri::AppHandle<R>, window: tauri::Window<R>, file_name: String, ) -> Result<String, String> { // Verify caller window label if window.label() != "main" { return Err("Unauthorized caller context".into()); } // Prevent directory traversal attacks if file_name.contains("..") || file_name.starts_with('/') { return Err("Invalid file path format".into()); } let safe_dir = app.path().app_data_dir().map_err(|e| e.to_string())?; let target = safe_dir.join("vault").join(file_name); std::fs::read_to_string(target).map_err(|e| format!("Failed to read file: {e}")) } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Granular Capability-Scoped IPC Permission Shield and Origin Guardrail

Tauri 2.0 Granular Capability-Scoped IPC Permission Shield and Origin Guardrail defines an industrial-grade behavioral standard for mobile engineering. Enforces Tauri 2.0 compile-time JSON capability contracts and cryptographic IPC boundary isolation for hybrid mobile platforms. Eliminates wildcards in permission files, enforces window-level capability isolation, and mandates origin validation to prevent arbitrary native command execution 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: Unrestricted IPC Access via Wildcard Permissions and Unscoped Window Capabilities 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	Unrestricted IPC Access via Wildcard Permissions and Unscoped Window Capabilities	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 capabilities in granular JSON files inside 'src-tauri/capabilities/' with explicit window targets and granular permissions rather than global 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.