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.

Tabla de Contenidos

1. Estrategias de Terminación SSL
2. Descarga SSL
3. Passthrough SSL
4. Re-Encriptación SSL
5. Enfoques Híbridos
6. Benchmarks de Rendimiento
7. Consideraciones de Seguridad
8. Ejemplos de Configuración
9. Gestión de Certificados
10. Monitoreo SSL
11. Mejores Prácticas

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.