import { z } from "zod"; import { AppError, attachUser, clearSessionCookie, clientIp, createRateLimiter, createSession, currentUser, hashPassword, isHttpsRequest, rateLimitKey, requireAuth, revokeSession, setSessionCookie, sha256, verifyPassword, type App, type Config, type Db, } from "../lib/index.js"; const credentials = z.object({ email: z.string().trim().min(3).max(255), password: z.string().min(1).max(1024), }); /** * Hachage de repli, calcule paresseusement a la premiere echec de connexion. * Sans lui, un compte inexistant repond plus vite qu'un compte existant, ce qui * permet d'enumerer les adresses e-mail en mesurant le temps de reponse. */ let dummyHash: Promise | undefined; const decoyHash = (): Promise => (dummyHash ??= hashPassword("aucun-compte-ne-correspond")); interface UserRow { id: string; email: string; first_name: string; last_name: string; password_hash: string; role_slug: string; role_name: string; quota_bytes: number; used_bytes: number; max_file_bytes: number; must_change_password: number; is_active: number; } const publicUser = (row: UserRow) => ({ id: row.id, email: row.email, first_name: row.first_name, last_name: row.last_name, role_slug: row.role_slug, role_name: row.role_name, quota_bytes: row.quota_bytes, used_bytes: row.used_bytes, max_file_bytes: row.max_file_bytes, must_change_password: row.must_change_password === 1, }); const SELECT_USER = ` SELECT u.id, u.email, u.first_name, u.last_name, u.password_hash, r.slug AS role_slug, r.name AS role_name, u.quota_bytes, u.used_bytes, u.max_file_bytes, u.must_change_password, u.is_active FROM users u JOIN roles r ON r.id = u.role_id`; export const registerAuthRoutes = (app: App, db: Db, config: Config): void => { app.use("/api/cloud/*", attachUser(db)); const limiter = createRateLimiter(config.RATE_LIMIT_LOGIN_MAX, config.RATE_LIMIT_LOGIN_WINDOW_MS); app.post("/api/cloud/auth/login", async (context) => { // Borne les tentatives par IP : une attaque par dictionnaire sur un mot de // passe faible est arretee avant le calcul scrypt, couteux. const ip = clientIp(context, config.TRUST_PROXY); if (!limiter.allow(rateLimitKey(ip))) { throw AppError.unprocessable("Trop de tentatives de connexion. Reessayez dans une minute."); } const parsed = credentials.safeParse(await context.req.json().catch(() => null)); if (!parsed.success) throw AppError.badRequest("Identifiants invalides."); const { email, password } = parsed.data; const row = await db.one(`${SELECT_USER} WHERE u.active_email = ?`, [email]); // Meme travail dans les deux cas, pour que le temps de reponse ne // revele pas si l'adresse existe. const stored = row && row.is_active === 1 ? row.password_hash : await decoyHash(); if (!row || row.is_active !== 1 || !(await verifyPassword(password, stored))) { throw AppError.unauthorized("Identifiants invalides."); } const forwarded = context.req.header("x-forwarded-for"); const { token, expiresAt } = await createSession( db, row.id, { ipAddress: config.TRUST_PROXY && forwarded ? forwarded.split(",")[0]?.trim() : null, userAgent: context.req.header("user-agent"), }, config.SESSION_TTL_HOURS, ); await db.exec("UPDATE users SET last_login_at = UTC_TIMESTAMP() WHERE id = ?", [row.id]); // Le marqueur Secure suit le protocole reellement annonce, pas // NODE_ENV : un deploiement en HTTP local doit rester utilisable, un // deploiement https:// ne doit jamais poser de cookie cleartext. // Le schema reel de la requete, pas PUBLIC_ORIGIN : voir isHttpsRequest. const secure = isHttpsRequest(context, config.TRUST_PROXY); setSessionCookie(context, token, expiresAt, secure); return context.json({ user: publicUser(row) }); }); app.post("/api/cloud/auth/logout", requireAuth, async (context) => { const token = context.get("token"); if (token) await revokeSession(db, token); clearSessionCookie(context); return context.json({ ok: true }); }); app.get("/api/cloud/auth/me", requireAuth, async (context) => { const session = currentUser(context); const row = await db.one(`${SELECT_USER} WHERE u.id = ?`, [session.id]); if (!row) throw AppError.unauthorized(); return context.json({ user: publicUser(row) }); }); const changePassword = z.object({ current: z.string().min(1).max(1024), next: z.string().min(8).max(1024), }); /** * Changement impose a la premiere connexion. Les autres sessions sont * revoquees : si le compte avait ete ouvert ailleurs, l'ancien mot de passe * ne doit plus rien ouvrir. */ app.post("/api/cloud/auth/change-password", requireAuth, async (context) => { const session = currentUser(context); const parsed = changePassword.safeParse(await context.req.json().catch(() => null)); if (!parsed.success) { throw AppError.badRequest("Le nouveau mot de passe doit contenir au moins 8 caracteres."); } const row = await db.one<{ password_hash: string }>( "SELECT password_hash FROM users WHERE id = ? AND deleted_at IS NULL", [session.id], ); if (!row) throw AppError.unauthorized(); if (!(await verifyPassword(parsed.data.current, row.password_hash))) { throw AppError.unauthorized("Mot de passe actuel incorrect."); } if (parsed.data.current === parsed.data.next) { throw AppError.badRequest("Le nouveau mot de passe doit differer de l'actuel."); } const hash = await hashPassword(parsed.data.next); await db.exec( `UPDATE users SET password_hash = ?, must_change_password = 0, password_changed_at = UTC_TIMESTAMP() WHERE id = ?`, [hash, session.id], ); // La session courante est conservee, toutes les autres sont revoquees. await db.exec( `UPDATE user_sessions SET revoked_at = UTC_TIMESTAMP() WHERE user_id = ? AND revoked_at IS NULL AND token_hash <> ?`, [session.id, sha256(context.get("token") ?? "")], ); return context.json({ ok: true }); }); };