Segui su:
Programmazione Web Italia

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

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. marco dice...

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:

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.