Tauri 2.0 Mobile Webview Origin ACL & Cryptographic Deep Link Guardrail

--- description: Tauri 2.0 Mobile Webview Origin ACL & Cryptographic Deep Link Guardrail - Mandates strict Origin Access Control Lists (ACLs) and cryptographic payload verification for OS-level deep link intents in Tauri 2.0 mobile architectures. Enforces zero-trust payload sanitization and signature verification before forwarding external custom scheme triggers to the Rust backend core to eliminate arbitrary remote command execution, privilege escalation, and cross-origin webview spoofing. globs: src-tauri/src/**/*.rs, src-tauri/tauri.conf.json, src-tauri/capabilities/**/*.json, src/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri2-mobile-origin-acl-deep-link-guardrail" --- # Tauri 2.0 Mobile Webview Origin ACL & Cryptographic Deep Link Guardrail > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Blindly dispatching unauthenticated OS deep link parameters directly into Tauri native IPC invoke commands. ## System Constraints You are a Principal Software Architect enforcing the Tauri 2.0 Native Webview Origin ACL & Deep Link Interception Guardrail. In Tauri 2.0 mobile architectures (Android Intents and iOS Custom URL Schemes), incoming OS signals represent untrusted external boundaries. You must strictly forbid any pattern where external URIs dynamically determine IPC command names or execute native core functions without cryptographic intent verification, capability scoping, and cryptographic nonce validation. ## Strict Guidelines - Engineers MUST ALWAYS configure strict Tauri 2.0 capability files with fine-grained permission scopes, never exposing wildcard (*) commands to webview contexts. - Engineers MUST NOT allow dynamic string-based IPC dispatching (e.g., `invoke(urlParam.action)`) derived from incoming deep link URLs. - Code MUST validate deep link authenticity using pre-shared state tokens, PKCE code verifiers, or asymmetric cryptographic signatures before mutating state or triggering native operations. - Services MUST route all incoming OS custom schemes through a dedicated native Rust intent-sanitizer command that enforces scheme, host, and payload schema invariants. - Components NEVER execute state mutations or privileged side effects directly from unauthenticated deep link listener callbacks. ## Bad vs Good Implementations ### Unvalidated Deep Link Dynamic Invocation vs. Cryptographically Verified Intent Dispatch #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Parsing dynamic command names and arbitrary payloads directly from an incoming OS deep link URL and forwarding them to `invoke()` allows any application on the device to execute arbitrary native core commands, completely bypassing Tauri's permission boundary. ```typescript import { onOpenUrl } from '@tauri-apps/plugin-deep-link'; import { invoke } from '@tauri-apps/api/core'; // CRITICAL VULNERABILITY: Blind dynamic dispatch of OS-level custom scheme triggers onOpenUrl(async (urls) => { for (const rawUrl of urls) { const parsed = new URL(rawUrl); const command = parsed.searchParams.get('cmd'); const payload = JSON.parse(parsed.searchParams.get('payload') || '{}'); if (command) { // Remote malicious apps can trigger arbitrary native Rust commands await invoke(command, payload); } } }); ``` #### Production Standard (Correct) > **Standard**: Enforces strict protocol checking, structural schema validation via Zod, and delegates execution exclusively to an explicit, non-dynamic Rust command (`process_verified_deep_link`) which cryptographically validates state nonces and digital signatures before acting. ```typescript import { onOpenUrl } from '@tauri-apps/plugin-deep-link'; import { invoke } from '@tauri-apps/api/core'; import { z } from 'zod'; const DeepLinkIntentSchema = z.object({ route: z.enum(['oauth/callback', 'workspace/join']), stateNonce: z.string().uuid(), signature: z.string().min(64), payload: z.record(z.string(), z.string().max(256)) }); type ValidatedIntent = z.infer<typeof DeepLinkIntentSchema>; onOpenUrl(async (urls) => { for (const rawUrl of urls) { try { const parsed = new URL(rawUrl); if (parsed.protocol !== 'myapp:') { console.warn('Rejected invalid scheme intent:', parsed.protocol); continue; } const rawPayload = parsed.searchParams.get('p'); const candidate = { route: parsed.pathname.replace(/^\/\//, ''), stateNonce: parsed.searchParams.get('state'), signature: parsed.searchParams.get('sig'), payload: rawPayload ? JSON.parse(rawPayload) : {} }; const validatedIntent: ValidatedIntent = DeepLinkIntentSchema.parse(candidate); // Dispatch exclusively to a locked-down, single-purpose Rust verification pipeline await invoke('process_verified_deep_link', { intent: validatedIntent }); } catch (err) { console.error('Dropped untrusted deep link activation:', err); } } }); ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile Webview Origin ACL & Cryptographic Deep Link Guardrail

Tauri 2.0 Mobile Webview Origin ACL & Cryptographic Deep Link Guardrail defines an industrial-grade behavioral standard for mobile engineering. Mandates strict Origin Access Control Lists (ACLs) and cryptographic payload verification for OS-level deep link intents in Tauri 2.0 mobile architectures. Enforces zero-trust payload sanitization and signature verification before forwarding external custom scheme triggers to the Rust backend core to eliminate arbitrary remote command execution, privilege escalation, and cross-origin webview spoofing. 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: Blindly dispatching unauthenticated OS deep link parameters directly into Tauri native IPC invoke commands. 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	Blindly dispatching unauthenticated OS deep link parameters directly into Tauri native IPC invoke commands.	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 configure strict Tauri 2.0 capability files with fine-grained permission scopes, never exposing wildcard (*) commands to webview contexts.

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.