Security Blog
Authorization Bypass Logic: Common Patterns Attackers Use to Escalate Access
Broken Access Control has sat at #1 on the OWASP Top 10 since 2021, overtaking even injection flaws. It is a broad category, but in practice, almost every access control bypass in the wild reduces down to a handful of repeatable logic patterns. This post catalogs the ones that show up again and again in real assessments and bug bounty reports.
1. Parameter Tampering (Client-Trusted State)
The most common pattern of all: the application trusts a value sent by the client that should only ever be decided server-side. Classic examples:
POST /api/checkout
{ "price": 499, "role": "customer" }
If the server trusts a client-supplied price field instead of looking it up server-side from the product catalog, an attacker simply changes it. The same logic applies to a role, isAdmin, or accountType field sent in a request body, a hidden form field, or even a client-side cookie — anything the client can edit before sending, the server must never treat as authoritative.
2. Forced Browsing to Unlinked Pages
Many applications practice "security by obscurity" — an admin panel or internal tool simply is not linked anywhere in the normal user interface, with no actual access control enforced server-side. If you can guess or discover the URL (/admin, /internal-dashboard, /_debug), you're in, because the only thing protecting it was the absence of a visible link, not an authentication or role check.
3. HTTP Method Switching
A very common and easily missed pattern: an endpoint correctly enforces access control for one HTTP method but not another. A developer locks down GET /api/users/1024 with a proper role check, but the corresponding DELETE /api/users/1024 or PUT /api/users/1024 was added later, by a different developer, and the same check was never copied over. Always test every verb — GET, POST, PUT, PATCH, DELETE — against every endpoint, not just the one your browser naturally sends.
4. Mismatched Access Control Between the API and the UI
Modern single-page applications frequently enforce access control only in the frontend — hiding a button, greying out a menu item, redirecting away from a page — while the underlying API endpoint that button calls has no server-side check at all. The fix sounds obvious (never trust the client), but this pattern is extremely common because it is easy to build the UI restriction first, intend to add the backend check later, and simply forget. Testing this means bypassing the UI entirely: call the underlying API directly with a tool like Burp Suite or curl, using a lower-privileged account's session, and see if the backend stops you or not.
5. JWT and Token Manipulation
When access control decisions are baked into a JSON Web Token, several bypass angles commonly apply in real assessments:
- Algorithm confusion — changing the token's declared algorithm from
RS256tonone, or from an asymmetric to a symmetric algorithm, to see if a poorly-implemented verifier can be tricked into skipping signature validation entirely. - Claim tampering combined with a weak secret — if the signing secret is weak or has leaked, an attacker can simply edit the
roleoruserIdclaim and re-sign the token themselves. - Missing expiry or revocation checks — a token issued before a privilege downgrade (a user demoted from admin) that the backend never checks against a revocation list, letting the old, more-privileged token keep working indefinitely.
6. Path and Case Normalization Tricks
Some access-control middleware is implemented as a simple string match against the request path, which creates gaps when the underlying web server or framework normalizes paths differently than the middleware's check does:
/admin/panel -> blocked by middleware
/Admin/panel -> case mismatch, middleware's check misses it
/admin//panel -> double slash normalized away by the framework, mismatch at the middleware layer
/admin/panel/. -> trailing dot-segment, same normalization gap
Whether any specific variant works depends entirely on how the specific framework and reverse proxy in front of it each normalize paths — but checking a handful of these variants against any "blocked" path takes seconds and regularly turns up real findings.
The Common Thread
Every single pattern above exists because an access-control decision was made in the wrong place, at the wrong layer, or was inconsistently applied across equivalent paths into the same functionality. The fix is always structural: enforce every authorization decision centrally, server-side, on every code path that reaches the protected action — never in the client, never only on "the obvious" entry point, and never assumed to be implied by a check that happened somewhere else in the request lifecycle.
Learn This Hands-On, Not Just in Theory
Reading about a vulnerability class is step one. Reproducing it yourself, in a safe lab environment, under guidance, is what actually turns it into a skill employers and bug bounty programs pay for. Rudra Tech Services runs hands-on ethical hacking and VAPT training out of Aurangabad (Chhatrapati Sambhajinagar), with real lab exercises covering exactly the vulnerability classes covered in this post.
If you want to practice this safely and legally, check out our Ethical Hacking course or try our recon-based CTF platform to test these techniques in a built-for-practice environment.
Explore RudraSec's Courses
Real hands-on training, with transparent pricing and no hidden placement claims.