JWT Security Hardening

// Implement key versioning
const keys = {
  current: process.env.JWT_SECRET_V2,
  previous: process.env.JWT_SECRET_V1  // Keep for 30 days
};

// Try current key first, fallback to previous
function verifyToken(token) {
  try {
    return jwt.verify(token, keys.current, { algorithms: ['HS256'] });
  } catch (error) {
    // Try previous key (for tokens issued before rotation)
    return jwt.verify(token, keys.previous, { algorithms: ['HS256'] });
  }
}

// Rotation schedule:
// - Rotate every 90 days
// - Keep previous key for 30 days after rotation
// - Update all services simultaneously
// - Monitor for token verification failures

// Rate limit token verification attempts
const rateLimiter = require('express-rate-limit');

const tokenVerificationLimiter = rateLimiter({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per windowMs
  message: 'Too many token verification attempts'
});

app.use('/api/protected', tokenVerificationLimiter);

// Detect brute force attempts
let failedAttempts = new Map();

function checkBruteForce(ip) {
  const attempts = failedAttempts.get(ip) || 0;
  if (attempts > 10) {
    // Block IP for 1 hour
    return false;
  }
  return true;
}

function recordFailedAttempt(ip) {
  const attempts = failedAttempts.get(ip) || 0;
  failedAttempts.set(ip, attempts + 1);
  setTimeout(() => {
    failedAttempts.delete(ip);
  }, 3600000); // Clear after 1 hour
}

// ❌ Vulnerable to timing attacks
if (signature === expectedSignature) {
  return true;
}

// ✅ Secure - constant-time comparison
const crypto = require('crypto');

function constantTimeEqual(a, b) {
  if (a.length !== b.length) {
    return false;
  }
  return crypto.timingSafeEqual(
    Buffer.from(a),
    Buffer.from(b)
  );
}

// Use in signature verification
if (constantTimeEqual(signature, expectedSignature)) {
  return true;
}

// Bind token to client fingerprint
const crypto = require('crypto');

function generateClientFingerprint(req) {
  const components = [
    req.headers['user-agent'],
    req.ip,
    req.headers['accept-language']
  ].join('|');
  
  return crypto.createHash('sha256')
    .update(components)
    .digest('hex');
}

// Include fingerprint in token
const token = jwt.sign({
  sub: userId,
  fingerprint: generateClientFingerprint(req)
}, secret);

// Verify fingerprint matches
function verifyTokenBinding(token, req) {
  const decoded = jwt.verify(token, secret);
  const currentFingerprint = generateClientFingerprint(req);
  
  if (decoded.fingerprint !== currentFingerprint) {
    throw new Error('Token binding mismatch');
  }
  
  return decoded;
}

// Pin JWKS endpoint certificate
const https = require('https');
const tls = require('tls');

const JWKS_PINNED_CERT = 'SHA256:abc123...'; // Certificate fingerprint

function fetchJWKS(url) {
  return new Promise((resolve, reject) => {
    const options = {
      hostname: new URL(url).hostname,
      port: 443,
      path: new URL(url).pathname,
      method: 'GET',
      checkServerIdentity: (servername, cert) => {
        const fingerprint = cert.fingerprint256;
        if (fingerprint !== JWKS_PINNED_CERT) {
          throw new Error('Certificate pinning mismatch');
        }
        return undefined; // Use default verification
      }
    };
    
    https.get(options, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => resolve(JSON.parse(data)));
    }).on('error', reject);
  });
}

// Include token version in payload
const token = jwt.sign({
  sub: userId,
  tokenVersion: user.tokenVersion,  // Increment on password change
  iat: Math.floor(Date.now() / 1000)
}, secret);

// Verify token version matches user
async function verifyTokenVersion(token) {
  const decoded = jwt.verify(token, secret);
  const user = await db.users.findById(decoded.sub);
  
  if (!user || user.tokenVersion !== decoded.tokenVersion) {
    throw new Error('Token version mismatch - please re-authenticate');
  }
  
  return decoded;
}

// Increment version on password change or logout
async function invalidateUserTokens(userId) {
  await db.users.updateOne(
    { _id: userId },
    { $inc: { tokenVersion: 1 } }
  );
}

// Store IP address in token (optional, for additional security)
const token = jwt.sign({
  sub: userId,
  ip: req.ip  // Client IP at token issuance
}, secret);

// Verify IP matches (be careful with proxies/load balancers)
function verifyIP(token, req) {
  const decoded = jwt.verify(token, secret);
  const clientIP = req.headers['x-forwarded-for']?.split(',')[0] || req.ip;
  
  // Allow some flexibility for IP changes (mobile networks, VPNs)
  // Or make it optional for better UX
  if (decoded.ip && decoded.ip !== clientIP) {
    // Log suspicious activity
    logger.warn('IP mismatch', { tokenIP: decoded.ip, clientIP });
    // Optionally reject or require re-authentication
  }
  
  return decoded;
}

// Implement fine-grained permissions
const token = jwt.sign({
  sub: userId,
  scopes: ['read:users', 'write:posts'],  // Specific permissions
  roles: ['user']  // General roles
}, secret);

// Verify scope for specific action
function requireScope(token, requiredScope) {
  const decoded = jwt.verify(token, secret);
  
  if (!decoded.scopes || !decoded.scopes.includes(requiredScope)) {
    throw new Error(`Missing required scope: ${requiredScope}`);
  }
  
  return decoded;
}

// Use in routes
app.get('/api/users', requireScope('read:users'), (req, res) => {
  // Handler
});

// Principle of least privilege
// Only grant minimum required permissions

// Monitor token-related events
const logger = require('./logger');
const metrics = require('./metrics');

function logTokenEvent(event, details) {
  logger.info('Token Event', {
    event,
    timestamp: new Date().toISOString(),
    ...details
    // Never log the actual token
  });
  
  metrics.increment(`token.${event}`);
}

// Monitor suspicious activities
function detectAnomalies(token, req) {
  const decoded = jwt.decode(token);
  
  // Check for unusual patterns
  if (decoded.iat && Date.now() - decoded.iat * 1000 > 86400000) {
    logTokenEvent('old_token_used', { userId: decoded.sub });
  }
  
  // Check for multiple rapid requests
  const requestCount = getRequestCount(req.ip);
  if (requestCount > 1000) {
    logTokenEvent('high_request_rate', { ip: req.ip });
    // Alert security team
  }
  
  // Monitor failed verifications
  // Alert on brute force attempts
}

// Set up alerts for:
// - High rate of failed verifications
// - Unusual token usage patterns
// - Token from unexpected locations
// - Expired tokens being used