HTTP/3 & UDP über SOCKS5

Residential-Proxys übertragen UDP-Datenverkehr über SOCKS5. Nutzen Sie sie, um Websites über HTTP/3 (QUIC) von einer privaten IP-Adresse aus zu öffnen und andere UDP-Protokolle weiterzuleiten: DNS, WebRTC, VoIP, Online-Spiele.

So funktioniert es

HTTP/3 läuft über QUIC, und QUIC läuft über UDP. Das HTTP-Proxy-Protokoll unterstützt nur TCP, daher wird der UDP-Verkehr über SOCKS5 geleitet.

Bevor das erste Datagramm Ihren Rechner verlässt, finden drei Datenaustausche statt:

1. Verbinden und authentifizieren

   Ihre App öffnet eine SOCKS5-Verbindung zum Gateway und meldet sich mit dem Benutzernamen und dem Passwort aus Ihrer Liste an.

2. UDP-Relay anfordern

   Es sendet eine UDP ASSOCIATE Anfrage (RFC 1928). Das Gateway antwortet mit einer Relay-Adresse: der IP-Adresse des Gateways und einem Port im Bereich von 30000 bis 39999.

3. Datagramme senden

   Die App sendet UDP-Datagramme an diesen Relay-Server. Jedes Datagramm beginnt mit einem kurzen SOCKS5-Header, der das Ziel angibt. Der Datenverkehr wird von der privaten Ausgangs-IP gesendet, und die Antworten kommen auf demselben Weg zurück.

Verbindungseinstellungen

HTTP und SOCKS5 nutzen denselben Host, dieselben Ports sowie denselben Benutzernamen und dasselbe Passwort – das Gateway erkennt das Protokoll automatisch. Um eine Verbindungszeichenfolge auf SOCKS5 umzustellen, ändern Sie lediglich das Schema und sonst nichts:

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

Das Gateway ist lediglich der Einstiegspunkt. Die Ausgangs-IP und deren Standort stammen aus den Listeneinstellungen, unabhängig davon, welches Gateway Sie verwenden – wählen Sie daher das Gateway mit der geringsten Latenz zu Ihrem Server aus.

Überprüfen Sie dies selbst

1. Überprüfen Sie die Verbindung

   Jeder SOCKS5-Client ist geeignet — curl Das reicht aus:

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

   Die Antwort ist die Ausgangs-IP des Proxys. Mit socks5h://, Domainnamen werden vom Proxy aufgelöst, nicht von Ihrem Rechner.

2. UDP prüfen

   Dieses Skript verwendet ausschließlich die Python-Standardbibliothek. Es meldet sich über SOCKS5 an, öffnet einen UDP-Relay und sendet eine DNS-Abfrage darüber. Der OpenDNS-Resolver antwortet myip.opendns.com mit der Adresse, von der die Anfrage stammt, sodass das Skript die Ausgangs-IP Ihres UDP-Datenverkehrs ausgibt.

   Speichern Sie die Datei unter socks5_udp.py, lege deinen Benutzernamen und dein Passwort fest und starte 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()

   Beispielausgabe:

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

3. Sende eine HTTP/3-Anfrage

   Bei HTTP/3 durchlaufen die QUIC-Pakete der Anfrage dasselbe UDP-Relay. In diesem Beispiel wird das aioquic Bibliothek (Python 3.11 oder neuer). Sie lädt https://cloudflare-quic.com/cdn-cgi/trace, eine Seite im Klartext, die das Protokoll und die Client-IP anzeigt.

   Installieren Sie die Abhängigkeiten und speichern Sie das Skript als http3_via_socks5.py neben socks5_udp.py, und führen Sie es aus:

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

   Ergebnis (gekürzt):

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

   http=http/3 bedeutet, dass die Website die Anfrage über HTTP/3 erhalten hat. ip und loc sind die Ausgangs-IP des Proxys und dessen Land.

HTTP/3 in Browsern und anderen Apps

Eine App kann UDP nur dann über einen Proxy senden, wenn sie UDP über SOCKS5 unterstützt (UDP ASSOCIATE).

Um HTTP/3 in einem Browser oder einer anderen App zu nutzen, leiten Sie den Datenverkehr über ein Tool weiter, das UDP über SOCKS5 weiterleitet. Die App nimmt den Proxy nicht wahr, nutzt also HTTP/3 wie gewohnt, und das Tool sendet die QUIC-Pakete über das Gateway.

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

Einschränkungen

• UDP funktioniert ausschließlich über SOCKS5. HTTP-Proxy-Verbindungen nutzen TCP.

• Eine Verbindung zum Proxy selbst über HTTPS (TLS) oder HTTP/3 wird nicht unterstützt – verwenden Sie http:// oder socks5://.

• Eine UDP-Sitzung kann eine andere Ausgangs-IP erhalten als TCP-Verbindungen auf demselben Port.

FAQ