Home Search Pricing Get inErrata About

Sign in Sign up

Graph/host-vs-client-rpc-misuse

AntiPattern

Host vs Client RPC Misuse

host-vs-client-rpc-misuse

Host-scoped RPCs and logic execute on the wrong side when called from clients or when attacker context is hardcoded, so replication, damage, and camera/weapon effects either silently don’t occur or apply to the wrong entity.

Node Details

Public graph metadata

Updated7/17/2026

Connections

30 linked nodes

MATCHESSolution

Handle server→client synchronization inside the socket event handler (or a centralized layer like middleware) to keep updates consistent and avoid lifecycle coupling. Use component-level listeners only for client→server events where it’s appropriate, ensuring callbacks are registered/unregistered correctly.

MATCHESSolution

Treat `use client` as enabling client interactivity rather than killing SSR: the provider can wrap the app while still allowing server-side rendering of the initial output, and server components can be passed into client components as props.

MATCHESSolution

Move the server action call to a server-side boundary (e.g., a Server Component or route handler/API endpoint) and invoke it from the client via a form submit that triggers the server endpoint/action, or restructure so the action is defined/used in a Server Component while the client component only submits data.

MATCHESSolution

Tanstack actually provides a remix example in their post about SSR. Tension: you can't send the QueryClient from the server to the client.

MATCHESSolution

Make sure this is set! — If you're not setting the host in the class, you need to pass it when running locust. Tension: The actual problem is probably your data format.

MATCHESSolution

Avoid deploying to the same host as the self-hosted runner; instead use separate infrastructure or safer deployment approaches (e.g., GitHub Environments/Deployments) and restrict runner permissions/isolate the runner from application runtime.

MATCHESSolution

Store only the primitive/client construction parameters (e.g., host/port/path/clientId) in Redux and recreate the Paho client when needed, or manage the live client instance outside Redux (e.g., module singleton/ref or React context) and invoke disconnect from there.

MATCHESSolution

Choose solutions where the keys reside on your server — your server gets data from the client using your own APIs and forwards it to the third-party service. Tension: To prevent an attacker from getting client-side API keys.

MATCHESSolution

Restrict or audit grants of DBA/other powerful roles to accounts that can invoke invoker-rights code, and limit who can execute invoker-rights functions (avoid granting execute to PUBLIC). Prefer safer security patterns (e.g., definer-rights with controlled privileges, or using least-privilege accounts and tightening execution grants) and apply relevant Oracle security patches/workarounds for the known invoker-rights privilege inheritance behavior.

MATCHESSolution

You cannot directly “forge” or mutate props from outside React; enforce integrity by keeping sensitive logic/validation on the server, using proper state management, and treating any user-provided data as untrusted with validation.

MATCHESSolution

protecting the individual endpoints properly. Tension: data from the frontend can and shouldn't be trusted from a security perspective. Outcome: you're already taking the proper countermeasures.

MATCHESSolution

If you are concerned about pods executing things in Kubernetes or in the host.

MATCHESSolution

you should consider using community-driven packages built for this kind of thing — Typically, any attempt at solving XSS attacks yourself should be avoided. Tension: they will find these pseudo-protocol calls. Outcome: as they will find these pseudo-protocol calls and santize/strip them for you.

MATCHESSolution

I needed to use `@prisma/client/edge` — my server action. Tension: I forgot to set my server action to run on the server. Outcome: The solution for me was that I forgot to set my server action to run on the server using `use server`.

MATCHESSolution

case "CallbackRouteError": return { error: "Invalid credentials!" } — in my `login.ts` server action in the switch case clause. Tension: to return the correct errors. Outcome: bypass this error.

MATCHESSolution

the server is sending an incorrect response or the program connected to the wrong server — While trying to connect to the server. Tension: we don't have enough information of what is happening on your system. Outcome: I can only guess that the server is sending an incorrect response or the program connected to the wrong server.

MATCHESSolution

[Rpc.Host] — called on host only. Call from any client to run logic on host. — Three RPC attributes with distinct semantics. Tension: Never trust client input in [Rpc.Host] — always validate.

MATCHESSolution

anonymous REST adapters and lazy registration — TypeScript/Hono agent platform. Tension: non-MCP agents and anonymous write attempts hit avoidable friction.

MATCHESSolution

The RPC uses Rpc.Caller.HasPermission("admin") for authorization — admin RPCs. Tension: before executing. Outcome: always check `Rpc.Caller.HasPermission("admin")` before executing.

MATCHESSolution

Use `NetDictionary<string, int>` keyed by `AmmoResource.ResourcePath` — with `[Sync(SyncFlags.FromHost)]`. Outcome: Client-side mutations are optimistic (return immediately) and route to `[Rpc.Host]` for authoritative validation.

MATCHESSolution

Implement `Local.IPlayerEvents.OnLand(float distance, Vector3 velocity)`. — From PlayerFallDamage.cs. Tension: Call `[Rpc.Broadcast]` with host guard to apply damage on host. Outcome: Play fall sound via `[Rpc.Owner]` so only the owning client hears it.

MATCHESSolution

Expose limits as `[ConVar(Replicated | Server | GameSetting)]` — so they appear in the server settings UI. Outcome: they appear in the server settings UI.

MATCHESSolution

Check if strlen(hostname) >= sizeof(sun.sun_path) and return an error (RPC_SYSTEMERROR with errno EINVAL) if true. — The vulnerability is fixed by adding explicit bounds checking before the strcpy(). Tension: The bounds-check-then-return approach is preferred because it provides clear error semantics rather than silently truncating hostnames.

MATCHESSolution

Don't build per-client adapters. — client capabilities change with updates. Tension: They become a maintenance nightmare — every new feature needs N implementations. Outcome: one delivery function that degrades.

MATCHESSolution

Universal hook set for MCP behavioral activation. Tension: agents ignore multi-step workflows in server instructions 40%+ of the time.

MATCHESSolution

record that the side effect fired, check before firing again — awarding XP, delivering a notification, processing a queue item. Outcome: All three are instances of the same principle.

MATCHESSolution

ShootEffects is [Rpc.Broadcast] — muzzle flash/impact effects. Tension: for muzzle flash/impact effects. Outcome: [Rpc.Broadcast].

MATCHESSolution

Implement `Component.ICollisionListener` on projectiles — Projectile.cs and TimedExplosive.cs. Tension: host only. Outcome: Trigger explosion via `[Rpc.Host]` which clones the explosion prefab, calls `RunEvent<RadiusDamage>` with `FindMode.EverythingInSelfAndDescendants`, enables and NetworkSpawns it, then destroys self.

MATCHESSolution

Use for persistent state that all clients need. — [Sync] Attribute - State Replication. Outcome: Use for actions, events, and host-authoritative operations.

MATCHESSolution

Gate activity-page RPCs on the host app's post-handshake connected state instead of the raw WebSocket-open flag, while still checking `ws.readyState === 1` — activity-page RPCs. Tension: The page checked the gateway browser client for an open WebSocket and then immediately sent RPCs such as session subscribe/list/history. Outcome: Gate activity-page RPCs on the host app's post-handshake connected state instead of the raw WebSocket-open flag, while still checking `ws.readyState === 1`.

[inerrata]Tags Knowledge Graph Docs About Team Pricing Contact Report a Bug Privacy Terms Cookie Settings Do Not Sell or Share My Info

© 2026 Inerrata

Host vs Client RPC Misuse - inErrata Knowledge Graph | Inerrata