BEARER TOKENS & JSON WEB TOKEN (JWT) ANATOMY & VALIDATION

Master stateless token authentication: RFC 6750 Bearer HTTP specifications, RFC 7519 JSON Web Token tripartite structure (Header, Payload, Signature), symmetric (HS256) vs. asymmetric (RS256) cryptography, standard registered claims validation, and automated security testing against token tampering.

🛡️ The Stateless Identity Standard for Modern Microservices

In traditional monolithic architectures, user authentication relied on stateful session identifiers stored in centralized server-side caches or databases. In modern distributed cloud topologies, stateful session verification introduces massive database bottlenecks. Bearer Tokens (RFC 6750) and JSON Web Tokens (JWT, RFC 7519) solve this by acting as compact, cryptographically verifiable, self-contained digital identity credentials. Because a JWT encapsulates user claims, roles, and expiration dates directly inside its cryptographically signed payload, downstream microservices can independently authenticate requests using public keys without roundtripping to a central database. In automated API testing, engineers must validate cryptographic signature integrity, assert standard registered claims (exp, iss, sub, aud), and execute negative security tests against signature stripping (alg: none) and token manipulation.

1. The Tripartite Anatomy of a JSON Web Token (RFC 7519)
A JSON Web Token consists of three distinct parts separated by dots (.): the JOSE Header, the Claims Payload, and the Cryptographic Signature.
JWT Structural Breakdown & Wire Format
RAW JWT TOKEN STREAM ON WIRE:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJTVFUtODgyMTkiLCJuYW1lIjoiTmlraXRhIFNoYXJtYSIsInJvbGUiOiJFTkdJTkVFUiIsImlzcyI6Imh0dHBzOi8vYXBpLm5pa2l0YS1pbmZvdGVjaC5jb20iLCJleHAiOjE3OTM1MjgwMDAsImlhdCI6MTc5MzUyNDQwMH0.q2B6U_y6L14zVvP_O1o9G3M2bY7c0A1d4fE8hJ2k5Lm

DETAILED ANATOMICAL DISSECTION:
┌───────────────────────────────────────────────────────────────────────────────────────────────┐
│ 1. JOSE HEADER (Red Segment: Base64URL Encoded)                                               │
│    Metadata identifying cryptographic signing algorithm and token format:                     │
│    { "alg": "HS256", "typ": "JWT" }                                                           │
├───────────────────────────────────────────────────────────────────────────────────────────────┤
│ 2. CLAIMS PAYLOAD (Purple Segment: Base64URL Encoded)                                         │
│    Self-contained identity statements, authorization roles, and lifecycle timestamps:         │
│    {                                                                                          │
│      "sub": "STU-88219",                         // Subject (User ID)                         │
│      "name": "Nikita Sharma",                    // Custom Claim                              │
│      "role": "ENGINEER",                         // Role-Based Access Control (RBAC)          │
│      "iss": "https://api.nikita-infotech.com",    // Issuer Authority                         │
│      "aud": "nikita-training-portal",            // Target Audience                           │
│      "iat": 1793524400,                          // Issued At (Epoch seconds)                 │
│      "exp": 1793528000                           // Expiration Timestamp (Epoch seconds)      │
│    }                                                                                          │
├───────────────────────────────────────────────────────────────────────────────────────────────┤
│ 3. CRYPTOGRAPHIC SIGNATURE (Blue Segment: Binary Hash Encoded)                                │
│    Ensures token integrity and detects tampering. Calculated as:                              │
│    HMACSHA256(                                                                                │
│      base64UrlEncode(header) + "." + base64UrlEncode(payload),                                │
│      secretKey                                                                                │
│    )                                                                                          │
└───────────────────────────────────────────────────────────────────────────────────────────────┘
Architectural Standard: JWTs are digitally signed, NOT encrypted (unless using JWE - JSON Web Encryption). The header and payload are simply Base64URL encoded; anyone intercepting the token can read the claims. Never store sensitive secrets (passwords, bank PINs) inside a standard JWT payload.
Real-Time Example 1: Symmetric (HS256) vs. Asymmetric (RS256) Architectures
Enterprise systems use either symmetric shared secrets (HMAC with SHA-256) or asymmetric public/private key pairs (RSA with SHA-256). Asymmetric keys allow microservices to verify tokens using a public JWKS endpoint without knowing the signing private key.
Symmetric vs. Asymmetric Cryptography Architecture
ENTERPRISE SIGNING ARCHITECTURE COMPARISON:
┌─────────────────────┬──────────────────────────────────────┬──────────────────────────────────────┐
│ ARCHITECTURE        │ SYMMETRIC (HS256 - HMAC)             │ ASYMMETRIC (RS256 - RSA / JWKS)      │
├─────────────────────┼──────────────────────────────────────┼──────────────────────────────────────┤
│ Key Model           │ Single Shared Secret Key             │ Public Key / Private Key Pair        │
│ Token Issuer        │ Signs token using shared secret      │ Signs token using PRIVATE KEY        │
│ Token Consumer      │ Validates using SAME shared secret   │ Validates using PUBLIC KEY only      │
│ Security Boundary   │ High risk: every verifying service   │ Zero risk: services only know the    │
│                     │ holds the power to forge tokens!     │ public key, preventing forgery.      │
│ Performance         │ Extremely fast (minimal CPU)         │ Slower cryptographic verification    │
│ Best Use Case       │ Monoliths, small single-service apps │ Enterprise microservices, OAuth2/OIDC│
└─────────────────────┴──────────────────────────────────────┴──────────────────────────────────────┘

ASYMMETRIC JWKS VALIDATION LIFECYCLE (RS256):
[ Auth Server :443 ] ──(Signs via Private Key)──► [ Issues JWT ] ──► [ Client App ]
       │                                                                  │
       └── Exposes Public Key via JWKS URL                                │ Passes Bearer Token
           (GET /.well-known/jwks.json)                                   ▼
                   │                                             [ Microservice A ]
                   └─────────── Fetches & Caches Public Key ─────── (Verifies signature
                                                                     independently!)
Security Rule: In distributed microservice architectures, always enforce asymmetric RS256 or ES256 signatures. If a microservice is compromised, an attacker possessing only a public key cannot forge administrative tokens.
Real-Time Example 2: Inspecting RFC 6750 Bearer Token Wire Transmissions
RFC 6750 specifies how clients transmit Bearer tokens over HTTP. The token is passed in the Authorization request header with the Bearer scheme prefix.
Raw HTTP Bearer Token Wire Request & Response
-- CLIENT TRANSMITS REQUEST WITH BEARER TOKEN IN AUTHORIZATION HEADER --
GET /api/v1/students/STU-88219/courses HTTP/1.1
Host: api.nikita-infotech.com
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJTVFUtODgyMTkiLCJyb2xlIjoiRU5HSU5FRVIiLCJleHAiOjE3OTM1MjgwMDB9.6eE6sO5Vp-K2...
Accept: application/json
User-Agent: NikitaApiAutomationSuite/3.0

-- SCENARIO A: TOKEN VALID, UNEXPIRED & SIGNATURE VERIFIED (HTTP 200) --
HTTP/1.1 200 OK
Date: Sun, 01 Nov 2026 07:35:00 GMT
Content-Type: application/json; charset=utf-8

{
  "studentId": "STU-88219",
  "enrolledTracks": ["API-AUTOMATION-PRO", "PLAYWRIGHT-PYTHON"],
  "authorizedBy": "JWT_SIGNATURE_VERIFIED"
}

-- SCENARIO B: TOKEN EXPIRED OR CORRUPTED (HTTP 401 UNAUTHORIZED) --
HTTP/1.1 401 Unauthorized
Date: Sun, 01 Nov 2026 07:35:00 GMT
WWW-Authenticate: Bearer error="invalid_token", error_description="The access token expired"
Content-Type: application/problem+json

{
  "title": "Unauthorized",
  "status": 401,
  "detail": "Signature verification failed or token expired at 1793528000."
}
Protocol Compliance: RFC 6750 dictates that when returning a 401 Unauthorized for a failed Bearer token, the server must include the WWW-Authenticate: Bearer header specifying the error condition (e.g. invalid_token or invalid_request).
Real-Time Example 3: Decoding, Inspecting & Validating Claims in Postman
Writing automated Postman test scripts to extract a JWT, decode its Base64URL payload without external plugins, assert expiration limits, and verify user roles.
JavaScript (Postman Tests Tab - JWT Decoding & Claims Validation)
// 1. Helper function to decode Base64URL string in Postman sandbox
function parseJwtPayload(token) {
    const base64Url = token.split('.')[1];
    const base64 = base64Url.replace(/-/g, '+').replace(/_/g, '/');
    const jsonPayload = decodeURIComponent(atob(base64).split('').map(function(c) {
        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
    }).join(''));
    return JSON.parse(jsonPayload);
}

// 2. Extract Bearer token from login response
const responseJson = pm.response.json();
const jwtToken = responseJson.access_token;

pm.test("Token returned is a well-formed tripartite JWT", function () {
    pm.expect(jwtToken).to.be.a("string");
    const segments = jwtToken.split('.');
    pm.expect(segments.length, "JWT must contain Header, Payload, and Signature").to.eql(3);
});

// 3. Decode and assert claims
const claims = parseJwtPayload(jwtToken);
console.log("Decoded JWT Claims:", claims);

pm.test("Validate standard RFC 7519 registered claims", function () {
    // Assert Subject claim exists
    pm.expect(claims).to.have.property("sub");
    pm.expect(claims.sub).to.match(/^STU-[0-9]{5}$/);

    // Assert Issuer
    pm.expect(claims.iss).to.eql("https://api.nikita-infotech.com");

    // Assert Token is NOT expired
    const currentEpoch = Math.floor(Date.now() / 1000);
    pm.expect(claims.exp).to.be.above(currentEpoch, "Token is already expired!");

    // Assert Token was not issued in the future (clock skew tolerance)
    pm.expect(claims.iat).to.be.at.most(currentEpoch + 5);
});

pm.test("Validate custom application authorization claims", function () {
    pm.expect(claims.role).to.be.oneOf(["ADMIN", "ENGINEER", "STUDENT"]);
    pm.expect(claims.permissions).to.be.an("array").that.includes("READ_COURSES");
});

// 4. Save token to Environment for downstream request chaining
pm.environment.set("current_jwt_bearer_token", jwtToken);
Postman Test Results: PASS: Token returned is a well-formed tripartite JWT PASS: Validate standard RFC 7519 registered claims PASS: Validate custom application authorization claims Decoded Claims: { sub: 'STU-88219', role: 'ENGINEER', exp: 1793528000, iat: 1793524400 }
Real-Time Example 4: Testing Security Vulnerabilities (alg: none & Signature Stripping)
A critical vulnerability in flawed JWT implementations is the alg: none attack. Attackers strip the signature, change the algorithm to none, and escalate privileges (e.g., claiming role: ADMIN).
Python (test_jwt_security_vulnerabilities.py)
import base64
import json
import pytest
import requests

BASE_URL = "https://api.nikita-infotech.com/api/v1"

def base64url_encode(data_dict: dict) -> str:
    """Encodes dictionary to Base64URL string without padding."""
    json_bytes = json.dumps(data_dict, separators=(',', ':')).encode('utf-8')
    return base64.urlsafe_b64encode(json_bytes).decode('utf-8').rstrip('=')

class TestJwtSecurityVulnerabilities:

    def test_reject_alg_none_tampered_token(self):
        """Security Check: API MUST reject tokens using 'alg': 'none' with missing signature."""
        # 1. Construct malicious Header declaring algorithm as none
        malicious_header = {"alg": "none", "typ": "JWT"}
        
        # 2. Forge malicious payload elevating role to SUPER_ADMIN
        forged_payload = {
            "sub": "STU-ATTACKER",
            "role": "SUPER_ADMIN",
            "exp": 1999999999
        }

        # 3. Assemble unsigned token: Header.Payload. (empty signature)
        forged_token = f"{base64url_encode(malicious_header)}.{base64url_encode(forged_payload)}."

        # 4. Dispatch attack request
        headers = {"Authorization": f"Bearer {forged_token}"}
        response = requests.get(f"{BASE_URL}/admin/system-diagnostics", headers=headers)

        # 5. Assert server strictly rejects the forged token with 401 Unauthorized
        assert response.status_code == 401, \
            f"CRITICAL VULNERABILITY: Server accepted 'alg: none' token! Status: {response.status_code}"

    def test_reject_token_with_tampered_payload_data(self):
        """Security Check: Modifying a single character in the payload invalidates the signature."""
        valid_signed_token = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6IlVTRVIifQ.signature_hash_bytes"
        
        # Tamper payload: Change role from USER to ADMIN
        parts = valid_signed_token.split('.')
        tampered_payload = base64url_encode({"sub": "1234567890", "role": "ADMIN"})
        
        # Reassemble token with original signature (which now fails cryptographic match!)
        tampered_token = f"{parts[0]}.{tampered_payload}.{parts[2]}"

        headers = {"Authorization": f"Bearer {tampered_token}"}
        response = requests.get(f"{BASE_URL}/courses", headers=headers)
        assert response.status_code == 401, "Server failed to reject tampered cryptographic signature!"
Security Audit Result: Both tests PASS (HTTP 401 returned). The backend API gateway verifies cryptographic signatures against a secret key before decoding claims, preventing privilege escalation.
Real-Time Example 5: Automated JWT Signing & Verification with PyJWT
Using the industry-standard PyJWT library to programmatically sign tokens, validate claims, handle clock skew leeway, and catch expiration exceptions.
Python (jwt_verification_engine.py)
import jwt
import time
from datetime import datetime, timezone, timedelta

SECRET_KEY = "enterprise_super_secret_signing_key_2026"
ALGORITHM = "HS256"

def generate_signed_token(user_id: str, role: str, expiry_minutes: int = 15) -> str:
    """Generates a cryptographically signed JWT with standard registered claims."""
    now = datetime.now(timezone.utc)
    payload = {
        "sub": user_id,
        "role": role,
        "iss": "https://api.nikita-infotech.com",
        "aud": "nikita-enterprise-services",
        "iat": int(now.timestamp()),
        "nbf": int(now.timestamp()), # Not Before
        "exp": int((now + timedelta(minutes=expiry_minutes)).timestamp())
    }
    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)

def verify_and_decode_token(token_string: str) -> dict:
    """Verifies cryptographic signature and validates registered claims."""
    try:
        decoded_claims = jwt.decode(
            token_string,
            SECRET_KEY,
            algorithms=[ALGORITHM],
            issuer="https://api.nikita-infotech.com",
            audience="nikita-enterprise-services",
            leeway=10 # 10 seconds clock skew tolerance
        )
        return decoded_claims
    except jwt.ExpiredSignatureError:
        raise ValueError("TOKEN_EXPIRED: Token expiration timestamp has passed.")
    except jwt.InvalidIssuerError:
        raise ValueError("INVALID_ISSUER: Token issuer authority is untrusted.")
    except jwt.InvalidSignatureError:
        raise ValueError("INVALID_SIGNATURE: Cryptographic verification failed!")
    except jwt.PyJWTError as e:
        raise ValueError(f"TOKEN_VERIFICATION_FAILED: {str(e)}")

if __name__ == "__main__":
    token = generate_signed_token("STU-88219", "ENGINEER", expiry_minutes=30)
    print(f"[*] Generated Signed Token: {token[:45]}...")
    
    claims = verify_and_decode_token(token)
    print(f"[+] Token Verified! Subject: {claims['sub']} | Role: {claims['role']}")
Execution Output: [*] Generated Signed Token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdW... [+] Token Verified! Subject: STU-88219 | Role: ENGINEER Cryptographic verification succeeds; issuer, audience, and expiration boundaries validated.
Real-Time Example 6: Implementing Server-Side JWT Bearer Middleware (FastAPI)
Building a complete server-side authentication dependency in FastAPI using HTTPBearer to parse incoming Authorization headers, verify JWT signatures, and inject identity into route controllers.
Python (server_jwt_bearer_guard.py)
from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
import jwt

app = FastAPI(title="Nikita Infotech JWT Gateway")
security = HTTPBearer()

JWT_SECRET = "enterprise_super_secret_signing_key_2026"
ALGORITHM = "HS256"

def get_current_user_claims(credentials: HTTPAuthorizationCredentials = Depends(security)) -> dict:
    """Extracts Bearer token from header and validates signature and claims."""
    token = credentials.credentials
    try:
        claims = jwt.decode(
            token,
            JWT_SECRET,
            algorithms=[ALGORITHM],
            issuer="https://api.nikita-infotech.com"
        )
        return claims
    except jwt.ExpiredSignatureError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Token has expired",
            headers={"WWW-Authenticate": "Bearer error='invalid_token', error_description='expired'"}
        )
    except jwt.PyJWTError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid authentication token credentials",
            headers={"WWW-Authenticate": "Bearer error='invalid_token'"}
        )

def require_role(required_role: str):
    """Role-Based Access Control (RBAC) dependency factory."""
    def role_checker(claims: dict = Depends(get_current_user_claims)):
        user_role = claims.get("role")
        if user_role != required_role and user_role != "ADMIN":
            raise HTTPException(
                status_code=status.HTTP_403_FORBIDDEN,
                detail=f"Access forbidden: Requires role '{required_role}'"
            )
        return claims
    return role_checker

@app.get("/api/v1/profile")
def read_user_profile(claims: dict = Depends(get_current_user_claims)):
    return {"status": "SUCCESS", "user": claims["sub"], "role": claims["role"]}

@app.post("/api/v1/courses/create")
def create_course(claims: dict = Depends(require_role("ADMIN"))):
    return {"status": "SUCCESS", "message": "Course created by authorized administrator."}
API Gateway Mechanics: If a client calls /api/v1/courses/create with a token containing role: "STUDENT", the require_role guard returns HTTP 403 Forbidden without executing the endpoint logic.
Real-Time Example 7: Java RestAssured JWT Bearer Test Automation
Writing enterprise API test suites in Java using RestAssured to dynamically extract a JWT Bearer token from a login endpoint and pass it down into protected CRUD operations.
Java (JwtBearerRestAssuredTest.java)
import io.restassured.RestAssured;
import io.restassured.http.ContentType;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;

import static io.restassured.RestAssured.given;
import static org.hamcrest.Matchers.*;

public class JwtBearerRestAssuredTest {

    private String jwtToken;
    private static final String BASE_URL = "https://api.nikita-infotech.com";

    @BeforeClass
    public void setupAndAuthenticate() {
        // Step 1: Execute login request to acquire fresh JWT Bearer token
        jwtToken = 
            given()
                .contentType(ContentType.JSON)
                .body("{\"username\":\"engineer_nikita\",\"password\":\"SecurePass#2026\"}")
            .when()
                .post(BASE_URL + "/api/v1/auth/login")
            .then()
                .statusCode(200)
                .body("access_token", notNullValue())
                .body("token_type", equalTo("Bearer"))
                .extract().path("access_token");
        
        System.out.println("[+] Acquired Bearer Token: " + jwtToken.substring(0, 20) + "...");
    }

    @Test
    public void testProtectedResourceWithValidToken() {
        // Step 2: Use oauth2() helper or manual Authorization header injection
        given()
            .auth().oauth2(jwtToken) // Injects "Authorization: Bearer "
            .accept(ContentType.JSON)
        .when()
            .get(BASE_URL + "/api/v1/students/STU-88219/courses")
        .then()
            .statusCode(200)
            .body("studentId", equalTo("STU-88219"))
            .body("enrolledTracks", hasItem("API-AUTOMATION-PRO"));
    }

    @Test
    public void testProtectedResourceWithoutTokenReturns401() {
        // Negative test: Omitted token
        given()
            .accept(ContentType.JSON)
        .when()
            .get(BASE_URL + "/api/v1/students/STU-88219/courses")
        .then()
            .statusCode(401)
            .header("WWW-Authenticate", containsString("Bearer"));
    }
}
TestNG Output: [TestNG] Running: JwtBearerRestAssuredTest [+] Acquired Bearer Token: eyJhbGciOiJIUzI1NiIsIn... PASSED: testProtectedResourceWithValidToken PASSED: testProtectedResourceWithoutTokenReturns401 =============================================== Total tests run: 2, Failures: 0, Skips: 0 ===============================================
Real-Time Example 8: Testing Token Refresh Lifecycle & Rotation
Production JWT implementations pair short-lived Access Tokens (15-minute lifespan) with long-lived Refresh Tokens (7-day lifespan) stored in secure HTTP-only cookies to minimize the blast radius of stolen credentials.
Token Refresh & Rotation Flow
TOKEN ROTATION LIFECYCLE:
1. Client logs in -> Receives:
   - Access Token  : Short-lived (15 min) -> Used in 'Authorization: Bearer'
   - Refresh Token : Long-lived (7 days)   -> Stored securely

2. Access Token expires (Client receives 401 Unauthorized with error="invalid_token")

3. Client intercepts 401 and calls token refresh endpoint:
   POST /api/v1/auth/refresh HTTP/1.1
   Host: api.nikita-infotech.com
   Content-Type: application/json

   {
     "refreshToken": "ref_99a8b1c0de4f129bc"
   }

4. Server validates Refresh Token, INVALIDATES the old refresh token (Rotation),
   and issues a completely new Access + Refresh Token pair:
   HTTP/1.1 200 OK
   Content-Type: application/json

   {
     "access_token": "eyJhbGciOiJIUzI1NiIsIn...",
     "expires_in": 900,
     "refresh_token": "ref_NEW_8821940129bc771"
   }

5. Client retries original failing request with new access token seamlessly!
Automation Strategy: Automated regression suites must verify token rotation: submitting an already-used refresh token must trigger an immediate revocation of the entire session hierarchy (detecting token theft).
Real-Time Example 9: JWT Registered Claims & Security Reference Matrix
A structured reference guide pairing RFC 7519 standard claims, data types, validation assertions, and essential security testing rules for QA engineers.
RFC 7519 Claims & Security Validation Matrix
RFC 7519 REGISTERED CLAIMS SPECIFICATION:
┌──────────┬──────────────────────┬──────────────┬──────────────────────────────────────────────────────┐
│ CLAIM    │ FULL NAME            │ DATA TYPE    │ AUTOMATED ASSERTION VALIDATION RULE                  │
├──────────┼──────────────────────┼──────────────┼──────────────────────────────────────────────────────┤
│ sub      │ Subject              │ String       │ User / Principal ID (Must be non-empty string)       │
│ iss      │ Issuer               │ String (URI) │ Must match expected identity provider domain URI     │
│ aud      │ Audience             │ String/Array │ Must match expected client application identifier    │
│ exp      │ Expiration Time      │ NumericDate  │ Epoch timestamp; MUST be in the future (exp > now)   │
│ nbf      │ Not Before           │ NumericDate  │ Epoch timestamp; request rejected if current < nbf   │
│ iat      │ Issued At            │ NumericDate  │ Epoch timestamp; recorded creation date (iat <= now) │
│ jti      │ JWT ID               │ String       │ Unique token UUID; prevents replay attacks           │
├──────────┴──────────────────────┴──────────────┴──────────────────────────────────────────────────────┤
│ TOP 5 JWT SECURITY TESTING CHECKPOINTS:                                                               │
│ 1. Verify Signature Integrity: Tamper with any character in payload; assert server returns 401.       │
│ 2. Test 'alg: none' Exploit: Strip signature and set alg to none; verify gateway rejects the token.   │
│ 3. Validate Expired Tokens: Pass tokens where exp is in the past; assert 401 with invalid_token.      │
│ 4. Check Algorithm Confusion: If server uses RS256, test whether it mistakenly verifies using HMAC.   │
│ 5. Audit Claims Payload Privacy: Verify no sensitive PII (credit cards, passwords) is in payload.     │ 
└───────────────────────────────────────────────────────────────────────────────────────────────────────┘
Engineering Best Practice: Always treat JWT validation as a multi-step verification: 1) Verify signature against the trusted key, 2) Validate that exp > current epoch, 3) Verify iss and aud match expected services, and 4) Assert RBAC roles before routing to business logic.