feat: ntp service

adapter/adapter.go

@@ -10,6 +10,7 @@ import (
 	"net/netip"
 	"net/url"
 	"strconv"
+	"sync"
 	"time"
 
 	"github.com/Dreamacro/clash/common/atomic"
@@ -18,8 +19,6 @@ import (
 	"github.com/Dreamacro/clash/component/dialer"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
-
-	"github.com/puzpuzpuz/xsync/v2"
 )
 
 var UnifiedDelay = atomic.NewBool(false)
@@ -38,7 +37,7 @@ type Proxy struct {
 	history *queue.Queue[C.DelayHistory]
 	alive   *atomic.Bool
 	url     string
-	extra   *xsync.MapOf[string, *extraProxyState]
+	extra   sync.Map
 }
 
 // Alive implements C.Proxy
@@ -49,7 +48,7 @@ func (p *Proxy) Alive() bool {
 // AliveForTestUrl implements C.Proxy
 func (p *Proxy) AliveForTestUrl(url string) bool {
 	if state, ok := p.extra.Load(url); ok {
-		return state.alive.Load()
+		return state.(*extraProxyState).alive.Load()
 	}
 
 	return p.alive.Load()
@@ -97,7 +96,7 @@ func (p *Proxy) DelayHistoryForTestUrl(url string) []C.DelayHistory {
 	var queueM []C.DelayHistory
 
 	if state, ok := p.extra.Load(url); ok {
-		queueM = state.history.Copy()
+		queueM = state.(*extraProxyState).history.Copy()
 	}
 
 	if queueM == nil {
@@ -114,10 +113,10 @@ func (p *Proxy) DelayHistoryForTestUrl(url string) []C.DelayHistory {
 func (p *Proxy) ExtraDelayHistory() map[string][]C.DelayHistory {
 	extraHistory := map[string][]C.DelayHistory{}
 
-	p.extra.Range(func(k string, v *extraProxyState) bool {
+	p.extra.Range(func(k, v interface{}) bool {
 
-		testUrl := k
-		state := v
+		testUrl := k.(string)
+		state := v.(*extraProxyState)
 
 		histories := []C.DelayHistory{}
 		queueM := state.history.Copy()
@@ -156,8 +155,8 @@ func (p *Proxy) LastDelayForTestUrl(url string) (delay uint16) {
 	history := p.history.Last()
 
 	if state, ok := p.extra.Load(url); ok {
-		alive = state.alive.Load()
-		history = state.history.Last()
+		alive = state.(*extraProxyState).alive.Load()
+		history = state.(*extraProxyState).history.Last()
 	}
 
 	if !alive {
@@ -227,10 +226,10 @@ func (p *Proxy) URLTest(ctx context.Context, url string, expectedStatus utils.In
 				p.extra.Store(url, state)
 			}
 
-			state.alive.Store(alive)
-			state.history.Put(record)
-			if state.history.Len() > defaultHistoriesNum {
-				state.history.Pop()
+			state.(*extraProxyState).alive.Store(alive)
+			state.(*extraProxyState).history.Put(record)
+			if state.(*extraProxyState).history.Len() > defaultHistoriesNum {
+				state.(*extraProxyState).history.Pop()
 			}
 		default:
 			log.Debugln("health check result will be discarded, url: %s alive: %t, delay: %d", url, alive, t)
@@ -312,7 +311,7 @@ func NewProxy(adapter C.ProxyAdapter) *Proxy {
 		history:      queue.New[C.DelayHistory](defaultHistoriesNum),
 		alive:        atomic.NewBool(true),
 		url:          "",
-		extra:        xsync.NewMapOf[*extraProxyState]()}
+		extra:        sync.Map{}}
 }
 
 func urlToMetadata(rawURL string) (addr C.Metadata, err error) {
@@ -355,7 +354,13 @@ func (p *Proxy) determineFinalStoreType(store C.DelayHistoryStoreType, url strin
 		return C.OriginalHistory
 	}
 
-	if p.extra.Size() < 2*C.DefaultMaxHealthCheckUrlNum {
+	length := 0
+	p.extra.Range(func(_, _ interface{}) bool {
+		length++
+		return length < 2*C.DefaultMaxHealthCheckUrlNum
+	})
+
+	if length == 0 {
 		return C.ExtraHistory
 	}
 
@@ -364,5 +369,9 @@ func (p *Proxy) determineFinalStoreType(store C.DelayHistoryStoreType, url strin
 		return C.ExtraHistory
 	}
 
+	if length < 2*C.DefaultMaxHealthCheckUrlNum {
+		return C.ExtraHistory
+	}
+
 	return store
 }

adapter/inbound/mitm.go

@@ -1,22 +0,0 @@
-package inbound
-
-import (
-	"net"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/context"
-	"github.com/Dreamacro/clash/transport/socks5"
-)
-
-// NewMitm receive mitm request and return MitmContext
-func NewMitm(target socks5.Addr, source net.Addr, userAgent string, conn net.Conn) *context.ConnContext {
-	metadata := parseSocksAddr(target)
-	metadata.NetWork = C.TCP
-	metadata.Type = C.MITM
-	metadata.UserAgent = userAgent
-	if ip, port, err := parseAddr(source); err == nil {
-		metadata.SrcIP = ip
-		metadata.SrcPort = port
-	}
-	return context.NewConnContext(conn, metadata)
-}

adapter/outbound/direct.go

@@ -3,8 +3,6 @@ package outbound
 import (
 	"context"
 	"errors"
-
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/resolver"
 	C "github.com/Dreamacro/clash/constant"
@@ -26,7 +24,7 @@ func (d *Direct) DialContext(ctx context.Context, metadata *C.Metadata, opts ...
 	if err != nil {
 		return nil, err
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	return NewConn(c, d), nil
 }
 

adapter/outbound/http.go

@@ -7,13 +7,11 @@ import (
 	"encoding/base64"
 	"errors"
 	"fmt"
-
 	"io"
 	"net"
 	"net/http"
 	"strconv"
 
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/proxydialer"
 	tlsC "github.com/Dreamacro/clash/component/tls"
@@ -76,7 +74,7 @@ func (h *Http) DialContextWithDialer(ctx context.Context, dialer C.Dialer, metad
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", h.addr, err)
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
@@ -113,10 +111,6 @@ func (h *Http) shakeHand(metadata *C.Metadata, rw io.ReadWriter) error {
 		tempHeaders["Proxy-Authorization"] = "Basic " + base64.StdEncoding.EncodeToString([]byte(auth))
 	}
 
-	if metadata.Type == C.MITM {
-		tempHeaders["Origin-Request-Source-Address"] = metadata.SourceAddress()
-	}
-
 	for key, value := range tempHeaders {
 		HeaderString += key + ": " + value + "\r\n"
 	}

adapter/outbound/mitm.go

@@ -1,50 +0,0 @@
-package outbound
-
-import (
-	"context"
-	"net"
-	"time"
-
-	"github.com/Dreamacro/clash/component/dialer"
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type Mitm struct {
-	*Base
-	serverAddr      *net.TCPAddr
-	httpProxyClient *Http
-}
-
-// DialContext implements C.ProxyAdapter
-func (m *Mitm) DialContext(ctx context.Context, metadata *C.Metadata, _ ...dialer.Option) (C.Conn, error) {
-	c, err := net.DialTCP("tcp", nil, m.serverAddr)
-	if err != nil {
-		return nil, err
-	}
-
-	_ = c.SetKeepAlive(true)
-	_ = c.SetKeepAlivePeriod(60 * time.Second)
-
-	metadata.Type = C.MITM
-
-	hc, err := m.httpProxyClient.StreamConnContext(ctx, c, metadata)
-	if err != nil {
-		_ = c.Close()
-		return nil, err
-	}
-
-	return NewConn(hc, m), nil
-}
-
-func NewMitm(serverAddr string) *Mitm {
-	tcpAddr, _ := net.ResolveTCPAddr("tcp", serverAddr)
-	http, _ := NewHttp(HttpOption{})
-	return &Mitm{
-		Base: &Base{
-			name: "Mitm",
-			tp:   C.Mitm,
-		},
-		serverAddr:      tcpAddr,
-		httpProxyClient: http,
-	}
-}

adapter/outbound/shadowsocks.go

@@ -146,7 +146,7 @@ func (ss *ShadowSocks) DialContextWithDialer(ctx context.Context, dialer C.Diale
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 
 	defer func(c net.Conn) {
 		safeConnClose(c, err)

adapter/outbound/shadowsocksr.go

@@ -80,7 +80,7 @@ func (ssr *ShadowSocksR) DialContextWithDialer(ctx context.Context, dialer C.Dia
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", ssr.addr, err)
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 
 	defer func(c net.Conn) {
 		safeConnClose(c, err)

adapter/outbound/snell.go

@@ -6,7 +6,6 @@ import (
 	"net"
 	"strconv"
 
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/common/structure"
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/proxydialer"
@@ -94,7 +93,7 @@ func (s *Snell) DialContextWithDialer(ctx context.Context, dialer C.Dialer, meta
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", s.addr, err)
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
@@ -122,7 +121,7 @@ func (s *Snell) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 	if err != nil {
 		return nil, err
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	c = streamConn(c, streamOption{s.psk, s.version, s.addr, s.obfsOption})
 
 	err = snell.WriteUDPHeader(c, s.version)
@@ -208,7 +207,7 @@ func NewSnell(option SnellOption) (*Snell, error) {
 				return nil, err
 			}
 
-			N.TCPKeepAlive(c)
+			tcpKeepAlive(c)
 			return streamConn(c, streamOption{psk, option.Version, addr, obfsOption}), nil
 		})
 	}

adapter/outbound/socks5.go

@@ -9,7 +9,6 @@ import (
 	"net"
 	"strconv"
 
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/proxydialer"
 	tlsC "github.com/Dreamacro/clash/component/tls"
@@ -81,7 +80,7 @@ func (ss *Socks5) DialContextWithDialer(ctx context.Context, dialer C.Dialer, me
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", ss.addr, err)
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
@@ -127,7 +126,7 @@ func (ss *Socks5) ListenPacketContext(ctx context.Context, metadata *C.Metadata,
 		safeConnClose(c, err)
 	}(c)
 
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	var user *socks5.User
 	if ss.user != "" {
 		user = &socks5.User{

adapter/outbound/trojan.go

@@ -8,7 +8,6 @@ import (
 	"net/http"
 	"strconv"
 
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/component/dialer"
 	"github.com/Dreamacro/clash/component/proxydialer"
 	tlsC "github.com/Dreamacro/clash/component/tls"
@@ -132,7 +131,7 @@ func (t *Trojan) DialContextWithDialer(ctx context.Context, dialer C.Dialer, met
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
@@ -185,7 +184,7 @@ func (t *Trojan) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, me
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
 	}(c)
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	c, err = t.plainStream(ctx, c)
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %w", t.addr, err)
@@ -269,7 +268,7 @@ func NewTrojan(option TrojanOption) (*Trojan, error) {
 			if err != nil {
 				return nil, fmt.Errorf("%s connect error: %s", t.addr, err.Error())
 			}
-			N.TCPKeepAlive(c)
+			tcpKeepAlive(c)
 			return c, nil
 		}
 

adapter/outbound/util.go

@@ -7,6 +7,7 @@ import (
 	"net"
 	"net/netip"
 	"sync"
+	"time"
 
 	"github.com/Dreamacro/clash/component/resolver"
 	C "github.com/Dreamacro/clash/constant"
@@ -18,6 +19,13 @@ var (
 	once                     sync.Once
 )
 
+func tcpKeepAlive(c net.Conn) {
+	if tcp, ok := c.(*net.TCPConn); ok {
+		_ = tcp.SetKeepAlive(true)
+		_ = tcp.SetKeepAlivePeriod(30 * time.Second)
+	}
+}
+
 func getClientSessionCache() tls.ClientSessionCache {
 	once.Do(func() {
 		globalClientSessionCache = tls.NewLRUClientSessionCache(128)

adapter/outbound/vless.go

@@ -263,7 +263,7 @@ func (v *Vless) DialContextWithDialer(ctx context.Context, dialer C.Dialer, meta
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
 	}(c)
@@ -328,7 +328,7 @@ func (v *Vless) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
 	}(c)
@@ -578,7 +578,7 @@ func NewVless(option VlessOption) (*Vless, error) {
 			if err != nil {
 				return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 			}
-			N.TCPKeepAlive(c)
+			tcpKeepAlive(c)
 			return c, nil
 		}
 

adapter/outbound/vmess.go

@@ -308,7 +308,7 @@ func (v *Vmess) DialContextWithDialer(ctx context.Context, dialer C.Dialer, meta
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
 	}(c)
@@ -369,7 +369,7 @@ func (v *Vmess) ListenPacketWithDialer(ctx context.Context, dialer C.Dialer, met
 	if err != nil {
 		return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 	}
-	N.TCPKeepAlive(c)
+	tcpKeepAlive(c)
 	defer func(c net.Conn) {
 		safeConnClose(c, err)
 	}(c)
@@ -469,7 +469,7 @@ func NewVmess(option VmessOption) (*Vmess, error) {
 			if err != nil {
 				return nil, fmt.Errorf("%s connect error: %s", v.addr, err.Error())
 			}
-			N.TCPKeepAlive(c)
+			tcpKeepAlive(c)
 			return c, nil
 		}
 

adapter/outboundgroup/util.go

@@ -1,5 +1,17 @@
 package outboundgroup
 
+import (
+	"net"
+	"time"
+)
+
+func tcpKeepAlive(c net.Conn) {
+	if tcp, ok := c.(*net.TCPConn); ok {
+		_ = tcp.SetKeepAlive(true)
+		_ = tcp.SetKeepAlivePeriod(30 * time.Second)
+	}
+}
+
 type SelectAble interface {
 	Set(string) error
 	ForceSet(name string)

common/cert/cert.go

@@ -1,303 +0,0 @@
-package cert
-
-import (
-	"crypto/rand"
-	"crypto/rsa"
-	"crypto/sha1"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"math/big"
-	"net"
-	"os"
-	"strings"
-	"sync/atomic"
-	"time"
-)
-
-var currentSerialNumber = time.Now().Unix()
-
-type Config struct {
-	ca           *x509.Certificate
-	caPrivateKey *rsa.PrivateKey
-
-	roots *x509.CertPool
-
-	privateKey *rsa.PrivateKey
-
-	validity     time.Duration
-	keyID        []byte
-	organization string
-
-	certsStorage CertsStorage
-}
-
-type CertsStorage interface {
-	Get(key string) (*tls.Certificate, bool)
-
-	Set(key string, cert *tls.Certificate)
-}
-
-func NewAuthority(name, organization string, validity time.Duration) (*x509.Certificate, *rsa.PrivateKey, error) {
-	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return nil, nil, err
-	}
-	pub := privateKey.Public()
-
-	pkixPub, err := x509.MarshalPKIXPublicKey(pub)
-	if err != nil {
-		return nil, nil, err
-	}
-	h := sha1.New()
-	_, err = h.Write(pkixPub)
-	if err != nil {
-		return nil, nil, err
-	}
-	keyID := h.Sum(nil)
-
-	serial := atomic.AddInt64(&currentSerialNumber, 1)
-
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(serial),
-		Subject: pkix.Name{
-			CommonName:   name,
-			Organization: []string{organization},
-		},
-		SubjectKeyId:          keyID,
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-		NotBefore:             time.Now().Add(-validity),
-		NotAfter:              time.Now().Add(validity),
-		DNSNames:              []string{name},
-		IsCA:                  true,
-	}
-
-	raw, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, pub, privateKey)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	x509c, err := x509.ParseCertificate(raw)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	return x509c, privateKey, nil
-}
-
-func NewConfig(ca *x509.Certificate, caPrivateKey *rsa.PrivateKey) (*Config, error) {
-	roots := x509.NewCertPool()
-	roots.AddCert(ca)
-
-	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return nil, err
-	}
-	pub := privateKey.Public()
-
-	pkixPub, err := x509.MarshalPKIXPublicKey(pub)
-	if err != nil {
-		return nil, err
-	}
-	h := sha1.New()
-	_, err = h.Write(pkixPub)
-	if err != nil {
-		return nil, err
-	}
-	keyID := h.Sum(nil)
-
-	return &Config{
-		ca:           ca,
-		caPrivateKey: caPrivateKey,
-		privateKey:   privateKey,
-		keyID:        keyID,
-		validity:     time.Hour,
-		organization: "Clash",
-		certsStorage: NewDomainTrieCertsStorage(),
-		roots:        roots,
-	}, nil
-}
-
-func (c *Config) GetCA() *x509.Certificate {
-	return c.ca
-}
-
-func (c *Config) SetOrganization(organization string) {
-	c.organization = organization
-}
-
-func (c *Config) SetValidity(validity time.Duration) {
-	c.validity = validity
-}
-
-func (c *Config) NewTLSConfigForHost(hostname string) *tls.Config {
-	tlsConfig := &tls.Config{
-		GetCertificate: func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
-			host := clientHello.ServerName
-			if host == "" {
-				host = hostname
-			}
-
-			return c.GetOrCreateCert(host)
-		},
-		NextProtos: []string{"http/1.1"},
-	}
-
-	tlsConfig.InsecureSkipVerify = true
-
-	return tlsConfig
-}
-
-func (c *Config) GetOrCreateCert(hostname string, ips ...net.IP) (*tls.Certificate, error) {
-	var leaf *x509.Certificate
-	tlsCertificate, ok := c.certsStorage.Get(hostname)
-	if ok {
-		leaf = tlsCertificate.Leaf
-		if _, err := leaf.Verify(x509.VerifyOptions{
-			DNSName: hostname,
-			Roots:   c.roots,
-		}); err == nil {
-			return tlsCertificate, nil
-		}
-	}
-
-	var (
-		key          = hostname
-		topHost      = hostname
-		wildcardHost = "*." + hostname
-		dnsNames     []string
-	)
-
-	if ip := net.ParseIP(hostname); ip != nil {
-		ips = append(ips, ip)
-	} else {
-		parts := strings.Split(hostname, ".")
-		l := len(parts)
-
-		if leaf != nil {
-			dnsNames = append(dnsNames, leaf.DNSNames...)
-		}
-
-		if l > 2 {
-			topIndex := l - 2
-			topHost = strings.Join(parts[topIndex:], ".")
-
-			for i := topIndex; i > 0; i-- {
-				wildcardHost = "*." + strings.Join(parts[i:], ".")
-
-				if i == topIndex && (len(dnsNames) == 0 || dnsNames[0] != topHost) {
-					dnsNames = append(dnsNames, topHost, wildcardHost)
-				} else if !hasDnsNames(dnsNames, wildcardHost) {
-					dnsNames = append(dnsNames, wildcardHost)
-				}
-			}
-		} else {
-			dnsNames = append(dnsNames, topHost, wildcardHost)
-		}
-
-		key = "+." + topHost
-	}
-
-	serial := atomic.AddInt64(&currentSerialNumber, 1)
-
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(serial),
-		Subject: pkix.Name{
-			CommonName:   topHost,
-			Organization: []string{c.organization},
-		},
-		SubjectKeyId:          c.keyID,
-		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-		NotBefore:             time.Now().Add(-c.validity),
-		NotAfter:              time.Now().Add(c.validity),
-		DNSNames:              dnsNames,
-		IPAddresses:           ips,
-	}
-
-	raw, err := x509.CreateCertificate(rand.Reader, tmpl, c.ca, c.privateKey.Public(), c.caPrivateKey)
-	if err != nil {
-		return nil, err
-	}
-
-	x509c, err := x509.ParseCertificate(raw)
-	if err != nil {
-		return nil, err
-	}
-
-	tlsCertificate = &tls.Certificate{
-		Certificate: [][]byte{raw, c.ca.Raw},
-		PrivateKey:  c.privateKey,
-		Leaf:        x509c,
-	}
-
-	c.certsStorage.Set(key, tlsCertificate)
-	return tlsCertificate, nil
-}
-
-// GenerateAndSave generate CA private key and CA certificate and dump them to file
-func GenerateAndSave(caPath string, caKeyPath string) error {
-	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
-	if err != nil {
-		return err
-	}
-
-	tmpl := &x509.Certificate{
-		SerialNumber: big.NewInt(time.Now().Unix()),
-		Subject: pkix.Name{
-			Country:      []string{"US"},
-			CommonName:   "Clash Root CA",
-			Organization: []string{"Clash Trust Services"},
-		},
-		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		NotBefore:             time.Now().Add(-(time.Hour * 24 * 60)),
-		NotAfter:              time.Now().Add(time.Hour * 24 * 365 * 25),
-		BasicConstraintsValid: true,
-		IsCA:                  true,
-	}
-
-	caRaw, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, privateKey.Public(), privateKey)
-	if err != nil {
-		return err
-	}
-
-	caOut, err := os.OpenFile(caPath, os.O_CREATE|os.O_WRONLY, 0o600)
-	if err != nil {
-		return err
-	}
-	defer func(caOut *os.File) {
-		_ = caOut.Close()
-	}(caOut)
-
-	if err = pem.Encode(caOut, &pem.Block{Type: "CERTIFICATE", Bytes: caRaw}); err != nil {
-		return err
-	}
-
-	caKeyOut, err := os.OpenFile(caKeyPath, os.O_CREATE|os.O_WRONLY, 0o600)
-	if err != nil {
-		return err
-	}
-	defer func(caKeyOut *os.File) {
-		_ = caKeyOut.Close()
-	}(caKeyOut)
-
-	if err = pem.Encode(caKeyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(privateKey)}); err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func hasDnsNames(dnsNames []string, hostname string) bool {
-	for _, name := range dnsNames {
-		if name == hostname {
-			return true
-		}
-	}
-	return false
-}

common/cert/storage.go

@@ -1,32 +0,0 @@
-package cert
-
-import (
-	"crypto/tls"
-
-	"github.com/Dreamacro/clash/component/trie"
-)
-
-// DomainTrieCertsStorage cache wildcard certificates
-type DomainTrieCertsStorage struct {
-	certsCache *trie.DomainTrie[*tls.Certificate]
-}
-
-// Get gets the certificate from the storage
-func (c *DomainTrieCertsStorage) Get(key string) (*tls.Certificate, bool) {
-	ca := c.certsCache.Search(key)
-	if ca == nil {
-		return nil, false
-	}
-	return ca.Data(), true
-}
-
-// Set saves the certificate to the storage
-func (c *DomainTrieCertsStorage) Set(key string, cert *tls.Certificate) {
-	_ = c.certsCache.Insert(key, cert)
-}
-
-func NewDomainTrieCertsStorage() *DomainTrieCertsStorage {
-	return &DomainTrieCertsStorage{
-		certsCache: trie.New[*tls.Certificate](),
-	}
-}

common/cmd/cmd_test.go

@@ -21,7 +21,7 @@ func TestSplitArgs(t *testing.T) {
 
 func TestExecCmd(t *testing.T) {
 	if runtime.GOOS == "windows" {
-		_, err := ExecCmd("cmd -c 'dir'")
+		_, err := ExecCmd("dir")
 		assert.Nil(t, err)
 		return
 	}

common/net/tcpip.go

@@ -4,11 +4,8 @@ import (
 	"fmt"
 	"net"
 	"strings"
-	"time"
 )
 
-var KeepAliveInterval time.Duration
-
 func SplitNetworkType(s string) (string, string, error) {
 	var (
 		shecme   string
@@ -47,10 +44,3 @@ func SplitHostPort(s string) (host, port string, hasPort bool, err error) {
 	host, port, err = net.SplitHostPort(temp)
 	return
 }
-
-func TCPKeepAlive(c net.Conn) {
-	if tcp, ok := c.(*net.TCPConn); ok {
-		_ = tcp.SetKeepAlive(true)
-		_ = tcp.SetKeepAlivePeriod(KeepAliveInterval * time.Second)
-	}
-}

component/auth/auth.go

@@ -1,7 +1,7 @@
 package auth
 
 import (
-	"github.com/puzpuzpuz/xsync/v2"
+	"sync"
 )
 
 type Authenticator interface {
@@ -15,7 +15,7 @@ type AuthUser struct {
 }
 
 type inMemoryAuthenticator struct {
-	storage   *xsync.MapOf[string, string]
+	storage   *sync.Map
 	usernames []string
 }
 
@@ -31,13 +31,13 @@ func NewAuthenticator(users []AuthUser) Authenticator {
 		return nil
 	}
 
-	au := &inMemoryAuthenticator{storage: xsync.NewMapOf[string]()}
+	au := &inMemoryAuthenticator{storage: &sync.Map{}}
 	for _, user := range users {
 		au.storage.Store(user.User, user.Pass)
 	}
 	usernames := make([]string, 0, len(users))
-	au.storage.Range(func(key string, value string) bool {
-		usernames = append(usernames, key)
+	au.storage.Range(func(key, value any) bool {
+		usernames = append(usernames, key.(string))
 		return true
 	})
 	au.usernames = usernames

component/geodata/memconservative/cache.go

@@ -32,7 +32,7 @@ func (g GeoIPCache) Set(key string, value *router.GeoIP) {
 }
 
 func (g GeoIPCache) Unmarshal(filename, code string) (*router.GeoIP, error) {
-	asset := C.Path.Resolve(filename)
+	asset := C.Path.GetAssetLocation(filename)
 	idx := strings.ToLower(asset + ":" + code)
 	if g.Has(idx) {
 		return g.Get(idx), nil
@@ -97,7 +97,7 @@ func (g GeoSiteCache) Set(key string, value *router.GeoSite) {
 }
 
 func (g GeoSiteCache) Unmarshal(filename, code string) (*router.GeoSite, error) {
-	asset := C.Path.Resolve(filename)
+	asset := C.Path.GetAssetLocation(filename)
 	idx := strings.ToLower(asset + ":" + code)
 	if g.Has(idx) {
 		return g.Get(idx), nil

component/geodata/standard/standard.go

@@ -26,7 +26,7 @@ func ReadFile(path string) ([]byte, error) {
 }
 
 func ReadAsset(file string) ([]byte, error) {
-	return ReadFile(C.Path.Resolve(file))
+	return ReadFile(C.Path.GetAssetLocation(file))
 }
 
 func loadIP(geoipBytes []byte, country string) ([]*router.CIDR, error) {

component/nat/table.go

@@ -5,28 +5,23 @@ import (
 	"sync"
 
 	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/puzpuzpuz/xsync/v2"
 )
 
 type Table struct {
-	mapping *xsync.MapOf[string, *Entry]
-	lockMap *xsync.MapOf[string, *sync.Cond]
+	mapping sync.Map
 }
 
 type Entry struct {
 	PacketConn      C.PacketConn
 	WriteBackProxy  C.WriteBackProxy
-	LocalUDPConnMap *xsync.MapOf[string, *net.UDPConn]
-	LocalLockMap    *xsync.MapOf[string, *sync.Cond]
+	LocalUDPConnMap sync.Map
 }
 
 func (t *Table) Set(key string, e C.PacketConn, w C.WriteBackProxy) {
 	t.mapping.Store(key, &Entry{
 		PacketConn:      e,
 		WriteBackProxy:  w,
-		LocalUDPConnMap: xsync.NewMapOf[*net.UDPConn](),
-		LocalLockMap:    xsync.NewMapOf[*sync.Cond](),
+		LocalUDPConnMap: sync.Map{},
 	})
 }
 
@@ -39,19 +34,15 @@ func (t *Table) Get(key string) (C.PacketConn, C.WriteBackProxy) {
 }
 
 func (t *Table) GetOrCreateLock(key string) (*sync.Cond, bool) {
-	item, loaded := t.lockMap.LoadOrCompute(key, makeLock)
-	return item, loaded
+	item, loaded := t.mapping.LoadOrStore(key, sync.NewCond(&sync.Mutex{}))
+	return item.(*sync.Cond), loaded
 }
 
 func (t *Table) Delete(key string) {
 	t.mapping.Delete(key)
 }
 
-func (t *Table) DeleteLock(lockKey string) {
-	t.lockMap.Delete(lockKey)
-}
-
-func (t *Table) GetForLocalConn(lAddr, rAddr string) *net.UDPConn {
+func (t *Table) GetLocalConn(lAddr, rAddr string) *net.UDPConn {
 	entry, exist := t.getEntry(lAddr)
 	if !exist {
 		return nil
@@ -60,10 +51,10 @@ func (t *Table) GetForLocalConn(lAddr, rAddr string) *net.UDPConn {
 	if !exist {
 		return nil
 	}
-	return item
+	return item.(*net.UDPConn)
 }
 
-func (t *Table) AddForLocalConn(lAddr, rAddr string, conn *net.UDPConn) bool {
+func (t *Table) AddLocalConn(lAddr, rAddr string, conn *net.UDPConn) bool {
 	entry, exist := t.getEntry(lAddr)
 	if !exist {
 		return false
@@ -72,7 +63,7 @@ func (t *Table) AddForLocalConn(lAddr, rAddr string, conn *net.UDPConn) bool {
 	return true
 }
 
-func (t *Table) RangeForLocalConn(lAddr string, f func(key string, value *net.UDPConn) bool) {
+func (t *Table) RangeLocalConn(lAddr string, f func(key, value any) bool) {
 	entry, exist := t.getEntry(lAddr)
 	if !exist {
 		return
@@ -85,11 +76,11 @@ func (t *Table) GetOrCreateLockForLocalConn(lAddr, key string) (*sync.Cond, bool
 	if !loaded {
 		return nil, false
 	}
-	item, loaded := entry.LocalLockMap.LoadOrCompute(key, makeLock)
-	return item, loaded
+	item, loaded := entry.LocalUDPConnMap.LoadOrStore(key, sync.NewCond(&sync.Mutex{}))
+	return item.(*sync.Cond), loaded
 }
 
-func (t *Table) DeleteForLocalConn(lAddr, key string) {
+func (t *Table) DeleteLocalConnMap(lAddr, key string) {
 	entry, loaded := t.getEntry(lAddr)
 	if !loaded {
 		return
@@ -97,26 +88,17 @@ func (t *Table) DeleteForLocalConn(lAddr, key string) {
 	entry.LocalUDPConnMap.Delete(key)
 }
 
-func (t *Table) DeleteLockForLocalConn(lAddr, key string) {
-	entry, loaded := t.getEntry(lAddr)
-	if !loaded {
-		return
-	}
-	entry.LocalLockMap.Delete(key)
-}
-
 func (t *Table) getEntry(key string) (*Entry, bool) {
-	return t.mapping.Load(key)
-}
-
-func makeLock() *sync.Cond {
-	return sync.NewCond(&sync.Mutex{})
+	item, ok := t.mapping.Load(key)
+	// This should not happen usually since this function called after PacketConn created
+	if !ok {
+		return nil, false
+	}
+	entry, ok := item.(*Entry)
+	return entry, ok
 }
 
 // New return *Cache
 func New() *Table {
-	return &Table{
-		mapping: xsync.NewMapOf[*Entry](),
-		lockMap: xsync.NewMapOf[*sync.Cond](),
-	}
+	return &Table{}
 }

config/config.go

@@ -16,7 +16,6 @@ import (
 	"github.com/Dreamacro/clash/adapter/outbound"
 	"github.com/Dreamacro/clash/adapter/outboundgroup"
 	"github.com/Dreamacro/clash/adapter/provider"
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/common/utils"
 	"github.com/Dreamacro/clash/component/auth"
 	"github.com/Dreamacro/clash/component/dialer"
@@ -35,7 +34,6 @@ import (
 	L "github.com/Dreamacro/clash/listener"
 	LC "github.com/Dreamacro/clash/listener/config"
 	"github.com/Dreamacro/clash/log"
-	rewrites "github.com/Dreamacro/clash/rewrite"
 	R "github.com/Dreamacro/clash/rules"
 	RP "github.com/Dreamacro/clash/rules/provider"
 	T "github.com/Dreamacro/clash/tunnel"
@@ -61,7 +59,6 @@ type General struct {
 	Sniffing                bool              `json:"sniffing"`
 	EBpf                    EBpf              `json:"-"`
 	GlobalClientFingerprint string            `json:"global-client-fingerprint"`
-	KeepAliveInterval       int               `json:"keep-alive-interval"`
 }
 
 // Inbound config
@@ -80,7 +77,6 @@ type Inbound struct {
 	BindAddress       string        `json:"bind-address"`
 	InboundTfo        bool          `json:"inbound-tfo"`
 	InboundMPTCP      bool          `json:"inbound-mptcp"`
-	MitmPort          int           `json:"mitm-port"`
 }
 
 // Controller config
@@ -154,12 +150,6 @@ type Sniffer struct {
 	ParsePureIp     bool
 }
 
-// Mitm config
-type Mitm struct {
-	Port  int           `yaml:"port" json:"port"`
-	Rules C.RewriteRule `yaml:"rules" json:"rules"`
-}
-
 // Experimental config
 type Experimental struct {
 	Fingerprints []string `yaml:"fingerprints"`
@@ -169,7 +159,6 @@ type Experimental struct {
 type Config struct {
 	General       *General
 	IPTables      *IPTables
-	Mitm          *Mitm
 	NTP           *NTP
 	DNS           *DNS
 	Experimental  *Experimental
@@ -262,18 +251,12 @@ type RawTuicServer struct {
 	CWND                  int               `yaml:"cwnd" json:"cwnd,omitempty"`
 }
 
-type RawMitm struct {
-	Port  int                    `yaml:"port" json:"port"`
-	Rules []rewrites.RawMitmRule `yaml:"rules" json:"rules"`
-}
-
 type RawConfig struct {
 	Port                    int               `yaml:"port"`
 	SocksPort               int               `yaml:"socks-port"`
 	RedirPort               int               `yaml:"redir-port"`
 	TProxyPort              int               `yaml:"tproxy-port"`
 	MixedPort               int               `yaml:"mixed-port"`
-	MitmPort                int               `yaml:"mitm-port"`
 	ShadowSocksConfig       string            `yaml:"ss-config"`
 	VmessConfig             string            `yaml:"vmess-config"`
 	InboundTfo              bool              `yaml:"inbound-tfo"`
@@ -297,7 +280,6 @@ type RawConfig struct {
 	TCPConcurrent           bool              `yaml:"tcp-concurrent" json:"tcp-concurrent"`
 	FindProcessMode         P.FindProcessMode `yaml:"find-process-mode" json:"find-process-mode"`
 	GlobalClientFingerprint string            `yaml:"global-client-fingerprint"`
-	KeepAliveInterval       int               `yaml:"keep-alive-interval"`
 
 	Sniffer       RawSniffer                `yaml:"sniffer"`
 	ProxyProvider map[string]map[string]any `yaml:"proxy-providers"`
@@ -309,7 +291,6 @@ type RawConfig struct {
 	TuicServer    RawTuicServer             `yaml:"tuic-server"`
 	EBpf          EBpf                      `yaml:"ebpf"`
 	IPTables      IPTables                  `yaml:"iptables"`
-	MITM          RawMitm                   `yaml:"mitm"`
 	Experimental  Experimental              `yaml:"experimental"`
 	Profile       Profile                   `yaml:"profile"`
 	GeoXUrl       GeoXUrl                   `yaml:"geox-url"`
@@ -454,10 +435,6 @@ func UnmarshalRawConfig(buf []byte) (*RawConfig, error) {
 			ParsePureIp:     true,
 			OverrideDest:    true,
 		},
-		MITM: RawMitm{
-			Port:  0,
-			Rules: []rewrites.RawMitmRule{},
-		},
 		Profile: Profile{
 			StoreSelected: true,
 		},
@@ -552,12 +529,6 @@ func ParseRawConfig(rawCfg *RawConfig) (*Config, error) {
 		return nil, err
 	}
 
-	mitm, err := parseMitm(rawCfg.MITM)
-	if err != nil {
-		return nil, err
-	}
-	config.Mitm = mitm
-
 	config.Users = parseAuthentication(rawCfg.Authentication)
 
 	config.Tunnels = rawCfg.Tunnels
@@ -588,11 +559,6 @@ func parseGeneral(cfg *RawConfig) (*General, error) {
 	C.GeoSiteUrl = cfg.GeoXUrl.GeoSite
 	C.MmdbUrl = cfg.GeoXUrl.Mmdb
 	C.GeodataMode = cfg.GeodataMode
-	if cfg.KeepAliveInterval == 0 {
-		cfg.KeepAliveInterval = 30
-	}
-	N.KeepAliveInterval = time.Duration(cfg.KeepAliveInterval) * time.Second
-	log.Infoln("Keep Alive Interval set %+v", N.KeepAliveInterval)
 	// checkout externalUI exist
 	if externalUI != "" {
 		externalUI = C.Path.Resolve(externalUI)
@@ -608,7 +574,6 @@ func parseGeneral(cfg *RawConfig) (*General, error) {
 			RedirPort:         cfg.RedirPort,
 			TProxyPort:        cfg.TProxyPort,
 			MixedPort:         cfg.MixedPort,
-			MitmPort:          cfg.MitmPort,
 			ShadowSocksConfig: cfg.ShadowSocksConfig,
 			VmessConfig:       cfg.VmessConfig,
 			AllowLan:          cfg.AllowLan,
@@ -635,7 +600,6 @@ func parseGeneral(cfg *RawConfig) (*General, error) {
 		FindProcessMode:         cfg.FindProcessMode,
 		EBpf:                    cfg.EBpf,
 		GlobalClientFingerprint: cfg.GlobalClientFingerprint,
-		KeepAliveInterval:       cfg.KeepAliveInterval,
 	}, nil
 }
 
@@ -656,11 +620,6 @@ func parseProxies(cfg *RawConfig) (proxies map[string]C.Proxy, providersMap map[
 	proxies["PASS"] = adapter.NewProxy(outbound.NewPass())
 	proxyList = append(proxyList, "DIRECT", "REJECT")
 
-	if cfg.MITM.Port != 0 {
-		proxies["MITM"] = adapter.NewProxy(outbound.NewMitm(fmt.Sprintf("127.0.0.1:%d", cfg.MITM.Port)))
-		proxyList = append(proxyList, "MITM")
-	}
-
 	// parse proxy
 	for idx, mapping := range proxiesConfig {
 		proxy, err := adapter.ParseProxy(mapping)
@@ -941,14 +900,6 @@ func parseHosts(cfg *RawConfig) (*trie.DomainTrie[resolver.HostValue], error) {
 			_ = tree.Insert(domain, value)
 		}
 	}
-
-	if cfg.MITM.Port != 0 {
-		value, _ := resolver.NewHostValue("8.8.9.9")
-		if err := tree.Insert("mitm.clash", value); err != nil {
-			log.Errorln("insert mitm.clash to host error: %s", err.Error())
-		}
-	}
-
 	tree.Optimize()
 
 	return tree, nil
@@ -1497,28 +1448,3 @@ func parseSniffer(snifferRaw RawSniffer) (*Sniffer, error) {
 
 	return sniffer, nil
 }
-
-func parseMitm(rawMitm RawMitm) (*Mitm, error) {
-	var (
-		req []C.Rewrite
-		res []C.Rewrite
-	)
-
-	for _, line := range rawMitm.Rules {
-		rule, err := rewrites.ParseRewrite(line)
-		if err != nil {
-			return nil, fmt.Errorf("parse rewrite rule failure: %w", err)
-		}
-
-		if rule.RuleType() == C.MitmResponseHeader || rule.RuleType() == C.MitmResponseBody {
-			res = append(res, rule)
-		} else {
-			req = append(req, rule)
-		}
-	}
-
-	return &Mitm{
-		Port:  rawMitm.Port,
-		Rules: rewrites.NewRewriteRules(req, res),
-	}, nil
-}

constant/adapters.go

@@ -19,7 +19,6 @@ const (
 	Direct AdapterType = iota
 	Reject
 	Compatible
-	Mitm
 	Pass
 
 	Relay
@@ -183,8 +182,6 @@ func (at AdapterType) String() string {
 		return "Compatible"
 	case Pass:
 		return "Pass"
-	case Mitm:
-		return "Mitm"
 	case Shadowsocks:
 		return "Shadowsocks"
 	case ShadowsocksR:
@@ -270,17 +267,13 @@ type NatTable interface {
 
 	Delete(key string)
 
-	DeleteLock(key string)
+	GetLocalConn(lAddr, rAddr string) *net.UDPConn
 
-	GetForLocalConn(lAddr, rAddr string) *net.UDPConn
+	AddLocalConn(lAddr, rAddr string, conn *net.UDPConn) bool
 
-	AddForLocalConn(lAddr, rAddr string, conn *net.UDPConn) bool
+	RangeLocalConn(lAddr string, f func(key, value any) bool)
 
-	RangeForLocalConn(lAddr string, f func(key string, value *net.UDPConn) bool)
+	GetOrCreateLockForLocalConn(lAddr, key string) (*sync.Cond, bool)
 
-	GetOrCreateLockForLocalConn(lAddr string, key string) (*sync.Cond, bool)
-
-	DeleteForLocalConn(lAddr, key string)
-
-	DeleteLockForLocalConn(lAddr, key string)
+	DeleteLocalConnMap(lAddr, key string)
 }

constant/metadata.go

@@ -31,7 +31,6 @@ const (
 	TUN
 	TUIC
 	INNER
-	MITM
 )
 
 type NetWork int
@@ -81,8 +80,6 @@ func (t Type) String() string {
 		return "Tuic"
 	case INNER:
 		return "Inner"
-	case MITM:
-		return "Mitm"
 	default:
 		return "Unknown"
 	}
@@ -147,8 +144,6 @@ type Metadata struct {
 	RemoteDst    string     `json:"remoteDestination"`
 	// Only domain rule
 	SniffHost string `json:"sniffHost"`
-	// Only Mitm rule
-	UserAgent string `json:"userAgent"`
 }
 
 func (m *Metadata) RemoteAddress() string {
@@ -162,8 +157,6 @@ func (m *Metadata) SourceAddress() string {
 func (m *Metadata) SourceDetail() string {
 	if m.Type == INNER {
 		return fmt.Sprintf("%s", ClashName)
-	} else if m.Type == MITM {
-		return fmt.Sprintf("%s-MITM", ClashName)
 	}
 
 	switch {

constant/path.go

@@ -148,12 +148,8 @@ func (p *path) GeoSite() string {
 	return P.Join(p.homeDir, "GeoSite.dat")
 }
 
-func (p *path) RootCA() string {
-	return p.Resolve("mitm_ca.crt")
-}
-
-func (p *path) CAKey() string {
-	return p.Resolve("mitm_ca.key")
+func (p *path) GetAssetLocation(file string) string {
+	return P.Join(p.homeDir, file)
 }
 
 func (p *path) GetExecutableFullPath() string {

constant/rewrite.go

@@ -1,120 +0,0 @@
-package constant
-
-import (
-	"encoding/json"
-	"errors"
-	regexp "github.com/dlclark/regexp2"
-)
-
-var RewriteTypeMapping = map[string]RewriteType{
-	MitmReject.String():         MitmReject,
-	MitmReject200.String():      MitmReject200,
-	MitmRejectImg.String():      MitmRejectImg,
-	MitmRejectDict.String():     MitmRejectDict,
-	MitmRejectArray.String():    MitmRejectArray,
-	Mitm302.String():            Mitm302,
-	Mitm307.String():            Mitm307,
-	MitmRequestHeader.String():  MitmRequestHeader,
-	MitmRequestBody.String():    MitmRequestBody,
-	MitmResponseHeader.String(): MitmResponseHeader,
-	MitmResponseBody.String():   MitmResponseBody,
-}
-
-const (
-	MitmReject RewriteType = iota
-	MitmReject200
-	MitmRejectImg
-	MitmRejectDict
-	MitmRejectArray
-
-	Mitm302
-	Mitm307
-
-	MitmRequestHeader
-	MitmRequestBody
-
-	MitmResponseHeader
-	MitmResponseBody
-)
-
-type RewriteType int
-
-// UnmarshalYAML unserialize RewriteType with yaml
-func (e *RewriteType) UnmarshalYAML(unmarshal func(any) error) error {
-	var tp string
-	if err := unmarshal(&tp); err != nil {
-		return err
-	}
-	mode, exist := RewriteTypeMapping[tp]
-	if !exist {
-		return errors.New("invalid MITM Action")
-	}
-	*e = mode
-	return nil
-}
-
-// MarshalYAML serialize RewriteType with yaml
-func (e RewriteType) MarshalYAML() (any, error) {
-	return e.String(), nil
-}
-
-// UnmarshalJSON unserialize RewriteType with json
-func (e *RewriteType) UnmarshalJSON(data []byte) error {
-	var tp string
-	json.Unmarshal(data, &tp)
-	mode, exist := RewriteTypeMapping[tp]
-	if !exist {
-		return errors.New("invalid MITM Action")
-	}
-	*e = mode
-	return nil
-}
-
-// MarshalJSON serialize RewriteType with json
-func (e RewriteType) MarshalJSON() ([]byte, error) {
-	return json.Marshal(e.String())
-}
-
-func (rt RewriteType) String() string {
-	switch rt {
-	case MitmReject:
-		return "reject" // 404
-	case MitmReject200:
-		return "reject-200"
-	case MitmRejectImg:
-		return "reject-img"
-	case MitmRejectDict:
-		return "reject-dict"
-	case MitmRejectArray:
-		return "reject-array"
-	case Mitm302:
-		return "302"
-	case Mitm307:
-		return "307"
-	case MitmRequestHeader:
-		return "request-header"
-	case MitmRequestBody:
-		return "request-body"
-	case MitmResponseHeader:
-		return "response-header"
-	case MitmResponseBody:
-		return "response-body"
-	default:
-		return "Unknown"
-	}
-}
-
-type Rewrite interface {
-	ID() string
-	URLRegx() *regexp.Regexp
-	RuleType() RewriteType
-	RuleRegx() *regexp.Regexp
-	RulePayload() string
-	ReplaceURLPayload([]string) string
-	ReplaceSubPayload(string) string
-}
-
-type RewriteRule interface {
-	SearchInRequest(func(Rewrite) bool) bool
-	SearchInResponse(func(Rewrite) bool) bool
-}

constant/rule.go

@@ -23,7 +23,6 @@ const (
 	Network
 	Uid
 	SubRules
-	UserAgent
 	MATCH
 	AND
 	OR
@@ -68,8 +67,6 @@ func (rt RuleType) String() string {
 		return "Process"
 	case ProcessPath:
 		return "ProcessPath"
-	case UserAgent:
-		return "UserAgent"
 	case MATCH:
 		return "Match"
 	case RuleSet:

docs/config.yaml

@@ -50,8 +50,6 @@ external-ui: /path/to/ui/folder # 配置 WEB UI 目录，使用 http://{{externa
 # Utls is currently support TLS transport in TCP/grpc/WS/HTTP for VLESS/Vmess and trojan.
 global-client-fingerprint: chrome
 
-keep-alive-interval: 30
-
 # routing-mark:6666 # 配置 fwmark 仅用于 Linux
 experimental:
 

go.mod

@@ -12,7 +12,6 @@ require (
 	github.com/go-chi/chi/v5 v5.0.10
 	github.com/go-chi/cors v1.2.1
 	github.com/go-chi/render v1.0.3
-	github.com/gofrs/uuid v4.4.0+incompatible
 	github.com/gofrs/uuid/v5 v5.0.0
 	github.com/gorilla/websocket v1.5.0
 	github.com/insomniacslk/dhcp v0.0.0-20230731140434-0f9eb93a696c
@@ -31,7 +30,6 @@ require (
 	github.com/mroth/weightedrand/v2 v2.1.0
 	github.com/openacid/low v0.1.21
 	github.com/oschwald/maxminddb-golang v1.12.0
-	github.com/puzpuzpuz/xsync/v2 v2.5.0
 	github.com/sagernet/netlink v0.0.0-20220905062125-8043b4a9aa97
 	github.com/sagernet/sing v0.2.10-0.20230807080248-4db0062caa0a
 	github.com/sagernet/sing-mux v0.1.3-0.20230811111955-dc1639b5204c
@@ -45,14 +43,12 @@ require (
 	github.com/stretchr/testify v1.8.4
 	github.com/zhangyunhao116/fastrand v0.3.0
 	go.etcd.io/bbolt v1.3.7
-	go.uber.org/atomic v1.9.0
 	go.uber.org/automaxprocs v1.5.3
 	golang.org/x/crypto v0.12.0
 	golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb
 	golang.org/x/net v0.14.0
 	golang.org/x/sync v0.3.0
 	golang.org/x/sys v0.11.0
-	golang.org/x/text v0.12.0
 	google.golang.org/protobuf v1.31.0
 	gopkg.in/yaml.v3 v3.0.1
 	lukechampine.com/blake3 v1.2.1
@@ -103,6 +99,7 @@ require (
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
 	gitlab.com/yawning/bsaes.git v0.0.0-20190805113838-0a714cd429ec // indirect
 	golang.org/x/mod v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	golang.org/x/tools v0.9.1 // indirect
 )

go.sum

@@ -50,8 +50,6 @@ github.com/go-ole/go-ole v1.2.6 h1:/Fpf6oFPoeFik9ty7siob0G6Ke8QvQEuVcuChpwXzpY=
 github.com/go-ole/go-ole v1.2.6/go.mod h1:pprOEPIfldk/42T2oK7lQ4v4JSDwmV0As9GaiUsvbm0=
 github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 h1:tfuBGBXKqDEevZMzYi5KSi8KkcZtzBcTgAUUtapy0OI=
 github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572/go.mod h1:9Pwr4B2jHnOSGXyyzV8ROjYa2ojvAY6HCGYYfMoC3Ls=
-github.com/gofrs/uuid v4.4.0+incompatible h1:3qXRTX8/NbyulANqlc0lchS1gqAVxRgsuW1YrTJupqA=
-github.com/gofrs/uuid v4.4.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM=
 github.com/gofrs/uuid/v5 v5.0.0 h1:p544++a97kEL+svbcFbCQVM9KFu0Yo25UoISXGNNH9M=
 github.com/gofrs/uuid/v5 v5.0.0/go.mod h1:CDOjlDMVAtN56jqyRUZh58JT31Tiw7/oQyEXZV+9bD8=
 github.com/golang/mock v1.6.0 h1:ErTB+efbowRARo13NNdxyJji2egdxLGQhRaY+DUumQc=
@@ -136,8 +134,6 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw=
 github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c/go.mod h1:OmDBASR4679mdNQnz2pUhc2G8CO2JrUAVFDRBDP/hJE=
 github.com/prashantv/gostub v1.1.0 h1:BTyx3RfQjRHnUWaGF9oQos79AlQ5k8WNktv7VGvVH4g=
-github.com/puzpuzpuz/xsync/v2 v2.5.0 h1:2k4qrO/orvmEXZ3hmtHqIy9XaQtPTwzMZk1+iErpE8c=
-github.com/puzpuzpuz/xsync/v2 v2.5.0/go.mod h1:gD2H2krq/w52MfPLE+Uy64TzJDVY7lP2znR9qmR35kU=
 github.com/quic-go/qpack v0.4.0 h1:Cr9BXA1sQS2SmDUWjSofMPNKmvF6IiIfDRmgU0w1ZCo=
 github.com/quic-go/qpack v0.4.0/go.mod h1:UZVnYIfi5GRk+zI9UMaCPsmZ2xKJP7XBUvVyT1Knj9A=
 github.com/quic-go/qtls-go1-20 v0.3.2 h1:rRgN3WfnKbyik4dBV8A6girlJVxGand/d+jVKbQq5GI=
@@ -208,8 +204,6 @@ gitlab.com/yawning/bsaes.git v0.0.0-20190805113838-0a714cd429ec h1:FpfFs4EhNehiV
 gitlab.com/yawning/bsaes.git v0.0.0-20190805113838-0a714cd429ec/go.mod h1:BZ1RAoRPbCxum9Grlv5aeksu2H8BiKehBYooU2LFiOQ=
 go.etcd.io/bbolt v1.3.7 h1:j+zJOnnEjF/kyHlDDgGnVL/AIqIJPq8UoB2GSNfkUfQ=
 go.etcd.io/bbolt v1.3.7/go.mod h1:N9Mkw9X8x5fupy0IKsmuqVtoGDyxsaDlbk4Rd05IAQw=
-go.uber.org/atomic v1.9.0 h1:ECmE8Bn/WFTYwEW/bpKD3M8VtR/zQVbavAoalC1PYyE=
-go.uber.org/atomic v1.9.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
 go.uber.org/automaxprocs v1.5.3 h1:kWazyxZUrS3Gs4qUpbwo5kEIMGe/DAvi5Z4tl2NW4j8=
 go.uber.org/automaxprocs v1.5.3/go.mod h1:eRbA25aqJrxAbsLO0xy5jVwPt7FQnRgjW+efnwa1WM0=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=

hub/executor/executor.go

@@ -91,11 +91,10 @@ func ApplyConfig(cfg *config.Config, force bool) {
 	}
 
 	updateUsers(cfg.Users)
-	updateProxies(cfg.Mitm, cfg.Proxies, cfg.Providers)
+	updateProxies(cfg.Proxies, cfg.Providers)
 	updateRules(cfg.Rules, cfg.SubRules, cfg.RuleProviders)
 	updateSniffer(cfg.Sniffer)
 	updateHosts(cfg.Hosts)
-	updateMitm(cfg.Mitm)
 	updateGeneral(cfg.General)
 	updateNTP(cfg.NTP)
 	updateDNS(cfg.DNS, cfg.RuleProviders, cfg.General.IPv6)
@@ -135,8 +134,7 @@ func GetGeneral() *config.General {
 			RedirPort:         ports.RedirPort,
 			TProxyPort:        ports.TProxyPort,
 			MixedPort:         ports.MixedPort,
-			MitmPort:          ports.MitmPort,
-			Tun:               listener.GetTunConf(),
+			Tun:               listener.LastTunConf,
 			TuicServer:        listener.GetTuicConf(),
 			ShadowSocksConfig: ports.ShadowSocksConfig,
 			VmessConfig:       ports.VmessConfig,
@@ -264,7 +262,7 @@ func updateHosts(tree *trie.DomainTrie[resolver.HostValue]) {
 	resolver.DefaultHosts = resolver.NewHosts(tree)
 }
 
-func updateProxies(mitm *config.Mitm, proxies map[string]C.Proxy, providers map[string]provider.ProxyProvider) {
+func updateProxies(proxies map[string]C.Proxy, providers map[string]provider.ProxyProvider) {
 	tunnel.UpdateProxies(proxies, providers)
 }
 
@@ -492,13 +490,8 @@ func updateIPTables(cfg *config.Config) {
 	log.Infoln("[IPTABLES] Setting iptables completed")
 }
 
-func updateMitm(mitm *config.Mitm) {
-	listener.ReCreateMitm(mitm.Port, tunnel.TCPIn())
-	tunnel.UpdateRewrites(mitm.Rules)
-}
-
 func Shutdown() {
-	listener.Cleanup()
+	listener.Cleanup(false)
 	tproxy.CleanupTProxyIPTables()
 	resolver.StoreFakePoolState()
 

hub/route/configs.go

@@ -40,7 +40,6 @@ type configSchema struct {
 	RedirPort         *int               `json:"redir-port"`
 	TProxyPort        *int               `json:"tproxy-port"`
 	MixedPort         *int               `json:"mixed-port"`
-	MitmPort          *int               `json:"mitm-port"`
 	Tun               *tunSchema         `json:"tun"`
 	TuicServer        *tuicServerSchema  `json:"tuic-server"`
 	ShadowSocksConfig *string            `json:"ss-config"`
@@ -263,7 +262,6 @@ func patchConfigs(w http.ResponseWriter, r *http.Request) {
 	P.ReCreateShadowSocks(pointerOrDefaultString(general.ShadowSocksConfig, ports.ShadowSocksConfig), tcpIn, udpIn)
 	P.ReCreateVmess(pointerOrDefaultString(general.VmessConfig, ports.VmessConfig), tcpIn, udpIn)
 	P.ReCreateTuic(pointerOrDefaultTuicServer(general.TuicServer, P.LastTuicConf), tcpIn, udpIn)
-	P.ReCreateMitm(pointerOrDefault(general.MitmPort, ports.MitmPort), tcpIn)
 
 	if general.Mode != nil {
 		tunnel.SetMode(*general.Mode)

listener/autoredir/tcp.go

@@ -5,7 +5,6 @@ import (
 	"net/netip"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/log"
 	"github.com/Dreamacro/clash/transport/socks5"
@@ -56,7 +55,7 @@ func (l *Listener) handleRedir(conn net.Conn, in chan<- C.ConnContext) {
 		return
 	}
 
-	N.TCPKeepAlive(conn)
+	_ = conn.(*net.TCPConn).SetKeepAlive(true)
 
 	in <- inbound.NewSocket(target, conn, C.REDIR, l.additions...)
 }

listener/http/proxy.go

@@ -36,7 +36,7 @@ func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache[strin
 		var resp *http.Response
 
 		if !trusted {
-			resp = Authenticate(request, cache)
+			resp = authenticate(request, cache)
 
 			trusted = resp == nil
 		}
@@ -66,19 +66,19 @@ func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache[strin
 				return // hijack connection
 			}
 
-			RemoveHopByHopHeaders(request.Header)
-			RemoveExtraHTTPHostPort(request)
+			removeHopByHopHeaders(request.Header)
+			removeExtraHTTPHostPort(request)
 
 			if request.URL.Scheme == "" || request.URL.Host == "" {
-				resp = ResponseWith(request, http.StatusBadRequest)
+				resp = responseWith(request, http.StatusBadRequest)
 			} else {
 				resp, err = client.Do(request)
 				if err != nil {
-					resp = ResponseWith(request, http.StatusBadGateway)
+					resp = responseWith(request, http.StatusBadGateway)
 				}
 			}
 
-			RemoveHopByHopHeaders(resp.Header)
+			removeHopByHopHeaders(resp.Header)
 		}
 
 		if keepAlive {
@@ -98,12 +98,12 @@ func HandleConn(c net.Conn, in chan<- C.ConnContext, cache *cache.LruCache[strin
 	_ = conn.Close()
 }
 
-func Authenticate(request *http.Request, cache *cache.LruCache[string, bool]) *http.Response {
+func authenticate(request *http.Request, cache *cache.LruCache[string, bool]) *http.Response {
 	authenticator := authStore.Authenticator()
 	if authenticator != nil {
 		credential := parseBasicProxyAuthorization(request)
 		if credential == "" {
-			resp := ResponseWith(request, http.StatusProxyAuthRequired)
+			resp := responseWith(request, http.StatusProxyAuthRequired)
 			resp.Header.Set("Proxy-Authenticate", "Basic")
 			return resp
 		}
@@ -117,14 +117,14 @@ func Authenticate(request *http.Request, cache *cache.LruCache[string, bool]) *h
 		if !authed {
 			log.Infoln("Auth failed from %s", request.RemoteAddr)
 
-			return ResponseWith(request, http.StatusForbidden)
+			return responseWith(request, http.StatusForbidden)
 		}
 	}
 
 	return nil
 }
 
-func ResponseWith(request *http.Request, statusCode int) *http.Response {
+func responseWith(request *http.Request, statusCode int) *http.Response {
 	return &http.Response{
 		StatusCode: statusCode,
 		Status:     http.StatusText(statusCode),

listener/http/upgrade.go

@@ -6,7 +6,6 @@ import (
 	"net"
 	"net/http"
 	"strings"
-	"time"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
 	N "github.com/Dreamacro/clash/common/net"
@@ -30,7 +29,7 @@ func handleUpgrade(conn net.Conn, request *http.Request, in chan<- C.ConnContext
 	defer conn.Close()
 
 	removeProxyHeaders(request.Header)
-	RemoveExtraHTTPHostPort(request)
+	removeExtraHTTPHostPort(request)
 
 	address := request.Host
 	if _, _, err := net.SplitHostPort(address); err != nil {
@@ -88,65 +87,3 @@ func handleUpgrade(conn net.Conn, request *http.Request, in chan<- C.ConnContext
 		N.Relay(bufferedLeft, conn)
 	}
 }
-
-func HandleUpgradeY(localConn net.Conn, serverConn *N.BufferedConn, request *http.Request, in chan<- C.ConnContext) (resp *http.Response) {
-	removeProxyHeaders(request.Header)
-	RemoveExtraHTTPHostPort(request)
-
-	if serverConn == nil {
-		address := request.Host
-		if _, _, err := net.SplitHostPort(address); err != nil {
-			port := "80"
-			if request.TLS != nil {
-				port = "443"
-			}
-			address = net.JoinHostPort(address, port)
-		}
-
-		dstAddr := socks5.ParseAddr(address)
-		if dstAddr == nil {
-			return
-		}
-
-		left, right := net.Pipe()
-
-		in <- inbound.NewHTTP(dstAddr, localConn.RemoteAddr(), right)
-
-		serverConn = N.NewBufferedConn(left)
-
-		defer func() {
-			_ = serverConn.Close()
-		}()
-	}
-
-	err := request.Write(serverConn)
-	if err != nil {
-		_ = localConn.Close()
-		return
-	}
-
-	resp, err = http.ReadResponse(serverConn.Reader(), request)
-	if err != nil {
-		_ = localConn.Close()
-		return
-	}
-
-	if resp.StatusCode == http.StatusSwitchingProtocols {
-		removeProxyHeaders(resp.Header)
-
-		err = localConn.SetReadDeadline(time.Time{}) // set to not time out
-		if err != nil {
-			return
-		}
-
-		err = resp.Write(localConn)
-		if err != nil {
-			return
-		}
-
-		N.Relay(serverConn, localConn) // blocking here
-		_ = localConn.Close()
-		resp = nil
-	}
-	return
-}

listener/http/utils.go

@@ -15,8 +15,8 @@ func removeProxyHeaders(header http.Header) {
 	header.Del("Proxy-Authorization")
 }
 
-// RemoveHopByHopHeaders remove hop-by-hop header
-func RemoveHopByHopHeaders(header http.Header) {
+// removeHopByHopHeaders remove hop-by-hop header
+func removeHopByHopHeaders(header http.Header) {
 	// Strip hop-by-hop header based on RFC:
 	// http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html#sec13.5.1
 	// https://www.mnot.net/blog/2011/07/11/what_proxies_must_do
@@ -38,9 +38,9 @@ func RemoveHopByHopHeaders(header http.Header) {
 	}
 }
 
-// RemoveExtraHTTPHostPort remove extra host port (example.com:80 --> example.com)
+// removeExtraHTTPHostPort remove extra host port (example.com:80 --> example.com)
 // It resolves the behavior of some HTTP servers that do not handle host:80 (e.g. baidu.com)
-func RemoveExtraHTTPHostPort(req *http.Request) {
+func removeExtraHTTPHostPort(req *http.Request) {
 	host := req.Host
 	if host == "" {
 		host = req.URL.Host

listener/listener.go

@@ -1,26 +1,19 @@
 package listener
 
 import (
-	"crypto/rsa"
-	"crypto/tls"
-	"crypto/x509"
 	"fmt"
 	"golang.org/x/exp/slices"
 	"net"
-	"os"
 	"sort"
 	"strconv"
 	"strings"
 	"sync"
-	"time"
 
-	"github.com/Dreamacro/clash/common/cert"
 	"github.com/Dreamacro/clash/component/ebpf"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/listener/autoredir"
 	LC "github.com/Dreamacro/clash/listener/config"
 	"github.com/Dreamacro/clash/listener/http"
-	"github.com/Dreamacro/clash/listener/mitm"
 	"github.com/Dreamacro/clash/listener/mixed"
 	"github.com/Dreamacro/clash/listener/redir"
 	embedSS "github.com/Dreamacro/clash/listener/shadowsocks"
@@ -30,10 +23,9 @@ import (
 	"github.com/Dreamacro/clash/listener/socks"
 	"github.com/Dreamacro/clash/listener/tproxy"
 	"github.com/Dreamacro/clash/listener/tuic"
-	LT "github.com/Dreamacro/clash/listener/tunnel"
+	"github.com/Dreamacro/clash/listener/tunnel"
 	"github.com/Dreamacro/clash/log"
 
-	rewrites "github.com/Dreamacro/clash/rewrite"
 	"github.com/samber/lo"
 )
 
@@ -50,8 +42,8 @@ var (
 	tproxyUDPListener   *tproxy.UDPListener
 	mixedListener       *mixed.Listener
 	mixedUDPLister      *socks.UDPListener
-	tunnelTCPListeners  = map[string]*LT.Listener{}
-	tunnelUDPListeners  = map[string]*LT.PacketConn{}
+	tunnelTCPListeners  = map[string]*tunnel.Listener{}
+	tunnelUDPListeners  = map[string]*tunnel.PacketConn{}
 	inboundListeners    = map[string]C.InboundListener{}
 	tunLister           *sing_tun.Listener
 	shadowSocksListener C.MultiAddrListener
@@ -60,7 +52,6 @@ var (
 	autoRedirListener   *autoredir.Listener
 	autoRedirProgram    *ebpf.TcEBpfProgram
 	tcProgram           *ebpf.TcEBpfProgram
-	mitmListener        *mitm.Listener
 
 	// lock for recreate function
 	socksMux     sync.Mutex
@@ -76,7 +67,6 @@ var (
 	tuicMux      sync.Mutex
 	autoRedirMux sync.Mutex
 	tcMux        sync.Mutex
-	mitmMux      sync.Mutex
 
 	LastTunConf  LC.Tun
 	LastTuicConf LC.TuicServer
@@ -90,12 +80,13 @@ type Ports struct {
 	MixedPort         int    `json:"mixed-port"`
 	ShadowSocksConfig string `json:"ss-config"`
 	VmessConfig       string `json:"vmess-config"`
-	MitmPort          int    `json:"mitm-port"`
 }
 
 func GetTunConf() LC.Tun {
 	if tunLister == nil {
-		return LastTunConf
+		return LC.Tun{
+			Enable: false,
+		}
 	}
 	return tunLister.Config()
 }
@@ -526,6 +517,7 @@ func ReCreateTun(tunConf LC.Tun, tcpIn chan<- C.ConnContext, udpIn chan<- C.Pack
 		if err != nil {
 			log.Errorln("Start TUN listening error: %s", err.Error())
 			tunConf.Enable = false
+			Cleanup(false)
 		}
 	}()
 
@@ -536,7 +528,7 @@ func ReCreateTun(tunConf LC.Tun, tcpIn chan<- C.ConnContext, udpIn chan<- C.Pack
 		return
 	}
 
-	closeTunListener()
+	Cleanup(true)
 
 	if !tunConf.Enable {
 		return
@@ -710,7 +702,7 @@ func PatchTunnel(tunnels []LC.Tunnel, tcpIn chan<- C.ConnContext, udpIn chan<- C
 	for _, elm := range needCreate {
 		key := fmt.Sprintf("%s/%s/%s", elm.addr, elm.target, elm.proxy)
 		if elm.network == "tcp" {
-			l, err := LT.New(elm.addr, elm.target, elm.proxy, tcpIn)
+			l, err := tunnel.New(elm.addr, elm.target, elm.proxy, tcpIn)
 			if err != nil {
 				log.Errorln("Start tunnel %s error: %s", elm.target, err.Error())
 				continue
@@ -718,7 +710,7 @@ func PatchTunnel(tunnels []LC.Tunnel, tcpIn chan<- C.ConnContext, udpIn chan<- C
 			tunnelTCPListeners[key] = l
 			log.Infoln("Tunnel(tcp/%s) proxy %s listening at: %s", elm.target, elm.proxy, tunnelTCPListeners[key].Address())
 		} else {
-			l, err := LT.NewUDP(elm.addr, elm.target, elm.proxy, udpIn)
+			l, err := tunnel.NewUDP(elm.addr, elm.target, elm.proxy, udpIn)
 			if err != nil {
 				log.Errorln("Start tunnel %s error: %s", elm.target, err.Error())
 				continue
@@ -758,79 +750,6 @@ func PatchInboundListeners(newListenerMap map[string]C.InboundListener, tcpIn ch
 	}
 }
 
-func ReCreateMitm(port int, tcpIn chan<- C.ConnContext) {
-	mitmMux.Lock()
-	defer mitmMux.Unlock()
-
-	var err error
-	defer func() {
-		if err != nil {
-			log.Errorln("Start MITM server error: %s", err.Error())
-		}
-	}()
-
-	addr := genAddr(bindAddress, port, allowLan)
-
-	if mitmListener != nil {
-		if mitmListener.RawAddress() == addr {
-			return
-		}
-		_ = mitmListener.Close()
-		mitmListener = nil
-	}
-
-	if portIsZero(addr) {
-		return
-	}
-
-	if err = initCert(); err != nil {
-		return
-	}
-
-	var (
-		rootCACert tls.Certificate
-		x509c      *x509.Certificate
-		certOption *cert.Config
-	)
-
-	rootCACert, err = tls.LoadX509KeyPair(C.Path.RootCA(), C.Path.CAKey())
-	if err != nil {
-		return
-	}
-
-	privateKey := rootCACert.PrivateKey.(*rsa.PrivateKey)
-
-	x509c, err = x509.ParseCertificate(rootCACert.Certificate[0])
-	if err != nil {
-		return
-	}
-
-	certOption, err = cert.NewConfig(
-		x509c,
-		privateKey,
-	)
-	if err != nil {
-		return
-	}
-
-	certOption.SetValidity(time.Hour * 24 * 365 * 2) // 2 years
-	certOption.SetOrganization("Clash ManInTheMiddle Proxy Services")
-
-	opt := &mitm.Option{
-		Addr:       addr,
-		ApiHost:    "mitm.clash",
-		CertConfig: certOption,
-		Handler:    &rewrites.RewriteHandler{},
-	}
-
-	mitmListener, err = mitm.New(opt, tcpIn)
-	if err != nil {
-		return
-	}
-
-	log.Infoln("Mitm proxy listening at: %s", mitmListener.Address())
-}
-
 // GetPorts return the ports of proxy servers
 func GetPorts() *Ports {
 	ports := &Ports{}
@@ -873,12 +792,6 @@ func GetPorts() *Ports {
 		ports.VmessConfig = vmessListener.Config()
 	}
 
-	if mitmListener != nil {
-		_, portStr, _ := net.SplitHostPort(mitmListener.Address())
-		port, _ := strconv.Atoi(portStr)
-		ports.MitmPort = port
-	}
-
 	return ports
 }
 
@@ -985,26 +898,10 @@ func hasTunConfigChange(tunConf *LC.Tun) bool {
 	return false
 }
 
-func closeTunListener() {
+func Cleanup(wait bool) {
 	if tunLister != nil {
 		tunLister.Close()
 		tunLister = nil
 	}
-}
-
-func initCert() error {
-	if _, err := os.Stat(C.Path.RootCA()); os.IsNotExist(err) {
-		log.Infoln("Can't find mitm_ca.crt, start generate")
-		err = cert.GenerateAndSave(C.Path.RootCA(), C.Path.CAKey())
-		if err != nil {
-			return err
-		}
-		log.Infoln("Generated CA private key and CA certificate finish")
-	}
-
-	return nil
-}
-
-func Cleanup() {
-	closeTunListener()
+	LastTunConf = LC.Tun{}
 }

listener/mitm/client.go

@@ -1,55 +0,0 @@
-package mitm
-
-import (
-	"context"
-	"crypto/tls"
-	"net"
-	"net/http"
-
-	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/transport/socks5"
-)
-
-func getServerConn(serverConn *N.BufferedConn, request *http.Request, srcAddr net.Addr, in chan<- C.ConnContext) (*N.BufferedConn, error) {
-	if serverConn != nil {
-		return serverConn, nil
-	}
-
-	address := request.URL.Host
-	if _, _, err := net.SplitHostPort(address); err != nil {
-		port := "80"
-		if request.TLS != nil {
-			port = "443"
-		}
-		address = net.JoinHostPort(address, port)
-	}
-
-	dstAddr := socks5.ParseAddr(address)
-	if dstAddr == nil {
-		return nil, socks5.ErrAddressNotSupported
-	}
-
-	left, right := net.Pipe()
-
-	in <- inbound.NewMitm(dstAddr, srcAddr, request.Header.Get("User-Agent"), right)
-
-	if request.TLS != nil {
-		tlsConn := tls.Client(left, &tls.Config{
-			ServerName: request.TLS.ServerName,
-		})
-
-		ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
-		defer cancel()
-		if err := tlsConn.HandshakeContext(ctx); err != nil {
-			return nil, err
-		}
-
-		serverConn = N.NewBufferedConn(tlsConn)
-	} else {
-		serverConn = N.NewBufferedConn(left)
-	}
-
-	return serverConn, nil
-}

listener/mitm/hack.go

@@ -1,9 +0,0 @@
-package mitm
-
-import (
-	_ "net/http"
-	_ "unsafe"
-)
-
-//go:linkname validMethod net/http.validMethod
-func validMethod(method string) bool

listener/mitm/proxy.go

@@ -1,349 +0,0 @@
-package mitm
-
-import (
-	"bufio"
-	"bytes"
-	"context"
-	"crypto/tls"
-	"encoding/pem"
-	"fmt"
-	"io"
-	"net"
-	"net/http"
-	"net/netip"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/Dreamacro/clash/common/cache"
-	N "github.com/Dreamacro/clash/common/net"
-	C "github.com/Dreamacro/clash/constant"
-	H "github.com/Dreamacro/clash/listener/http"
-)
-
-func HandleConn(c net.Conn, opt *Option, in chan<- C.ConnContext, cache *cache.LruCache[string, bool]) {
-	var (
-		clientIP   = netip.MustParseAddrPort(c.RemoteAddr().String()).Addr()
-		sourceAddr net.Addr
-		serverConn *N.BufferedConn
-		connState  *tls.ConnectionState
-	)
-
-	defer func() {
-		if serverConn != nil {
-			_ = serverConn.Close()
-		}
-	}()
-
-	conn := N.NewBufferedConn(c)
-
-	trusted := cache == nil // disable authenticate if cache is nil
-	if !trusted {
-		trusted = clientIP.IsLoopback() || clientIP.IsUnspecified()
-	}
-
-readLoop:
-	for {
-		// use SetReadDeadline instead of Proxy-Connection keep-alive
-		if err := conn.SetReadDeadline(time.Now().Add(65 * time.Second)); err != nil {
-			break
-		}
-
-		request, err := H.ReadRequest(conn.Reader())
-		if err != nil {
-			break
-		}
-
-		var response *http.Response
-
-		session := newSession(conn, request, response)
-
-		sourceAddr = parseSourceAddress(session.request, conn.RemoteAddr(), sourceAddr)
-		session.request.RemoteAddr = sourceAddr.String()
-
-		if !trusted {
-			session.response = H.Authenticate(session.request, cache)
-
-			trusted = session.response == nil
-		}
-
-		if trusted {
-			if session.request.Method == http.MethodConnect {
-				if session.request.ProtoMajor > 1 {
-					session.request.ProtoMajor = 1
-					session.request.ProtoMinor = 1
-				}
-
-				// Manual writing to support CONNECT for http 1.0 (workaround for uplay client)
-				if _, err = fmt.Fprintf(session.conn, "HTTP/%d.%d %03d %s\r\n\r\n", session.request.ProtoMajor, session.request.ProtoMinor, http.StatusOK, "Connection established"); err != nil {
-					handleError(opt, session, err)
-					break // close connection
-				}
-
-				if strings.HasSuffix(session.request.URL.Host, ":80") {
-					goto readLoop
-				}
-
-				b, err1 := conn.Peek(1)
-				if err1 != nil {
-					handleError(opt, session, err1)
-					break // close connection
-				}
-
-				// TLS handshake.
-				if b[0] == 0x16 {
-					tlsConn := tls.Server(conn, opt.CertConfig.NewTLSConfigForHost(session.request.URL.Hostname()))
-
-					ctx, cancel := context.WithTimeout(context.Background(), C.DefaultTLSTimeout)
-					// handshake with the local client
-					if err = tlsConn.HandshakeContext(ctx); err != nil {
-						cancel()
-						session.response = session.NewErrorResponse(fmt.Errorf("handshake failed: %w", err))
-						_ = writeResponse(session, false)
-						break // close connection
-					}
-					cancel()
-
-					cs := tlsConn.ConnectionState()
-					connState = &cs
-
-					conn = N.NewBufferedConn(tlsConn)
-				}
-
-				if strings.HasSuffix(session.request.URL.Host, ":443") {
-					goto readLoop
-				}
-
-				if conn.SetReadDeadline(time.Now().Add(time.Second)) != nil {
-					break
-				}
-
-				buf, err2 := conn.Peek(7)
-				if err2 != nil {
-					if err2 != bufio.ErrBufferFull && !os.IsTimeout(err2) {
-						handleError(opt, session, err2)
-						break // close connection
-					}
-				}
-
-				// others protocol over tcp
-				if !isHTTPTraffic(buf) {
-					if connState != nil {
-						session.request.TLS = connState
-					}
-
-					serverConn, err = getServerConn(serverConn, session.request, sourceAddr, in)
-					if err != nil {
-						break
-					}
-
-					if conn.SetReadDeadline(time.Time{}) != nil {
-						break
-					}
-
-					N.Relay(serverConn, conn)
-					return // hijack connection
-				}
-
-				goto readLoop
-			}
-
-			prepareRequest(connState, session.request)
-
-			// hijack api
-			if session.request.URL.Hostname() == opt.ApiHost {
-				if err = handleApiRequest(session, opt); err != nil {
-					handleError(opt, session, err)
-				}
-				break
-			}
-
-			// forward websocket
-			if isWebsocketRequest(request) {
-				serverConn, err = getServerConn(serverConn, session.request, sourceAddr, in)
-				if err != nil {
-					break
-				}
-
-				session.request.RequestURI = ""
-				if session.response = H.HandleUpgradeY(conn, serverConn, request, in); session.response == nil {
-					return // hijack connection
-				}
-			}
-
-			if session.response == nil {
-				H.RemoveHopByHopHeaders(session.request.Header)
-				H.RemoveExtraHTTPHostPort(session.request)
-
-				// hijack custom request and write back custom response if necessary
-				newReq, newRes := opt.Handler.HandleRequest(session)
-				if newReq != nil {
-					session.request = newReq
-				}
-				if newRes != nil {
-					session.response = newRes
-
-					if err = writeResponse(session, false); err != nil {
-						handleError(opt, session, err)
-						break
-					}
-					continue
-				}
-
-				session.request.RequestURI = ""
-
-				if session.request.URL.Host == "" {
-					session.response = session.NewErrorResponse(ErrInvalidURL)
-				} else {
-					serverConn, err = getServerConn(serverConn, session.request, sourceAddr, in)
-					if err != nil {
-						break
-					}
-
-					// send the request to remote server
-					err = session.request.Write(serverConn)
-					if err != nil {
-						break
-					}
-
-					session.response, err = http.ReadResponse(serverConn.Reader(), request)
-					if err != nil {
-						break
-					}
-				}
-			}
-		}
-
-		if err = writeResponseWithHandler(session, opt); err != nil {
-			handleError(opt, session, err)
-			break // close connection
-		}
-	}
-
-	_ = conn.Close()
-}
-
-func writeResponseWithHandler(session *Session, opt *Option) error {
-	res := opt.Handler.HandleResponse(session)
-	if res != nil {
-		session.response = res
-	}
-
-	return writeResponse(session, true)
-}
-
-func writeResponse(session *Session, keepAlive bool) error {
-	H.RemoveHopByHopHeaders(session.response.Header)
-
-	if keepAlive {
-		session.response.Header.Set("Connection", "keep-alive")
-		session.response.Header.Set("Keep-Alive", "timeout=60")
-	}
-
-	return session.writeResponse()
-}
-
-func handleApiRequest(session *Session, opt *Option) error {
-	if opt.CertConfig != nil && strings.ToLower(session.request.URL.Path) == "/cert.crt" {
-		b := pem.EncodeToMemory(&pem.Block{
-			Type:  "CERTIFICATE",
-			Bytes: opt.CertConfig.GetCA().Raw,
-		})
-
-		session.response = session.NewResponse(http.StatusOK, bytes.NewReader(b))
-
-		session.response.Close = true
-		session.response.Header.Set("Content-Type", "application/x-x509-ca-cert")
-		session.response.ContentLength = int64(len(b))
-
-		return session.writeResponse()
-	}
-
-	b := `<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
-<html><head>
-<title>Clash MITM Proxy Services - 404 Not Found</title>
-</head><body>
-<h1>Not Found</h1>
-<p>The requested URL %s was not found on this server.</p>
-</body></html>
-`
-
-	if opt.Handler.HandleApiRequest(session) {
-		return nil
-	}
-
-	b = fmt.Sprintf(b, session.request.URL.Path)
-
-	session.response = session.NewResponse(http.StatusNotFound, bytes.NewReader([]byte(b)))
-	session.response.Close = true
-	session.response.Header.Set("Content-Type", "text/html;charset=utf-8")
-	session.response.ContentLength = int64(len(b))
-
-	return session.writeResponse()
-}
-
-func handleError(opt *Option, session *Session, err error) {
-	if session.response != nil {
-		defer func() {
-			_, _ = io.Copy(io.Discard, session.response.Body)
-			_ = session.response.Body.Close()
-		}()
-	}
-	opt.Handler.HandleError(session, err)
-}
-
-func prepareRequest(connState *tls.ConnectionState, request *http.Request) {
-	host := request.Header.Get("Host")
-	if host != "" {
-		request.Host = host
-	}
-
-	if request.URL.Host == "" {
-		request.URL.Host = request.Host
-	}
-
-	if request.URL.Scheme == "" {
-		request.URL.Scheme = "http"
-	}
-
-	if connState != nil {
-		request.TLS = connState
-		request.URL.Scheme = "https"
-	}
-
-	if request.Header.Get("Accept-Encoding") != "" {
-		request.Header.Set("Accept-Encoding", "gzip")
-	}
-}
-
-func parseSourceAddress(req *http.Request, connSource, source net.Addr) net.Addr {
-	if source != nil {
-		return source
-	}
-
-	sourceAddress := req.Header.Get("Origin-Request-Source-Address")
-	if sourceAddress == "" {
-		return connSource
-	}
-
-	req.Header.Del("Origin-Request-Source-Address")
-
-	addrPort, err := netip.ParseAddrPort(sourceAddress)
-	if err != nil {
-		return connSource
-	}
-
-	return &net.TCPAddr{
-		IP:   addrPort.Addr().AsSlice(),
-		Port: int(addrPort.Port()),
-	}
-}
-
-func isWebsocketRequest(req *http.Request) bool {
-	return strings.EqualFold(req.Header.Get("Connection"), "Upgrade") && strings.EqualFold(req.Header.Get("Upgrade"), "websocket")
-}
-
-func isHTTPTraffic(buf []byte) bool {
-	method, _, _ := strings.Cut(string(buf), " ")
-	return validMethod(method)
-}

listener/mitm/server.go

@@ -1,88 +0,0 @@
-package mitm
-
-import (
-	"crypto/tls"
-	"github.com/Dreamacro/clash/common/cache"
-	"github.com/Dreamacro/clash/common/cert"
-	C "github.com/Dreamacro/clash/constant"
-	"net"
-	"net/http"
-)
-
-type Handler interface {
-	HandleRequest(*Session) (*http.Request, *http.Response) // Session.Response maybe nil
-	HandleResponse(*Session) *http.Response
-	HandleApiRequest(*Session) bool
-	HandleError(*Session, error) // Session maybe nil
-}
-
-type Option struct {
-	Addr    string
-	ApiHost string
-
-	TLSConfig  *tls.Config
-	CertConfig *cert.Config
-
-	Handler Handler
-}
-
-type Listener struct {
-	*Option
-
-	listener net.Listener
-	addr     string
-	closed   bool
-}
-
-// RawAddress implements C.Listener
-func (l *Listener) RawAddress() string {
-	return l.addr
-}
-
-// Address implements C.Listener
-func (l *Listener) Address() string {
-	return l.listener.Addr().String()
-}
-
-// Close implements C.Listener
-func (l *Listener) Close() error {
-	l.closed = true
-	return l.listener.Close()
-}
-
-// New the MITM proxy actually is a type of HTTP proxy
-func New(option *Option, in chan<- C.ConnContext) (*Listener, error) {
-	return NewWithAuthenticate(option, in, true)
-}
-
-func NewWithAuthenticate(option *Option, in chan<- C.ConnContext, authenticate bool) (*Listener, error) {
-	l, err := net.Listen("tcp", option.Addr)
-	if err != nil {
-		return nil, err
-	}
-
-	var c *cache.LruCache[string, bool]
-	if authenticate {
-		c = cache.New[string, bool](cache.WithAge[string, bool](90))
-	}
-
-	hl := &Listener{
-		listener: l,
-		addr:     option.Addr,
-		Option:   option,
-	}
-	go func() {
-		for {
-			conn, err1 := hl.listener.Accept()
-			if err1 != nil {
-				if hl.closed {
-					break
-				}
-				continue
-			}
-			go HandleConn(conn, option, in, c)
-		}
-	}()
-
-	return hl, nil
-}

listener/mitm/session.go

@@ -1,59 +0,0 @@
-package mitm
-
-import (
-	"io"
-	"net"
-	"net/http"
-)
-
-type Session struct {
-	conn     net.Conn
-	request  *http.Request
-	response *http.Response
-
-	props map[string]any
-}
-
-func (s *Session) Request() *http.Request {
-	return s.request
-}
-
-func (s *Session) Response() *http.Response {
-	return s.response
-}
-
-func (s *Session) GetProperties(key string) (any, bool) {
-	v, ok := s.props[key]
-	return v, ok
-}
-
-func (s *Session) SetProperties(key string, val any) {
-	s.props[key] = val
-}
-
-func (s *Session) NewResponse(code int, body io.Reader) *http.Response {
-	return NewResponse(code, body, s.request)
-}
-
-func (s *Session) NewErrorResponse(err error) *http.Response {
-	return NewErrorResponse(s.request, err)
-}
-
-func (s *Session) writeResponse() error {
-	if s.response == nil {
-		return ErrInvalidResponse
-	}
-	defer func(resp *http.Response) {
-		_ = resp.Body.Close()
-	}(s.response)
-	return s.response.Write(s.conn)
-}
-
-func newSession(conn net.Conn, request *http.Request, response *http.Response) *Session {
-	return &Session{
-		conn:     conn,
-		request:  request,
-		response: response,
-		props:    map[string]any{},
-	}
-}

listener/mitm/utils.go

@@ -1,95 +0,0 @@
-package mitm
-
-import (
-	"bytes"
-	"compress/gzip"
-	"errors"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"net/http"
-	"time"
-
-	"golang.org/x/text/encoding/charmap"
-	"golang.org/x/text/transform"
-)
-
-var (
-	ErrInvalidResponse = errors.New("invalid response")
-	ErrInvalidURL      = errors.New("invalid URL")
-)
-
-func NewResponse(code int, body io.Reader, req *http.Request) *http.Response {
-	if body == nil {
-		body = &bytes.Buffer{}
-	}
-
-	rc, ok := body.(io.ReadCloser)
-	if !ok {
-		rc = ioutil.NopCloser(body)
-	}
-
-	res := &http.Response{
-		StatusCode: code,
-		Status:     fmt.Sprintf("%d %s", code, http.StatusText(code)),
-		Proto:      "HTTP/1.1",
-		ProtoMajor: 1,
-		ProtoMinor: 1,
-		Header:     http.Header{},
-		Body:       rc,
-		Request:    req,
-	}
-
-	if req != nil {
-		res.Close = req.Close
-		res.Proto = req.Proto
-		res.ProtoMajor = req.ProtoMajor
-		res.ProtoMinor = req.ProtoMinor
-	}
-
-	return res
-}
-
-func NewErrorResponse(req *http.Request, err error) *http.Response {
-	res := NewResponse(http.StatusBadGateway, nil, req)
-	res.Close = true
-
-	date := res.Header.Get("Date")
-	if date == "" {
-		date = time.Now().Format(http.TimeFormat)
-	}
-
-	w := fmt.Sprintf(`199 "clash" %q %q`, err.Error(), date)
-	res.Header.Add("Warning", w)
-	return res
-}
-
-func ReadDecompressedBody(res *http.Response) ([]byte, error) {
-	rBody := res.Body
-	if res.Header.Get("Content-Encoding") == "gzip" {
-		gzReader, err := gzip.NewReader(rBody)
-		if err != nil {
-			return nil, err
-		}
-		rBody = gzReader
-
-		defer func(gzReader *gzip.Reader) {
-			_ = gzReader.Close()
-		}(gzReader)
-	}
-	return ioutil.ReadAll(rBody)
-}
-
-func DecodeLatin1(reader io.Reader) (string, error) {
-	r := transform.NewReader(reader, charmap.ISO8859_1.NewDecoder())
-	b, err := ioutil.ReadAll(r)
-	if err != nil {
-		return "", err
-	}
-
-	return string(b), nil
-}
-
-func EncodeLatin1(str string) ([]byte, error) {
-	return charmap.ISO8859_1.NewEncoder().Bytes([]byte(str))
-}

listener/mixed/mixed.go

@@ -1,9 +1,9 @@
 package mixed
 
 import (
+	"github.com/Dreamacro/clash/adapter/inbound"
 	"net"
 
-	"github.com/Dreamacro/clash/adapter/inbound"
 	"github.com/Dreamacro/clash/common/cache"
 	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
@@ -70,7 +70,7 @@ func New(addr string, in chan<- C.ConnContext, additions ...inbound.Addition) (*
 }
 
 func handleConn(conn net.Conn, in chan<- C.ConnContext, cache *cache.LruCache[string, bool], additions ...inbound.Addition) {
-	N.TCPKeepAlive(conn)
+	conn.(*net.TCPConn).SetKeepAlive(true)
 
 	bufConn := N.NewBufferedConn(conn)
 	head, err := bufConn.Peek(1)

listener/redir/tcp.go

@@ -4,7 +4,6 @@ import (
 	"net"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 )
 
@@ -67,6 +66,6 @@ func handleRedir(conn net.Conn, in chan<- C.ConnContext, additions ...inbound.Ad
 		conn.Close()
 		return
 	}
-	N.TCPKeepAlive(conn)
+	conn.(*net.TCPConn).SetKeepAlive(true)
 	in <- inbound.NewSocket(target, conn, C.REDIR, additions...)
 }

listener/shadowsocks/tcp.go

@@ -59,7 +59,7 @@ func New(config LC.ShadowsocksServer, tcpIn chan<- C.ConnContext, udpIn chan<- C
 					}
 					continue
 				}
-				N.TCPKeepAlive(c)
+				_ = c.(*net.TCPConn).SetKeepAlive(true)
 				go sl.HandleConn(c, tcpIn)
 			}
 		}()

listener/sing_shadowsocks/server.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
 	"github.com/Dreamacro/clash/common/sockopt"
 	C "github.com/Dreamacro/clash/constant"
 	LC "github.com/Dreamacro/clash/listener/config"
@@ -146,7 +145,7 @@ func New(config LC.ShadowsocksServer, tcpIn chan<- C.ConnContext, udpIn chan<- C
 					}
 					continue
 				}
-				N.TCPKeepAlive(c)
+				_ = c.(*net.TCPConn).SetKeepAlive(true)
 
 				go sl.HandleConn(c, tcpIn)
 			}

listener/sing_vmess/server.go

@@ -7,7 +7,6 @@ import (
 	"strings"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 	LC "github.com/Dreamacro/clash/listener/config"
 	"github.com/Dreamacro/clash/listener/sing"
@@ -85,7 +84,7 @@ func New(config LC.VmessServer, tcpIn chan<- C.ConnContext, udpIn chan<- C.Packe
 					}
 					continue
 				}
-				N.TCPKeepAlive(c)
+				_ = c.(*net.TCPConn).SetKeepAlive(true)
 
 				go sl.HandleConn(c, tcpIn)
 			}

listener/socks/tcp.go

@@ -67,7 +67,7 @@ func New(addr string, in chan<- C.ConnContext, additions ...inbound.Addition) (*
 }
 
 func handleSocks(conn net.Conn, in chan<- C.ConnContext, additions ...inbound.Addition) {
-	N.TCPKeepAlive(conn)
+	conn.(*net.TCPConn).SetKeepAlive(true)
 	bufConn := N.NewBufferedConn(conn)
 	head, err := bufConn.Peek(1)
 	if err != nil {

listener/tproxy/packet.go

@@ -55,15 +55,16 @@ func (c *packet) InAddr() net.Addr {
 func createOrGetLocalConn(rAddr, lAddr net.Addr, in chan<- C.PacketAdapter, natTable C.NatTable) (*net.UDPConn, error) {
 	remote := rAddr.String()
 	local := lAddr.String()
-	localConn := natTable.GetForLocalConn(local, remote)
+	localConn := natTable.GetLocalConn(local, remote)
 	// localConn not exist
 	if localConn == nil {
-		cond, loaded := natTable.GetOrCreateLockForLocalConn(local, remote)
+		lockKey := remote + "-lock"
+		cond, loaded := natTable.GetOrCreateLockForLocalConn(local, lockKey)
 		if loaded {
 			cond.L.Lock()
 			cond.Wait()
 			// we should get localConn here
-			localConn = natTable.GetForLocalConn(local, remote)
+			localConn = natTable.GetLocalConn(local, remote)
 			if localConn == nil {
 				return nil, fmt.Errorf("localConn is nil, nat entry not exist")
 			}
@@ -73,7 +74,7 @@ func createOrGetLocalConn(rAddr, lAddr net.Addr, in chan<- C.PacketAdapter, natT
 				return nil, fmt.Errorf("cond is nil, nat entry not exist")
 			}
 			defer func() {
-				natTable.DeleteLockForLocalConn(local, remote)
+				natTable.DeleteLocalConnMap(local, lockKey)
 				cond.Broadcast()
 			}()
 			conn, err := listenLocalConn(rAddr, lAddr, in, natTable)
@@ -81,7 +82,7 @@ func createOrGetLocalConn(rAddr, lAddr net.Addr, in chan<- C.PacketAdapter, natT
 				log.Errorln("listenLocalConn failed with error: %s, packet loss (rAddr[%T]=%s lAddr[%T]=%s)", err.Error(), rAddr, remote, lAddr, local)
 				return nil, err
 			}
-			natTable.AddForLocalConn(local, remote, conn)
+			natTable.AddLocalConn(local, remote, conn)
 			localConn = conn
 		}
 	}

listener/tproxy/tproxy.go

@@ -4,7 +4,6 @@ import (
 	"net"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/transport/socks5"
 )
@@ -33,7 +32,7 @@ func (l *Listener) Close() error {
 
 func (l *Listener) handleTProxy(conn net.Conn, in chan<- C.ConnContext, additions ...inbound.Addition) {
 	target := socks5.ParseAddrToSocksAddr(conn.LocalAddr())
-	N.TCPKeepAlive(conn)
+	conn.(*net.TCPConn).SetKeepAlive(true)
 	in <- inbound.NewSocket(target, conn, C.TPROXY, additions...)
 }
 

listener/tunnel/tcp.go

@@ -5,7 +5,6 @@ import (
 	"net"
 
 	"github.com/Dreamacro/clash/adapter/inbound"
-	N "github.com/Dreamacro/clash/common/net"
 	C "github.com/Dreamacro/clash/constant"
 	"github.com/Dreamacro/clash/transport/socks5"
 )
@@ -35,7 +34,7 @@ func (l *Listener) Close() error {
 }
 
 func (l *Listener) handleTCP(conn net.Conn, in chan<- C.ConnContext, additions ...inbound.Addition) {
-	N.TCPKeepAlive(conn)
+	conn.(*net.TCPConn).SetKeepAlive(true)
 	ctx := inbound.NewSocket(l.target, conn, C.TUNNEL, additions...)
 	ctx.Metadata().SpecialProxy = l.proxy
 	in <- ctx

ntp/service.go

@@ -17,7 +17,7 @@ type Service struct {
 	ticker   *time.Ticker
 	ctx      context.Context
 	cancel   context.CancelFunc
-	mu       sync.Mutex
+	mu       *sync.Mutex
 	running  bool
 }
 
@@ -26,7 +26,7 @@ func ReCreateNTPService(addr string, interval time.Duration) {
 		service.Stop()
 	}
 	ctx, cancel := context.WithCancel(context.Background())
-	service = &Service{addr: addr, interval: interval, ctx: ctx, cancel: cancel}
+	service = &Service{addr: addr, interval: interval, ctx: ctx, cancel: cancel, mu: &sync.Mutex{}}
 	service.Start()
 }
 
@@ -40,7 +40,7 @@ func (srv *Service) Start() {
 		for {
 			err := srv.updateTime(srv.addr)
 			if err != nil {
-				log.Warnln("updateTime failed: %s", err)
+				log.Warnln("updateTime failed:", err)
 			}
 			select {
 			case <-srv.ticker.C:
@@ -54,20 +54,9 @@ func (srv *Service) Start() {
 func (srv *Service) Stop() {
 	srv.mu.Lock()
 	defer srv.mu.Unlock()
-	if service.running {
-		srv.ticker.Stop()
-		srv.cancel()
-		service.running = false
-	}
-}
-
-func (srv *Service) Running() bool {
-	if srv == nil {
-		return false
-	}
-	srv.mu.Lock()
-	defer srv.mu.Unlock()
-	return srv.running
+	srv.ticker.Stop()
+	srv.cancel()
+	service.running = false
 }
 
 func (srv *Service) updateTime(addr string) error {
@@ -79,16 +68,16 @@ func (srv *Service) updateTime(addr string) error {
 	ntpTime := response.Time
 	offset = localTime.Sub(ntpTime)
 	if offset > time.Duration(0) {
-		log.Warnln("System clock is ahead of NTP time by %s", offset)
+		log.Warnln("System clock is ahead of NTP time by", offset)
 	} else if offset < time.Duration(0) {
-		log.Warnln("System clock is behind NTP time by %s", -offset)
+		log.Warnln("System clock is behind NTP time by", -offset)
 	}
 	return nil
 }
 
 func Now() time.Time {
 	now := time.Now()
-	if service.Running() && offset.Abs() > 0 {
+	if service.running && offset.Abs() > 0 {
 		now = now.Add(offset)
 	}
 	return now

rewrite/base.go

@@ -1,72 +0,0 @@
-package rewrites
-
-import (
-	"bytes"
-	"io"
-	"io/ioutil"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-var (
-	EmptyDict   = NewResponseBody([]byte("{}"))
-	EmptyArray  = NewResponseBody([]byte("[]"))
-	OnePixelPNG = NewResponseBody([]byte{0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a, 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x08, 0x06, 0x00, 0x00, 0x00, 0x1f, 0x15, 0xc4, 0x89, 0x00, 0x00, 0x00, 0x11, 0x49, 0x44, 0x41, 0x54, 0x78, 0x9c, 0x62, 0x62, 0x60, 0x60, 0x60, 0x00, 0x04, 0x00, 0x00, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x03, 0xfe, 0x8f, 0xeb, 0xcf, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae, 0x42, 0x60, 0x82})
-)
-
-type Body interface {
-	Body() io.ReadCloser
-	ContentLength() int64
-}
-
-type ResponseBody struct {
-	data   []byte
-	length int64
-}
-
-func (r *ResponseBody) Body() io.ReadCloser {
-	return ioutil.NopCloser(bytes.NewReader(r.data))
-}
-
-func (r *ResponseBody) ContentLength() int64 {
-	return r.length
-}
-
-func NewResponseBody(data []byte) *ResponseBody {
-	return &ResponseBody{
-		data:   data,
-		length: int64(len(data)),
-	}
-}
-
-type RewriteRules struct {
-	request  []C.Rewrite
-	response []C.Rewrite
-}
-
-func (rr *RewriteRules) SearchInRequest(do func(C.Rewrite) bool) bool {
-	for _, v := range rr.request {
-		if do(v) {
-			return true
-		}
-	}
-	return false
-}
-
-func (rr *RewriteRules) SearchInResponse(do func(C.Rewrite) bool) bool {
-	for _, v := range rr.response {
-		if do(v) {
-			return true
-		}
-	}
-	return false
-}
-
-func NewRewriteRules(req []C.Rewrite, res []C.Rewrite) *RewriteRules {
-	return &RewriteRules{
-		request:  req,
-		response: res,
-	}
-}
-
-var _ C.RewriteRule = (*RewriteRules)(nil)

rewrite/handler.go

@@ -1,212 +0,0 @@
-package rewrites
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	log "github.com/sirupsen/logrus"
-	"io"
-	"net/http"
-	"net/textproto"
-	"strconv"
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-	"github.com/Dreamacro/clash/listener/mitm"
-	"github.com/Dreamacro/clash/tunnel"
-)
-
-var _ mitm.Handler = (*RewriteHandler)(nil)
-
-type RewriteHandler struct{}
-
-func (*RewriteHandler) HandleRequest(session *mitm.Session) (*http.Request, *http.Response) {
-	var (
-		request  = session.Request()
-		response *http.Response
-	)
-
-	rule, sub, found := matchRewriteRule(request.URL.String(), true)
-	if !found {
-		return nil, nil
-	}
-
-	log.Infof("[MITM] %s <- request %s", rule.RuleType().String(), request.URL.String())
-
-	switch rule.RuleType() {
-	case C.MitmReject:
-		response = session.NewResponse(http.StatusNotFound, nil)
-		response.Header.Set("Content-Type", "text/html; charset=utf-8")
-	case C.MitmReject200:
-		response = session.NewResponse(http.StatusOK, nil)
-		response.Header.Set("Content-Type", "text/html; charset=utf-8")
-	case C.MitmRejectImg:
-		response = session.NewResponse(http.StatusOK, OnePixelPNG.Body())
-		response.Header.Set("Content-Type", "image/png")
-		response.ContentLength = OnePixelPNG.ContentLength()
-	case C.MitmRejectDict:
-		response = session.NewResponse(http.StatusOK, EmptyDict.Body())
-		response.Header.Set("Content-Type", "application/json; charset=utf-8")
-		response.ContentLength = EmptyDict.ContentLength()
-	case C.MitmRejectArray:
-		response = session.NewResponse(http.StatusOK, EmptyArray.Body())
-		response.Header.Set("Content-Type", "application/json; charset=utf-8")
-		response.ContentLength = EmptyArray.ContentLength()
-	case C.Mitm302:
-		response = session.NewResponse(http.StatusFound, nil)
-		response.Header.Set("Location", rule.ReplaceURLPayload(sub))
-	case C.Mitm307:
-		response = session.NewResponse(http.StatusTemporaryRedirect, nil)
-		response.Header.Set("Location", rule.ReplaceURLPayload(sub))
-	case C.MitmRequestHeader:
-		if len(request.Header) == 0 {
-			return nil, nil
-		}
-
-		rawHeader := &bytes.Buffer{}
-		oldHeader := request.Header
-		if err := oldHeader.Write(rawHeader); err != nil {
-			return nil, nil
-		}
-
-		newRawHeader := rule.ReplaceSubPayload(rawHeader.String())
-		tb := textproto.NewReader(bufio.NewReader(strings.NewReader(newRawHeader)))
-		newHeader, err := tb.ReadMIMEHeader()
-		if err != nil && !errors.Is(err, io.EOF) {
-			return nil, nil
-		}
-		request.Header = http.Header(newHeader)
-	case C.MitmRequestBody:
-		if !CanRewriteBody(request.ContentLength, request.Header.Get("Content-Type")) {
-			return nil, nil
-		}
-
-		buf := make([]byte, request.ContentLength)
-		_, err := io.ReadFull(request.Body, buf)
-		if err != nil {
-			return nil, nil
-		}
-
-		newBody := rule.ReplaceSubPayload(string(buf))
-		request.Body = io.NopCloser(strings.NewReader(newBody))
-		request.ContentLength = int64(len(newBody))
-	default:
-		found = false
-	}
-
-	if found {
-		if response != nil {
-			response.Close = true
-		}
-		return request, response
-	}
-	return nil, nil
-}
-
-func (*RewriteHandler) HandleResponse(session *mitm.Session) *http.Response {
-	var (
-		request  = session.Request()
-		response = session.Response()
-	)
-
-	rule, _, found := matchRewriteRule(request.URL.String(), false)
-	found = found && rule.RuleRegx() != nil
-	if !found {
-		return nil
-	}
-
-	log.Infof("[MITM] %s <- response %s", rule.RuleType().String(), request.URL.String())
-
-	switch rule.RuleType() {
-	case C.MitmResponseHeader:
-		if len(response.Header) == 0 {
-			return nil
-		}
-
-		rawHeader := &bytes.Buffer{}
-		oldHeader := response.Header
-		if err := oldHeader.Write(rawHeader); err != nil {
-			return nil
-		}
-
-		newRawHeader := rule.ReplaceSubPayload(rawHeader.String())
-		tb := textproto.NewReader(bufio.NewReader(strings.NewReader(newRawHeader)))
-		newHeader, err := tb.ReadMIMEHeader()
-		if err != nil && !errors.Is(err, io.EOF) {
-			return nil
-		}
-
-		response.Header = http.Header(newHeader)
-		response.Header.Set("Content-Length", strconv.FormatInt(response.ContentLength, 10))
-	case C.MitmResponseBody:
-		if !CanRewriteBody(response.ContentLength, response.Header.Get("Content-Type")) {
-			return nil
-		}
-
-		b, err := mitm.ReadDecompressedBody(response)
-		_ = response.Body.Close()
-		if err != nil {
-			return nil
-		}
-
-		//body, err := mitm.DecodeLatin1(bytes.NewReader(b))
-		//if err != nil {
-		//	return nil
-		//}
-
-		newBody := rule.ReplaceSubPayload(string(b))
-
-		//modifiedBody, err := mitm.EncodeLatin1(newBody)
-		//if err != nil {
-		//	return nil
-		//}
-		modifiedBody := []byte(newBody)
-
-		response.Body = io.NopCloser(bytes.NewReader(modifiedBody))
-		response.Header.Del("Content-Encoding")
-		response.ContentLength = int64(len(modifiedBody))
-	default:
-		found = false
-	}
-
-	if found {
-		return response
-	}
-	return nil
-}
-
-func (h *RewriteHandler) HandleApiRequest(*mitm.Session) bool {
-	return false
-}
-
-// HandleError session maybe nil
-func (h *RewriteHandler) HandleError(*mitm.Session, error) {}
-
-func matchRewriteRule(url string, isRequest bool) (rr C.Rewrite, sub []string, found bool) {
-	rewrites := tunnel.Rewrites()
-	if isRequest {
-		found = rewrites.SearchInRequest(func(r C.Rewrite) bool {
-			sub, err := r.URLRegx().FindStringMatch(url)
-			if err != nil || sub == nil {
-				return false
-			}
-
-			rr = r
-			var groups []string
-			for _, fg := range sub.Groups() {
-				groups = append(groups, fg.String())
-			}
-			return true
-		})
-	} else {
-		found = rewrites.SearchInResponse(func(r C.Rewrite) bool {
-			if b, err := r.URLRegx().MatchString(url); b && err == nil {
-				rr = r
-				return true
-			}
-			return false
-		})
-	}
-
-	return
-}

rewrite/parser.go

@@ -1,53 +0,0 @@
-package rewrites
-
-import (
-	regexp "github.com/dlclark/regexp2"
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-func ParseRewrite(line RawMitmRule) (C.Rewrite, error) {
-	var (
-		urlRegx     *regexp.Regexp
-		ruleType    *C.RewriteType
-		ruleRegx    *regexp.Regexp
-		rulePayload string
-
-		err error
-	)
-
-	url := line.Url
-	urlRegx, err = regexp.Compile(strings.Trim(url, " "), regexp.None)
-	if err != nil {
-		return nil, err
-	}
-
-	ruleType = &line.Action
-	switch *ruleType {
-	case C.Mitm302, C.Mitm307:
-		{
-			rulePayload = line.New
-			break
-		}
-	case C.MitmRequestHeader, C.MitmRequestBody, C.MitmResponseHeader, C.MitmResponseBody:
-		{
-			var old string
-			if line.Old == nil {
-				old = ".*"
-			} else {
-				old = *line.Old
-			}
-
-			re, err := regexp.Compile(old, regexp.Singleline)
-			if err != nil {
-				return nil, err
-			}
-			ruleRegx = re
-
-			rulePayload = line.New
-		}
-	}
-
-	return NewRewriteRule(urlRegx, *ruleType, ruleRegx, rulePayload), nil
-}

rewrite/rewrite.go

@@ -1,105 +0,0 @@
-package rewrites
-
-import (
-	regexp "github.com/dlclark/regexp2"
-	"strconv"
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-
-	"github.com/gofrs/uuid"
-)
-
-type RawMitmRule struct {
-	Url    string        `yaml:"url" json:"url"`
-	Action C.RewriteType `yaml:"action" json:"action"`
-	Old    *string       `yaml:"old" json:"old"`
-	New    string        `yaml:"new" json:"new"`
-}
-
-type RewriteRule struct {
-	id          string
-	urlRegx     *regexp.Regexp
-	ruleType    C.RewriteType
-	ruleRegx    *regexp.Regexp
-	rulePayload string
-}
-
-func (r *RewriteRule) ID() string {
-	return r.id
-}
-
-func (r *RewriteRule) URLRegx() *regexp.Regexp {
-	return r.urlRegx
-}
-
-func (r *RewriteRule) RuleType() C.RewriteType {
-	return r.ruleType
-}
-
-func (r *RewriteRule) RuleRegx() *regexp.Regexp {
-	return r.ruleRegx
-}
-
-func (r *RewriteRule) RulePayload() string {
-	return r.rulePayload
-}
-
-func (r *RewriteRule) ReplaceURLPayload(matchSub []string) string {
-	url := r.rulePayload
-
-	l := len(matchSub)
-	if l < 2 {
-		return url
-	}
-
-	for i := 1; i < l; i++ {
-		url = strings.ReplaceAll(url, "$"+strconv.Itoa(i), matchSub[i])
-	}
-	return url
-}
-
-func (r *RewriteRule) ReplaceSubPayload(oldData string) string {
-	payload := r.rulePayload
-
-	if r.ruleRegx == nil {
-		return oldData
-	}
-
-	sub, err := r.ruleRegx.FindStringMatch(oldData)
-
-	for err == nil && sub != nil {
-		var (
-			groups   []string
-			sPayload = payload
-		)
-		for _, fg := range sub.Groups() {
-			groups = append(groups, fg.String())
-		}
-
-		l := len(groups)
-
-		for i := 1; i < l; i++ {
-			sPayload = strings.Replace(payload, "$"+strconv.Itoa(i), groups[i], 1)
-		}
-
-		oldData = strings.Replace(oldData, groups[0], sPayload, 1)
-
-		sub, err = r.ruleRegx.FindNextMatch(sub)
-	}
-
-	return oldData
-}
-
-func NewRewriteRule(urlRegx *regexp.Regexp, ruleType C.RewriteType, ruleRegx *regexp.Regexp, rulePayload string) *RewriteRule {
-	id, _ := uuid.NewV4()
-	return &RewriteRule{
-		id:          id.String(),
-		urlRegx:     urlRegx,
-		ruleType:    ruleType,
-		ruleRegx:    ruleRegx,
-		rulePayload: rulePayload,
-	}
-}
-
-var _ C.Rewrite = (*RewriteRule)(nil)

rewrite/util.go

@@ -1,28 +0,0 @@
-package rewrites
-
-import (
-	"strings"
-)
-
-var allowContentType = []string{
-	"text/",
-	"application/xhtml",
-	"application/xml",
-	"application/atom+xml",
-	"application/json",
-	"application/x-www-form-urlencoded",
-}
-
-func CanRewriteBody(contentLength int64, contentType string) bool {
-	if contentLength <= 0 {
-		return false
-	}
-
-	for _, v := range allowContentType {
-		if strings.HasPrefix(contentType, v) {
-			return true
-		}
-	}
-
-	return false
-}

rules/common/user_gent.go

@@ -1,52 +0,0 @@
-package common
-
-import (
-	"strings"
-
-	C "github.com/Dreamacro/clash/constant"
-)
-
-type UserAgent struct {
-	*Base
-	ua      string
-	adapter string
-}
-
-func (d *UserAgent) RuleType() C.RuleType {
-	return C.UserAgent
-}
-
-func (d *UserAgent) Match(metadata *C.Metadata) (bool, string) {
-	if metadata.Type != C.MITM || metadata.UserAgent == "" {
-		return false, d.adapter
-	}
-
-	return strings.Contains(metadata.UserAgent, d.ua), d.adapter
-}
-
-func (d *UserAgent) Adapter() string {
-	return d.adapter
-}
-
-func (d *UserAgent) Payload() string {
-	return d.ua
-}
-
-func (d *UserAgent) ShouldResolveIP() bool {
-	return false
-}
-
-func NewUserAgent(ua string, adapter string) (*UserAgent, error) {
-	ua = strings.Trim(ua, "*")
-	if ua == "" {
-		return nil, errPayload
-	}
-
-	return &UserAgent{
-		Base:    &Base{},
-		ua:      ua,
-		adapter: adapter,
-	}, nil
-}
-
-var _ C.Rule = (*UserAgent)(nil)

test/go.mod

@@ -20,7 +20,6 @@ require (
 	github.com/Yawning/aez v0.0.0-20211027044916-e49e68abd344 // indirect
 	github.com/aead/chacha20 v0.0.0-20180709150244-8b13a72661da // indirect
 	github.com/andybalholm/brotli v1.0.5 // indirect
-	github.com/beevik/ntp v1.3.0 // indirect
 	github.com/cilium/ebpf v0.11.0 // indirect
 	github.com/coreos/go-iptables v0.7.0 // indirect
 	github.com/davecgh/go-spew v1.1.1 // indirect
@@ -32,7 +31,6 @@ require (
 	github.com/ericlagergren/siv v0.0.0-20220507050439-0b757b3aa5f1 // indirect
 	github.com/ericlagergren/subtle v0.0.0-20220507045147-890d697da010 // indirect
 	github.com/fsnotify/fsnotify v1.6.0 // indirect
-	github.com/gaukas/godicttls v0.0.4 // indirect
 	github.com/go-ole/go-ole v1.2.6 // indirect
 	github.com/go-task/slim-sprig v0.0.0-20230315185526-52ccab3ef572 // indirect
 	github.com/gofrs/uuid/v5 v5.0.0 // indirect
@@ -73,7 +71,6 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c // indirect
-	github.com/puzpuzpuz/xsync/v2 v2.5.0 // indirect
 	github.com/quic-go/qpack v0.4.0 // indirect
 	github.com/quic-go/qtls-go1-20 v0.3.2 // indirect
 	github.com/sagernet/go-tun2socks v1.16.12-0.20220818015926-16cb67876a61 // indirect
@@ -97,12 +94,10 @@ require (
 	github.com/tklauser/numcpus v0.6.0 // indirect
 	github.com/u-root/uio v0.0.0-20230220225925-ffce2a382923 // indirect
 	github.com/vishvananda/netns v0.0.0-20211101163701-50045581ed74 // indirect
-	github.com/xtls/go v0.0.0-20210920065950-d4af136d3672 // indirect
 	github.com/yusufpapurcu/wmi v1.2.3 // indirect
 	github.com/zhangyunhao116/fastrand v0.3.0 // indirect
 	gitlab.com/yawning/bsaes.git v0.0.0-20190805113838-0a714cd429ec // indirect
 	go.etcd.io/bbolt v1.3.7 // indirect
-	go.uber.org/atomic v1.9.0 // indirect
 	golang.org/x/crypto v0.12.0 // indirect
 	golang.org/x/exp v0.0.0-20230811145659-89c5cff77bcb // indirect
 	golang.org/x/mod v0.11.0 // indirect
@@ -111,16 +106,7 @@ require (
 	golang.org/x/text v0.12.0 // indirect
 	golang.org/x/time v0.3.0 // indirect
 	golang.org/x/tools v0.9.1 // indirect
-	golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect
-	golang.zx2c4.com/wintun v0.0.0-20211104114900-415007cec224 // indirect
-	golang.zx2c4.com/wireguard v0.0.0-20220318042302-193cf8d6a5d6 // indirect
-	golang.zx2c4.com/wireguard/windows v0.5.4-0.20220317000008-6432784c2469 // indirect
-	google.golang.org/genproto v0.0.0-20230110181048-76db0878b65f // indirect
-	google.golang.org/grpc v1.53.0-dev.0.20230123225046-4075ef07c5d5 // indirect
 	google.golang.org/protobuf v1.31.0 // indirect
-	gopkg.in/yaml.v2 v2.4.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
-	gotest.tools/v3 v3.4.0 // indirect
-	gvisor.dev/gvisor v0.0.0-20220326024801-5d1f3d24cb84 // indirect
 	lukechampine.com/blake3 v1.2.1 // indirect
 )

transport/tuic/v4/client.go

@@ -22,7 +22,6 @@ import (
 	"github.com/Dreamacro/clash/transport/tuic/common"
 
 	"github.com/metacubex/quic-go"
-	"github.com/puzpuzpuz/xsync/v2"
 	"github.com/zhangyunhao116/fastrand"
 )
 
@@ -50,7 +49,7 @@ type clientImpl struct {
 	openStreams atomic.Int64
 	closed      atomic.Bool
 
-	udpInputMap *xsync.MapOf[uint32, net.Conn]
+	udpInputMap sync.Map
 
 	// only ready for PoolClient
 	dialerRef   C.Dialer
@@ -264,10 +263,11 @@ func (t *clientImpl) forceClose(quicConn quic.Connection, err error) {
 	if quicConn != nil {
 		_ = quicConn.CloseWithError(ProtocolError, errStr)
 	}
-	udpInputMap := t.udpInputMap
-	udpInputMap.Range(func(key uint32, value net.Conn) bool {
-		conn := value
-		_ = conn.Close()
+	udpInputMap := &t.udpInputMap
+	udpInputMap.Range(func(key, value any) bool {
+		if conn, ok := value.(net.Conn); ok {
+			_ = conn.Close()
+		}
 		udpInputMap.Delete(key)
 		return true
 	})
@@ -469,7 +469,6 @@ func NewClient(clientOption *ClientOption, udp bool, dialerRef C.Dialer) *Client
 		ClientOption: clientOption,
 		udp:          udp,
 		dialerRef:    dialerRef,
-		udpInputMap:  xsync.NewIntegerMapOf[uint32, net.Conn](),
 	}
 	c := &Client{ci}
 	runtime.SetFinalizer(c, closeClient)

transport/tuic/v4/server.go

@@ -17,7 +17,6 @@ import (
 
 	"github.com/gofrs/uuid/v5"
 	"github.com/metacubex/quic-go"
-	"github.com/puzpuzpuz/xsync/v2"
 )
 
 type ServerOption struct {
@@ -34,7 +33,6 @@ func NewServerHandler(option *ServerOption, quicConn quic.EarlyConnection, uuid
 		quicConn:     quicConn,
 		uuid:         uuid,
 		authCh:       make(chan struct{}),
-		udpInputMap:  xsync.NewIntegerMapOf[uint32, *atomic.Bool](),
 	}
 }
 
@@ -47,7 +45,7 @@ type serverHandler struct {
 	authOk   atomic.Bool
 	authOnce sync.Once
 
-	udpInputMap *xsync.MapOf[uint32, *atomic.Bool]
+	udpInputMap sync.Map
 }
 
 func (s *serverHandler) AuthOk() bool {
@@ -80,7 +78,8 @@ func (s *serverHandler) parsePacket(packet *Packet, udpRelayMode common.UdpRelay
 
 	assocId = packet.ASSOC_ID
 
-	writeClosed, _ := s.udpInputMap.LoadOrCompute(assocId, func() *atomic.Bool { return &atomic.Bool{} })
+	v, _ := s.udpInputMap.LoadOrStore(assocId, &atomic.Bool{})
+	writeClosed := v.(*atomic.Bool)
 	if writeClosed.Load() {
 		return nil
 	}
@@ -174,7 +173,8 @@ func (s *serverHandler) HandleUniStream(reader *bufio.Reader) (err error) {
 		if err != nil {
 			return
 		}
-		if writeClosed, loaded := s.udpInputMap.LoadAndDelete(disassociate.ASSOC_ID); loaded {
+		if v, loaded := s.udpInputMap.LoadAndDelete(disassociate.ASSOC_ID); loaded {
+			writeClosed := v.(*atomic.Bool)
 			writeClosed.Store(true)
 		}
 	case HeartbeatType:

transport/tuic/v5/client.go

@@ -20,7 +20,6 @@ import (
 	"github.com/Dreamacro/clash/transport/tuic/common"
 
 	"github.com/metacubex/quic-go"
-	"github.com/puzpuzpuz/xsync/v2"
 	"github.com/zhangyunhao116/fastrand"
 )
 
@@ -47,7 +46,7 @@ type clientImpl struct {
 	openStreams atomic.Int64
 	closed      atomic.Bool
 
-	udpInputMap xsync.MapOf[uint16, net.Conn]
+	udpInputMap sync.Map
 
 	// only ready for PoolClient
 	dialerRef   C.Dialer
@@ -271,9 +270,10 @@ func (t *clientImpl) forceClose(quicConn quic.Connection, err error) {
 		_ = quicConn.CloseWithError(ProtocolError, errStr)
 	}
 	udpInputMap := &t.udpInputMap
-	udpInputMap.Range(func(key uint16, value net.Conn) bool {
-		conn := value
-		_ = conn.Close()
+	udpInputMap.Range(func(key, value any) bool {
+		if conn, ok := value.(net.Conn); ok {
+			_ = conn.Close()
+		}
 		udpInputMap.Delete(key)
 		return true
 	})
@@ -406,7 +406,6 @@ func NewClient(clientOption *ClientOption, udp bool, dialerRef C.Dialer) *Client
 		ClientOption: clientOption,
 		udp:          udp,
 		dialerRef:    dialerRef,
-		udpInputMap:  *xsync.NewIntegerMapOf[uint16, net.Conn](),
 	}
 	c := &Client{ci}
 	runtime.SetFinalizer(c, closeClient)

transport/tuic/v5/server.go

@@ -16,7 +16,6 @@ import (
 
 	"github.com/gofrs/uuid/v5"
 	"github.com/metacubex/quic-go"
-	"github.com/puzpuzpuz/xsync/v2"
 )
 
 type ServerOption struct {
@@ -33,7 +32,6 @@ func NewServerHandler(option *ServerOption, quicConn quic.EarlyConnection, uuid
 		quicConn:     quicConn,
 		uuid:         uuid,
 		authCh:       make(chan struct{}),
-		udpInputMap:  xsync.NewIntegerMapOf[uint16, *serverUDPInput](),
 	}
 }
 
@@ -47,7 +45,7 @@ type serverHandler struct {
 	authUUID atomic.TypedValue[string]
 	authOnce sync.Once
 
-	udpInputMap *xsync.MapOf[uint16, *serverUDPInput]
+	udpInputMap sync.Map
 }
 
 func (s *serverHandler) AuthOk() bool {
@@ -96,7 +94,8 @@ func (s *serverHandler) parsePacket(packet *Packet, udpRelayMode common.UdpRelay
 
 	assocId = packet.ASSOC_ID
 
-	input, _ := s.udpInputMap.LoadOrCompute(assocId, func() *serverUDPInput { return &serverUDPInput{} })
+	v, _ := s.udpInputMap.LoadOrStore(assocId, &serverUDPInput{})
+	input := v.(*serverUDPInput)
 	if input.writeClosed.Load() {
 		return nil
 	}
@@ -187,7 +186,8 @@ func (s *serverHandler) HandleUniStream(reader *bufio.Reader) (err error) {
 		if err != nil {
 			return
 		}
-		if input, loaded := s.udpInputMap.LoadAndDelete(disassociate.ASSOC_ID); loaded {
+		if v, loaded := s.udpInputMap.LoadAndDelete(disassociate.ASSOC_ID); loaded {
+			input := v.(*serverUDPInput)
 			input.writeClosed.Store(true)
 		}
 	}

tunnel/connection.go

@@ -73,9 +73,12 @@ func handleUDPToLocal(writeBack C.WriteBack, pc N.EnhancePacketConn, key string,
 }
 
 func closeAllLocalCoon(lAddr string) {
-	natTable.RangeForLocalConn(lAddr, func(key string, value *net.UDPConn) bool {
-		conn := value
-
+	natTable.RangeLocalConn(lAddr, func(key, value any) bool {
+		conn, ok := value.(*net.UDPConn)
+		if !ok || conn == nil {
+			log.Debugln("Value %#v unknown value when closing TProxy local conn...", conn)
+			return true
+		}
 		conn.Close()
 		log.Debugln("Closing TProxy local conn... lAddr=%s rAddr=%s", lAddr, key)
 		return true

tunnel/statistic/manager.go

@@ -2,11 +2,11 @@ package statistic
 
 import (
 	"os"
+	"sync"
 	"time"
 
 	"github.com/Dreamacro/clash/common/atomic"
 
-	"github.com/puzpuzpuz/xsync/v2"
 	"github.com/shirou/gopsutil/v3/process"
 )
 
@@ -14,7 +14,6 @@ var DefaultManager *Manager
 
 func init() {
 	DefaultManager = &Manager{
-		connections:   xsync.NewMapOf[Tracker](),
 		uploadTemp:    atomic.NewInt64(0),
 		downloadTemp:  atomic.NewInt64(0),
 		uploadBlip:    atomic.NewInt64(0),
@@ -28,7 +27,7 @@ func init() {
 }
 
 type Manager struct {
-	connections   *xsync.MapOf[string, Tracker]
+	connections   sync.Map
 	uploadTemp    *atomic.Int64
 	downloadTemp  *atomic.Int64
 	uploadBlip    *atomic.Int64
@@ -49,14 +48,14 @@ func (m *Manager) Leave(c Tracker) {
 
 func (m *Manager) Get(id string) (c Tracker) {
 	if value, ok := m.connections.Load(id); ok {
-		c = value
+		c = value.(Tracker)
 	}
 	return
 }
 
 func (m *Manager) Range(f func(c Tracker) bool) {
-	m.connections.Range(func(key string, value Tracker) bool {
-		return f(value)
+	m.connections.Range(func(key, value any) bool {
+		return f(value.(Tracker))
 	})
 }
 

tunnel/tunnel.go

@@ -30,7 +30,6 @@ var (
 	udpQueue       = make(chan C.PacketAdapter, 200)
 	natTable       = nat.New()
 	rules          []C.Rule
-	rewrites       C.RewriteRule
 	listeners      = make(map[string]C.InboundListener)
 	subRules       map[string][]C.Rule
 	proxies        = make(map[string]C.Proxy)
@@ -180,18 +179,6 @@ func isHandle(t C.Type) bool {
 	return status == Running || (status == Inner && t == C.INNER)
 }
 
-// Rewrites return all rewrites
-func Rewrites() C.RewriteRule {
-	return rewrites
-}
-
-// UpdateRewrites handle update rewrites
-func UpdateRewrites(rules C.RewriteRule) {
-	configMux.Lock()
-	rewrites = rules
-	configMux.Unlock()
-}
-
 // processUDP starts a loop to handle udp packet
 func processUDP() {
 	queue := udpQueue
@@ -331,7 +318,8 @@ func handleUDPConn(packet C.PacketAdapter) {
 		return
 	}
 
-	cond, loaded := natTable.GetOrCreateLock(key)
+	lockKey := key + "-lock"
+	cond, loaded := natTable.GetOrCreateLock(lockKey)
 
 	go func() {
 		defer packet.Drop()
@@ -345,7 +333,7 @@ func handleUDPConn(packet C.PacketAdapter) {
 		}
 
 		defer func() {
-			natTable.DeleteLock(key)
+			natTable.Delete(lockKey)
 			cond.Broadcast()
 		}()
 
@@ -446,9 +434,8 @@ func handleTCPConn(connCtx C.ConnContext) {
 		return
 	}
 
-	isMitmProxy := metadata.Type == C.MITM
 	dialMetadata := metadata
-	if len(metadata.Host) > 0 && !isMitmProxy {
+	if len(metadata.Host) > 0 {
 		if node, ok := resolver.DefaultHosts.Search(metadata.Host, false); ok {
 			if dstIp, _ := node.RandIP(); !FakeIPRange().Contains(dstIp) {
 				dialMetadata.DstIP = dstIp
@@ -561,10 +548,6 @@ func match(metadata *C.Metadata) (C.Proxy, C.Rule, error) {
 	}
 
 	for _, rule := range getRules(metadata) {
-		if metadata.Type == C.MITM && rule.Adapter() == "MITM" {
-			continue
-		}
-
 		if !resolved && shouldResolveIP(rule, metadata) {
 			func() {
 				ctx, cancel := context.WithTimeout(context.Background(), resolver.DefaultDNSTimeout)