Questa pagina è stata tradotta dall'API Cloud Translation.

Come configurare SXG (Signed HTTP Exchanges) utilizzando nginx

Come generare un certificato TLS con estensioni SXG, installare strumenti per la generazione di file SXG e configurare nginx per pubblicare file SXG.

Hiroki Kumazaki

Signed HTTP Exchange (SXG) è una nuova tecnologia web che consente agli utenti di distinguere più facilmente i creator di contenuti dai distributori di contenuti. Questa guida spiega come configurare SXG.

Supporto su più browser

Diversi browser basati su Chromium supportano SXG, tra cui Google Chrome, Samsung Internet e Microsoft Edge. Per informazioni più aggiornate, consulta la sezione Consenso e standardizzazione di Piattaforme di scambio HTTP firmate dall'origine.

Prerequisiti

Per implementare SXG sul tuo sito web, devi:

Avere il controllo del tuo dominio, incluse le voci DNS.
Ricevi i certificati. SXG richiede l'emissione di un certificato dedicato. In particolare, non puoi riutilizzare la chiave o il certificato TLS.
Disporre di un server HTTP in grado di generare e pubblicare messaggi SXG tramite HTTPS.

Ipotesi

Questa guida presuppone che tu:

Avere un ambiente OpenSSL 1.1.1. Questa guida è stata scritta con Ubuntu 18.04 LTS su amd64 ISA.
Devi avere la possibilità di eseguire sudo per installare gli eseguibili.
Utilizza nginx come server HTTP.
Utilizzano DigiCert per generare certificati che includono estensioni correlate a SXG, perché al momento sembra essere l'unico fornitore che supporta queste estensioni.

Inoltre, i comandi di esempio in questo articolo presuppongono che il tuo dominio sia website.test, quindi devi sostituire website.test con il tuo dominio effettivo.

Passaggio 1: ottieni il certificato per SXG

Per generare SXG, è necessario un certificato TLS con l'estensione CanSignHttpExchanges e un tipo di chiave specifico. DigiCert fornisce certificati con questa estensione. Per l'emissione di un certificato, devi disporre di un file CSR, quindi generalo con i seguenti comandi:

openssl ecparam -genkey -name prime256v1 -out mySxg.key
openssl req -new -key mySxg.key -nodes -out mySxg.csr -subj "/O=Test/C=US/CN=website.test"

Riceverai un file CSR simile al seguente:

Accertati che:

Il periodo di validità non deve superare i 90 giorni.
La casella di controllo Includi l'estensione CanSignHttpExchanges nel certificato è attivata, che si trova in Opzioni aggiuntive del certificato.

La casella di controllo **Includi l'estensione CanSignHttpExchanges nel certificato**.

Se il certificato non soddisfa queste condizioni, i browser e i distributori rifiuteranno il tuo SXG per motivi di sicurezza. Questa guida presuppone che il nome file del certificato che hai ricevuto da DigiCert sia mySxg.pem.

Passaggio 2: installa `libsxg`

Il formato SXG è complesso e difficile da generare senza utilizzare strumenti. Per generare SXG, puoi utilizzare una delle seguenti opzioni:

Lo strumento gen-signedexchange scritto in Go.
La libreria libsxg scritta in C.

Questa guida utilizza libsxg.

Opzione 1: installa `libsxg` da un pacchetto Debian

Puoi installare il pacchetto nel solito modo Debian, a condizione che la versione di OpenSSL (libssl-dev) corrisponda.

sudo apt install -y libssl-dev
wget https://github.com/google/libsxg/releases/download/v0.2/libsxg0_0.2-1_amd64.deb
wget https://github.com/google/libsxg/releases/download/v0.2/libsxg-dev_0.2-1_amd64.deb
sudo dpkg -i libsxg0_0.2-1_amd64.deb
sudo dpkg -i libsxg-dev_0.2-1_amd64.deb

Opzione 2: crea `libsxg` manualmente

Se non utilizzi un ambiente compatibile con i file .deb, puoi creare libsxg autonomamente. Come condizione preliminare, devi installare git, cmake, openssl e gcc.

git clone https://github.com/google/libsxg
mkdir libsxg/build
cd libsxg/build
cmake .. -DRUN_TEST=false -DCMAKE_BUILD_TYPE=Release
make
sudo make install

Passaggio 3: installa il plug-in `nginx`

Il plug-in nginx ti consente di generare SXG in modo dinamico anziché statico prima della pubblicazione.

Opzione 1: installa il plug-in da un pacchetto Debian

Il modulo SXG per nginx è distribuito su GitHub. Sui sistemi basati su Debian, puoi installarlo come pacchetto binario:

sudo apt install -y nginx=1.15.9-0
wget https://github.com/google/nginx-sxg-module/releases/download/v0.1/libnginx-mod-http-sxg-filter_1.15.9-0ubuntu1.1_amd64.deb
sudo dpkg -i libnginx-mod-http-sxg-filter_1.15.9-0ubuntu1.1_amd64.deb

Opzione 2: crea manualmente il plug-in

La compilazione del modulo nginx richiede il codice sorgente di nginx. Puoi ottenere il file tarball e compilarlo insieme al modulo dinamico SXG utilizzando i comandi riportati di seguito:

git clone https://github.com/google/nginx-sxg-module
wget https://nginx.org/download/nginx-1.17.5.tar.gz
tar xvf nginx-1.17.5.tar.gz
cd nginx-1.17.5
./configure --prefix=/opt/nginx --add-dynamic-module=../nginx-sxg-module --without-http_rewrite_module --with-http_ssl_module
make
sudo make install

La configurazione nginx è molto flessibile. Installa nginx in qualsiasi punto del sistema, quindi specifica il relativo percorso di module/config/log/pidfile. Questa guida presuppone che tu lo installi in /opt/nginx.

Passaggio 4: configura il plug-in `nginx` in modo che funzioni con SXG

Opzione 1: configura un modulo `nginx` installato da Debian

Segui queste istruzioni se hai già utilizzato il Passaggio 3, opzione 1.

La pubblicazione di contenuti SXG richiede HTTPS. Puoi ottenere un certificato SSL/TLS da DigiCert, Let's Encrypt e altri servizi. Tieni presente che NON puoi utilizzare un certificato SXG per SSL e viceversa, pertanto avrai bisogno di due certificati. Il file di configurazione in /etc/nginx/nginx.conf dovrebbe avere il seguente aspetto, supponendo che tu abbia inserito la coppia chiave/certificato SSL in /path/to/ssl/ e la coppia chiave/certificato SXG in /path/to/sxg/:

user www-data;
include /etc/nginx/modules-enabled/*.conf;

events {
     worker_connections 768;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    add_header  X-Content-Type-Options nosniff;

    server {
        listen 443 ssl;
        ssl_certificate     /path/to/ssl/fullchain.pem;
        ssl_certificate_key /path/to/ssl/privkey.pem;
        server_name  website.test;

        sxg on;
        sxg_certificate     /path/to/sxg/mySxg.pem;
        sxg_certificate_key /path/to/sxg/mySxg.key;
        sxg_cert_url        https://website.test/certs/cert.cbor;
        sxg_validity_url    https://website.test/validity/resource.msg;
        sxg_cert_path       /certs/cert.cbor;

        root /var/www/html;
    }
}

sxg_cert_url è essenziale per caricare correttamente SXG ai browser perché individua la catena di certificati. La catena di certificati contiene informazioni su certificati e stapling OCSP in formato cbor. Tieni presente che non è necessario pubblicare il file cert.cbor dalla stessa origine. Puoi pubblicarlo tramite qualsiasi CDN o altri servizi di pubblicazione di file statici, purché supportino HTTPS.
È previsto che sxg_validitiy_url fornisca informazioni relative all'intestazione della firma SXG. Se una pagina non è stata modificata dall'ultimo SXG, il download dell'intero file SXG non è tecnicamente necessario. Pertanto, l'aggiornamento delle informazioni dell'intestazione della firma dovrebbe ridurre il traffico di rete. ma i dettagli non sono ancora stati implementati.

Avvia nginx e potrai iniziare a pubblicare gli annunci SXG.

sudo systemctl start nginx.service
curl -H"Accept: application/signed-exchange;v=b3" https://website.test/ > index.html.sxg
cat index.html.sxg
sxg1-b3...https://website.test/...(omit)

Opzione 2: configura un modulo `nginx` compilato da sorgente

Segui queste istruzioni se hai già utilizzato il Passaggio 3, opzione 2.

Configura il sistema nginx installato in /opt/nginx in modo che sia simile all'esempio seguente:

load_module "/opt/nginx/modules/ngx_http_sxg_filter_module.so";

events {
    worker_connections 768;
}

http {
    include       mime.types;
    default_type  application/octet-stream;
    add_header X-Content-Type-Options nosniff;

    server {
        listen 443 ssl;
        ssl_certificate     /path/to/ssl/fullchain.pem;
        ssl_certificate_key /path/to/ssl/privkey.pem;
        server_name  example.com;

        sxg on;
        sxg_certificate     /path/to/sxg/mySxg.pem;
        sxg_certificate_key /path/to/sxg/mySxg.key;
        sxg_cert_url        https://website.test/certs/cert.cbor;
        sxg_validity_url    https://website.test/validity/resource.msg;
        sxg_cert_path       /certs/cert.cbor;

        root /opt/nginx/html;
    }
}

Quindi avvia nginx. Ora puoi ottenere il tuo SXG.

cd /opt/nginx/sbin
sudo ./nginx
curl -H "Accept: application/signed-exchange;v=b3" https://website.test/ > index.html.sxg
less index.html.sxg
sxg1-b3...https://website.test/...(omit)

Passaggio 5: pubblica il backend dell'applicazione

Negli esempi precedenti, nginx serve file statici nella directory principale, ma puoi utilizzare le direttive upstream per le tue applicazioni per creare SXG per backend di applicazioni web arbitrari (come Ruby on Rails, Django o Express) purché nginx funzioni come server HTTP(S) anteriore.

upstream app {
    server 127.0.0.1:8080;
}

server {
    location / {
        proxy_pass http://app;
    }
}

Passaggio 6: test

Utilizza lo strumento dump-signedexchange per verificare che gli SXG pubblicati siano corretti, assicurarti che non vengano segnalati errori e verificare che le intestazioni e il corpo siano come previsto.

go get -u github.com/WICG/webpackage/go/signedexchange/cmd/dump-signedexchange
export PATH=$PATH:~/go/bin
dump-signedexchange -verify -uri https://website.test/ | less

Invia feedback

Gli ingegneri di Chromium che lavorano a SXG sono ansiosi di ricevere il tuo feedback all'indirizzo webpackage-dev@chromium.org. Puoi anche partecipare alla discussione sulle specifiche o segnalare un bug al team. Il tuo feedback contribuirà notevolmente alla procedura di standardizzazione e aiuterà anche a risolvere i problemi di implementazione. Grazie.