React 19 Server Component Cryptographic Taint & Secret Exfiltration Guardrail

--- description: React 19 Server Component Cryptographic Taint & Secret Exfiltration Guardrail - Enforces compiler-level taint checking using experimental_taintUniqueValue and taintObjectReference across all internal data-access boundaries. This prevents accidental serialization and exfiltration of sensitive backend credentials, cryptographic keys, and PII across React Server Component (RSC) serialization boundaries into Client Component bundles. Any data access layer entity containing sensitive identifiers or secrets must be explicitly marked as tainted before processing. 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-server-component-taint-security-guardrail" --- # React 19 Server Component Cryptographic Taint & Secret Exfiltration Guardrail > **Severity**: CRITICAL | **Category**: security > **Anti-Pattern Warning**: Passing Raw Database Entities and Environment Secrets to Client Component Boundary Props Without Taint Invariants ## System Constraints You are a Principal Security and Software Architect enforcing React 19 Server Component cryptographic taint semantics. You must mandate the systematic application of experimental_taintUniqueValue and taintObjectReference across all data fetching, database client layers, and authentication gateways. Prevent silent secret leakage, token serialization, and accidental PII exfiltration across the Server-Client serialization boundary. Reject any code where un-tainted raw models or internal tokens can be directly imported or passed across Server Component props. ## Strict Guidelines - Engineers MUST ALWAYS invoke `experimental_taintObjectReference` on sensitive domain entities (User, Tenant, PaymentAccount, AuthSession) immediately upon retrieval in the data access layer (DAL). - Engineers MUST ALWAYS invoke `experimental_taintUniqueValue` for distinct high-entropy secrets, such as API tokens, session IDs, private keys, and hashed credentials, before returning them within server contexts. - Engineers MUST NOT rely exclusively on partial destructuring or object spreading (`{ ...user }`) to strip sensitive fields before passing objects across the RSC-to-Client boundary. - Code SHOULD enforce dedicated Data Transfer Object (DTO) mapper functions (`toPublicUserDTO`) that project only non-tainted, explicit primitive fields into client components. - Services MUST execute taint assertions in server-only modules (`import 'server-only'`) to guarantee that the React compiler and runtime catch exfiltration attempts at build and request time. - Components NEVER accept raw ORM records, database entities, or sensitive server credentials via React props without prior schema-validated safe projection. ## Bad vs Good Implementations ### Tainting Database Entities and Session Tokens at Data Boundary #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Passing the raw ORM entity directly into a Client Component serializes the entire object into the Flight protocol stream. This leaks internal fields (stripeCustomerId, session token, password hashes) to client inspect tools and DOM payload dumps. ```typescript import { db } from '@/lib/db'; import { ClientUserProfile } from '@/components/ClientUserProfile'; export async function UserProfilePage({ params }: { params: { id: string } }) { // Anti-Pattern: Raw DB record fetched without taint checks. // Accidental spreading or prop passing exposes hashed passwords, stripeCustomerId, and session tokens to the client bundle. const user = await db.user.findUnique({ where: { id: params.id }, include: { session: true } }); if (!user) throw new Error('Not found'); return ( <div> {/* Exfiltration risk: user object is fully serialized into RSC payload */} <ClientUserProfile user={user} /> </div> ); } ``` #### Production Standard (Correct) > **Standard**: Using experimental_taintObjectReference and experimental_taintUniqueValue guarantees that if the raw user object or the session token is ever passed to a Client Component, React will immediately halt execution and throw an error. A dedicated DTO mapper is used to project only safe primitives. ```typescript import 'server-only'; import { experimental_taintObjectReference, experimental_taintUniqueValue } from 'react'; import { db } from '@/lib/db'; import { ClientUserProfile } from '@/components/ClientUserProfile'; export interface SafeUserDTO { id: string; displayName: string; avatarUrl: string | null; } export async function getUserWithTaint(userId: string) { const user = await db.user.findUnique({ where: { id: userId }, include: { session: true } }); if (!user) return null; // Invariant: Taint raw database record reference experimental_taintObjectReference( 'Do not pass raw User records directly to Client Components. Project to SafeUserDTO.', user ); // Invariant: Taint unique high-entropy values like session tokens or secret IDs if (user.session?.token) { experimental_taintUniqueValue( 'Do not leak active session tokens to client bundles.', user, user.session.token ); } return user; } function toSafeUserDTO(user: Awaited<ReturnType<typeof getUserWithTaint>>): SafeUserDTO { if (!user) throw new Error('User not found'); return { id: user.id, displayName: user.name, avatarUrl: user.image ?? null }; } export async function UserProfilePage({ params }: { params: { id: string } }) { const user = await getUserWithTaint(params.id); if (!user) throw new Error('Not found'); const safeDto = toSafeUserDTO(user); return ( <div> <ClientUserProfile user={safeDto} /> </div> ); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: React 19 Server Component Cryptographic Taint & Secret Exfiltration Guardrail

React 19 Server Component Cryptographic Taint & Secret Exfiltration Guardrail defines an industrial-grade behavioral standard for security engineering. Enforces compiler-level taint checking using experimental_taintUniqueValue and taintObjectReference across all internal data-access boundaries. This prevents accidental serialization and exfiltration of sensitive backend credentials, cryptographic keys, and PII across React Server Component (RSC) serialization boundaries into Client Component bundles. Any data access layer entity containing sensitive identifiers or secrets must be explicitly marked as tainted before processing. 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: Passing Raw Database Entities and Environment Secrets to Client Component Boundary Props Without Taint Invariants 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	Passing Raw Database Entities and Environment Secrets to Client Component Boundary Props Without Taint Invariants	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 `experimental_taintObjectReference` on sensitive domain entities (User, Tenant, PaymentAccount, AuthSession) immediately upon retrieval in the data access layer (DAL).

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.