competition-request-normalization-smuggling
Lets your agent investigate how different systems interpret requests. It helps find bugs where how proxies and servers process data leads to vulnerabilities like request smuggling.
What it does
This tool helps understand how different parts of a computer system interpret the requests they receive. It investigates if there are differences in how paths, headers, or data are read, which can cause problems or unexpected behavior.
When to use it
- ✓When you suspect a request is interpreted differently by an intermediary server and the final server.
- ✓If a request seems to work in a test but fails in production due to small differences.
- ✓To investigate how the system handles complex URL paths or ambiguous headers.
Example of what to ask your AI
“Analyze request interpretation differences between the proxy and backend server to identify path normalization gaps.”
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
Ready-to-paste message
How it works
The tool compares identical requests with minor changes to see where the interpretation shifts. It maps out each step a request takes, logging how each component processes it.
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-request-normalization-smugglingOr download just the file:
curl -L https://raw.githubusercontent.com/zhaoxuya520/reverse-skill/main/CTF-Sandbox-Orchestrator/competition-request-normalization-smuggling/SKILL.md -o SKILL.mdTechnical content (original SKILL.md)
Original text by the author, straight from GitHub.
Competition Request Normalization Smuggling
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 request interpretation changes between proxy, middleware, and backend parser layers.
Reply in Simplified Chinese unless the user explicitly requests English.
Quick Start
- Map every parsing hop: client-facing proxy, gateway, app server, and downstream service.
- Record path normalization, header canonicalization, transfer framing, and host derivation at each hop.
- Capture one accepted baseline request and one differential request with minimal delta.
- Prove which hop interprets the request differently.
- Reproduce one minimal differential path that yields decisive behavior.
Workflow
1. Map Parse And Routing Boundaries
- Record
Host, forwarded headers, path decoding, slash collapsing, dot-segment handling, and case behavior. - Note
Content-Length,Transfer-Encoding, chunk framing, and connection reuse behavior when relevant. - Keep edge parser and backend parser decisions side by side.
2. Prove Differential Interpretation
- Build paired requests that differ in one canonicalization dimension only.
- Capture proxy logs, backend logs, route match, and downstream request shape.
- Show where route, auth scope, or body boundary diverges.
3. Reduce To Decisive Smuggling Chain
- Compress to: crafted request -> parser differential across hops -> unintended routed request or hidden endpoint reach -> resulting effect.
- State whether root cause is path normalization drift, header ambiguity, transfer framing differential, or host-derivation confusion.
- If the chain becomes primarily runtime routing without framing tricks, hand off to runtime routing skill.
Read This Reference
- Load
references/request-normalization-smuggling.mdfor parse-differential checklist and evidence packaging.
What To Preserve
- Raw request pairs, hop-by-hop interpretation, and final routed target
- Exact normalization or framing delta that flips behavior
- One minimal replayable differential request path
FAQ
What is request 'normalization'?
It's the process of standardizing or simplifying parts of a request, like URL paths, so the server can understand it consistently.
What is 'request smuggling'?
It's an attack technique where an attacker sends malicious requests that are interpreted differently by different servers, leading to unexpected behavior or access to restricted areas.
Do I need to understand networking to use this?
Not strictly necessary, but understanding basic concepts of how requests travel the internet (client, server, proxy) can help in understanding the results.
Details
Original description by the author
Internal downstream skill for ctf-sandbox-orchestrator. CTF-sandbox workflow for parser differentials, HTTP normalization gaps, ambiguous headers, path decoding drift, transfer-framing mismatches, and request smuggling routes. Use when the user asks to trace proxy and backend parse differences, conflicting path normalization, Host or forwarded-header ambiguity, CL/TE issues, or routing outcomes th
Popularity
- GitHub stars
- 42k
- Ranking position
- #4734
- License
- MIT
- Updated
- 9/22/2026
Comments
- …
More skills from this repository
competition-ad-certificate-abuse
Helps your agent analyze attacks on digital certificate systems. It investigates how certificates can be misused to gain access.
zhaoxuya520/reverse-skill
competition-agent-cloud
Helps your agent analyze security challenges in AI and cloud systems. It investigates how prompts, tools, and the cloud can be exploited.
zhaoxuya520/reverse-skill
competition-android-hooking
Helps your agent investigate Android applications. It analyzes how apps work internally and how they might be modified or exploited.
zhaoxuya520/reverse-skill
competition-browser-persistence
Helps your agent analyze how websites store information in your browser. It investigates cookies and other data to understand how sessions work.
zhaoxuya520/reverse-skill
Similar skills
dashboard-builder
Helps your agent create useful monitoring dashboards. It turns data into charts that answer important system questions.
affaan-m/ECC
dev-team
Simulates a collaborative development team where different roles respond to a problem together. It's useful for getting multiple perspectives without manually switching agents.
affaan-m/ECC
ecc-council
Has your agent convene a four-voice council for difficult decisions. It's useful when there are multiple good options and debate is needed before choosing.
affaan-m/ECC