```html

Solución de problemas SSL/TLS al usar proxy: guía completa

Los errores SSL/TLS son uno de los problemas más frecuentes al trabajar a través de servidores proxy. La configuración incorrecta provoca fallos de conexión, fugas de datos e imposibilidad de analizar recursos protegidos. En esta guía analizaremos las causas de los errores y los métodos para resolverlos con ejemplos de código específicos.

Cómo funciona SSL/TLS a través de proxy

Antes de resolver problemas, es importante entender el mecanismo de funcionamiento de las conexiones seguras a través de proxy. Existen dos enfoques fundamentalmente diferentes para proxificar tráfico HTTPS, y cada uno tiene sus propias características, ventajas y puntos potenciales de fallo.

Tunelización transparente (CONNECT)

Al utilizar el método CONNECT, el servidor proxy crea un túnel TCP entre el cliente y el servidor de destino. El proxy no ve el contenido del tráfico: simplemente transmite bytes cifrados en ambas direcciones. Este es el método más seguro y común para trabajar con HTTPS a través de proxy.

El proceso de establecimiento de conexión se ve de la siguiente manera: el cliente envía una solicitud CONNECT al proxy especificando el host y puerto de destino. El proxy establece una conexión TCP con el servidor de destino y devuelve al cliente una respuesta 200 Connection Established. Después de esto, el cliente realiza el protocolo de enlace TLS directamente con el servidor de destino a través del túnel establecido.

# Esquema de túnel CONNECT
Cliente → Proxy: CONNECT example.com:443 HTTP/1.1
Proxy → Servidor: [Conexión TCP al puerto 443]
Proxy → Cliente: HTTP/1.1 200 Connection Established
Cliente ↔ Servidor: [Protocolo de enlace TLS a través del túnel]
Cliente ↔ Servidor: [Tráfico cifrado]

Proxificación MITM (interceptación)

Algunos proxies (especialmente corporativos) utilizan la técnica Man-in-the-Middle: terminan la conexión TLS en su lado, descifran el tráfico y luego establecen una nueva conexión TLS con el servidor de destino. Para ello, el proxy genera su propio certificado para cada dominio, firmado por el certificado raíz del proxy.

Este enfoque permite inspeccionar y filtrar tráfico HTTPS, pero requiere instalar el certificado raíz del proxy en el almacén de certificados de confianza del cliente. Aquí es donde surgen la mayoría de los problemas con SSL/TLS al trabajar a través de redes corporativas.

Errores típicos y sus causas

Consideremos los errores SSL/TLS más comunes al trabajar a través de proxy. Comprender la causa de cada error es la clave para resolver rápidamente el problema.

SSL: CERTIFICATE_VERIFY_FAILED

Este error significa que el cliente no puede verificar la autenticidad del certificado del servidor. Puede haber varias razones: el proxy utiliza inspección MITM con un certificado raíz no instalado, el certificado del servidor de destino ha expirado o es autofirmado, o falta un certificado intermedio en la cadena.

# Python - mensaje de error típico
ssl.SSLCertVerificationError: [SSL: CERTIFICATE_VERIFY_FAILED] 
certificate verify failed: unable to get local issuer certificate

# Node.js
Error: unable to verify the first certificate

# cURL
curl: (60) SSL certificate problem: unable to get local issuer certificate

SSL: WRONG_VERSION_NUMBER

El error ocurre cuando el cliente intenta establecer una conexión TLS pero recibe una respuesta en un formato inesperado. La mayoría de las veces esto sucede cuando el proxy no admite el método CONNECT e intenta procesar la solicitud HTTPS como HTTP ordinario. La causa también puede ser un puerto o protocolo incorrecto.

TLSV1_ALERT_PROTOCOL_VERSION

El servidor rechaza la conexión debido a una versión de protocolo TLS incompatible. Los servidores modernos deshabilitan las versiones antiguas de TLS 1.0 y TLS 1.1 por razones de seguridad. Si el proxy o cliente están configurados para usar versiones antiguas, la conexión será rechazada.

SSLV3_ALERT_HANDSHAKE_FAILURE

El cliente y el servidor no pudieron negociar los parámetros de cifrado. Esto puede ocurrir debido a la ausencia de suites de cifrado comunes, problemas con SNI (Server Name Indication) o incompatibilidad de bibliotecas criptográficas.

Error	Causa probable	Solución
`CERTIFICATE_VERIFY_FAILED`	Proxy MITM, certificado expirado	Instalar certificado raíz del proxy
`WRONG_VERSION_NUMBER`	HTTP en lugar de HTTPS, sin soporte CONNECT	Verificar configuración de proxy y protocolo
`PROTOCOL_VERSION`	Versión antigua de TLS	Actualizar versión mínima de TLS
`HANDSHAKE_FAILURE`	Suites de cifrado incompatibles	Configurar lista de cifrados

Problemas con certificados

Los certificados son la fuente más frecuente de problemas al trabajar a través de proxy. Consideremos los escenarios principales y las formas de resolverlos.

Instalación del certificado raíz del proxy

Si el proxy utiliza inspección MITM, es necesario agregar su certificado raíz al almacén de certificados de confianza. El proceso depende del sistema operativo y del lenguaje de programación utilizado.

# Linux: agregar certificado al almacén del sistema
sudo cp proxy-ca.crt /usr/local/share/ca-certificates/
sudo update-ca-certificates

# macOS: agregar a Keychain
sudo security add-trusted-cert -d -r trustRoot \
    -k /Library/Keychains/System.keychain proxy-ca.crt

# Windows PowerShell (como administrador)
Import-Certificate -FilePath "proxy-ca.crt" `
    -CertStoreLocation Cert:\LocalMachine\Root

Especificación del certificado en el código

A veces es más conveniente especificar la ruta del certificado directamente en el código, especialmente cuando se trabaja en contenedores o en servidores sin acceso de root. Esto permite evitar modificar la configuración del sistema.

# Python: especificar CA-bundle personalizado
import requests

# Método 1: especificar ruta al archivo de certificado
response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy:8080'},
    verify='/path/to/proxy-ca.crt'
)

# Método 2: combinar con certificados del sistema
import certifi
import ssl

# Crear archivo de certificados combinado
with open('combined-ca.crt', 'w') as combined:
    with open(certifi.where()) as system_certs:
        combined.write(system_certs.read())
    with open('proxy-ca.crt') as proxy_cert:
        combined.write(proxy_cert.read())

response = requests.get(url, verify='combined-ca.crt')

Deshabilitación de la verificación de certificados

En algunos casos (¡solo para pruebas y depuración!) puede ser necesario deshabilitar la verificación de certificados. Esto no es seguro y no debe usarse en producción, ya que hace que la conexión sea vulnerable a ataques MITM.

⚠️ Advertencia: Deshabilitar la verificación de certificados hace que la conexión sea vulnerable a interceptación. ¡Úselo solo para depuración en un entorno aislado, nunca en producción!

# Python - ¡SOLO para depuración!
import requests
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy:8080'},
    verify=False  # ¡No es seguro!
)

Configuración de túneles CONNECT

La configuración correcta del túnel CONNECT es la clave para un funcionamiento estable de HTTPS a través de proxy. Consideremos las características de configuración para diferentes escenarios de uso.

Verificación de soporte CONNECT

No todos los proxies admiten el método CONNECT. Los proxies HTTP pueden estar configurados solo para proxificar tráfico HTTP. Antes de usar, asegúrese de que el proxy admita tunelización HTTPS.

# Verificar soporte CONNECT mediante netcat/telnet
echo -e "CONNECT example.com:443 HTTP/1.1\r\nHost: example.com:443\r\n\r\n" | \
    nc proxy.example.com 8080

# Respuesta esperada en caso de éxito:
# HTTP/1.1 200 Connection Established

# Posibles respuestas en caso de error:
# HTTP/1.1 403 Forbidden - CONNECT está prohibido
# HTTP/1.1 405 Method Not Allowed - método no soportado

Autenticación en solicitudes CONNECT

Al usar un proxy con autenticación, es importante transmitir correctamente las credenciales. El encabezado Proxy-Authorization debe estar presente en la solicitud CONNECT.

# Python: autenticación mediante URL
import requests

proxy_url = 'http://username:password@proxy.example.com:8080'
response = requests.get(
    'https://target.com',
    proxies={'https': proxy_url}
)

# Python: autenticación mediante encabezados (para casos complejos)
import base64

credentials = base64.b64encode(b'username:password').decode('ascii')
session = requests.Session()
session.headers['Proxy-Authorization'] = f'Basic {credentials}'
session.proxies = {'https': 'http://proxy.example.com:8080'}

response = session.get('https://target.com')

Trabajo con proxies SOCKS5

Los proxies SOCKS5 funcionan en un nivel más bajo y no requieren un manejo especial de HTTPS. Simplemente tunelean conexiones TCP, lo que los hace ideales para trabajar con cualquier protocolo.

# Python con PySocks
import requests

proxies = {
    'http': 'socks5h://user:pass@proxy:1080',
    'https': 'socks5h://user:pass@proxy:1080'
}

# socks5h - resolución DNS a través del proxy
# socks5 - resolución DNS local

response = requests.get('https://example.com', proxies=proxies)

Soluciones para diferentes lenguajes de programación

Cada lenguaje y biblioteca tienen sus propias características para trabajar con SSL/TLS a través de proxy. Consideremos las opciones más comunes con ejemplos de código completos.

Python (requests + urllib3)

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.ssl_ import create_urllib3_context
import ssl

class TLSAdapter(HTTPAdapter):
    """Adaptador con parámetros TLS personalizables"""
    
    def __init__(self, ssl_context=None, **kwargs):
        self.ssl_context = ssl_context
        super().__init__(**kwargs)
    
    def init_poolmanager(self, *args, **kwargs):
        if self.ssl_context:
            kwargs['ssl_context'] = self.ssl_context
        return super().init_poolmanager(*args, **kwargs)

# Crear contexto con configuración moderna
ctx = create_urllib3_context()
ctx.minimum_version = ssl.TLSVersion.TLSv1_2
ctx.set_ciphers('ECDHE+AESGCM:DHE+AESGCM:ECDHE+CHACHA20')

# Cargar certificado adicional
ctx.load_verify_locations('proxy-ca.crt')

session = requests.Session()
session.mount('https://', TLSAdapter(ssl_context=ctx))
session.proxies = {
    'http': 'http://proxy:8080',
    'https': 'http://proxy:8080'
}

response = session.get('https://example.com')
print(response.status_code)

Node.js (axios + https-proxy-agent)

const axios = require('axios');
const { HttpsProxyAgent } = require('https-proxy-agent');
const fs = require('fs');
const https = require('https');

// Cargar certificado CA personalizado
const customCA = fs.readFileSync('proxy-ca.crt');

const agent = new HttpsProxyAgent({
    host: 'proxy.example.com',
    port: 8080,
    auth: 'username:password',
    ca: customCA,
    rejectUnauthorized: true  // ¡No deshabilite en producción!
});

const client = axios.create({
    httpsAgent: agent,
    proxy: false  // Importante: deshabilitar proxy integrado de axios
});

async function fetchData() {
    try {
        const response = await client.get('https://example.com');
        console.log(response.data);
    } catch (error) {
        if (error.code === 'UNABLE_TO_VERIFY_LEAF_SIGNATURE') {
            console.error('Problema con certificado:', error.message);
        }
        throw error;
    }
}

fetchData();

Go (net/http)

package main

import (
    "crypto/tls"
    "crypto/x509"
    "io/ioutil"
    "net/http"
    "net/url"
    "log"
)

func main() {
    // Cargar certificado adicional
    caCert, err := ioutil.ReadFile("proxy-ca.crt")
    if err != nil {
        log.Fatal(err)
    }
    
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)
    
    // Configurar TLS
    tlsConfig := &tls.Config{
        RootCAs:    caCertPool,
        MinVersion: tls.VersionTLS12,
    }
    
    // Configurar proxy
    proxyURL, _ := url.Parse("http://user:pass@proxy:8080")
    
    transport := &http.Transport{
        Proxy:           http.ProxyURL(proxyURL),
        TLSClientConfig: tlsConfig,
    }
    
    client := &http.Client{Transport: transport}
    
    resp, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    
    log.Printf("Status: %s", resp.Status)
}

cURL (línea de comandos)

# Solicitud básica a través de proxy
curl -x http://proxy:8080 https://example.com

# Con autenticación
curl -x http://proxy:8080 -U username:password https://example.com

# Especificando certificado CA
curl -x http://proxy:8080 --cacert proxy-ca.crt https://example.com

# Forzar uso de TLS 1.2+
curl -x http://proxy:8080 --tlsv1.2 https://example.com

# Depuración del protocolo de enlace TLS
curl -x http://proxy:8080 -v --trace-ascii - https://example.com 2>&1 | \
    grep -E "(SSL|TLS|certificate)"

Detección y evasión de inspección MITM

Algunas redes (corporativas, Wi-Fi público) utilizan inspección MITM transparente del tráfico HTTPS. Esto puede causar problemas con certificate pinning e interrumpir el funcionamiento de aplicaciones que esperan certificados específicos.

Detección de proxy MITM

import ssl
import socket

def check_certificate_issuer(hostname, port=443):
    """Verifica quién emitió el certificado del sitio"""
    context = ssl.create_default_context()
    
    with socket.create_connection((hostname, port)) as sock:
        with context.wrap_socket(sock, server_hostname=hostname) as ssock:
            cert = ssock.getpeercert()
            
            issuer = dict(x[0] for x in cert['issuer'])
            subject = dict(x[0] for x in cert['subject'])
            
            print(f"Asunto: {subject.get('commonName')}")
            print(f"Emisor: {issuer.get('commonName')}")
            print(f"Organización: {issuer.get('organizationName')}")
            
            # Proxies MITM corporativos conocidos
            mitm_indicators = [
                'Zscaler', 'BlueCoat', 'Symantec', 'Fortinet',
                'Palo Alto', 'McAfee', 'Cisco', 'Corporate'
            ]
            
            issuer_str = str(issuer)
            for indicator in mitm_indicators:
                if indicator.lower() in issuer_str.lower():
                    print(f"⚠️ Proxy MITM detectado: {indicator}")
                    return True
            
            return False

# Verificación
check_certificate_issuer('google.com')

Trabajo en condiciones MITM

Si se detecta un proxy MITM, hay varias estrategias de trabajo. Puede instalar el certificado raíz del proxy (si es una red corporativa confiable), usar puertos o protocolos alternativos, o aplicar VPN para evadir la inspección.

# Obtener certificado del proxy MITM para instalación
openssl s_client -connect example.com:443 -proxy proxy:8080 \
    -showcerts 2>/dev/null | \
    openssl x509 -outform PEM > mitm-cert.pem

# Ver información del certificado
openssl x509 -in mitm-cert.pem -text -noout | head -20

Herramientas de diagnóstico

El diagnóstico correcto es la mitad de la solución del problema. Consideremos herramientas y métodos para depurar conexiones SSL/TLS a través de proxy.

OpenSSL para diagnóstico

# Verificar conexión a través de proxy
openssl s_client -connect example.com:443 \
    -proxy proxy.example.com:8080 \
    -servername example.com

# Verificar cadena de certificados
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -showcerts 2>/dev/null | \
    grep -E "(Certificate chain|s:|i:)"

# Probar versión específica de TLS
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -tls1_2

# Verificar suites de cifrado soportados
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -cipher 'ECDHE-RSA-AES256-GCM-SHA384'

Script Python para diagnóstico

import ssl
import socket
import requests
from urllib.parse import urlparse

def diagnose_ssl_proxy(target_url, proxy_url):
    """Diagnóstico integral de SSL a través de proxy"""
    
    print(f"🔍 Diagnóstico: {target_url}")
    print(f"📡 Proxy: {proxy_url}\n")
    
    # 1. Verificar disponibilidad del proxy
    proxy = urlparse(proxy_url)
    try:
        sock = socket.create_connection(
            (proxy.hostname, proxy.port), 
            timeout=10
        )
        sock.close()
        print("✅ Proxy disponible")
    except Exception as e:
        print(f"❌ Proxy no disponible: {e}")
        return
    
    # 2. Verificar método CONNECT
    try:
        response = requests.get(
            target_url,
            proxies={'https': proxy_url},
            timeout=15
        )
        print(f"✅ Conexión HTTPS exitosa: {response.status_code}")
    except requests.exceptions.SSLError as e:
        print(f"❌ Error SSL (intento {1}): {e}")
        
        # Intentar sin verificación para diagnóstico
        try:
            response = requests.get(
                target_url,
                proxies={'https': proxy_url},
                verify=False,
                timeout=15
            )
            print("⚠️ Conexión funciona sin verificación de certificado")
            print("   Probable problema con certificado CA del proxy")
        except Exception as e2:
            print(f"❌ No funciona ni sin verificación: {e2}")
    
    except Exception as e:
        print(f"❌ Error de conexión: {e}")
    
    # 3. Información de SSL
    print(f"\n📋 Versión OpenSSL: {ssl.OPENSSL_VERSION}")
    print(f"📋 Rutas de verificación predeterminadas: {ssl.get_default_verify_paths()}")

# Uso
diagnose_ssl_proxy(
    'https://httpbin.org/ip',
    'http://proxy:8080'
)

Wireshark para análisis profundo

Para casos complejos, use Wireshark con filtro en tráfico TLS. Esto permite ver detalles del protocolo de enlace e identificar exactamente el momento del fallo.

# Filtros de Wireshark para análisis TLS
tls.handshake.type == 1          # Client Hello
tls.handshake.type == 2          # Server Hello
tls.handshake.type == 11         # Certificate
tls.alert_message                 # Alertas TLS (errores)

# Capturar tráfico con tcpdump
tcpdump -i eth0 -w ssl_debug.pcap \
    'port 443 or port 8080' -c 1000

Mejores prácticas de trabajo seguro

Seguir las mejores prácticas ayudará a evitar la mayoría de los problemas con SSL/TLS y garantizará la seguridad de sus datos al trabajar a través de proxy.

Configuración de TLS

Use mínimo TLS 1.2, preferiblemente TLS 1.3
Configure suites de cifrado modernos (ECDHE, AES-GCM, ChaCha20)
Habilite la verificación de certificados (nunca deshabilite verify en producción)
Actualice regularmente CA-bundle y bibliotecas criptográficas

Trabajo con proxy

Prefiera proxies con soporte completo del método CONNECT para tráfico HTTPS
Use SOCKS5 para tunelización universal
Al trabajar con proxies residenciales tenga en cuenta posibles características de redes de proveedores
Almacene credenciales de proxy en variables de entorno, no en código

Manejo de errores

import requests
from requests.exceptions import SSLError, ProxyError, ConnectionError
import time

def robust_request(url, proxy, max_retries=3):
    """Solicitud resistente a errores a través de proxy"""
    
    for attempt in range(max_retries):
        try:
            response = requests.get(
                url,
                proxies={'https': proxy},
                timeout=30
            )
            return response
            
        except SSLError as e:
            print(f"Error SSL (intento {attempt + 1}): {e}")
            # Los errores SSL generalmente no se corrigen con reintentos
            if 'CERTIFICATE_VERIFY_FAILED' in str(e):
                raise  # Requiere corrección de configuración
                
        except ProxyError as e:
            print(f"Error de proxy (intento {attempt + 1}): {e}")
            time.sleep(2 ** attempt)  # Retraso exponencial
            
        except ConnectionError as e:
            print(f"Error de conexión (intento {attempt + 1}): {e}")
            time.sleep(2 ** attempt)
    
    raise Exception(f"No se pudo ejecutar solicitud después de {max_retries} intentos")

Lista de verificación para resolver problemas

Cuando surjan errores SSL/TLS, siga este orden de diagnóstico:

Verifique la disponibilidad del servidor proxy (ping, telnet)
Asegúrese de que admita el método CONNECT
Verifique la corrección de las credenciales de autenticación
Examine el certificado usando openssl s_client
Verifique la presencia de inspección MITM
Instale los certificados CA necesarios
Actualice la versión de TLS y suites de cifrado

💡 Consejo: La mayoría de los problemas SSL/TLS al trabajar a través de proxy están relacionados con certificados. Comience el diagnóstico verificando la cadena de certificados y asegúrese de que todos los certificados intermedios estén presentes.

Conclusión

Los problemas SSL/TLS al trabajar a través de proxy se pueden resolver con un enfoque sistemático para el diagnóstico. Los puntos clave son: comprender la diferencia entre tunelización CONNECT e inspección MITM, configurar correctamente los certificados y usar versiones modernas del protocolo TLS. La mayoría de los errores están relacionados con la ausencia de certificados CA necesarios o incompatibilidad de parámetros criptográficos.

Para tareas de análisis y automatización que requieren funcionamiento estable de HTTPS, se recomienda usar proxies de calidad con soporte completo del método CONNECT; más información sobre opciones disponibles en proxycove.com.

```

Solución de Problemas SSL/TLS al Usar Proxy: Guía Completa