competition-graphql-rpc-drift

Compare GraphQL schemas, RPC manifests, and generated clients against live handlers to expose drift.

Updated Aug 14, 2026
One-click install
npx skills add https://github.com/MDSIXONE/opencode-config --skill competition-graphql-rpc-drift-mdsixone
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: competition-graphql-rpc-drift
Source: https://github.com/MDSIXONE/opencode-config/tree/main/skills/reverse-skill/CTF-Sandbox-Orchestrator/competition-graphql-rpc-drift
Command: npx skills add https://github.com/MDSIXONE/opencode-config --skill competition-graphql-rpc-drift-mdsixone

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve? CTF challenges and API audits often hide the decisive behavior in mismatches between declared contracts (GraphQL schemas, persisted queries, RPC manifests, OpenAPI specs) and what live handlers actually accept. This Skill provides a structured workflow to capture real requests, compare them against declared contracts, and isolate hidden, stale, or privileged operations. ## Core Features & Use Cases - Contract Surface Mapping: Record schemas, introspection output, persisted query ids, RPC manifests, generated clients, and OpenAPI documents with version markers. - Live Handler Verification: Capture real request/response pairs including operation names, variables, headers, and auth context to prove handler-side behavior. - Drift Reduction: Compress findings into the smallest contract-to-handler mismatch that proves the decisive branch, such as a hidden mutation or undocumented RPC method. - Use Case: During a CTF sandbox challenge, you suspect a GraphQL endpoint accepts operations not present in the schema. Use this Skill to diff the declared schema against captured live requests and reproduce the hidden operation that yields the flag. ## Quick Start After $ctf-sandbox-orchestrator is active, ask it to compare the declared GraphQL schema and generated client against captured live requests to find the hidden operation that produces the decisive behavior.

Frequently Asked Questions about competition-graphql-rpc-drift

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I find hidden GraphQL operations not in the schema?▼

Capture real request and response pairs including operation names, variables, and headers, then compare them against the declared schema or introspection output. Hidden operations appear as handler-accepted requests that the contract does not declare.

How to detect drift between an OpenAPI spec and live API handlers?▼

Record the declared contract surface first, then capture actual requests with method, path, and auth context. Compare client-side validation and schema expectations against live handler normalization or fallback behavior to isolate the drift.

Can generated clients be trusted to show all supported RPC operations?▼

No. Generated clients only reflect the contract they were built from and may miss handler-only branches, stale fields, or undocumented methods. Always verify generated client assumptions against captured live traffic.

When should I use this skill instead of a generic API testing approach?▼

Use it when the hard part is matching declared contracts to live handlers, such as persisted query mismatches or schema version skew. It is a downstream specialization and requires $ctf-sandbox-orchestrator to be active first.

What evidence should I preserve when proving contract drift?▼

Keep the contract side (schema, manifest, generated client, persisted query id, version marker), the request side (operation name, variables, headers, cookies), and the effect side (hidden data, accepted action, or state change) together.