Spaces:
Sleeping
Sleeping
Download api/auth.js from DavidRambeau/Locmouth: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/spaces/DavidRambeau/Locmouth/resolve/main/api/auth.js
- Command line
-
hf download hf://spaces/DavidRambeau/Locmouth/api/auth.js
-
curl -L -o auth.js https://huggingface.co/spaces/DavidRambeau/Locmouth/resolve/main/api/auth.js
10.7 kB
| const { randomBytes, createHash, scrypt, timingSafeEqual } = require("node:crypto"); | |
| const { promisify } = require("node:util"); | |
| const deriveKey = promisify(scrypt); | |
| const COOKIE = "locmouth_session"; | |
| const SESSION_MS = 7 * 24 * 60 * 60 * 1000; | |
| const SCRYPT_OPTIONS = { N: 131072, r: 8, p: 1, maxmem: 256 * 1024 * 1024 }; | |
| const digest = (value) => createHash("sha256").update(value).digest("hex"); | |
| async function hashPassword(password, salt = randomBytes(16).toString("hex")) { | |
| const key = await deriveKey(password, salt, 64, SCRYPT_OPTIONS); | |
| return `${salt}:${key.toString("hex")}`; | |
| } | |
| async function verifyPassword(password, stored) { | |
| const [salt, expected] = stored.split(":"); | |
| const actual = await hashPassword(password, salt); | |
| return timingSafeEqual(Buffer.from(actual.split(":")[1], "hex"), Buffer.from(expected, "hex")); | |
| } | |
| function initializeProfiles(db) { | |
| db.transaction(() => { | |
| db.exec(` | |
| CREATE TABLE IF NOT EXISTS users ( | |
| id INTEGER PRIMARY KEY AUTOINCREMENT, | |
| username TEXT NOT NULL COLLATE NOCASE UNIQUE, | |
| password_hash TEXT NOT NULL, | |
| settings TEXT NOT NULL DEFAULT '{}', | |
| created_at TEXT NOT NULL DEFAULT (datetime('now')) | |
| ); | |
| CREATE TABLE IF NOT EXISTS sessions ( | |
| token_hash TEXT PRIMARY KEY, | |
| user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE, | |
| expires_at INTEGER NOT NULL | |
| ); | |
| CREATE INDEX IF NOT EXISTS idx_sessions_expiry ON sessions(expires_at); | |
| `); | |
| if (!db.prepare("PRAGMA table_info(fiches)").all().some((c) => c.name === "user_id")) { | |
| db.exec("ALTER TABLE fiches ADD COLUMN user_id INTEGER REFERENCES users(id)"); | |
| } | |
| // Replace the legacy global URL uniqueness with uniqueness within each profile. | |
| if (!db.prepare("PRAGMA table_info(immo_sites)").all().some((c) => c.name === "user_id")) { | |
| db.exec(` | |
| ALTER TABLE immo_sites RENAME TO immo_sites_legacy; | |
| CREATE TABLE immo_sites ( | |
| id INTEGER PRIMARY KEY AUTOINCREMENT, | |
| user_id INTEGER REFERENCES users(id), | |
| nom TEXT NOT NULL, url TEXT NOT NULL, | |
| favicon_url TEXT GENERATED ALWAYS AS ( | |
| 'https://www.google.com/s2/favicons?domain=' || url || '&sz=32' | |
| ) VIRTUAL, | |
| categorie TEXT, sort_order INTEGER DEFAULT 0, actif INTEGER DEFAULT 1, | |
| notes TEXT, created_at TEXT DEFAULT (datetime('now','localtime')), | |
| UNIQUE(user_id, url) | |
| ); | |
| INSERT INTO immo_sites (id, nom, url, categorie, sort_order, actif, notes, created_at) | |
| SELECT id, nom, url, categorie, sort_order, actif, notes, created_at FROM immo_sites_legacy; | |
| DROP TABLE immo_sites_legacy; | |
| `); | |
| } | |
| db.exec(` | |
| CREATE INDEX IF NOT EXISTS idx_fiches_user ON fiches(user_id); | |
| CREATE INDEX IF NOT EXISTS idx_immo_sites_user ON immo_sites(user_id); | |
| `); | |
| })(); | |
| } | |
| function installAuth(app, db) { | |
| initializeProfiles(db); | |
| const attempts = new Map(); | |
| // A fixed fake hash makes unknown usernames take the same hashing path. | |
| const dummyHash = `${"0".repeat(32)}:${"0".repeat(128)}`; | |
| const secureCookie = process.env.COOKIE_SECURE === "true" || | |
| (process.env.COOKIE_SECURE !== "false" && process.env.NODE_ENV === "production"); | |
| const cookieOptions = { httpOnly: true, sameSite: "lax", secure: secureCookie, path: "/" }; | |
| function readSession(req) { | |
| const token = (req.headers.cookie || "").split(";") | |
| .map((part) => part.trim()).find((part) => part.startsWith(`${COOKIE}=`))?.slice(COOKIE.length + 1); | |
| if (!token || !/^[a-f0-9]{64}$/.test(token)) return null; | |
| return db.prepare(`SELECT users.id, users.username, users.settings, sessions.token_hash | |
| FROM sessions JOIN users ON users.id = sessions.user_id | |
| WHERE token_hash = ? AND expires_at > ?`).get(digest(token), Date.now()); | |
| } | |
| function startSession(req, res, userId) { | |
| const previous = readSession(req); | |
| if (previous) db.prepare("DELETE FROM sessions WHERE token_hash = ?").run(previous.token_hash); | |
| db.prepare("DELETE FROM sessions WHERE expires_at <= ?").run(Date.now()); | |
| const token = randomBytes(32).toString("hex"); | |
| db.prepare("INSERT INTO sessions VALUES (?, ?, ?)").run(digest(token), userId, Date.now() + SESSION_MS); | |
| res.cookie(COOKIE, token, { ...cookieOptions, maxAge: SESSION_MS }); | |
| } | |
| function publicUser(user) { | |
| return { id: user.id, username: user.username }; | |
| } | |
| function validCredentials(username, password) { | |
| return typeof username === "string" && /^[a-zA-Z0-9_.-]{3,40}$/.test(username) && | |
| typeof password === "string" && password.length >= 10 && password.length <= 256; | |
| } | |
| function throttle(req, res, next) { | |
| const now = Date.now(); | |
| for (const [key, entry] of attempts) if (entry.until <= now) attempts.delete(key); | |
| const key = req.socket.remoteAddress; | |
| const entry = attempts.get(key) || { count: 0, until: now + 15 * 60 * 1000 }; | |
| entry.count += 1; | |
| attempts.set(key, entry); | |
| if (entry.count > 30) { | |
| res.set("Retry-After", String(Math.ceil((entry.until - now) / 1000))); | |
| return res.status(429).json({ error: "Trop de tentatives. Réessayez dans quelques minutes." }); | |
| } | |
| next(); | |
| } | |
| app.use("/api", (req, res, next) => { | |
| res.set("Cache-Control", "no-store"); | |
| // Custom header + absence of CORS permissions prevents cross-origin form/fetch mutations. | |
| if (!["GET", "HEAD", "OPTIONS"].includes(req.method) && req.get("X-LocMouth-Request") !== "1") { | |
| return res.status(403).json({ error: "Requête non autorisée" }); | |
| } | |
| next(); | |
| }); | |
| app.get("/api/auth/session", (req, res) => { | |
| const user = readSession(req); | |
| res.json({ user: user ? publicUser(user) : null, | |
| setupRequired: !db.prepare("SELECT 1 FROM users LIMIT 1").get(), | |
| hasLegacyData: !!db.prepare("SELECT 1 FROM fiches WHERE user_id IS NULL UNION ALL SELECT 1 FROM immo_sites WHERE user_id IS NULL LIMIT 1").get() }); | |
| }); | |
| app.post("/api/auth/register", throttle, async (req, res) => { | |
| const username = typeof req.body?.username === "string" ? req.body.username.trim() : ""; | |
| const { password } = req.body || {}; | |
| if (!validCredentials(username, password)) { | |
| return res.status(400).json({ error: "Identifiant : 3 à 40 lettres, chiffres, points, tirets ou underscores. Mot de passe : 10 à 256 caractères." }); | |
| } | |
| const passwordHash = await hashPassword(password); | |
| let id; | |
| try { | |
| id = db.transaction(() => { | |
| const firstProfile = !db.prepare("SELECT 1 FROM users LIMIT 1").get(); | |
| const result = db.prepare("INSERT INTO users (username, password_hash) VALUES (?, ?)").run(username, passwordHash); | |
| if (firstProfile) { | |
| db.prepare("UPDATE fiches SET user_id = ? WHERE user_id IS NULL").run(result.lastInsertRowid); | |
| db.prepare("UPDATE immo_sites SET user_id = ? WHERE user_id IS NULL").run(result.lastInsertRowid); | |
| } | |
| return result.lastInsertRowid; | |
| }).immediate(); | |
| } catch (error) { | |
| if (error.code === "SQLITE_CONSTRAINT_UNIQUE") return res.status(409).json({ error: "Cet identifiant est déjà utilisé." }); | |
| throw error; | |
| } | |
| startSession(req, res, id); | |
| res.status(201).json({ user: { id, username } }); | |
| }); | |
| app.post("/api/auth/login", throttle, async (req, res) => { | |
| const { username, password } = req.body || {}; | |
| if (typeof username !== "string" || typeof password !== "string" || password.length > 256) { | |
| return res.status(400).json({ error: "Identifiant ou mot de passe invalide." }); | |
| } | |
| const user = db.prepare("SELECT * FROM users WHERE username = ?").get(username.trim()); | |
| const matches = await verifyPassword(password, user?.password_hash || dummyHash); | |
| if (!user || !matches) return res.status(401).json({ error: "Identifiant ou mot de passe incorrect." }); | |
| startSession(req, res, user.id); | |
| res.json({ user: publicUser(user) }); | |
| }); | |
| function requireAuth(req, res, next) { | |
| const user = readSession(req); | |
| if (!user) return res.status(401).json({ error: "Veuillez vous connecter." }); | |
| // An old tab must not write its data into a newly selected account. | |
| const expectedProfile = req.get("X-LocMouth-Profile"); | |
| if (expectedProfile && expectedProfile !== String(user.id)) { | |
| res.set("X-LocMouth-Profile-Changed", "1"); | |
| return res.status(409).json({ error: "Le profil connecté a changé. Rechargez la page." }); | |
| } | |
| req.user = user; | |
| next(); | |
| } | |
| app.use("/api", requireAuth); | |
| app.post("/api/auth/logout", (req, res) => { | |
| db.prepare("DELETE FROM sessions WHERE token_hash = ?").run(req.user.token_hash); | |
| res.clearCookie(COOKIE, cookieOptions); | |
| res.json({ message: "Déconnexion effectuée" }); | |
| }); | |
| app.get("/api/profile/settings", (req, res) => res.json(JSON.parse(req.user.settings))); | |
| app.put("/api/profile/settings", (req, res) => { | |
| const settings = req.body; | |
| if (!settings || Array.isArray(settings) || typeof settings !== "object" || JSON.stringify(settings).length > 32768) { | |
| return res.status(400).json({ error: "Paramètres invalides ou trop volumineux." }); | |
| } | |
| db.prepare("UPDATE users SET settings = ? WHERE id = ?").run(JSON.stringify(settings), req.user.id); | |
| res.json(settings); | |
| }); | |
| app.put("/api/profile", throttle, async (req, res) => { | |
| const { currentPassword, password } = req.body || {}; | |
| const username = typeof req.body?.username === "string" ? req.body.username.trim() : ""; | |
| if (!validCredentials(username, password || currentPassword)) { | |
| return res.status(400).json({ error: "Identifiant invalide ou mot de passe trop court (10 caractères minimum)." }); | |
| } | |
| const user = db.prepare("SELECT * FROM users WHERE id = ?").get(req.user.id); | |
| if (typeof currentPassword !== "string" || currentPassword.length > 256 || !await verifyPassword(currentPassword, user.password_hash)) { | |
| return res.status(403).json({ error: "Mot de passe actuel incorrect." }); | |
| } | |
| const passwordHash = password ? await hashPassword(password) : user.password_hash; | |
| try { | |
| db.transaction(() => { | |
| db.prepare("UPDATE users SET username = ?, password_hash = ? WHERE id = ?").run(username, passwordHash, user.id); | |
| db.prepare("DELETE FROM sessions WHERE user_id = ?").run(user.id); | |
| })(); | |
| } catch (error) { | |
| if (error.code === "SQLITE_CONSTRAINT_UNIQUE") return res.status(409).json({ error: "Cet identifiant est déjà utilisé." }); | |
| throw error; | |
| } | |
| startSession(req, res, user.id); | |
| res.json({ user: { id: user.id, username } }); | |
| }); | |
| return { requireAuth }; | |
| } | |
| module.exports = { installAuth }; | |