Comparación de Estrategias de Terminación SSL

La terminación SSL/TLS es el proceso de desencriptar tráfico HTTPS en un proxy de borde, luego comunicarse con servicios backend usando conexiones sin encriptar o encriptadas por separado. Las diferentes estrategias de terminación ofrecen compensaciones de seguridad, rendimiento y operacionales variadas. Esta guía compara descarga SSL, passthrough, re-encriptación e enfoques híbridos con benchmarks de rendimiento y consideraciones de seguridad.

Estrategias de Terminación SSL

Tres estrategias primarias existen para manejar SSL/TLS en arquitecturas de proxy:

  1. Descarga SSL: El proxy maneja encriptación/desencriptación, backends usan texto plano
  2. Passthrough SSL: El proxy reenvía tráfico encriptado sin cambios
  3. Re-Encriptación SSL: El proxy termina SSL de cliente, crea nuevo SSL a backends

Cada estrategia implica diferentes características de rendimiento, implicaciones de seguridad y consideraciones operacionales.

Descarga SSL

La descarga SSL termina HTTPS en el proxy y se comunica con backends sobre HTTP:

Cliente HTTPS ──→ [Proxy: SSL/TLS] → Backend HTTP

Beneficios:

  • Gestión centralizada de certificados
  • Descarga de encriptación CPU-intensiva de backends
  • Simplifica configuración backend
  • Habilita inspección y modificación de SSL
  • Reduce complejidad backend

Desventajas:

  • Tráfico en texto plano entre proxy y backend
  • Requiere red interna segura
  • Problema potencial de seguridad para datos sensibles
  • Visibilidad del certificado de cliente backend limitada

Configuración de Descarga SSL de Nginx

upstream backend {
    server 192.168.1.100:8000;
    server 192.168.1.101:8000;
    server 192.168.1.102:8000;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name api.example.com;
    
    ssl_certificate /etc/nginx/ssl/api.example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/api.example.com.key;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_session_tickets off;
    
    add_header Strict-Transport-Security "max-age=31536000" always;
    
    location / {
        proxy_pass http://backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

server {
    listen 80;
    server_name api.example.com;
    return 301 https://$server_name$request_uri;
}

Descarga SSL de HAProxy

global
    tune.ssl.default-dh-param 2048
    tune.ssl.ciphers HIGH:!aNULL:!MD5

frontend https_in
    bind *:443 ssl crt /etc/haproxy/certs/api.example.com.pem
    bind *:80
    
    mode http
    option httpclose
    option forwardfor
    
    http-request set-header X-Forwarded-Proto https
    http-request redirect scheme https code 301 if !{ ssl_fc }
    
    default_backend backend_servers

backend backend_servers
    balance roundrobin
    server srv1 192.168.1.100:8000 check
    server srv2 192.168.1.101:8000 check

Passthrough SSL

El passthrough SSL reenvía tráfico encriptado sin cambios, permitiendo que los backends manejen encriptación:

Cliente HTTPS → [Proxy: Passthrough] → Backend HTTPS

Beneficios:

  • Sin costo de CPU de encriptación en proxy
  • Encriptación end-to-end, backends desencriptan
  • Backends retienen control total de SSL
  • Apropiado para aplicaciones sensibles

Desventajas:

  • No puede inspeccionar o modificar contenido encriptado
  • No puede enrutar basado en propiedades SSL
  • Basado en Capa 4 (TCP), enrutamiento menos inteligente
  • Requiere gestión de certificados en todos los backends

Configuración de Passthrough SSL de HAProxy

frontend https_in
    bind *:443
    mode tcp
    default_backend https_backend

backend https_backend
    balance leastconn
    mode tcp
    
    server srv1 192.168.1.100:443 check
    server srv2 192.168.1.101:443 check
    server srv3 192.168.1.102:443 check

El passthrough soporta solo enrutamiento de capa 4:

global
    stats socket /run/haproxy/admin.sock

frontend https_in
    bind *:443
    mode tcp
    
    acl has_client_cert ssl_c_verify eq SUCCESS
    
    use_backend backend_trusted if has_client_cert
    default_backend backend_standard

backend backend_trusted
    balance roundrobin
    mode tcp
    server srv1 192.168.1.100:443 check
    server srv2 192.168.1.101:443 check

backend backend_standard
    balance roundrobin
    mode tcp
    server srv3 192.168.1.110:443 check
    server srv4 192.168.1.111:443 check

Re-Encriptación SSL

La re-encriptación SSL termina SSL de cliente, luego crea nuevas conexiones SSL a backends:

Cliente HTTPS → [Proxy: SSL→SSL] → Backend HTTPS

Beneficios:

  • Los clientes usan versiones TLS modernas mientras backends usan versiones antiguas
  • Gestión centralizada de certificados para cliente
  • Puede inspeccionar y modificar tráfico encriptado
  • Habilita decisiones de enrutamiento avanzadas
  • Backends mantienen encriptación con certificados separados

Desventajas:

  • Mayor costo de CPU que descarga
  • Requiere certificados en proxy y backends
  • Gestión más compleja
  • Latencia adicional de doble encriptación

Re-Encriptación SSL de Nginx

upstream backend_ssl {
    server 192.168.1.100:8443;
    server 192.168.1.101:8443;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name api.example.com;
    
    # SSL cliente
    ssl_certificate /etc/nginx/ssl/api.example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/api.example.com.key;
    ssl_protocols TLSv1.3;
    ssl_ciphers TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    
    location / {
        proxy_pass https://backend_ssl;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto https;
        
        # SSL Upstream
        proxy_ssl_certificate /etc/nginx/ssl/client-cert.pem;
        proxy_ssl_certificate_key /etc/nginx/ssl/client-key.pem;
        proxy_ssl_verify off;
        proxy_ssl_session_reuse on;
    }
}

Re-Encriptación SSL de HAProxy

global
    tune.ssl.default-dh-param 2048

frontend https_in
    bind *:443 ssl crt /etc/haproxy/certs/api.example.com.pem
    mode http
    option httpclose
    option forwardfor
    default_backend backend_ssl

backend backend_ssl
    balance roundrobin
    mode http
    
    server srv1 192.168.1.100:8443 check ssl verify none
    server srv2 192.168.1.101:8443 check ssl verify none
    server srv3 192.168.1.102:8443 check ssl verify none

Enfoques Híbridos

Combine estrategias para diferentes tipos de tráfico:

upstream backend_plaintext {
    server 192.168.1.100:8000;
    server 192.168.1.101:8000;
}

upstream backend_ssl {
    server 192.168.1.110:8443;
    server 192.168.1.111:8443;
}

upstream backend_passthrough {
    server 192.168.1.200:443;
    server 192.168.1.201:443;
}

server {
    listen 443 ssl http2;
    server_name api.example.com;
    
    ssl_certificate /etc/nginx/ssl/api.example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/api.example.com.key;
    
    location /api {
        # SSL offloading for public API
        proxy_pass http://backend_plaintext;
    }
    
    location /secure {
        # SSL re-encryption for sensitive data
        proxy_pass https://backend_ssl;
        proxy_ssl_verify off;
    }
    
    location /legacy {
        # Passthrough for legacy systems
        # Note: This would require layer 4 routing
    }
}

Benchmarks de Rendimiento

El rendimiento de terminación SSL depende del hardware, algoritmos y reanudación de sesión.

Rendimiento de Descarga

# Test SSL offloading (proxy handles encryption)
ab -n 1000 -c 100 https://proxy.example.com/

# Results (4-core server):
# Requests per second: 15,000 - 25,000 req/sec
# Time per request: 4-7ms

Rendimiento de Passthrough

# Test passthrough (no proxy encryption)
# Layer 4 routing, minimal overhead
# Results:
# Requests per second: 30,000 - 50,000 req/sec
# Time per request: 2-3ms

Rendimiento de Re-Encriptación

# Test re-encryption (double SSL)
ab -n 1000 -c 100 https://proxy.example.com/

# Results:
# Requests per second: 8,000 - 12,000 req/sec
# Time per request: 8-12ms

Características de rendimiento:

  • Descarga: Costo de encriptación base (~10-20% vs texto plano)
  • Passthrough: Sobrecarga mínima (~2-3% vs texto plano)
  • Re-Encriptación: Sobrecarga significativa (~30-40% vs texto plano)

Consideraciones de Seguridad

Seguridad de Descarga SSL

Asegúrese de que las redes internas sean seguras:

# Use IPsec or VPN for untrusted networks
sudo ip link add vti0 type vti remote 192.168.1.100 local 10.0.0.1

Restrinja acceso al puerto backend con reglas de firewall:

sudo ufw allow from 10.0.0.5 to 192.168.1.100 port 8000

Habilite encabezados X-Forwarded con cuidado:

# Only trust proxy-added headers
set_real_ip_from 10.0.0.0/24;
real_ip_header X-Forwarded-For;

Seguridad de Passthrough SSL

Asegúrese de que los certificados backend sean válidos:

openssl s_client -connect 192.168.1.100:443 -servername example.com

Use fijación de certificado si es necesario:

backend passthrough_backend
    balance roundrobin
    mode tcp
    server srv1 192.168.1.100:443 check ssl verify required ca-file /etc/ssl/certs/ca.pem

Seguridad de Re-Encriptación SSL

Use autenticación fuerte de certificado de cliente:

proxy_ssl_certificate /etc/nginx/ssl/client-cert.pem;
proxy_ssl_certificate_key /etc/nginx/ssl/client-key.pem;
proxy_ssl_verify on;
proxy_ssl_verify_depth 2;
proxy_ssl_trusted_certificate /etc/nginx/ssl/ca.pem;

Implemente rotación de certificados:

# Rotate proxy certificates every 3 months
# Rotate client certificates every 1 year

Ejemplos de Configuración

Configuración Completa de Descarga

upstream backend {
    server 192.168.1.100:8000;
    server 192.168.1.101:8000;
    server 192.168.1.102:8000;
    keepalive 32;
}

server {
    listen 443 ssl http2;
    server_name api.example.com;
    
    ssl_certificate /etc/nginx/ssl/api.example.com.crt;
    ssl_certificate_key /etc/nginx/ssl/api.example.com.key;
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5:!3DES:!DES:!RC4:!IDEA:!SEED:!aDSS:!SRP:!PSK;
    ssl_prefer_server_ciphers on;
    ssl_session_cache shared:SSL:10m;
    ssl_session_timeout 10m;
    ssl_session_tickets off;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_stapling_responder_timeout 5s;
    
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    add_header X-Frame-Options "DENY" always;
    add_header X-Content-Type-Options "nosniff" always;
    
    location / {
        proxy_pass http://backend;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        proxy_connect_timeout 5s;
        proxy_send_timeout 30s;
        proxy_read_timeout 30s;
    }
}

server {
    listen 80;
    server_name api.example.com;
    return 301 https://$server_name$request_uri;
}

Gestión de Certificados

Automatice actualizaciones de certificados:

#!/bin/bash
# Certificate renewal script

for domain in api.example.com blog.example.com cdn.example.com; do
    certbot renew --cert-name $domain --quiet
done

# Reload Nginx to pick up new certificates
nginx -s reload

Monitoreo SSL

Compruebe expiración del certificado SSL:

for domain in api.example.com blog.example.com; do
    echo "=== $domain ==="
    openssl s_client -connect $domain:443 -servername $domain < /dev/null 2>/dev/null | \
    openssl x509 -noout -dates
done

Monitoree estadísticas de sesión SSL:

server {
    listen 8080;
    location /ssl_stats {
        access_log off;
        default_type text/plain;
        return 200 "SSL Sessions: $ssl_session_reused\n";
    }
}

Mejores Prácticas

  1. Use Descarga SSL para la mayoría de casos: Simple, eficiente, manejable
  2. Implemente HSTS: Fuerce HTTPS y transporte seguro de cookies
  3. Habilite OCSP Stapling: Reduzca retrasos de validación de certificado del lado del cliente
  4. Use TLS 1.2+: Deshabilite protocolos antiguos
  5. Habilite Reanudación de Sesión: Reduzca sobrecarga de reconexión
  6. Rote Certificados: Cada 90 días o menos
  7. Monitoree Expiración de Certificado: Alerta antes de expiración
  8. Use Cifrados Fuertes: Deshabilite cifrados débiles y algoritmos
  9. Implemente Perfect Forward Secrecy: Use intercambio de claves efímero
  10. Asegure Redes Internas: Proteja tráfico backend en texto plano

Conclusión

Elija estrategias de terminación SSL basadas en requisitos de seguridad, necesidades de rendimiento y restricciones operacionales. La descarga SSL proporciona el mejor equilibrio para la mayoría de implementaciones, passthrough SSL para escenarios donde backends deben controlar encriptación, y re-encriptación SSL para casos que requieren encriptación tanto de cliente como de backend. La configuración apropiada, gestión de certificados y endurecimiento de seguridad aseguran comunicación encriptada confiable y segura.