Remove Snell and OpenVPN

protocol/openvpn/outbound.go

@@ -1,167 +0,0 @@
-//go:build with_openvpn
-
-package openvpn
-
-import (
-	"context"
-	"net"
-	"os"
-	"time"
-
-	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/adapter/outbound"
-	"github.com/sagernet/sing-box/common/dialer"
-	"github.com/sagernet/sing-box/common/tls"
-	C "github.com/sagernet/sing-box/constant"
-	"github.com/sagernet/sing-box/log"
-	"github.com/sagernet/sing-box/option"
-	ovpn "github.com/sagernet/sing-box/transport/openvpn"
-	"github.com/sagernet/sing/common"
-	"github.com/sagernet/sing/common/bufio"
-	E "github.com/sagernet/sing/common/exceptions"
-	"github.com/sagernet/sing/common/logger"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-	"github.com/sagernet/sing/service"
-)
-
-func RegisterOutbound(registry *outbound.Registry) {
-	outbound.Register[option.OpenVPNOutboundOptions](registry, C.TypeOpenVPN, NewOutbound)
-}
-
-type Outbound struct {
-	outbound.Adapter
-	ctx       context.Context
-	dnsRouter adapter.DNSRouter
-	logger    logger.ContextLogger
-	tunnel    *ovpn.Tunnel
-}
-
-func NewOutbound(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.OpenVPNOutboundOptions) (adapter.Outbound, error) {
-	tlsConfig, err := tls.NewOpenVPNClient(ctx, logger, common.PtrValueOrDefault(options.TLS))
-	if err != nil {
-		return nil, err
-	}
-	var tlsKey []byte
-	keyDirection := -1
-	if options.TLSAuth != "" || options.TLSAuthPath != "" {
-		tlsAuth := options.TLSAuth
-		if tlsAuth == "" {
-			data, err := os.ReadFile(options.TLSAuthPath)
-			if err != nil {
-				return nil, E.Cause(err, "read tls_auth_path")
-			}
-			tlsAuth = string(data)
-		}
-		tlsKey = []byte(tlsAuth)
-		keyDirection = options.KeyDirection
-	} else {
-		tlsCrypt := options.TLSCrypt
-		if tlsCrypt == "" && options.TLSCryptPath != "" {
-			data, err := os.ReadFile(options.TLSCryptPath)
-			if err != nil {
-				return nil, E.Cause(err, "read tls_crypt_path")
-			}
-			tlsCrypt = string(data)
-		}
-		tlsKey = []byte(tlsCrypt)
-	}
-	clientConfig := &ovpn.ClientConfig{
-		Proto:        options.Proto,
-		Cipher:       options.Cipher,
-		Auth:         options.Auth,
-		Username:     options.Username,
-		Password:     options.Password,
-		KeyDirection: keyDirection,
-		TLSCrypt:     tlsKey,
-		TLSCryptV2:   options.TLSCryptV2,
-	}
-	if err := clientConfig.Prepare(); err != nil {
-		return nil, E.Cause(err, "invalid openvpn config")
-	}
-	outboundDialer, err := dialer.New(ctx, options.DialerOptions, true)
-	if err != nil {
-		return nil, err
-	}
-	o := &Outbound{
-		Adapter:   outbound.NewAdapterWithDialerOptions(C.TypeOpenVPN, tag, []string{N.NetworkTCP, N.NetworkUDP}, options.DialerOptions),
-		ctx:       ctx,
-		dnsRouter: service.FromContext[adapter.DNSRouter](ctx),
-		logger:    logger,
-	}
-	tunnel, err := ovpn.NewTunnel(ctx, logger, ovpn.TunnelOptions{
-		System: options.System,
-		Name:   options.Name,
-		CreateDialer: func(interfaceName string) N.Dialer {
-			return common.Must1(dialer.NewDefault(ctx, option.DialerOptions{
-				BindInterface: interfaceName,
-			}))
-		},
-		Dialer:         outboundDialer,
-		Servers:        options.Servers,
-		TLSConfig:      tlsConfig,
-		Config:         clientConfig,
-		AllowedAddress: options.AllowedIPs,
-		ReconnectDelay: time.Duration(options.ReconnectDelay),
-		PingInterval:   time.Duration(options.PingInterval),
-		PingRestart:    time.Duration(options.PingRestart),
-	})
-	if err != nil {
-		return nil, err
-	}
-	o.tunnel = tunnel
-	return o, nil
-}
-
-func (o *Outbound) Start(stage adapter.StartStage) error {
-	if stage != adapter.StartStatePostStart {
-		return nil
-	}
-	return o.tunnel.Start()
-}
-
-func (o *Outbound) Close() error {
-	if o.tunnel != nil {
-		return o.tunnel.Close()
-	}
-	return nil
-}
-
-func (o *Outbound) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
-	switch network {
-	case N.NetworkTCP:
-		o.logger.InfoContext(ctx, "outbound connection to ", destination)
-	case N.NetworkUDP:
-		o.logger.InfoContext(ctx, "outbound packet connection to ", destination)
-	}
-	if destination.IsDomain() {
-		destinationAddresses, err := o.dnsRouter.Lookup(ctx, destination.Fqdn, adapter.DNSQueryOptions{})
-		if err != nil {
-			return nil, err
-		}
-		return N.DialSerial(ctx, o.tunnel, network, destination, destinationAddresses)
-	}
-	if !destination.Addr.IsValid() {
-		return nil, E.New("invalid destination: ", destination)
-	}
-	return o.tunnel.DialContext(ctx, network, destination)
-}
-
-func (o *Outbound) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
-	o.logger.InfoContext(ctx, "outbound packet connection to ", destination)
-	if destination.IsDomain() {
-		destinationAddresses, err := o.dnsRouter.Lookup(ctx, destination.Fqdn, adapter.DNSQueryOptions{})
-		if err != nil {
-			return nil, err
-		}
-		packetConn, destinationAddress, err := N.ListenSerial(ctx, o.tunnel, destination, destinationAddresses)
-		if err != nil {
-			return nil, err
-		}
-		if destinationAddress.IsValid() && destination != M.SocksaddrFrom(destinationAddress, destination.Port) {
-			return bufio.NewNATPacketConn(bufio.NewPacketConn(packetConn), M.SocksaddrFrom(destinationAddress, destination.Port), destination), nil
-		}
-		return packetConn, nil
-	}
-	return o.tunnel.ListenPacket(ctx, destination)
-}

protocol/snell/inbound.go

@@ -1,130 +0,0 @@
-package snell
-
-import (
-	"context"
-	"net"
-
-	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/adapter/inbound"
-	"github.com/sagernet/sing-box/common/listener"
-	C "github.com/sagernet/sing-box/constant"
-	"github.com/sagernet/sing-box/log"
-	"github.com/sagernet/sing-box/option"
-	"github.com/sagernet/sing-box/transport/snell"
-	"github.com/sagernet/sing/common"
-	"github.com/sagernet/sing/common/bufio"
-	E "github.com/sagernet/sing/common/exceptions"
-	"github.com/sagernet/sing/common/logger"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-func RegisterInbound(registry *inbound.Registry) {
-	inbound.Register[option.SnellInboundOptions](registry, C.TypeSnell, NewInbound)
-}
-
-type Inbound struct {
-	inbound.Adapter
-	router   adapter.ConnectionRouterEx
-	logger   logger.ContextLogger
-	listener *listener.Listener
-	service  *snell.Service
-}
-
-func NewInbound(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.SnellInboundOptions) (adapter.Inbound, error) {
-	if options.PSK == "" {
-		return nil, E.New("snell requires psk")
-	}
-	udpEnabled := common.Contains(options.Network.Build(), N.NetworkUDP)
-	obfsMode := ""
-	if options.Obfs != nil {
-		obfsMode = options.Obfs.Mode
-	}
-	in := &Inbound{
-		Adapter: inbound.NewAdapter(C.TypeSnell, tag),
-		router:  router,
-		logger:  logger,
-	}
-	service, err := snell.NewService(snell.ServiceOptions{
-		PSK:      []byte(options.PSK),
-		Version:  options.Version,
-		ObfsMode: obfsMode,
-		UDP:      udpEnabled,
-		Logger:   logger,
-		Handler:  (*inboundHandler)(in),
-	})
-	if err != nil {
-		return nil, err
-	}
-	in.service = service
-	in.listener = listener.New(listener.Options{
-		Context:           ctx,
-		Logger:            logger,
-		Network:           []string{N.NetworkTCP},
-		Listen:            options.ListenOptions,
-		ConnectionHandler: in,
-	})
-	return in, nil
-}
-
-func (h *Inbound) Start(stage adapter.StartStage) error {
-	if stage != adapter.StartStateStart {
-		return nil
-	}
-	return h.listener.Start()
-}
-
-func (h *Inbound) Close() error {
-	return h.listener.Close()
-}
-
-func (h *Inbound) NewConnectionEx(ctx context.Context, conn net.Conn, metadata adapter.InboundContext, onClose N.CloseHandlerFunc) {
-	err := h.service.NewConnection(ctx, conn, metadata.Source)
-	N.CloseOnHandshakeFailure(conn, onClose, err)
-	if err != nil {
-		h.logger.ErrorContext(ctx, E.Cause(err, "process connection from ", metadata.Source))
-	}
-}
-
-var _ adapter.TCPInjectableInbound = (*Inbound)(nil)
-
-type inboundHandler Inbound
-
-func (h *inboundHandler) NewConnection(ctx context.Context, conn net.Conn, source M.Socksaddr, destination M.Socksaddr, clientID string) {
-	var metadata adapter.InboundContext
-	metadata.Inbound = h.Tag()
-	metadata.InboundType = h.Type()
-	metadata.InboundDetour = h.listener.ListenOptions().Detour
-	metadata.Source = source
-	metadata.Destination = destination
-	if clientID != "" {
-		metadata.User = clientID
-		h.logger.InfoContext(ctx, "[", clientID, "] inbound connection to ", destination)
-	} else {
-		h.logger.InfoContext(ctx, "inbound connection to ", destination)
-	}
-	done := make(chan struct{})
-	h.router.RouteConnectionEx(ctx, conn, metadata, N.OnceClose(func(error) {
-		close(done)
-	}))
-	<-done
-}
-
-func (h *inboundHandler) NewPacketConnection(ctx context.Context, conn net.PacketConn, source M.Socksaddr, clientID string) {
-	var metadata adapter.InboundContext
-	metadata.Inbound = h.Tag()
-	metadata.InboundType = h.Type()
-	metadata.InboundDetour = h.listener.ListenOptions().Detour
-	metadata.Source = source
-	if clientID != "" {
-		metadata.User = clientID
-		h.logger.InfoContext(ctx, "[", clientID, "] inbound packet connection")
-	} else {
-		h.logger.InfoContext(ctx, "inbound packet connection")
-	}
-	done := make(chan struct{})
-	h.router.RoutePacketConnectionEx(ctx, bufio.NewPacketConn(conn), metadata, N.OnceClose(func(error) {
-		close(done)
-	}))
-	<-done
-}

protocol/snell/outbound.go

@@ -1,114 +0,0 @@
-package snell
-
-import (
-	"context"
-	"fmt"
-	"net"
-
-	"github.com/sagernet/sing-box/adapter"
-	"github.com/sagernet/sing-box/adapter/outbound"
-	"github.com/sagernet/sing-box/common/dialer"
-	C "github.com/sagernet/sing-box/constant"
-	"github.com/sagernet/sing-box/log"
-	"github.com/sagernet/sing-box/option"
-	"github.com/sagernet/sing-box/transport/snell"
-	"github.com/sagernet/sing/common"
-	"github.com/sagernet/sing/common/bufio"
-	E "github.com/sagernet/sing/common/exceptions"
-	"github.com/sagernet/sing/common/logger"
-	M "github.com/sagernet/sing/common/metadata"
-	N "github.com/sagernet/sing/common/network"
-)
-
-func RegisterOutbound(registry *outbound.Registry) {
-	outbound.Register[option.SnellOutboundOptions](registry, C.TypeSnell, NewOutbound)
-}
-
-type Outbound struct {
-	outbound.Adapter
-	logger logger.ContextLogger
-	client *snell.Client
-}
-
-func NewOutbound(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.SnellOutboundOptions) (adapter.Outbound, error) {
-	if options.PSK == "" {
-		return nil, E.New("snell requires psk")
-	}
-	version := options.Version
-	if version == 0 {
-		version = snell.DefaultSnellVersion
-	}
-	if version == snell.Version5 {
-		version = snell.Version4
-	}
-	udpEnabled := common.Contains(options.Network.Build(), N.NetworkUDP)
-	switch version {
-	case snell.Version1, snell.Version2:
-		if udpEnabled {
-			return nil, fmt.Errorf("snell version %d does not support UDP", version)
-		}
-	case snell.Version3, snell.Version4:
-	default:
-		return nil, fmt.Errorf("snell version error: %d", version)
-	}
-	reuse := version == snell.Version2 || (version == snell.Version4 && options.Reuse)
-	obfsMode := ""
-	obfsHost := "bing.com"
-	if options.Obfs != nil {
-		switch options.Obfs.Mode {
-		case "", "tls", "http":
-			obfsMode = options.Obfs.Mode
-		default:
-			return nil, fmt.Errorf("snell obfs mode error: %s", options.Obfs.Mode)
-		}
-		if options.Obfs.Host != "" {
-			obfsHost = options.Obfs.Host
-		}
-	}
-	outboundDialer, err := dialer.New(ctx, options.DialerOptions, options.ServerIsDomain())
-	if err != nil {
-		return nil, err
-	}
-	client := snell.NewClient(snell.ClientOptions{
-		Dialer:   outboundDialer,
-		Server:   options.ServerOptions.Build(),
-		PSK:      []byte(options.PSK),
-		Version:  version,
-		Reuse:    reuse,
-		ObfsMode: obfsMode,
-		ObfsHost: obfsHost,
-	})
-	return &Outbound{
-		Adapter: outbound.NewAdapterWithDialerOptions(C.TypeSnell, tag, options.Network.Build(), options.DialerOptions),
-		logger:  logger,
-		client:  client,
-	}, nil
-}
-
-func (h *Outbound) DialContext(ctx context.Context, network string, destination M.Socksaddr) (net.Conn, error) {
-	ctx, metadata := adapter.ExtendContext(ctx)
-	metadata.Outbound = h.Tag()
-	metadata.Destination = destination
-	switch N.NetworkName(network) {
-	case N.NetworkTCP:
-		h.logger.InfoContext(ctx, "outbound connection to ", destination)
-		return h.client.DialContext(ctx, destination)
-	case N.NetworkUDP:
-		h.logger.InfoContext(ctx, "outbound packet connection to ", destination)
-		conn, err := h.client.ListenPacket(ctx, destination)
-		if err != nil {
-			return nil, err
-		}
-		return bufio.NewBindPacketConn(conn, destination), nil
-	default:
-		return nil, E.Extend(N.ErrUnknownNetwork, network)
-	}
-}
-
-func (h *Outbound) ListenPacket(ctx context.Context, destination M.Socksaddr) (net.PacketConn, error) {
-	ctx, metadata := adapter.ExtendContext(ctx)
-	metadata.Outbound = h.Tag()
-	metadata.Destination = destination
-	h.logger.InfoContext(ctx, "outbound packet connection to ", destination)
-	return h.client.ListenPacket(ctx, destination)
-}