Se usó la API de Cloud Translation para traducir esta página.

Cómo configurar intercambios HTTP firmados (SXG) con nginx

Cómo generar un certificado TLS con extensiones SXG, instalar herramientas para generar archivos SXG y configurar nginx para entregar archivos SXG

Hiroki Kumazaki

Los intercambios HTTP firmados (SXG) son una nueva tecnología web que permite a los usuarios diferenciar fácilmente a los creadores de contenido de los distribuidores de contenido. En esta guía, se muestra cómo configurar SXG.

Compatibilidad con varios navegadores

Varios navegadores basados en Chromium admiten SXG, como Google Chrome, Samsung Internet y Microsoft Edge. Consulta la sección Consenso y estandarización de Intercambios HTTP firmados por el origen para obtener información más actualizada.

Requisitos previos

Para implementar SXG en tu sitio web, debes hacer lo siguiente:

Tener control sobre tu dominio, incluidas las entradas de DNS
Obtener certificados SXG requiere la emisión de un certificado exclusivo. En particular, no puedes volver a usar tu clave o certificado TLS.
Tener un servidor HTTP que pueda generar y entregar SXG a través de HTTPS

Suposiciones

En esta guía, se da por sentado que:

Tener un entorno de OpenSSL 1.1.1 Esta guía se escribió con Ubuntu 18.04 LTS en la ISA amd64.
Tener la capacidad de ejecutar sudo para instalar ejecutables
Usa nginx como un servidor HTTP.
Usan DigiCert para generar certificados que incluyen extensiones relacionadas con SXG, ya que, en la actualidad, parece ser el único proveedor que admite estas extensiones.

Además, en los comandos de ejemplo de este artículo, se supone que tu dominio es website.test, por lo que deberás reemplazar website.test por tu dominio real.

Paso 1: Obtén tu certificado para SXG

Para generar SXG, necesitas un certificado TLS con la extensión CanSignHttpExchanges, así como un tipo de clave en particular. DigiCert proporciona certificados con esta extensión. Necesitas un archivo CSR para emitir un certificado, así que genéralo con los siguientes comandos:

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"

Recibirás un archivo CSR que se verá de la siguiente manera:

Asegúrate de lo siguiente:

El período de validez no debe exceder los 90 días.
La casilla de verificación Incluir la extensión CanSignHttpExchanges en el certificado está habilitada, que se encuentra en Opciones adicionales del certificado.

La casilla de verificación **Incluir la extensión CanSignHttpExchanges en el certificado**.

Si tu certificado no cumple con estas condiciones, los navegadores y los distribuidores rechazarán tu SXG por motivos de seguridad. En esta guía, se supone que el nombre de archivo del certificado que obtuviste de DigiCert es mySxg.pem.

Paso 2: Instala `libsxg`

El formato SXG es complejo y difícil de generar sin usar herramientas. Puedes usar una de las siguientes opciones para generar SXG:

La herramienta gen-signedexchange escrita en Go
La biblioteca libsxg escrita en C.

En esta guía, se usa libsxg.

Opción 1: Instala `libsxg` desde un paquete Debian

Puedes instalar el paquete de la forma habitual de Debian, siempre y cuando la versión de OpenSSL (libssl-dev) coincida.

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

Opción 2: Compila `libsxg` de forma manual

Si no usas un entorno compatible con los archivos .deb, puedes compilar libsxg por tu cuenta. Como condición previa, debes instalar git, cmake, openssl y 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

Paso 3: Instala el complemento `nginx`

El complemento nginx te permite generar SXG de forma dinámica en lugar de hacerlo de forma estática antes de la publicación.

Opción 1: Instala el complemento desde un paquete Debian

El módulo SXG para nginx se distribuye en GitHub. En los sistemas basados en Debian, puedes instalarlo como un paquete 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

Opción 2: Compila el complemento de forma manual

La compilación del módulo nginx requiere el código fuente de nginx. Puedes obtener el archivo tar y compilarlo junto con el módulo dinámico SXG con los siguientes comandos:

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 configuración de nginx tiene una gran flexibilidad. Instala nginx en cualquier parte del sistema y, luego, especifica una ruta de acceso respectiva de module/config/log/pidfile. En esta guía, se supone que lo instalas en /opt/nginx.

Paso 4: Configura el complemento `nginx` para que funcione con SXG

Opción 1: Configura un módulo `nginx` instalado desde Debian

Sigue estas instrucciones si usaste el Paso 3, Opción 1 antes.

Para entregar contenido de SXG, se requiere HTTPS. Puedes obtener un certificado SSL/TLS de DigiCert, Let's Encrypt y otros servicios. Ten en cuenta que NO puedes usar un certificado SXG para SSL ni viceversa, por lo que necesitarás dos certificados. El archivo de configuración en /etc/nginx/nginx.conf debería ser similar al siguiente, suponiendo que colocaste el par clave-certificado SSL en /path/to/ssl/ y el par clave-certificado SXG en /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 es esencial para que los navegadores carguen SXG correctamente, ya que localiza la cadena de certificados. La cadena de certificados contiene información de unión de certificados y OCSP con formato cbor. Ten en cuenta que no tienes que entregar el archivo cert.cbor desde el mismo origen. Puedes publicarlo a través de cualquier CDN o cualquier otro servicio de publicación de archivos estáticos, siempre que admita HTTPS.
Se planea que sxg_validitiy_url publique información relacionada con el encabezado de la firma de SXG. Si una página no se modificó desde el último SXG, no es necesario descargar todo el archivo SXG. Por lo tanto, se espera que solo la actualización de la información del encabezado de la firma reduzca el tráfico de red. Sin embargo, los detalles aún no se implementan.

Inicia nginx y estarás listo para publicar 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)

Opción 2: Configura un módulo `nginx` compilado desde la fuente

Sigue estas instrucciones si usaste el Paso 3, Opción 2 antes.

Configura tu sistema nginx instalado en /opt/nginx para que se vea similar al siguiente ejemplo:

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

Luego, inicia nginx. Ya puedes conseguir tu 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)

Paso 5: Publica el backend de tu aplicación

En los ejemplos anteriores, nginx entrega archivos estáticos en el directorio raíz, pero puedes usar directivas upstream para que tus aplicaciones creen SXG para backends de aplicaciones web arbitrarios (como Ruby on Rails, Django o Express), siempre y cuando tu nginx funcione como un servidor HTTP(S) frontal.

upstream app {
    server 127.0.0.1:8080;
}

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

Paso 6: Prueba

Usa la herramienta dump-signedexchange para probar que los SXG que se entregan sean correctos, asegurarte de que no se informen errores y verificar que los encabezados y el cuerpo sean los esperados.

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

Enviar comentarios

Los ingenieros de Chromium que trabajan en SXG están ansiosos por escuchar tus comentarios en webpackage-dev@chromium.org. También puedes unirte a la discusión sobre las especificaciones o informar un error al equipo. Tus comentarios ayudarán en gran medida al proceso de estandarización y también a abordar los problemas de implementación. ¡Gracias!