Auth & Authorization

const argon2 = require('argon2')

// REGISTER: hash and store (salt + settings are saved inside the hash string)
const hash = await argon2.hash(password)
await pool.query('INSERT INTO users (email, password) VALUES ($1, $2)', [email, hash])

// LOGIN: verify
const valid = await argon2.verify(user.password, password)
if (!valid) throw new AuthError('authentication failed')

// LOGIN (after verifying the password)
const sessionId = crypto.randomUUID()
await redis.setex(`session:${sessionId}`, 1800, JSON.stringify({ userId: user.id, role: user.role }))
res.cookie('sessionId', sessionId, { httpOnly: true, secure: true, sameSite: 'lax', maxAge: 1800000 })

// PROTECTED ROUTE
const data = await redis.get(`session:${req.cookies.sessionId}`)
if (!data) return res.status(401).json({ error: 'authentication failed' })

// LOGOUT: instant revocation
await redis.del(`session:${req.cookies.sessionId}`)

// LOGIN: create a JWT
const token = jwt.sign({ sub: user.id, role: user.role }, process.env.JWT_SECRET, { expiresIn: '15m' })

// MIDDLEWARE: verify on every protected request
function authenticate(req, res, next) {
  try {
    const token = req.headers.authorization.split(' ')[1] // "Bearer <token>"
    req.user = jwt.verify(token, process.env.JWT_SECRET)
  } catch {
    return res.status(401).json({ error: 'authentication failed' })
  }
  next()
}

async function refresh(token) {
  const record = JSON.parse(await redis.get(`rt:${token}`)) // { userId, role, familyId }
  if (!record || (await redis.exists(`revoked:${record.familyId}`))) throw new AuthError('invalid')

  // mark as used; NX fails if it was already used -> reuse detected
  const firstUse = await redis.set(`used:${token}`, 1, 'EX', THIRTY_DAYS, 'NX')
  if (!firstUse) {
    await redis.set(`revoked:${record.familyId}`, 1, 'EX', THIRTY_DAYS) // revoke whole family
    throw new AuthError('invalid')
  }

  const newToken = crypto.randomUUID()
  await redis.set(`rt:${newToken}`, JSON.stringify(record), 'EX', THIRTY_DAYS) // same familyId
  const accessToken = jwt.sign({ sub: record.userId, role: record.role }, SECRET, { expiresIn: '15m' })
  return { accessToken, refreshToken: newToken }
}

res.cookie('sessionId', sessionId, {
  httpOnly: true, // JS can't read it
  secure: true, // HTTPS only
  sameSite: 'lax', // CSRF protection
  maxAge: 1800000, // 30 minutes
})

// at login: a random token tied to the session
req.session.csrfToken = crypto.randomBytes(32).toString('hex')

// frontend: send it back on every POST / PUT / PATCH / DELETE
fetch('/notes/7/delete', { method: 'POST', headers: { 'X-CSRF-Token': csrfToken } })

// middleware
function csrf(req, res, next) {
  if (['GET', 'HEAD', 'OPTIONS'].includes(req.method)) return next()
  if (req.get('X-CSRF-Token') !== req.session.csrfToken) {
    return res.status(403).json({ error: 'invalid csrf token' })
  }
  next()
}

const verifier = crypto.randomBytes(32).toString('base64url')                  // keep secret
const challenge = crypto.createHash('sha256').update(verifier).digest('base64url')

// 1. redirect: /authorize?...&code_challenge=${challenge}&code_challenge_method=S256
// 2. exchange: POST /token ... &code=${code}&code_verifier=${verifier}

{
  "sub": "google-user-123",
  "name": "Ali Ahmed",
  "email": "ali@gmail.com",
  "iss": "https://accounts.google.com",
  "aud": "your-client-id",
  "iat": 1700000000,
  "exp": 1700003600
}

async function apiKeyAuth(req, res, next) {
  const key = req.headers['x-api-key']
  if (!key) return res.status(401).json({ error: 'authentication failed' })

  // store and look up a HASH of the key, never the raw key
  const hash = crypto.createHash('sha256').update(key).digest('hex')
  const { rows } = await pool.query('SELECT user_id FROM api_keys WHERE key_hash = $1 AND active = true', [hash])
  if (!rows[0]) return res.status(401).json({ error: 'authentication failed' })

  req.user = { id: rows[0].user_id }
  next()
}

const https = require('https')

https.createServer({
  key: fs.readFileSync('payments.key'),
  cert: fs.readFileSync('payments.crt'),
  ca: fs.readFileSync('internal-ca.crt'), // trust only our internal CA
  requestCert: true, // ask the caller for a certificate
  rejectUnauthorized: true, // no valid certificate → handshake fails
}, app).listen(443)

app.post('/charge', (req, res) => {
  const caller = req.socket.getPeerCertificate().subject.CN // "orders.internal"
  if (caller !== 'orders.internal') return res.status(403).end()
  // ...charge
})

// authentication: who are you? (jwt.verify throws on a bad token, so catch it -> 401)
function authenticate(req, res, next) {
  try {
    const token = req.headers.authorization.split(' ')[1]
    req.user = jwt.verify(token, process.env.JWT_SECRET)
  } catch {
    return res.status(401).json({ error: 'authentication failed' })
  }
  next()
}

// authorization: what can you do?
function authorize(...roles) {
  return (req, res, next) => {
    if (!roles.includes(req.user.role)) return res.status(403).json({ error: 'forbidden' })
    next()
  }
}

app.get('/admin/dead-zone', authenticate, authorize('admin'), getDeadZoneNotes)
app.delete('/notes/:id', authenticate, authorize('admin', 'moderator'), deleteNote)
app.get('/notes', authenticate, authorize('user', 'moderator', 'admin'), getNotes)

app.get('/notes/:noteId', authenticate, authorize('user', 'moderator', 'admin'), async (req, res) => {
  const canReadAny = ['moderator', 'admin'].includes(req.user.role)
  const { rows } = canReadAny
    ? await pool.query('SELECT * FROM notes WHERE id = $1', [req.params.noteId])
    : await pool.query('SELECT * FROM notes WHERE id = $1 AND owner_id = $2', [req.params.noteId, req.user.sub])
  if (!rows[0]) return res.status(404).json({ error: 'not found' })
  res.json(rows[0])
})

// FIX 1: always hash. The dummy must be a REAL argon2 hash, computed once at startup.
// (A fake string can make argon2.verify throw or return early, and the timing gap comes back.)
const dummyHashPromise = argon2.hash('dummy-password')

const hash = user ? user.password : await dummyHashPromise
const valid = await argon2.verify(hash, password)
if (!user || !valid) return res.status(401).json({ error: 'authentication failed' })

// FIX 2: constant-time comparison for secret strings (hash first so lengths always match)
const a = crypto.createHash('sha256').update(expected).digest()
const b = crypto.createHash('sha256').update(received).digest()
const match = crypto.timingSafeEqual(a, b)

app.post('/forgot', async (req, res) => {
  const user = await findUserByEmail(req.body.email)
  if (user) {
    const token = crypto.randomBytes(32).toString('base64url')
    await redis.set(`reset:${sha256(token)}`, user.id, 'EX', 900) // 15 min, stored hashed
    queue.add('send-reset-email', { to: user.email, token }) // in the background: no timing difference
  }
  res.json({ message: 'If an account exists, we sent a reset link.' }) // always the same
})

app.post('/reset', async (req, res) => {
  const key = `reset:${sha256(req.body.token)}`
  const userId = await redis.get(key)
  if (!userId) return res.status(400).json({ error: 'invalid or expired link' })

  await redis.del(key) // single use
  await pool.query('UPDATE users SET password = $1 WHERE id = $2', [await argon2.hash(req.body.password), userId])
  await revokeAllSessions(userId) // log out everywhere
  res.json({ message: 'Password updated. Please log in.' })
})