Créez un en-tête Content-Security-Policy avec les sources admises
Un en-tête Content-Security-Policy indique au navigateur quels emplacements peuvent fournir scripts, styles, images, polices, cadres et autres ressources.
Lancer gratuitement
Tout se passe dans votre navigateur : gratuit, sans envoi de vos données.
Ce générateur transforme des lignes structurées de directives en une seule valeur correctement séparée, tout en détectant les noms inconnus, doublons, séparateurs dangereux et valeurs absentes. Il convient aux politiques assemblées depuis un outil de déploiement, un écran de configuration, une liste de contrôle de sécurité ou un modèle d’application lorsque vous souhaitez un résultat prévisible sans réunir des fragments à la main ni accepter par erreur une directive mal orthographiée.
Décrivez la politique sous forme de lignes
Saisissez une ligne pour chaque directive à envoyer. Chaque ligne comprend le nom de la directive et une liste ordonnée d’expressions de source ou de jetons. Ainsi, default-src commence souvent par 'self', tandis que script-src peut ajouter un hôte HTTPS précis de diffusion de contenu. Le générateur met les noms en minuscules, retire les espaces extérieurs, conserve l’ordre des lignes et des sources, puis sépare les directives par des points-virgules. Il n’invente aucune directive de repli et n’élargit jamais la politique en silence. Cette distinction compte, car une omission et une autorisation n’ont pas le même effet. Sans img-src, default-src peut s’appliquer, alors qu’un joker supplémentaire peut autoriser davantage d’emplacements que prévu. Considérez chaque source comme un seul jeton CSP et gardez les apostrophes de mots tels que 'self' et 'none'. N’utilisez un schéma comme data: que si l’application en a réellement besoin. Le résultat est la valeur complète, et non le nom de l’en-tête; vous pouvez donc l’affecter directement à Content-Security-Policy sur le serveur ou en périphérie.
La validation repère les erreurs de structure
Le générateur n’accepte que les noms de directives CSP reconnus et signale une erreur d’entrée pour tout nom inconnu. Il détecte ainsi des fautes que le navigateur pourrait ignorer et qui laisseraient certaines ressources moins limitées que prévu. Les doublons sont refusés, car une ligne unique et explicite se contrôle plus facilement et évite les surprises. Les points-virgules, virgules, sauts de ligne et espaces internes sont interdits dans un jeton de source: ils pourraient scinder ou altérer la politique. La plupart des directives exigent au moins une source ou un jeton. En revanche, upgrade-insecure-requests et block-all-mixed-content sont sans valeur: elles nécessitent une liste vide et sont émises seules. L’outil valide la structure; il ne décide ni si un hôte est fiable ni si la politique protège suffisamment votre application. Il ne consulte aucun site, n’inspecte pas le code, ne génère pas de nonce et ne teste pas la compatibilité. Vérifiez les permissions par rapport au comportement réel et déployez les restrictions avec surveillance et environnements progressifs si une rupture peut toucher les utilisateurs.
Déployez, examinez et entretenez le résultat
Copiez la valeur renvoyée dans l’en-tête de réponse Content-Security-Policy. Conservez-la comme configuration auprès de l’application au lieu de disperser des fragments entre intergiciels, règles de proxy et modèles. Une liste centralisée rend les ajouts vérifiables et permet aux systèmes automatisés de régénérer exactement la même chaîne. Commencez par default-src comme base volontaire, puis ajoutez des directives ciblées telles que script-src, style-src, img-src, connect-src, font-src, frame-src, object-src et frame-ancestors lorsque l’application demande un autre comportement. Préférez les hôtes et schémas explicites aux jokers étendus. Pour des hachages ou nonces, fournissez le jeton CSP complet entre apostrophes; la création du nonce appartient à la couche qui traite chaque requête, car cette capacité est déterministe et ne produit aucun aléa. Testez la réponse déployée dans les outils du navigateur et envisagez d’abord un mode de rapport. Les rapports peuvent révéler des dépendances bloquées, mais doivent conduire à des corrections précises plutôt qu’à des permissions générales. Relancez le générateur après chaque modification. Les requêtes API coûtent $0.002, tandis que le navigateur emploie le même algorithme pur.
Cas d’usage
Générez une configuration serveur
Transformez une liste vérifiée de directives CSP en valeur exacte pour la configuration de l’application ou du proxy.
Validez un formulaire de déploiement
Refusez les noms mal orthographiés et les jetons de source incorrects avant que la politique arrive en production.
Gardez un résultat déterministe
Produisez un texte CSP stable depuis une configuration versionnée pour les tests, modèles et automatisations d’infrastructure.
Questions fréquentes
Quel est le tarif ?
Chaque requête API coûte $0.002. La version du navigateur s’exécute localement avec le même algorithme déterministe.
Cet outil vérifie-t-il la sécurité de ma politique ?
Non. Il valide les noms et la structure de sortie, mais vous devez décider quelles sources votre application peut considérer comme fiables.
Les mots-clés doivent-ils garder leurs apostrophes ?
Oui. Saisissez les mots-clés CSP sous forme de jetons complets, par exemple 'self', 'none', 'unsafe-inline' ou 'strict-dynamic'.
Peut-il générer un nonce ?
Non. Un nonce doit être imprévisible et créé pour chaque réponse. Fournissez un jeton nonce déjà préparé et entre apostrophes pour une politique donnée.
Pourquoi les directives en double sont-elles refusées ?
Une ligne par directive est sans ambiguïté, plus simple à contrôler et évite de dépendre du traitement des noms répétés par le navigateur.
Comment ajouter upgrade-insecure-requests ?
Ajoutez cette directive avec une liste de sources vide. Elle sera émise comme une directive sans valeur.
Pour les développeurs — accès API
Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.
Endpoint
Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.
Appeler depuis votre stack
curl -X POST https://api.kit.forhosting.com/security/csp-header-build \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"directives":[{"name":"default-src","sources":["'\''self'\''"]},{"name":"script-src","sources":["'\''self'\''","https://cdn.example.com"]},{"name":"img-src","sources":["'\''self'\''","data:"]}]}'const res = await fetch("https://api.kit.forhosting.com/security/csp-header-build", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"directives": [
{
"name": "default-src",
"sources": [
"'self'"
]
},
{
"name": "script-src",
"sources": [
"'self'",
"https://cdn.example.com"
]
},
{
"name": "img-src",
"sources": [
"'self'",
"data:"
]
}
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/security/csp-header-build",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"directives": [
{
"name": "default-src",
"sources": [
"'self'"
]
},
{
"name": "script-src",
"sources": [
"'self'",
"https://cdn.example.com"
]
},
{
"name": "img-src",
"sources": [
"'self'",
"data:"
]
}
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/security/csp-header-build", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"directives":[{"name":"default-src","sources":["\'self\'"]},{"name":"script-src","sources":["\'self\'","https://cdn.example.com"]},{"name":"img-src","sources":["\'self\'","data:"]}]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"directives":[{"name":"default-src","sources":["'self'"]},{"name":"script-src","sources":["'self'","https://cdn.example.com"]},{"name":"img-src","sources":["'self'","data:"]}]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/security/csp-header-build", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Exemple de requête
{
"directives": [
{
"name": "default-src",
"sources": [
"'self'"
]
},
{
"name": "script-src",
"sources": [
"'self'",
"https://cdn.example.com"
]
},
{
"name": "img-src",
"sources": [
"'self'",
"data:"
]
}
]
}Exemple de réponse
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.csp_header_build",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.
Tarifs
Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.
Erreurs
| HTTP | Code | Signification |
|---|---|---|
401 | unauthorized | Clé API absente ou invalide : vérifiez l’en-tête Authorization. |
402 | insufficient_balance | Solde insuffisant : rechargez votre compte pour lancer cette tâche. |
404 | unknown_type | Type de tâche inconnu : vérifiez le champ type de votre requête. |
429 | rate_limited | Trop de requêtes : ralentissez la cadence, puis réessayez. |