1Not validating the alg header

✗ Wrong: Accepting any algorithm the token claims in its header — allows the 'alg:none' attack where attacker strips the signature

✓ Fix: Always pin the expected algorithm in your verification code: jwt.verify(token, secret, { algorithms: ['HS256'] }). Reject tokens that claim alg:none.

2Storing JWTs in localStorage

✗ Wrong: Storing tokens in localStorage because it's easy — exposes them to XSS attacks from any script on the page

✓ Fix: Store JWTs in httpOnly cookies (not accessible to JavaScript). If localStorage is required, harden against XSS with a strict Content-Security-Policy.

3Using a weak or guessable HS256 secret

✗ Wrong: JWT_SECRET=mysecret or JWT_SECRET=password — brute-forceable offline in seconds with hashcat

✓ Fix: Generate a 256-bit random secret: node -e "console.log(require('crypto').randomBytes(32).toString('hex'))". Store it in a secrets manager, not in .env files.

4Skipping audience (aud) validation

✗ Wrong: Only checking the signature — a token issued for service A is accepted by service B

✓ Fix: Set aud to the specific service identifier when issuing tokens, and verify it matches on every decode: jwt.verify(token, secret, { audience: 'my-api' }).

5Treating JWT verification as authentication

✗ Wrong: Accepting any valid JWT as proof of identity — doesn't account for revoked tokens or logged-out sessions

✓ Fix: For logout/revocation, maintain a token denylist (Redis set of jti values) and check it on every request, or use very short exp + refresh token rotation.

import jwt from "jsonwebtoken" // npm install jsonwebtoken

const secret = process.env.JWT_SECRET! // must be 256-bit random

// Sign a token (access token, 15-minute expiry):
const token = jwt.sign(
  { sub: userId, role: "user", aud: "my-api" },
  secret,
  { algorithm: "HS256", expiresIn: "15m", issuer: "my-auth-service" }
)

// Verify — throws if invalid, expired, wrong alg, wrong aud:
try {
  const payload = jwt.verify(token, secret, {
    algorithms: ["HS256"],  // pin algorithm — never omit
    audience: "my-api",
    issuer: "my-auth-service",
  })
  console.log(payload.sub) // user ID
} catch (err) {
  // TokenExpiredError, JsonWebTokenError, NotBeforeError
  return Response.json({ error: "Unauthorized" }, { status: 401 })
}

// middleware.ts
import { NextRequest, NextResponse } from "next/server"
import { jwtVerify } from "jose" // npm install jose

const secret = new TextEncoder().encode(process.env.JWT_SECRET)

export async function middleware(req: NextRequest) {
  const token = req.cookies.get("access_token")?.value
  if (!token) return NextResponse.redirect(new URL("/login", req.url))

  try {
    const { payload } = await jwtVerify(token, secret, {
      algorithms: ["HS256"],
      audience: "my-api",
      issuer: "my-auth-service",
    })
    // Forward user ID to route handlers via header:
    const res = NextResponse.next()
    res.headers.set("x-user-id", payload.sub as string)
    return res
  } catch {
    return NextResponse.redirect(new URL("/login", req.url))
  }
}

export const config = { matcher: ["/dashboard/:path*", "/api/user/:path*"] }

# pip install PyJWT cryptography
import jwt
import os

secret = os.environ["JWT_SECRET"]

# Sign:
token = jwt.encode(
    {"sub": user_id, "aud": "my-api", "exp": datetime.utcnow() + timedelta(minutes=15)},
    secret,
    algorithm="HS256"
)

# Verify — raises exceptions on failure:
try:
    payload = jwt.decode(
        token,
        secret,
        algorithms=["HS256"],  # pin — never pass algorithms=jwt.get_unverified_header(token)
        audience="my-api",
    )
    user_id = payload["sub"]
except jwt.ExpiredSignatureError:
    raise HTTPException(status_code=401, detail="Token expired")
except jwt.InvalidTokenError:
    raise HTTPException(status_code=401, detail="Invalid token")

// go get github.com/golang-jwt/jwt/v5
import (
    "github.com/golang-jwt/jwt/v5"
    "os"
)

secret := []byte(os.Getenv("JWT_SECRET"))

// Parse and verify:
token, err := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
    // Pin algorithm — reject tokens claiming a different alg:
    if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
        return nil, fmt.Errorf("unexpected signing method: %v", t.Header["alg"])
    }
    return secret, nil
}, jwt.WithAudience("my-api"), jwt.WithIssuer("my-auth-service"))

if err != nil || !token.Valid {
    http.Error(w, "Unauthorized", http.StatusUnauthorized)
    return
}

claims := token.Claims.(jwt.MapClaims)
userID := claims["sub"].(string)