Cartographier les menaces dans un service de connexion simple

Introduction

La modélisation des menaces est une méthode pratique pour anticiper les défaillances potentielles avant qu'un système ne soit attaqué. Plutôt que de commencer par les outils, vous identifiez d'abord ce qui doit être protégé, les endroits où les données franchissent des frontières de confiance, la manière dont un attaquant pourrait se déplacer dans le système et les contrôles qui permettent de réduire les risques.

Dans ce laboratoire, vous allez inspecter un petit service de connexion local et compléter un modèle de menaces structuré dans security-model.json. Ce modèle n'est pas un rapport libre : chaque étape ajoute des entrées JSON spécifiques qui peuvent être vérifiées par un script de validation.

Inspecter le service de connexion

Dans cette étape, vous allez inspecter le petit service que vous allez modéliser. Un modèle de menaces commence par l'observation du comportement du système : ce que fait l'application, les fichiers qu'elle utilise et les informations qui pourraient intéresser un attaquant.

Tout d'abord, accédez au répertoire du projet :

cd /home/labex/project

Listez les fichiers préparés :

ls -l

Vous devriez voir des fichiers tels que app.py, users.json, sessions.json, security-model.json et le répertoire uploads.

Demandez maintenant à l'application de démonstration d'afficher ses routes. Une route est un point d'entrée de l'application qui accepte un certain type de requête :

python3 app.py routes

La sortie devrait afficher quatre routes :

/login - accepte un nom d'utilisateur et un mot de passe, puis crée un jeton de session
/files - liste les fichiers appartenant à l'utilisateur connecté
/download - lit un nom de fichier demandé dans le répertoire uploads
/admin - affiche les enregistrements de compte aux administrateurs uniquement

Enfin, exécutez le vérificateur de modèle actuel. Il signalera des sections manquantes car le modèle est intentionnellement vide :

python3 model-check.py all

Vous devriez voir des messages indiquant que chaque section manque d'entrées requises. C'est le point de départ pour le reste du laboratoire.

Identifier les actifs

Dans cette étape, vous allez ajouter des actifs au modèle. En modélisation des menaces, un actif est tout ce que le système doit protéger. Pour ce service de connexion, les actifs importants ne sont pas seulement des fichiers ; ils incluent également les données d'authentification et l'état de la session.

Utilisez cat pour inspecter la base de données des utilisateurs :

cat users.json

Le fichier contient des noms d'utilisateur, des mots de passe et des rôles. Cela fait de user_credentials et admin_records des actifs importants.

Inspectez le fichier de session et le répertoire des téléchargements :

cat sessions.json

ls -l uploads

Le fichier de session peut contenir des jetons de connexion, et le répertoire uploads contient du contenu utilisateur privé. Ceux-ci correspondent à session_tokens et private_uploads.

Mettez maintenant à jour le tableau assets dans security-model.json. La commande ci-dessous utilise un « here-document » Python. Un « here-document » envoie les lignes situées entre les marqueurs PY à python3 sous forme de script court :

python3 - <<'PY'
import json
from pathlib import Path

path = Path("security-model.json")
model = json.loads(path.read_text())
model["assets"] = [
    "user_credentials",
    "session_tokens",
    "private_uploads",
    "admin_records",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY

Vérifiez uniquement la section des actifs :

python3 model-check.py assets

Le résultat attendu est :

assets: complete

Cartographier les frontières de confiance

Dans cette étape, vous allez ajouter des frontières de confiance. Une frontière de confiance est un endroit où les données circulent entre des zones ayant différents niveaux de contrôle ou de confiance. Les frontières sont utiles car de nombreuses attaques se produisent lorsqu'une entrée non fiable traverse du code, des fichiers ou des fonctions privilégiées de confiance.

Regardez à nouveau la liste des routes :

python3 app.py routes

Les routes /login, /files et /download reçoivent des entrées provenant du côté utilisateur et les transmettent à la logique du serveur. Il s'agit de la frontière browser_to_server dans ce petit modèle.

La route /download lit les noms à partir de la requête, puis accède au répertoire uploads. Cela crée une frontière server_to_filesystem. La route /admin sépare les utilisateurs normaux des données réservées aux administrateurs, elle crée donc une frontière user_to_admin_area.

Ajoutez ces frontières au modèle :

python3 - <<'PY'
import json
from pathlib import Path

path = Path("security-model.json")
model = json.loads(path.read_text())
model["trust_boundaries"] = [
    "browser_to_server",
    "server_to_filesystem",
    "user_to_admin_area",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY

Vérifiez la section des frontières de confiance :

python3 model-check.py trust_boundaries

Le résultat attendu est :

trust_boundaries: complete

Ajouter des vecteurs d'attaque

Dans cette étape, vous allez ajouter des vecteurs d'attaque. Un vecteur d'attaque est une manière concrète pour un attaquant de se déplacer depuis un point d'entrée vers un actif. C'est le cœur de la modélisation des menaces : relier les actifs et les frontières à un comportement d'attaquant réaliste.

Essayez une tentative de connexion avec les identifiants de démonstration :

python3 app.py login alice wonderland

La sortie est un jeton de session :

session-alice-demo

Ce comportement montre pourquoi les mots de passe et les jetons de session sont importants. Un mot de passe faible pourrait permettre une credential_guessing (devinette d'identifiants), et un jeton volé pourrait permettre un session_token_theft (vol de jeton de session).

La route /download accepte un nom de fichier demandé, donc une implémentation négligente pourrait permettre un path_traversal (traversée de chemin). La route /admin protège les enregistrements des administrateurs, donc l'absence de vérification des rôles pourrait permettre un admin_area_abuse (abus de zone d'administration).

Ajoutez ces vecteurs d'attaque au modèle :

python3 - <<'PY'
import json
from pathlib import Path

path = Path("security-model.json")
model = json.loads(path.read_text())
model["attack_paths"] = [
    "credential_guessing",
    "session_token_theft",
    "path_traversal",
    "admin_area_abuse",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY

Vérifiez la section des vecteurs d'attaque :

python3 model-check.py attack_paths

Le résultat attendu est :

attack_paths: complete

Choisir les mesures d'atténuation

Dans cette étape, vous allez terminer le modèle en ajoutant des mesures d'atténuation. Une mesure d'atténuation est un contrôle qui réduit la probabilité ou l'impact d'un vecteur d'attaque. Les bons modèles de menaces associent chaque vecteur d'attaque important à au moins un contrôle pratique.

Utilisez ces associations pour le petit service de connexion :

credential_guessing peut être réduit par rate_limit_login.
session_token_theft peut être réduit par protect_session_tokens.
path_traversal peut être réduit par validate_download_paths.
admin_area_abuse peut être réduit par enforce_admin_authorization.

Ajoutez les mesures d'atténuation au modèle :

python3 - <<'PY'
import json
from pathlib import Path

path = Path("security-model.json")
model = json.loads(path.read_text())
model["mitigations"] = [
    "rate_limit_login",
    "protect_session_tokens",
    "validate_download_paths",
    "enforce_admin_authorization",
]
path.write_text(json.dumps(model, indent=2) + "\n")
PY

Exécutez maintenant la vérification complète du modèle :

python3 model-check.py all

Chaque section devrait être complète :

assets: complete
trust_boundaries: complete
attack_paths: complete
mitigations: complete

Vous pouvez également visualiser le modèle structuré final :

cat security-model.json

Le résultat important est que le modèle relie désormais les actifs protégés, les frontières de confiance, les vecteurs d'attaque et les mesures d'atténuation pour ce même petit service.

Résumé

Vous avez pratiqué un flux de travail de modélisation des menaces sur un petit service de connexion. Vous avez inspecté le service, identifié les actifs, cartographié les frontières de confiance, ajouté des vecteurs d'attaque et associé ces vecteurs à des mesures d'atténuation dans un modèle JSON structuré.

Ce flux de travail aide à relier la réflexion sur la sécurité au comportement observable du système, plutôt que de traiter la modélisation des menaces comme un rapport écrit séparé.