Crei un header Content-Security-Policy con le fonti consentite
Quattro righe, da default-src con 'self' fino a upgrade-insecure-requests senza fonti, diventano un’unica riga di policy unita da punti e virgola, nel suo ordine. Le direttive sconosciute o ripetute vengono respinte. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Funziona nel tuo browser: gratis, senza registrazione, i file non escono dal tuo dispositivo.
Un header Content-Security-Policy indica al browser quali posizioni possono fornire script, stili, immagini, font, frame e altre risorse. Questo generatore trasforma righe strutturate di direttive in un unico valore correttamente separato, rilevando nomi sconosciuti, duplicati, separatori pericolosi e valori mancanti. È utile quando una policy viene composta tramite uno strumento di distribuzione, una schermata di configurazione, una checklist di sicurezza o un modello applicativo e Lei desidera un risultato prevedibile senza unire frammenti manualmente o accettare per errore una direttiva scritta male.
Descriva la policy tramite righe di direttive
Inserisca una riga per ogni direttiva che intende inviare. Ogni riga contiene il nome della direttiva e un elenco ordinato di espressioni di origine o token. Il generatore converte i nomi in minuscolo, elimina gli spazi esterni da ogni fonte, conserva l’ordine di righe e fonti e unisce le direttive con punti e virgola.
Non inventa direttive di ripiego e non amplia silenziosamente la policy. È importante, perché omissione e autorizzazione hanno effetti di sicurezza diversi. Se manca img-src può essere applicata default-src, mentre un carattere jolly aggiuntivo può consentire più posizioni del previsto.
Consideri ogni fonte un singolo token CSP e mantenga gli apici di parole come 'self' e 'none'. Fornisca schemi come data: solo quando l’applicazione ne ha davvero bisogno. Il risultato è il valore completo, non il nome dell’header, quindi può assegnarlo direttamente a Content-Security-Policy nella configurazione del server o edge.
La convalida rileva gli errori strutturali
Il generatore accetta soltanto nomi di direttive CSP riconosciuti e segnala un errore di input quando un nome è sconosciuto. In questo modo individua refusi che il browser potrebbe ignorare, lasciando una categoria di risorse meno limitata del previsto. Anche le direttive duplicate vengono respinte, perché una sola riga esplicita è più semplice da controllare ed evita sorprese.
Punti e virgola, virgole, ritorni a capo e spazi interni non sono ammessi nei singoli token di fonte, poiché potrebbero dividere o danneggiare la policy. Quasi tutte le direttive richiedono almeno una fonte o un token. upgrade-insecure-requests e block-all-mixed-content, invece, non hanno valore: richiedono un elenco vuoto e vengono emesse solo con il nome. Lo strumento verifica la struttura, non stabilisce se un host sia affidabile o se la policy protegga adeguatamente l’applicazione.
Inoltre non visita siti, non analizza codice, non genera nonce e non prova la compatibilità. Confronti i permessi con il comportamento reale e distribuisca le restrizioni con monitoraggio e ambienti graduali quando un malfunzionamento potrebbe colpire gli utenti.
Distribuisca, esamini e mantenga il risultato
Copi il valore restituito nell’header di risposta Content-Security-Policy. Lo conservi come configurazione insieme all’applicazione, invece di spargere frammenti tra middleware, regole proxy e modelli. Un elenco centralizzato rende verificabili le aggiunte e consente ai sistemi automatici di rigenerare esattamente la stessa stringa a ogni esecuzione.
Parta da default-src come base intenzionale, quindi aggiunga direttive mirate come script-src, style-src, img-src, connect-src, font-src, frame-src, object-src e frame-ancestors quando l’applicazione richiede un comportamento diverso. Preferisca host e schemi espliciti ai caratteri jolly ampi. Se usa hash o nonce, fornisca il token CSP completo tra apici; la creazione del nonce spetta al livello che gestisce ogni richiesta, perché questa capacità è deterministica e non genera valori casuali.
Verifichi la risposta distribuita negli strumenti del browser e valuti prima una modalità di sola segnalazione. I report possono rivelare dipendenze bloccate, ma devono portare a correzioni precise, non a permessi indiscriminati. Riesegua il generatore dopo ogni modifica di configurazione.
Casi d'uso
Generi la configurazione del server
Converta un elenco verificato di direttive CSP nel valore esatto usato dalla configurazione dell’applicazione o del proxy.
Convalidi un modulo di distribuzione
Respinga nomi di direttive errati e token di fonte malformati prima che la policy raggiunga la produzione.
Mantenga un output deterministico
Produca testo CSP stabile da configurazione versionata per test, modelli e automazione dell’infrastruttura.
Domande frequenti
Quanto costa?
La versione nel browser viene eseguita localmente con lo stesso algoritmo deterministico.
Verifica se la mia policy è sicura?
No. Convalida i nomi delle direttive e la struttura dell’output, ma spetta a Lei decidere quali fonti siano affidabili per l’applicazione.
Le parole chiave devono mantenere gli apici?
Sì. Inserisca le parole chiave CSP come token completi, per esempio 'self', 'none', 'unsafe-inline' o 'strict-dynamic'.
Può generare un nonce?
No. I nonce devono essere imprevedibili e creati per ogni risposta. Fornisca un token nonce già preparato e tra apici quando compone una policy specifica.
Perché le direttive duplicate vengono respinte?
Una riga per direttiva è inequivocabile, più facile da controllare ed evita di dipendere dal comportamento del browser per nomi ripetuti.
Come aggiungo upgrade-insecure-requests?
Aggiunga la direttiva con un elenco di fonti vuoto. Verrà emessa come direttiva senza valore.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo 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)Esempio di richiesta
{
"directives": [
{
"name": "default-src",
"sources": [
"'self'"
]
},
{
"name": "script-src",
"sources": [
"'self'",
"https://cdn.example.com"
]
},
{
"name": "img-src",
"sources": [
"'self'",
"data:"
]
}
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "security.csp_header_build",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Descriva la policy tramite righe di direttive
Per esempio, default-src inizia spesso con 'self', mentre script-src può aggiungere uno specifico host HTTPS per la distribuzione dei contenuti.
Distribuisca, esamini e mantenga il risultato
Le richieste API costano $0.002, mentre il browser usa lo stesso algoritmo puro.