Générateur d'en-têtes CSP gratuit

Créez des en-têtes Content Security Policy pour votre site web. Gratuit, rapide et fonctionnant entièrement dans votre navigateur, sans inscription.

Mis à jour le

Share:
Home/Security Tools/CSP Generator

CSP Generator

Build Content Security Policy headers interactively with presets, directive builder, nonce support, and strictness scoring.

CSP Builder

Strictness Score
70/100
Nonce:Not generated

Directives

default-src
L1

Fallback for other fetch directives

'self'
script-src
L1

Valid sources for JavaScript

'self'
style-src
L1

Valid sources for stylesheets

'self'
'unsafe-inline'
img-src
L1

Valid sources for images

'self'
data:
font-src
L1

Valid sources for fonts

'self'
connect-src
L1

Valid targets for fetch, XHR, WebSocket

'self'
object-src
L1

Valid sources for plugins (Flash, etc.)

'none'
frame-ancestors
L2

Valid parents that can embed this page

'none'

Questions Fréquentes

Qu'est-ce que le générateur de CSP ?

Le générateur de CSP est un outil en ligne gratuit qui crée des en-têtes Content Security Policy pour protéger votre site web contre les attaques XSS, le clickjacking et d'autres attaques par injection.

Le générateur de CSP est-il gratuit ?

Oui, il est entièrement gratuit et ne nécessite aucune inscription. Toute la génération de politiques se fait côté client dans votre navigateur.

Pourquoi ai-je besoin d'une Content Security Policy ?

Une CSP indique aux navigateurs quelles sources de contenu sont fiables, bloquant ainsi les scripts malveillants et réduisant le risque d'attaques par cross-site scripting (XSS) sur votre site web.

Mes données sont-elles en sécurité avec cet outil ?

Absolument. Le générateur d'en-têtes CSP traite tout côté client dans votre navigateur. Aucune donnée n'est envoyée ni stockée sur un serveur. Votre contenu reste privé sur votre appareil à tout moment.

Le générateur d'en-têtes CSP fonctionne-t-il sur les appareils mobiles ?

Oui, le générateur d'en-têtes CSP est entièrement adaptatif et fonctionne sur smartphones et tablettes. Vous pouvez l'utiliser sur tout appareil doté d'un navigateur web moderne, sans aucune application à télécharger.

Dois-je créer un compte pour utiliser cet outil ?

Aucun compte ni inscription n'est nécessaire. Ouvrez simplement le générateur d'en-têtes CSP dans votre navigateur et commencez à l'utiliser immédiatement. Il n'y a ni page d'inscription ni restriction d'utilisation.

Comment utiliser le générateur d'en-têtes CSP ?

Saisissez simplement votre texte dans le champ prévu à cet effet, ajustez les paramètres selon vos préférences et l'outil le traitera instantanément. Vous pouvez ensuite copier le résultat dans le presse-papiers ou le télécharger.

Quels navigateurs sont pris en charge ?

Le générateur d'en-têtes CSP fonctionne sur tous les navigateurs modernes, notamment Chrome, Firefox, Safari, Edge et Opera. Pour une expérience optimale, utilisez la dernière version de votre navigateur préféré.

Quelle est la différence entre 'self', 'none' et 'unsafe-inline' dans une CSP ?

Ce sont des mots-clés source CSP qui indiquent au navigateur quel contenu une directive autorise. 'self' n'autorise les ressources que depuis votre propre origine (même schéma, même hôte, même port) : un script-src défini sur 'self' charge donc vos propres scripts mais bloque ceux de tiers. 'none' est la valeur la plus stricte : elle bloque toute source pour cette directive, ce qui explique pourquoi object-src 'none' est une mesure de durcissement courante. 'unsafe-inline' réactive les scripts et styles inline écrits directement dans votre HTML, et 'unsafe-eval' autorise le code basé sur eval() ; les deux sont pratiques mais rouvrent exactement la faille XSS que la CSP est censée fermer, d'où l'intérêt d'utiliser plutôt un nonce ou un hash quand c'est possible. Ce générateur vous permet de cliquer directement ces mots-clés sur chaque directive et montre comment chaque choix fait évoluer votre score de rigueur, afin de visualiser le compromis de sécurité au fil de la construction.

Pourquoi ma Content Security Policy ne fonctionne-t-elle pas dans une balise meta HTML ?

Certaines directives sont tout simplement ignorées lorsque la CSP est transmise via une balise meta HTML au lieu d'un véritable en-tête de réponse HTTP. La directive frame-ancestors, qui empêche le clickjacking en contrôlant qui peut intégrer votre page dans un cadre, ne fonctionne qu'en en-tête car la décision de cadrage intervient avant que le document n'analyse la balise meta. La directive report-uri, utilisée pour collecter les rapports de violation, ainsi que la directive sandbox, sont ignorées en meta pour la même raison. Si vos règles anti-clickjacking ou de reporting semblent ne rien faire, c'est généralement pour cette raison. Partout où vous contrôlez la configuration de votre serveur, privilégiez l'en-tête HTTP. Cet outil signale précisément cette limite dans sa vue Sortie et fournit l'en-tête brut Content-Security-Policy accompagné de blocs de configuration prêts à coller pour Nginx, Apache, Express.js et Next.js, afin que vous puissiez déployer correctement.

Comment utiliser un nonce CSP pour autoriser un script inline précis en toute sécurité ?

Un nonce est un jeton aléatoire à usage unique qui permet de faire confiance à un script inline précis sans ouvrir la porte avec 'unsafe-inline'. Vous ajoutez la valeur 'nonce-{random}' à votre directive script-src, puis vous placez l'attribut nonce correspondant sur la balise script que vous voulez autoriser, par exemple <script nonce="{random}">. Le navigateur n'exécute que les scripts inline portant exactement ce jeton et bloque tout autre script injecté, de sorte qu'un attaquant incapable de deviner la valeur ne peut pas exécuter sa charge utile. La règle essentielle est que le nonce doit être généré à nouveau à chaque chargement de page, jamais codé en dur ni réutilisé. Ce générateur crée un nonce cryptographiquement fort avec l'API crypto.getRandomValues() du navigateur et vous fournit la chaîne 'nonce-...' déjà formatée à copier à la fois dans votre politique et dans vos balises script.

Quelle est la différence entre le mode rapport seul et l'application stricte d'une CSP ?

Une politique trop stricte bloque silencieusement des scripts, styles ou appels API légitimes, ce qui rend risqué le déploiement direct d'une CSP en mode strict. Le mode rapport seul résout ce problème. En envoyant la politique via l'en-tête Content-Security-Policy-Report-Only au lieu de Content-Security-Policy, le navigateur ne bloque rien : il se contente de consigner chaque violation qu'il aurait provoquée, en envoyant les détails à votre point de terminaison report-uri. Cela permet d'observer le trafic réel, de repérer quelles ressources déclenchent la politique, et de corriger les règles avant qu'un utilisateur ne voie une page cassée. Le déploiement prudent standard consiste à démarrer en rapport seul, à surveiller jusqu'à ce que les rapports se taisent, puis à basculer vers l'en-tête d'application stricte. Utilisez le générateur de cet outil pour assembler et ajuster la politique, et sa vue Test pour vérifier des URL précises face à vos directives avant de passer en application stricte.

Quel préréglage CSP choisir pour WordPress ou une application monopage (SPA) ?

Partir d'une base sensée est plus rapide et plus sûr que de tout construire à partir de zéro, et le bon point de départ dépend de votre infrastructure. Le préréglage WordPress est plus permissif car les thèmes et extensions injectent fréquemment des scripts et styles inline ; il autorise donc 'unsafe-inline' et des sources d'intégration courantes comme YouTube et Vimeo, afin d'éviter de casser le tableau de bord et le site public. Le préréglage SPA convient aux applications React, Vue ou Angular : il garde script-src strict sur 'self', ajoute worker-src pour les workers blob, et ouvre connect-src pour votre API et vos points de terminaison WebSocket. Il existe aussi des préréglages Strict, Modéré et Souple couvrant toute la gamme, du plus verrouillé au plus permissif. Appliquez le préréglage le plus proche dans cet outil, puis affinez ou étendez les directives individuelles selon vos véritables domaines tiers, pendant que le score de rigueur en direct vous guide vers une politique plus stricte.

À propos du générateur d'en-tête CSP

Le générateur d'en-tête CSP est un outil gratuit pour construire une Content Security Policy — l'en-tête de réponse HTTP qui indique au navigateur quelles sources de scripts, styles, images, polices et autres ressources il est autorisé à charger sur votre page. Une politique bien réglée est l'une des défenses les plus solides contre le cross-site scripting (XSS), car elle empêche le navigateur d'exécuter des scripts injectés ou tiers que vous n'avez jamais approuvés. Cet outil s'adresse aux développeurs web, aux propriétaires de sites et aux ingénieurs sécurité qui veulent une politique correcte sans avoir à mémoriser la syntaxe.

Tout se passe dans votre navigateur. Aucune inscription, aucun envoi de fichier, rien n'est transmis à un serveur — vous assemblez la politique directement sur votre appareil et copiez le résultat obtenu. Cette conception entièrement côté client signifie aussi que l'outil fonctionne dès le chargement de la page.

Construisez votre politique directive par directive

Vous composez une politique à partir de directives individuelles, chacune contrôlant un type de ressource. Le générateur prend en charge 15 directives couvrant les niveaux CSP 1 à 3, dont default-src, script-src, style-src, img-src, font-src, connect-src, frame-ancestors, base-uri, form-action, ainsi que des ajouts plus récents comme worker-src et manifest-src. Pour chaque directive, vous ajoutez des valeurs sources — soit en cliquant sur des suggestions courantes telles que 'self', 'none', data: ou https:, soit en saisissant une origine personnalisée. Si vous préférez partir d'une base éprouvée, cinq préréglages sont accessibles en un clic : Strict, Modéré, Souple, WordPress et SPA.

Pour autoriser en toute sécurité certains scripts inline précis, l'outil génère également un nonce cryptographique grâce à l'API crypto.getRandomValues() du navigateur, prêt à être inséré à la fois dans votre politique et dans vos balises <script>.

Suivez le score de rigueur en temps réel

Un score de rigueur en direct, sur 100, reflète à quel point votre politique est verrouillée. Il valorise les choix qui comptent le plus : un default-src restrictif, un script-src dépourvu de 'unsafe-inline' et de 'unsafe-eval', un object-src 'none', un frame-ancestors défini, et un report-uri pour collecter les rapports de violation. Ces mots-clés méritent d'être bien compris :

  • 'self' n'autorise les ressources que depuis votre propre origine.
  • 'none' bloque toute source pour cette directive.
  • 'unsafe-inline' et 'unsafe-eval' rouvrent la porte au code inline et au code basé sur eval() — pratique, mais cela affaiblit la protection que la CSP est censée offrir.
  • 'strict-dynamic', les nonces et les hashes constituent la manière moderne et plus sûre de faire confiance à des scripts précis.

Ce score est un indicateur rapide, pas une garantie : testez toujours votre politique sur de vraies pages avant de l'appliquer en mode strict.

Copiez le résultat dans le format que vous déployez

Une fois que la politique correspond à ce que vous voulez, la vue Sortie fournit des extraits prêts à coller : l'en-tête HTTP brut Content-Security-Policy:, une balise HTML <meta>, ainsi que des blocs de configuration serveur pour Nginx, Apache, Express.js et Next.js. Un rappel que l'outil affiche : certaines directives — frame-ancestors, report-uri et sandbox — ne fonctionnent que sous forme d'un véritable en-tête HTTP et sont ignorées dans une balise meta ; privilégiez donc l'en-tête partout où vous contrôlez la configuration du serveur.

Testez avant d'appliquer

Les échecs de CSP sont fréquents car une politique trop stricte bloque silencieusement des ressources légitimes. La vue Test vous permet de coller une URL — par exemple un script CDN ou un point de terminaison analytics — et de voir, directive par directive, si votre politique actuelle l'autoriserait ou la bloquerait. Une série d'exemples de violations courantes montre les cas typiques, des scripts inline et styles inline aux tentatives de clickjacking interceptées par frame-ancestors, chacun accompagné de sa correction. Un déploiement prudent consiste à commencer en mode rapport seul, à observer ce qui se déclenche, puis à passer en application stricte une fois les rapports silencieux.

Construisez votre politique ci-dessus, regardez le score de rigueur grimper, et copiez-la dans le format adapté à votre infrastructure.