Programme Leçon 96 sur 156 · La modélisation des menaces
La modélisation des menaces

Projet de l'étape 4 : une modélisation des menaces

Pourquoi c'est important Ce projet réunit l'étape 4. Tu vas écrire une vraie modélisation des menaces pour un produit que tu utilises vraiment, sous forme de données Python, et le code qui la vérifie avec une grille. Tu finis avec un outil réutilisable pour n'importe quel produit, et une liste claire des trois choses à corriger en premier.

La commande

Choisis un produit que tu utilises : une appli de messagerie, un bracelet de sport, un site de vente, une enceinte connectée. Écris sa modélisation des menaces de ton point de vue d'utilisateur dans un dictionnaire appelé MODEL, puis écris trois fonctions qui la vérifient et la classent.

Gardé privé : ton code est noté dans ton propre navigateur. Si tu actives la sauvegarde sur tous les appareils, tes brouillons sont aussi stockés sur le serveur de Floati, ce qui est une raison de plus de rester général. Même ainsi, garde la modélisation générale : écris « mes messages » ou « mon adresse personnelle », jamais de vrais mots de passe, noms d'utilisateur, adresses ou numéros de compte. Une modélisation des menaces porte sur la forme du risque, pas sur les secrets eux-mêmes.

La forme de MODEL

MODEL = {
    "product": "a fitness tracker app (fitly.example)",
    "assets": ["my running routes", "my heart-rate history", "my contacts"],
    "adversaries": [
        {"who": "advertisers", "wants": "my habits", "capability": "buy data from the app"},
        {"who": "a stranger", "wants": "where I live", "capability": "see public route maps"},
    ],
    "threats": [
        {"id": "T1", "asset": "my running routes", "adversary": "a stranger",
         "what": "public maps show where my runs start, near my home",
         "likelihood": 2, "impact": 3},
        # ... at least 4 threats
    ],
    "mitigations": [
        {"threat": "T1", "action": "hide the first and last 500 m of every route", "owner": "me"},
        # ... at least one for every threat
    ],
}

L'asset de chaque menace doit être l'un de tes assets, et l'adversary de chaque menace doit correspondre au "who" d'un adversaire. Ça rend la modélisation cohérente : chaque menace dit exactement ce qu'elle touche et qui la mène. owner dit qui applique la mesure d'atténuation : "me" ou "product" (ce que tu demanderais à l'entreprise de changer).

La grille

VérificationCode du problème si elle échoue
Un nom de produit non videno-product
Au moins 3 actifsfew-assets
Au moins 2 adversairesfew-adversaries
Au moins 4 menacesfew-threats
L'actif de chaque menace est dans la liste des actifsunknown-asset:T1 (avec l'id de cette menace)
L'adversaire de chaque menace correspond à un « who »unknown-adversary:T1
La probabilité et l'impact valent chacun 1, 2 ou 3bad-score:T1
Chaque menace a au moins une mesure d'atténuationunmitigated:T1

Auto-évaluation et retours du tuteur

Les tests vérifient que ta modélisation est complète et cohérente, et que tes fonctions sont justes. Ils ne peuvent pas juger si tes menaces sont les bonnes menaces. Pour ça, lis tes trois principales menaces à voix haute et demande-toi : quelqu'un qui connaît ce produit serait-il d'accord que ce sont les plus gros risques ? Tu peux aussi appuyer sur le bouton de relecture de code du tuteur sur l'appareil pour avoir des commentaires sur ton travail. Il tourne dans ton navigateur, donc la modélisation reste avec toi. C'est un petit modèle, donc traite ses notes comme des pistes de réflexion, pas comme un verdict. Les vérifications automatiques prouvent que ta modélisation est complète ; savoir si elle est juste, c'est la partie que tu juges toi-même.

Conseils pour une bonne modélisation

  • Utilise ce que tu as appris : cookies, empreintes, pixels et consentement (étape 1), comment marchent les traqueurs en code (étape 2), tiers et fuites sur les sites (étape 3), ce que HTTPS et le chiffrement de bout en bout cachent ou non, et où les fonctions d'IA envoient ton texte.
  • Inclus au moins une menace ordinaire (un mot de passe réutilisé, un téléphone perdu) et une sur le produit lui-même (ce qu'il collecte, avec qui il partage).
  • Préfère des mesures d'atténuation que tu appliqueras vraiment cette semaine à des mesures parfaites que tu n'appliqueras pas.
Dans d'autres langages

JavaScript : le classement des risques avec un tri en deux parties.

const risk = t => t.likelihood * t.impact;
function topThreats(model, n = 3) {
  return [...model.threats]
    .sort((a, b) => risk(b) - risk(a) || a.id.localeCompare(b.id))
    .slice(0, n)
    .map(t => t.id);
}

Rust : le même ordre avec sort_by.

threats.sort_by(|a, b| risk(b).cmp(&risk(a)).then(a.id.cmp(&b.id)));

Récap

  • Une modélisation des menaces sous forme de données peut être vérifiée par du code : complète, cohérente et classée.
  • Le risque, c'est la probabilité fois l'impact ; les égalités sont départagées par l'id de la menace pour que l'ordre soit toujours le même.
  • Les tests vérifient la structure ; toi et le tuteur jugez si les menaces sont les bonnes.
  • Garde ta modélisation générale et privée : décris les risques, n'écris jamais les secrets.
À ton tour

Remplis MODEL pour un produit que tu utilises (voir la forme ci-dessus) : une chaîne "product", au moins 3 "assets", au moins 2 "adversaries" (chacun avec des "who", "wants" et "capability" non vides), au moins 4 "threats" et une mesure d'atténuation (avec une "action" non vide et un "owner" valant "me" ou "product") pour chaque menace. Puis écris :

  1. risk(threat) : renvoie likelihood * impact.
  2. top_threats(model, n=3) : renvoie les id des n menaces au risque le plus élevé, la plus élevée d'abord ; quand deux menaces ont le même risque, le plus petit id (dans l'ordre normal des chaînes) vient en premier.
  3. rubric(model) : renvoie une liste de codes de problèmes tirés du tableau de la grille, ou [] quand la modélisation passe. Vérifie d'abord les quatre règles sur toute la modélisation, puis chaque menace dans l'ordre de la liste, en vérifiant l'actif, l'adversaire, la note, la mesure d'atténuation dans cet ordre. Utilise .get avec des valeurs par défaut pour qu'une modélisation aux clés manquantes ne fasse pas planter.
Enfin, affiche rubric(MODEL) et top_threats(MODEL).

Tu as repéré un problème dans cette leçon ? Signale-le · Pose une question sur cette leçon

Cet exercice s'ouvre bientôt

Termine la leçon précédente pour débloquer celle-ci. Tout le cours est gratuit, aucun compte n'est requis, et tu peux lire cette leçon dès maintenant.