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 que entregue archivos SXG

Hiroki Kumazaki

Los intercambios HTTP firmados (SXG) son una nueva tecnología web que les permite a los usuarios diferenciar más 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, incluidos Google Chrome, Samsung Internet y Microsoft Edge. Consulta la sección de consenso y estandarización de los 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 dedicado. En particular, no puedes reutilizar tu clave o certificado TLS.
Tener un servidor HTTP que pueda generar y entregar SXG a través de HTTPS

Supuestos

En esta guía, se da por sentado lo siguiente:

Tener un entorno de OpenSSL 1.1.1 Esta guía se escribió con Ubuntu 18.04 LTS en amd64 ISA.
Tener la capacidad de ejecutar sudo para instalar ejecutables
Usa nginx como servidor HTTP.
Usan DigiCert para generar certificados que incluyan extensiones relacionadas con SXG, ya que, por el momento, 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 de SXG

Para generar un SXG, necesitas un certificado TLS con la extensión CanSignHttpExchanges y un tipo de clave particular. DigiCert proporciona certificados con esta extensión. Necesitas un archivo CSR para la emisión de un certificado, por lo que debes generarlo 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"

Obtendrás un archivo CSR similar al siguiente:

Comprueba lo siguiente:

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

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

Si tu certificado no cumple con estas condiciones, los navegadores y 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 manera habitual en Debian, siempre que 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 entrega.

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 nginx. Puedes obtener el tarball 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 de tu sistema y especifica una ruta de acceso respectiva de module/config/log/pidfile. En esta guía, se da por sentado que lo instalas en /opt/nginx.

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

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

Sigue estas instrucciones si ya usaste el Paso 3, opción 1.

La entrega de contenido de SXG requiere HTTPS. Puede obtener un certificado SSL/TLS de DigiCert, Let's Encrypt y otros servicios. Tenga en cuenta que NO puede usar un certificado SXG para SSL ni viceversa, por lo que necesitará 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 fundamental para que los navegadores carguen SXG de forma correcta, ya que localiza la cadena de certificados. La cadena de certificados contiene información sobre certificados y grapados de OCSP con formato cbor. Ten en cuenta que no es necesario que entregues el archivo cert.cbor desde el mismo origen. Puedes entregarlo a través de cualquier CDN o cualquier otro servicio de entrega de archivos estáticos, siempre y cuando sea compatible con HTTPS.
Se planea que sxg_validitiy_url entregue información relacionada con el encabezado de la firma SXG. Si una página no se modificó desde el último SXG, técnicamente no es necesario descargar el archivo SXG completo. Por lo tanto, se espera que actualizar por sí solo la información del encabezado de firma reduzca el tráfico de red. Sin embargo, aún no se implementaron los detalles.

Inicia nginx y estará todo 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 a partir de la fuente

Sigue estas instrucciones si ya usaste el Paso 3, opción 2.

Configura el 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: Entrega el backend de tu aplicación

En los ejemplos anteriores, nginx entrega archivos estáticos en el directorio raíz, pero puedes usar directivas ascendentes para que tus aplicaciones creen SXG para backends de aplicaciones web arbitrarios (como Ruby on Rails, Django o Express) siempre que 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 volcado de firmas 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 dispuestos a recibir tus comentarios en webpackage-dev@chromium.org. También puedes unirte a la discusión sobre especificaciones o informar un error al equipo. Tus comentarios serán de gran ayuda para el proceso de estandarización y también ayudarán a abordar los problemas de implementación. Gracias