// HS256 — same secret for sign & verify
const token = jwt.sign({ sub: userId }, process.env.JWT_SECRET, { algorithm: 'HS256' });
jwt.verify(token, process.env.JWT_SECRET, { algorithms: ['HS256'] });

// RS256 — private key signs, public key verifies
const token = jwt.sign({ sub: userId }, privateKey, { algorithm: 'RS256' });
jwt.verify(token, publicKey, { algorithms: ['RS256'] }); // any service can do this

// Simple AuthContext pattern
const AuthContext = createContext(null);

export function AuthProvider({ children }) {
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(async () => {
    try {
      const res = await fetch('/api/auth/me', { credentials: 'include' });
      if (res.ok) setUser(await res.json());
    } finally { setLoading(false); }
  }, []);

  return (
    <AuthContext.Provider value={{ user, loading, setUser }}>
      {!loading && children}
    </AuthContext.Provider>
  );
}

import session from 'express-session';
import RedisStore from 'connect-redis';
import { createClient } from 'redis';

const redisClient = createClient({ url: process.env.REDIS_URL });
await redisClient.connect();

app.use(session({
  secret: process.env.SESSION_SECRET,  // long random string, rotate periodically
  resave: false,                         // don't save session if unmodified
  saveUninitialized: false,             // don't create session until data is set
  store: new RedisStore({ client: redisClient }),
  cookie: {
    httpOnly: true,                      // JS cannot read the cookie (XSS protection)
    secure: process.env.NODE_ENV === 'production', // HTTPS only in prod
    sameSite: 'lax',                     // CSRF protection for most cases
    maxAge: 24 * 60 * 60 * 1000          // 24 hours in milliseconds
  }
}));

// connect-redis v7+ (peer depends on redis v4)
import RedisStore from 'connect-redis';
import { createClient } from 'redis';

const client = createClient({ url: process.env.REDIS_URL });
client.on('error', err => console.error('Redis error:', err));
await client.connect();

// Pass into express-session store option
store: new RedisStore({ client, prefix: 'sess:' })

<!-- Victim visits attacker.com while logged in to yourbank.com -->
<form action="https://yourbank.com/transfer" method="POST">
  <input name="amount" value="10000">
  <input name="to" value="attacker-account">
</form>
<script>document.forms[0].submit();</script>
<!-- Browser auto-sends session cookie → bank sees valid authenticated request -->

import csrf from 'csrf';
const tokens = new csrf();

// Generate a secret per session, send token to client
app.get('/csrf-token', (req, res) => {
  if (!req.session.csrfSecret) req.session.csrfSecret = tokens.secretSync();
  res.json({ csrfToken: tokens.create(req.session.csrfSecret) });
});

// Verify on every mutating request
const verifyCsrf = (req, res, next) => {
  const token = req.headers['x-csrf-token'];
  if (!tokens.verify(req.session.csrfSecret, token))
    return res.status(403).json({ error: 'Invalid CSRF token' });
  next();
};

app.post('/auth/login', async (req, res) => {
  const { email, password, rememberMe } = req.body;
  const user = await User.findOne({ email });
  if (!user || !await bcrypt.compare(password, user.password))
    return res.status(401).json({ error: 'Invalid credentials' });

  req.session.userId = user._id;

  // Extend session lifetime based on "remember me" flag
  if (rememberMe) {
    req.session.cookie.maxAge = 30 * 24 * 60 * 60 * 1000; // 30 days
  } else {
    req.session.cookie.expires = false; // session cookie — gone on browser close
  }

  res.json({ user: { id: user._id, email: user.email } });
});

app.use(session({
  // ...other options...
  rolling: true,          // reset maxAge on every response
  cookie: { maxAge: 30 * 60 * 1000 }  // 30 min idle timeout
}));

// Redis TTL also needs refreshing — connect-redis handles this automatically
// when the session is saved (which rolling:true triggers)

app.post('/auth/logout', (req, res) => {
  // Step 1: Destroy the session record in Redis
  req.session.destroy(err => {
    if (err) return res.status(500).json({ error: 'Logout failed' });

    // Step 2: Clear the cookie from the browser
    res.clearCookie('connect.sid', {
      httpOnly: true,
      secure: process.env.NODE_ENV === 'production',
      sameSite: 'lax'
    });

    res.json({ message: 'Logged out successfully' });
  });
});

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9   ← Header
.eyJzdWIiOiI2NjQxYWJjZCIsInJvbGUiOiJ1c2VyIiwiZXhwIjoxNzE2MDAwMDAwfQ  ← Payload
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c   ← Signature

// POST /auth/login
app.post('/auth/login', async (req, res) => {
  const user = await User.findOne({ email: req.body.email });
  if (!user || !await bcrypt.compare(req.body.password, user.password))
    return res.status(401).json({ error: 'Invalid credentials' });

  const accessToken = jwt.sign(
    { sub: user._id, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '15m', algorithm: 'HS256' }
  );

  // Send as httpOnly cookie (safer than response body for web apps)
  res.cookie('accessToken', accessToken, {
    httpOnly: true, secure: true, sameSite: 'lax', maxAge: 15 * 60 * 1000
  });
  res.json({ user: { id: user._id, email: user.email, role: user.role } });
});

const authenticate = (req, res, next) => {
  try {
    // Support both cookie and Authorization header
    const token = req.cookies?.accessToken
      ?? req.headers.authorization?.replace('Bearer ', '');

    if (!token) return res.status(401).json({ error: 'No token' });

    req.user = jwt.verify(token, process.env.JWT_SECRET, {
      algorithms: ['HS256']   // always whitelist — prevents none attack
    });
    next();
  } catch {
    res.status(401).json({ error: 'Invalid or expired token' });
  }
};

// Usage
router.get('/profile', authenticate, (req, res) => res.json(req.user));

// tokenStore.js — module-level variable, invisible to injected scripts
let accessToken = null;
export const setToken  = t => accessToken = t;
export const getToken  = ()  => accessToken;
export const clearToken = () => accessToken = null;

app.post('/auth/refresh', async (req, res) => {
  const incomingToken = req.cookies?.refreshToken;
  if (!incomingToken) return res.status(401).json({ error: 'No refresh token' });

  // Look up the token in DB (stores hashed version)
  const storedToken = await RefreshToken.findOne({
    tokenHash: hash(incomingToken)
  });

  if (!storedToken) {
    // Token not found — either expired or already used
    // If it was used before, it may be a replay attack → revoke entire family
    const family = await RefreshToken.findOne({ tokenHash: hash(incomingToken), used: true });
    if (family) await RefreshToken.deleteMany({ familyId: family.familyId });
    return res.status(401).json({ error: 'Token reuse detected' });
  }

  // Mark old token as used
  await RefreshToken.findByIdAndUpdate(storedToken._id, { used: true });

  // Issue new access token + new refresh token (same family)
  const newAccessToken  = jwt.sign({ sub: storedToken.userId }, process.env.JWT_SECRET, { expiresIn: '15m' });
  const newRefreshToken = generateSecureToken(); // crypto.randomBytes(64).toString('hex')

  await RefreshToken.create({
    tokenHash: hash(newRefreshToken),
    userId: storedToken.userId,
    familyId: storedToken.familyId,  // same family for theft detection
    expiresAt: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000)
  });

  res.cookie('refreshToken', newRefreshToken, { httpOnly: true, secure: true, sameSite: 'lax' });
  res.json({ accessToken: newAccessToken });
});

const authenticate = async (req, res, next) => {
  try {
    const token = req.cookies?.accessToken;
    const decoded = jwt.verify(token, process.env.JWT_SECRET, { algorithms: ['HS256'] });

    // Check blocklist using jti claim
    const isBlocked = await redis.get(`blocklist:${decoded.jti}`);
    if (isBlocked) return res.status(401).json({ error: 'Token revoked' });

    req.user = decoded;
    next();
  } catch { res.status(401).json({ error: 'Invalid token' }); }
};

// On logout: add jti to blocklist with TTL = remaining token lifetime
const ttl = decoded.exp - Math.floor(Date.now() / 1000);
await redis.setEx(`blocklist:${decoded.jti}`, ttl, '1');

// Header (base64url-decoded)
{ "alg": "none", "typ": "JWT" }

// Payload — attacker puts whatever they want
{ "sub": "admin-user-id", "role": "admin", "exp": 9999999999 }

// Signature — empty string
""

// Resulting token: header.payload.  (trailing dot, no signature)
// Vulnerable server verifies with alg:none → accepts it as valid!

// ❌ Vulnerable — trusts whatever alg the token header says
jwt.verify(token, secret);

// ✅ Safe — explicitly whitelist the algorithm
jwt.verify(token, secret, { algorithms: ['HS256'] });

// ✅ Also safe for RS256
jwt.verify(token, publicKey, { algorithms: ['RS256'] });

// ✅ Minimal — only what downstream services need for auth decisions
const payload = {
  sub: user._id.toString(),   // identify the user
  role: user.role,             // needed for authorization
  iat: Math.floor(Date.now() / 1000),
  jti: crypto.randomUUID()   // unique ID for revocation
};

// ❌ Over-stuffed — exposes sensitive data
const badPayload = { sub: user._id, email: user.email,
  phone: user.phone, address: user.address, dob: user.dob };

import axios from 'axios';
import { getToken, setToken, clearToken } from './tokenStore';

let refreshPromise = null; // deduplication — only one refresh at a time

api.interceptors.request.use(config => {
  const token = getToken();
  if (token) config.headers.Authorization = `Bearer ${token}`;
  return config;
});

api.interceptors.response.use(
  res => res,
  async err => {
    const original = err.config;
    if (err.response?.status === 401 && !original._retry) {
      original._retry = true;
      try {
        // Multiple concurrent 401s → only one refresh call
        if (!refreshPromise) {
          refreshPromise = api.post('/auth/refresh', {}, { withCredentials: true })
            .finally(() => refreshPromise = null);
        }
        const { data } = await refreshPromise;
        setToken(data.accessToken);          // store new token in memory
        return api(original);              // retry original request
      } catch {
        clearToken();
        window.location.assign('/login');  // refresh failed — re-login
      }
    }
    return Promise.reject(err);
  }
);

// Step 1 & 2 — generate verifier + challenge
const verifier = crypto.randomBytes(64).toString('base64url');
const challenge = crypto.createHash('sha256').update(verifier).digest('base64url');
sessionStorage.setItem('pkce_verifier', verifier); // store for callback

// Step 3 — build authorization URL
const authUrl = new URL('https://accounts.google.com/o/oauth2/auth');
authUrl.searchParams.set('client_id', CLIENT_ID);
authUrl.searchParams.set('code_challenge', challenge);
authUrl.searchParams.set('code_challenge_method', 'S256');
authUrl.searchParams.set('response_type', 'code');
window.location.href = authUrl.toString();

// Step 4 — token exchange in callback
const verifier = sessionStorage.getItem('pkce_verifier');
await fetch('/auth/google/token', {
  method: 'POST',
  body: JSON.stringify({ code, code_verifier: verifier })
});

import { OAuth2Client } from 'google-auth-library';
const client = new OAuth2Client(process.env.GOOGLE_CLIENT_ID);

async function verifyGoogleIdToken(idToken) {
  const ticket = await client.verifyIdToken({
    idToken,
    audience: process.env.GOOGLE_CLIENT_ID  // verify aud claim
  });
  const { sub, email, email_verified, name, picture } = ticket.getPayload();

  // Only trust verified emails
  if (!email_verified) throw new Error('Email not verified by Google');
  return { googleId: sub, email, name, picture };
}

import passport from 'passport';
import { Strategy as GoogleStrategy } from 'passport-google-oauth20';

passport.use(new GoogleStrategy({
  clientID:     process.env.GOOGLE_CLIENT_ID,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET,
  callbackURL:  '/auth/google/callback',
  scope: ['openid', 'email', 'profile']
}, async (accessToken, refreshToken, profile, done) => {
  try {
    // Upsert user by Google ID
    let user = await User.findOne({ googleId: profile.id });
    if (!user) {
      user = await User.create({
        googleId: profile.id,
        email:    profile.emails[0].value,
        name:     profile.displayName,
        avatar:   profile.photos[0]?.value
      });
    }
    done(null, user);
  } catch (err) { done(err); }
}));

// Initiate OAuth flow
router.get('/auth/google',
  passport.authenticate('google', { scope: ['openid', 'email', 'profile'] })
);

// Handle callback from Google
router.get('/auth/google/callback',
  passport.authenticate('google', { session: false, failureRedirect: '/login' }),
  (req, res) => {
    // req.user is the Mongoose user from the strategy callback
    const accessToken = jwt.sign(
      { sub: req.user._id, role: req.user.role },
      process.env.JWT_SECRET,
      { expiresIn: '15m' }
    );
    res.cookie('accessToken', accessToken, { httpOnly: true, secure: true, sameSite: 'lax' });
    res.redirect('http://localhost:3000/dashboard'); // redirect to React app
  }
);

// Before redirect — store state in session
app.get('/auth/google', (req, res) => {
  const state = crypto.randomBytes(16).toString('hex');
  req.session.oauthState = state;

  const url = `https://accounts.google.com/o/oauth2/auth?`
    + new URLSearchParams({ client_id, redirect_uri, state: state,
        scope: 'openid email', response_type: 'code' });
  res.redirect(url);
});

// In callback — verify state before doing anything
app.get('/auth/google/callback', (req, res) => {
  if (req.query.state !== req.session.oauthState)
    return res.status(403).json({ error: 'State mismatch — possible CSRF' });

  delete req.session.oauthState; // consume it — single use
  // proceed with token exchange...
});

const userSchema = new Schema({
  email:    { type: String, unique: true, sparse: true },
  password: String,   // null for OAuth-only users
  providers: [{
    provider:   { type: String, enum: ['google', 'github', 'facebook'] },
    providerId: String,  // stable ID from the OAuth provider
    linkedAt:   { type: Date, default: Date.now }
  }]
});

// Find user by provider ID or verified email
const findOrCreateOAuthUser = async ({ provider, providerId, email, emailVerified }) => {
  // 1. Look up by provider ID first (most reliable)
  let user = await User.findOne({ 'providers.providerId': providerId });
  if (user) return user;

  // 2. Link to existing account by verified email
  if (emailVerified && email) {
    user = await User.findOne({ email });
    if (user) {
      user.providers.push({ provider, providerId });
      return user.save();
    }
  }

  // 3. Create new account
  return User.create({ email: emailVerified ? email : undefined, providers: [{ provider, providerId }] });
};

import crypto from 'crypto';

// Generate a secure, URL-safe API key
const generateApiKey = () => {
  const raw = crypto.randomBytes(32).toString('base64url');
  return `sk_live_${raw}`; // prefix helps users identify key type
};

// NEVER store the raw key — store a SHA-256 hash
const hashKey = key =>
  crypto.createHash('sha256').update(key).digest('hex');

// On key creation — show raw key ONCE, store hash
const createApiKey = async (userId) => {
  const rawKey = generateApiKey();
  await ApiKey.create({
    keyHash:   hashKey(rawKey),
    prefix:    rawKey.slice(0, 12),  // store prefix for display ("sk_live_ab12…")
    userId,
    scopes:    ['read'],
    createdAt: new Date()
  });
  return rawKey; // return raw key to user — this is the only time it's visible
};

const validateApiKey = async (req, res, next) => {
  const key = req.headers['x-api-key'] ?? req.headers.authorization?.replace('Bearer ', '');
  if (!key) return res.status(401).json({ error: 'API key required' });

  const apiKey = await ApiKey.findOne({ keyHash: hashKey(key), revokedAt: null });
  if (!apiKey) return res.status(401).json({ error: 'Invalid API key' });

  req.apiKey = apiKey;
  next();
};

app.get('/auth/verify', async (req, res) => {
  const { token, email } = req.query;
  if (!token || !email) return res.status(400).send('Invalid link');

  const tokenHash = crypto.createHash('sha256').update(token).digest('hex');
  const record = await MagicToken.findOne({
    tokenHash: tokenHash,
    email,
    expiresAt: { $gt: new Date() }  // not expired
  });

  if (!record) return res.status(401).send('Link expired or already used');

  await MagicToken.deleteOne({ _id: record._id }); // single-use

  const accessToken = jwt.sign({ sub: record.userId }, process.env.JWT_SECRET, { expiresIn: '15m' });
  res.cookie('accessToken', accessToken, { httpOnly: true, secure: true, sameSite: 'lax' });
  res.redirect('/dashboard');
});

import speakeasy from 'speakeasy';
import QRCode from 'qrcode';

// Step 1: Generate a secret for the user during 2FA setup
app.post('/auth/2fa/setup', authenticate, async (req, res) => {
  const secret = speakeasy..generateSecret({
    name: `YourApp (${req.user.email})`,
    length: 20
  });

  // Store PENDING secret (not active until user confirms first code)
  await User.findByIdAndUpdate(req.user.sub, {
    twoFactorSecretPending: secret.base32  // encrypt this at rest
  });

  const qrDataUrl = await QRCode.toDataURL(secret.otpauth_url);
  res.json({ qrCode: qrDataUrl, manualKey: secret.base32 });
});

// Step 2: User scans QR code, enters first TOTP to confirm setup
app.post('/auth/2fa/verify-setup', authenticate, async (req, res) => {
  const user = await User.findById(req.user.sub);
  const valid = speakeasy.totp.verify({
    secret: user.twoFactorSecretPending,
    encoding: 'base32',
    token: req.body.code,
    window: 1   // accept ±1 time step for clock skew
  });
  if (!valid) return res.status(400).json({ error: 'Invalid code' });

  // Promote pending secret to active, generate backup codes
  const backupCodes = Array.from({ length: 8 }, () =>
    crypto.randomBytes(4).toString('hex')
  );
  await User.findByIdAndUpdate(req.user.sub, {
    twoFactorSecret: user.twoFactorSecretPending,
    twoFactorEnabled: true,
    twoFactorBackupCodes: backupCodes.map(hashKey),
    $unset: { twoFactorSecretPending: '' }
  });
  res.json({ backupCodes }); // show once — user must save these
});

Authorization: Basic dXNlcjpwYXNzd29yZA==
// Base64("user:password") — trivially reversible, NOT encryption

import https from 'https';
import fs from 'fs';

const server = https.createServer({
  key:  fs.readFileSync('server-key.pem'),
  cert: fs.readFileSync('server-cert.pem'),
  ca:   fs.readFileSync('ca-cert.pem'),  // internal CA that signs client certs
  requestCert: true,     // require client certificate
  rejectUnauthorized: true  // reject if cert isn't signed by our CA
}, app);

// Access client cert info in middleware
app.use((req, res, next) => {
  const cert = req.socket.getPeerCertificate();
  req.clientService = cert.subject.CN; // e.g. "payment-service"
  next();
});

const bcrypt = require('bcryptjs');

const SALT_ROUNDS = 12;   // 10 minimum; 12–14 for high-security apps
const hashPassword   = (p) => bcrypt.hash(p, SALT_ROUNDS);
const verifyPassword = (p, h) => bcrypt.compare(p, h);

// Mongoose pre-save hook
userSchema.pre('save', async function(next) {
  if (!this.isModified('password')) return next();
  this.password = await hashPassword(this.password);  next();
});
userSchema.methods.comparePassword = function(candidate) {
  return bcrypt.compare(candidate, this.password);
};

const argon2 = require('argon2');

const hash  = await argon2.hash(plaintext, {
  type:        argon2.argon2id,  // hybrid, recommended
  memoryCost:  2 ** 16,         // 64 MB
  timeCost:    3,
  parallelism: 1,
});
const valid = await argon2.verify(hash, plaintext);

const rateLimit  = require('express-rate-limit');
const RedisStore = require('rate-limit-redis');
const { createClient } = require('redis');

const redisClient = createClient({ url: process.env.REDIS_URL });
await redisClient.connect();

const loginLimiter = rateLimit({
  windowMs:              15 * 60 * 1000,
  max:                   10,
  standardHeaders:       true,
  legacyHeaders:         false,
  store: new RedisStore({ sendCommand: (...args) => redisClient.sendCommand(args) }),
  keyGenerator: (req) => req.body?.email
    ? `login:${req.body.email.toLowerCase()}`   // key by email (account-level)
    : req.ip,
  skipSuccessfulRequests: true,
  handler: (req, res) => res.status(429).json({
    error: 'Too many login attempts. Try again in 15 minutes.',
  }),
});

app.use('/api/', rateLimit({ windowMs: 60000, max: 100,
  store: new RedisStore({ sendCommand: (...args) => redisClient.sendCommand(args) }) }));
app.post('/api/auth/login', loginLimiter, loginController);
app.post('/api/auth/forgot-password',
  rateLimit({ windowMs: 3600000, max: 5 }), forgotController);

const helmet = require('helmet');
app.use(helmet());  // sensible defaults for all 15 headers

app.use(helmet.contentSecurityPolicy({
    directives: {
      "'self'", "https://cdn.jsdelivr.net"],
      styleSrc:   ["'self'", "'unsafe-inline'"],
      imgSrc:     ["'self'", "data:", "https:"],
      connectSrc: ["'self'"],
      objectSrc:  ["'none'"],
      upgradeInsecureRequests: [],
    },
  }));

server {
  listen 80;
  return 301 https://$host$request_uri;
}
server {
  listen 443 ssl http2;
  ssl_protocols  TLSv1.2 TLSv1.3;
  ssl_ciphers    HIGH:!aNULL:!MD5;
  add_header Strict-Transport-Security
    "max-age=31536000; includeSubDomains; preload" always;
}

// Required when behind Nginx/ALB
app.set('trust proxy', 1);

// Redirect HTTP → HTTPS
app.use((req, res, next) => {
  if (req.secure || req.headers['x-forwarded-proto'] === 'https') return next();
  res.redirect(301, `https://${req.headers.host}${req.url}`);
});

// HSTS — browser never tries HTTP again for 1 year
app.use(helmet.hsts({ maxAge: 31536000, includeSubDomains: true, preload: true }));

// SAFE — React escapes HTML entities automatically
const name = "<script>alert(1)</script>";
return <div>{name}</div>;  // renders as text, not a live script

// DANGEROUS — bypasses React's escaping; only use with sanitized content
return <div dangerouslySetInnerHTML={{ __html: userContent }} />;

// Client — sanitize before rendering rich HTML
import DOMPurify from 'dompurify';
const clean = DOMPurify.sanitize(userHtml, {
  ALLOWED_TAGS: ['b', 'i', 'a', 'p'],
  ALLOWED_ATTR: ['href'],
  FORBID_ATTR:  ['onclick', 'onerror'],
});
return <div dangerouslySetInnerHTML={{ __html: clean }} />;

// Server — strip HTML from all plain-text body fields
const sanitizeHtml = require('sanitize-html');
app.use((req, res, next) => {
  if (req.body) {
    for (const key of Object.keys(req.body)) {
      if (typeof req.body[key] === 'string')
        req.body[key] = sanitizeHtml(req.body[key], { allowedTags: [], allowedAttributes: {} });
    }
  }
  next();
});

async function login(req, res) {
  const { email, password } = req.body;
  const key      = `login_fail:${email.toLowerCase()}`;
  const failures = Number(await redis.get(key)) || 0;

  if (failures >= 10)
    return res.status(429).json({ error: 'Account temporarily locked. Try again in 15 minutes.' });

  const user  = await User.findOne({ email });
  const valid = user && await user.comparePassword(password);

  if (!valid) {
    const count = await redis.incr(key);
    if (count === 1) await redis.expire(key, 15 * 60);
    // Exponential delay: 0 / 0 / 0 / 500ms / 1s / 2s / 4s / 8s / 16s…
    const delay = count > 3 ? Math.min(500 * 2 ** (count - 4), 16_000) : 0;
    await new Promise(r => setTimeout(r, delay));
    return res.status(401).json({ error: 'Invalid credentials' });
  }

  await redis.del(key);  // Success — reset counter
}

res.cookie('sessionId', sid, {
  httpOnly: true,
  secure:   true,    // required for SameSite=None
  sameSite: 'lax',   // 'strict' | 'lax' | 'none'
  maxAge:   24 * 60 * 60 * 1000,
});
app.use(session({
  cookie: { sameSite: 'lax', secure: process.env.NODE_ENV === 'production', httpOnly: true },
}));

<!-- Attacker's page: victim is logged into bank.com -->
<form action="https://bank.com/transfer" method="POST">
  <input name="amount" value="10000" />
</form>
<!-- SameSite=Strict → cookie NOT sent → bank.com sees no session → BLOCKED ✓ -->
<!-- SameSite=Lax    → cookie NOT sent (POST) → BLOCKED ✓                      -->
<!-- SameSite=None   → cookie IS sent → CSRF succeeds without CSRF token ✗      -->

const crypto = require('crypto');

// Step 1: issue token — silent if email not found
async function requestReset(email) {
  const user = await User.findOne({ email });
  if (!user) return;

  const rawToken  = crypto.randomBytes(32).toString('hex');
  const tokenHash = crypto.createHash('sha256').update(rawToken).digest('hex');
  const expiresAt = new Date(Date.now() + 3600000);  // 1 hour

  await PasswordReset.deleteMany({ userId: user._id });
  await PasswordReset.create({ userId: user._id, tokenHash, expiresAt });
  await sendEmail(email, `https://app.com/reset?token=${rawToken}`);  // send RAW token
}

// Step 2: consume token
async function resetPassword(rawToken, newPassword) {
  const hash   = crypto.createHash('sha256').update(rawToken).digest('hex');
  const record = await PasswordReset.findOne({
    tokenHash: hash, expiresAt: { $gt: new Date() },
  }).populate('userId');

  if (!record) throw new Error('Invalid or expired token');
  record.userId.password = newPassword;
  await record.userId.save();
  await PasswordReset.deleteOne({ _id: record._id });  // single-use
  await invalidateAllSessions(record.userId._id);
}

const jwt = require('jsonwebtoken');
const JWT_SECRET         = process.env.JWT_SECRET;
const ALLOWED_ALGORITHMS = ['HS256'];  // explicit allowlist

function authenticate(req, res, next) {
  const header = req.headers.authorization;
  if (!header?.startsWith('Bearer '))
    return res.status(401).json({ error: 'Missing Authorization header' });

  try {
    const payload = jwt.verify(header.slice(7), JWT_SECRET, {
      algorithms: ALLOWED_ALGORITHMS,   // ← CRITICAL: blocks 'none' attack
      issuer:     'yourdomain.com',
      audience:   'yourdomain.com',
    });
    req.user = { id: payload.sub, email: payload.email, role: payload.role };
    next();
  } catch (err) {
    if (err.name === 'TokenExpiredError')
      return res.status(401).json({ error: 'Token expired', code: 'TOKEN_EXPIRED' });
    if (err.name === 'JsonWebTokenError')
      return res.status(401).json({ error: 'Invalid token' });
    next(err);
  }
}

// 1. Rotate JWT secret — all existing tokens become invalid instantly
//    Deploy new JWT_SECRET env var + restart servers

// 2. Invalidate all sessions in Redis
await redis.flushdb();

// 3. Per-user token versioning (graceful)
await User.updateMany({}, { $inc: { tokenVersion: 1 } });
// Middleware: if (payload.ver !== user.tokenVersion) → 401

// 4. Force password reset for affected accounts
await User.updateMany(
  { _id: { $in: affectedUserIds } },
  { $set: { forcePasswordReset: true } }
);

const { createHash } = require('crypto');
const axios = require('axios');

async function isBreachedPassword(password) {
  const sha1   = createHash('sha1').update(password).digest('hex').toUpperCase();
  const prefix = sha1.slice(0, 5);
  const { data } = await axios.get(`https://api.pwnedpasswords.com/range/${prefix}`,
    { headers: { 'Add-Padding': 'true' } });
  return data.split('\r\n').some(line => line.startsWith(sha1.slice(5)));
}

if (await isBreachedPassword(newPassword))
  return res.status(400).json({ error: 'Password appears in known data breaches.' });

// Mongoose User schema
const userSchema = new Schema({
  email:    String,
  password: String,
  role:     { type: String, enum: ['user', 'moderator', 'admin'], default: 'user' },
});

// Embed role in JWT at login
const token = jwt.sign(
  { sub: user._id, email: user.email, role: user.role },
  process.env.JWT_SECRET,
  { expiresIn: '15m', issuer: 'yourdomain.com' }
);

// requireRole middleware — composable, variadic
const requireRole = (...roles) => (req, res, next) => {
  if (!roles.includes(req.user?.role))
    return res.status(403).json({ error: 'Insufficient permissions' });
  next();
};

// Usage
app.get('/api/users',         authenticate, requireRole('admin'),                  listUsers);
app.delete('/api/posts/:id', authenticate, requireRole('admin', 'moderator'), deletePost);
app.get('/api/profile',      authenticate,                                          getProfile);

// ABAC: combine user attributes + resource attributes + context
function canEditPost(user, post, context = {}) {
  const isOwner    = post.authorId.equals(user._id);
  const isAdmin    = user.role === 'admin';
  const within24h  = (Date.now() - post.createdAt) < 86_400_000;
  const notLocked  = !post.locked;

  if (isAdmin)                return true;
  if (isOwner && within24h && notLocked) return true;
  return false;
}

// In route handler
const post = await Post.findById(req.params.id);
if (!canEditPost(req.user, post))
  return res.status(403).json({ error: 'Not authorized to edit this post' });

// ❌ VULNERABLE — returns any order if user is authenticated
app.get('/api/orders/:id', authenticate, async (req, res) => {
  const order = await Order.findById(req.params.id);  // no ownership check!
  res.json(order);
});

// ✓ SAFE — scopes query to the authenticated user
app.get('/api/orders/:id', authenticate, async (req, res) => {
  const order = await Order.findOne({
    _id:    req.params.id,
    userId: req.user.id,   // ownership enforced at query level
  });
  if (!order) return res.status(404).json({ error: 'Not found' });
  // Return 404, not 403 — don't confirm the resource exists
  res.json(order);
});

// Admin override — can see any order
app.get('/api/admin/orders/:id', authenticate, requireRole('admin'), async (req, res) => {
  const order = await Order.findById(req.params.id);
  res.json(order);
});

// Generic middleware factory — works for any Mongoose model
const ownsResource = (Model, ownerField = 'userId') => async (req, res, next) => {
  const doc = await Model.findById(req.params.id).lean();
  if (!doc) return res.status(404).json({ error: 'Not found' });
  if (req.user.role === 'admin')  return next();   // admin bypass
  if (!doc[ownerField].equals(req.user.id))
    return res.status(404).json({ error: 'Not found' });
  req.resource = doc;
  next();
};

app.delete('/api/posts/:id', authenticate, ownsResource(Post), deletePostHandler);
app.put('/api/comments/:id', authenticate, ownsResource(Comment), updateCommentHandler);

const speakeasy = require('speakeasy');
const QRCode    = require('qrcode');

// Step 1: generate secret — store as pending until user confirms
const secret = speakeasy.generateSecret({
  name: `MyApp (${user.email})`,
  length: 20,
});
await User.findByIdAndUpdate(user._id, { mfaPendingSecret: secret.base32 });
const qrDataUrl = await QRCode.toDataURL(secret.otpauth_url);
res.json({ qrDataUrl });   // client renders as <img src={qrDataUrl} />

// Step 2: confirm TOTP code (verify before saving as active)
const verified = speakeasy.totp.verify({
  secret:   user.mfaPendingSecret,
  encoding: 'base32',
  token:    req.body.code,
  window:   1,   // allow 1 interval (30s) clock drift
});
if (!verified) return res.status(400).json({ error: 'Invalid code' });
await User.findByIdAndUpdate(user._id, {
  mfaSecret:        user.mfaPendingSecret,
  mfaEnabled:       true,
  mfaPendingSecret: null,
  backupCodes:      generateBackupCodes(10),   // hashed one-time codes
});

// MongoDB schema
const refreshTokenSchema = new Schema({
  tokenHash: { type: String, required: true, unique: true },
  family:    { type: String, required: true },   // UUID shared by all tokens in lineage
  userId:    { type: ObjectId, ref: 'User' },
  used:      { type: Boolean, default: false },
  expiresAt: Date,
});

// Refresh endpoint
async function refreshTokens(req, res) {
  const rawToken = req.cookies.refreshToken;
  const hash     = sha256(rawToken);
  const record   = await RefreshToken.findOne({ tokenHash: hash });

  if (!record) return res.status(401).json({ error: 'Invalid token' });

  if (record.used) {
    // ⚠️  Reuse detected — token was already used → theft likely
    // Revoke entire family to log out attacker AND legitimate user
    await RefreshToken.deleteMany({ family: record.family });
    return res.status(401).json({ error: 'Token reuse detected. Please log in again.' });
  }

  if (record.expiresAt < new Date())
    return res.status(401).json({ error: 'Refresh token expired' });

  // Mark old token as used
  record.used = true;
  await record.save();

  // Issue new token in the same family
  const newRawToken = crypto.randomBytes(64).toString('base64url');
  await RefreshToken.create({
    tokenHash: sha256(newRawToken),
    family:    record.family,   // same family
    userId:    record.userId,
    expiresAt: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
  });

  const newAccessToken = issueAccessToken(record.userId);
  res.cookie('refreshToken', newRawToken, { httpOnly: true, secure: true, sameSite: 'strict' });
  res.json({ accessToken: newAccessToken });
}

const { Strategy: SamlStrategy } = require('passport-saml');

passport.use(new SamlStrategy({
  entryPoint:  process.env.SAML_ENTRY_POINT,   // IdP SSO URL
  issuer:      'https://yourdomain.com',      // SP entity ID
  callbackUrl: 'https://yourdomain.com/auth/saml/callback',
  cert:        process.env.SAML_CERT,          // IdP public cert for signature verification
  wantAssertionsSigned: true,
}, async (profile, done) => {
  // profile.nameID = user's email / unique ID from IdP
  let user = await User.findOne({ samlId: profile.nameID });
  if (!user) {
    user = await User.create({
      samlId: profile.nameID,
      email:  profile.email || profile.nameID,
      role:   'user',
    });
  }
  return done(null, user);
}));

app.get('/auth/saml',          passport.authenticate('saml'));
app.post('/auth/saml/callback', passport.authenticate('saml'), (req, res) => {
  const token = issueJWT(req.user);
  res.redirect(`${process.env.CLIENT_URL}/auth/callback?token=${token}`);
});

// 1. Short-lived access tokens (15 min max)
const accessToken = jwt.sign({ sub: user._id, role: user.role },
  JWT_SECRET, { expiresIn: '15m' });

// 2. Scoped tokens — token can only call specific endpoints
const exportToken = jwt.sign({
  sub:   user._id,
  scope: 'export:csv',   // single-purpose token
}, JWT_SECRET, { expiresIn: '5m' });
// Middleware: if (!payload.scope?.includes('export:csv')) → 403

// 3. Step-up auth — re-verify for high-value actions
const requireFreshAuth = (maxAgeSeconds = 300) => (req, res, next) => {
  const issuedAt = req.user.iat * 1000;
  if (Date.now() - issuedAt > maxAgeSeconds * 1000)
    return res.status(401).json({ error: 'Re-authentication required', code: 'STALE_TOKEN' });
  next();
};
app.delete('/api/account', authenticate, requireFreshAuth(60), deleteAccount);

// 4. Service-to-service mTLS (handled at Nginx/Istio layer)
//    Express sees req.client.authorized === true when client cert is valid
app.use((req, res, next) => {
  if (!req.client.authorized) return res.status(401).end();
  next();
});

// Permission registry — define all possible permissions
const PERMISSIONS = {
  'posts:read':       true,
  'posts:create':     true,
  'posts:delete:own': true,    // user can delete only their own
  'posts:delete:any': true,    // admin/moderator can delete anyone's
  'users:read':       true,
  'users:ban':        true,
};

// Role → permission mapping
const ROLE_PERMISSIONS = {
  user:      ['posts:read', 'posts:create', 'posts:delete:own'],
  moderator: ['posts:read', 'posts:create', 'posts:delete:any', 'users:read'],
  admin:     Object.keys(PERMISSIONS),   // all permissions
};

function hasPermission(role, permission) {
  return ROLE_PERMISSIONS[role]?.includes(permission) ?? false;
}

// Middleware factory
const requirePermission = (permission) => (req, res, next) => {
  if (!hasPermission(req.user?.role, permission))
    return res.status(403).json({ error: `Requires permission: ${permission}` });
  next();
};

// Usage
app.post('/api/posts',        authenticate, requirePermission('posts:create'),     createPost);
app.delete('/api/posts/:id', authenticate, requirePermission('posts:delete:any'), deletePost);
app.post('/api/users/:id/ban',authenticate, requirePermission('users:ban'),         banUser);

// Auth server — introspection endpoint (RFC 7662)
app.post('/oauth/introspect', async (req, res) => {
  const { token } = req.body;
  try {
    const payload = jwt.verify(token, JWT_SECRET, { algorithms: ['HS256'] });
    const revoked = await RevokedToken.exists({ jti: payload.jti });
    if (revoked) return res.json({ active: false });
    res.json({
      active:    true,
      sub:       payload.sub,
      exp:       payload.exp,
      scope:     payload.scope,
    });
  } catch {
    res.json({ active: false });
  }
});

// Resource server — call introspect for high-value endpoints
async function introspectMiddleware(req, res, next) {
  const token = req.headers.authorization?.slice(7);
  const { data } = await axios.post('https://auth.yourdomain.com/oauth/introspect',
    { token }, { auth: { username: CLIENT_ID, password: CLIENT_SECRET } });
  if (!data.active)
    return res.status(401).json({ error: 'Token is inactive or revoked' });
  req.user = { id: data.sub };  next();
}

// Use introspect only where revocation matters
app.post('/api/payments', introspectMiddleware, processPayment);
app.get('/api/feed',     authenticate,          getFeed);         // local verify is fine

// middleware/auth.js — single import surface
module.exports = {
  authenticate,          // verify JWT, populate req.user
  requireRole,           // role check
  requirePermission,     // permission string check
  ownsResource,          // object-level ownership
  requireFreshAuth,      // ZT step-up (token age check)
  loginLimiter,          // rate limiter for login
  auditLog,              // write to audit collection
};

// Usage — layers run left to right, short-circuit on error
app.post('/api/auth/login',
  loginLimiter,          // 1. Rate limit BEFORE authentication
  loginController
);

app.get('/api/posts',
  authenticate,          // 2. Verify JWT, set req.user
  requirePermission('posts:read'),  // 3. Check permission
  getPosts
);

app.delete('/api/posts/:id',
  authenticate,
  requirePermission('posts:delete:own'),
  ownsResource(Post),   // 4. Verify ownership (IDOR check)
  auditLog,              // 5. Write audit trail
  deletePost
);

app.delete('/api/account',
  authenticate,
  requireFreshAuth(60), // ZT: token must be < 60s old
  auditLog,
  deleteAccount
);

// Centralized error handler — catches 401/403 from all middleware
app.use((err, req, res, next) => {
  if (err.status) return res.status(err.status).json({ error: err.message });
  console.error(err);
  res.status(500).json({ error: 'Internal server error' });
});

async function login(req, res) {
  const user = await User.findOne({ email: req.body.email });
  if (!user || !await user.comparePassword(req.body.password))
    return res.status(401).json({ error: 'Invalid credentials' });

  // Access token — short-lived, returned in body
  const accessToken = jwt.sign(
    { sub: user._id, email: user.email, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: '15m', issuer: 'yourdomain.com' }
  );

  // Refresh token — long-lived, HttpOnly cookie
  const rawRefresh = crypto.randomBytes(64).toString('base64url');
  await RefreshToken.create({
    tokenHash: sha256(rawRefresh),
    userId:    user._id,
    family:    crypto.randomUUID(),
    expiresAt: new Date(Date.now() + 30 * 86_400_000),
  });

  res.cookie('refreshToken', rawRefresh, {
    httpOnly: true, secure: true, sameSite: 'strict',
    maxAge: 30 * 86_400_000,
  });
  res.json({ accessToken, user: { id: user._id, email: user.email, role: user.role } });
}

import { Navigate, Outlet, useLocation } from 'react-router-dom';
import { useAuth } from './AuthContext';

// Base auth guard — redirects to /login if not authenticated
export function RequireAuth() {
  const { user, loading } = useAuth();
  const location = useLocation();

  if (loading) return <div>Loading…</div>;  // wait for initial auth check
  if (!user)   return <Navigate to="/login" state={{ from: location }} replace />;
  return <Outlet />;
}

// Role guard — renders 403 if user lacks required role
export function RequireRole({ roles }) {
  const { user } = useAuth();
  if (!roles.includes(user?.role)) return <Navigate to="/403" replace />;
  return <Outlet />;
}

// Router setup
<Routes>
  <Route path="/login"    element={<LoginPage />} />
  <Route path="/register" element={<RegisterPage />} />

  <Route element={<RequireAuth />}>               {/* all below require login */}
    <Route path="/"        element={<Dashboard />} />
    <Route path="/profile" element={<Profile />} />

    <Route element={<RequireRole roles={['admin']} />}>  {/* admin only */}
      <Route path="/admin"  element={<AdminPanel />} />
    </Route>
  </Route>
</Routes>

import axios from 'axios';

const api = axios.create({ baseURL: '/api', withCredentials: true });

let accessToken   = null;              // stored in module scope (memory)
let refreshPromise = null;             // deduplication lock

export const setAccessToken = (t) => { accessToken = t; };

// Request interceptor — attach token
api.interceptors.request.use((config) => {
  if (accessToken) config.headers.Authorization = `Bearer ${accessToken}`;
  return config;
});

// Response interceptor — handle 401
api.interceptors.response.use(
  (res) => res,
  async (error) => {
    const original = error.config;
    const is401    = error.response?.status === 401;
    const isExpiry = error.response?.data?.code === 'TOKEN_EXPIRED';

    if (!is401 || !isExpiry || original._retry) return Promise.reject(error);

    original._retry = true;  // prevent infinite retry loop

    try {
      // Deduplication: reuse an in-flight refresh for concurrent expired requests
      if (!refreshPromise) {
        refreshPromise = axios
          .post('/api/auth/refresh', {}, { withCredentials: true })
          .then(({ data }) => {
            setAccessToken(data.accessToken);
            return data.accessToken;
          })
          .finally(() => { refreshPromise = null; });
      }

      const newToken = await refreshPromise;
      original.headers.Authorization = `Bearer ${newToken}`;
      return api(original);   // retry original request with new token

    } catch {
      setAccessToken(null);
      window.location.replace('/login');  // refresh failed → force logout
      return Promise.reject(error);
    }
  }
);

// Server: login response
res.cookie('refreshToken', rawRefresh, {
  httpOnly: true, secure: true, sameSite: 'strict',
  maxAge: 30 * 86_400_000,
});
res.json({ accessToken });   // short-lived JWT in response body

// Client: store access token in module scope (not localStorage)
let _accessToken = null;
export const setToken = (t) => { _accessToken = t; };
export const getToken = ()  => _accessToken;

// On page reload — silently restore from cookie
async function restoreSession() {
  try {
    const { data } = await axios.post('/api/auth/refresh', {}, { withCredentials: true });
    setToken(data.accessToken);
    return data.user;
  } catch {
    return null;  // no valid cookie → user not logged in
  }
}

import { createContext, useContext, useReducer, useEffect } from 'react';
import { setToken, restoreSession } from './api';

const AuthContext = createContext(null);

const authReducer = (state, action) => {
  switch (action.type) {
    case 'INIT':   return { ...state, user: action.user,  loading: false };
    case 'LOGIN':  return { ...state, user: action.user };
    case 'LOGOUT': return { user: null, loading: false };
    default:      return state;
  }
};

export function AuthProvider({ children }) {
  const [state, dispatch] = useReducer(authReducer, { user: null, loading: true });

  useEffect(() => {
    // Silently restore session on every page load
    restoreSession().then((user) => dispatch({ type: 'INIT', user }));
  }, []);

  const login = (user, token) => {
    setToken(token);
    dispatch({ type: 'LOGIN', user });
  };

  const logout = async () => {
    await api.post('/auth/logout');   // clears server-side cookie
    setToken(null);
    dispatch({ type: 'LOGOUT' });
  };

  return (
    <AuthContext.Provider value={{ ...state, login, logout }}>
      {state.loading ? <SplashScreen /> : children}
    </AuthContext.Provider>
  );
}

export const useAuth = () => useContext(AuthContext);

// auth.ts
import NextAuth from 'next-auth';
import Google  from 'next-auth/providers/google';
import Credentials from 'next-auth/providers/credentials';

export const { handlers, auth, signIn, signOut } = NextAuth({
  providers: [
    Google({ clientId: process.env.GOOGLE_ID, clientSecret: process.env.GOOGLE_SECRET }),
    Credentials({
      async authorize({ email, password }) {
        const user = await verifyCredentials(email, password);
        return user ?? null;
      },
    }),
  ],
  callbacks: {
    async session({ session, token }) {
      session.user.id   = token.sub;
      session.user.role = token.role;
      return session;
    },
    async jwt({ token, user }) {
      if (user) token.role = user.role;
      return token;
    },
  },
});

// middleware.ts — protect routes at the edge (runs before page renders)
import { auth } from './auth';
export default auth;
export const config = { matcher: ['/dashboard/:path*', '/admin/:path*'] };

// Server component — read session without useEffect or loading state
export default async function DashboardPage() {
  const session = await auth();  // direct session access, no API call
  if (!session) redirect('/login');
  return <Dashboard user={session.user} />;
}

const cors = require('cors');

app.use(cors({
  origin:      process.env.CLIENT_URL,  // exact origin — NOT '*' with credentials
  credentials: true,                   // allows cookies to be sent cross-origin
  methods:     ['GET', 'POST', 'PUT', 'DELETE'],
  allowedHeaders: ['Content-Type', 'Authorization'],
}));

const jwt = require('jsonwebtoken');
const { authenticate } = require('../middleware/auth');

const mockRes = () => ({ status: jest.fn().mockReturnThis(), json: jest.fn() });

test('rejects missing header', () => {
  const req = { headers: {} },  res = mockRes(),  next = jest.fn();
  authenticate(req, res, next);
  expect(res.status).toHaveBeenCalledWith(401);
  expect(next).not.toHaveBeenCalled();
});

test('accepts valid JWT and populates req.user', () => {
  const token = jwt.sign({ sub: 'u1', role: 'user' }, process.env.JWT_SECRET,
    { algorithms: ['HS256'], issuer: 'yourdomain.com', audience: 'yourdomain.com' });
  const req = { headers: { authorization: `Bearer ${token}` } };
  const next = jest.fn();
  authenticate(req, mockRes(), next);
  expect(next).toHaveBeenCalled();
  expect(req.user.id).toBe('u1');
});

// Temporary debug middleware — add before authenticate
app.use((req, res, next) => {
  console.log(`[AUTH DEBUG] ${req.method} ${req.path}`);
  console.log('Authorization:', req.headers.authorization?.slice(0, 30) + '...');
  console.log('Cookies:',       req.cookies);
  console.log('Origin:',        req.headers.origin);
  next();
});