/** * Express authentication middleware. * Validates JWT bearer tokens and attaches the decoded payload to the request. * Provides role-based access control via higher-order middleware factories. */ import { Request, Response, NextFunction } from 'express'; import { verifyToken } from '../services/authService'; import { touchAppPresence } from '../realtime/redis/onlinePresence'; import { JwtPayload } from '../types'; import type { RoleName } from '../models'; import { hasAdminAccess, hasStaffAccess, hasAdminPanelAccess, userRoleList } from '../utils/roleAccess'; import { userHasAllPermissions } from '../rbac/permissionResolver'; import { logAccessDenied } from '../utils/securityAudit'; import { config } from '../config'; import * as settingsRepository from '../repositories/settingsRepository'; import * as userRepository from '../repositories/userRepository'; import * as roleRepository from '../repositories/roleRepository'; /** Express request extended with the authenticated user's JWT payload. */ export interface AuthRequest extends Request { user?: JwtPayload; } /** Reloads roles and permissions from the database onto the JWT payload. */ async function syncUserAccessFromDb(req: AuthRequest): Promise { if (!req.user?.userId) return; const [roles, permissions] = await Promise.all([ roleRepository.getUserRoleNames(req.user.userId), roleRepository.getUserPermissions(req.user.userId), ]); const primaryRole = roleRepository.resolvePrimaryRole(roles); req.user.roles = roles; req.user.permissions = permissions; req.user.primaryRole = primaryRole; req.user.role = primaryRole; } function userRoles(user: JwtPayload): string[] { return userRoleList(user); } function userHasAnyRole(user: JwtPayload, roles: string[]): boolean { const assigned = userRoles(user); return roles.some((r) => assigned.includes(r)); } function roleCheckPassed(req: AuthRequest, roles: string[]): boolean { if (!req.user) return false; if (userHasAnyRole(req.user, roles)) return true; if (roles.includes('admin') && hasAdminPanelAccess(req.user)) return true; if (roles.includes('admin') && hasAdminAccess(req.user)) return true; if (roles.includes('moderator') && hasStaffAccess(req.user)) return true; return false; } async function enforceAdmin2faIfRequired(req: AuthRequest, roles: string[]): Promise { if (!req.user || !roles.includes('admin') || !hasAdminAccess(req.user)) { return true; } const envOverride = config.security.requireAdmin2faEnv; if (envOverride === 'false' || envOverride === '0' || envOverride === 'no') { return true; } const settings = await settingsRepository.getSettings(); const required = envOverride === 'true' || envOverride === '1' || envOverride === 'yes' ? true : settings.require_admin_2fa; if (!required) return true; const user = await userRepository.findById(req.user.userId); return Boolean(user?.totp_enabled); } /** * Verifies the Authorization bearer token and attaches the decoded user to the request. */ export async function authMiddleware(req: AuthRequest, res: Response, next: NextFunction): Promise { const authHeader = req.headers.authorization; if (!authHeader || !authHeader.startsWith('Bearer ')) { res.status(401).json({ error: 'Unauthorized' }); return; } const token = authHeader.slice(7); try { const payload = await verifyToken(token); const gate = await userRepository.getAuthGate(payload.userId); if (!gate || gate.deleted_at) { res.status(401).json({ error: 'Invalid or expired token' }); return; } if (!config.security.skipAccessTokenVersionCheck) { const jwtVersion = payload.tv ?? 1; if (jwtVersion !== gate.token_version) { res.status(401).json({ error: 'Invalid or expired token', code: 'TOKEN_REVOKED' }); return; } } if (gate.is_enabled === false) { res.status(403).json({ error: 'Account is disabled.', code: 'ACCOUNT_DISABLED' }); return; } if (gate.is_account_non_locked === false) { res.status(403).json({ error: 'Account is locked.', code: 'ACCOUNT_LOCKED' }); return; } if (gate.is_account_non_expired === false || gate.is_credentials_non_expired === false) { res.status(403).json({ error: 'Account is not available.', code: 'ACCOUNT_DISABLED' }); return; } req.user = payload; if (payload.userId) void touchAppPresence(payload.userId); next(); } catch { res.status(401).json({ error: 'Invalid or expired token' }); } } /** * Restricts access to users whose roles intersect the allowed list. * `super_admin` satisfies routes that require `admin`. * Admin routes also enforce mandatory 2FA when configured. */ export function requireRoles(...roles: string[]) { return async (req: AuthRequest, res: Response, next: NextFunction): Promise => { if (!req.user) { res.status(401).json({ error: 'Unauthorized' }); return; } await syncUserAccessFromDb(req); if (!roleCheckPassed(req, roles)) { logAccessDenied(req, 'missing_role', { requiredRoles: roles }); res.status(403).json({ error: 'Forbidden' }); return; } try { const ok2fa = await enforceAdmin2faIfRequired(req, roles); if (!ok2fa) { logAccessDenied(req, 'admin_2fa_required'); res.status(403).json({ error: '2FA required for admin access. Enable two-factor authentication in your profile.', code: 'ADMIN_2FA_REQUIRED', }); return; } } catch { res.status(500).json({ error: 'Internal server error' }); return; } next(); }; } /** Requires every listed permission on the JWT payload. */ export function requirePermissions(...perms: string[]) { return async (req: AuthRequest, res: Response, next: NextFunction): Promise => { if (!req.user) { res.status(401).json({ error: 'Unauthorized' }); return; } await syncUserAccessFromDb(req); // Super admin is granted the full catalog at sync time; always allow even if a // newly added key has not yet appeared in a stale client session copy. if (userRoles(req.user).includes('super_admin')) { next(); return; } const userPerms = req.user.permissions ?? []; if (userHasAllPermissions(userPerms, perms)) { next(); return; } logAccessDenied(req, 'missing_permission', { requiredPermissions: perms }); res.status(403).json({ error: 'Forbidden' }); }; } /** Admin or super_admin. */ export function requireAdmin() { return requireRoles('admin', 'super_admin'); } /** Admin, moderator, or super_admin — support desk and similar staff tools. */ export function requireStaff() { return async (req: AuthRequest, res: Response, next: NextFunction): Promise => { if (!req.user) { res.status(401).json({ error: 'Unauthorized' }); return; } await syncUserAccessFromDb(req); if (!hasStaffAccess(req.user)) { logAccessDenied(req, 'missing_staff_role'); res.status(403).json({ error: 'Forbidden' }); return; } try { const ok2fa = await enforceAdmin2faIfRequired(req, ['admin']); if (!ok2fa) { logAccessDenied(req, 'admin_2fa_required'); res.status(403).json({ error: '2FA required for admin access. Enable two-factor authentication in your profile.', code: 'ADMIN_2FA_REQUIRED', }); return; } } catch { res.status(500).json({ error: 'Internal server error' }); return; } next(); }; }