games_app/backend/src/middleware/auth.ts
2026-11-15 17:36:00 +02:00

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();
};
}