Tauri 2.0 Scoped IPC Buffer Deserialization & Native Capability Guardrail

--- description: Tauri 2.0 Scoped IPC Buffer Deserialization & Native Capability Guardrail - Enforces strict bounds checking, memory allocation limits, and capability-scoped access controls on all IPC binary payloads entering Tauri 2.0 Rust commands from webviews. Prevents remote code execution, unauthenticated arbitrary memory access, and host privilege escalation resulting from unbounded deserialization of raw byte buffers. Guarantees full compliance with Tauri 2.0 permission sets and capability scoping invariants. globs: src-tauri/src/**/*.rs, src-tauri/capabilities/**/*.json, src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-scoped-ipc-buffer-guardrail" --- # Tauri 2.0 Scoped IPC Buffer Deserialization & Native Capability Guardrail > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Unbounded raw buffer deserialization and unvalidated native invocation from untrusted webview contexts ## System Constraints You are a Principal Security Architect enforcing Tauri 2.0 Scoped IPC Buffer Deserialization Guardrails. Mandate strict boundaries between untrusted webviews and host-native Rust runtimes: enforce byte payload allocation caps, prohibit unsafe memory transmutations, require explicit Tauri 2.0 capability permissions, and ensure defense-in-depth deserialization limits across all IPC invocations. ## Strict Guidelines - Engineers MUST ALWAYS validate incoming binary buffer sizes against an explicit maximum byte threshold before passing them into deserialization pipelines. - Engineers MUST NOT use unsafe memory coercion, raw pointer arithmetic, or unchecked transmutes on IPC payload buffers provided by the webview. - Code SHOULD validate granular Tauri 2.0 permissions and capability scopes (e.g., via `tauri::ipc::Request` or custom scope checks) prior to processing native host commands. - Services MUST return structured, non-leaking `tauri::ipc::InvokeError` responses and immediately reject unparseable or oversized inputs without triggering Rust panics. - Components NEVER transmit unvalidated system pointers, raw memory offsets, or OS file handles directly across the IPC bridge. ## Bad vs Good Implementations ### Tauri 2.0 IPC Binary Buffer Deserialization #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Accepts an unbounded Vec<u8> directly from the webview, executes an unsafe pointer dereference that triggers undefined behavior on malformed payloads, and executes a privileged host operation without validating Tauri 2.0 capability scopes. ```rust // BAD: Vulnerable to memory exhaustion, panics, and unchecked pointer transmutes from untrusted webview #[tauri::command] pub fn process_user_buffer(raw_bytes: Vec<u8>) -> Result<(), String> { // Anti-pattern: Unbounded allocation and unsafe transmute of external IPC data if raw_bytes.is_empty() { return Err("Empty buffer".into()); } // Highly dangerous: Assumes layout memory alignment from webview without bounds or scope checks let header = unsafe { &*(raw_bytes.as_ptr() as *const NativeHeader) }; execute_privileged_operation(header.command_id); Ok(()) } ``` #### Production Standard (Correct) > **Standard**: Imposes a hard 1 MB allocation ceiling, parses binary payloads safely using serde with `deny_unknown_fields`, returns structured `InvokeError` on violation, and validates command scope boundaries before calling host primitives. ```rust // GOOD: Bounded payload validation, zero unsafe operations, and explicit capability scope enforcement use tauri::ipc::InvokeError; use serde::Deserialize; const MAX_BUFFER_SIZE: usize = 1024 * 1024; // 1 MB boundary #[derive(Deserialize)] #[serde(deny_unknown_fields)] pub struct ValidatedPayload { pub command_id: u32, pub data: Vec<u8>, } #[tauri::command] pub fn process_user_buffer( app: tauri::AppHandle, raw_bytes: Vec<u8>, ) -> Result<(), InvokeError> { // Invariant: Enforce explicit payload size limit to prevent host memory exhaustion if raw_bytes.len() > MAX_BUFFER_SIZE { return Err(InvokeError::from_anyhow(anyhow::anyhow!("Payload exceeds max allocation limit"))); } // Invariant: Safe deserialization using serde with strictly defined structure let payload: ValidatedPayload = serde_json::from_slice(&raw_bytes) .map_err(|e| InvokeError::from_anyhow(anyhow::anyhow!("Deserialization failed: {}", e)))?; // Invariant: Check logical capability boundary before privileged native execution if payload.command_id > 1000 { return Err(InvokeError::from_anyhow(anyhow::anyhow!("Command identifier out of allowed scope"))); } execute_privileged_operation(payload.command_id); Ok(()) } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Scoped IPC Buffer Deserialization & Native Capability Guardrail

Tauri 2.0 Scoped IPC Buffer Deserialization & Native Capability Guardrail defines an industrial-grade behavioral standard for security engineering. Enforces strict bounds checking, memory allocation limits, and capability-scoped access controls on all IPC binary payloads entering Tauri 2.0 Rust commands from webviews. Prevents remote code execution, unauthenticated arbitrary memory access, and host privilege escalation resulting from unbounded deserialization of raw byte buffers. Guarantees full compliance with Tauri 2.0 permission sets and capability scoping invariants. 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: Unbounded raw buffer deserialization and unvalidated native invocation from untrusted webview contexts 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	Unbounded raw buffer deserialization and unvalidated native invocation from untrusted webview contexts	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 validate incoming binary buffer sizes against an explicit maximum byte threshold before passing them into deserialization pipelines.

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.