HTTP/3 e UDP sobre SOCKS5

Proxies residenciais transportam tráfego UDP por meio do protocolo SOCKS5. Use-os para acessar sites via HTTP/3 (QUIC) a partir de um IP residencial e para rotear qualquer outro protocolo UDP: DNS, WebRTC, VoIP e jogos online.

Como funciona

O HTTP/3 é executado sobre o QUIC, e o QUIC é executado sobre o UDP. O protocolo de proxy HTTP suporta apenas TCP, portanto, o tráfego UDP passa pelo SOCKS5.

Três trocas ocorrem antes que o primeiro datagrama saia da sua máquina:

1. Conectar-se e autenticar-se

   Seu aplicativo abre uma conexão SOCKS5 com o gateway e faz o login com o nome de usuário e a senha da sua lista.

2. Solicitar um retransmissor UDP

   Isso envia um UDP ASSOCIATE solicitação (RFC 1928). O gateway responde com um endereço de retransmissão: o IP do gateway e uma porta no intervalo de 30000 a 39999.

3. Enviar datagramas

   O aplicativo envia datagramas UDP para esse relé. Cada datagrama começa com um pequeno cabeçalho SOCKS5 indicando o destino. O tráfego sai do IP de saída residencial, e as respostas retornam pelo mesmo caminho.

Configurações de conexão

HTTP e SOCKS5 compartilham o mesmo host, portas, login e senha — o gateway detecta o protocolo automaticamente. Para migrar uma string de conexão para SOCKS5, altere apenas o esquema e nada mais:

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

O gateway é apenas o ponto de entrada. O IP de saída e sua localização vêm das configurações da lista, independentemente do gateway que você usar — portanto, escolha o gateway com a menor latência a partir do seu servidor.

Verifique você mesmo

1. Verifique a conexão

   Qualquer cliente SOCKS5 serve — curl É o suficiente:

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

   A resposta é o IP de saída do proxy. Com socks5h://, os nomes de domínio são resolvidos pelo proxy, não pelo seu computador.

2. Verifique o UDP

   Este script utiliza apenas a biblioteca padrão do Python. Ele faz login via SOCKS5, abre um relé UDP e envia uma consulta DNS por meio dele. O resolvedor OpenDNS responde myip.opendns.com com o endereço de onde a consulta veio, de modo que o script exiba o IP de saída do seu tráfego UDP.

   Salve como socks5_udp.py, defina seu nome de usuário e senha e execute 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()

   Exemplo de resultado:

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

3. Envie uma solicitação HTTP/3

   Para o HTTP/3, os pacotes QUIC da solicitação passam pelo mesmo retransmissor UDP. Este exemplo utiliza o aioquic biblioteca (Python 3.11 ou mais recente). Ela carrega https://cloudflare-quic.com/cdn-cgi/trace, uma página em texto simples que mostra o protocolo e o IP do cliente.

   Instale as dependências, salve o script como http3_via_socks5.py ao lado de socks5_udp.py, e execute-o:

   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 o site recebeu a solicitação via HTTP/3. ip e loc são o IP de saída do proxy e seu país.

HTTP/3 em navegadores e outros aplicativos

Um aplicativo só pode enviar UDP por meio de um proxy se for compatível com UDP sobre SOCKS5 (UDP ASSOCIATE).

Para usar o HTTP/3 em um navegador ou outro aplicativo, encaminhe o tráfego por meio de uma ferramenta que encaminhe UDP por SOCKS5. O aplicativo nunca percebe o proxy, portanto usa o HTTP/3 normalmente, e a ferramenta envia os pacotes QUIC pelo gateway.

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

Limitações

• O UDP funciona apenas sobre SOCKS5. As conexões de proxy HTTP utilizam o protocolo TCP.

• A conexão direta com o próprio proxy via HTTPS (TLS) ou HTTP/3 não é suportada — use http:// ou socks5://.

• Uma sessão UDP pode receber um endereço IP de saída diferente do das conexões TCP na mesma porta.

Perguntas frequentes