Configuración del certificado de caché

Elige una opción de TLS para el modo de caché#

¿No hay sufijo _cache- en la contraseña? No cambies nada. El modo normal del proxy mantiene TLS de extremo a extremo y no requiere instalar ningún certificado ni cambiar el TLS del cliente para el endpoint de proxy http:// sin cifrar. El endpoint de proxy https:// es la única excepción: el certificado de su hub encadena con esta misma raíz, así que confía en ella para la conexión con el proxy, como se describe en Endpoint de proxy HTTP frente a HTTPS. Esa confianza por sí sola nunca activa el modo de caché.

Con el modo de caché activo, elige una:

Omitir la verificación significa que el cliente no puede autenticar los certificados del destino. No uses nunca esa opción para inicios de sesión, pagos, API privadas, cookies ni tráfico sensible.

La URL del proxy puede empezar con http:// porque identifica el endpoint del proxy HTTP. El destino sigue siendo https://example.com/...; el esquema del endpoint del proxy y el esquema del destino son distintos.

Omitir la verificación en automatización aislada con datos públicos#

Usa esta opción solo en un cliente de caché dedicado que obtenga datos estáticos públicos. Desactiva la autenticación del certificado del destino en el cliente; no hace que sea seguro interceptar tráfico privado. Guarda las credenciales del proxy en un almacén de secretos y quita el sufijo de caché cuando termine la carga de trabajo aislada.

curl#

curl --insecure --proxy 'http://hub-us-7.litport.net:PORT' \
  --proxy-user 'USER:PASSWORD_cache-scripts' \
  'https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js'

Python Requests#

import requests

requests.get(
    'https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js',
    proxies={'https': 'http://USER:[email protected]:PORT'},
    verify=False,
    timeout=30,
)

Node#

NODE_TLS_REJECT_UNAUTHORIZED=0 node scraper.mjs

Configura el proxy HTTP en ese proceso de Node aislado. Este ajuste de entorno desactiva la verificación de certificados en ese proceso; no lo establezcas en un servicio de uso general.

Automatización de navegadores#

import { chromium } from 'playwright'

const browser = await chromium.launch({ proxy: {
  server: 'http://hub-us-7.litport.net:PORT',
  username: 'USER',
  password: 'PASSWORD_cache-scripts',
}})
const context = await browser.newContext({ ignoreHTTPSErrors: true })
await (await context.newPage()).goto('https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js')

Usa un perfil de navegador dedicado para esta carga de trabajo. No navegues con él por sitios con sesión iniciada ni por sitios sensibles.

Go#

proxyURL, err := url.Parse("http://USER:[email protected]:PORT")
if err != nil { log.Fatal(err) }
client := &http.Client{Transport: &http.Transport{
  Proxy: http.ProxyURL(proxyURL),
  TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // public-data-only isolated client
}}
response, err := client.Get("https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js")

Confiar en la raíz de Litport (recomendado)#

Dos tramos TLS verificados#

El modo de caché termina la conexión TLS del lado del cliente en el hub de Litport seleccionado para poder leer una respuesta elegible y servir después una copia local. El cliente verifica el certificado emitido para el destino contra la raíz de caché de Litport. Por separado, el hub verifica el certificado y el nombre de host reales del origen antes de leer la respuesta del origen. Mantén la verificación activada en ambos límites de confianza.

Un destino HTTP no tiene una identidad de origen autenticada y sigue la ruta normal del proxy. Usa un destino HTTPS para el modo de caché.

Identidad publicada de la raíz#

Descarga: https://litport.net/certificates/litport-cache-root.crt

Identidad legible por máquina (opcional): litport-cache-root.json

La huella es el hash de la representación DER del certificado. La suma de comprobación del archivo es el hash de los bytes del PEM descargado, incluidos la codificación del texto y los finales de línea, por lo que estos valores SHA-256 son distintos.

curl --fail --remote-name https://litport.net/certificates/litport-cache-root.crt
openssl x509 -in litport-cache-root.crt -noout -subject -issuer -dates -fingerprint -sha256
sha256sum litport-cache-root.crt

La descarga contiene material público del certificado, nunca una clave privada. Una sola raíz funciona con cualquier hub seleccionado. Cambiar de hub puede causar un fallo de caché porque las entradas son locales de cada hub; no requiere una raíz nueva.

Qué permite instalar la raíz#

La raíz pública permite que tu cliente valide los certificados de destino emitidos por la jerarquía de CA de caché de Litport. La misma raíz también valida el certificado que un hub presenta en su endpoint de proxy https://; consulta Endpoint de proxy HTTP frente a HTTPS. Litport mantiene la clave privada de la raíz sin conexión; no se despliega en los hubs. Cada hub recibe su propio certificado intermedio y su propia clave privada, por lo que la clave de la raíz no queda expuesta si un hub se ve comprometido.

En una conexión con la caché activada, el hub seleccionado puede leer la solicitud y la respuesta HTTPS. Instalar la raíz en todo el sistema también hace que cada aplicación que usa ese almacén del sistema acepte los certificados emitidos por la jerarquía de caché de Litport. Limita la confianza al cliente de caché o a su contenedor dedicado, usa el modo de caché solo con datos estáticos públicos y quita la raíz cuando la carga de trabajo ya no la necesite. Sin un sufijo _cache- válido, Litport mantiene opaco el túnel HTTPS aunque la raíz siga instalada.

Configuración del cliente#

Prefiere la confianza por proceso, por perfil o en un contenedor dedicado. La confianza a nivel de sistema es amplia: todas las aplicaciones que usan ese almacén pueden confiar en los certificados emitidos por esta raíz. Reemplaza USER, PASSWORD y PORT; aplica codificación porcentual a los caracteres reservados de la URL y nunca incluyas en commits los secretos del proxy.

curl --proxy 'http://hub-us-7.litport.net:PORT' \
  --proxy-user 'USER:PASSWORD_cache-scripts' \
  --cacert ./litport-cache-root.crt \
  'https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js'

import requests

requests.get(
    "https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js",
    proxies={"https": "http://USER:[email protected]:PORT"},
    verify="litport-cache-root.crt",
    timeout=30,
)

NODE_EXTRA_CA_CERTS=./litport-cache-root.crt node scraper.js

// Configure the Litport HTTP proxy in your Node client.
// Keep rejectUnauthorized at its default true.

// Trust litport-cache-root.crt in the isolated browser/profile
// trust store actually used by the automation browser.
// Keep ignoreHTTPSErrors: false.
// Do not use --ignore-certificate-errors.

pool, _ := x509.SystemCertPool()
pem, _ := os.ReadFile("litport-cache-root.crt")
pool.AppendCertsFromPEM(pem)
transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
    TLSClientConfig: &tls.Config{RootCAs: pool, MinVersion: tls.VersionTLS12},
}

keytool -importcert -alias litport-cache \
  -file litport-cache-root.crt \
  -keystore ./litport-cache-truststore.p12 \
  -storetype PKCS12

java -Djavax.net.ssl.trustStore=./litport-cache-truststore.p12 App

<network-security-config>
  <base-config>
    <trust-anchors><certificates src="system" /></trust-anchors>
  </base-config>
  <debug-overrides>
    <trust-anchors>
      <certificates src="@raw/litport_cache_root" />
    </trust-anchors>
  </debug-overrides>
</network-security-config>

1. Instala el perfil raíz de Litport.
2. Abre Configuración → General → Información → Config. certificados de confianza.
3. En «Confiar plenamente en certificados raíz», activa la raíz de Litport.
4. Elimina el perfil cuando termines las pruebas del modo de caché.

curl#

--cacert reemplaza el paquete de CA predeterminado de curl en esta solicitud. Si el destino necesita otra CA privada, combina las raíces necesarias en un paquete dedicado.

curl --proxy 'http://hub-us-7.litport.net:PORT' --proxy-user 'USER:PASSWORD_cache-scripts' \
  --cacert ./litport-cache-root.crt --verbose \
  'https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js'

Python Requests, httpx y aiohttp#

El archivo verify de Requests reemplaza su paquete predeterminado. Con httpx y aiohttp, crea primero el contexto predeterminado y luego llama a load_verify_locations() para agregar esta raíz a las raíces del sistema.

import asyncio, ssl
import aiohttp, httpx, requests
proxy = 'http://USER:[email protected]:PORT'
url = 'https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js'
requests.get(url, proxies={'https': proxy}, verify='litport-cache-root.crt', timeout=30)
context = ssl.create_default_context()
context.load_verify_locations(cafile='litport-cache-root.crt')
httpx.get(url, proxy=proxy, verify=context, timeout=30)
async def fetch():
    async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(ssl=context)) as session:
        async with session.get(url, proxy=proxy) as response: return await response.read()
asyncio.run(fetch())

Clientes HTTPS de Node#

NODE_EXTRA_CA_CERTS agrega raíces a Node. Un agente de proxy HTTPS real enruta el tráfico; deja rejectUnauthorized en su valor predeterminado true.

npm install https-proxy-agent
NODE_EXTRA_CA_CERTS=./litport-cache-root.crt node scraper.mjs

import https from 'node:https'
import { HttpsProxyAgent } from 'https-proxy-agent'
const agent = new HttpsProxyAgent('http://USER:[email protected]:PORT')
https.get('https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js', { agent }, response => response.resume())

Este ajuste no configura el tráfico de Chromium, Playwright ni Puppeteer.

Automatización de navegadores#

Instala la raíz en el almacén del sistema operativo o de NSS del perfil de navegador aislado. Deja ignoreHTTPSErrors: false y no uses --ignore-certificate-errors.

import { chromium } from 'playwright'
const browser = await chromium.launch({ proxy: {
  server: 'http://hub-us-7.litport.net:PORT', username: 'USER', password: 'PASSWORD_cache-scripts',
}})
const context = await browser.newContext({ ignoreHTTPSErrors: false })
await (await context.newPage()).goto('https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js')

Go#

pool, err := x509.SystemCertPool()
if err != nil || pool == nil { pool = x509.NewCertPool() }
pem, err := os.ReadFile("litport-cache-root.crt")
if err != nil || !pool.AppendCertsFromPEM(pem) { log.Fatal("could not add Litport root") }
proxyURL, err := url.Parse("http://USER:[email protected]:PORT")
if err != nil { log.Fatal(err) }
client := &http.Client{Transport: &http.Transport{
  Proxy: http.ProxyURL(proxyURL),
  TLSClientConfig: &tls.Config{RootCAs: pool, MinVersion: tls.VersionTLS12},
}}
response, err := client.Get("https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js")

SystemCertPool junto con AppendCertsFromPEM conserva las raíces del sistema y agrega esta raíz.

Java#

Un truststore dedicado se limita al proceso, pero reemplaza el paquete predeterminado de Java. Importa las demás raíces necesarias en ese almacén dedicado.

keytool -importcert -noprompt -alias litport-cache -file litport-cache-root.crt \
  -keystore ./litport-cache-truststore.p12 -storetype PKCS12 -storepass changeit
java -Djavax.net.ssl.trustStore=./litport-cache-truststore.p12 \
  -Djavax.net.ssl.trustStoreType=PKCS12 -Djavax.net.ssl.trustStorePassword=changeit App

Instalar en almacenes de confianza amplios y quitar de ellos#

Usa estos métodos solo cuando la confianza por proceso o por perfil no esté disponible; también afectan a otras aplicaciones.

Debian y Ubuntu#

sudo install -m 0644 litport-cache-root.crt /usr/local/share/ca-certificates/litport-cache-root.crt
sudo update-ca-certificates
# Remove: sudo rm /usr/local/share/ca-certificates/litport-cache-root.crt && sudo update-ca-certificates

RHEL y Fedora#

sudo install -m 0644 litport-cache-root.crt /etc/pki/ca-trust/source/anchors/litport-cache-root.crt
sudo update-ca-trust extract
# Remove: sudo rm /etc/pki/ca-trust/source/anchors/litport-cache-root.crt && sudo update-ca-trust extract

macOS#

sudo security add-trusted-cert -d -r trustRoot -k /Library/Keychains/System.keychain litport-cache-root.crt
# Remove: sudo security delete-certificate -c 'Litport cache root CA' /Library/Keychains/System.keychain

Windows#

Ejecuta lo siguiente en PowerShell con privilegios elevados:

certutil -addstore -f Root .\litport-cache-root.crt
# Remove: certutil -delstore Root "Litport cache root CA"

Firefox y NSS#

Establece FIREFOX_PROFILE con el directorio del perfil que contiene cert9.db; en Debian/Ubuntu, instala primero libnss3-tools.

certutil -A -n 'Litport cache root' -t 'C,,' -i litport-cache-root.crt -d "sql:$FIREFOX_PROFILE"
# Remove: certutil -D -n 'Litport cache root' -d "sql:$FIREFOX_PROFILE"

Contenedores y Kubernetes#

Usa una imagen dedicada para la carga de trabajo o un montaje de solo lectura en tiempo de ejecución en lugar de la confianza del host. Para Node:

COPY litport-cache-root.crt /opt/litport/litport-cache-root.crt
ENV NODE_EXTRA_CA_CERTS=/opt/litport/litport-cache-root.crt

Actualizar el almacén del sistema de la distribución hace que todos los procesos del contenedor confíen en el certificado. En Kubernetes, crea un ConfigMap a partir del PEM público descargado y móntalo solo en la carga de trabajo que necesite el modo de caché:

kubectl create configmap litport-cache-root --from-file=litport-cache-root.crt

# Pod template fragment
spec:
  containers:
    - name: client
      env:
        - name: NODE_EXTRA_CA_CERTS
          value: /var/run/litport-ca/litport-cache-root.crt
      volumeMounts:
        - { name: litport-cache-root, mountPath: /var/run/litport-ca, readOnly: true }
  volumes:
    - name: litport-cache-root
      configMap: { name: litport-cache-root }

Android#

Las apps de Android 7.0+ normalmente no confían en las CA agregadas por el usuario. Una CA incluida en la app es una opción acotada: incluye este PEM en la compilación de depuración y confía solo en él. src="user" confía en todas las CA instaladas por el usuario y es más amplio de lo que deberían aceptar la mayoría de las apps en producción. Android documenta estas fuentes de confianza y las anulaciones de depuración en Configuración de seguridad de red.

<!-- AndroidManifest.xml -->
<application android:networkSecurityConfig="@xml/network_security_config" />

La compilación de producción mantiene sus raíces normales del sistema:

<!-- src/main/res/xml/network_security_config.xml -->
<network-security-config><base-config><trust-anchors><certificates src="system" /></trust-anchors></base-config></network-security-config>

La compilación de depuración agrega la raíz de Litport incluida:

<!-- src/debug/res/xml/network_security_config.xml -->
<network-security-config>
  <base-config><trust-anchors><certificates src="system" /></trust-anchors></base-config>
  <debug-overrides><trust-anchors><certificates src="@raw/litport_cache_root" /></trust-anchors></debug-overrides>
</network-security-config>

Coloca el PEM en src/debug/res/raw/litport_cache_root.pem. Una app de terceros cuya política de confianza no se puede cambiar es incompatible con el modo de caché verificado; quita el sufijo _cache-.

iPhone y iPad#

Instala el perfil de la raíz descargado y luego completa la instalación en Configuración → General → VPN y administración de dispositivos. En Configuración → General → Información → Config. certificados de confianza, activa la confianza total para la raíz de Litport. Quítala desde VPN y administración de dispositivos → perfil → Eliminar perfil. Los dispositivos administrados deben instalar y quitar ese mismo payload mediante MDM. Una app con su propia política o con fijación de certificados puede rechazar la conexión de todos modos. Apple documenta el paso aparte de confianza total en Confiar en perfiles de certificado instalados manualmente.

Verifica la configuración#

1. Haz una solicitud de control sin sufijo: no necesita la raíz y usa el comportamiento normal del proxy.
2. Haz la misma solicitud HTTPS con una contraseña válida con la caché activada y con la verificación habilitada.
3. Repite esa misma solicitud en el mismo hub. Revisa las estadísticas de caché para ver un fallo y luego un acierto; no des por hecho que existan encabezados de caché propios.
4. Agrega --verbose a la solicitud curl verificada y confirma que la verificación del certificado se completa correctamente y que el emisor que se muestra pertenece a la jerarquía de caché de Litport.
5. Cambiar de hub puede dar un fallo porque las entradas son locales de cada hub; no requiere una raíz nueva.

curl --proxy 'http://hub-us-7.litport.net:PORT' --proxy-user 'USER:PASSWORD_cache-scripts' \
  --cacert ./litport-cache-root.crt --verbose --output /dev/null \
  'https://cdn.jsdelivr.net/npm/[email protected]/lodash.min.js'

Síntomas concretos del certificado#

Rotación y seguridad de las credenciales#

Durante la rotación, verifica la huella publicada y la suma de comprobación del archivo del nuevo PEM, confía en ambas raíces durante el periodo de solapamiento indicado, prueba el modo de caché y, pasado el solapamiento, quita la raíz anterior de cada paquete dedicado, perfil de navegador, imagen y payload de dispositivos administrados. Usa URL de proxy entre comillas y --proxy-user cuando esté disponible; usa un almacén de secretos o una variable de entorno inyectada, aplica codificación porcentual a los caracteres reservados de la URL y nunca incluyas en commits los secretos del proxy ni un historial de comandos que contenga contraseñas.

Vuelve al inicio rápido de la caché o a las opciones y solución de problemas.