Authentication is the cornerstone of web security. In 2026, OAuth 2.0 with PKCE and JWT (JSON Web Tokens) remain the industry standard, but implementation details matter more than ever.
🔐 OAuth 2.0 Flows Explained
| Flow | Use Case | Security |
|---|---|---|
| Authorization Code + PKCE | SPAs, Mobile Apps | ✅ Highest |
| Client Credentials | Server-to-server | ✅ High |
| Device Code | TVs, IoT devices | ✅ High |
| Implicit (deprecated) | Legacy SPAs | ❌ Vulnerable |
🔑 JWT Token Structure
// JWT consists of three parts: Header.Payload.Signature
// Header
{
"alg": "RS256",
"typ": "JWT",
"kid": "key-id-123"
}
// Payload (Claims)
{
"sub": "user-uuid-123",
"email": "john@example.com",
"role": "admin",
"iat": 1712000000,
"exp": 1712003600, // 1 hour expiry
"iss": "https://auth.example.com",
"aud": "https://api.example.com"
}
// Signature
RSASHA256(
base64UrlEncode(header) + "." + base64UrlEncode(payload),
privateKey
)
💻 Node.js JWT Implementation
import jwt from "jsonwebtoken";
import { createHash, randomBytes } from "crypto";
// Generate tokens
function generateTokens(user) {
const accessToken = jwt.sign(
{ sub: user.id, email: user.email, role: user.role },
process.env.JWT_SECRET,
{ expiresIn: "15m", issuer: "your-app", audience: "your-api" }
);
const refreshToken = randomBytes(64).toString("hex");
return { accessToken, refreshToken };
}
// Verify middleware
function authenticate(req, res, next) {
const token = req.headers.authorization?.split(" ")[1];
if (!token) return res.status(401).json({ error: "No token" });
try {
const decoded = jwt.verify(token, process.env.JWT_SECRET, {
issuer: "your-app",
audience: "your-api",
});
req.user = decoded;
next();
} catch (err) {
return res.status(401).json({ error: "Invalid token" });
}
}
// Refresh token rotation (prevent replay attacks)
async function refreshAccessToken(req, res) {
const { refreshToken } = req.body;
const stored = await db.findRefreshToken(refreshToken);
if (!stored || stored.revoked) {
// Token reuse detected — revoke all tokens for this user
await db.revokeAllTokens(stored?.userId);
return res.status(401).json({ error: "Token reuse detected" });
}
// Rotate: revoke old, issue new
await db.revokeRefreshToken(refreshToken);
const tokens = generateTokens(stored.user);
await db.saveRefreshToken(tokens.refreshToken, stored.userId);
return res.json(tokens);
}
⚛️ React PKCE Flow
// Generate PKCE challenge for SPA
async function generatePKCE() {
const verifier = randomString(128);
const encoder = new TextEncoder();
const data = encoder.encode(verifier);
const digest = await crypto.subtle.digest("SHA-256", data);
const challenge = btoa(String.fromCharCode(...new Uint8Array(digest)))
.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
return { verifier, challenge };
}
// Initiate login
const { verifier, challenge } = await generatePKCE();
sessionStorage.setItem("pkce_verifier", verifier);
const authUrl = new URL("https://auth.example.com/authorize");
authUrl.searchParams.set("response_type", "code");
authUrl.searchParams.set("client_id", "your-spa-client-id");
authUrl.searchParams.set("redirect_uri", "https://app.example.com/callback");
authUrl.searchParams.set("code_challenge", challenge);
authUrl.searchParams.set("code_challenge_method", "S256");
window.location.href = authUrl.toString();
🛡️ Security Best Practices
- Short-lived access tokens — 15 minutes max
- Refresh token rotation — New refresh token on every use
- PKCE for SPAs — Never use implicit flow
- HttpOnly cookies — Store tokens in secure cookies, not localStorage
- Token binding — Bind tokens to client fingerprint
- Rate limiting — Protect token endpoints from brute force
🔒 Key Takeaway: Never roll your own auth from scratch in production. Use battle-tested providers (Auth0, Supabase Auth, Clerk) and focus on proper token management and rotation.