AdSense avec une Content Security Policy : la configuration stricte à nonce que Google prend en charge
L'essentiel
- Les éditeurs ne sont pas obligés d'utiliser une Content Security Policy, mais s'ils le font, AdSense ne prend en charge que la CSP stricte fondée sur un nonce aléatoire, et non une liste blanche de domaines.
- Google fournit une politique prise en charge : object-src 'none', un script-src avec un nonce, 'unsafe-inline', 'unsafe-eval', 'strict-dynamic', https: et http:, ainsi que base-uri 'none'.
- Chaque balise script, y compris le chargeur adsbygoogle.js et l'appel push en ligne, doit porter le nonce de la réponse en cours.
- Google précise que des politiques plus restrictives peuvent cesser de fonctionner sans préavis, et que ne pas suivre ses consignes CSP peut perturber la diffusion des annonces.
- Testez d'abord avec l'en-tête Content-Security-Policy-Report-Only, qui signale les violations sans rien bloquer.

Vous n’avez pas besoin d’une Content Security Policy pour faire fonctionner AdSense. Si vous en utilisez une, Google ne prend en charge qu’une CSP stricte fondée sur un nonce aléatoire : chaque balise <script>, y compris le chargeur AdSense et l’appel push() en ligne, porte le nonce généré pour cette réponse, et la politique utilise 'strict-dynamic'. Les listes blanches de domaines ne sont pas prises en charge, car les hôtes utilisés par le code publicitaire changent avec le temps.
Que prend en charge Google ?
L’article de Google Integrate the AdSense ad code with a Content Security Policy commence par deux points qui méritent d’être cités :
- Les éditeurs ne sont pas obligés d’utiliser une CSP (« publishers are not required to use CSP »).
- Vous devez mettre à jour la CSP de votre site pour respecter les consignes documentées par Google ; à défaut, la diffusion des annonces sur votre site peut être perturbée.
L’article compare ensuite les deux manières habituelles d’écrire une CSP : une liste de domaines autorisés, ou un nonce aléatoire que tout script doit porter, ce qu’on appelle la CSP stricte. La position de Google : comme les domaines utilisés par le code publicitaire AdSense changent avec le temps, seule la CSP stricte (option 2) est prise en charge.
Les directives que Google dit prises en charge par le code AdSense :
Content-Security-Policy:
object-src 'none';
script-src 'nonce-{random}' 'unsafe-inline' 'unsafe-eval' 'strict-dynamic' https: http:;
base-uri 'none';
report-uri https://your-report-collector.example.com/
Google ajoute que vous pouvez choisir une politique plus permissive si elle correspond à votre cas, et que des politiques plus restrictives peuvent cesser de fonctionner sans préavis (« More restrictive policies may break without notice »).
À quoi sert chaque élément ?
| Directive ou mot-clé | Rôle | Source |
|---|---|---|
'nonce-{random}' |
Seuls les scripts portant cet attribut nonce s’exécutent | web.dev, CSP stricte |
'strict-dynamic' |
Les scripts chargés par un script de confiance (avec nonce) sont eux aussi de confiance, ce qui permet à adsbygoogle.js de charger ce dont il a besoin | MDN, web.dev |
https: http: |
Solution de repli pour les navigateurs sans 'strict-dynamic' ; les navigateurs qui le prennent en charge les ignorent |
web.dev |
'unsafe-inline' |
Solution de repli pour les très anciens navigateurs ; ignoré lorsqu’un nonce ou une empreinte est présent | MDN, web.dev |
'unsafe-eval' |
Autorise le code de type eval() ; contrairement à 'unsafe-inline', il s’applique encore à côté d’un nonce |
MDN |
object-src 'none' |
Bloque les modules externes comme <object> et <embed> |
web.dev |
base-uri 'none' |
Bloque l’injection de balise <base> |
web.dev |
report-uri |
Destination des rapports de violation envoyés par les navigateurs | Google, MDN |
Notez ce qui est absent : ni default-src, ni img-src, ni frame-src, ni connect-src. Ajouter une ligne default-src 'self' est la manière la plus courante de transformer cette politique en politique « plus restrictive », car elle restreint alors les images, les frames et les requêtes réseau dont dépendent les annonces. Si vous avez besoin de ces directives pour votre propre contenu, gardez-les assez permissives pour les annonces et testez d’abord en mode report-only.
Comment ajouter le nonce au code AdSense ?
L’exemple de Google, adapté avec des valeurs fictives :
<script nonce="RANDOM_NONCE" async
src="https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js?client=ca-pub-0000000000000000"
crossorigin="anonymous"></script>
<ins class="adsbygoogle"
style="display:block"
data-ad-client="ca-pub-0000000000000000"
data-ad-slot="1234567890"
data-ad-format="auto"
data-full-width-responsive="true"></ins>
<script nonce="RANDOM_NONCE">
(adsbygoogle = window.adsbygoogle || []).push({});
</script>
Les deux balises script portent le nonce, exactement comme dans l’exemple de Google. L’exemple de Google utilise aussi une URL //pagead2... sans protocole ; conserver l’URL complète en https:// de votre code généré convient, car 'strict-dynamic' fait confiance à la balise grâce à son nonce, pas à son URL.
Le nonce lui-même doit respecter les règles du guide de la CSP stricte de web.dev : une valeur aléatoire cryptographiquement forte (idéalement 128 bits ou plus), générée à neuf pour chaque réponse, et encodée en base64. Un exemple minimal en Node.js avec Express :
import crypto from "node:crypto";
import express from "express";
const app = express();
app.use((req, res, next) => {
const nonce = crypto.randomBytes(16).toString("base64");
res.locals.nonce = nonce;
res.setHeader(
"Content-Security-Policy",
`object-src 'none'; ` +
`script-src 'nonce-${nonce}' 'unsafe-inline' 'unsafe-eval' 'strict-dynamic' https: http:; ` +
`base-uri 'none'`
);
next();
});
Vos modèles impriment ensuite res.locals.nonce dans chaque attribut nonce.
Comment cela fonctionne-t-il dans les frameworks ?
Next.js. Le guide CSP de Next.js génère le nonce dans proxy.ts, définit l’en-tête et transmet la valeur dans un en-tête de requête x-nonce. Next.js applique ensuite le nonce à ses propres scripts et aux composants <Script> qui reçoivent la prop nonce. Le guide avertit qu’il faut un rendu dynamique pour ajouter des nonces (« you must use dynamic rendering to add nonces ») : les pages générées statiquement ne peuvent pas recevoir un nonce par requête. Le guide AdSense dans Next.js montre le code de la mise en page.
Générateurs de sites statiques (Astro, Hugo, Eleventy). Un nonce écrit dans le HTML au moment du build est identique pour chaque visiteur, ce qui annule son intérêt. Il faut un élément qui s’exécute à chaque requête, par exemple une fonction de périphérie ou un serveur placé devant les fichiers statiques, pour générer le nonce, définir l’en-tête et réécrire les attributs nonce. web.dev recommande une CSP à empreintes pour les pages statiques, mais l’article de Google sur AdSense ne documente que l’approche par nonce : une politique à empreintes seules sort donc de ce que Google dit prendre en charge. Voyez AdSense dans Astro pour le côté mise en page.
Applications monopage. 'strict-dynamic' permet au chargeur muni d’un nonce d’insérer des iframes et des scripts publicitaires après des navigations côté client ; l’appel de push pour les nouveaux emplacements doit venir de votre propre bundle muni d’un nonce, pas de scripts en ligne injectés. Le guide sur les applications monopage traite du moment où faire le push.
Comment tester avant d’appliquer la politique ?
Google recommande de tester d’abord avec l’en-tête Content-Security-Policy-Report-Only : il signale les violations tout en les laissant se produire sur la page (« reports violations but still allows them on the page »). Un plan de déploiement :
- Envoyez la politique dans
Content-Security-Policy-Report-Onlyavec unreport-urique vous pouvez lire. - Chargez des pages avec annonces sur mobile et sur ordinateur, y compris les formats en superposition (ancrée, vignette) et des pages comportant plusieurs unités.
- Lisez la console du navigateur et vos rapports. Les violations provenant de vos propres gestionnaires en ligne (
onclick="...") ou de liensjavascript:demandent une refonte, comme le décrit web.dev. - Remplacez le nom de l’en-tête par
Content-Security-Policyune fois les rapports propres. - Laissez les rapports actifs. Un changement du code publicitaire que votre politique bloque y apparaît avant que les revenus ne baissent.
web.dev note que les balises <meta> de CSP ne prennent pas en charge le mode report-only, et recommande l’en-tête HTTP plutôt que la balise meta. Si votre hébergeur ne vous permet d’ajouter qu’une balise meta, vous ne pouvez pas tester de cette façon.
report-uri ou report-to ?
La politique d’exemple de Google utilise report-uri. MDN décrit cette directive comme obsolète et recommande plutôt l’API Reporting : déclarez un point de terminaison dans un en-tête Reporting-Endpoints et faites pointer la directive report-to de la politique vers lui. MDN ajoute qu’il faut déclarer les deux jusqu’à ce que report-to soit pris en charge par tous les navigateurs (« you should declare both until report-to is supported in all browsers ») :
Reporting-Endpoints: csp-endpoint="https://reports.example.com/csp"
Content-Security-Policy-Report-Only: object-src 'none'; script-src 'nonce-RANDOM_NONCE' 'unsafe-inline' 'unsafe-eval' 'strict-dynamic' https: http:; base-uri 'none'; report-uri https://reports.example.com/csp; report-to csp-endpoint
MDN note aussi que lorsqu’un en-tête Content-Security-Policy et un en-tête Content-Security-Policy-Report-Only sont présents ensemble, les deux politiques sont appliquées (« both policies are honored »). Vous pouvez ainsi continuer à appliquer votre politique actuelle tout en testant en mode report-only une politique candidate plus stricte.
Les contrôles automatisés aident ici. web.dev mentionne que l’audit Bonnes pratiques de Lighthouse peut vérifier si une page a une CSP et si elle est assez stricte pour être efficace contre les XSS ; l’exécuter en intégration continue détecte les régressions, voyez Lighthouse CI pour les pages avec annonces.
Dépannage
| Symptôme | Cause probable | Correctif |
|---|---|---|
| Console : “Refused to load the script … adsbygoogle.js” | La balise du chargeur n’a pas de nonce, ou un nonce périmé | Imprimer le nonce de la réponse en cours sur la balise |
| Le chargeur s’exécute mais les emplacements restent vides | Script push() en ligne bloqué (pas de nonce) |
Ajouter le nonce au script en ligne, ou faire le push depuis votre bundle muni d’un nonce |
| Les annonces fonctionnaient, puis se sont arrêtées après un changement de politique | Ajout de default-src, frame-src ou connect-src |
Les retirer ou les assouplir ; Google indique que des politiques plus strictes peuvent cesser de fonctionner |
| Toutes les pages affichent le même nonce | Nonce généré au moment du build ou HTML mis en cache | Générer à chaque réponse et ne pas mettre en cache le HTML contenant le nonce |
| La bannière de consentement ou la CMP ne fonctionne plus | Ses scripts n’ont pas le nonce | Mettre le nonce sur chaque balise script, y compris votre CMP certifiée |
Erreurs courantes
- Écrire une liste blanche de domaines publicitaires de Google. Google ne la prend pas en charge, et elle cessera de fonctionner quand les domaines changeront.
- Retirer
'unsafe-eval'pour « durcir » la politique. C’est une politique plus restrictive que celle documentée par Google, qui peut cesser de fonctionner sans préavis. - Mettre en cache des pages HTML complètes contenant un nonce. Un CDN qui sert le même HTML à tout le monde sert le même nonce. Générez le nonce en périphérie ou contournez le cache pour le HTML.
- Oublier les balises tierces. L’analyse d’audience, la CMP et tout autre chargeur doivent eux aussi porter le nonce.
Questions fréquentes
Faut-il une Content Security Policy pour utiliser AdSense ?
Non. L'article de Google sur la CSP indique que les éditeurs ne sont pas obligés d'utiliser une CSP. Le sujet ne vous concerne que si votre site envoie déjà un en-tête Content-Security-Policy, ou si vous prévoyez d'en ajouter un pour des raisons de sécurité. Dans ce cas, la politique doit suivre les consignes strictes à nonce de Google, sous peine de perturber la diffusion des annonces.
Puis-je autoriser pagead2.googlesyndication.com par liste blanche au lieu d'utiliser un nonce ?
Google répond que non. Son article explique que les domaines utilisés par le code AdSense changent avec le temps : seule la CSP stricte à nonce aléatoire est donc prise en charge. Une liste blanche qui fonctionne aujourd'hui pourrait cesser de fonctionner sans avertissement le jour où le code publicitaire chargera des ressources depuis un hôte que vous n'avez pas listé.
Pourquoi la politique AdSense de Google comprend-elle 'unsafe-inline' et 'unsafe-eval' ?
Google les range dans les directives que le code AdSense prend en charge, sans en expliquer la raison. MDN note que les navigateurs ignorent 'unsafe-inline' quand un nonce ou une empreinte est présent : il ne sert donc que de solution de repli pour les anciens navigateurs. 'unsafe-eval' continue de s'appliquer à côté d'un nonce. Si vous le retirez, vous appliquez une politique plus restrictive, qui peut selon Google cesser de fonctionner sans préavis.
Un site statique peut-il utiliser AdSense avec une CSP stricte ?
Seulement si quelque chose génère un nonce neuf pour chaque réponse : un nonce figé dans un fichier statique est identique pour tout le monde et peut être deviné. Sur un hébergement statique, cela suppose une fonction de périphérie ou un serveur qui réécrit l'en-tête et les attributs nonce à chaque requête. web.dev suggère des empreintes pour les pages statiques, mais l'article de Google sur AdSense ne documente que l'approche par nonce.
Sources
- Integrate the AdSense ad code with a Content Security Policy (CSP) · Google AdSense Help
- Mitigate cross-site scripting (XSS) with a strict Content Security Policy (CSP) · web.dev
- Content Security Policy (CSP) · MDN Web Docs
- How to set a Content Security Policy (CSP) for your Next.js application · Next.js Docs
Guides liés
- Comment ajouter Google AdSense à un site Next.js avec l'App Router
Installer AdSense dans un projet Next.js App Router : stratégie next/script, composant client pour les unités, changements de route, nonces CSP et fichier ads.txt.
- Comment ajouter Google AdSense à un site Astro (avec ou sans transitions de vue)
Ajouter AdSense à un site Astro : script du head non transformé, composant d'unité publicitaire réutilisable, ClientRouter, chargement en production et ads.txt.
- AdSense dans une application monopage : relancer les emplacements à chaque changement de route sans enfreindre les règles
AdSense dans une application monopage React, Vue ou Svelte : un push par nouvel ins à chaque route, ce que Google ne documente pas et la règle d'actualisation.
- L'exigence de CMP certifiée de Google : ce que les éditeurs AdSense doivent prévoir pour le trafic de l'EEE, du Royaume-Uni et de la Suisse
Depuis 2024, AdSense exige une CMP TCF certifiée Google pour les annonces personnalisées dans l'EEE, au Royaume-Uni et en Suisse : dates, effets, vérification.
- Lighthouse et Lighthouse CI sur des pages chargées de publicité : configuration, budgets et mesure de l'impact des tiers
Lancez Lighthouse et Lighthouse CI sur des pages AdSense : configuration testée, budgets pour les scripts tiers, comparaison avec et sans annonces.