DevSecOps

Point de départ

// ── 1. Des vulnérabilités, et leur contexte ───────────────────────────────
const VULNERABILITES = [
  { id: "CVE-2025-1001", paquet: "lodash",       gravite: 9.8,
    atteignable: false, enProduction: true,  distance: true,
    note: "prototype pollution dans une fonction que le projet n'appelle pas" },
  { id: "CVE-2025-1002", paquet: "express",      gravite: 6.5,
    atteignable: true,  enProduction: true,  distance: true,
    note: "sur le point d'entrée public" },
  { id: "CVE-2025-1003", paquet: "webpack",      gravite: 8.1,
    atteignable: true,  enProduction: false, distance: false,
    note: "outil de construction, absent de l'image finale" },
  { id: "CVE-2025-1004", paquet: "postgres",     gravite: 7.5,
    atteignable: true,  enProduction: true,  distance: false,
    note: "exploitable avec un accès local sur la machine" },
  { id: "CVE-2025-1005", paquet: "jsonwebtoken", gravite: 7.2,
    atteignable: true,  enProduction: true,  distance: true,
    note: "vérification de signature contournable" },
  { id: "CVE-2025-1006", paquet: "chalk",        gravite: 5.3,
    atteignable: false, enProduction: false, distance: false,
    note: "coloration de sortie, développement seulement" },
];

function score(v) {
  // ← à écrire : pondérer la gravité par l'exploitabilité RÉELLE.
  //   Non atteignable, hors production, ou non exploitable à distance
  //   doivent faire chuter la priorité.
  return v.gravite;
}

// ── 2. Deux images de base ────────────────────────────────────────────────
const IMAGES = {
  "node:20":          { paquets: 412, vulnHautes: 17, vulnMoyennes: 63, mo: 1100 },
  "node:20-alpine":   { paquets: 47,  vulnHautes: 1,  vulnMoyennes: 4,  mo: 130 },
  "distroless/nodejs": { paquets: 12, vulnHautes: 0,  vulnMoyennes: 1,  mo: 110 },
};

// ── 3. Audit de permissions ───────────────────────────────────────────────
const COMPTE = {
  nom: "service-commandes",
  accordes: ["db:read", "db:write", "db:drop", "s3:read", "s3:write",
             "secrets:read", "users:read", "users:write", "deploy:prod"],
};
const JOURNAL_UN_MOIS = [
  "db:read", "db:read", "db:write", "db:read", "s3:read",
  "db:write", "db:read", "s3:read", "db:read", "db:write",
];

// ── À VOUS ────────────────────────────────────────────────────────────────
// 1. Écrivez score(). Comparez le classement par GRAVITÉ et par
//    EXPLOITABILITÉ : les deux premières places sont-elles les mêmes ?
// 2. Chiffrez ce que l'image minimale supprime — sans aucune correction.
// 3. Calculez l'écart entre droits accordés et droits utilisés.

for (const v of VULNERABILITES) console.log("   " + v.id + "  " + v.gravite);

Solution

const VULNERABILITES = [
  { id: "CVE-2025-1001", paquet: "lodash", gravite: 9.8,
    atteignable: false, enProduction: true, distance: true,
    note: "fonction jamais appelée par le projet" },
  { id: "CVE-2025-1002", paquet: "express", gravite: 6.5,
    atteignable: true, enProduction: true, distance: true,
    note: "sur le point d'entrée public" },
  { id: "CVE-2025-1003", paquet: "webpack", gravite: 8.1,
    atteignable: true, enProduction: false, distance: false,
    note: "outil de construction, hors image finale" },
  { id: "CVE-2025-1004", paquet: "postgres", gravite: 7.5,
    atteignable: true, enProduction: true, distance: false,
    note: "demande un accès local" },
  { id: "CVE-2025-1005", paquet: "jsonwebtoken", gravite: 7.2,
    atteignable: true, enProduction: true, distance: true,
    note: "signature contournable" },
  { id: "CVE-2025-1006", paquet: "chalk", gravite: 5.3,
    atteignable: false, enProduction: false, distance: false,
    note: "développement seulement" },
];

function score(v) {
  // Le score de gravité est calculé DANS L'ABSOLU. On le pondère par le
  // contexte, dans l'ordre d'efficacité des trois filtres du cours.
  let s = v.gravite;
  if (!v.atteignable) s *= 0.15;    // le filtre le plus efficace
  if (!v.enProduction) s *= 0.10;   // écartée par la construction multi-étapes
  if (!v.distance) s *= 0.40;       // demande un accès déjà obtenu
  return s;
}

const classer = (cle) => [...VULNERABILITES].sort((a, b) => cle(b) - cle(a));

console.log("— 1. deux classements, deux priorités —");
console.log("   par GRAVITÉ seule                    | par EXPLOITABILITÉ");
const g = classer((v) => v.gravite), e = classer(score);
for (let i = 0; i < VULNERABILITES.length; i++) {
  console.log("   " + (i + 1) + ". " + g[i].paquet.padEnd(13) + g[i].gravite.toFixed(1) +
    "                | " + (i + 1) + ". " + e[i].paquet.padEnd(13) +
    score(e[i]).toFixed(2).padStart(5) + "  " + e[i].note.slice(0, 34));
}
console.log("   Les deux premières places diffèrent : lodash, noté 9,8, tombe en");
console.log("   queue parce que la fonction vulnérable n'est jamais appelée ; express,");
console.log("   noté 6,5, passe en tête parce qu'il est sur le point d'entrée public.");
const aTraiter = VULNERABILITES.filter((v) => score(v) >= 5);
console.log("   À traiter cette semaine : " + aTraiter.length + " sur " +
            VULNERABILITES.length + " — un volume tenable, donc réellement traité.");

console.log("");
console.log("— 2. ce que l'image minimale supprime, sans corriger une ligne —");
const IMAGES = {
  "node:20":           { paquets: 412, vulnHautes: 17, vulnMoyennes: 63, mo: 1100 },
  "node:20-alpine":    { paquets: 47,  vulnHautes: 1,  vulnMoyennes: 4,  mo: 130 },
  "distroless/nodejs": { paquets: 12,  vulnHautes: 0,  vulnMoyennes: 1,  mo: 110 },
};
const base = IMAGES["node:20"];
for (const [nom, i] of Object.entries(IMAGES)) {
  console.log("   " + nom.padEnd(20) + String(i.paquets).padStart(4) + " paquets | " +
    String(i.vulnHautes).padStart(2) + " hautes, " + String(i.vulnMoyennes).padStart(2) + " moyennes | " +
    String(i.mo).padStart(5) + " Mo" +
    (nom === "node:20" ? "" : "   −" + Math.round((1 - i.vulnHautes / base.vulnHautes) * 100) +
     " % de vulnérabilités hautes"));
}
console.log("   Changer une ligne de FROM supprime seize vulnérabilités hautes.");
console.log("   Aucune correction de code, aucune montée de version applicative :");
console.log("   c'est le meilleur rapport effort/résultat de tout le chapitre.");

console.log("");
console.log("— 3. audit de permissions —");
const COMPTE = { nom: "service-commandes",
  accordes: ["db:read", "db:write", "db:drop", "s3:read", "s3:write",
             "secrets:read", "users:read", "users:write", "deploy:prod"] };
const JOURNAL = ["db:read", "db:read", "db:write", "db:read", "s3:read",
                 "db:write", "db:read", "s3:read", "db:read", "db:write"];
const utilises = new Set(JOURNAL);
const inutiles = COMPTE.accordes.filter((d) => !utilises.has(d));
console.log("   compte : " + COMPTE.nom);
console.log("   accordés : " + COMPTE.accordes.length + " droits");
console.log("   utilisés : " + utilises.size + " droits — " + [...utilises].join(", "));
console.log("   JAMAIS UTILISÉS (" + inutiles.length + ") : " + inutiles.join(", "));
const graves = inutiles.filter((d) => /drop|secrets|deploy|users:write/.test(d));
console.log("   dont " + graves.length + " particulièrement dangereux : " + graves.join(", "));
console.log("   Écart : " + Math.round((inutiles.length / COMPTE.accordes.length) * 100) +
            " % des droits accordés ne servent à rien.");
console.log("   Un service qui lit des commandes peut détruire des tables, lire tous");
console.log("   les secrets et déployer en production. Le moindre privilège consiste");
console.log("   exactement à supprimer cet écart — et un mois de journaux suffit à");
console.log("   le calculer, sans deviner.");

Avant de commencer

• Le pipeline du TP 5, qui construit et publie une image
• Les outils trivy et gitleaks, ou leurs équivalents

Énoncé

1. Analyser les dépendances — Lancez une analyse de composition sur le projet et comptez les vulnérabilités remontées. Notez le nombre : c'est lui qui pose le problème du chapitre.
2. Trier par exploitabilité — Pour les dix plus graves, répondez aux trois questions : le code vulnérable est-il atteignable, est-il dans l'image de production, est-il exploitable à distance ? Comparez le classement obtenu à celui par gravité.
3. Analyser l'image — Analysez l'image du TP 3, puis la même application construite sur une base complète. Comparez le nombre de vulnérabilités héritées. Indice : Vous n'aurez modifié qu'une ligne : celle du FROM.
4. Empêcher les secrets d'entrer — Ajoutez un crochet local et une étape de pipeline qui refusent une modification contenant un secret. Testez avec une fausse clé, puis avec une référence à une variable d'environnement — la seconde ne doit PAS déclencher d'alerte.
5. Mesurer les faux positifs — Passez le détecteur sur tout l'historique du dépôt. Comptez les alertes et la part réellement problématique. Que se passerait-il si vous laissiez ce niveau de bruit ?
6. Auditer les droits du pipeline — Listez ce que votre pipeline a le droit de faire. Retirez tout ce dont il n'a pas besoin sur une demande de fusion — notamment le droit de déployer en production.
7. Écrire une règle de conformité — Ajoutez une vérification automatique qui refuse tout manifeste déclarant un conteneur tournant en root. Testez-la sur un manifeste fautif.

C'est réussi quand

• ✓ Le pipeline échoue sur une fausse clé et passe sur une référence à une variable
• ✓ Vous savez nommer les trois ou quatre vulnérabilités qui méritent une action cette semaine
• ✓ Une demande de fusion ne peut plus déployer en production
• ✓ Un manifeste sans utilisateur non privilégié est refusé

Correction

jobs:
secrets:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
      with: { fetch-depth: 0 }     # tout l'historique
    - run: gitleaks detect --redact --exit-code 1

dependances:
  runs-on: ubuntu-latest
  steps:
    - uses: actions/checkout@v4
    - run: trivy fs --severity HIGH,CRITICAL --exit-code 1 .

image:
  needs: [secrets, dependances]
  runs-on: ubuntu-latest
  steps:
    - run: docker build -t tickets:test .
    - run: trivy image --severity CRITICAL --exit-code 1 tickets:test

par gravité             par exploitabilité
1. lodash        9,8     1. express       6,5  point d'entrée public
2. webpack       8,1     2. jsonwebtoken  7,2  signature contournable
3. postgres      7,5     3. postgres      7,5  accès local requis
4. jsonwebtoken  7,2     …  lodash        9,8  fonction jamais appelée
                       …  webpack       8,1  hors image de production

FROM node:20         →  17 vulnérabilités hautes, 412 paquets, 1,1 Go
FROM node:20-alpine  →   1 vulnérabilité haute,  47 paquets, 130 Mo

[allowlist]
description = "faux positifs connus, justifiés un par un"
regexes = [
"process[.]env[.][A-Z_]+",   # une référence, pas une valeur
"[$]2[aby][$][0-9]{2}[$]",   # une empreinte bcrypt, pas un secret
]
paths = ["tests/fixtures/"]    # jeux d'essai, clés factices

# droits minimaux sur une demande de fusion
permissions:
contents: read
pull-requests: write
# AUCUN droit de déploiement : réservé au job déclenché sur main

# règle de conformité, refusée avant application
deny[msg] {
input.kind == "Deployment"
not input.spec.template.spec.securityContext.runAsNonRoot
msg := "le conteneur doit tourner sous un utilisateur non privilégié"
}