First commit

.gitignore

@@ -0,0 +1 @@
+/.idea

README.md

@@ -0,0 +1,203 @@
+# Démonstration : injection SQL avec Node.js, Express et SQLite
+
+Ce projet démontre comment une simple concaténation SQL peut rendre une application vulnérable à une injection SQL, et comment corriger cette faille à l'aide de requêtes préparées.
+
+Il propose **deux routes** :
+
+* `/demo-vulnerable/login` → version vulnérable
+* `/demo-secure/login` → version sécurisée
+
+---
+
+## Installation
+
+```bash
+npm install
+nodemon ./bin/www
+```
+
+L'application démarre sur :
+
+```
+http://localhost:3000
+```
+
+---
+
+## Objectifs pédagogiques
+
+Cette mini-démonstration permet de :
+
+* comprendre ce qu'est une **injection SQL**
+* observer clairement la différence entre :
+
+    * une requête créée par concaténation (dangereux)
+    * une requête préparée avec paramètres (sécurisé)
+* manipuler Express, SQLite et les routes API
+* visualiser l'impact d'une exploitation sur une base de données
+
+---
+
+## Structure du projet
+
+```text
+project/
+│── app.js
+│── db/
+│    └── database.js
+│── routes/
+│    ├── auth_vulnerable.js
+│    └── auth_secure.js
+└── bin/www
+```
+
+---
+
+# Comprendre l'architecture
+
+## 1. Initialisation de la base en mémoire
+
+```javascript
+const db = new sqlite3.Database(':memory:');
+```
+
+La base est volatile, recréée à chaque démarrage, et contient deux utilisateurs :
+
+* admin / password123
+* user / userpass
+
+### Diagramme — création de la base
+
+```mermaid
+flowchart TD
+    a["demarrage de l'application"] --> b["creation de la base en memoire"]
+    b --> c["creation de la table users"]
+    c --> d["insertion de l'utilisateur admin"]
+    c --> e["insertion de l'utilisateur user"]
+```
+
+---
+
+## 2. Version vulnérable : concaténation SQL
+
+Dans `auth_vulnerable.js` :
+
+```javascript
+const sqlQuery = "SELECT * FROM users WHERE username = '" + username +
+        "' AND password = '" + password + "'";
+```
+
+Cette méthode permet à un utilisateur d'injecter du code SQL.
+
+### Diagramme — route vulnérable
+
+```mermaid
+sequenceDiagram
+    participant client
+    participant serveur
+    participant sqlite
+
+    client->>serveur: envoi de donnees username et password
+    serveur->>serveur: creation d'une requete concatenee
+    serveur->>sqlite: execution de la requete non protegee
+    sqlite-->>serveur: renvoi d'une ligne ou non
+    serveur-->>client: reponse json
+```
+
+---
+
+# Tests de démonstration
+
+## Test 1 : attaque réussie (vulnérable)
+
+Envoyer un POST :
+
+```
+POST http://localhost:3000/demo-vulnerable/login
+```
+
+Body JSON :
+
+```json
+{
+  "username": "' OR 1=1 --",
+  "password": "peu-importe"
+}
+```
+
+**Résultat attendu :**
+
+Connexion acceptée, vous devenez admin même sans connaître le mot de passe.
+
+---
+
+## Test 2 : l'attaque échoue (sécurisé)
+
+Même requête mais vers :
+
+```
+POST http://localhost:3000/demo-secure/login
+```
+
+Body identique :
+
+```json
+{
+  "username": "' OR 1=1 --",
+  "password": "peu-importe"
+}
+```
+
+**Résultat attendu :**
+
+Connexion refusée : l'injection est traitée comme du texte.
+
+---
+
+# 3. Version sécurisée : requêtes préparées
+
+Dans `auth_secure.js` :
+
+```javascript
+const sqlQuery = "SELECT * FROM users WHERE username = ? AND password = ?";
+const params = [username, password];
+db.get(sqlQuery, params, (...));
+```
+
+SQLite protège automatiquement les valeurs et empêche l'injection.
+
+### Diagramme — route sécurisée
+
+```mermaid
+flowchart TD
+    a["reception de la requete http"] --> b["construction de la requete preparee"]
+    b --> c["envoi de la requete avec parametres"]
+    c --> d["sqlite assainit les valeurs"]
+    d --> e["execution de la requete securisee"]
+```
+
+---
+
+# Comprendre la faille SQL
+
+### Exemple vulnérable
+
+Requête générée :
+
+```sql
+SELECT * FROM users WHERE username = '' OR 1=1 --' AND password='peu-importe'
+```
+
+`OR 1=1` rend la condition **toujours vraie**.
+
+---
+
+# Bonnes pratiques
+
+* toujours utiliser des requêtes préparées
+* jamais concaténer des valeurs utilisateur dans du SQL
+* toujours valider / nettoyer les entrées
+* activer des logs SQL en développement
+* éviter les messages d'erreurs trop détaillés en production
+
+---

app.js

@@ -0,0 +1,36 @@
+var createError = require('http-errors');
+var express = require('express');
+var logger = require('morgan');
+
+var authVulnerableRouter = require('./routes/auth_vulnerable');
+var authSecureRouter = require('./routes/auth_secure');
+
+var app = express();
+
+app.use(logger('dev'));
+app.use(express.json()); // Important pour lire req.body en JSON
+app.use(express.urlencoded({ extended: false }));
+
+// Montez les routeurs sur des chemins spécifiques pour la démo
+app.use('/demo-vulnerable', authVulnerableRouter);
+app.use('/demo-secure', authSecureRouter);
+
+// catch 404 and forward to error handler
+app.use(function(req, res, next) {
+  next(createError(404));
+});
+
+// --- Gestionnaire d'erreurs ---
+app.use(function(err, req, res, next) {
+  // En développement, on affiche l'erreur
+  const errorDetails = req.app.get('env') === 'development' ? err : {};
+
+  // Répondre en JSON
+  res.status(err.status || 500);
+  res.json({
+    message: err.message,
+    error: errorDetails
+  });
+});
+
+module.exports = app;

bin/www

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+
+/**
+ * Module dependencies.
+ */
+
+var app = require('../app');
+var debug = require('debug')('injection-sql:server');
+var http = require('http');
+
+/**
+ * Get port from environment and store in Express.
+ */
+
+var port = normalizePort(process.env.PORT || '3000');
+app.set('port', port);
+
+/**
+ * Create HTTP server.
+ */
+
+var server = http.createServer(app);
+
+/**
+ * Listen on provided port, on all network interfaces.
+ */
+
+server.listen(port);
+server.on('error', onError);
+server.on('listening', onListening);
+
+/**
+ * Normalize a port into a number, string, or false.
+ */
+
+function normalizePort(val) {
+  var port = parseInt(val, 10);
+
+  if (isNaN(port)) {
+    // named pipe
+    return val;
+  }
+
+  if (port >= 0) {
+    // port number
+    return port;
+  }
+
+  return false;
+}
+
+/**
+ * Event listener for HTTP server "error" event.
+ */
+
+function onError(error) {
+  if (error.syscall !== 'listen') {
+    throw error;
+  }
+
+  var bind = typeof port === 'string'
+    ? 'Pipe ' + port
+    : 'Port ' + port;
+
+  // handle specific listen errors with friendly messages
+  switch (error.code) {
+    case 'EACCES':
+      console.error(bind + ' requires elevated privileges');
+      process.exit(1);
+      break;
+    case 'EADDRINUSE':
+      console.error(bind + ' is already in use');
+      process.exit(1);
+      break;
+    default:
+      throw error;
+  }
+}
+
+/**
+ * Event listener for HTTP server "listening" event.
+ */
+
+function onListening() {
+  var addr = server.address();
+  var bind = typeof addr === 'string'
+    ? 'pipe ' + addr
+    : 'port ' + addr.port;
+  debug('Listening on ' + bind);
+}

db/database.js

@@ -0,0 +1,18 @@
+const sqlite3 = require('sqlite3').verbose();
+
+// ':memory:' crée une BDD en mémoire vive
+const db = new sqlite3.Database(':memory:');
+
+// Initialisation de la BDD avec des utilisateurs
+db.serialize(() => {
+    console.log("Initialisation de la base de données en mémoire...");
+    db.run("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, username TEXT, password TEXT, role TEXT)");
+
+    // On insère un utilisateur "admin" pour le test
+    db.run("INSERT INTO users (username, password, role) VALUES ('admin', 'password123', 'admin')");
+    db.run("INSERT INTO users (username, password, role) VALUES ('user', 'userpass', 'user')");
+    console.log("Utilisateurs de démo créés.");
+});
+
+// Exporter l'instance de la BDD pour qu'elle soit utilisable partout (Singleton)
+module.exports = db;

package.json

@@ -0,0 +1,18 @@
+{
+  "name": "injection-sql",
+  "version": "0.0.0",
+  "private": true,
+  "scripts": {
+    "start": "node ./bin/www"
+  },
+  "dependencies": {
+    "cookie-parser": "~1.4.4",
+    "debug": "~2.6.9",
+    "express": "~4.16.1",
+    "http-errors": "~1.6.3",
+    "morgan": "~1.9.1",
+    "nodemon": "^3.1.10",
+    "pug": "2.0.0-beta11",
+    "sqlite3": "^5.1.7"
+  }
+}

routes/auth_secure.js

@@ -0,0 +1,34 @@
+var express = require('express');
+var router = express.Router();
+var db = require('../db/database'); // Importe notre BDD
+
+/* POST /login - Version SÉCURISÉE */
+router.post('/login', function(req, res, next) {
+    const { username, password } = req.body;
+
+    // == LA CORRECTION (Requête préparée) ==
+    // On utilise des placeholders (?) pour les variables.
+    const sqlQuery = "SELECT * FROM users WHERE username = ? AND password = ?";
+    const params = [username, password]; // Les valeurs sont passées dans un tableau
+
+    console.log("Requête SÉCURISÉE préparée :", sqlQuery);
+    console.log("Valeurs :", params);
+
+    // Le driver (sqlite3) va "assainir" les entrées.
+    // L'injection ' OR 1=1 sera traitée comme une simple chaîne de texte
+    // et non comme du code SQL.
+    db.get(sqlQuery, params, (err, row) => {
+        if (err) {
+            // Transmet l'erreur au gestionnaire d'erreurs d'Express
+            return next(err);
+        }
+
+        if (row) {
+            res.json({ message: `(Sécurisé) Connexion réussie ! Bonjour, ${row.username} (rôle: ${row.role})` });
+        } else {
+            res.status(401).json({ message: "(Sécurisé) Échec de la connexion." });
+        }
+    });
+});
+
+module.exports = router;

routes/auth_vulnerable.js

@@ -0,0 +1,30 @@
+var express = require('express');
+var router = express.Router();
+var db = require('../db/database'); // Importe notre BDD
+
+/* POST /login - Version VULNÉRABLE */
+router.post('/login', function(req, res, next) {
+    const { username, password } = req.body;
+
+    // !! LA FAILLE EST ICI (Concaténation de chaîne) !!
+    const sqlQuery = "SELECT * FROM users WHERE username = '" + username +
+        "' AND password = '" + password + "'";
+
+    console.log("Requête VULNÉRABLE exécutée :", sqlQuery);
+
+    // db.get récupère la première ligne correspondante
+    db.get(sqlQuery, (err, row) => {
+        if (err) {
+            // Transmet l'erreur au gestionnaire d'erreurs d'Express
+            return next(err);
+        }
+
+        if (row) {
+            res.json({ message: `(Vulnérable) Connexion réussie ! Bonjour, ${row.username} (rôle: ${row.role})` });
+        } else {
+            res.status(401).json({ message: "(Vulnérable) Échec de la connexion." });
+        }
+    });
+});
+
+module.exports = router;