HTTP/3 et UDP via SOCKS5

Les proxys résidentiels acheminent le trafic UDP via SOCKS5. Utilisez-les pour accéder à des sites web via HTTP/3 (QUIC) à partir d'une adresse IP résidentielle, et pour acheminer tout autre protocole UDP : DNS, WebRTC, VoIP, jeux en ligne.

Comment ça marche

HTTP/3 fonctionne sur QUIC, et QUIC fonctionne sur UDP. Le protocole proxy HTTP ne prend en charge que le TCP ; le trafic UDP passe donc par SOCKS5.

Trois échanges ont lieu avant que le premier datagramme ne quitte votre machine :

1. Se connecter et s'authentifier

   Votre application établit une connexion SOCKS5 vers la passerelle et se connecte à l'aide de l'identifiant et du mot de passe figurant dans votre liste.

2. Demander un relais UDP

   Cela envoie un UDP ASSOCIATE requête (RFC 1928). La passerelle répond en indiquant une adresse de relais : l'adresse IP de la passerelle et un port compris entre 30 000 et 39 999.

3. Envoyer des datagrammes

   L'application envoie des datagrammes UDP à ce relais. Chaque datagramme commence par un court en-tête SOCKS5 indiquant la destination. Le trafic part de l'adresse IP de sortie résidentielle, et les réponses reviennent par le même chemin.

Paramètres de connexion

HTTP et SOCKS5 partagent le même hôte, les mêmes ports, le même identifiant et le même mot de passe — la passerelle détecte automatiquement le protocole. Pour faire passer une chaîne de connexion en SOCKS5, modifiez uniquement le schéma :

http://LOGIN:[email protected]:10000
socks5://LOGIN:[email protected]:10000

La passerelle n’est qu’un point d’entrée. L’adresse IP de sortie et son emplacement proviennent des paramètres de la liste, quelle que soit la passerelle que vous utilisez — choisissez donc la passerelle présentant la latence la plus faible depuis votre serveur.

Vérifiez par vous-même

1. Vérifiez la connexion

   N'importe quel client SOCKS5 fera l'affaire — curl Cela suffit :

   curl -x socks5h://LOGIN:[email protected]:10000 https://api.ipify.org

   La réponse correspond à l'adresse IP de sortie du proxy. Avec socks5h://, les noms de domaine sont résolus par le proxy, et non par votre ordinateur.

2. Vérifier UDP

   Ce script utilise uniquement la bibliothèque standard de Python. Il se connecte via SOCKS5, ouvre un relais UDP et y envoie une requête DNS. Le résolveur OpenDNS répond myip.opendns.com avec l'adresse d'où provient la requête, de sorte que le script affiche l'adresse IP de sortie de votre trafic UDP.

   Enregistrez-le sous le nom socks5_udp.py, définissez votre identifiant et votre mot de passe, puis lancez python socks5_udp.py.

   """UDP through a residential proxy: SOCKS5 login, UDP ASSOCIATE and one DNS query.
   
   The OpenDNS resolver answers "myip.opendns.com" with the IP the query came from,
   so the script prints the exit IP your UDP traffic leaves from.
   """
   import os
   import socket
   import struct
   
   PROXY_HOST = "res.proxy-seller.com"
   PROXY_PORT = 10000
   LOGIN = "LOGIN"
   PASSWORD = "PASSWORD"
   
   
   def recv_exact(sock, n):
       data = b""
       while len(data) < n:
           chunk = sock.recv(n - len(data))
           if not chunk:
               raise ConnectionError("proxy closed the connection")
           data += chunk
       return data
   
   
   def udp_associate(host, port, login, password):
       """SOCKS5 login (RFC 1929) and UDP ASSOCIATE (RFC 1928).
   
       Returns the TCP control connection and the UDP relay address.
       The relay works while the TCP connection stays open.
       """
       tcp = socket.create_connection((host, port), timeout=15)
       tcp.sendall(b"\x05\x01\x02")  # SOCKS5, one auth method: username/password
       if recv_exact(tcp, 2)[1] != 0x02:
           raise RuntimeError("username/password authentication is not available")
       tcp.sendall(b"\x01" + bytes([len(login)]) + login.encode()
                   + bytes([len(password)]) + password.encode())
       if recv_exact(tcp, 2)[1] != 0x00:
           raise RuntimeError("wrong login or password")
       tcp.sendall(b"\x05\x03\x00\x01" + bytes(6))  # UDP ASSOCIATE, client address 0.0.0.0:0
       _, reply, _, atyp = recv_exact(tcp, 4)
       if reply != 0x00:
           raise RuntimeError(f"UDP ASSOCIATE failed, reply code {reply}")
       if atyp == 0x01:
           relay_ip = socket.inet_ntoa(recv_exact(tcp, 4))
       elif atyp == 0x03:
           relay_ip = recv_exact(tcp, recv_exact(tcp, 1)[0]).decode()
       else:
           raise RuntimeError("IPv6 relay address is not handled in this example")
       relay_port = struct.unpack("!H", recv_exact(tcp, 2))[0]
       if relay_ip == "0.0.0.0":
           relay_ip = tcp.getpeername()[0]
       return tcp, (relay_ip, relay_port)
   
   
   def strip_udp_header(datagram):
       """Remove the SOCKS5 UDP header from a datagram received from the relay."""
       atyp = datagram[3]
       if atyp == 0x01:  # IPv4
           return datagram[10:]
       if atyp == 0x04:  # IPv6
           return datagram[22:]
       return datagram[7 + datagram[4]:]  # domain name
   
   
   if __name__ == "__main__":
       tcp, relay = udp_associate(PROXY_HOST, PROXY_PORT, LOGIN, PASSWORD)
       print("UDP relay:", f"{relay[0]}:{relay[1]}")
   
       # DNS query "myip.opendns.com, type A" without EDNS: the answer ends with the IPv4 address
       query = (os.urandom(2) + b"\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00"
                + b"\x04myip\x07opendns\x03com\x00" + b"\x00\x01\x00\x01")
       # every datagram to the relay starts with a SOCKS5 UDP header: RSV, FRAG, ATYP=IPv4, destination
       header = b"\x00\x00\x00\x01" + socket.inet_aton("208.67.222.222") + struct.pack("!H", 53)
   
       udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
       udp.settimeout(10)
       udp.sendto(header + query, relay)
       answer = strip_udp_header(udp.recv(4096))
       print("Exit IP over UDP:", socket.inet_ntoa(answer[-4:]))
       udp.close()
       tcp.close()

   Exemple de résultat :

   UDP relay: 103.152.136.28:39631
   Exit IP over UDP: 203.0.113.45

3. Envoyer une requête HTTP/3

   Pour HTTP/3, les paquets QUIC de la requête transitent par le même relais UDP. Cet exemple utilise le aioquic bibliothèque (Python 3.11 ou version plus récente). Elle charge https://cloudflare-quic.com/cdn-cgi/trace, une page en texte brut qui affiche le protocole et l'adresse IP du client.

   Installez les dépendances, enregistrez le script sous le nom http3_via_socks5.py à côté de socks5_udp.py, puis exécutez-le :

   pip install aioquic certifi
   python http3_via_socks5.py

   """HTTP/3 (QUIC) request to a website through a residential proxy.
   
   QUIC packets go to the SOCKS5 UDP relay; the website sees an HTTP/3 connection from the exit IP.
   Requires: pip install aioquic certifi, and socks5_udp.py from the previous example in the same folder.
   """
   import socket
   import struct
   import time
   
   import certifi
   from aioquic.h3.connection import H3_ALPN, H3Connection
   from aioquic.h3.events import DataReceived, HeadersReceived
   from aioquic.quic.configuration import QuicConfiguration
   from aioquic.quic.connection import QuicConnection
   from aioquic.quic.events import ConnectionTerminated, HandshakeCompleted
   
   from socks5_udp import LOGIN, PASSWORD, PROXY_HOST, PROXY_PORT, strip_udp_header, udp_associate
   
   TARGET_HOST = "cloudflare-quic.com"
   TARGET_PATH = "/cdn-cgi/trace"  # plain text: shows the protocol (http=http/3) and the client IP
   
   tcp, relay = udp_associate(PROXY_HOST, PROXY_PORT, LOGIN, PASSWORD)
   udp = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
   # the destination goes into the SOCKS5 UDP header as a domain name (ATYP=3): the proxy resolves it
   header = b"\x00\x00\x00\x03" + bytes([len(TARGET_HOST)]) + TARGET_HOST.encode() + struct.pack("!H", 443)
   
   config = QuicConfiguration(is_client=True, alpn_protocols=H3_ALPN, server_name=TARGET_HOST)
   config.load_verify_locations(certifi.where())
   quic = QuicConnection(configuration=config)
   peer = ("0.0.0.0", 443)  # placeholder: only the proxy knows the real address
   quic.connect(peer, now=time.time())
   h3 = H3Connection(quic)
   
   
   def send_pending():
       for datagram, _ in quic.datagrams_to_send(now=time.time()):
           udp.sendto(header + datagram, relay)
   
   
   send_pending()
   stream_id, body, done = None, b"", False
   deadline = time.time() + 20
   while not done and time.time() < deadline:
       timer = quic.get_timer()
       udp.settimeout(0.5 if timer is None else min(0.5, max(0.01, timer - time.time())))
       try:
           quic.receive_datagram(strip_udp_header(udp.recv(65535)), peer, now=time.time())
       except socket.timeout:
           if timer is not None and time.time() >= timer:
               quic.handle_timer(now=time.time())
       event = quic.next_event()
       while event is not None:
           if isinstance(event, HandshakeCompleted):
               stream_id = quic.get_next_available_stream_id()
               h3.send_headers(stream_id, [
                   (b":method", b"GET"), (b":scheme", b"https"),
                   (b":authority", TARGET_HOST.encode()), (b":path", TARGET_PATH.encode()),
               ], end_stream=True)
           elif isinstance(event, ConnectionTerminated):
               done = True
           for h3_event in h3.handle_event(event):
               if isinstance(h3_event, (HeadersReceived, DataReceived)) and h3_event.stream_id == stream_id:
                   if isinstance(h3_event, DataReceived):
                       body += h3_event.data
                   done = done or h3_event.stream_ended
           event = quic.next_event()
       send_pending()
   
   print(body.decode() or "No HTTP/3 response within 20 seconds")
   quic.close()
   send_pending()
   udp.close()
   tcp.close()

   Résultat (version abrégée) :

   ip=203.0.113.45
   http=http/3
   loc=GB
   tls=TLSv1.3

   http=http/3 signifie que le site web a reçu la requête via HTTP/3. ip et loc sont l'adresse IP de sortie du proxy et son pays.

HTTP/3 dans les navigateurs et autres applications

Une application ne peut envoyer de paquets UDP via un proxy que si elle prend en charge le protocole UDP sur SOCKS5 (UDP ASSOCIATE).

Pour utiliser HTTP/3 dans un navigateur ou une autre application, acheminez son trafic via un outil qui transfère le protocole UDP via SOCKS5. L'application ne voit jamais le proxy ; elle utilise donc HTTP/3 comme d'habitude, tandis que l'outil envoie les paquets QUIC via la passerelle.

{
  "type": "socks",
  "tag": "residential",
  "server": "res.proxy-seller.com",
  "server_port": 10000,
  "version": "5",
  "username": "LOGIN",
  "password": "PASSWORD"
}

Contraintes

• Le protocole UDP fonctionne uniquement via SOCKS5. Les connexions proxy HTTP utilisent le protocole TCP.

• La connexion au proxy lui-même via HTTPS (TLS) ou HTTP/3 n'est pas prise en charge — utilisez http:// ou socks5://.

• Une session UDP peut obtenir une adresse IP de sortie différente de celle des connexions TCP sur le même port.

FAQ