React 19 RSC Cryptographic Boundary & Tainted Values Quarantine

--- description: React 19 RSC Cryptographic Boundary & Tainted Values Quarantine - Enforces strict isolation of cryptographic keys, sensitive credentials, and unhashed tokens within React 19 Server Components using experimental_taintUniqueValue and experimental_taintObjectReference. Guarantees that private server-side security primitives are never serialized across the RSC Flight protocol to client component trees. globs: src/**/*.{ts,tsx}, app/**/*.{ts,tsx}, lib/**/*.{ts,tsx} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/react-19-rsc-taint-cryptographic-boundary" --- # React 19 RSC Cryptographic Boundary & Tainted Values Quarantine > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: Exposing Raw Cryptographic Material and Plaintext Secrets to RSC Client Serialization Payloads ## System Constraints You are a Principal Software Architect enforcing React 19 Server Component (RSC) cryptographic isolation. Your mandate is to eliminate runtime credential leaks into the React Flight serialization protocol. You must ensure all sensitive data access is quarantined with 'server-only', registered with React 19 Taint APIs (experimental_taintUniqueValue, experimental_taintObjectReference), and strictly decoupled from Client Component props and public Server Action returns. ## Strict Guidelines - Engineers MUST ALWAYS invoke 'server-only' at the top of any module importing cryptographic keys, KMS clients, API secrets, or high-entropy credentials. - Engineers MUST register all sensitive primitive tokens, secret keys, and passwords using 'experimental_taintUniqueValue' as soon as they are loaded into memory. - Engineers MUST register complex cryptographic key representations, signing keyrings, and database credentials using 'experimental_taintObjectReference' to prevent object-tree serialization leaks. - Components NEVER pass tainted values, data derived directly from untruncated cryptographic contexts, or private user entities directly to 'use client' boundaries as props. - Server Actions MUST sanitize, transform, or hash any sensitive operation results into explicit, strictly-typed public DTOs before returning values across the network boundary. - Code SHOULD enforce compile-time checks via TypeScript nominal typing or brand types for sensitive cryptographic keys to prohibit accidental binding to React UI components. ## Bad vs Good Implementations ### Tainted Cryptographic Key Quarantining in RSC #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: The component passes raw private keys and JWT master secrets directly into a Client Component. React Server Components serializes all Client Component props into the plaintext Flight response stream, exposing cryptographic material in the browser DOM and network panel. ```typescript // Bad: Unprotected sensitive cryptographic keys and session tokens passed to client boundaries import { fetchUserVault } from '@/services/vault'; import { KeyCardClient } from '@/components/KeyCardClient'; export async function VaultPage({ userId }: { userId: string }) { // Anti-Pattern: Accessing private key & tokens without taint protection or server quarantine const vault = await fetchUserVault(userId); return ( <div> <h1>User Security Vault</h1> {/* Leaks encrypted payload and raw private signing key into Flight JSON */} <KeyCardClient publicKey={vault.publicKey} privateKey={vault.rawPrivateKey} sessionSecret={vault.jwtMasterSecret} /> </div> ); } ``` #### Production Standard (Correct) > **Standard**: Uses 'server-only' to protect module evaluation, applies React 19's experimental_taintObjectReference and experimental_taintUniqueValue to immediately block RSC serialization, and passes only a safe, sanitized DTO to the Client Component. ```typescript // Good: Quarantine module with 'server-only', taint secrets, and project only public DTOs import 'server-only'; import { experimental_taintObjectReference, experimental_taintUniqueValue } from 'react'; import { fetchUserVault } from '@/services/vault'; import { KeyCardClient } from '@/components/KeyCardClient'; interface PublicVaultDTO { publicKey: string; keyId: string; algorithm: string; } export async function VaultPage({ userId }: { userId: string }) { const vault = await fetchUserVault(userId); // Runtime cryptographic boundary guard: aborts rendering if passed to Client Components experimental_taintObjectReference( 'Do not pass the raw Vault entity to the client.', vault ); experimental_taintUniqueValue( 'Do not pass the private key to the client.', vault, vault.rawPrivateKey ); experimental_taintUniqueValue( 'Do not pass JWT master secret to the client.', vault, vault.jwtMasterSecret ); // Explicit projection strictly decoupling server secrets from UI props const publicDto: PublicVaultDTO = { publicKey: vault.publicKey, keyId: vault.id, algorithm: vault.algorithm, }; return ( <div> <h1>User Security Vault</h1> <KeyCardClient vault={publicDto} /> </div> ); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: React 19 RSC Cryptographic Boundary & Tainted Values Quarantine

React 19 RSC Cryptographic Boundary & Tainted Values Quarantine defines an industrial-grade behavioral standard for frontend engineering. Enforces strict isolation of cryptographic keys, sensitive credentials, and unhashed tokens within React 19 Server Components using experimental_taintUniqueValue and experimental_taintObjectReference. Guarantees that private server-side security primitives are never serialized across the RSC Flight protocol to client component trees. 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: Exposing Raw Cryptographic Material and Plaintext Secrets to RSC Client Serialization Payloads 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	Exposing Raw Cryptographic Material and Plaintext Secrets to RSC Client Serialization Payloads	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 invoke 'server-only' at the top of any module importing cryptographic keys, KMS clients, API secrets, or high-entropy credentials.

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.