Content-Security-Policy (CSP): guida alla sicurezza web e protezione dagli attacchi XSS

Scopri cos'è la Content-Security-Policy (CSP), come funziona e come configurarla per proteggere le applicazioni web dagli attacchi XSS, controllare le risorse e migliorare la sicurezza frontend. 
Cos'è la Content-Security-Policy (CSP)
La Content-Security-Policy (CSP) è una policy di sicurezza implementata dal browser che consente di controllare quali risorse possono essere caricate ed eseguite all'interno di una pagina web. Attraverso una serie di direttive, è possibile limitare le origini da cui provengono script, fogli di stile, immagini, font, connessioni e altri contenuti.
Il suo obiettivo principale è ridurre la superficie di attacco di un'applicazione web, impedendo al browser di eseguire contenuti non autorizzati, anche quando una vulnerabilità permette a un attaccante di iniettare codice HTML o JavaScript all'interno della pagina (per esempio, nel caso di un attacco SQL injection).
La CSP rappresenta quindi un importante livello di difesa aggiuntivo, soprattutto contro gli attacchi Cross-Site Scripting (XSS), ma non sostituisce la corretta validazione degli input, l'escaping dei dati, l'utilizzo di API sicure e le altre misure necessarie per proteggere un'applicazione.
Come funziona una Content-Security-Policy
Una Content-Security-Policy viene comunicata al browser attraverso
un header HTTP di risposta, oppure tramite un elemento
<meta> inserito nel documento HTML.
Una volta ricevuta, il browser applica le regole definite dalla policy
e verifica che le risorse richieste dalla pagina rispettino le
restrizioni configurate.
Se una risorsa non rientra tra quelle consentite, il browser ne blocca il caricamento o l'esecuzione, a seconda della direttiva coinvolta, e registra un messaggio nella console degli strumenti di sviluppo.
Ad esempio, una policy che consente di caricare script esclusivamente dalla stessa origine dell'applicazione impedisce l'esecuzione di script provenienti da domini esterni non autorizzati.
Content-Security-Policy: script-src 'self'
In questo caso, la direttiva script-src autorizza
gli script provenienti dalla stessa origine, identificata dal valore
'self'. Eventuali script caricati da domini differenti
verranno bloccati.
È importante considerare che la CSP non verifica se una risorsa sia affidabile dal punto di vista del contenuto o della logica applicativa. Autorizzare un dominio significa consentire al browser di utilizzare le risorse provenienti da quell'origine, non garantire che tali risorse siano sicure.
Come configurare la CSP
Il metodo consigliato per implementare una Content-Security-Policy
consiste nell'impostarla attraverso l'header HTTP
Content-Security-Policy, configurato direttamente
sul server web, sul reverse proxy, sul framework applicativo
o sul sistema che gestisce le risposte HTTP.
Un esempio di configurazione minimale potrebbe essere il seguente:
Content-Security-Policy: default-src 'self';
Questa policy stabilisce che, in assenza di direttive più specifiche, le risorse possono essere caricate esclusivamente dalla stessa origine del documento.
Il valore 'self' rappresenta l'origine corrente,
comprensiva di protocollo, host e porta. Non autorizza automaticamente
altri domini, sottodomini o protocolli.
Una policy più articolata può definire regole specifiche per ogni tipologia di risorsa:
Content-Security-Policy:
default-src 'self';
script-src 'self';
style-src 'self';
img-src 'self' https://images.example.com;
font-src 'self';
connect-src 'self' https://api.example.com;
object-src 'none';
base-uri 'self';
form-action 'self';
Questa configurazione consente di caricare script, stili e font
dalla stessa origine, immagini anche da un dominio dedicato e
connessioni HTTP verso un endpoint API autorizzato.
Inoltre, impedisce l'utilizzo di plugin e limita la destinazione
dei form e il comportamento dell'elemento base.
La policy deve essere adattata alle esigenze del progetto: aggiungere domini senza una reale necessità aumenta le origini considerate attendibili e riduce l'efficacia delle restrizioni.
Le principali direttive CSP
La Content-Security-Policy dispone di numerose direttive, ciascuna progettata per controllare una specifica tipologia di risorsa o un comportamento del browser. Comprenderne il funzionamento è fondamentale per costruire una policy efficace e mantenibile.
default-src
default-src definisce la policy predefinita per
le risorse che non dispongono di una direttiva specifica.
È generalmente il punto di partenza di una CSP e consente
di stabilire una regola generale da cui derivare restrizioni
più precise.
default-src 'self';
Nell'esempio, tutte le tipologie di risorse prive di una direttiva
dedicata potranno essere caricate esclusivamente dalla stessa origine.
Se una risorsa dispone di una direttiva specifica, come
img-src, quest'ultima prevale sulla regola predefinita.
script-src
script-src controlla le origini da cui possono essere
caricati ed eseguiti gli script JavaScript, oltre a disciplinare
alcune modalità di esecuzione degli script inline e dinamici.
È una delle direttive più importanti per la prevenzione degli attacchi XSS.
script-src 'self' https://scripts.example.com;
Questa configurazione consente gli script provenienti dall'origine corrente e dal dominio specificato. Tuttavia, autorizzare un dominio esterno significa consentire anche l'esecuzione di script che potrebbero diventare vulnerabili, essere compromessi o includere contenuti non affidabili.
style-src
style-src definisce le origini autorizzate per
i fogli di stile CSS e controlla, in determinate condizioni,
l'utilizzo di stili inline.
style-src 'self' https://styles.example.com;
È consigliabile evitare di autorizzare indiscriminatamente gli stili
inline attraverso 'unsafe-inline', soprattutto quando
si desidera mantenere una policy restrittiva.
img-src
img-src controlla le origini da cui possono essere
caricate le immagini, comprese quelle utilizzate negli elementi
HTML e, in diversi contesti, le immagini definite tramite CSS.
img-src 'self' https://cdn.example.com data:;
In questo esempio sono autorizzate le immagini provenienti dalla stessa
origine, da un CDN specifico e dagli URI data:.
L'utilizzo di data: può essere utile per immagini
codificate direttamente nel documento, ma dovrebbe essere consentito
soltanto se realmente necessario.
font-src
font-src limita le origini da cui possono essere
scaricati i font utilizzati nell'interfaccia.
font-src 'self' https://fonts.example.com;
Se il progetto utilizza font ospitati da servizi esterni, è necessario autorizzare esplicitamente le origini corrette, evitando di concedere permessi più ampi del necessario.
connect-src
connect-src controlla le origini verso cui il browser
può effettuare connessioni tramite API come Fetch, XMLHttpRequest,
WebSocket, EventSource e altre funzionalità di comunicazione.
connect-src 'self' https://api.example.com;
È una direttiva particolarmente importante per le applicazioni frontend che comunicano con API REST, servizi GraphQL, WebSocket o endpoint esterni.
object-src
object-src controlla le origini da cui possono essere
caricati contenuti attraverso elementi come
<object> e <embed>.
Nelle applicazioni moderne, questi elementi sono spesso inutilizzati
e possono essere disabilitati completamente.
object-src 'none';
L'utilizzo di 'none' impedisce il caricamento
di qualsiasi risorsa tramite queste modalità.
base-uri
base-uri limita i valori utilizzabili nell'elemento
HTML <base>, che può influenzare la risoluzione
degli URL relativi presenti nella pagina.
base-uri 'self';
Questa direttiva aiuta a prevenire modifiche indesiderate alla
destinazione degli URL relativi, ad esempio in presenza di
un'iniezione dell'elemento <base>.
form-action
form-action definisce gli endpoint verso cui i form
HTML possono inviare i propri dati.
form-action 'self';
Limitare le destinazioni dei form può ridurre il rischio che un form venga modificato o utilizzato per inviare informazioni a endpoint non autorizzati.
frame-ancestors
frame-ancestors specifica quali origini possono
incorporare la pagina attraverso elementi come
<iframe>, <frame>,
<object> o <embed>.
È una direttiva utile per contrastare gli attacchi di
Clickjacking.
frame-ancestors 'self';
La configurazione consente alla pagina di essere incorporata
esclusivamente da documenti appartenenti alla stessa origine.
Se non è necessario consentire l'incorporamento, è possibile
utilizzare frame-ancestors 'none'.
A differenza di molte altre direttive CSP, frame-ancestors
non eredita il valore di default-src e deve essere
dichiarata esplicitamente quando si vuole applicare questa restrizione.
upgrade-insecure-requests
upgrade-insecure-requests indica al browser di
aggiornare le richieste HTTP di risorse presenti nel documento
a HTTPS, quando possibile.
upgrade-insecure-requests;
È particolarmente utile durante la migrazione di applicazioni che contengono riferimenti a risorse non ancora aggiornati al protocollo HTTPS. Non sostituisce comunque una corretta configurazione HTTPS né garantisce che tutte le risorse siano disponibili tramite connessioni sicure.
Script inline, nonce e hash
Uno dei principali ostacoli nell'introduzione di una CSP restrittiva
è la gestione degli script inline. Molte applicazioni contengono
blocchi JavaScript direttamente nel documento HTML, oppure utilizzano
attributi come onclick, onload
e altri handler inline.
Una policy come script-src 'self' non autorizza
automaticamente questi script. Il browser li bloccherà, a meno che
non siano autorizzati attraverso meccanismi espliciti.
Le principali soluzioni sono l'utilizzo di nonce, hash e, in alcuni casi, la rimozione degli script inline spostando il codice in file JavaScript esterni.
Utilizzare un nonce
Un nonce (number used once) è un valore generato dal server, sufficientemente imprevedibile, che viene associato alla policy CSP e agli script autorizzati all'interno del documento. Deve essere generato nuovamente per ogni risposta HTML.
Un esempio di header CSP con nonce è il seguente:
Content-Security-Policy:
script-src 'self' 'nonce-randomValue123';
Il valore deve essere associato anche allo script inline:
<script nonce="randomValue123">
console.log('Script autorizzato');
</script>
Il browser eseguirà lo script perché il nonce presente nel tag corrisponde a quello autorizzato dalla policy. Uno script inline privo del nonce corretto verrà invece bloccato.
In un'applicazione reale, il nonce non deve essere statico: deve essere generato in modo crittograficamente sicuro dal server, utilizzando un generatore di numeri casuali appropriato, e inserito sia nell'header CSP sia nei tag autorizzati. Non deve essere riutilizzato tra risposte differenti.
Utilizzare un hash
Un'altra soluzione consiste nell'autorizzare uno script inline attraverso il suo hash crittografico, ad esempio SHA-256. In questo modo il browser può verificare che il contenuto dello script corrisponda esattamente a quello autorizzato.
Content-Security-Policy:
script-src 'self' 'sha256-BASE64_HASH';
L'hash deve essere calcolato sul contenuto esatto dello script, rispettando caratteri, spazi e formattazione. Qualsiasi modifica al codice richiede un aggiornamento del valore autorizzato.
Gli hash sono particolarmente utili per script statici e piccoli blocchi inline che non cambiano frequentemente, mentre i nonce si adattano meglio a documenti generati dinamicamente dal server.
Il problema di unsafe-inline e unsafe-eval
Tra i valori che è possibile utilizzare nelle direttive CSP,
'unsafe-inline' e 'unsafe-eval'
meritano particolare attenzione perché riducono significativamente
l'efficacia delle restrizioni sugli script.
unsafe-inline
Il valore 'unsafe-inline' autorizza l'esecuzione
di script inline, inclusi blocchi JavaScript e handler inline,
in base alla direttiva nella quale viene utilizzato.
Questo può rendere più semplice l'introduzione di una CSP
in applicazioni legacy, ma amplia le possibilità di esecuzione
del codice in caso di attacco XSS.
script-src 'self' 'unsafe-inline';
Una policy di questo tipo perde gran parte del vantaggio offerto dal controllo degli script inline. È preferibile migrare verso nonce o hash e rimuovere gradualmente il codice inline non necessario.
unsafe-eval
'unsafe-eval' consente l'utilizzo di funzionalità
JavaScript che valutano stringhe come codice, tra cui
eval(), Function() e alcune forme
di compilazione dinamica.
script-src 'self' 'unsafe-eval';
Queste funzionalità possono introdurre rischi significativi quando le stringhe valutate contengono dati controllati dall'utente. È opportuno evitarne l'autorizzazione, salvo che sia indispensabile per il funzionamento di librerie o strumenti specifici.
Strict CSP: una strategia più sicura
Una CSP basata principalmente su liste di domini autorizzati,
come script-src 'self' https://cdn.example.com,
può risultare insufficiente in applicazioni complesse.
Anche un'origine autorizzata può ospitare script vulnerabili,
contenuti dinamici o endpoint che permettono di aggirare
le restrizioni previste.
Un approccio più robusto è rappresentato dalla Strict CSP, che basa l'autorizzazione degli script su nonce o hash, anziché affidarsi esclusivamente a una lista di domini.
Un esempio di configurazione basata su nonce e
strict-dynamic:
Content-Security-Policy:
script-src 'nonce-{RANDOM}' 'strict-dynamic';
object-src 'none';
base-uri 'none';
La direttiva 'strict-dynamic' consente di propagare
la fiducia dagli script autorizzati tramite nonce o hash
agli script caricati dinamicamente da questi stessi script,
nei browser che supportano il meccanismo.
In presenza di 'strict-dynamic', le liste di origini
tradizionali all'interno di script-src possono essere
ignorate dai browser che implementano il comportamento previsto
dalla direttiva. Per questo motivo è necessario comprendere
attentamente il modello di caricamento degli script
dell'applicazione prima di adottarla.
Strict CSP non è una configurazione da applicare indiscriminatamente: richiede una gestione corretta dei nonce o degli hash e una revisione dei meccanismi con cui gli script vengono caricati e inizializzati.
Modalità Report-Only: testare la CSP senza bloccare le risorse
Introdurre una Content-Security-Policy direttamente in produzione può causare problemi imprevisti. Una risorsa necessaria potrebbe essere bloccata, una libreria esterna potrebbe non funzionare oppure alcune funzionalità dell'applicazione potrebbero interrompersi.
Per questo motivo il browser mette a disposizione l'header
Content-Security-Policy-Report-Only, che consente
di monitorare le violazioni senza applicare effettivamente
i blocchi previsti dalla policy.
Content-Security-Policy-Report-Only:
default-src 'self';
script-src 'self';
img-src 'self';
style-src 'self';
In questa modalità, le risorse che non rispettano la policy continuano a essere caricate, ma il browser segnala le violazioni. È quindi possibile analizzare i problemi e correggere la policy prima di renderla effettiva.
Report-Only è particolarmente utile durante la fase iniziale di implementazione, nei test di regressione e nella migrazione di applicazioni esistenti.
Quando la policy è sufficientemente stabile, è possibile passare
all'header Content-Security-Policy, che applica
realmente le restrizioni.
Come gestire le violazioni CSP
Quando una risorsa viola la policy, il browser può generare un report contenente informazioni utili per identificare il problema, come la direttiva violata, l'origine della risorsa e il documento interessato.
La gestione dei report permette di monitorare le violazioni che si verificano durante l'utilizzo dell'applicazione e di individuare potenziali problemi di configurazione o comportamenti sospetti.
La direttiva report-uri è stata utilizzata per
specificare un endpoint al quale inviare i report CSP, ma è
considerata obsoleta. Le implementazioni moderne dovrebbero
valutare l'utilizzo di report-to e della relativa
configurazione tramite l'header HTTP Report-To,
tenendo conto del supporto effettivo dei browser.
Un esempio di configurazione legacy è:
Content-Security-Policy:
default-src 'self';
report-uri /csp-report;
L'endpoint /csp-report deve essere implementato
sul server per ricevere e gestire i report inviati dal browser.
Non è sufficiente dichiararlo nella policy.
Il report endpoint deve inoltre essere progettato per gestire input non affidabili: i report CSP possono contenere dati arbitrari, devono essere validati e non devono essere interpretati come istruzioni da eseguire.
Implementare una CSP in un'applicazione web
L'introduzione di una Content-Security-Policy dovrebbe essere affrontata in modo progressivo. Applicare una policy restrittiva senza conoscere tutte le risorse utilizzate dall'applicazione può compromettere funzionalità che dipendono da script, font, API, immagini o servizi esterni.
1. Analizzare le risorse utilizzate
Individua tutte le risorse caricate dal frontend, comprese quelle provenienti da CDN, servizi di analytics, sistemi di autenticazione, mappe, video, API e font esterni. Gli strumenti di sviluppo del browser, in particolare il pannello Network, possono aiutarti a identificare le origini coinvolte.
2. Definire una policy iniziale
Parti da una configurazione restrittiva, utilizzando
default-src 'self' e aggiungendo soltanto
le direttive necessarie per il funzionamento dell'applicazione.
Evita di autorizzare intere categorie di domini quando
puoi specificare origini più precise.
3. Utilizzare Report-Only
Distribuisci la policy in modalità Report-Only e verifica le violazioni generate durante i test e l'utilizzo reale. Questo passaggio permette di identificare dipendenze non previste e correggere la configurazione senza bloccare le risorse.
4. Correggere le violazioni
Analizza i report, verifica le risorse coinvolte e modifica la policy soltanto quando è necessario. Se possibile, elimina gli script inline, utilizza nonce o hash e riduci progressivamente le origini autorizzate.
5. Attivare la policy
Quando la configurazione è stata verificata, distribuiscila
attraverso l'header Content-Security-Policy.
Continua a monitorare le violazioni e verifica che le modifiche
successive all'applicazione non introducano nuove dipendenze.
6. Mantenere la policy aggiornata
La CSP deve essere considerata parte della manutenzione dell'applicazione. Ogni nuova integrazione, libreria, servizio esterno o modifica al sistema di caricamento delle risorse può richiedere un aggiornamento della policy.
Configurare la CSP lato server
La CSP può essere configurata a diversi livelli dell'infrastruttura: applicazione backend, web server, reverse proxy o piattaforma di hosting. L'importante è che l'header venga restituito correttamente nelle risposte HTTP che contengono i documenti da proteggere.
Esempio con Nginx
server {
location / {
add_header Content-Security-Policy
"default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'self';"
always;
}
}
In Nginx, la direttiva add_header permette di
aggiungere header HTTP alle risposte. Il parametro
always consente di applicare l'header anche
in presenza di determinate risposte HTTP non appartenenti
alla classe di successo.
È importante verificare la configurazione effettiva, soprattutto
quando esistono più blocchi location, proxy
intermedi o configurazioni che potrebbero sovrascrivere
o duplicare gli header.
Esempio con Express.js
In un'applicazione Node.js basata su Express, è possibile impostare l'header attraverso middleware:
app.use((req, res, next) => {
res.setHeader(
'Content-Security-Policy',
"default-src 'self'; script-src 'self'; object-src 'none'; base-uri 'self';"
);
next();
});
Per applicazioni più articolate è preferibile utilizzare una soluzione dedicata alla gestione degli header di sicurezza, come Helmet, che permette di configurare la CSP e altre protezioni HTTP attraverso un middleware.
Quando si utilizza un middleware dedicato, è comunque necessario verificare che la policy generata sia coerente con le esigenze applicative e che non vengano introdotte direttive permissive senza una reale necessità.
Content-Security-Policy e sicurezza applicativa
La CSP è una misura di difesa importante, ma non deve essere considerata una soluzione definitiva contro gli attacchi web. Una policy configurata correttamente può ridurre le conseguenze di alcune vulnerabilità, ma non elimina la causa del problema.
Un'applicazione vulnerabile a XSS deve essere corretta intervenendo sulla gestione degli input, sull'output encoding, sulla manipolazione del DOM e sull'utilizzo di API sicure.
In particolare, è opportuno:
- Validare i dati ricevuti dal client secondo il contesto applicativo.
- Utilizzare tecniche di output encoding appropriate al contesto HTML, JavaScript, CSS o URL.
- Evitare l'inserimento di stringhe non affidabili tramite API DOM pericolose, come
innerHTML, quando non necessario. - Preferire API DOM sicure, come
textContent, per inserire contenuti testuali. - Utilizzare HTTPS per tutte le comunicazioni.
- Configurare correttamente cookie, sessioni e altri header HTTP di sicurezza.
- Monitorare e aggiornare regolarmente le dipendenze utilizzate dal progetto.
La CSP funziona al meglio quando è integrata in una strategia di sicurezza multilivello, insieme alle altre misure di protezione adottate durante lo sviluppo e la distribuzione dell'applicazione.
Compatibilità con i browser
La Content-Security-Policy è supportata dai principali browser
moderni, tra cui Chrome, Firefox, Edge e Safari. Le direttive
fondamentali, come default-src, script-src,
img-src e style-src, sono ampiamente
disponibili.
Alcune funzionalità più recenti, come determinati meccanismi di reporting, possono presentare differenze di supporto o comportamento tra i browser e le relative versioni. Anche direttive avanzate e funzionalità di CSP3 devono essere verificate in base ai browser effettivamente supportati dal progetto.
Per controllare il supporto delle singole direttive e dei relativi valori è consigliabile consultare la documentazione di MDN e Can I Use, soprattutto quando si sviluppano applicazioni che devono supportare browser meno recenti.
Link utili
Per approfondire la Content-Security-Policy, le singole direttive e le strategie di implementazione, puoi consultare le seguenti risorse:
- MDN Web Docs - Content Security Policy (CSP) : documentazione completa sulle direttive CSP, il funzionamento delle policy e le modalità di configurazione.
- W3C - Content Security Policy Level 3 : specifica tecnica che descrive il funzionamento della CSP e le direttive previste.
- Google - Content Security Policy : approfondimenti sull'utilizzo di CSP, strategie di configurazione e approcci orientati a una policy più restrittiva.
- Can I Use - Content Security Policy : panoramica sul supporto CSP nei principali browser.
- OWASP Web Security Testing Guide : guida alle metodologie di test e verifica della sicurezza delle applicazioni web.
Conclusioni
La Content-Security-Policy è uno strumento fondamentale per migliorare la sicurezza di un'applicazione web, limitando le origini delle risorse che possono essere caricate ed eseguite dal browser e riducendo l'impatto di alcune vulnerabilità, in particolare quelle legate agli attacchi XSS.
Una configurazione efficace non si limita a definire una lista di domini autorizzati, ma richiede una conoscenza delle risorse utilizzate dal progetto, un'attenta scelta delle direttive e una gestione consapevole degli script inline, dei nonce, degli hash e delle dipendenze esterne.
Introdurre la CSP attraverso una fase iniziale di monitoraggio, correggere le violazioni e applicare progressivamente restrizioni più rigorose consente di ottenere una policy solida senza compromettere l'esperienza degli utenti.
Come ogni misura di sicurezza, la CSP deve essere mantenuta nel tempo e integrata con le altre pratiche di sviluppo sicuro. Non sostituisce la prevenzione delle vulnerabilità, ma aggiunge un importante livello di protezione che contribuisce a rendere le applicazioni web più resilienti.
