Understanding JWT Tokens: How to Decode and Verify JWTs

• Compact: JWTs are small and can be easily transmitted via URL, POST parameters, or HTTP headers.
• Self-Contained: All necessary information is in the token itself, reducing database lookups.
• Stateless: No server-side session storage required, making them scalable.
• Signed: JWTs are signed to ensure integrity and authenticity.
• Standardized: Based on RFC 7519, ensuring compatibility across platforms.

• API Authentication: Authenticate API requests without storing sessions.
• Single Sign-On (SSO): Share authentication across multiple applications.
• Information Exchange: Securely transmit information between parties.
• Authorization: Include user permissions and roles in the token.
• Microservices: Authenticate requests between microservices.

Example JWT:

{
  "alg": "HS256",
  "typ": "JWT"
}

{
  "sub": "1234567890",
  "name": "John Doe",
  "iat": 1516239022,
  "exp": 1516242622
}

HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  secret
)

JavaScript:

function decodeJWT(token) {
  const parts = token.split('.');
  const header = JSON.parse(atob(parts[0]));
  const payload = JSON.parse(atob(parts[1]));
  return { header, payload };
}

1. Extract Header and Payload: Decode the header and payload from the JWT.
2. Check Algorithm: Verify the algorithm matches what you expect (prevent algorithm confusion attacks).
3. Recreate Signature: Use the secret key and the same algorithm to recreate the signature.
4. Compare Signatures: Compare the recreated signature with the signature in the JWT.
5. Check Expiration: Verify the token hasn't expired by checking the 'exp' claim.
6. Validate Claims: Check other claims like 'iss' (issuer), 'aud' (audience) if applicable.

• iss (Issuer): Identifies who issued the JWT.
• sub (Subject): Identifies the subject of the JWT (usually the user ID).
• aud (Audience): Identifies the recipients that the JWT is intended for.
• exp (Expiration Time): Unix timestamp when the JWT expires.
• nbf (Not Before): Unix timestamp before which the JWT must not be accepted.
• iat (Issued At): Unix timestamp when the JWT was issued.
• jti (JWT ID): Unique identifier for the JWT.

{
  "sub": "1234567890",
  "name": "John Doe",
  "role": "admin",
  "permissions": ["read", "write"],
  "exp": 1516242622
}

• Always Verify Signatures: Never trust a JWT without verifying its signature. Decoding is not verification.
• Use Strong Secrets: Use cryptographically strong, random secrets for HMAC algorithms. Never use weak or predictable secrets.
• Set Short Expiration Times: Use short-lived tokens (15 minutes to 1 hour) and implement refresh tokens for longer sessions.
• Validate All Claims: Check expiration, issuer, audience, and other relevant claims before accepting a token.
• Use HTTPS: Always transmit JWTs over HTTPS to prevent interception and man-in-the-middle attacks.
• Avoid Sensitive Data: Don't store sensitive information like passwords in JWT payloads. JWTs are encoded, not encrypted.
• Prevent Algorithm Confusion: Always specify the expected algorithm when verifying. Don't trust the 'alg' claim blindly.
• Implement Token Revocation: For critical applications, maintain a blacklist of revoked tokens or use short expiration times.
• Store Securely: If storing JWTs client-side, use httpOnly cookies when possible, or secure localStorage with proper security headers.
• Monitor and Log: Log JWT verification failures and monitor for suspicious patterns or attacks.