Comptes et sécurité

# 1. Arrête le serveur : Ctrl+C dans le terminal où tourne npm run dev

# 2. Supprime l'ancienne base (sur Windows, dans PowerShell : del data.db)
$ rm data.db

# 3. Remplace db.js par la version ci-dessous, puis relance
$ npm run dev

import { DatabaseSync } from "node:sqlite";

export const db = new DatabaseSync("data.db");

db.exec(`
  CREATE TABLE IF NOT EXISTS users (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    email TEXT NOT NULL UNIQUE,
    password_hash TEXT NOT NULL,
    created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
  );

  CREATE TABLE IF NOT EXISTS tasks (
    id INTEGER PRIMARY KEY AUTOINCREMENT,
    user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
    text TEXT NOT NULL,
    done INTEGER NOT NULL DEFAULT 0,
    created_at TEXT NOT NULL DEFAULT CURRENT_TIMESTAMP
  );
`);

import { scryptSync, randomBytes, timingSafeEqual } from "node:crypto";

// Réglages de scrypt : un des jeux de valeurs conseillés par l'OWASP.
// Ne les change plus une fois que des comptes existent.
const SCRYPT = { N: 16384, r: 8, p: 5 };
const KEYLEN = 64; // longueur du hash, en octets

export function hashPassword(password) {
  const salt = randomBytes(16).toString("hex");
  const hash = scryptSync(password, salt, KEYLEN, SCRYPT).toString("hex");
  return `${salt}:${hash}`;
}

export function verifyPassword(password, stored) {
  const [salt, hash] = stored.split(":");
  const expected = Buffer.from(hash, "hex");
  const actual = scryptSync(password, salt, KEYLEN, SCRYPT);
  return timingSafeEqual(actual, expected);
}

import { hashPassword, verifyPassword } from "./auth.js";

const stored = hashPassword("motdepasse123");
console.log("Stocké :", stored);
console.log("Même mot de passe, autre hash :", hashPassword("motdepasse123"));

console.log("Bon mot de passe :", verifyPassword("motdepasse123", stored));
console.log("Mauvais mot de passe :", verifyPassword("MotDePasse123", stored));

import { Router } from "express";
import { db } from "../db.js";
import { hashPassword } from "../auth.js";

const router = Router();

const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

router.post("/register", (req, res) => {
  const { email, password } = req.body ?? {};

  if (typeof email !== "string" || !EMAIL_REGEX.test(email.trim())) {
    return res.status(400).json({ error: "Email invalide" });
  }
  if (typeof password !== "string" || password.length < 8) {
    return res.status(400).json({ error: "Le mot de passe doit faire au moins 8 caractères" });
  }

  const cleanEmail = email.trim().toLowerCase();
  const existing = db.prepare("SELECT id FROM users WHERE email = ?").get(cleanEmail);
  if (existing) {
    return res.status(409).json({ error: "Un compte existe déjà avec cet email" });
  }

  const result = db.prepare("INSERT INTO users (email, password_hash) VALUES (?, ?)")
    .run(cleanEmail, hashPassword(password));

  res.status(201).json({ id: result.lastInsertRowid, email: cleanEmail });
});

export default router;

// En haut, avec les autres import
import authRouter from "./routes/auth.js";

// Juste au-dessus de app.use("/api/tasks", tasksRouter);
app.use("/api/auth", authRouter);

$ curl -i -X POST http://localhost:3000/api/auth/register -H "Content-Type: application/json" -d '{"email":"Alex@exemple.com","password":"motdepasse123"}'

# Le même email une deuxième fois
$ curl -X POST http://localhost:3000/api/auth/register -H "Content-Type: application/json" -d '{"email":"alex@exemple.com","password":"autrechose99"}'

# Un mot de passe trop court
$ curl -X POST http://localhost:3000/api/auth/register -H "Content-Type: application/json" -d '{"email":"sam@exemple.com","password":"court"}'

CREATE TABLE IF NOT EXISTS sessions (
  token TEXT PRIMARY KEY,
  user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
  expires_at INTEGER NOT NULL
);

import { Router } from "express";
import { randomBytes } from "node:crypto";
import { db } from "../db.js";
import { hashPassword, verifyPassword } from "../auth.js";

const router = Router();

const EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
const SESSION_DURATION = 30 * 24 * 60 * 60 * 1000; // 30 jours, en millisecondes

const cookieOptions = {
  httpOnly: true,
  sameSite: "lax",
  secure: process.env.NODE_ENV === "production",
};

// Crée une session en base et pose le cookie dans la réponse
function startSession(res, userId) {
  // Au passage, on fait le ménage dans les sessions expirées
  db.prepare("DELETE FROM sessions WHERE expires_at <= ?").run(Date.now());

  const token = randomBytes(32).toString("hex");
  db.prepare("INSERT INTO sessions (token, user_id, expires_at) VALUES (?, ?, ?)")
    .run(token, userId, Date.now() + SESSION_DURATION);

  res.cookie("session", token, { ...cookieOptions, maxAge: SESSION_DURATION });
}

router.post("/register", (req, res) => {
  const { email, password } = req.body ?? {};

  if (typeof email !== "string" || !EMAIL_REGEX.test(email.trim())) {
    return res.status(400).json({ error: "Email invalide" });
  }
  if (typeof password !== "string" || password.length < 8) {
    return res.status(400).json({ error: "Le mot de passe doit faire au moins 8 caractères" });
  }

  const cleanEmail = email.trim().toLowerCase();
  const existing = db.prepare("SELECT id FROM users WHERE email = ?").get(cleanEmail);
  if (existing) {
    return res.status(409).json({ error: "Un compte existe déjà avec cet email" });
  }

  const result = db.prepare("INSERT INTO users (email, password_hash) VALUES (?, ?)")
    .run(cleanEmail, hashPassword(password));

  // Nouveau : connecté directement après l'inscription
  startSession(res, result.lastInsertRowid);
  res.status(201).json({ id: result.lastInsertRowid, email: cleanEmail });
});

router.post("/login", (req, res) => {
  const { email, password } = req.body ?? {};
  if (typeof email !== "string" || typeof password !== "string") {
    return res.status(400).json({ error: "Email et mot de passe obligatoires" });
  }

  const user = db.prepare("SELECT id, email, password_hash FROM users WHERE email = ?")
    .get(email.trim().toLowerCase());

  // Même réponse que l'email ou le mot de passe soit faux
  if (!user || !verifyPassword(password, user.password_hash)) {
    return res.status(401).json({ error: "Email ou mot de passe incorrect" });
  }

  startSession(res, user.id);
  res.json({ id: user.id, email: user.email });
});

router.post("/logout", (req, res) => {
  const token = req.cookies.session;
  if (typeof token === "string") {
    db.prepare("DELETE FROM sessions WHERE token = ?").run(token);
  }
  res.clearCookie("session", cookieOptions);
  res.status(204).end();
});

router.get("/me", (req, res) => {
  const token = req.cookies.session;
  if (typeof token !== "string") {
    return res.status(401).json({ error: "Connecte-toi d'abord" });
  }

  const user = db.prepare(`
    SELECT users.id, users.email
    FROM sessions
    JOIN users ON users.id = sessions.user_id
    WHERE sessions.token = ? AND sessions.expires_at > ?
  `).get(token, Date.now());

  if (!user) {
    return res.status(401).json({ error: "Session expirée, reconnecte-toi" });
  }
  res.json(user);
});

export default router;

// En haut, avec les autres import
import cookieParser from "cookie-parser";

// Juste après app.use(express.json());
app.use(cookieParser()); // lit les cookies et les range dans req.cookies

$ npm install cookie-parser

# Connexion : -c range les cookies reçus dans le fichier alex.txt
$ curl -i -c alex.txt -X POST http://localhost:3000/api/auth/login -H "Content-Type: application/json" -d '{"email":"alex@exemple.com","password":"motdepasse123"}'

# -b renvoie les cookies du fichier : le serveur sait que c'est Alex
$ curl -b alex.txt http://localhost:3000/api/auth/me

# Sans cookie
$ curl http://localhost:3000/api/auth/me

# Mauvais mot de passe
$ curl -X POST http://localhost:3000/api/auth/login -H "Content-Type: application/json" -d '{"email":"alex@exemple.com","password":"mauvais123"}'

# Déconnexion, puis on réessaie
$ curl -b alex.txt -c alex.txt -X POST http://localhost:3000/api/auth/logout
$ curl -b alex.txt http://localhost:3000/api/auth/me

import { db } from "../db.js";

export function requireAuth(req, res, next) {
  const token = req.cookies.session;
  if (typeof token !== "string") {
    return res.status(401).json({ error: "Connecte-toi d'abord" });
  }

  const user = db.prepare(`
    SELECT users.id, users.email
    FROM sessions
    JOIN users ON users.id = sessions.user_id
    WHERE sessions.token = ? AND sessions.expires_at > ?
  `).get(token, Date.now());

  if (!user) {
    return res.status(401).json({ error: "Session expirée, reconnecte-toi" });
  }

  req.user = user; // les routes suivantes savent qui parle
  next();
}

// En haut, avec les autres import
import { requireAuth } from "../middleware/requireAuth.js";

// Remplace toute l'ancienne route /me par :
router.get("/me", requireAuth, (req, res) => {
  res.json(req.user);
});

import express from "express";
import { db } from "../db.js";
import { requireAuth } from "../middleware/requireAuth.js"; // nouveau

const router = express.Router();

// Nouveau : toutes les routes de ce fichier exigent d'être connecté
router.use(requireAuth);

// SQLite range done en 0 ou 1 : on renvoie un vrai booléen, comme avant
function toTask(row) {
  return { id: row.id, text: row.text, done: row.done === 1 };
}

// Renvoie un message d'erreur, ou null si le texte est valide
function checkText(text) {
  if (typeof text !== "string" || text.trim() === "") {
    return "Le texte est obligatoire";
  }
  if (text.trim().length > 200) {
    return "200 caractères maximum";
  }
  return null;
}

// GET /api/tasks et GET /api/tasks?done=true
router.get("/", (req, res) => {
  let rows;
  if (req.query.done !== undefined) {
    const done = req.query.done === "true" ? 1 : 0;
    rows = db.prepare("SELECT * FROM tasks WHERE user_id = ? AND done = ? ORDER BY id")
      .all(req.user.id, done);
  } else {
    rows = db.prepare("SELECT * FROM tasks WHERE user_id = ? ORDER BY id").all(req.user.id);
  }
  res.json(rows.map(toTask));
});

// GET /api/tasks/3
router.get("/:id", (req, res) => {
  const row = db.prepare("SELECT * FROM tasks WHERE id = ? AND user_id = ?")
    .get(Number(req.params.id), req.user.id);
  if (!row) {
    return res.status(404).json({ error: "Tâche introuvable" });
  }
  res.json(toTask(row));
});

// POST /api/tasks   corps : { "text": "..." }
router.post("/", (req, res) => {
  const { text } = req.body ?? {};
  const error = checkText(text);
  if (error) {
    return res.status(400).json({ error });
  }
  // Le propriétaire vient de la session, jamais du corps de la requête
  const result = db.prepare("INSERT INTO tasks (user_id, text) VALUES (?, ?)")
    .run(req.user.id, text.trim());
  const row = db.prepare("SELECT * FROM tasks WHERE id = ?").get(result.lastInsertRowid);
  res.status(201).json(toTask(row));
});

// PATCH /api/tasks/3   corps : { "text": "..." } et/ou { "done": true }
router.patch("/:id", (req, res) => {
  const id = Number(req.params.id);
  const { text, done } = req.body ?? {};

  if (text === undefined && done === undefined) {
    return res.status(400).json({ error: "Rien à modifier : envoie text et/ou done" });
  }
  if (text !== undefined) {
    const error = checkText(text);
    if (error) return res.status(400).json({ error });
  }
  if (done !== undefined && typeof done !== "boolean") {
    return res.status(400).json({ error: "done doit valoir true ou false" });
  }

  // COALESCE(?, text) : si on envoie null, la colonne garde sa valeur
  const result = db
    .prepare("UPDATE tasks SET text = COALESCE(?, text), done = COALESCE(?, done) WHERE id = ? AND user_id = ?")
    .run(
      text === undefined ? null : text.trim(),
      done === undefined ? null : done ? 1 : 0,
      id,
      req.user.id
    );

  if (result.changes === 0) {
    return res.status(404).json({ error: "Tâche introuvable" });
  }
  const row = db.prepare("SELECT * FROM tasks WHERE id = ? AND user_id = ?").get(id, req.user.id);
  res.json(toTask(row));
});

// DELETE /api/tasks/3
router.delete("/:id", (req, res) => {
  const result = db.prepare("DELETE FROM tasks WHERE id = ? AND user_id = ?")
    .run(Number(req.params.id), req.user.id);
  if (result.changes === 0) {
    return res.status(404).json({ error: "Tâche introuvable" });
  }
  res.status(204).end();
});

export default router;

# Deux comptes, deux fichiers de cookies
$ curl -c alex.txt -X POST http://localhost:3000/api/auth/login -H "Content-Type: application/json" -d '{"email":"alex@exemple.com","password":"motdepasse123"}'
$ curl -c sam.txt -X POST http://localhost:3000/api/auth/register -H "Content-Type: application/json" -d '{"email":"sam@exemple.com","password":"motdepasse456"}'

# Chacun ajoute ses tâches
$ curl -b alex.txt -X POST http://localhost:3000/api/tasks -H "Content-Type: application/json" -d '{"text":"Acheter du pain"}'
$ curl -b alex.txt -X POST http://localhost:3000/api/tasks -H "Content-Type: application/json" -d '{"text":"Finir la mission 5"}'
$ curl -b sam.txt -X POST http://localhost:3000/api/tasks -H "Content-Type: application/json" -d '{"text":"Appeler Léa"}'

# Chacun voit ses tâches
$ curl -b alex.txt http://localhost:3000/api/tasks
$ curl -b sam.txt http://localhost:3000/api/tasks

# Sam essaie de toucher à la tâche 1, celle d'Alex
$ curl -b sam.txt http://localhost:3000/api/tasks/1
$ curl -b sam.txt -X PATCH http://localhost:3000/api/tasks/1 -H "Content-Type: application/json" -d '{"done":true}'
$ curl -i -b sam.txt -X DELETE http://localhost:3000/api/tasks/1

# Et sans cookie du tout
$ curl -i http://localhost:3000/api/tasks

<!DOCTYPE html>
<html lang="fr">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <title>Connexion · Ma to-do list</title>
    <link rel="stylesheet" href="style.css">
    <script src="login.js" defer></script>
  </head>
  <body>
    <main>
      <h1>Connexion</h1>
      <form id="login-form">
        <label for="login-email">Email</label>
        <input id="login-email" name="email" type="email" autocomplete="email" required>
        <label for="login-password">Mot de passe</label>
        <input id="login-password" name="password" type="password" autocomplete="current-password" required>
        <button type="submit">Se connecter</button>
      </form>

      <h2>Pas encore de compte ?</h2>
      <form id="register-form">
        <label for="register-email">Email</label>
        <input id="register-email" name="email" type="email" autocomplete="email" required>
        <label for="register-password">Mot de passe (8 caractères minimum)</label>
        <input id="register-password" name="password" type="password" autocomplete="new-password" minlength="8" required>
        <button type="submit">Créer mon compte</button>
      </form>

      <p id="auth-error" class="error" hidden></p>
    </main>
  </body>
</html>

const loginForm = document.querySelector("#login-form");
const registerForm = document.querySelector("#register-form");
const errorMsg = document.querySelector("#auth-error");

async function submitAuth(form, path) {
  const button = form.querySelector("button");
  errorMsg.hidden = true;
  button.disabled = true;

  try {
    const response = await fetch(path, {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({
        email: form.elements.email.value,
        password: form.elements.password.value,
      }),
    });
    const data = await response.json();
    if (!response.ok) throw new Error(data.error || "Erreur serveur");

    // Le serveur a posé le cookie : direction la to-do
    location.href = "/";
  } catch (error) {
    errorMsg.textContent = error instanceof TypeError ? "Serveur injoignable" : error.message;
    errorMsg.hidden = false;
  } finally {
    button.disabled = false;
  }
}

loginForm.addEventListener("submit", (event) => {
  event.preventDefault();
  submitAuth(loginForm, "/api/auth/login");
});

registerForm.addEventListener("submit", (event) => {
  event.preventDefault();
  submitAuth(registerForm, "/api/auth/register");
});

<!-- Juste sous <h1>À faire</h1> -->
<p class="account">
  Connecté : <span id="user-email"></span>
  <button id="logout-btn" type="button">Se déconnecter</button>
</p>

// En haut, avec les autres querySelector
const userEmail = document.querySelector("#user-email");
const logoutBtn = document.querySelector("#logout-btn");

// Ton helper api() de l'étape 5, avec un cas en plus : le 401
async function api(path, options = {}) {
  const response = await fetch(path, {
    ...options,
    headers: { "Content-Type": "application/json", ...options.headers },
  });
  if (response.status === 401) {
    // Pas (ou plus) connecté : retour à la page de connexion
    location.href = "/login.html";
    throw new Error("Connecte-toi d'abord");
  }
  if (response.status === 204) return null;
  const data = await response.json();
  if (!response.ok) throw new Error(data.error || "Erreur serveur");
  return data;
}

// Tout en bas : remplace l'appel loadTasks(); par ceci
logoutBtn.addEventListener("click", async () => {
  await api("/api/auth/logout", { method: "POST" });
  location.href = "/login.html";
});

async function start() {
  try {
    const user = await api("/api/auth/me");
    userEmail.textContent = user.email;
    loadTasks();
  } catch (error) {
    showError(error); // ta fonction de l'étape 5 (serveur éteint, etc.)
  }
}

start();

// Ce que fait ta to-do (fonction render) : le texte reste du texte
text.textContent = task.text;

// À NE JAMAIS FAIRE avec un texte venu d'un utilisateur
text.innerHTML = task.text;

// En haut de routes/auth.js
import { rateLimit } from "express-rate-limit";

const loginLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // fenêtre de 15 minutes
  limit: 10,                // 10 essais par adresse IP dans la fenêtre
  message: { error: "Trop de tentatives, réessaie dans 15 minutes" },
});

// La route de connexion passe d'abord par le limiteur
router.post("/login", loginLimiter, (req, res) => {
  // ... le reste ne change pas