Programme Leçon 65 sur 156 · La Content Security Policy et l'intégration en frame
La Content Security Policy et l'intégration en frame

Écrire une politique

Pourquoi c'est important Une politique trop lâche laisse passer l'attaque ; une politique trop serrée casse ta propre page, et alors quelqu'un désactive la CSP « pour l'instant ». La compétence, c'est d'écrire la politique la plus stricte qui laisse quand même marcher ta page. Tu vas le faire en code, pour que ça marche sur n'importe quelle page, et un correcteur notera les deux moitiés.

Revenons à la liste d'invités. Un bon hôte n'écrit pas « toute personne en joli manteau ». Il regarde qui est vraiment invité et écrit ces noms-là, et personne d'autre. Ici, tu fais pareil : regarde ce que la page charge vraiment, et autorise exactement ça.

L'attaque à arrêter

Au module 10, le texte d'un attaquant sur une page d'entraînement transportait du script : un bloc <script> dans le livre d'or (leçon 58), un <img onerror> qui a échappé au filtre jouet (leçon 61), et un faux code qui envoyait les cookies à prize.example (leçon 62). L'échappement a corrigé ça. Ici, tu ajoutes la deuxième ligne, au cas où un endroit serait un jour oublié. Le code injecté arrive en général sous l'une de trois formes, et les pages d'entraînement ici contiennent les trois :

  • un bloc <script>...</script> en ligne ;
  • un gestionnaire d'événement en ligne, un attribut comme onerror="..." sur une balise d'image ;
  • un <script src="https://prize.example/x.js"> qui pointe vers le serveur de l'attaquant.

Une bonne politique bloque les trois, et laisse quand même la page charger son propre script d'appli, sa feuille de style, ses images, sa bibliothèque de paiement, sa frame vidéo et son unique script en ligne.

Gestionnaire d'événement en ligne : du script écrit directement dans un attribut HTML dont le nom commence par on, comme onerror ou onclick. Le navigateur l'exécute quand cet événement se produit. La CSP le traite comme du script en ligne.

La page d'entraînement et le correcteur

practice_site(seed) de watched.leg3a_csp renvoie une page sous forme de dict : son origin et une liste de resources. Chaque ressource a un kind (script, style, img, font, connect, frame), soit une url soit inline: True, et injected, qui vaut True pour les trois de l'attaquant. Le propre script en ligne de la page porte un nonce : une valeur aléatoire que seul le vrai serveur connaît (la leçon 66 l'explique en détail).

{"kind": "script", "url": "https://pay.example/lib.js", "injected": False}
{"kind": "script", "inline": True, "nonce": "y334r23xgecgnryn", "injected": False}
{"kind": "script", "inline": True, "handler": True, "injected": True}

evaluate(policy, page) joue le navigateur. Elle renvoie broken (les ressources nécessaires que ta politique bloque) et attacks_run (celles injectées qu'elle laisse passer). Tu veux que les deux soient vides. print_report(policy, page) de watched.leg3d_csp_more affiche la même chose de façon lisible.

Un plan

  1. Commence chaque directive par 'self', pour que tes propres fichiers se chargent.
  2. Pour chaque URL extérieure nécessaire, ajoute son schéma et son hôte, comme https://pay.example, à la directive de son type. Pas https: ni * : ceux-là laissent aussi entrer prize.example.
  3. Pour le propre script en ligne de la page, ajoute 'nonce-VALUE' à script-src. Jamais 'unsafe-inline'.
  4. Termine par default-src 'self' pour tout le reste, plus object-src 'none', base-uri 'none' et frame-ancestors 'none', qui ne coûtent rien sur une page qui n'en a pas besoin.

Remarque l'effet sur le gestionnaire d'événement : aucune source que tu peux ajouter n'autorise les attributs onerror= sauf 'unsafe-inline', donc omettre ce mot-clé les bloque tous. Remarque aussi que chaque type a sa propre liste. Si ta page récupère des données sur api.example, cet hôte va dans connect-src, pas dans script-src ; sinon un attaquant capable d'y déposer un fichier pourrait l'exécuter comme script.

Une idée reçue : « script-src https: est strict car il impose HTTPS ». Il n'impose que le schéma. N'importe quel attaquant peut héberger un script sur une adresse HTTPS.

Dans d'autres langages

Une fois que tu as l'en-tête, chaque serveur le pose de la même façon :

// JavaScript (Express)
app.use((req, res, next) => {
  res.set("Content-Security-Policy", "default-src 'self'; object-src 'none'; base-uri 'none'");
  next();
});
// Go (net/http)
w.Header().Set("Content-Security-Policy", "default-src 'self'; object-src 'none'; base-uri 'none'")
// PHP
header("Content-Security-Policy: default-src 'self'; object-src 'none'; base-uri 'none'");
# nginx
add_header Content-Security-Policy "default-src 'self'; object-src 'none'; base-uri 'none'" always;

Dans Django, le paquet django-csp construit l'en-tête à partir des réglages et ajoute un nonce neuf à chaque requête, c'est ainsi que fait ce site.

Récap

  • Autorise exactement les hôtes dont chaque type de ressource a besoin ; jamais * ni https: pour les scripts.
  • Autorise ton propre script en ligne avec un nonce ; omettre 'unsafe-inline' bloque les blocs injectés et les gestionnaires d'événement.
  • Ajoute object-src 'none', base-uri et frame-ancestors, qui ne se replient pas.
  • Vérifie les deux moitiés : rien de nécessaire cassé, rien d'injecté exécuté.
À ton tour

Écris deux fonctions :

  1. source_for(url) : renvoie le schéma et l'hôte de url, comme "https://cdn.example" pour "https://cdn.example/v3.js?x=1" (sans chemin, requête ni fragment).
  2. write_policy(page) : renvoie une chaîne d'en-tête CSP pour une page venant de practice_site. Saute les ressources où injected est activé. Pour chaque autre ressource, utilise DIRECTIVE_FOR pour trouver sa directive ; chaque directive commence par 'self' et reçoit 'nonce-VALUE' pour un script en ligne, ou source_for(url) pour une URL d'une autre origine (sans doublons). Relie avec "; ", en commençant par default-src 'self' et en terminant par object-src 'none', base-uri 'none' et frame-ancestors 'none'. N'utilise pas 'unsafe-inline', * ni https:.
Garde les dernières lignes, qui affichent un rapport pour practice_site(seed=0). Les tests essaient 20 pages d'entraînement différentes et une faite à la main, et vérifient à la fois que rien de nécessaire n'est bloqué et qu'aucun script injecté ne s'exécute.

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.