dialers: use protect.RDialer over *protect.RDial

Author: ignoramous

intra/dialers/retrier.go

@@ -48,7 +48,7 @@ const maxRetryCount = 3
 // be typecastable to *net.TCPConn (see: xdial.DialTCP)
 // inheritance: go.dev/play/p/mMiQgXsPM7Y
 type retrier struct {
-	dialer     *protect.RDial
+	dialers    []protect.RDialer
 	dialerOpts settings.DialerOpts
 	raddr      *net.TCPAddr
 	laddr      *net.TCPAddr // laddr may be nil; TCPAddr.IP may be nil.
@@ -79,8 +79,9 @@ type retrier struct {
 	// and is cleared when the first byte is received.
 	tee []byte
 	// retryErr is set to the error from the last retry, if any.
-	retryErr   error
-	retryCount uint8
+	retryErr    error
+	retryCount  uint8
+	dialerCount int
 	// Flag indicating when retry is finished or unnecessary.
 	retryDoneCh chan struct{} // always unbuffered
 }
@@ -129,7 +130,7 @@ func calcTimeout(rtt time.Duration) time.Duration {
 // `addr` is the destination.
 func DialWithSplitRetry(d *protect.RDial, laddr, raddr *net.TCPAddr) (*retrier, error) {
 	r := &retrier{
-		dialer:      d,
+		dialers:     []protect.RDialer{d},
 		dialerOpts:  settings.GetDialerOpts(),
 		laddr:       laddr, // may be nil
 		raddr:       raddr, // must not be nil
@@ -236,6 +237,7 @@ func (r *retrier) dialLocked() (c core.DuplexConn, err error) {
 	begin := time.Now()
 	c, err = r.doDialLocked(strat)
 	rtt := time.Since(begin)
+	r.dialerCount++
 
 	r.conn = c // c may be nil
 	r.timeout = calcTimeout(rtt)
@@ -251,17 +253,19 @@ func (r *retrier) dialLocked() (c core.DuplexConn, err error) {
 func (r *retrier) doDialLocked(dialStrat int32) (_ core.DuplexConn, err error) {
 	var conn *net.TCPConn
 
+	di := r.dialerCount % len(r.dialers)
+
 	// r.raddr may be nil or laddr.IP may be nil.
 	switch dialStrat {
 	case settings.SplitNever:
-		return r.dialer.DialTCP(r.raddr.Network(), r.laddr, r.raddr)
+		return protect.DialTCP(r.dialers[di], r.raddr.Network(), r.laddr, r.raddr)
 	case settings.SplitDesync:
-		return dialWithSplitAndDesync(r.dialer, r.laddr, r.raddr)
+		return dialWithSplitAndDesync(r.dialers[di], r.laddr, r.raddr)
 	case settings.SplitTCP, settings.SplitTCPOrTLS:
 		fallthrough
 	default:
 	}
-	conn, err = r.dialer.DialTCP(r.raddr.Network(), r.laddr, r.raddr)
+	conn, err = protect.DialTCP(r.dialers[di], r.raddr.Network(), r.laddr, r.raddr)
 	if err != nil || conn == nil {
 		return nil, err
 	}

intra/dialers/split_and_desync.go

@@ -104,7 +104,7 @@ func exceedsTTL(cmsgs []unix.SocketControlMessage) bool {
 
 // tracert dials a UDP conn to the target address over a port range basePort to basePort+DESYNC_MAX_TTL, with TTL
 // set to 2, 3, ..., DESYNC_MAX_TTL. It does not take ownership of the conn (which must be closed by the caller).
-func tracert(d *protect.RDial, ipp netip.AddrPort, basePort int) (*net.UDPConn, int, error) {
+func tracert(d protect.RDialer, ipp netip.AddrPort, basePort int) (*net.UDPConn, int, error) {
 	udpAddr := net.UDPAddrFromAddrPort(ipp)
 	udpAddr.Port = 1 // unset port
 
@@ -119,7 +119,7 @@ func tracert(d *protect.RDial, ipp netip.AddrPort, basePort int) (*net.UDPConn,
 	}
 
 	var udpFD int
-	uc, err := d.AnnounceUDP(proto, ":0")
+	uc, err := protect.AnnounceUDP(d, proto, ":0")
 	if err != nil {
 		log.E("desync: err announcing udp: %v", err)
 		return uc, udpFD, err
@@ -179,7 +179,7 @@ func tracert(d *protect.RDial, ipp netip.AddrPort, basePort int) (*net.UDPConn,
 // If `payload` is smaller than the initial upstream segment, it launches the attack and splits.
 // This traceroute is not accurate, because of time limit (TCP handshake).
 // Note: The path the UDP packet took to reach the destination may differ from the path the TCP packet took.
-func desyncWithTraceroute(d *protect.RDial, local, remote netip.AddrPort) (*overwriteSplitter, error) {
+func desyncWithTraceroute(d protect.RDialer, local, remote netip.AddrPort) (*overwriteSplitter, error) {
 	const maxport = 65535
 	measureTTL := true
 	isIPv6 := remote.Addr().Is6()
@@ -255,7 +255,7 @@ func desyncWithTraceroute(d *protect.RDial, local, remote netip.AddrPort) (*over
 	return oc, nil
 }
 
-func desyncWithFixedTtl(d *protect.RDial, local, remote netip.AddrPort, initialTTL int) (*overwriteSplitter, error) {
+func desyncWithFixedTtl(d protect.RDialer, local, remote netip.AddrPort, initialTTL int) (*overwriteSplitter, error) {
 	var raddr *net.TCPAddr = net.TCPAddrFromAddrPort(remote)
 	var laddr *net.TCPAddr // nil is valid
 	if local.IsValid() {
@@ -271,7 +271,7 @@ func desyncWithFixedTtl(d *protect.RDial, local, remote netip.AddrPort, initialT
 		proto = "tcp6"
 	}
 
-	tcpConn, err := d.DialTCP(proto, laddr, raddr)
+	tcpConn, err := protect.DialTCP(d, proto, laddr, raddr)
 
 	logeif(err)("desync: dialTCP: %s => %s, do desync? %t, ttl: %d",
 		laddr, raddr, !avoidDesync, initialTTL)
@@ -298,7 +298,7 @@ func desyncWithFixedTtl(d *protect.RDial, local, remote netip.AddrPort, initialT
 // then returns a TCP connection that may launch TCB Desynchronization
 // and split the initial upstream segment.
 // ref: github.com/bol-van/zapret/blob/c369f11638/docs/readme.eng.md#dpi-desync-attack
-func dialWithSplitAndDesync(d *protect.RDial, laddr, raddr *net.TCPAddr) (*overwriteSplitter, error) {
+func dialWithSplitAndDesync(d protect.RDialer, laddr, raddr *net.TCPAddr) (*overwriteSplitter, error) {
 	remote := raddr.AddrPort() // must not be invalid
 	local := laddr.AddrPort()  // can be invalid
 

intra/protect/xdial.go

@@ -38,6 +38,7 @@ type Listener = net.Listener
 type DialFn func(network, addr string) (net.Conn, error)
 
 type RDialer interface {
+	ID() string
 	// Dial creates a connection to the given address,
 	// the resulting net.Conn must be a *net.TCPConn if
 	// network is "tcp" or "tcp4" or "tcp6" and must be
@@ -83,18 +84,21 @@ var (
 	errAccept    = errors.New("cannot accept network")
 )
 
-// Handle implements RDialer.
-func (d *RDial) Handle() uintptr {
-	return core.Loc(d)
-}
-
 func (d *RDial) context() context.Context {
 	if d.ctx != nil {
 		return d.ctx
 	}
 	return context.Background()
 }
 
+// ID implements RDialer.
+func (d *RDial) ID() string {
+	if d.owner != "" {
+		return d.owner
+	}
+	return "xdial" // ownerless
+}
+
 // Dial implements RDialer.
 func (d *RDial) Dial(network, addr string) (net.Conn, error) {
 	return d.dialer.DialContext(d.context(), network, addr)
@@ -190,7 +194,8 @@ func (d *RDial) Announce(network, local string) (net.PacketConn, error) {
 		case *net.UDPConn:
 			return x, nil
 		default:
-			log.T("xdial: Announce (o: %s): addr(%s) failed; %T is not net.UDPConn; other errs: %v", d.owner, local, x, err)
+			log.T("xdial: Announce (o: %s): addr(%s) failed; %T is not net.UDPConn; other errs: %v",
+				d.owner, local, x, err)
 			clos(pc)
 			return nil, errNoUDPMux
 		}
@@ -225,13 +230,17 @@ func (d *RDial) Probe(network, local string) (PacketConn, error) {
 // DialTCP creates a net.TCPConn to raddr.
 // Helper method for d.Dial("tcp", laddr.String(), raddr.String())
 func (d *RDial) DialTCP(network string, laddr, raddr *net.TCPAddr) (*net.TCPConn, error) {
+	return DialTCP(d, network, laddr, raddr)
+}
+
+func DialTCP(d RDialer, network string, laddr, raddr *net.TCPAddr) (*net.TCPConn, error) {
 	if c, err := d.DialBind(network, laddr.String(), raddr.String()); err != nil {
 		return nil, err
 	} else if tc, ok := c.(*net.TCPConn); ok {
 		return tc, nil
 	} else {
 		log.T("xdial: DialTCP: (%s) to %s => %s, %T is not %T (ok? %t); other errs: %v",
-			d.owner, laddr, raddr, c, tc, ok, err)
+			d.ID(), laddr, raddr, c, tc, ok, err)
 		// some proxies like wgproxy, socks5 do not vend *net.TCPConn
 		// also errors if retrier (core.DuplexConn) is looped back here
 		clos(c)
@@ -242,13 +251,17 @@ func (d *RDial) DialTCP(network string, laddr, raddr *net.TCPAddr) (*net.TCPConn
 // DialUDP creates a net.UDPConn to raddr.
 // Helper method for d.Dial("udp", laddr.String(), raddr.String())
 func (d *RDial) DialUDP(network string, laddr, raddr *net.UDPAddr) (*net.UDPConn, error) {
+	return DialUDP(d, network, laddr, raddr)
+}
+
+func DialUDP(d RDialer, network string, laddr, raddr *net.UDPAddr) (*net.UDPConn, error) {
 	if c, err := d.DialBind(network, laddr.String(), raddr.String()); err != nil {
 		return nil, err
 	} else if uc, ok := c.(*net.UDPConn); ok {
 		return uc, nil
 	} else {
 		log.T("xdial: DialUDP: (%s) to %s => %s, %T is not %T (ok? %t); other errs: %v",
-			d.owner, laddr, raddr, c, uc, ok, err)
+			d.ID(), laddr, raddr, c, uc, ok, err)
 		// some proxies like wgproxy, socks5 do not vend *net.UDPConn
 		clos(c)
 		return nil, errNoUDP
@@ -258,13 +271,17 @@ func (d *RDial) DialUDP(network string, laddr, raddr *net.UDPAddr) (*net.UDPConn
 // AnnounceUDP announces the local address. network must be "udp" or "udp4" or "udp6".
 // Helper method for d.Announce("udp", local)
 func (d *RDial) AnnounceUDP(network, local string) (*net.UDPConn, error) {
+	return AnnounceUDP(d, network, local)
+}
+
+func AnnounceUDP(d RDialer, network, local string) (*net.UDPConn, error) {
 	if c, err := d.Announce(network, local); err != nil {
 		return nil, err
 	} else if uc, ok := c.(*net.UDPConn); ok {
 		return uc, nil
 	} else {
 		log.T("xdial: AnnounceUDP: (%s) from %s, %T is not %T (ok? %t); other errs: %v",
-			d.owner, local, c, uc, ok, err)
+			d.ID(), local, c, uc, ok, err)
 		clos(c)
 		return nil, errNoUDPMux
 	}
@@ -273,13 +290,17 @@ func (d *RDial) AnnounceUDP(network, local string) (*net.UDPConn, error) {
 // AcceptTCP creates a listener on the local address. network must be "tcp" or "tcp4" or "tcp6".
 // Helper method for d.Accept("tcp", local)
 func (d *RDial) AcceptTCP(network string, local string) (*net.TCPListener, error) {
+	return AcceptTCP(d, network, local)
+}
+
+func AcceptTCP(d RDialer, network string, local string) (*net.TCPListener, error) {
 	if ln, err := d.Accept(network, local); err != nil {
 		return nil, err
 	} else if tl, ok := ln.(*net.TCPListener); ok {
 		return tl, nil
 	} else {
 		log.T("xdial: AcceptTCP: (%s) from %s, %T is not %T (ok? %t); other errs: %v",
-			d.owner, local, ln, tl, ok, err)
+			d.ID(), local, ln, tl, ok, err)
 		clos(ln)
 		return nil, errNoTCPMux
 	}