First commit

server.js

@@ -0,0 +1,208 @@
+const express = require('express');
+const sqlite3 = require('sqlite3').verbose();
+const argon2 = require('argon2');
+const jwt = require('jsonwebtoken');
+const crypto = require('crypto');
+const { v4: uuidv4 } = require('uuid');
+const cors = require('cors');
+const cookieParser = require('cookie-parser');
+
+const app = express();
+
+app.use(cors({
+    // Note : si vous ouvrez le fichier HTML en double cliquant (file://), les cookies ne marcheront pas.
+    // Il faut utiliser "Live Server" WebStorm (clic droit sur le fichier "index.html" > "Run 'index.html'")
+    origin: 'http://localhost:63342', // L'adresse EXACTE de votre client (pas *)
+    credentials: true // Autorise l'envoi de cookies
+}));
+app.use(express.json());
+app.use(cookieParser());
+
+// --- CONFIGURATION ---
+const JWT_SECRET = 'jwt_secret_pour_signature';
+const SERVER_MASTER_KEY = crypto.randomBytes(32); // Clé interne serveur pour protéger le JWT
+// Note : Dans la vraie vie, SERVER_MASTER_KEY doit être fixe et dans un .env ou var. env. (sinon au restart serveur, les JWT ne marchent plus)
+
+const DB_SOURCE = "db_final.sqlite";
+
+// --- OUTILS CRYPTO ---
+
+// 1. Chiffrement Générique AES-GCM
+const encryptAES = (text, key) => {
+  const iv = crypto.randomBytes(12);
+  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
+  let encrypted = cipher.update(text, 'utf8', 'hex');
+  encrypted += cipher.final('hex');
+  return { content: encrypted, iv: iv.toString('hex'), tag: cipher.getAuthTag().toString('hex') };
+};
+
+// 2. Déchiffrement Générique AES-GCM
+const decryptAES = (encryptedHex, key, ivHex, tagHex) => {
+  const decipher = crypto.createDecipheriv('aes-256-gcm', key, Buffer.from(ivHex, 'hex'));
+  decipher.setAuthTag(Buffer.from(tagHex, 'hex'));
+  let decrypted = decipher.update(encryptedHex, 'hex', 'utf8');
+  decrypted += decipher.final('utf8');
+  return decrypted;
+};
+
+// 3. Dérivation Argon2 (Password -> Key)
+const deriveKeyFromPass = async (pass, salt) => {
+  return await argon2.hash(pass, {
+    type: argon2.argon2id, raw: true, salt: Buffer.from(salt, 'hex'), hashLength: 32
+  });
+};
+
+// --- BDD ---
+const db = new sqlite3.Database(DB_SOURCE, (err) => {
+  if (err) throw err;
+
+  // Table Users : On stocke la CLÉ DU COFFRE (Vault Key) protégée par le mot de passe
+  db.run(`CREATE TABLE IF NOT EXISTS users (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        email TEXT UNIQUE,
+        auth_hash TEXT,            -- Hash pour vérifier le login (rapide)
+        vault_key_salt TEXT,       -- Sel pour dériver la clé
+        encrypted_vault_key TEXT,  -- La clé AES de l'user, chiffrée par son pass
+        key_iv TEXT,
+        key_tag TEXT
+    )`);
+
+  // Table Entries : Le contenu est chiffré par la Vault Key
+  db.run(`CREATE TABLE IF NOT EXISTS entries (
+        id TEXT PRIMARY KEY,
+        owner_id INTEGER,
+        title TEXT,
+        username_field TEXT,
+        url TEXT,
+        encrypted_blob TEXT, 
+        iv TEXT,              
+        auth_tag TEXT,
+        FOREIGN KEY(owner_id) REFERENCES users(id)
+    )`);
+});
+
+// --- MIDDLEWARE ---
+// C'est lui qui récupère la clé de chiffrement des secrets dans le JWT
+const authenticateAndUnpackKey = (req, res, next) => {
+  const token = req.cookies.auth_token;
+  if (!token) return res.sendStatus(401);
+
+  jwt.verify(token, JWT_SECRET, (err, decoded) => {
+    if (err) return res.sendStatus(403);
+
+    try {
+      // On récupère la clé de chiffrement de l'utilisateur stockée dans le token
+      // Elle est chiffrée avec la clé globale du serveur (ServerMasterKey), donc on la déchiffre.
+      const userVaultKeyHex = decryptAES(
+          decoded.encryptedKey,
+          SERVER_MASTER_KEY,
+          decoded.iv,
+          decoded.tag
+      );
+
+      // On attache la clé (Buffer) à la requête pour les routes suivantes
+      req.user = { ...decoded, vaultKey: Buffer.from(userVaultKeyHex, 'hex') };
+      next();
+    } catch (e) {
+      return res.status(403).json({error: "Token invalide ou corruption serveur"});
+    }
+  });
+};
+
+// --- ROUTES ---
+
+// 1. Inscription
+app.post('/register', async (req, res) => {
+  const { email, password } = req.body;
+
+  try {
+    // A. Login Auth Hash
+    const authHash = await argon2.hash(password);
+
+    // B. Création du "Trousseau" (Vault Key)
+    const userVaultKey = crypto.randomBytes(32); // La clé réelle qui chiffrera les données
+    const vaultSalt = crypto.randomBytes(16).toString('hex');
+
+    // C. On chiffre ce trousseau avec le mot de passe de l'user
+    const keyDerivedFromPass = await deriveKeyFromPass(password, vaultSalt);
+    const encryptedVault = encryptAES(userVaultKey.toString('hex'), keyDerivedFromPass);
+
+    db.run(`INSERT INTO users (email, auth_hash, vault_key_salt, encrypted_vault_key, key_iv, key_tag) VALUES (?,?,?,?,?,?)`,
+        [email, authHash, vaultSalt, encryptedVault.content, encryptedVault.iv, encryptedVault.tag],
+        function(err) {
+          if (err) return res.status(400).json({ error: "Erreur création" });
+          res.json({ message: "Compte créé avec succès" });
+        }
+    );
+  } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+// 2. Login (C'est ici qu'on prépare le JWT "chargé")
+app.post('/login', (req, res) => {
+  const { email, password } = req.body;
+  db.get("SELECT id, email, encrypted_vault_key, vault_key_salt, key_iv, key_tag, auth_hash FROM users WHERE email = ?", [email], async (err, user) => {
+    if (!user || !await argon2.verify(user.auth_hash, password)) {
+      return res.status(401).json({ error: "Creds invalides" });
+    }
+
+    try {
+      // A. On recrée la clé qui protège le trousseau
+      const keyDerivedFromPass = await deriveKeyFromPass(password, user.vault_key_salt);
+
+      // B. On déchiffre le trousseau (Vault Key)
+      // Si ça marche, c'est que le mot de passe est bon ET qu'on a accès aux données
+      const userVaultKeyHex = decryptAES(user.encrypted_vault_key, keyDerivedFromPass, user.key_iv, user.key_tag);
+
+      // C. On met ce trousseau DANS le JWT, mais chiffré par le SERVEUR
+      // (Pour que le client ne puisse pas le voir, et pour ne pas le stocker en session serveur)
+      const tokenPayloadEncrypted = encryptAES(userVaultKeyHex, SERVER_MASTER_KEY);
+
+      const token = jwt.sign({
+        id: user.id,
+        email: user.email,
+        // On injecte le payload chiffré
+        encryptedKey: tokenPayloadEncrypted.content,
+        iv: tokenPayloadEncrypted.iv,
+        tag: tokenPayloadEncrypted.tag
+      }, JWT_SECRET, { expiresIn: '1h' });
+
+      // res.json({ token }); // <-- Avant, on envoyait le token dans le corps de la réponse, maintenant on l'envoie en cookie sécurisé (protection XSS/CSRF), cf ci-dessous
+
+      res.cookie('auth_token', token, {
+        httpOnly: true, // JS ne peut pas le lire (Protection XSS, CSRF)
+        secure: false,  // Mettre à 'true' si vous êtes en HTTPS
+        sameSite: 'lax', // Protection CSRF
+        maxAge: 3600000 // 1 heure (en ms)
+      });
+
+      res.json({ message: "Connexion réussie" }); // On n'envoie plus le token dans le corps !
+
+    } catch (e) {
+      res.status(500).json({ error: "Erreur crypto login" });
+    }
+  });
+});
+
+// 3. Créer une entrée
+app.post('/entries', authenticateAndUnpackKey, (req, res) => {
+  const { title, username_field, url, password } = req.body;
+  // TODO
+});
+
+// 4. Déchiffrer une entrée
+app.get('/entries/:id/password', authenticateAndUnpackKey, (req, res) => {
+  // TODO
+});
+
+// 5. Lister les entrées (Métadonnées uniquement)
+app.get('/entries', authenticateAndUnpackKey, (req, res) => {
+  // TODO
+});
+
+// 6. Logout (supprime le cookie)
+app.post('/logout', (req, res) => {
+    res.clearCookie('auth_token');
+    res.json({ message: "Déconnecté" });
+});
+
+app.listen(3000, () => console.log("Serveur Secure Token démarré"));