HTTP/3 y UDP sobre SOCKS5

Los proxies residenciales transmiten tráfico UDP a través de SOCKS5. Úsalos para abrir páginas web mediante HTTP/3 (QUIC) desde una IP residencial y para enrutar cualquier otro protocolo UDP: DNS, WebRTC, VoIP y juegos en línea.

Cómo funciona

HTTP/3 se ejecuta sobre QUIC, y QUIC se ejecuta sobre UDP. El protocolo de proxy HTTP solo admite TCP, por lo que el tráfico UDP pasa por SOCKS5.

Se producen tres intercambios antes de que el primer datagrama salga de tu equipo:

1. Conectarse e autenticarse

   Tu aplicación abre una conexión SOCKS5 con la pasarela y inicia sesión con el nombre de usuario y la contraseña de tu lista.

2. Solicitar un relé UDP

   Envía un UDP ASSOCIATE solicitud (RFC 1928). La pasarela responde con una dirección de retransmisión: la IP de la pasarela y un puerto comprendido entre 30000 y 39999.

3. Enviar datagramas

   La aplicación envía datagramas UDP a ese relé. Cada datagrama comienza con una breve cabecera SOCKS5 que indica el destino. El tráfico sale desde la IP de salida residencial y las respuestas vuelven por el mismo camino.

Configuración de la conexión

HTTP y SOCKS5 comparten el mismo servidor, puertos, nombre de usuario y contraseña; la pasarela detecta el protocolo por sí misma. Para cambiar una cadena de conexión a SOCKS5, modifica solo el esquema y nada más:

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

La puerta de enlace es solo el punto de entrada. La IP de salida y su ubicación provienen de la configuración de la lista, independientemente de la puerta de enlace que utilices; por lo tanto, elige la puerta de enlace con menor latencia desde tu servidor.

Compruébalo tú mismo

1. Comprueba la conexión

   Cualquier cliente SOCKS5 servirá — curl Es suficiente:

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

   La respuesta es la IP de salida del proxy. Con socks5h://, los nombres de dominio son resueltos por el proxy, no por tu ordenador.

2. Comprueba UDP

   Este script utiliza únicamente la biblioteca estándar de Python. Se conecta a través de SOCKS5, abre un relé UDP y envía una consulta DNS a través de él. El resolutor de OpenDNS responde myip.opendns.com con la dirección de la que proviene la consulta, de modo que el script muestre la IP de salida de tu tráfico UDP.

   Guárdalo como socks5_udp.py, configura tu nombre de usuario y contraseña, y ejecuta 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()

   Ejemplo de resultado:

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

3. Enviar una solicitud HTTP/3

   En el caso de HTTP/3, los paquetes QUIC de la solicitud pasan por el mismo relé UDP. Este ejemplo utiliza el aioquic biblioteca (Python 3.11 o posterior). Carga https://cloudflare-quic.com/cdn-cgi/trace, una página de texto sin formato que muestra el protocolo y la IP del cliente.

   Instala las dependencias y guarda el script como http3_via_socks5.py junto a socks5_udp.py, y ejecútalo:

   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()

   Resultado (resumido):

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

   http=http/3 significa que el sitio web recibió la solicitud a través de HTTP/3. ip y loc son la IP de salida del proxy y su país.

HTTP/3 en navegadores y otras aplicaciones

Una aplicación solo puede enviar UDP a través de un proxy si es compatible con UDP sobre SOCKS5 (UDP ASSOCIATE).

Para utilizar HTTP/3 en un navegador u otra aplicación, redirige su tráfico a través de una herramienta que reenvía UDP por SOCKS5. La aplicación nunca ve el proxy, por lo que utiliza HTTP/3 como de costumbre, y la herramienta envía los paquetes QUIC a través de la pasarela.

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

Limitaciones

• UDP solo funciona a través de SOCKS5. Las conexiones de proxy HTTP utilizan TCP.

• No se admite la conexión al propio proxy a través de HTTPS (TLS) o HTTP/3; utiliza http:// o socks5://.

• Una sesión UDP puede obtener una dirección IP de salida diferente a la de las conexiones TCP en el mismo puerto.

Preguntas frecuentes