```html

Résolution des problèmes SSL/TLS lors de l'utilisation de proxy : guide complet

Les erreurs SSL/TLS sont l'un des problèmes les plus courants lors du travail via des serveurs proxy. Une configuration incorrecte entraîne des défaillances de connexion, des fuites de données et l'impossibilité d'analyser les ressources protégées. Dans ce guide, nous examinerons les causes des erreurs et les méthodes pour les résoudre avec des exemples de code spécifiques.

Comment fonctionne SSL/TLS via proxy

Avant de résoudre les problèmes, il est important de comprendre le mécanisme de fonctionnement des connexions sécurisées via proxy. Il existe deux approches fondamentalement différentes pour le proxying du trafic HTTPS, et chacune a ses propres caractéristiques, avantages et points de défaillance potentiels.

Tunnelage transparent (CONNECT)

Lors de l'utilisation de la méthode CONNECT, le serveur proxy crée un tunnel TCP entre le client et le serveur cible. Le proxy ne voit pas le contenu du trafic — il transmet simplement les octets chiffrés dans les deux sens. C'est la méthode la plus sûre et la plus courante pour travailler avec HTTPS via proxy.

Le processus d'établissement de la connexion se déroule comme suit : le client envoie une demande CONNECT au proxy en spécifiant l'hôte cible et le port. Le proxy établit une connexion TCP avec le serveur cible et renvoie au client une réponse 200 Connection Established. Après cela, le client effectue une négociation TLS directement avec le serveur cible via le tunnel établi.

# Schéma du tunnel CONNECT
Client → Proxy: CONNECT example.com:443 HTTP/1.1
Proxy → Serveur: [Connexion TCP sur le port 443]
Proxy → Client: HTTP/1.1 200 Connection Established
Client ↔ Serveur: [Négociation TLS via tunnel]
Client ↔ Serveur: [Trafic chiffré]

Proxying MITM (interception)

Certains proxies (en particulier les proxies d'entreprise) utilisent la technique Man-in-the-Middle : ils terminent la connexion TLS de leur côté, déchiffrent le trafic, puis établissent une nouvelle connexion TLS avec le serveur cible. Pour ce faire, le proxy génère son propre certificat pour chaque domaine, signé par le certificat racine du proxy.

Cette approche permet d'inspecter et de filtrer le trafic HTTPS, mais nécessite l'installation du certificat racine du proxy dans le magasin de certificats de confiance du client. C'est là que surviennent la plupart des problèmes SSL/TLS lors du travail via des réseaux d'entreprise.

Erreurs typiques et leurs causes

Examinons les erreurs SSL/TLS les plus courantes lors du travail via proxy. Comprendre la cause de chaque erreur est la clé pour résoudre rapidement le problème.

SSL: CERTIFICATE_VERIFY_FAILED

Cette erreur signifie que le client ne peut pas vérifier l'authenticité du certificat du serveur. Il peut y avoir plusieurs raisons : le proxy utilise l'inspection MITM avec un certificat racine non installé, le certificat du serveur cible a expiré ou est auto-signé, ou il manque un certificat intermédiaire dans la chaîne.

# Python - message d'erreur typique
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

L'erreur se produit lorsque le client tente d'établir une connexion TLS mais reçoit une réponse dans un format inattendu. Le plus souvent, cela se produit lorsque le proxy ne supporte pas la méthode CONNECT et tente de traiter la demande HTTPS comme un HTTP ordinaire. La cause peut également être un port ou un protocole incorrect.

TLSV1_ALERT_PROTOCOL_VERSION

Le serveur rejette la connexion en raison d'une version de protocole TLS incompatible. Les serveurs modernes désactivent les anciennes versions de TLS 1.0 et TLS 1.1 pour des raisons de sécurité. Si le proxy ou le client sont configurés pour utiliser des versions anciennes, la connexion sera rejetée.

SSLV3_ALERT_HANDSHAKE_FAILURE

Le client et le serveur n'ont pas pu négocier les paramètres de chiffrement. Cela peut se produire en raison de l'absence de suites de chiffrement communes, de problèmes avec SNI (Server Name Indication) ou d'incompatibilité des bibliothèques cryptographiques.

Erreur	Cause probable	Solution
`CERTIFICATE_VERIFY_FAILED`	Proxy MITM, certificat expiré	Installer le certificat racine du proxy
`WRONG_VERSION_NUMBER`	HTTP au lieu de HTTPS, pas de support CONNECT	Vérifier les paramètres du proxy et le protocole
`PROTOCOL_VERSION`	Version TLS obsolète	Mettre à jour la version TLS minimale
`HANDSHAKE_FAILURE`	Suites de chiffrement incompatibles	Configurer la liste des chiffres

Problèmes de certificats

Les certificats sont la source la plus courante de problèmes lors du travail via proxy. Examinons les scénarios principaux et les façons de les résoudre.

Installation du certificat racine du proxy

Si le proxy utilise l'inspection MITM, il est nécessaire d'ajouter son certificat racine au magasin de certificats de confiance. Le processus dépend du système d'exploitation et du langage de programmation utilisé.

# Linux : ajout du certificat au magasin système
sudo cp proxy-ca.crt /usr/local/share/ca-certificates/
sudo update-ca-certificates

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

# Windows PowerShell (en tant qu'administrateur)
Import-Certificate -FilePath "proxy-ca.crt" `
    -CertStoreLocation Cert:\LocalMachine\Root

Spécification du certificat dans le code

Parfois, il est plus pratique de spécifier le chemin du certificat directement dans le code, en particulier lors du travail dans des conteneurs ou sur des serveurs sans accès root. Cela permet d'éviter la modification des paramètres système.

# Python : spécification d'un CA-bundle personnalisé
import requests

# Méthode 1 : spécifier le chemin du fichier de certificat
response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy:8080'},
    verify='/path/to/proxy-ca.crt'
)

# Méthode 2 : combiner avec les certificats système
import certifi
import ssl

# Créer un fichier de certificats combiné
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')

Désactivation de la vérification des certificats

Dans certains cas (uniquement pour les tests et le débogage !) il peut être nécessaire de désactiver la vérification des certificats. C'est peu sûr et ne doit pas être utilisé en production, car cela rend la connexion vulnérable aux attaques MITM.

⚠️ Attention : La désactivation de la vérification des certificats rend la connexion vulnérable à l'interception. Utilisez uniquement pour le débogage dans un environnement isolé, jamais en production !

# Python - UNIQUEMENT pour le débogage !
import requests
import urllib3
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

response = requests.get(
    'https://example.com',
    proxies={'https': 'http://proxy:8080'},
    verify=False  # Peu sûr !
)

Configuration des tunnels CONNECT

La configuration correcte du tunnel CONNECT est la clé d'un fonctionnement stable de HTTPS via proxy. Examinons les particularités de la configuration pour différents scénarios d'utilisation.

Vérification du support CONNECT

Tous les proxies ne supportent pas la méthode CONNECT. Les proxies HTTP peuvent être configurés uniquement pour le proxying du trafic HTTP. Avant utilisation, assurez-vous que le proxy supporte le tunnelage HTTPS.

# Vérification du support CONNECT via 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

# Réponse attendue en cas de succès :
# HTTP/1.1 200 Connection Established

# Réponses possibles en cas d'erreur :
# HTTP/1.1 403 Forbidden - CONNECT est interdit
# HTTP/1.1 405 Method Not Allowed - méthode non supportée

Authentification dans les demandes CONNECT

Lors de l'utilisation d'un proxy avec authentification, il est important de transmettre correctement les identifiants. L'en-tête Proxy-Authorization doit être présent dans la demande CONNECT.

# Python : authentification via URL
import requests

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

# Python : authentification via en-têtes (pour les cas complexes)
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')

Travail avec les proxies SOCKS5

Les proxies SOCKS5 fonctionnent à un niveau inférieur et ne nécessitent pas de traitement spécial de HTTPS. Ils tunnelisent simplement les connexions TCP, ce qui les rend idéaux pour travailler avec n'importe quel protocole.

# Python avec PySocks
import requests

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

# socks5h - résolution DNS via proxy
# socks5 - résolution DNS locale

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

Solutions pour différents langages de programmation

Chaque langage et bibliothèque ont leurs propres particularités de travail avec SSL/TLS via proxy. Examinons les variantes les plus courantes avec des exemples de code complets.

Python (requests + urllib3)

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

class TLSAdapter(HTTPAdapter):
    """Adaptateur avec paramètres TLS configurables"""
    
    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)

# Création d'un contexte avec des paramètres modernes
ctx = create_urllib3_context()
ctx.minimum_version = ssl.TLSVersion.TLSv1_2
ctx.set_ciphers('ECDHE+AESGCM:DHE+AESGCM:ECDHE+CHACHA20')

# Chargement d'un certificat supplémentaire
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');

// Chargement du certificat CA supplémentaire
const customCA = fs.readFileSync('proxy-ca.crt');

const agent = new HttpsProxyAgent({
    host: 'proxy.example.com',
    port: 8080,
    auth: 'username:password',
    ca: customCA,
    rejectUnauthorized: true  // Ne désactivez pas en production !
});

const client = axios.create({
    httpsAgent: agent,
    proxy: false  // Important : désactiver le proxy intégré d'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('Problème de certificat:', error.message);
        }
        throw error;
    }
}

fetchData();

Go (net/http)

package main

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

func main() {
    // Chargement du certificat supplémentaire
    caCert, err := ioutil.ReadFile("proxy-ca.crt")
    if err != nil {
        log.Fatal(err)
    }
    
    caCertPool := x509.NewCertPool()
    caCertPool.AppendCertsFromPEM(caCert)
    
    // Configuration de TLS
    tlsConfig := &tls.Config{
        RootCAs:    caCertPool,
        MinVersion: tls.VersionTLS12,
    }
    
    // Configuration du 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 (ligne de commande)

# Demande basique via proxy
curl -x http://proxy:8080 https://example.com

# Avec authentification
curl -x http://proxy:8080 -U username:password https://example.com

# Avec spécification du certificat CA
curl -x http://proxy:8080 --cacert proxy-ca.crt https://example.com

# Forcer l'utilisation de TLS 1.2+
curl -x http://proxy:8080 --tlsv1.2 https://example.com

# Débogage de la négociation TLS
curl -x http://proxy:8080 -v --trace-ascii - https://example.com 2>&1 | \
    grep -E "(SSL|TLS|certificate)"

Détection et contournement de l'inspection MITM

Certains réseaux (d'entreprise, Wi-Fi public) utilisent l'inspection MITM transparente du trafic HTTPS. Cela peut causer des problèmes avec le certificate pinning et perturber le fonctionnement des applications qui s'attendent à des certificats spécifiques.

Détection du proxy MITM

import ssl
import socket

def check_certificate_issuer(hostname, port=443):
    """Vérifie qui a émis le certificat du site"""
    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"Subject: {subject.get('commonName')}")
            print(f"Issuer: {issuer.get('commonName')}")
            print(f"Organization: {issuer.get('organizationName')}")
            
            # Proxies MITM d'entreprise connus
            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 détecté : {indicator}")
                    return True
            
            return False

# Vérification
check_certificate_issuer('google.com')

Travail dans les conditions MITM

Si un proxy MITM est détecté, il existe plusieurs stratégies de travail. Vous pouvez installer le certificat racine du proxy (s'il s'agit d'un réseau d'entreprise de confiance), utiliser des ports ou des protocoles alternatifs, ou appliquer un VPN pour contourner l'inspection.

# Obtention du certificat du proxy MITM pour installation
openssl s_client -connect example.com:443 -proxy proxy:8080 \
    -showcerts 2>/dev/null | \
    openssl x509 -outform PEM > mitm-cert.pem

# Affichage des informations sur le certificat
openssl x509 -in mitm-cert.pem -text -noout | head -20

Outils de diagnostic

Un diagnostic correct est la moitié de la solution au problème. Examinons les outils et méthodes pour déboguer les connexions SSL/TLS via proxy.

OpenSSL pour le diagnostic

# Vérification de la connexion via proxy
openssl s_client -connect example.com:443 \
    -proxy proxy.example.com:8080 \
    -servername example.com

# Vérification de la chaîne de certificats
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -showcerts 2>/dev/null | \
    grep -E "(Certificate chain|s:|i:)"

# Test d'une version TLS spécifique
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -tls1_2

# Vérification des suites de chiffrement supportées
openssl s_client -connect example.com:443 \
    -proxy proxy:8080 \
    -cipher 'ECDHE-RSA-AES256-GCM-SHA384'

Script Python pour le diagnostic

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

def diagnose_ssl_proxy(target_url, proxy_url):
    """Diagnostic complet de SSL via proxy"""
    
    print(f"🔍 Diagnostic : {target_url}")
    print(f"📡 Proxy : {proxy_url}\n")
    
    # 1. Vérification de la disponibilité du 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 indisponible : {e}")
        return
    
    # 2. Vérification de la méthode CONNECT
    try:
        response = requests.get(
            target_url,
            proxies={'https': proxy_url},
            timeout=15
        )
        print(f"✅ Connexion HTTPS réussie : {response.status_code}")
    except requests.exceptions.SSLError as e:
        print(f"❌ Erreur SSL : {e}")
        
        # Tentative sans vérification pour le diagnostic
        try:
            response = requests.get(
                target_url,
                proxies={'https': proxy_url},
                verify=False,
                timeout=15
            )
            print("⚠️ La connexion fonctionne sans vérification de certificat")
            print("   Problème probable avec le certificat CA du proxy")
        except Exception as e2:
            print(f"❌ Ne fonctionne pas même sans vérification : {e2}")
    
    except Exception as e:
        print(f"❌ Erreur de connexion : {e}")
    
    # 3. Informations sur SSL
    print(f"\n📋 Version OpenSSL : {ssl.OPENSSL_VERSION}")
    print(f"📋 Chemins de vérification par défaut : {ssl.get_default_verify_paths()}")

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

Wireshark pour l'analyse approfondie

Pour les cas complexes, utilisez Wireshark avec un filtre sur le trafic TLS. Cela vous permet de voir les détails de la négociation et de déterminer exactement le moment de l'échec.

# Filtres Wireshark pour l'analyse TLS
tls.handshake.type == 1          # Client Hello
tls.handshake.type == 2          # Server Hello
tls.handshake.type == 11         # Certificate
tls.alert_message                 # Alertes TLS (erreurs)

# Capture du trafic via tcpdump
tcpdump -i eth0 -w ssl_debug.pcap \
    'port 443 or port 8080' -c 1000

Meilleures pratiques de travail sécurisé

Le respect des meilleures pratiques aidera à éviter la plupart des problèmes SSL/TLS et assurera la sécurité de vos données lors du travail via proxy.

Configuration de TLS

Utilisez au minimum TLS 1.2, de préférence TLS 1.3
Configurez les suites de chiffrement modernes (ECDHE, AES-GCM, ChaCha20)
Activez la vérification des certificats (ne la désactivez jamais en production)
Mettez à jour régulièrement le CA-bundle et les bibliothèques cryptographiques

Travail avec les proxies

Préférez les proxies avec support complet de CONNECT pour le trafic HTTPS
Utilisez SOCKS5 pour le tunnelage universel
Lors du travail avec des proxies résidentiels, tenez compte des particularités possibles des réseaux des fournisseurs
Stockez les identifiants du proxy dans les variables d'environnement, pas dans le code

Gestion des erreurs

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

def robust_request(url, proxy, max_retries=3):
    """Demande résistante aux erreurs via 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"Erreur SSL (tentative {attempt + 1}) : {e}")
            # Les erreurs SSL ne sont généralement pas corrigées par une nouvelle tentative
            if 'CERTIFICATE_VERIFY_FAILED' in str(e):
                raise  # Nécessite une correction de la configuration
                
        except ProxyError as e:
            print(f"Erreur proxy (tentative {attempt + 1}) : {e}")
            time.sleep(2 ** attempt)  # Délai exponentiel
            
        except ConnectionError as e:
            print(f"Erreur de connexion (tentative {attempt + 1}) : {e}")
            time.sleep(2 ** attempt)
    
    raise Exception(f"Impossible d'exécuter la demande après {max_retries} tentatives")

Liste de contrôle pour la résolution des problèmes

En cas d'erreur SSL/TLS, suivez cet ordre de diagnostic :

Vérifiez la disponibilité du serveur proxy (ping, telnet)
Assurez-vous du support de la méthode CONNECT
Vérifiez l'exactitude des identifiants d'authentification
Étudiez le certificat via openssl s_client
Vérifiez la présence d'inspection MITM
Installez les certificats CA nécessaires
Mettez à jour la version TLS et les suites de chiffrement

💡 Conseil : La plupart des problèmes SSL/TLS lors du travail via proxy sont liés aux certificats. Commencez le diagnostic par la vérification de la chaîne de certificats et assurez-vous que tous les certificats intermédiaires sont présents.

Conclusion

Les problèmes SSL/TLS lors du travail via proxy sont résolubles avec une approche systématique du diagnostic. Les points clés sont : comprendre la différence entre le tunnelage CONNECT et le proxying MITM, configurer correctement les certificats et utiliser les versions modernes du protocole TLS. La plupart des erreurs sont liées à l'absence de certificats CA nécessaires ou à l'incompatibilité des paramètres cryptographiques.

Pour les tâches d'analyse et d'automatisation nécessitant un fonctionnement stable de HTTPS, il est recommandé d'utiliser des proxies de qualité avec un support complet de la méthode CONNECT — plus de détails sur les options sur proxycove.com.

```

Guide Complet : Résoudre les Problèmes SSL/TLS avec un Proxy