mkdir -p ~/http3-test && cd ~/http3-test
cat > main.go <<'EOF'
package main
import (
"bytes"
"context"
"crypto/tls"
"flag"
"fmt"
"io"
"log/slog"
"net"
"net/http"
"time"
"github.com/quic-go/quic-go"
"github.com/quic-go/quic-go/http3"
"github.com/txthinking/socks5"
)
var (
proxyUsername = flag.String("u", "", "proxy username")
proxyPassword = flag.String("p", "", "proxy password")
proxyHost = flag.String("h", "socks5-gate.decodo.com:10000", "proxy host with port")
remoteHost = flag.String("t", "udp-test.decodo.com", "target host")
payload = flag.String("body", "", "optional request body")
)
type SOCKS5PacketConn struct {
net.Conn
targetAddr net.Addr
}
func (s *SOCKS5PacketConn) ReadFrom(p []byte) (int, net.Addr, error) {
n, err := s.Conn.Read(p)
return n, s.targetAddr, err
}
func (s *SOCKS5PacketConn) WriteTo(p []byte, addr net.Addr) (int, error) {
return s.Conn.Write(p)
}
func (s *SOCKS5PacketConn) LocalAddr() net.Addr { return s.Conn.LocalAddr() }
func (s *SOCKS5PacketConn) SetDeadline(t time.Time) error { return s.Conn.SetDeadline(t) }
func (s *SOCKS5PacketConn) SetReadBuffer(bytes int) error {
if udpConn, ok := s.Conn.(interface{ SetReadBuffer(int) error }); ok {
return udpConn.SetReadBuffer(bytes)
}
return nil
}
func (s *SOCKS5PacketConn) SetWriteBuffer(bytes int) error {
if udpConn, ok := s.Conn.(interface{ SetReadBuffer(int) error }); ok {
return udpConn.SetReadBuffer(bytes)
}
return nil
}
func HTTP3viaProxy(proxyUsername, proxyPassword, proxyHost, target, payload string) error {
socks5Client, err := socks5.NewClient(proxyHost, proxyUsername, proxyPassword, 5, 5)
if err != nil {
return err
}
closeChan := make(chan struct{})
defer func() { closeChan <- struct{}{} }()
client := http.Client{
Transport: &http3.Transport{
Dial: proxyDialer(closeChan, socks5Client),
TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
},
}
req, err := http.NewRequest(http.MethodGet, "https://"+target, bytes.NewReader([]byte(payload)))
if err != nil {
return err
}
resp, err := client.Do(req)
if err != nil {
return err
}
defer resp.Body.Close()
res, err := io.ReadAll(resp.Body)
if err != nil {
return err
}
fmt.Println("Status: ", resp.StatusCode)
fmt.Println("Protocol: ", resp.Proto)
fmt.Printf("Response: \n%s", string(res))
return nil
}
func proxyDialer(closeChan <-chan struct{}, socks5client *socks5.Client) func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error) {
return func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error) {
proxyConn, err := socks5client.Dial("udp", addr)
if err != nil {
return nil, err
}
go func() {
<-closeChan
if proxyConn != nil {
if err := proxyConn.Close(); err != nil {
slog.Error("Failed to close proxy connection", "error", err)
}
}
}()
remoteAddr, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, err
}
socks5PacketConn := &SOCKS5PacketConn{Conn: proxyConn, targetAddr: remoteAddr}
deadline := time.Now().Add(40 * time.Second)
if err = proxyConn.SetReadDeadline(deadline); err != nil {
return nil, err
}
if err = proxyConn.SetWriteDeadline(deadline); err != nil {
return nil, err
}
earlyConn, err := quic.DialEarly(ctx, socks5PacketConn, remoteAddr, tlsCfg, cfg)
if err != nil {
return nil, err
}
return earlyConn, nil
}
}
func main() {
flag.Parse()
start := time.Now()
if err := HTTP3viaProxy(*proxyUsername, *proxyPassword, *proxyHost, *remoteHost, *payload); err != nil {
slog.Error("failed to perform HTTP3 request via proxy", "error", err)
}
fmt.Printf("Request took: %d ms\n", time.Since(start).Milliseconds())
}
EOF
go mod init http3-test
go get github.com/quic-go/quic-go github.com/quic-go/quic-go/http3 github.com/txthinking/socks5
go run main.go
