Diese Seite wurde von der Cloud Translation API übersetzt.

Signed HTTP Exchanges (SXG) mit nginx einrichten

Hier erfahren Sie, wie Sie ein TLS-Zertifikat mit SXG-Erweiterungen generieren, Tools zum Generieren von SXG-Dateien installieren und nginx für die Bereitstellung von SXG-Dateien konfigurieren.

Hiroki Kumazaki

Signed HTTP Exchanges (SXG) ist eine neue Webtechnologie, mit der Nutzer Content-Ersteller von Content-Distributoren unterscheiden können. In diesem Leitfaden erfährst du, wie du SXG einrichtest.

Browserübergreifende Unterstützung

SXG wird von verschiedenen Chromium-basierten Browsern unterstützt, darunter Google Chrome, Samsung Internet und Microsoft Edge. Aktuelle Informationen finden Sie im Abschnitt „Consensus and Standardization“ (Konsens und Standardisierung) von Origin-Signed HTTP Exchanges.

Voraussetzungen

Damit Sie SXG auf Ihrer Website implementieren können, müssen folgende Voraussetzungen erfüllt sein:

Sie haben die Kontrolle über Ihre Domain, einschließlich DNS-Einträgen.
Zertifikate anfordern. Für SXG muss ein spezielles Zertifikat ausgestellt werden. Insbesondere können Sie Ihren TLS-Schlüssel oder -Zertifikat nicht wiederverwenden.
Du benötigst einen HTTP-Server, der SXG über HTTPS generieren und bereitstellen kann.

Annahmen

In diesem Leitfaden wird von folgenden Voraussetzungen ausgegangen:

Du musst eine OpenSSL 1.1.1-Umgebung haben. Dieser Leitfaden wurde mit Ubuntu 18.04 LTS auf amd64-ISA geschrieben.
Sie müssen die Möglichkeit haben, sudo auszuführen, um ausführbare Dateien zu installieren.
Verwende nginx als HTTP-Server.
verwenden DigiCert, um Zertifikate mit SXG-bezogenen Erweiterungen zu generieren, da es aktuell offenbar der einzige Anbieter ist, der diese Erweiterungen unterstützt.

Bei den Beispielbefehlen in diesem Artikel wird außerdem davon ausgegangen, dass Ihre Domain website.test ist. Daher müssen Sie website.test durch Ihre tatsächliche Domain ersetzen.

Schritt 1: SXG-Zertifikat anfordern

Zum Generieren von SXG benötigst du ein TLS-Zertifikat mit der Erweiterung CanSignHttpExchanges sowie einen bestimmten Schlüsseltyp. DigiCert stellt Zertifikate mit dieser Erweiterung zur Verfügung. Da Sie zum Ausstellen eines Zertifikats eine CSR-Datei benötigen, generieren Sie sie mit den folgenden Befehlen:

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"

Sie erhalten eine CSR-Datei, die so aussieht:

Prüfen Sie Folgendes:

Der Gültigkeitszeitraum überschreitet 90 Tage.
Das Kästchen Erweiterung „CanSignHttpExchanges“ in das Zertifikat aufnehmen ist aktiviert. Sie finden es unter „Zusätzliche Zertifikatsoptionen“.

Das Kästchen **Fügen Sie die Erweiterung „CanSignHttpExchanges“ in das Zertifikat ein**.

Wenn dein Zertifikat diese Bedingungen nicht erfüllt, lehnen Browser und Händler deinen SXG aus Sicherheitsgründen ab. In diesem Leitfaden wird davon ausgegangen, dass der Dateiname des von DigiCert erhaltenen Zertifikats mySxg.pem lautet.

Schritt 2: `libsxg` installieren

Das SXG-Format ist ohne Tools komplex und schwer zu erstellen. Du kannst eine der folgenden Optionen verwenden, um SXG zu generieren:

Das in Go geschriebene Tool gen-signedexchange
Die Bibliothek libsxg in C.

In dieser Anleitung wird libsxg verwendet.

Option 1: `libsxg` aus einem Debian-Paket installieren

Sie können das Paket auf die übliche Debian-Art installieren, solange die OpenSSL-Version (libssl-dev) übereinstimmt.

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

Option 2: `libsxg` manuell erstellen

Wenn Sie keine Umgebung verwenden, die mit .deb-Dateien kompatibel ist, können Sie libsxg selbst erstellen. Als Voraussetzung müssen Sie git, cmake, openssl und gcc installieren.

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

Schritt 3: Plug-in `nginx` installieren

Mit dem nginx-Plug-in kannst du SXG dynamisch statt statisch generieren.

Option 1: Plug-in aus einem Debian-Paket installieren

Das SXG-Modul für nginx wird auf GitHub bereitgestellt. Auf Debian-basierten Systemen können Sie es als Binärpaket installieren:

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

Option 2: Plug-in manuell erstellen

Für das Erstellen des Moduls nginx ist der Quellcode nginx erforderlich. Mit den folgenden Befehlen kannst du das Tarball-Paket herunterladen und zusammen mit dem dynamischen SXG-Modul erstellen:

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

Die nginx-Konfiguration ist äußerst flexibel. Installieren Sie nginx an einer beliebigen Stelle in Ihrem System und geben Sie dann den entsprechenden Pfad module/config/log/pidfile an. In dieser Anleitung wird davon ausgegangen, dass Sie sie in /opt/nginx installieren.

Schritt 4: Plug-in `nginx` für SXG konfigurieren

Option 1: Über Debian installiertes `nginx`-Modul konfigurieren

Folgen Sie dieser Anleitung, wenn Sie Schritt 3, Option 1 bereits verwendet haben.

Für SXG-Inhalte ist HTTPS erforderlich. Ein SSL/TLS-Zertifikat erhalten Sie von DigiCert, Let's Encrypt und anderen Diensten. Beachten Sie, dass für SSL kein SXG-Zertifikat verwendet werden kann oder umgekehrt. Sie benötigen daher zwei Zertifikate. Die Konfigurationsdatei in /etc/nginx/nginx.conf sollte in etwa so aussehen, vorausgesetzt, du gibst das SSL-Schlüssel/Zertifikat-Paar in /path/to/ssl/ und das SXG-Schlüssel/Zertifikat-Paar in /path/to/sxg/ ein:

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 ist für das korrekte Laden von SXG in Browsern wichtig, da damit die Zertifikatskette gefunden wird. Die Zertifikatskette enthält Informationen zu Zertifikaten und OCSP-Heftungen im cbor-Format. Sie müssen die Datei cert.cbor nicht aus demselben Ursprung bereitstellen. Sie können sie über alle CDNs oder andere Dienste zur Bereitstellung statischer Dateien bereitstellen, solange HTTPS unterstützt wird.
sxg_validitiy_url soll Informationen zu SXG-Signaturheadern bereitstellen. Wenn eine Seite seit der letzten SXG-Datei nicht geändert wurde, ist der Download der gesamten SXG-Datei technisch nicht erforderlich. Allein die Aktualisierung der Informationen im Signaturheader sollte also den Netzwerkverkehr reduzieren. Die Details wurden jedoch noch nicht implementiert.

Wenn Sie nginx starten, sind Sie bereit für 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)

Option 2: Integriertes `nginx`-Modul konfigurieren

Folgen Sie dieser Anleitung, wenn Sie Schritt 3, Option 2 bereits verwendet haben.

Konfigurieren Sie das unter /opt/nginx installierte nginx-System so, dass es in etwa so aussieht:

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

Starten Sie dann nginx. Hol dir deinen 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)

Schritt 5: Anwendungs-Back-End bereitstellen

In den obigen Beispielen stellt nginx statische Dateien im Stammverzeichnis bereit. Sie können jedoch Upstream-Anweisungen für Ihre Anwendungen verwenden, um SXG für beliebige Webanwendungs-Back-Ends (z. B. Ruby on Rails, Django oder Express) zu erstellen, solange nginx als Front-HTTP(S)-Server funktioniert.

upstream app {
    server 127.0.0.1:8080;
}

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

Schritt 6: Testen

Testen Sie mit dem Dump-Signed Exchange-Tool, ob die bereitgestellten SXGs korrekt sind, ob keine Fehler gemeldet werden, und ob die Header und der Textkörper wie erwartet aussehen.

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

Feedback geben

Die Chromium-Entwickler, die an SXG arbeiten, freuen sich auf dein Feedback unter webpackage-dev@chromium.org. Außerdem kannst du dich an der Diskussion zu den Spezifikationen beteiligen oder dem Team einen Fehler melden. Ihr Feedback hilft uns sehr, den Standardisierungsprozess zu optimieren und Probleme bei der Implementierung zu lösen. Vielen Dank!