213 lines
7.5 KiB
TypeScript
213 lines
7.5 KiB
TypeScript
/**
|
|
* 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<void> {
|
|
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<boolean> {
|
|
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<void> {
|
|
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<void> => {
|
|
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<void> => {
|
|
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<void> => {
|
|
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();
|
|
};
|
|
}
|