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 generare file SXG e configurare nginx per la pubblicazione di file SXG.

Hiroki Kumazaki

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

Supporto cross-browser

Diversi browser basati su Chromium supportano SXG, tra cui Google Chrome, Samsung Internet e Microsoft Edge. Per informazioni più aggiornate, consulta la sezione su consenso e standardizzazione di scambi HTTP con firma dell'origine.

Prerequisiti

Per implementare SXG sul tuo sito web, devi:

Hai il controllo del tuo dominio, incluse le voci DNS.
Richiedi i certificati. SXG richiede l'emissione di un certificato dedicato. In particolare, non puoi riutilizzare la chiave o il certificato TLS.
Devi disporre di un server HTTP in grado di generare e gestire 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.
Puoi eseguire sudo per installare gli eseguibili.
Utilizza nginx come server HTTP.
Stanno utilizzando DigiCert per generare certificati che includano estensioni correlate a SXG, in quanto risulta attualmente l'unico provider che supporta queste estensioni.

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

Passaggio 1: recupera il certificato per SXG

Per generare SXG, sono necessari un certificato TLS con l'estensione CanSignHttpExchanges e un tipo di chiave particolare. DigiCert fornisce certificati con questa estensione. Per l'emissione di un certificato è necessario 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"

Verrà visualizzato un file CSR che ha il seguente aspetto:

Accertati che:

Il periodo di validità non supera i 90 giorni.
La casella di controllo Includi l'estensione CanSignHttpExchanges nel certificato è abilitata, disponibile in Opzioni certificato aggiuntive.

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

Se il tuo 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 ottenuto da DigiCert sia mySxg.pem.

Passaggio 2: installa `libsxg`

Il formato SXG è complesso e difficile da generare senza l'uso di 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 come di consueto Debian, purché la versione 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 manualmente `libsxg`

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 consente di generare SXG in modo dinamico anziché in modo statico prima della pubblicazione.

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

Il modulo SXG per nginx è distribuito su GitHub. Nei 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 il plug-in manualmente

La creazione del modulo nginx richiede il codice sorgente nginx. Puoi ottenere il tarball e crearlo insieme al modulo dinamico SXG utilizzando i seguenti comandi:

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 offre un'elevata flessibilità. Installa nginx in qualsiasi punto del sistema, quindi specifica un rispettivo percorso di module/config/log/pidfile. Questa guida presuppone che tu l'abbia installata su /opt/nginx.

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

Opzione 1: configura un modulo `nginx` install-from-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 essere simile al seguente, 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 consentire ai browser di caricare correttamente SXG perché individua la catena di certificati. La catena di certificati contiene informazioni di stapling di certificati e OCSP in formato cbor. Tieni presente che non è necessario pubblicare il file cert.cbor dalla stessa origine. Puoi utilizzarlo tramite qualsiasi rete CDN o altro servizio di pubblicazione di file statici purché supporti HTTPS.
È previsto che sxg_validitiy_url fornisca informazioni relative all'intestazione della firma SXG. Se una pagina non è stata modificata dall'ultimo SXG, tecnicamente non è necessario scaricare l'intero file SXG. Pertanto, aggiornare solo le informazioni dell'intestazione della firma dovrebbe ridurre il traffico di rete. Tuttavia, i dettagli non sono ancora stati implementati.

Inizia nginx e tutto è pronto per pubblicare 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` di origine integrato

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

Configura il tuo sistema nginx installato in /opt/nginx in modo che sia simile al seguente esempio:

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;
    }
}

Dopodiché avvia nginx. Ora puoi ricevere 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: gestisci il backend dell'applicazione

Negli esempi precedenti, nginx pubblica file statici nella directory root, ma puoi utilizzare istruzioni upstream per le tue applicazioni per rendere SXG per backend di applicazioni web arbitrari (come Ruby on Rails, Django o Express), purché nginx funzioni come server HTTP(S) frontale.

upstream app {
    server 127.0.0.1:8080;
}

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

Passaggio 6: prova

Utilizza lo strumento dump-Sign Exchange per verificare che gli SXG forniti 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 su SXG sono interessati a 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 sarà di grande aiuto per il processo di standardizzazione e contribuirà inoltre a risolvere i problemi di implementazione. Grazie!