Le niveau `cloud` etait redondant : il ne reste qu'une seule application. - backend/cloud/* -> backend/*, frontend/cloud/* -> frontend/* - workspaces npm : frontend et backend ; reference tsconfig ./backend - extends tsconfig.base corrige (../ au lieu de ../../) - docker-compose : APP_DIR backend/frontend, montage ./backend/migrations - deploy.yml : reconstruit aussi l'image migrate - chemins mis a jour dans les docs, le Makefile et docker/README.md
180 lines
6.1 KiB
TypeScript
180 lines
6.1 KiB
TypeScript
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<string> | undefined;
|
|
const decoyHash = (): Promise<string> => (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<UserRow>(`${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<UserRow>(`${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 });
|
|
});
|
|
};
|