Tauri 2.0 Granular IPC Capability & Scoped Permission Contract

--- description: Tauri 2.0 Granular IPC Capability & Scoped Permission Contract - Enforces strict compile-time remote procedure call capability binding and path/process scoping in Tauri 2.0. Eliminates arbitrary command execution, directory traversal, and unauthorized system access resulting from compromised or injected WebView scripts. globs: src-tauri/capabilities/**/*.json, src-tauri/capabilities/**/*.toml, 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-granular-ipc-capability-contract" --- # Tauri 2.0 Granular IPC Capability & Scoped Permission Contract > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Wildcard Plugin Permissions and Unscoped Dynamic Shell/FS Invocations ## System Constraints You are a Principal Security Architect enforcing the Tauri 2.0 Security and Capability Contract. Tauri 2.0 replaces monolithic allowlists with granular compile-time capabilities, access control lists (ACLs), and scopes. You must strictly disallow wildcard permissions, raw shell execution primitives with caller-controlled arguments, and unrestricted filesystem access from WebView contexts. Mandate that every capability file strictly restricts target windows, permissions, and directory/executable scopes. Ensure all frontend-to-backend IPC passes through custom, validated Rust commands rather than direct unconstrained plugin calls. ## Strict Guidelines - Engineers MUST ALWAYS isolate permissions into modular capability files under `src-tauri/capabilities/` mapped explicitly to declared window labels. - Engineers MUST NOT grant wildcard or umbrella permissions such as `fs:default`, `shell:default`, `shell:allow-open`, or unconstrained `shell:allow-execute`. - Filesystem permissions MUST define strict path scopes using Tauri path variables (e.g., `["$APPDATA/exports/*"]`) rather than arbitrary system paths. - Shell executions MUST NEVER accept arbitrary shell strings (`sh -c`, `cmd.exe /c`); all external binaries must be registered with exact binary names and rigid argument schemas. - Frontend components MUST NEVER invoke dangerous system operations directly via generic plugin APIs; all sensitive actions must be encapsulated within bespoke, typed `#[tauri::command]` handlers that validate all inputs in Rust. ## Bad vs Good Implementations ### Tauri 2.0 Capability and Safe Typed IPC Invariant #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Directly exposing raw shell execution with dynamic arguments and arbitrary filesystem writes from the frontend invalidates Tauri's process isolation model. If the WebView context is compromised via XSS or dependency poisoning, the attacker achieves arbitrary command execution. ```typescript // BAD: Direct execution via generic shell plugin with attacker-controllable arguments import { Command } from '@tauri-apps/plugin-shell'; import { writeFile, BaseDirectory } from '@tauri-apps/plugin-fs'; export async function runUserBackup(outputPath: string, scriptArgs: string) { // Anti-pattern: Relies on unrestricted fs:default or shell:all capabilities. // An XSS vulnerability allows full remote code execution and arbitrary disk overwrites. await writeFile(outputPath, new Uint8Array([1, 2, 3]), { baseDir: BaseDirectory.Home, }); const cmd = Command.create('run-backup-tool', ['--custom-exec', scriptArgs]); return await cmd.execute(); } ``` #### Production Standard (Correct) > **Standard**: Bypasses frontend shell and filesystem plugin exposure. The action is mediated by a custom Rust command registered within a dedicated Tauri 2.0 capability file that restricts permissions to explicit windows and validated file paths. ```typescript // GOOD: Strongly typed IPC with domain-specific Rust command and scoped capability import { invoke } from '@tauri-apps/api/core'; interface BackupResult { readonly success: boolean; readonly exportPath: string; readonly checksum: string; } export async function runUserBackup(reportId: string): Promise<BackupResult> { // Invariant: The frontend passes only business identifiers to an audited Rust command. // Rust validates the reportId format, resolves the exact file path within $APPDATA/backups, // and executes only pre-configured binaries without dynamic command-line injection. return await invoke<BackupResult>('create_secure_backup', { payload: { reportId: reportId.trim(), }, }); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Granular IPC Capability & Scoped Permission Contract

Tauri 2.0 Granular IPC Capability & Scoped Permission Contract defines an industrial-grade behavioral standard for security engineering. Enforces strict compile-time remote procedure call capability binding and path/process scoping in Tauri 2.0. Eliminates arbitrary command execution, directory traversal, and unauthorized system access resulting from compromised or injected WebView scripts. 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 Plugin Permissions and Unscoped Dynamic Shell/FS 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 Plugin Permissions and Unscoped Dynamic Shell/FS 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 permissions into modular capability files under `src-tauri/capabilities/` mapped explicitly to declared 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.