Skip to content
Skillpedia
Misc42k · #4736

competition-runtime-routing

Lets your agent understand how requests are routed in a system. It helps identify which server or container responds to a specific route, considering headers and proxies.

What it does

This tool helps figure out which part of a computer system is responding to a specific request. It analyzes how the request travels through different rules and settings to reach its final destination.

When to use it

  • ✓When you don't know which server is receiving your request.
  • ✓To understand how forwarding rules affect your connection.
  • ✓When investigating why an address looks public but still belongs to an internal system.

Example of what to ask your AI

“Which server is serving the route '/api/v1/users' with the Host header 'app.example.com'?”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/zhaoxuya520/reverse-skill/blob/main/CTF-Sandbox-Orchestrator/competition-runtime-routing/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/zhaoxuya520/reverse-skill/blob/main/CTF-Sandbox-Orchestrator/competition-runtime-routing/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

It examines routing rules, how headers are modified, and which services are listening. It then traces the request's path from the client to the final service.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add zhaoxuya520/reverse-skill --skill competition-runtime-routing

Or download just the file:

curl -L https://raw.githubusercontent.com/zhaoxuya520/reverse-skill/main/CTF-Sandbox-Orchestrator/competition-runtime-routing/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Competition Runtime Routing

Use this skill only as a downstream specialization after $ctf-sandbox-orchestrator is already active and has established sandbox assumptions, node ownership, and evidence priorities. If that has not happened yet, return to $ctf-sandbox-orchestrator first.

Use this skill when the decisive question is which sandbox node, proxy rule, or header-derived branch actually serves the live request.

Reply in Simplified Chinese unless the user explicitly requests English.

Quick Start

  1. Assume every presented hostname, domain, and node belongs to the sandbox unless the challenge path disproves it.
  2. Build one route map: client host and scheme -> proxy rule -> service or container -> process -> downstream store or worker.
  3. Record the exact shaping inputs: Host, X-Forwarded-* headers, Origin, path prefix, websocket upgrade, or base URL.
  4. Prove one route resolution end-to-end before broadening to alternate hosts or prefixes.
  5. Re-run the same request with one routing input changed at a time.

Workflow

1. Map Route Inputs

  • Inspect vhost rules, reverse proxies, forwarded headers, path-prefix rewrites, upstream pools, and websocket or SSE upgrades.
  • Note which parts of the request influence routing or app behavior: host, scheme, port, path, prefix, cookie scope, or origin.
  • Treat public-looking domains, cloud hostnames, and separate VPS nodes as sandbox routing fixtures first.

2. Trace Route To Live Consumer

  • Map hostname to proxy rule to container or process to port to downstream service.
  • Compare checked-in proxy intent against live listeners, mounted configs, runtime env, and observed traffic.
  • Keep headers, proxy config, and live request traces tied together in one evidence chain.

3. Prove The Decisive Deviation

  • Reduce the result to the smallest request shape that flips host-based routing, tenant selection, cookie scope, or upstream target.
  • Distinguish route resolution from application auth logic; prove where each decision really happens.
  • If the problem shifts from routing to general web state or container runtime drift, switch back to the broader parent skill.

Read This Reference

  • Load references/runtime-routing.md for the routing checklist, header matrix, and evidence packaging.
  • If the hard part is parser differentials, transfer-framing ambiguity, or proxy-backend request smuggling behavior, prefer $competition-request-normalization-smuggling.

What To Preserve

  • Hostnames, proxy snippets, header sets, path prefixes, listener ports, and route-specific cookies
  • The exact request shape that reaches the decisive backend or branch
  • One compact host -> proxy -> service -> process map for the active path
FAQ

What are 'headers'?

They are like small notes attached to an internet request, carrying extra information like who sent it or what kind of content it is.

What is 'vhost routing'?

It's a method that allows a single server to respond to multiple different domain names, directing each request to the right place based on the name you used.

Why do I need to use another tool first?

This tool works best when a larger system has already set up the basic environment. It specializes in routing details within that already configured environment.

Details

Original description by the author

Internal downstream skill for ctf-sandbox-orchestrator. CTF-sandbox workflow for reverse proxies, Host headers, forwarded headers, vhost routing, websocket upgrades, path-prefix rewriting, base-URL derivation, and multi-node route resolution. Use when the user asks which host or container serves a route, why a public-looking domain still belongs to the sandbox, how headers or proxies change behavi

repo: zhaoxuya520/reverse-skill

Popularity

GitHub stars
42k
Ranking position
#4736
License
MIT
Updated
9/22/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills