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 gli strumenti per generare file SXG e configurare nginx per gestire i 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 ti mostra come configurare SXG.

Supporto cross-browser

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

Prerequisiti

Per implementare SXG sul tuo sito web, devi:

Avere il controllo del tuo dominio, incluse le voci DNS.
Ottieni 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.
Stanno utilizzando DigiCert per generare certificati che includono estensioni SXG, perché al momento sembra essere l'unico provider che le supporta.

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. Hai bisogno di un file CSR per l'emissione di un certificato, quindi generalo con questi 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 supera i 90 giorni.
La casella di controllo Includi l'estensione CanSignHttpExchanges nel certificato sia selezionata. disponibile in Opzioni di certificato aggiuntive.

di Gemini Advanced.

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

Se il tuo certificato non corrisponde a 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 raccolta libsxg scritta in C.

Questa guida fa uso di libsxg.

Opzione 1: installa `libsxg` da un pacchetto Debian

Puoi installare il pacchetto nel solito metodo 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 dinamicamente SXG invece di generarli in modo 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 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 di nginx offre una grande flessibilità. Installa nginx ovunque nel sistema, quindi specifica il rispettivo percorso di module/config/log/pidfile. Questa guida presuppone l'installazione dell'app su /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 o viceversa, pertanto avrai bisogno di due certificati. Il file di configurazione in /etc/nginx/nginx.conf dovrebbe avere un aspetto simile al seguente, supponendo che sia stata inserita 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 di supilazione del certificato e OCSP in formato cbor. Tieni presente che non è necessario pubblicare il file cert.cbor dalla stessa origine. Puoi pubblicare il file tramite qualsiasi CDN o altri servizi di pubblicazione di file statici, purché supporti il protocollo HTTPS.
Si prevede che sxg_validitiy_url pubblichi informazioni relative all'intestazione SXG-signature-header. Se una pagina non è stata modificata dall'ultimo file SXG, tecnicamente non è necessario scaricare l'intero file SXG. Di conseguenza, l'aggiornamento delle sole informazioni dell'intestazione della firma dovrebbe ridurre il traffico di rete. Tuttavia, i dettagli non sono ancora stati implementati.

Avvia nginx e potrai 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` creato dall'origine

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

Configura l'impianto nginx installato in /opt/nginx in modo che abbia un aspetto 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;
    }
}

Poi 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: gestisci il backend dell'applicazione

Negli esempi precedenti, nginx gestisce i file statici nella directory root, ma puoi utilizzare istruzioni upstream per le tue applicazioni per creare SXG per backend di applicazioni web arbitrarie (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-SignExchange. per verificare che gli SXG pubblicati siano corretti, che non siano segnalati errori e che le intestazioni 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

I tecnici di Chromium che lavorano su SXG sono pronti 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à molto utile per il processo di standardizzazione e per la risoluzione dei problemi di implementazione. Grazie.