diff --git a/app/dns/dns_test.go b/app/dns/dns_test.go index 8ccfe8407..575fda271 100644 --- a/app/dns/dns_test.go +++ b/app/dns/dns_test.go @@ -148,7 +148,7 @@ func TestUDPServerSubnet(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -210,7 +210,7 @@ func TestUDPServer(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -350,7 +350,7 @@ func TestPrioritizedDomain(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -421,7 +421,7 @@ func TestUDPServerIPv6(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -490,7 +490,7 @@ func TestStaticHostDomain(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -577,7 +577,7 @@ func TestIPMatch(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -696,7 +696,7 @@ func TestLocalDomain(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -953,7 +953,7 @@ func TestMultiMatchPrioritizedDomain(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/app/dns/nameserver.go b/app/dns/nameserver.go index 5112f3581..7ba3a798f 100644 --- a/app/dns/nameserver.go +++ b/app/dns/nameserver.go @@ -68,6 +68,10 @@ func NewServer(ctx context.Context, dest net.Destination, dispatcher routing.Dis return NewTCPNameServer(u, dispatcher, disableCache, serveStale, serveExpiredTTL, clientIP) case strings.EqualFold(u.Scheme, "tcp+local"): // DNS-over-TCP Local mode return NewTCPLocalNameServer(u, disableCache, serveStale, serveExpiredTTL, clientIP) + case strings.EqualFold(u.Scheme, "udp"): // UDP DNS Remote mode + return NewUDPNameServer(u, dispatcher, false, disableCache, serveStale, serveExpiredTTL, clientIP) + case strings.EqualFold(u.Scheme, "udp+local"): // UDP DNS Local mode + return NewUDPNameServer(u, dispatcher, true, disableCache, serveStale, serveExpiredTTL, clientIP) case strings.EqualFold(u.String(), "fakedns"): var fd dns.FakeDNSEngine err = core.RequireFeatures(ctx, func(fdns dns.FakeDNSEngine) { diff --git a/app/dns/nameserver_udp.go b/app/dns/nameserver_udp.go index 7761662fb..4d303a735 100644 --- a/app/dns/nameserver_udp.go +++ b/app/dns/nameserver_udp.go @@ -2,12 +2,15 @@ package dns import ( "context" + "io" + "net/url" "strings" "sync" "sync/atomic" "time" "github.com/xtls/xray-core/common" + "github.com/xtls/xray-core/common/buf" "github.com/xtls/xray-core/common/errors" "github.com/xtls/xray-core/common/net" "github.com/xtls/xray-core/common/protocol/dns" @@ -15,6 +18,8 @@ import ( "github.com/xtls/xray-core/common/task" dns_feature "github.com/xtls/xray-core/features/dns" "github.com/xtls/xray-core/features/routing" + "github.com/xtls/xray-core/transport" + "github.com/xtls/xray-core/transport/internet" "github.com/xtls/xray-core/transport/internet/udp" "golang.org/x/net/dns/dnsmessage" ) @@ -59,6 +64,46 @@ func NewClassicNameServer(address net.Destination, dispatcher routing.Dispatcher return s } +// NewUDPNameServer creates a UDP DNS client from a URL. +func NewUDPNameServer(url *url.URL, dispatcher routing.Dispatcher, local bool, disableCache bool, serveStale bool, serveExpiredTTL uint32, clientIP net.IP) (*ClassicNameServer, error) { + if url.Hostname() == "" { + return nil, errors.New("missing UDP nameserver host") + } + port := net.Port(53) + if url.Port() != "" { + var err error + if port, err = net.PortFromString(url.Port()); err != nil { + return nil, err + } + } + if local { + dispatcher = &localUDPDispatcher{dispatcher} + } + s := NewClassicNameServer(net.UDPDestination(net.ParseAddress(url.Hostname()), port), dispatcher, disableCache, serveStale, serveExpiredTTL, clientIP) + if local { + s.cacheController.name = "UDPL//" + s.address.NetAddr() + } + return s, nil +} + +type localUDPDispatcher struct { + routing.Dispatcher +} + +func (*localUDPDispatcher) Dispatch(ctx context.Context, dest net.Destination) (*transport.Link, error) { + conn, err := internet.DialSystem(ctx, dest, nil) + if err != nil { + return nil, err + } + return &transport.Link{ + Reader: &struct { + buf.Reader + io.Closer + }{buf.NewPacketReader(conn), conn}, + Writer: buf.NewWriter(conn), + }, nil +} + // Name implements Server. func (s *ClassicNameServer) Name() string { return s.cacheController.name diff --git a/app/proxyman/outbound/handler_test.go b/app/proxyman/outbound/handler_test.go index 702944298..b9e6ecfa1 100644 --- a/app/proxyman/outbound/handler_test.go +++ b/app/proxyman/outbound/handler_test.go @@ -48,7 +48,7 @@ func TestOutboundWithoutStatCounter(t *testing.T) { ctx = session.ContextWithOutbounds(ctx, []*session.Outbound{{}}) h, _ := NewHandler(ctx, &core.OutboundHandlerConfig{ Tag: "tag", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }) conn, _ := h.(*Handler).Dial(ctx, net.TCPDestination(net.DomainAddress("localhost"), 13146)) _, ok := conn.(*stat.CounterConnection) @@ -78,7 +78,7 @@ func TestOutboundWithStatCounter(t *testing.T) { ctx = session.ContextWithOutbounds(ctx, []*session.Outbound{{}}) h, _ := NewHandler(ctx, &core.OutboundHandlerConfig{ Tag: "tag", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }) conn, _ := h.(*Handler).Dial(ctx, net.TCPDestination(net.DomainAddress("localhost"), 13146)) _, ok := conn.(*stat.CounterConnection) @@ -117,7 +117,7 @@ func TestTagsCache(t *testing.T) { tag := fmt.Sprintf("%s%d", tags_prefix, idx) cfg := &core.OutboundHandlerConfig{ Tag: tag, - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), } if h, err := NewHandler(ctx, cfg); err == nil { if err := ohm.AddHandler(ctx, h); err == nil { diff --git a/app/router/script_test.go b/app/router/script_test.go index 599ebbf7d..6d68b5eb0 100644 --- a/app/router/script_test.go +++ b/app/router/script_test.go @@ -24,7 +24,6 @@ import ( "github.com/xtls/xray-core/features/outbound" "github.com/xtls/xray-core/features/routing" routing_session "github.com/xtls/xray-core/features/routing/session" - "github.com/xtls/xray-core/proxy/blackhole" "github.com/xtls/xray-core/proxy/freedom" ) @@ -397,9 +396,9 @@ end`) serial.ToTypedMessage(&proxyman.OutboundConfig{}), }, Outbound: []*core.OutboundHandlerConfig{ - {Tag: "default", ProxySettings: serial.ToTypedMessage(&blackhole.Config{})}, + {Tag: "default", ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}})}, {Tag: "direct", ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, })}, }, }) diff --git a/core/functions_test.go b/core/functions_test.go index e1f13894c..030785dfb 100644 --- a/core/functions_test.go +++ b/core/functions_test.go @@ -53,7 +53,7 @@ func TestXrayDial(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -105,7 +105,7 @@ func TestXrayDialUDPConn(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -174,7 +174,7 @@ func TestXrayDialUDP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/infra/conf/blackhole.go b/infra/conf/blackhole.go index 7046d1efe..c203927ca 100644 --- a/infra/conf/blackhole.go +++ b/infra/conf/blackhole.go @@ -5,7 +5,8 @@ import ( "strings" "github.com/xtls/xray-core/common/errors" - "github.com/xtls/xray-core/proxy/blackhole" + "github.com/xtls/xray-core/common/log" + "github.com/xtls/xray-core/proxy/freedom" "google.golang.org/protobuf/proto" ) @@ -19,24 +20,29 @@ type BlackholeConfig struct { } func (v *BlackholeConfig) Build() (proto.Message, error) { - config := new(blackhole.Config) + errors.PrintDeprecatedFeatureWarning(`"blackhole" outbound`, `"freedom" outbound with a blocking "firewall" rule`) + rule := &freedom.FirewallConfig{ + Action: freedom.RuleAction_Block, + Delay: &freedom.Range{}, + LogLevel: log.Severity_Unknown.Enum(), + } if v.Response != nil { responseName := strings.ToLower(v.Response.Type) switch responseName { case "none", "": - config.Response = &blackhole.Response{Type: "none"} + rule.Reply = &freedom.Reply{Type: "none"} case "http": - config.Response = &blackhole.Response{Type: "http"} + rule.Reply = &freedom.Reply{Type: "http"} case "custom": data, err := base64.StdEncoding.DecodeString(v.Response.CustomResponseData) if err != nil { return nil, errors.New("failed to decode custom response data: " + err.Error()) } - config.Response = &blackhole.Response{Type: "custom", CustomResponseData: data} + rule.Reply = &freedom.Reply{Type: "custom", CustomResponseData: data} default: return nil, errors.New("unknown blackhole response: " + responseName) } } - return config, nil + return &freedom.Config{Firewall: []*freedom.FirewallConfig{rule}}, nil } diff --git a/infra/conf/blackhole_test.go b/infra/conf/blackhole_test.go index 83e9b1f22..a959b9cff 100644 --- a/infra/conf/blackhole_test.go +++ b/infra/conf/blackhole_test.go @@ -3,8 +3,9 @@ package conf_test import ( "testing" + "github.com/xtls/xray-core/common/log" . "github.com/xtls/xray-core/infra/conf" - "github.com/xtls/xray-core/proxy/blackhole" + "github.com/xtls/xray-core/proxy/freedom" ) func TestHTTPResponseJSON(t *testing.T) { @@ -20,14 +21,25 @@ func TestHTTPResponseJSON(t *testing.T) { } }`, Parser: loadJSON(creator), - Output: &blackhole.Config{ - Response: &blackhole.Response{Type: "http"}, + Output: &freedom.Config{ + Firewall: []*freedom.FirewallConfig{{ + Action: freedom.RuleAction_Block, + Delay: &freedom.Range{}, + LogLevel: log.Severity_Unknown.Enum(), + Reply: &freedom.Reply{Type: "http"}, + }}, }, }, { Input: `{}`, Parser: loadJSON(creator), - Output: &blackhole.Config{}, + Output: &freedom.Config{ + Firewall: []*freedom.FirewallConfig{{ + Action: freedom.RuleAction_Block, + Delay: &freedom.Range{}, + LogLevel: log.Severity_Unknown.Enum(), + }}, + }, }, }) } @@ -46,11 +58,16 @@ func TestCustomResponseJSON(t *testing.T) { } }`, Parser: loadJSON(creator), - Output: &blackhole.Config{ - Response: &blackhole.Response{ - Type: "custom", - CustomResponseData: []byte("custom response"), - }, + Output: &freedom.Config{ + Firewall: []*freedom.FirewallConfig{{ + Action: freedom.RuleAction_Block, + Delay: &freedom.Range{}, + LogLevel: log.Severity_Unknown.Enum(), + Reply: &freedom.Reply{ + Type: "custom", + CustomResponseData: []byte("custom response"), + }, + }}, }, }, }) diff --git a/infra/conf/freedom.go b/infra/conf/freedom.go index d825e032b..5384c7d9a 100644 --- a/infra/conf/freedom.go +++ b/infra/conf/freedom.go @@ -18,16 +18,17 @@ import ( ) type FreedomConfig struct { - TargetStrategy string `json:"targetStrategy"` - DomainStrategy string `json:"domainStrategy"` - Redirect string `json:"redirect"` - UserLevel uint32 `json:"userLevel"` - Fragment *Fragment `json:"fragment"` - Noise *Noise `json:"noise"` - Noises []*Noise `json:"noises"` - ProxyProtocol uint32 `json:"proxyProtocol"` - IPsBlocked *StringList `json:"ipsBlocked"` - FinalRules []*FreedomFinalRuleConfig `json:"finalRules"` + TargetStrategy string `json:"targetStrategy"` + DomainStrategy string `json:"domainStrategy"` + Redirect string `json:"redirect"` + UserLevel uint32 `json:"userLevel"` + Fragment *Fragment `json:"fragment"` + Noise *Noise `json:"noise"` + Noises []*Noise `json:"noises"` + ProxyProtocol uint32 `json:"proxyProtocol"` + IPsBlocked *StringList `json:"ipsBlocked"` + Firewall []*FreedomFirewallConfig `json:"firewall"` + FinalRules []*FreedomFirewallConfig `json:"finalRules"` } type Fragment struct { @@ -44,21 +45,45 @@ type Noise struct { ApplyTo string `json:"applyTo"` } -type FreedomFinalRuleConfig struct { - Action string `json:"action"` - Network *NetworkList `json:"network"` - Port *PortList `json:"port"` - IP *StringList `json:"ip"` - Delay *Int32Range `json:"delay"` - LogLevel string `json:"logLevel"` - BlockDelay *Int32Range `json:"blockDelay"` +type FreedomFirewallConfig struct { + Action string `json:"action"` + Network *NetworkList `json:"network"` + Port *PortList `json:"port"` + IP *StringList `json:"ip"` + Delay *Int32Range `json:"delay"` + LogLevel string `json:"logLevel"` + Reply *FreedomReplyConfig `json:"reply"` + BlockDelay *Int32Range `json:"blockDelay"` +} + +type FreedomReplyConfig struct { + Type string `json:"type"` + CustomResponseData string `json:"customResponseData"` +} + +func (c *FreedomReplyConfig) Build() (*freedom.Reply, error) { + replyType := strings.ToLower(c.Type) + switch replyType { + case "none", "": + return &freedom.Reply{Type: "none"}, nil + case "http": + return &freedom.Reply{Type: "http"}, nil + case "custom": + data, err := base64.StdEncoding.DecodeString(c.CustomResponseData) + if err != nil { + return nil, errors.New("failed to decode custom reply data: " + err.Error()) + } + return &freedom.Reply{Type: "custom", CustomResponseData: data}, nil + default: + return nil, errors.New("unknown firewall reply: " + replyType) + } } // Build implements Buildable func (c *FreedomConfig) Build() (proto.Message, error) { if c.IPsBlocked != nil { // todo: remove legacy - errors.LogWarning(context.Background(), `The feature "ipsBlocked" has been removed and migrated to "finalRules". Please update your config(s) according to release note and documentation.`) + errors.LogWarning(context.Background(), `The feature "ipsBlocked" has been removed and migrated to "firewall". Please update your config(s) according to release note and documentation.`) } config := new(freedom.Config) @@ -184,15 +209,22 @@ func (c *FreedomConfig) Build() (proto.Message, error) { } if c.ProxyProtocol > 0 && c.ProxyProtocol <= 2 { - config.ProxyProtocol = c.ProxyProtocol + errors.PrintDeprecatedFeatureWarning(`"proxyProtocol" in Freedom`, `"proxy-protocol" in "streamSettings.finalmask.tcp"`) } - for _, r := range c.FinalRules { + firewall := c.Firewall + if c.FinalRules != nil { + errors.PrintDeprecatedFeatureWarning("finalRules", "firewall") + if firewall == nil { + firewall = c.FinalRules + } + } + for _, r := range firewall { rule, err := r.Build() if err != nil { return nil, err } - config.FinalRules = append(config.FinalRules, rule) + config.Firewall = append(config.Firewall, rule) } return config, nil @@ -254,8 +286,8 @@ func ParseNoise(noise *Noise) (*freedom.Noise, error) { return NConfig, nil } -func (c *FreedomFinalRuleConfig) Build() (*freedom.FinalRuleConfig, error) { - rule := &freedom.FinalRuleConfig{} +func (c *FreedomFirewallConfig) Build() (*freedom.FirewallConfig, error) { + rule := &freedom.FirewallConfig{} switch strings.ToLower(c.Action) { case "allow": @@ -283,13 +315,13 @@ func (c *FreedomFinalRuleConfig) Build() (*freedom.FinalRuleConfig, error) { } if c.BlockDelay != nil { - errors.PrintDeprecatedFeatureWarning("finalRules.blockDelay", "finalRules.delay") + errors.PrintDeprecatedFeatureWarning("firewall.blockDelay", "firewall.delay") c.Delay = c.BlockDelay } if rule.Action != freedom.RuleAction_Block { - if c.Delay != nil || c.LogLevel != "" { - return nil, errors.New("delay and logLevel are only supported for block finalRules") + if c.Delay != nil || c.LogLevel != "" || c.Reply != nil { + return nil, errors.New("delay, logLevel and reply are only supported for firewall action block") } return rule, nil } @@ -301,6 +333,14 @@ func (c *FreedomFinalRuleConfig) Build() (*freedom.FinalRuleConfig, error) { } } + if c.Reply != nil { + reply, err := c.Reply.Build() + if err != nil { + return nil, err + } + rule.Reply = reply + } + switch strings.ToLower(c.LogLevel) { case "", "info": rule.LogLevel = log.Severity_Info.Enum() @@ -313,7 +353,7 @@ func (c *FreedomFinalRuleConfig) Build() (*freedom.FinalRuleConfig, error) { case "error": rule.LogLevel = log.Severity_Error.Enum() default: - return nil, errors.New("unknown finalRules.logLevel: ", c.LogLevel) + return nil, errors.New("unknown firewall.logLevel: ", c.LogLevel) } return rule, nil diff --git a/infra/conf/freedom_test.go b/infra/conf/freedom_test.go index 1d50fee7b..af29e9eeb 100644 --- a/infra/conf/freedom_test.go +++ b/infra/conf/freedom_test.go @@ -42,13 +42,17 @@ func TestFreedomConfig(t *testing.T) { }, { Input: `{ - "finalRules": [{ + "firewall": [{ "action": "block", "network": "tcp,udp", "port": "53,443", "ip": ["10.0.0.0/8", "2001:db8::/32"], "delay": "30-60", - "logLevel": "debug" + "logLevel": "debug", + "reply": { + "type": "custom", + "customResponseData": "Y3VzdG9tIHJlc3BvbnNl" + } }, { "action": "allow", "network": ["udp"] @@ -56,7 +60,7 @@ func TestFreedomConfig(t *testing.T) { }`, Parser: loadJSON(creator), Output: &freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{ + Firewall: []*freedom.FirewallConfig{ { Action: freedom.RuleAction_Block, Networks: []net.Network{net.Network_TCP, net.Network_UDP}, @@ -90,6 +94,10 @@ func TestFreedomConfig(t *testing.T) { }, Delay: &freedom.Range{Min: 30, Max: 60}, LogLevel: log.Severity_Debug.Enum(), + Reply: &freedom.Reply{ + Type: "custom", + CustomResponseData: []byte("custom response"), + }, }, { Action: freedom.RuleAction_Allow, diff --git a/infra/conf/transport_finalmask.go b/infra/conf/transport_finalmask.go index 6f3292313..1873159d2 100644 --- a/infra/conf/transport_finalmask.go +++ b/infra/conf/transport_finalmask.go @@ -18,6 +18,7 @@ import ( "github.com/xtls/xray-core/common/geodata" xlua "github.com/xtls/xray-core/common/lua" "github.com/xtls/xray-core/common/net" + "github.com/xtls/xray-core/common/serial" "github.com/xtls/xray-core/transport/internet" "github.com/xtls/xray-core/transport/internet/finalmask/filter" "github.com/xtls/xray-core/transport/internet/finalmask/fragment" @@ -26,6 +27,7 @@ import ( "github.com/xtls/xray-core/transport/internet/finalmask/mkcp/header" "github.com/xtls/xray-core/transport/internet/finalmask/mkcp/original" "github.com/xtls/xray-core/transport/internet/finalmask/noise" + "github.com/xtls/xray-core/transport/internet/finalmask/proxyprotocol" "github.com/xtls/xray-core/transport/internet/finalmask/realm" "github.com/xtls/xray-core/transport/internet/finalmask/salamander" "github.com/xtls/xray-core/transport/internet/finalmask/sudoku" @@ -76,11 +78,12 @@ var ( customVarNamePattern = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`) tcpmaskLoader = NewJSONConfigLoader(ConfigCreatorCache{ - "filter": func() interface{} { return new(Filter) }, - "header-custom": func() interface{} { return new(HeaderCustomTCP) }, - "fragment": func() interface{} { return new(FragmentMask) }, - "sudoku": func() interface{} { return new(Sudoku) }, - "xmc": func() interface{} { return new(XMC) }, + "filter": func() interface{} { return new(Filter) }, + "header-custom": func() interface{} { return new(HeaderCustomTCP) }, + "proxy-protocol": func() interface{} { return new(ProxyProtocol) }, + "fragment": func() interface{} { return new(FragmentMask) }, + "sudoku": func() interface{} { return new(Sudoku) }, + "xmc": func() interface{} { return new(XMC) }, }, "type", "settings") udpmaskLoader = NewJSONConfigLoader(ConfigCreatorCache{ @@ -97,6 +100,32 @@ var ( }, "type", "settings") ) +type ProxyProtocol struct { + Version uint32 `json:"version"` +} + +func (c *ProxyProtocol) Build() (proto.Message, error) { + version := c.Version + if version == 0 { + version = 2 + } + if version != 1 && version != 2 { + return nil, errors.New("PROXY protocol version must be 1 or 2") + } + return &proxyprotocol.Config{Version: version}, nil +} + +func addProxyProtocolMask(config *internet.StreamConfig, version uint32) { + mask := serial.ToTypedMessage(&proxyprotocol.Config{Version: version}) + for _, existing := range config.Tcpmasks { + if existing.Type == mask.Type { + return + } + } + // Put the header directly on the socket, before the other masks. + config.Tcpmasks = append(config.Tcpmasks, mask) +} + type Filter struct { BlockedSourceIPs []string `json:"blockedSourceIPs"` AllowedSourceIPs []string `json:"allowedSourceIPs"` @@ -932,9 +961,25 @@ func (c *XDNS) Build() (proto.Message, error) { } type XMC struct { - Hostname string `json:"hostname"` - Profiles []XMCProfile `json:"profiles"` - Password string `json:"password"` + Hostname string `json:"hostname"` + Profiles []XMCProfile `json:"profiles"` + Password string `json:"password"` + Paddings []XMCPaddingTurn `json:"paddings,omitempty"` + // A configured list is the complete padding schedule and replaces the + // built-in preset entirely, including the preset's Play-state join tail. + // NoPadding disables padding. An explicit empty "paddings" array means the + // same; an absent one keeps the built-in preset. + NoPadding bool `json:"noPadding,omitempty"` +} + +type XMCPaddingTurn struct { + Length string `json:"length"` + Direction string `json:"direction"` + // Delay is an optional millisecond value or inclusive min-max range: the + // pause that leads into this turn, written on the turn that follows the gap + // it reproduces. The sending side samples the range, the peer spends its + // minimum, and nothing pauses after the last turn. + Delay string `json:"delay,omitempty"` } type XMCProfile struct { @@ -977,6 +1022,48 @@ func (c *XMC) Build() (proto.Message, error) { if c.Password == "" { return nil, fmt.Errorf("empty password") } + if len(c.Password) > xmc.MaxLegacyPasswordLength { + return nil, fmt.Errorf("minecraft password is longer than %d bytes", xmc.MaxLegacyPasswordLength) + } + // An explicit empty array is different from an absent field: json leaves + // Paddings nil when it is absent, so the user can turn padding off without + // a second switch. + noPadding := c.NoPadding || (c.Paddings != nil && len(c.Paddings) == 0) + if noPadding && len(c.Paddings) > 0 { + return nil, fmt.Errorf("minecraft padding: noPadding and paddings are exclusive") + } + config := &xmc.Config{Password: c.Password, Hostname: c.Hostname, NoPadding: noPadding} + for i, turn := range c.Paddings { + minimum, maximum, err := ParseRangeString(turn.Length) + if err != nil { + return nil, fmt.Errorf("minecraft padding turn %d length: %w", i, err) + } + delayMinimum, delayMaximum, err := ParseRangeString(turn.Delay) + if err != nil { + return nil, fmt.Errorf("minecraft padding turn %d delay: %w", i, err) + } + + var direction int32 + switch turn.Direction { + case "c2s", "client-to-server": + direction = 1 + case "s2c", "server-to-client": + direction = 2 + default: + return nil, fmt.Errorf("minecraft padding turn %d: invalid direction %q (must be \"c2s\" or \"s2c\")", i, turn.Direction) + } + + config.Paddings = append(config.Paddings, &xmc.Padding{ + LengthMin: int64(minimum), + LengthMax: int64(maximum), + Direction: direction, + DelayMin: int64(delayMinimum), + DelayMax: int64(delayMaximum), + }) + } + if err := config.ValidatePadding(); err != nil { + return nil, fmt.Errorf("minecraft padding: %w", err) + } rsaPrivateKey, err := xmc.DeriveRSAKey(c.Password) if err != nil { @@ -997,13 +1084,10 @@ func (c *XMC) Build() (proto.Message, error) { profiles = append(profiles, profile) } - return &xmc.Config{ - Password: c.Password, - Hostname: c.Hostname, - RsaPrivateKey: x509.MarshalPKCS1PrivateKey(rsaPrivateKey), - RsaPublicKey: rsaPublicKey, - Profiles: profiles, - }, nil + config.RsaPrivateKey = x509.MarshalPKCS1PrivateKey(rsaPrivateKey) + config.RsaPublicKey = rsaPublicKey + config.Profiles = profiles + return config, nil } type Xicmp struct { diff --git a/infra/conf/transport_finalmask_xmc_test.go b/infra/conf/transport_finalmask_xmc_test.go index 5d4257456..1ce0b1474 100644 --- a/infra/conf/transport_finalmask_xmc_test.go +++ b/infra/conf/transport_finalmask_xmc_test.go @@ -1,6 +1,7 @@ package conf import ( + "encoding/json" "strings" "testing" @@ -10,6 +11,11 @@ import ( func TestXMCBuildProfile(t *testing.T) { built, err := (&XMC{ Password: "test-password", + Paddings: []XMCPaddingTurn{ + {Length: "3", Direction: "c2s"}, + {Length: "127-129", Direction: "s2c", Delay: "100"}, + {Length: "8388608", Direction: "c2s", Delay: "50-150"}, + }, Profiles: []XMCProfile{ { Username: "TestUser", @@ -26,6 +32,19 @@ func TestXMCBuildProfile(t *testing.T) { if len(config.Profiles) != 1 || len(config.Profiles[0].Uuid) != 16 { t.Fatalf("unexpected profiles: %+v", config.Profiles) } + if len(config.Paddings) != 3 || config.Paddings[0].LengthMin != 3 || config.Paddings[0].LengthMax != 3 || + config.Paddings[1].LengthMin != 127 || config.Paddings[1].LengthMax != 129 || + config.Paddings[2].LengthMin != 8388608 || config.Paddings[2].LengthMax != 8388608 { + t.Fatalf("unexpected padding: %v", config.Paddings) + } + if config.Paddings[0].Direction != 1 || config.Paddings[1].Direction != 2 || config.Paddings[2].Direction != 1 { + t.Fatalf("unexpected padding directions: %v, %v, %v", config.Paddings[0].Direction, config.Paddings[1].Direction, config.Paddings[2].Direction) + } + if config.Paddings[0].DelayMin != 0 || config.Paddings[0].DelayMax != 0 || + config.Paddings[1].DelayMin != 100 || config.Paddings[1].DelayMax != 100 || + config.Paddings[2].DelayMin != 50 || config.Paddings[2].DelayMax != 150 { + t.Fatalf("unexpected padding delays: %v, %v, %v", config.Paddings[0].DelayMin, config.Paddings[1].DelayMin, config.Paddings[2].DelayMin) + } } func TestXMCBuildRequiresProfile(t *testing.T) { @@ -34,3 +53,101 @@ func TestXMCBuildRequiresProfile(t *testing.T) { t.Fatalf("expected required profiles error, got %v", err) } } + +func TestXMCBuildRejectsPadding(t *testing.T) { + for name, padding := range map[string]string{ + "empty_length": `[{"length": "", "direction": "c2s"}]`, + "zero_length": `[{"length": "0", "direction": "c2s"}]`, + "one_length": `[{"length": "1", "direction": "c2s"}]`, + "two_length": `[{"length": "2", "direction": "c2s"}]`, + "negative_length": `[{"length": "-1", "direction": "c2s"}]`, + "reversed_range": `[{"length": "64-32", "direction": "c2s"}]`, + "oversized_length": `[{"length": "8388609", "direction": "c2s"}]`, + "huge_length": `[{"length": "4294967299", "direction": "c2s"}]`, + "overflow_length": `[{"length": "9223372036854775808", "direction": "c2s"}]`, + "invalid_range_format": `[{"length": "1-2-3", "direction": "c2s"}]`, + "invalid_direction": `[{"length": "3", "direction": "invalid"}]`, + "missing_direction": `[{"length": "3"}]`, + "numeric_direction": `[{"length": "3", "direction": "1"}]`, + "negative_delay": `[{"length": "3", "direction": "c2s", "delay": "-1"}]`, + "reversed_delay": `[{"length": "3", "direction": "c2s", "delay": "10-5"}]`, + "invalid_delay_format": `[{"length": "3", "direction": "c2s", "delay": "abc"}]`, + "huge_delay": `[{"length": "3", "direction": "c2s", "delay": "9223372036854775807"}]`, + } { + t.Run(name, func(t *testing.T) { + var config XMC + if err := json.Unmarshal([]byte(`{"paddings":`+padding+`}`), &config); err != nil { + t.Fatal(err) + } + config.Password = "test-password" + config.Profiles = []XMCProfile{{ + Username: "TestUser", UUID: "00112233-4455-6677-8899-aabbccddeeff", + TexturesValue: "textures-value", TexturesSignature: "textures-signature", + }} + if _, err := config.Build(); err == nil { + t.Fatalf("expected error for padding %s, got success", padding) + } else { + t.Logf("correctly rejected: %v", err) + } + }) + } +} + +func TestXMCBuildRejectsLongPassword(t *testing.T) { + profile := XMCProfile{ + Username: "TestUser", UUID: "00112233-4455-6677-8899-aabbccddeeff", + TexturesValue: "textures-value", TexturesSignature: "textures-signature", + } + + // The verify token and the password share one RSA-1024 PKCS#1 v1.5 block, + // so the password cannot exceed xmc.MaxLegacyPasswordLength bytes. + valid := strings.Repeat("p", xmc.MaxLegacyPasswordLength) + if _, err := (&XMC{Password: valid, Profiles: []XMCProfile{profile}}).Build(); err != nil { + t.Fatalf("password of %d bytes was rejected: %v", len(valid), err) + } + + tooLong := valid + "p" + _, err := (&XMC{Password: tooLong, Profiles: []XMCProfile{profile}}).Build() + if err == nil || !strings.Contains(err.Error(), "longer than") { + t.Fatalf("expected a password length error, got %v", err) + } +} + +func TestXMCBuildDisablesPadding(t *testing.T) { + profile := XMCProfile{ + Username: "TestUser", UUID: "00112233-4455-6677-8899-aabbccddeeff", + TexturesValue: "textures-value", TexturesSignature: "textures-signature", + } + + for name, settings := range map[string]string{ + "explicit_empty_array": `{"paddings": []}`, + "no_padding_switch": `{"noPadding": true}`, + } { + t.Run(name, func(t *testing.T) { + var config XMC + if err := json.Unmarshal([]byte(settings), &config); err != nil { + t.Fatal(err) + } + config.Password = "test-password" + config.Profiles = []XMCProfile{profile} + built, err := config.Build() + if err != nil { + t.Fatalf("build XMC config: %v", err) + } + builtConfig := built.(*xmc.Config) + if !builtConfig.NoPadding || len(builtConfig.Paddings) != 0 { + t.Fatalf("padding was not disabled: %+v", builtConfig) + } + }) + } + + var config XMC + if err := json.Unmarshal([]byte(`{"noPadding": true, "paddings": [{"length": "3", "direction": "c2s"}]}`), &config); err != nil { + t.Fatal(err) + } + config.Password = "test-password" + config.Profiles = []XMCProfile{profile} + if _, err := config.Build(); err == nil || !strings.Contains(err.Error(), "exclusive") { + t.Fatalf("expected an exclusive padding error, got %v", err) + } +} diff --git a/infra/conf/xray.go b/infra/conf/xray.go index 2c94ce55c..3a88eaca7 100644 --- a/infra/conf/xray.go +++ b/infra/conf/xray.go @@ -407,7 +407,16 @@ func (c *OutboundDetourConfig) Build() (*core.OutboundHandlerConfig, error) { return nil, errors.New("the masque transport can only be used by the masque outbound") } - if fc, ok := ts.(*freedom.Config); ok { + if _, ok := rawConfig.(*BlackholeConfig); ok { + // The legacy blackhole outbound never used its transport settings. + senderSettings.StreamSettings = nil + } else if fc, ok := ts.(*freedom.Config); ok { + if legacy := rawConfig.(*FreedomConfig); legacy.ProxyProtocol > 0 && legacy.ProxyProtocol <= 2 { + if senderSettings.StreamSettings == nil { + senderSettings.StreamSettings = &internet.StreamConfig{} + } + addProxyProtocolMask(senderSettings.StreamSettings, legacy.ProxyProtocol) + } if senderSettings.StreamSettings != nil && senderSettings.StreamSettings.SocketSettings != nil && senderSettings.StreamSettings.SocketSettings.AddressPortStrategy != internet.AddressPortStrategy_None { diff --git a/main/distro/all/all.go b/main/distro/all/all.go index 840d0e146..712f3eb77 100644 --- a/main/distro/all/all.go +++ b/main/distro/all/all.go @@ -35,7 +35,6 @@ import ( _ "github.com/xtls/xray-core/app/observatory" // Inbound and outbound proxies. - _ "github.com/xtls/xray-core/proxy/blackhole" _ "github.com/xtls/xray-core/proxy/dns" _ "github.com/xtls/xray-core/proxy/dokodemo" _ "github.com/xtls/xray-core/proxy/freedom" diff --git a/proxy/blackhole/blackhole.go b/proxy/blackhole/blackhole.go deleted file mode 100644 index ee0ee7b08..000000000 --- a/proxy/blackhole/blackhole.go +++ /dev/null @@ -1,88 +0,0 @@ -// Package blackhole is an outbound handler that blocks all connections. -package blackhole - -import ( - "bytes" - "context" - "net/http" - "time" - - "github.com/xtls/xray-core/common" - "github.com/xtls/xray-core/common/buf" - "github.com/xtls/xray-core/common/dice" - "github.com/xtls/xray-core/common/errors" - "github.com/xtls/xray-core/common/net" - "github.com/xtls/xray-core/common/session" - "github.com/xtls/xray-core/common/signal" - "github.com/xtls/xray-core/transport" - "github.com/xtls/xray-core/transport/internet" -) - -// Handler is an outbound connection that silently swallow the entire payload. -type Handler struct { - response []byte -} - -var http403response = http.Response{ - StatusCode: 403, - ProtoMajor: 1, - ProtoMinor: 1, - Header: http.Header{ - "Connection": {"close"}, - "Cache-Control": {"max-age=3600, public"}, - }, -} - -// New creates a new blackhole handler. -func New(ctx context.Context, config *Config) (*Handler, error) { - response := []byte{} - if config.Response != nil { - switch config.Response.Type { - case "", "none": - case "http": - var data bytes.Buffer - common.Must(http403response.Write(&data)) - response = data.Bytes() - case "custom": - response = config.Response.CustomResponseData - default: - return nil, errors.New("unknown blackhole response: " + config.Response.Type) - } - } - return &Handler{ - response: response, - }, nil -} - -// Process implements OutboundHandler.Dispatch(). -func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer internet.Dialer) error { - outbounds := session.OutboundsFromContext(ctx) - ob := outbounds[len(outbounds)-1] - ob.Name = "blackhole" - - if len(h.response) > 0 { - mbc := buf.MultiBufferContainer{} - common.Must2(mbc.Write(h.response)) - link.Writer.WriteMultiBuffer(mbc.MultiBuffer) - // Sleep a little here to make sure the response is sent to client. - time.Sleep(time.Second) - } - defer common.Interrupt(link.Writer) - defer common.Interrupt(link.Reader) - // wait to drain all the possible incoming UDP data - if ob.Target.Network == net.Network_UDP { - ctx, cancel := context.WithCancel(ctx) - timer := signal.CancelAfterInactivity(ctx, func() { - cancel() - }, time.Duration(30+dice.Roll(61))*time.Second) - go buf.Copy(link.Reader, buf.Discard, buf.UpdateActivity(timer)) - <-ctx.Done() - } - return nil -} - -func init() { - common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) { - return New(ctx, config.(*Config)) - })) -} diff --git a/proxy/blackhole/blackhole_test.go b/proxy/blackhole/blackhole_test.go deleted file mode 100644 index ac1822757..000000000 --- a/proxy/blackhole/blackhole_test.go +++ /dev/null @@ -1,76 +0,0 @@ -package blackhole_test - -import ( - "bufio" - "bytes" - "context" - "crypto/rand" - "net/http" - "testing" - - "github.com/xtls/xray-core/common" - "github.com/xtls/xray-core/common/buf" - "github.com/xtls/xray-core/common/session" - "github.com/xtls/xray-core/proxy/blackhole" - "github.com/xtls/xray-core/transport" - "github.com/xtls/xray-core/transport/pipe" -) - -func TestBlackholeHTTPResponse(t *testing.T) { - ctx := session.ContextWithOutbounds(context.Background(), []*session.Outbound{{}}) - handler, err := blackhole.New(ctx, &blackhole.Config{ - Response: &blackhole.Response{Type: "http"}, - }) - common.Must(err) - - reader, writer := pipe.New(pipe.WithoutSizeLimit()) - - dataCh := make(chan buf.MultiBuffer, 1) - go func() { - mb := common.Must2(reader.ReadMultiBuffer()) - dataCh <- mb - }() - link := transport.Link{ - Reader: reader, - Writer: writer, - } - common.Must(handler.Process(ctx, &link, nil)) - mb := <-dataCh - data := make([]byte, mb.Len()) - mb.Copy(data) - resp := common.Must2(http.ReadResponse(bufio.NewReader(bytes.NewBuffer(data)), nil)) - if resp.StatusCode != 403 { - t.Errorf("expected 403 response, got %d", resp.StatusCode) - } -} - -func TestBlackholeCustomResponse(t *testing.T) { - ctx := session.ContextWithOutbounds(context.Background(), []*session.Outbound{{}}) - // slightly bigger than a buffer - expected := make([]byte, buf.Size+1000) - if _, err := rand.Read(expected); err != nil { - t.Fatal(err) - } - handler, err := blackhole.New(ctx, &blackhole.Config{ - Response: &blackhole.Response{ - Type: "custom", - CustomResponseData: expected, - }, - }) - common.Must(err) - - reader, writer := pipe.New(pipe.WithoutSizeLimit()) - var actual buf.MultiBuffer - var rerr error - go func() { - actual, rerr = reader.ReadMultiBuffer() - }() - - link := transport.Link{Reader: reader, Writer: writer} - common.Must(handler.Process(ctx, &link, nil)) - common.Must(rerr) - - if actual.String() != string(expected) { - t.Errorf("custom response mismatch") - } -} diff --git a/proxy/blackhole/config.pb.go b/proxy/blackhole/config.pb.go deleted file mode 100644 index 74f6d1e02..000000000 --- a/proxy/blackhole/config.pb.go +++ /dev/null @@ -1,180 +0,0 @@ -// Code generated by protoc-gen-go. DO NOT EDIT. -// versions: -// protoc-gen-go v1.36.12 -// protoc (unknown) -// source: proxy/blackhole/config.proto - -package blackhole - -import ( - protoreflect "google.golang.org/protobuf/reflect/protoreflect" - protoimpl "google.golang.org/protobuf/runtime/protoimpl" - reflect "reflect" - sync "sync" - unsafe "unsafe" -) - -const ( - // Verify that this generated code is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) - // Verify that runtime/protoimpl is sufficiently up-to-date. - _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) -) - -type Response struct { - state protoimpl.MessageState `protogen:"open.v1"` - Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` - CustomResponseData []byte `protobuf:"bytes,2,opt,name=custom_response_data,json=customResponseData,proto3" json:"custom_response_data,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Response) Reset() { - *x = Response{} - mi := &file_proxy_blackhole_config_proto_msgTypes[0] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Response) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Response) ProtoMessage() {} - -func (x *Response) ProtoReflect() protoreflect.Message { - mi := &file_proxy_blackhole_config_proto_msgTypes[0] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Response.ProtoReflect.Descriptor instead. -func (*Response) Descriptor() ([]byte, []int) { - return file_proxy_blackhole_config_proto_rawDescGZIP(), []int{0} -} - -func (x *Response) GetType() string { - if x != nil { - return x.Type - } - return "" -} - -func (x *Response) GetCustomResponseData() []byte { - if x != nil { - return x.CustomResponseData - } - return nil -} - -type Config struct { - state protoimpl.MessageState `protogen:"open.v1"` - Response *Response `protobuf:"bytes,1,opt,name=response,proto3" json:"response,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache -} - -func (x *Config) Reset() { - *x = Config{} - mi := &file_proxy_blackhole_config_proto_msgTypes[1] - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - ms.StoreMessageInfo(mi) -} - -func (x *Config) String() string { - return protoimpl.X.MessageStringOf(x) -} - -func (*Config) ProtoMessage() {} - -func (x *Config) ProtoReflect() protoreflect.Message { - mi := &file_proxy_blackhole_config_proto_msgTypes[1] - if x != nil { - ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) - if ms.LoadMessageInfo() == nil { - ms.StoreMessageInfo(mi) - } - return ms - } - return mi.MessageOf(x) -} - -// Deprecated: Use Config.ProtoReflect.Descriptor instead. -func (*Config) Descriptor() ([]byte, []int) { - return file_proxy_blackhole_config_proto_rawDescGZIP(), []int{1} -} - -func (x *Config) GetResponse() *Response { - if x != nil { - return x.Response - } - return nil -} - -var File_proxy_blackhole_config_proto protoreflect.FileDescriptor - -const file_proxy_blackhole_config_proto_rawDesc = "" + - "\n" + - "\x1cproxy/blackhole/config.proto\x12\x14xray.proxy.blackhole\"P\n" + - "\bResponse\x12\x12\n" + - "\x04type\x18\x01 \x01(\tR\x04type\x120\n" + - "\x14custom_response_data\x18\x02 \x01(\fR\x12customResponseData\"D\n" + - "\x06Config\x12:\n" + - "\bresponse\x18\x01 \x01(\v2\x1e.xray.proxy.blackhole.ResponseR\bresponseB^\n" + - "\x18com.xray.proxy.blackholeP\x01Z)github.com/xtls/xray-core/proxy/blackhole\xaa\x02\x14Xray.Proxy.Blackholeb\x06proto3" - -var ( - file_proxy_blackhole_config_proto_rawDescOnce sync.Once - file_proxy_blackhole_config_proto_rawDescData []byte -) - -func file_proxy_blackhole_config_proto_rawDescGZIP() []byte { - file_proxy_blackhole_config_proto_rawDescOnce.Do(func() { - file_proxy_blackhole_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proxy_blackhole_config_proto_rawDesc), len(file_proxy_blackhole_config_proto_rawDesc))) - }) - return file_proxy_blackhole_config_proto_rawDescData -} - -var file_proxy_blackhole_config_proto_msgTypes = make([]protoimpl.MessageInfo, 2) -var file_proxy_blackhole_config_proto_goTypes = []any{ - (*Response)(nil), // 0: xray.proxy.blackhole.Response - (*Config)(nil), // 1: xray.proxy.blackhole.Config -} -var file_proxy_blackhole_config_proto_depIdxs = []int32{ - 0, // 0: xray.proxy.blackhole.Config.response:type_name -> xray.proxy.blackhole.Response - 1, // [1:1] is the sub-list for method output_type - 1, // [1:1] is the sub-list for method input_type - 1, // [1:1] is the sub-list for extension type_name - 1, // [1:1] is the sub-list for extension extendee - 0, // [0:1] is the sub-list for field type_name -} - -func init() { file_proxy_blackhole_config_proto_init() } -func file_proxy_blackhole_config_proto_init() { - if File_proxy_blackhole_config_proto != nil { - return - } - type x struct{} - out := protoimpl.TypeBuilder{ - File: protoimpl.DescBuilder{ - GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: unsafe.Slice(unsafe.StringData(file_proxy_blackhole_config_proto_rawDesc), len(file_proxy_blackhole_config_proto_rawDesc)), - NumEnums: 0, - NumMessages: 2, - NumExtensions: 0, - NumServices: 0, - }, - GoTypes: file_proxy_blackhole_config_proto_goTypes, - DependencyIndexes: file_proxy_blackhole_config_proto_depIdxs, - MessageInfos: file_proxy_blackhole_config_proto_msgTypes, - }.Build() - File_proxy_blackhole_config_proto = out.File - file_proxy_blackhole_config_proto_goTypes = nil - file_proxy_blackhole_config_proto_depIdxs = nil -} diff --git a/proxy/blackhole/config.proto b/proxy/blackhole/config.proto deleted file mode 100644 index 93b4d8e7b..000000000 --- a/proxy/blackhole/config.proto +++ /dev/null @@ -1,16 +0,0 @@ -syntax = "proto3"; - -package xray.proxy.blackhole; -option csharp_namespace = "Xray.Proxy.Blackhole"; -option go_package = "github.com/xtls/xray-core/proxy/blackhole"; -option java_package = "com.xray.proxy.blackhole"; -option java_multiple_files = true; - -message Response { - string type = 1; - bytes custom_response_data = 2; -} - -message Config { - Response response = 1; -} diff --git a/proxy/blackhole/config_test.go b/proxy/blackhole/config_test.go deleted file mode 100644 index f54cb0154..000000000 --- a/proxy/blackhole/config_test.go +++ /dev/null @@ -1,19 +0,0 @@ -package blackhole_test - -import ( - "context" - "testing" - - "github.com/xtls/xray-core/common" - "github.com/xtls/xray-core/proxy/blackhole" -) - -func TestHTTPResponse(t *testing.T) { - handler, err := blackhole.New(context.Background(), &blackhole.Config{ - Response: &blackhole.Response{Type: "http"}, - }) - common.Must(err) - if handler == nil { - t.Error("expected HTTP response handler") - } -} diff --git a/proxy/freedom/config.pb.go b/proxy/freedom/config.pb.go index 4bc9c1849..ced63563e 100644 --- a/proxy/freedom/config.pb.go +++ b/proxy/freedom/config.pb.go @@ -352,32 +352,28 @@ func (x *Range) GetMax() uint64 { return 0 } -type FinalRuleConfig struct { - state protoimpl.MessageState `protogen:"open.v1"` - Action RuleAction `protobuf:"varint,1,opt,name=action,proto3,enum=xray.proxy.freedom.RuleAction" json:"action,omitempty"` - Networks []net.Network `protobuf:"varint,2,rep,packed,name=networks,proto3,enum=xray.common.net.Network" json:"networks,omitempty"` - PortList *net.PortList `protobuf:"bytes,3,opt,name=port_list,json=portList,proto3" json:"port_list,omitempty"` - Ip []*geodata.IPRule `protobuf:"bytes,4,rep,name=ip,proto3" json:"ip,omitempty"` - Delay *Range `protobuf:"bytes,5,opt,name=delay,proto3" json:"delay,omitempty"` - LogLevel *log.Severity `protobuf:"varint,6,opt,name=log_level,json=logLevel,proto3,enum=xray.common.log.Severity,oneof" json:"log_level,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache +type Reply struct { + state protoimpl.MessageState `protogen:"open.v1"` + Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` + CustomResponseData []byte `protobuf:"bytes,2,opt,name=custom_response_data,json=customResponseData,proto3" json:"custom_response_data,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } -func (x *FinalRuleConfig) Reset() { - *x = FinalRuleConfig{} +func (x *Reply) Reset() { + *x = Reply{} mi := &file_proxy_freedom_config_proto_msgTypes[4] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *FinalRuleConfig) String() string { +func (x *Reply) String() string { return protoimpl.X.MessageStringOf(x) } -func (*FinalRuleConfig) ProtoMessage() {} +func (*Reply) ProtoMessage() {} -func (x *FinalRuleConfig) ProtoReflect() protoreflect.Message { +func (x *Reply) ProtoReflect() protoreflect.Message { mi := &file_proxy_freedom_config_proto_msgTypes[4] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) @@ -389,69 +385,132 @@ func (x *FinalRuleConfig) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use FinalRuleConfig.ProtoReflect.Descriptor instead. -func (*FinalRuleConfig) Descriptor() ([]byte, []int) { +// Deprecated: Use Reply.ProtoReflect.Descriptor instead. +func (*Reply) Descriptor() ([]byte, []int) { return file_proxy_freedom_config_proto_rawDescGZIP(), []int{4} } -func (x *FinalRuleConfig) GetAction() RuleAction { +func (x *Reply) GetType() string { + if x != nil { + return x.Type + } + return "" +} + +func (x *Reply) GetCustomResponseData() []byte { + if x != nil { + return x.CustomResponseData + } + return nil +} + +type FirewallConfig struct { + state protoimpl.MessageState `protogen:"open.v1"` + Action RuleAction `protobuf:"varint,1,opt,name=action,proto3,enum=xray.proxy.freedom.RuleAction" json:"action,omitempty"` + Networks []net.Network `protobuf:"varint,2,rep,packed,name=networks,proto3,enum=xray.common.net.Network" json:"networks,omitempty"` + PortList *net.PortList `protobuf:"bytes,3,opt,name=port_list,json=portList,proto3" json:"port_list,omitempty"` + Ip []*geodata.IPRule `protobuf:"bytes,4,rep,name=ip,proto3" json:"ip,omitempty"` + Delay *Range `protobuf:"bytes,5,opt,name=delay,proto3" json:"delay,omitempty"` + LogLevel *log.Severity `protobuf:"varint,6,opt,name=log_level,json=logLevel,proto3,enum=xray.common.log.Severity,oneof" json:"log_level,omitempty"` + Reply *Reply `protobuf:"bytes,7,opt,name=reply,proto3" json:"reply,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *FirewallConfig) Reset() { + *x = FirewallConfig{} + mi := &file_proxy_freedom_config_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *FirewallConfig) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*FirewallConfig) ProtoMessage() {} + +func (x *FirewallConfig) ProtoReflect() protoreflect.Message { + mi := &file_proxy_freedom_config_proto_msgTypes[5] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use FirewallConfig.ProtoReflect.Descriptor instead. +func (*FirewallConfig) Descriptor() ([]byte, []int) { + return file_proxy_freedom_config_proto_rawDescGZIP(), []int{5} +} + +func (x *FirewallConfig) GetAction() RuleAction { if x != nil { return x.Action } return RuleAction_Allow } -func (x *FinalRuleConfig) GetNetworks() []net.Network { +func (x *FirewallConfig) GetNetworks() []net.Network { if x != nil { return x.Networks } return nil } -func (x *FinalRuleConfig) GetPortList() *net.PortList { +func (x *FirewallConfig) GetPortList() *net.PortList { if x != nil { return x.PortList } return nil } -func (x *FinalRuleConfig) GetIp() []*geodata.IPRule { +func (x *FirewallConfig) GetIp() []*geodata.IPRule { if x != nil { return x.Ip } return nil } -func (x *FinalRuleConfig) GetDelay() *Range { +func (x *FirewallConfig) GetDelay() *Range { if x != nil { return x.Delay } return nil } -func (x *FinalRuleConfig) GetLogLevel() log.Severity { +func (x *FirewallConfig) GetLogLevel() log.Severity { if x != nil && x.LogLevel != nil { return *x.LogLevel } return log.Severity(0) } +func (x *FirewallConfig) GetReply() *Reply { + if x != nil { + return x.Reply + } + return nil +} + type Config struct { state protoimpl.MessageState `protogen:"open.v1"` DomainStrategy internet.DomainStrategy `protobuf:"varint,1,opt,name=domain_strategy,json=domainStrategy,proto3,enum=xray.transport.internet.DomainStrategy" json:"domain_strategy,omitempty"` DestinationOverride *DestinationOverride `protobuf:"bytes,3,opt,name=destination_override,json=destinationOverride,proto3" json:"destination_override,omitempty"` UserLevel uint32 `protobuf:"varint,4,opt,name=user_level,json=userLevel,proto3" json:"user_level,omitempty"` Fragment *Fragment `protobuf:"bytes,5,opt,name=fragment,proto3" json:"fragment,omitempty"` - ProxyProtocol uint32 `protobuf:"varint,6,opt,name=proxy_protocol,json=proxyProtocol,proto3" json:"proxy_protocol,omitempty"` Noises []*Noise `protobuf:"bytes,7,rep,name=noises,proto3" json:"noises,omitempty"` - FinalRules []*FinalRuleConfig `protobuf:"bytes,8,rep,name=final_rules,json=finalRules,proto3" json:"final_rules,omitempty"` + Firewall []*FirewallConfig `protobuf:"bytes,8,rep,name=firewall,proto3" json:"firewall,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *Config) Reset() { *x = Config{} - mi := &file_proxy_freedom_config_proto_msgTypes[5] + mi := &file_proxy_freedom_config_proto_msgTypes[6] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -463,7 +522,7 @@ func (x *Config) String() string { func (*Config) ProtoMessage() {} func (x *Config) ProtoReflect() protoreflect.Message { - mi := &file_proxy_freedom_config_proto_msgTypes[5] + mi := &file_proxy_freedom_config_proto_msgTypes[6] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -476,7 +535,7 @@ func (x *Config) ProtoReflect() protoreflect.Message { // Deprecated: Use Config.ProtoReflect.Descriptor instead. func (*Config) Descriptor() ([]byte, []int) { - return file_proxy_freedom_config_proto_rawDescGZIP(), []int{5} + return file_proxy_freedom_config_proto_rawDescGZIP(), []int{6} } func (x *Config) GetDomainStrategy() internet.DomainStrategy { @@ -507,13 +566,6 @@ func (x *Config) GetFragment() *Fragment { return nil } -func (x *Config) GetProxyProtocol() uint32 { - if x != nil { - return x.ProxyProtocol - } - return 0 -} - func (x *Config) GetNoises() []*Noise { if x != nil { return x.Noises @@ -521,9 +573,9 @@ func (x *Config) GetNoises() []*Noise { return nil } -func (x *Config) GetFinalRules() []*FinalRuleConfig { +func (x *Config) GetFirewall() []*FirewallConfig { if x != nil { - return x.FinalRules + return x.Firewall } return nil } @@ -558,26 +610,28 @@ const file_proxy_freedom_config_proto_rawDesc = "" + "\bapply_to\x18\x06 \x01(\tR\aapplyTo\"+\n" + "\x05Range\x12\x10\n" + "\x03min\x18\x01 \x01(\x04R\x03min\x12\x10\n" + - "\x03max\x18\x02 \x01(\x04R\x03max\"\xe0\x02\n" + - "\x0fFinalRuleConfig\x126\n" + + "\x03max\x18\x02 \x01(\x04R\x03max\"M\n" + + "\x05Reply\x12\x12\n" + + "\x04type\x18\x01 \x01(\tR\x04type\x120\n" + + "\x14custom_response_data\x18\x02 \x01(\fR\x12customResponseData\"\x90\x03\n" + + "\x0eFirewallConfig\x126\n" + "\x06action\x18\x01 \x01(\x0e2\x1e.xray.proxy.freedom.RuleActionR\x06action\x124\n" + "\bnetworks\x18\x02 \x03(\x0e2\x18.xray.common.net.NetworkR\bnetworks\x126\n" + "\tport_list\x18\x03 \x01(\v2\x19.xray.common.net.PortListR\bportList\x12+\n" + "\x02ip\x18\x04 \x03(\v2\x1b.xray.common.geodata.IPRuleR\x02ip\x12/\n" + "\x05delay\x18\x05 \x01(\v2\x19.xray.proxy.freedom.RangeR\x05delay\x12;\n" + - "\tlog_level\x18\x06 \x01(\x0e2\x19.xray.common.log.SeverityH\x00R\blogLevel\x88\x01\x01B\f\n" + + "\tlog_level\x18\x06 \x01(\x0e2\x19.xray.common.log.SeverityH\x00R\blogLevel\x88\x01\x01\x12/\n" + + "\x05reply\x18\a \x01(\v2\x19.xray.proxy.freedom.ReplyR\x05replyB\f\n" + "\n" + - "_log_level\"\xaf\x03\n" + + "_log_level\"\x88\x03\n" + "\x06Config\x12P\n" + "\x0fdomain_strategy\x18\x01 \x01(\x0e2'.xray.transport.internet.DomainStrategyR\x0edomainStrategy\x12Z\n" + "\x14destination_override\x18\x03 \x01(\v2'.xray.proxy.freedom.DestinationOverrideR\x13destinationOverride\x12\x1d\n" + "\n" + "user_level\x18\x04 \x01(\rR\tuserLevel\x128\n" + - "\bfragment\x18\x05 \x01(\v2\x1c.xray.proxy.freedom.FragmentR\bfragment\x12%\n" + - "\x0eproxy_protocol\x18\x06 \x01(\rR\rproxyProtocol\x121\n" + - "\x06noises\x18\a \x03(\v2\x19.xray.proxy.freedom.NoiseR\x06noises\x12D\n" + - "\vfinal_rules\x18\b \x03(\v2#.xray.proxy.freedom.FinalRuleConfigR\n" + - "finalRules*\"\n" + + "\bfragment\x18\x05 \x01(\v2\x1c.xray.proxy.freedom.FragmentR\bfragment\x121\n" + + "\x06noises\x18\a \x03(\v2\x19.xray.proxy.freedom.NoiseR\x06noises\x12>\n" + + "\bfirewall\x18\b \x03(\v2\".xray.proxy.freedom.FirewallConfigR\bfirewallJ\x04\b\x06\x10\a*\"\n" + "\n" + "RuleAction\x12\t\n" + "\x05Allow\x10\x00\x12\t\n" + @@ -597,40 +651,42 @@ func file_proxy_freedom_config_proto_rawDescGZIP() []byte { } var file_proxy_freedom_config_proto_enumTypes = make([]protoimpl.EnumInfo, 1) -var file_proxy_freedom_config_proto_msgTypes = make([]protoimpl.MessageInfo, 6) +var file_proxy_freedom_config_proto_msgTypes = make([]protoimpl.MessageInfo, 7) var file_proxy_freedom_config_proto_goTypes = []any{ (RuleAction)(0), // 0: xray.proxy.freedom.RuleAction (*DestinationOverride)(nil), // 1: xray.proxy.freedom.DestinationOverride (*Fragment)(nil), // 2: xray.proxy.freedom.Fragment (*Noise)(nil), // 3: xray.proxy.freedom.Noise (*Range)(nil), // 4: xray.proxy.freedom.Range - (*FinalRuleConfig)(nil), // 5: xray.proxy.freedom.FinalRuleConfig - (*Config)(nil), // 6: xray.proxy.freedom.Config - (*protocol.ServerEndpoint)(nil), // 7: xray.common.protocol.ServerEndpoint - (net.Network)(0), // 8: xray.common.net.Network - (*net.PortList)(nil), // 9: xray.common.net.PortList - (*geodata.IPRule)(nil), // 10: xray.common.geodata.IPRule - (log.Severity)(0), // 11: xray.common.log.Severity - (internet.DomainStrategy)(0), // 12: xray.transport.internet.DomainStrategy + (*Reply)(nil), // 5: xray.proxy.freedom.Reply + (*FirewallConfig)(nil), // 6: xray.proxy.freedom.FirewallConfig + (*Config)(nil), // 7: xray.proxy.freedom.Config + (*protocol.ServerEndpoint)(nil), // 8: xray.common.protocol.ServerEndpoint + (net.Network)(0), // 9: xray.common.net.Network + (*net.PortList)(nil), // 10: xray.common.net.PortList + (*geodata.IPRule)(nil), // 11: xray.common.geodata.IPRule + (log.Severity)(0), // 12: xray.common.log.Severity + (internet.DomainStrategy)(0), // 13: xray.transport.internet.DomainStrategy } var file_proxy_freedom_config_proto_depIdxs = []int32{ - 7, // 0: xray.proxy.freedom.DestinationOverride.server:type_name -> xray.common.protocol.ServerEndpoint - 0, // 1: xray.proxy.freedom.FinalRuleConfig.action:type_name -> xray.proxy.freedom.RuleAction - 8, // 2: xray.proxy.freedom.FinalRuleConfig.networks:type_name -> xray.common.net.Network - 9, // 3: xray.proxy.freedom.FinalRuleConfig.port_list:type_name -> xray.common.net.PortList - 10, // 4: xray.proxy.freedom.FinalRuleConfig.ip:type_name -> xray.common.geodata.IPRule - 4, // 5: xray.proxy.freedom.FinalRuleConfig.delay:type_name -> xray.proxy.freedom.Range - 11, // 6: xray.proxy.freedom.FinalRuleConfig.log_level:type_name -> xray.common.log.Severity - 12, // 7: xray.proxy.freedom.Config.domain_strategy:type_name -> xray.transport.internet.DomainStrategy - 1, // 8: xray.proxy.freedom.Config.destination_override:type_name -> xray.proxy.freedom.DestinationOverride - 2, // 9: xray.proxy.freedom.Config.fragment:type_name -> xray.proxy.freedom.Fragment - 3, // 10: xray.proxy.freedom.Config.noises:type_name -> xray.proxy.freedom.Noise - 5, // 11: xray.proxy.freedom.Config.final_rules:type_name -> xray.proxy.freedom.FinalRuleConfig - 12, // [12:12] is the sub-list for method output_type - 12, // [12:12] is the sub-list for method input_type - 12, // [12:12] is the sub-list for extension type_name - 12, // [12:12] is the sub-list for extension extendee - 0, // [0:12] is the sub-list for field type_name + 8, // 0: xray.proxy.freedom.DestinationOverride.server:type_name -> xray.common.protocol.ServerEndpoint + 0, // 1: xray.proxy.freedom.FirewallConfig.action:type_name -> xray.proxy.freedom.RuleAction + 9, // 2: xray.proxy.freedom.FirewallConfig.networks:type_name -> xray.common.net.Network + 10, // 3: xray.proxy.freedom.FirewallConfig.port_list:type_name -> xray.common.net.PortList + 11, // 4: xray.proxy.freedom.FirewallConfig.ip:type_name -> xray.common.geodata.IPRule + 4, // 5: xray.proxy.freedom.FirewallConfig.delay:type_name -> xray.proxy.freedom.Range + 12, // 6: xray.proxy.freedom.FirewallConfig.log_level:type_name -> xray.common.log.Severity + 5, // 7: xray.proxy.freedom.FirewallConfig.reply:type_name -> xray.proxy.freedom.Reply + 13, // 8: xray.proxy.freedom.Config.domain_strategy:type_name -> xray.transport.internet.DomainStrategy + 1, // 9: xray.proxy.freedom.Config.destination_override:type_name -> xray.proxy.freedom.DestinationOverride + 2, // 10: xray.proxy.freedom.Config.fragment:type_name -> xray.proxy.freedom.Fragment + 3, // 11: xray.proxy.freedom.Config.noises:type_name -> xray.proxy.freedom.Noise + 6, // 12: xray.proxy.freedom.Config.firewall:type_name -> xray.proxy.freedom.FirewallConfig + 13, // [13:13] is the sub-list for method output_type + 13, // [13:13] is the sub-list for method input_type + 13, // [13:13] is the sub-list for extension type_name + 13, // [13:13] is the sub-list for extension extendee + 0, // [0:13] is the sub-list for field type_name } func init() { file_proxy_freedom_config_proto_init() } @@ -638,14 +694,14 @@ func file_proxy_freedom_config_proto_init() { if File_proxy_freedom_config_proto != nil { return } - file_proxy_freedom_config_proto_msgTypes[4].OneofWrappers = []any{} + file_proxy_freedom_config_proto_msgTypes[5].OneofWrappers = []any{} type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_proxy_freedom_config_proto_rawDesc), len(file_proxy_freedom_config_proto_rawDesc)), NumEnums: 1, - NumMessages: 6, + NumMessages: 7, NumExtensions: 0, NumServices: 0, }, diff --git a/proxy/freedom/config.proto b/proxy/freedom/config.proto index 9a218877d..2a6dd33d5 100644 --- a/proxy/freedom/config.proto +++ b/proxy/freedom/config.proto @@ -47,21 +47,27 @@ enum RuleAction { Block = 1; } -message FinalRuleConfig { +message Reply { + string type = 1; + bytes custom_response_data = 2; +} + +message FirewallConfig { RuleAction action = 1; repeated xray.common.net.Network networks = 2; xray.common.net.PortList port_list = 3; repeated xray.common.geodata.IPRule ip = 4; Range delay = 5; optional xray.common.log.Severity log_level = 6; + Reply reply = 7; } message Config { + reserved 6; xray.transport.internet.DomainStrategy domain_strategy = 1; DestinationOverride destination_override = 3; uint32 user_level = 4; Fragment fragment = 5; - uint32 proxy_protocol = 6; repeated Noise noises = 7; - repeated FinalRuleConfig final_rules = 8; + repeated FirewallConfig firewall = 8; } diff --git a/proxy/freedom/freedom.go b/proxy/freedom/freedom.go index f656e1f3b..94fc158fb 100644 --- a/proxy/freedom/freedom.go +++ b/proxy/freedom/freedom.go @@ -1,14 +1,15 @@ package freedom import ( + "bytes" "context" "crypto/rand" "io" + "net/http" "strings" "sync/atomic" "time" - "github.com/pires/go-proxyproto" "github.com/xtls/xray-core/common" "github.com/xtls/xray-core/common/buf" "github.com/xtls/xray-core/common/crypto" @@ -35,10 +36,20 @@ import ( var ( useSplice atomic.Bool allNetworks [8]bool - defaultBlockPrivateRule *FinalRule - defaultBlockAllRule *FinalRule + defaultBlockPrivateRule *Firewall + defaultBlockAllRule *Firewall ) +var http403response = http.Response{ + StatusCode: 403, + ProtoMajor: 1, + ProtoMinor: 1, + Header: http.Header{ + "Connection": {"close"}, + "Cache-Control": {"max-age=3600, public"}, + }, +} + func reloadEnvSettings() error { const defaultFlagValue = "NOT_DEFINED_AT_ALL" value := platform.NewEnvFlag(platform.UseFreedomSplice).GetValue(func() string { return defaultFlagValue }) @@ -72,45 +83,60 @@ func init() { allNetworks[i] = true } - defaultBlockPrivateRule = &FinalRule{ + defaultBlockPrivateRule = &Firewall{ action: RuleAction_Block, network: allNetworks, ip: geodata.GetPrivateIPMatcher(), logLevel: log.Severity_Warning.Enum(), } - defaultBlockAllRule = &FinalRule{ + defaultBlockAllRule = &Firewall{ action: RuleAction_Block, network: allNetworks, logLevel: log.Severity_Warning.Enum(), } } -type FinalRule struct { +type Firewall struct { action RuleAction network [8]bool port net.MemoryPortList ip geodata.IPMatcher delay *Range logLevel *log.Severity + reply []byte } // Handler handles Freedom connections. type Handler struct { policyManager policy.Manager config *Config - finalRules []*FinalRule + firewall []*Firewall resolveStrategy internet.DomainStrategy usesDialerProxy bool } -func buildFinalRule(config *FinalRuleConfig) (*FinalRule, error) { - rule := &FinalRule{ +func buildRule(config *FirewallConfig) (*Firewall, error) { + rule := &Firewall{ action: config.GetAction(), delay: config.GetDelay(), logLevel: config.LogLevel, } + if config.Reply != nil { + switch config.Reply.Type { + case "", "none": + case "http": + var data bytes.Buffer + common.Must(http403response.Write(&data)) + rule.reply = data.Bytes() + case "custom": + rule.reply = config.Reply.CustomResponseData + default: + return nil, errors.New("unknown firewall reply: " + config.Reply.Type) + } + } + if len(config.Networks) == 0 { rule.network = allNetworks } else { @@ -134,25 +160,25 @@ func buildFinalRule(config *FinalRuleConfig) (*FinalRule, error) { return rule, nil } -func (r *FinalRule) matchNetwork(network net.Network) bool { +func (r *Firewall) matchNetwork(network net.Network) bool { return r.network[int(network)] } -func (r *FinalRule) matchPort(port net.Port) bool { +func (r *Firewall) matchPort(port net.Port) bool { if len(r.port) == 0 { return true } return r.port.Contains(port) } -func (r *FinalRule) matchIP(addr net.Address) bool { +func (r *Firewall) matchIP(addr net.Address) bool { if r.ip == nil { return true } return addr != nil && addr.Family().IsIP() && r.ip.Match(addr.IP()) } -func (r *FinalRule) Apply(network net.Network, address net.Address, port net.Port) bool { +func (r *Firewall) Apply(network net.Network, address net.Address, port net.Port) bool { if !r.matchNetwork(network) { return false } @@ -162,7 +188,7 @@ func (r *FinalRule) Apply(network net.Network, address net.Address, port net.Por return r.matchIP(address) } -func getDefaultFinalRule(inbound *session.Inbound) *FinalRule { +func getDefaultRule(inbound *session.Inbound) *Firewall { if inbound == nil { return nil } @@ -179,8 +205,8 @@ func getDefaultFinalRule(inbound *session.Inbound) *FinalRule { return nil } -func (h *Handler) matchFinalRule(network net.Network, address net.Address, port net.Port, defaultRule *FinalRule) *FinalRule { - for _, rule := range h.finalRules { +func (h *Handler) matchRule(network net.Network, address net.Address, port net.Port, defaultRule *Firewall) *Firewall { + for _, rule := range h.firewall { if rule.Apply(network, address, port) { return rule } @@ -195,19 +221,19 @@ func (h *Handler) matchFinalRule(network net.Network, address net.Address, port func (h *Handler) Init(config *Config, pm policy.Manager) error { h.config = config h.policyManager = pm - if h.usesDialerProxy { // freedom is not the final outbound, final rules do not apply - if len(config.FinalRules) > 0 { - errors.LogWarning(context.Background(), `The "finalRules" setting is ignored when "sockopt.dialerProxy" is set, since freedom is not the final outbound.`) + if h.usesDialerProxy { // freedom is not the final outbound, firewall does not apply + if len(config.Firewall) > 0 { + errors.LogWarning(context.Background(), `The "firewall" setting is ignored when "sockopt.dialerProxy" is set, since freedom is not the final outbound.`) } return nil } - h.finalRules = make([]*FinalRule, 0, len(config.FinalRules)) - for _, rc := range config.FinalRules { - rule, err := buildFinalRule(rc) + h.firewall = make([]*Firewall, 0, len(config.Firewall)) + for _, rc := range config.Firewall { + rule, err := buildRule(rc) if err != nil { - return errors.New("failed to build final rule").Base(err) + return errors.New("failed to build firewall rule").Base(err) } - h.finalRules = append(h.finalRules, rule) + h.firewall = append(h.firewall, rule) } return nil } @@ -217,7 +243,7 @@ func (h *Handler) policy() policy.Session { return p } -func (r *FinalRule) blockDuration() time.Duration { +func (r *Firewall) blockDuration() time.Duration { min := uint64(30) max := uint64(90) if r.delay != nil { @@ -231,7 +257,7 @@ func (r *FinalRule) blockDuration() time.Duration { return time.Duration(min+uint64(dice.Roll(int(span+1)))) * time.Second } -func (r *FinalRule) log(ctx context.Context, msg ...interface{}) { +func (r *Firewall) log(ctx context.Context, msg ...interface{}) { level := log.Severity_Info if r.logLevel != nil { level = *r.logLevel @@ -248,10 +274,17 @@ func (r *FinalRule) log(ctx context.Context, msg ...interface{}) { } } -func (h *Handler) blackhole(ctx context.Context, input buf.Reader, output buf.Writer, rule *FinalRule, dest *net.Destination) error { +func (h *Handler) blackhole(ctx context.Context, input buf.Reader, output buf.Writer, rule *Firewall, dest *net.Destination) error { delay := rule.blockDuration() - rule.log(ctx, "target blocked by a finalrule: ", *dest, ", blackholing connection for ", delay) + rule.log(ctx, "target blocked by a firewall rule: ", *dest, ", blackholing connection for ", delay) defer common.Close(output) + if len(rule.reply) > 0 { + mbc := buf.MultiBufferContainer{} + common.Must2(mbc.Write(rule.reply)) + output.WriteMultiBuffer(mbc.MultiBuffer) + // Sleep a little here to make sure the reply is sent to client. + time.Sleep(time.Second) + } done := make(chan struct{}) go func() { // a DispatchLink inbound's reader ignores Interrupt, so don't wait for this copy _ = buf.Copy(input, buf.Discard) @@ -286,10 +319,16 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte ob.Name = "freedom" ob.CanSpliceCopy = 1 + if !h.usesDialerProxy && len(h.firewall) > 0 { + rule := h.firewall[0] + if rule.action == RuleAction_Block && rule.network == allNetworks && len(rule.port) == 0 && rule.ip == nil { + return h.blackhole(ctx, link.Reader, link.Writer, rule, &ob.Target) + } + } inbound := session.InboundFromContext(ctx) - var defaultRule *FinalRule - if !h.usesDialerProxy { // freedom is not the final outbound, final rules do not apply (and the domain is not resolved) - defaultRule = getDefaultFinalRule(inbound) + var defaultRule *Firewall + if !h.usesDialerProxy { // freedom is not the final outbound, firewall does not apply (and the domain is not resolved) + defaultRule = getDefaultRule(inbound) } destination := ob.Target @@ -321,10 +360,10 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte var conn stat.Connection var blockedDest *net.Destination - var blockedRule *FinalRule + var blockedRule *Firewall err := retry.ExponentialBackoff(5, 100).On(func() error { if destination.Address.Family().IsDomain() { - if defaultRule != nil || len(h.finalRules) > 0 { + if defaultRule != nil || len(h.firewall) > 0 { if strategy := h.resolveStrategy; strategy.HasStrategy() { ips, err := internet.LookupForIP(destination.Address.Domain(), strategy, outGateway) if err != nil { // non-force may still dial with system DNS @@ -335,7 +374,7 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte } for _, ip := range ips { if addr := net.IPAddress(ip); addr != nil { - if rule := h.matchFinalRule(destination.Network, addr, destination.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { + if rule := h.matchRule(destination.Network, addr, destination.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { blockedDest = &destination blockedDest.Address = addr blockedRule = rule @@ -350,7 +389,7 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte } for _, addr := range addrs { if ipAddr := net.IPAddress(addr.IP); ipAddr != nil { - if rule := h.matchFinalRule(destination.Network, ipAddr, destination.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { + if rule := h.matchRule(destination.Network, ipAddr, destination.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { blockedDest = &destination blockedDest.Address = ipAddr blockedRule = rule @@ -361,7 +400,7 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte } } } else { - if rule := h.matchFinalRule(destination.Network, destination.Address, destination.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { + if rule := h.matchRule(destination.Network, destination.Address, destination.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { blockedDest = &destination blockedRule = rule return nil @@ -382,25 +421,15 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte if blockedDest != nil { return h.blackhole(ctx, input, output, blockedRule, blockedDest) } - if destination.Address.Family().IsDomain() && (defaultRule != nil || len(h.finalRules) > 0) { + if destination.Address.Family().IsDomain() && (defaultRule != nil || len(h.firewall) > 0) { // pre-check may fail or dialer may select another IP remoteDest := net.DestinationFromAddr(conn.RemoteAddr()) - if rule := h.matchFinalRule(remoteDest.Network, remoteDest.Address, remoteDest.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { + if rule := h.matchRule(remoteDest.Network, remoteDest.Address, remoteDest.Port, defaultRule); rule != nil && rule.action == RuleAction_Block { conn.Close() return h.blackhole(ctx, input, output, rule, &remoteDest) } } - if h.config.ProxyProtocol > 0 && h.config.ProxyProtocol <= 2 { - version := byte(h.config.ProxyProtocol) - srcAddr := inbound.Source.RawNetAddr() - dstAddr := conn.RemoteAddr() - header := proxyproto.HeaderProxyFromAddrs(version, srcAddr, dstAddr) - if _, err = header.WriteTo(conn); err != nil { - conn.Close() - return errors.New("failed to set PROXY protocol v", version).Base(err) - } - } defer conn.Close() errors.LogInfo(ctx, "connection opened to ", destination, ", local endpoint ", conn.LocalAddr(), ", remote endpoint ", conn.RemoteAddr()) @@ -489,7 +518,7 @@ func (h *Handler) Process(ctx context.Context, link *transport.Link, dialer inte return nil } -func NewPacketReader(conn net.Conn, h *Handler, defaultRule *FinalRule, UDPOverride net.Destination, DialDest net.Destination) buf.Reader { +func NewPacketReader(conn net.Conn, h *Handler, defaultRule *Firewall, UDPOverride net.Destination, DialDest net.Destination) buf.Reader { iConn := conn statConn, ok := iConn.(*stat.CounterConnection) if ok { @@ -522,7 +551,7 @@ type PacketReader struct { *net.PacketConnWrapper stats.Counter Handler *Handler - DefaultRule *FinalRule + DefaultRule *Firewall IsOverridden bool InitUnchangedAddr net.Address InitChangedAddr net.Address @@ -539,7 +568,7 @@ func (r *PacketReader) ReadMultiBuffer() (buf.MultiBuffer, error) { } udpAddr := d.(*net.UDPAddr) sourceAddr := net.IPAddress(udpAddr.IP) - if rule := r.Handler.matchFinalRule(net.Network_UDP, sourceAddr, net.Port(udpAddr.Port), r.DefaultRule); rule != nil && rule.action == RuleAction_Block { + if rule := r.Handler.matchRule(net.Network_UDP, sourceAddr, net.Port(udpAddr.Port), r.DefaultRule); rule != nil && rule.action == RuleAction_Block { continue } b.Resize(0, int32(n)) @@ -564,7 +593,7 @@ func (r *PacketReader) ReadMultiBuffer() (buf.MultiBuffer, error) { } // DialDest means the dial target used in the dialer when creating conn -func NewPacketWriter(conn net.Conn, h *Handler, defaultRule *FinalRule, UDPOverride net.Destination, DialDest net.Destination, outGateway net.Address) buf.Writer { +func NewPacketWriter(conn net.Conn, h *Handler, defaultRule *Firewall, UDPOverride net.Destination, DialDest net.Destination, outGateway net.Address) buf.Writer { iConn := conn statConn, ok := iConn.(*stat.CounterConnection) if ok { @@ -598,7 +627,7 @@ type PacketWriter struct { *net.PacketConnWrapper stats.Counter *Handler - DefaultRule *FinalRule + DefaultRule *Firewall UDPOverride net.Destination // Dest of udp packets might be a domain, we will resolve them to IP @@ -657,7 +686,7 @@ func (w *PacketWriter) WriteMultiBuffer(mb buf.MultiBuffer) error { } } } - if rule := w.matchFinalRule(net.Network_UDP, b.UDP.Address, b.UDP.Port, w.DefaultRule); rule != nil && rule.action == RuleAction_Block { + if rule := w.matchRule(net.Network_UDP, b.UDP.Address, b.UDP.Port, w.DefaultRule); rule != nil && rule.action == RuleAction_Block { b.Release() continue } diff --git a/proxy/freedom/freedom_test.go b/proxy/freedom/freedom_test.go new file mode 100644 index 000000000..a7940a76a --- /dev/null +++ b/proxy/freedom/freedom_test.go @@ -0,0 +1,87 @@ +package freedom + +import ( + "bufio" + "bytes" + "context" + "net/http" + "testing" + + "github.com/xtls/xray-core/common/buf" + "github.com/xtls/xray-core/common/net" + "github.com/xtls/xray-core/common/session" + "github.com/xtls/xray-core/transport" +) + +func TestUnconditionalBlockFastPath(t *testing.T) { + for _, network := range []net.Network{net.Network_TCP, net.Network_UDP} { + t.Run(network.String(), func(t *testing.T) { + const reply = "blocked" + h := new(Handler) + if err := h.Init(&Config{Firewall: []*FirewallConfig{{ + Action: RuleAction_Block, + Delay: &Range{}, + Reply: &Reply{Type: "custom", CustomResponseData: []byte(reply)}, + }}}, nil); err != nil { + t.Fatal(err) + } + ctx := session.ContextWithOutbounds(context.Background(), []*session.Outbound{{ + Target: net.Destination{Network: network, Address: net.DomainAddress("blocked.invalid"), Port: 443}, + }}) + var output bytes.Buffer + link := &transport.Link{ + Reader: buf.NewReader(bytes.NewReader(nil)), + Writer: &buf.BufferToBytesWriter{Writer: &output}, + } + // An unconditional block must finish without touching the dialer or resolving the domain. + if err := h.Process(ctx, link, nil); err != nil { + t.Fatal(err) + } + if output.String() != reply { + t.Fatalf("reply = %q, want %q", output.String(), reply) + } + }) + } +} + +func TestFirewallReply(t *testing.T) { + custom := bytes.Repeat([]byte("custom response"), buf.Size) + for _, test := range []struct { + name string + reply *Reply + want []byte + }{ + {name: "default"}, + {name: "none", reply: &Reply{Type: "none"}}, + {name: "http", reply: &Reply{Type: "http"}}, + {name: "custom", reply: &Reply{Type: "custom", CustomResponseData: custom}, want: custom}, + } { + t.Run(test.name, func(t *testing.T) { + rule, err := buildRule(&FirewallConfig{ + Action: RuleAction_Block, + Delay: &Range{}, + Reply: test.reply, + }) + if err != nil { + t.Fatal(err) + } + var output bytes.Buffer + dest := net.TCPDestination(net.LocalHostIP, 80) + if err := new(Handler).blackhole(context.Background(), buf.NewReader(bytes.NewReader(nil)), &buf.BufferToBytesWriter{Writer: &output}, rule, &dest); err != nil { + t.Fatal(err) + } + if test.name == "http" { + response, err := http.ReadResponse(bufio.NewReader(&output), nil) + if err != nil { + t.Fatal(err) + } + defer response.Body.Close() + if response.StatusCode != http.StatusForbidden { + t.Fatalf("HTTP status = %d, want 403", response.StatusCode) + } + } else if !bytes.Equal(output.Bytes(), test.want) { + t.Fatalf("reply has %d bytes, want %d", output.Len(), len(test.want)) + } + }) + } +} diff --git a/proxy/tun/tun_linux_dns_route_test.go b/proxy/tun/tun_linux_dns_route_test.go index 120ef7e10..179d4896e 100644 --- a/proxy/tun/tun_linux_dns_route_test.go +++ b/proxy/tun/tun_linux_dns_route_test.go @@ -17,7 +17,6 @@ import ( "github.com/xtls/xray-core/common/net" "github.com/xtls/xray-core/common/serial" "github.com/xtls/xray-core/core" - "github.com/xtls/xray-core/proxy/blackhole" proxydns "github.com/xtls/xray-core/proxy/dns" "github.com/xtls/xray-core/proxy/freedom" ) @@ -73,7 +72,7 @@ func newRouteTestContext(t *testing.T, withDNSApp bool, nameServers []*appdns.Na Outbound: []*core.OutboundHandlerConfig{ {Tag: "direct", ProxySettings: serial.ToTypedMessage(&freedom.Config{})}, {Tag: "dns", ProxySettings: serial.ToTypedMessage(&proxydns.Config{})}, - {Tag: "block", ProxySettings: serial.ToTypedMessage(&blackhole.Config{})}, + {Tag: "block", ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}})}, }, }) if err != nil { diff --git a/testing/scenarios/command_test.go b/testing/scenarios/command_test.go index 8f82bb2b4..e14344f75 100644 --- a/testing/scenarios/command_test.go +++ b/testing/scenarios/command_test.go @@ -71,7 +71,7 @@ func TestCommanderListenConfigurationItem(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { Tag: "default-outbound", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, } @@ -166,7 +166,7 @@ func TestCommanderRemoveHandler(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { Tag: "default-outbound", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, } @@ -262,7 +262,7 @@ func TestCommanderListHandlers(t *testing.T) { { Tag: "default-outbound", SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{}), - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, } @@ -390,7 +390,7 @@ func TestCommanderAddRemoveUser(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -579,7 +579,7 @@ func TestCommanderStats(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/dns_test.go b/testing/scenarios/dns_test.go index a38f1b200..ee5b49e80 100644 --- a/testing/scenarios/dns_test.go +++ b/testing/scenarios/dns_test.go @@ -13,7 +13,6 @@ import ( "github.com/xtls/xray-core/common/net" "github.com/xtls/xray-core/common/serial" "github.com/xtls/xray-core/core" - "github.com/xtls/xray-core/proxy/blackhole" "github.com/xtls/xray-core/proxy/freedom" "github.com/xtls/xray-core/proxy/socks" "github.com/xtls/xray-core/testing/servers/tcp" @@ -78,7 +77,7 @@ func TestResolveIP(t *testing.T) { }, Outbound: []*core.OutboundHandlerConfig{ { - ProxySettings: serial.ToTypedMessage(&blackhole.Config{}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}}), }, { Tag: "direct", diff --git a/testing/scenarios/dokodemo_test.go b/testing/scenarios/dokodemo_test.go index e160ab508..225044330 100644 --- a/testing/scenarios/dokodemo_test.go +++ b/testing/scenarios/dokodemo_test.go @@ -60,7 +60,7 @@ func TestDokodemoTCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -163,7 +163,7 @@ func TestDokodemoUDP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/feature_test.go b/testing/scenarios/feature_test.go index fa1ff3564..692d27f49 100644 --- a/testing/scenarios/feature_test.go +++ b/testing/scenarios/feature_test.go @@ -21,7 +21,6 @@ import ( "github.com/xtls/xray-core/common/serial" "github.com/xtls/xray-core/common/uuid" core "github.com/xtls/xray-core/core" - "github.com/xtls/xray-core/proxy/blackhole" "github.com/xtls/xray-core/proxy/dokodemo" "github.com/xtls/xray-core/proxy/freedom" v2http "github.com/xtls/xray-core/proxy/http" @@ -62,7 +61,7 @@ func TestPassiveConnection(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -123,7 +122,7 @@ func TestDialerProxy(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -152,7 +151,7 @@ func TestDialerProxy(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -254,7 +253,7 @@ func TestDialerProxyOverKCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -283,7 +282,7 @@ func TestDialerProxyOverKCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), SenderSettings: serial.ToTypedMessage(&proxyman.SenderConfig{ StreamSettings: &internet.StreamConfig{ @@ -402,11 +401,11 @@ func TestBlackhole(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { Tag: "direct", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, { Tag: "blocked", - ProxySettings: serial.ToTypedMessage(&blackhole.Config{}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}}), }, }, App: []*serial.TypedMessage{ @@ -517,7 +516,7 @@ func TestUDPConnection(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -582,7 +581,7 @@ func TestDomainSniffing(t *testing.T) { }, { Tag: "direct", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, App: []*serial.TypedMessage{ @@ -669,7 +668,7 @@ func TestDialXray(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/http_test.go b/testing/scenarios/http_test.go index 28d0ea4e8..8e91392da 100644 --- a/testing/scenarios/http_test.go +++ b/testing/scenarios/http_test.go @@ -50,7 +50,7 @@ func TestHttpConformance(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -113,7 +113,7 @@ func TestHttpError(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -163,7 +163,7 @@ func TestHTTPConnectMethod(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -245,7 +245,7 @@ func TestHttpPost(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -317,7 +317,7 @@ func TestHttpBasicAuth(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -405,7 +405,7 @@ func TestHTTPOutboundServerFirst(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/masque_test.go b/testing/scenarios/masque_test.go index 876ff0d2e..5d92cf4f7 100644 --- a/testing/scenarios/masque_test.go +++ b/testing/scenarios/masque_test.go @@ -499,7 +499,7 @@ func masqueServerConfig(serverPort net.Port, certificate *tls.Certificate, h2 bo Port: uint32(dest.Port), }, }, - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), } } diff --git a/testing/scenarios/metrics_test.go b/testing/scenarios/metrics_test.go index d75384770..fed9c5d05 100644 --- a/testing/scenarios/metrics_test.go +++ b/testing/scenarios/metrics_test.go @@ -63,7 +63,7 @@ func TestMetrics(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { Tag: "default-outbound", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, } diff --git a/testing/scenarios/policy_test.go b/testing/scenarios/policy_test.go index 588d07e5c..fea442831 100644 --- a/testing/scenarios/policy_test.go +++ b/testing/scenarios/policy_test.go @@ -85,7 +85,7 @@ func TestVMessClosing(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -193,7 +193,7 @@ func TestZeroBuffer(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/reverse_test.go b/testing/scenarios/reverse_test.go index 155386944..26ced6250 100644 --- a/testing/scenarios/reverse_test.go +++ b/testing/scenarios/reverse_test.go @@ -17,7 +17,6 @@ import ( "github.com/xtls/xray-core/common/serial" "github.com/xtls/xray-core/common/uuid" core "github.com/xtls/xray-core/core" - "github.com/xtls/xray-core/proxy/blackhole" "github.com/xtls/xray-core/proxy/dokodemo" "github.com/xtls/xray-core/proxy/freedom" "github.com/xtls/xray-core/proxy/vmess" @@ -100,7 +99,7 @@ func TestReverseProxy(t *testing.T) { }, Outbound: []*core.OutboundHandlerConfig{ { - ProxySettings: serial.ToTypedMessage(&blackhole.Config{}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}}), }, }, } @@ -151,7 +150,7 @@ func TestReverseProxy(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { Tag: "freedom", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, { Tag: "reverse", @@ -275,7 +274,7 @@ func TestReverseProxyLongRunning(t *testing.T) { }, Outbound: []*core.OutboundHandlerConfig{ { - ProxySettings: serial.ToTypedMessage(&blackhole.Config{}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}}), }, }, } @@ -340,7 +339,7 @@ func TestReverseProxyLongRunning(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { Tag: "freedom", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, { Tag: "reverse", diff --git a/testing/scenarios/shadowsocks_2022_test.go b/testing/scenarios/shadowsocks_2022_test.go index f456c5a3c..99c48f170 100644 --- a/testing/scenarios/shadowsocks_2022_test.go +++ b/testing/scenarios/shadowsocks_2022_test.go @@ -91,7 +91,7 @@ func testShadowsocks2022Tcp(t *testing.T, method string, password string) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -176,7 +176,7 @@ func testShadowsocks2022Udp(t *testing.T, method string, password string) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/shadowsocks_test.go b/testing/scenarios/shadowsocks_test.go index 2f4536993..ec46f02b1 100644 --- a/testing/scenarios/shadowsocks_test.go +++ b/testing/scenarios/shadowsocks_test.go @@ -53,7 +53,7 @@ func TestShadowsocksChaCha20Poly1305TCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -141,7 +141,7 @@ func TestShadowsocksAES256GCMTCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -236,7 +236,7 @@ func TestShadowsocksAES128GCMUDP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -330,7 +330,7 @@ func TestShadowsocksAES128GCMUDPMux(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/socks_test.go b/testing/scenarios/socks_test.go index e4682b80e..13794de07 100644 --- a/testing/scenarios/socks_test.go +++ b/testing/scenarios/socks_test.go @@ -11,7 +11,6 @@ import ( "github.com/xtls/xray-core/common/protocol" "github.com/xtls/xray-core/common/serial" "github.com/xtls/xray-core/core" - "github.com/xtls/xray-core/proxy/blackhole" "github.com/xtls/xray-core/proxy/dokodemo" "github.com/xtls/xray-core/proxy/freedom" "github.com/xtls/xray-core/proxy/http" @@ -51,7 +50,7 @@ func TestSocksBridgeTCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -128,7 +127,7 @@ func TestSocksWithHttpRequest(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -217,7 +216,7 @@ func TestSocksBridageUDP(t *testing.T) { }, Outbound: []*core.OutboundHandlerConfig{ { - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, } @@ -331,11 +330,11 @@ func TestSocksBridageUDPWithRouting(t *testing.T) { }, Outbound: []*core.OutboundHandlerConfig{ { - ProxySettings: serial.ToTypedMessage(&blackhole.Config{}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Block, Delay: &freedom.Range{}}}}), }, { Tag: "out", - ProxySettings: serial.ToTypedMessage(&freedom.Config{FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}}), + ProxySettings: serial.ToTypedMessage(&freedom.Config{Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}}), }, }, } @@ -435,7 +434,7 @@ func TestSocksConformanceMod(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/tls_test.go b/testing/scenarios/tls_test.go index c76ce4f60..f08144b7d 100644 --- a/testing/scenarios/tls_test.go +++ b/testing/scenarios/tls_test.go @@ -69,7 +69,7 @@ func TestSimpleTLSConnection(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -182,7 +182,7 @@ func TestAutoIssuingCertificate(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -287,7 +287,7 @@ func TestTLSOverKCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -387,7 +387,7 @@ func TestTLSOverWebSocket(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -503,7 +503,7 @@ func TestGRPC(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -619,7 +619,7 @@ func TestGRPCMultiMode(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -728,7 +728,7 @@ func TestSimpleTLSConnectionPinned(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -827,7 +827,7 @@ func TestSimpleTLSConnectionPinnedWrongCert(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -925,7 +925,7 @@ func TestUTLSConnectionPinned(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -1025,7 +1025,7 @@ func TestUTLSConnectionPinnedWrongCert(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/transport_test.go b/testing/scenarios/transport_test.go index a0bd43f5b..584c51ccd 100644 --- a/testing/scenarios/transport_test.go +++ b/testing/scenarios/transport_test.go @@ -63,7 +63,7 @@ func TestHTTPConnectionHeader(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/vless_test.go b/testing/scenarios/vless_test.go index a624b0844..963dae8b4 100644 --- a/testing/scenarios/vless_test.go +++ b/testing/scenarios/vless_test.go @@ -70,7 +70,7 @@ func TestVless(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -175,7 +175,7 @@ func TestVlessTls(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -298,7 +298,7 @@ func TestVlessXtlsVision(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -430,7 +430,7 @@ func TestVlessXtlsVisionReality(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -569,7 +569,7 @@ func TestVlessRealityFingerprints(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -661,7 +661,7 @@ func TestVlessRealityFingerprints(t *testing.T) { wg.Wait() } -// A blocked connection must close after finalRules.delay even while the client keeps it open and sends nothing. +// A blocked connection must close after firewall.delay even while the client keeps it open and sends nothing. func TestVlessBlockDelay(t *testing.T) { tcpServer := tcp.Server{ MsgProcessor: xor, @@ -695,7 +695,7 @@ func TestVlessBlockDelay(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{ + Firewall: []*freedom.FirewallConfig{ { Action: freedom.RuleAction_Block, Delay: &freedom.Range{Min: delay, Max: delay}, @@ -734,7 +734,7 @@ func TestVlessBlockDelay(t *testing.T) { t.Fatalf("connection is still open after %v", elapsed) } if elapsed < blockDuration { - t.Fatalf("connection is closed after %v, before finalRules.delay", elapsed) + t.Fatalf("connection is closed after %v, before firewall.delay", elapsed) } }) } diff --git a/testing/scenarios/vmess_test.go b/testing/scenarios/vmess_test.go index b1d73b20c..35e416f4a 100644 --- a/testing/scenarios/vmess_test.go +++ b/testing/scenarios/vmess_test.go @@ -62,7 +62,7 @@ func TestVMessGCM(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -162,7 +162,7 @@ func TestVMessGCMReadv(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -265,7 +265,7 @@ func TestVMessGCMUDP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -362,7 +362,7 @@ func TestVMessChacha20(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -463,7 +463,7 @@ func TestVMessKCP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -568,7 +568,7 @@ func TestVMessKCPLarge(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -674,7 +674,7 @@ func TestVMessGCMMux(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -787,7 +787,7 @@ func TestVMessGCMMuxUDP(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -910,7 +910,7 @@ func TestVMessGCMLengthAuth(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, @@ -1012,7 +1012,7 @@ func TestVMessGCMLengthAuthPlusNoTerminationSignal(t *testing.T) { Outbound: []*core.OutboundHandlerConfig{ { ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), }, }, diff --git a/testing/scenarios/wireguard_test.go b/testing/scenarios/wireguard_test.go index a3014c48e..663d02f76 100644 --- a/testing/scenarios/wireguard_test.go +++ b/testing/scenarios/wireguard_test.go @@ -61,7 +61,7 @@ func TestWireguard(t *testing.T) { Port: uint32(dest.Port), }, }, - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, }), } } diff --git a/transport/internet/finalmask/finalmask.go b/transport/internet/finalmask/finalmask.go index a64d4183a..617d7fa2e 100644 --- a/transport/internet/finalmask/finalmask.go +++ b/transport/internet/finalmask/finalmask.go @@ -9,9 +9,11 @@ import ( "github.com/xtls/xray-core/common/buf" "github.com/xtls/xray-core/common/errors" "github.com/xtls/xray-core/common/net" + "github.com/xtls/xray-core/common/session" ) type Dialer struct { + Source net.Addr DialTCP func(net.Destination) (net.Conn, error) DialUDP func(net.Destination) (net.Conn, error) } @@ -85,6 +87,9 @@ func (fm *FinalMask) DialTCP(ctx context.Context, dest net.Destination) (net.Con return &net.PacketConnWrapper{PacketConn: conn, Dest: addr}, err }, } + if inbound := session.InboundFromContext(ctx); inbound != nil && inbound.Source.IsValid() { + dialer.Source = inbound.Source.RawNetAddr() + } for i := range fm.tcpMasks { var newConn net.Conn newConn, err = fm.tcpMasks[i].WrapConnClient(conn, &dest, dialer) diff --git a/transport/internet/finalmask/proxyprotocol/config.go b/transport/internet/finalmask/proxyprotocol/config.go new file mode 100644 index 000000000..924de4d97 --- /dev/null +++ b/transport/internet/finalmask/proxyprotocol/config.go @@ -0,0 +1,31 @@ +package proxyprotocol + +import ( + "github.com/pires/go-proxyproto" + "github.com/xtls/xray-core/common/errors" + "github.com/xtls/xray-core/common/net" + "github.com/xtls/xray-core/transport/internet/finalmask" +) + +func (c *Config) WrapConnClient(conn net.Conn, dest *net.Destination, dialer *finalmask.Dialer) (net.Conn, error) { + version := c.Version + if version == 0 { + version = 2 + } + if version != 1 && version != 2 { + return nil, errors.New("PROXY protocol version must be 1 or 2") + } + source := conn.LocalAddr() + if dialer != nil && dialer.Source != nil { + source = dialer.Source + } + header := proxyproto.HeaderProxyFromAddrs(byte(version), source, conn.RemoteAddr()) + if _, err := header.WriteTo(conn); err != nil { + return nil, errors.New("failed to write PROXY protocol header").Base(err) + } + return conn, nil +} + +func (c *Config) WrapConnServer(conn net.Conn) (net.Conn, error) { + return proxyproto.NewConn(conn, proxyproto.WithPolicy(proxyproto.REQUIRE)), nil +} diff --git a/transport/internet/finalmask/proxyprotocol/config.pb.go b/transport/internet/finalmask/proxyprotocol/config.pb.go new file mode 100644 index 000000000..c765d3b9f --- /dev/null +++ b/transport/internet/finalmask/proxyprotocol/config.pb.go @@ -0,0 +1,123 @@ +// Code generated by protoc-gen-go. DO NOT EDIT. +// versions: +// protoc-gen-go v1.36.12 +// protoc (unknown) +// source: transport/internet/finalmask/proxyprotocol/config.proto + +package proxyprotocol + +import ( + protoreflect "google.golang.org/protobuf/reflect/protoreflect" + protoimpl "google.golang.org/protobuf/runtime/protoimpl" + reflect "reflect" + sync "sync" + unsafe "unsafe" +) + +const ( + // Verify that this generated code is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) + // Verify that runtime/protoimpl is sufficiently up-to-date. + _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) +) + +type Config struct { + state protoimpl.MessageState `protogen:"open.v1"` + Version uint32 `protobuf:"varint,1,opt,name=version,proto3" json:"version,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Config) Reset() { + *x = Config{} + mi := &file_transport_internet_finalmask_proxyprotocol_config_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Config) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Config) ProtoMessage() {} + +func (x *Config) ProtoReflect() protoreflect.Message { + mi := &file_transport_internet_finalmask_proxyprotocol_config_proto_msgTypes[0] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Config.ProtoReflect.Descriptor instead. +func (*Config) Descriptor() ([]byte, []int) { + return file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescGZIP(), []int{0} +} + +func (x *Config) GetVersion() uint32 { + if x != nil { + return x.Version + } + return 0 +} + +var File_transport_internet_finalmask_proxyprotocol_config_proto protoreflect.FileDescriptor + +const file_transport_internet_finalmask_proxyprotocol_config_proto_rawDesc = "" + + "\n" + + "7transport/internet/finalmask/proxyprotocol/config.proto\x12/xray.transport.internet.finalmask.proxyprotocol\"\"\n" + + "\x06Config\x12\x18\n" + + "\aversion\x18\x01 \x01(\rR\aversionB\xaf\x01\n" + + "3com.xray.transport.internet.finalmask.proxyprotocolP\x01ZDgithub.com/xtls/xray-core/transport/internet/finalmask/proxyprotocol\xaa\x02/Xray.Transport.Internet.Finalmask.ProxyProtocolb\x06proto3" + +var ( + file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescOnce sync.Once + file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescData []byte +) + +func file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescGZIP() []byte { + file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescOnce.Do(func() { + file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_transport_internet_finalmask_proxyprotocol_config_proto_rawDesc), len(file_transport_internet_finalmask_proxyprotocol_config_proto_rawDesc))) + }) + return file_transport_internet_finalmask_proxyprotocol_config_proto_rawDescData +} + +var file_transport_internet_finalmask_proxyprotocol_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1) +var file_transport_internet_finalmask_proxyprotocol_config_proto_goTypes = []any{ + (*Config)(nil), // 0: xray.transport.internet.finalmask.proxyprotocol.Config +} +var file_transport_internet_finalmask_proxyprotocol_config_proto_depIdxs = []int32{ + 0, // [0:0] is the sub-list for method output_type + 0, // [0:0] is the sub-list for method input_type + 0, // [0:0] is the sub-list for extension type_name + 0, // [0:0] is the sub-list for extension extendee + 0, // [0:0] is the sub-list for field type_name +} + +func init() { file_transport_internet_finalmask_proxyprotocol_config_proto_init() } +func file_transport_internet_finalmask_proxyprotocol_config_proto_init() { + if File_transport_internet_finalmask_proxyprotocol_config_proto != nil { + return + } + type x struct{} + out := protoimpl.TypeBuilder{ + File: protoimpl.DescBuilder{ + GoPackagePath: reflect.TypeOf(x{}).PkgPath(), + RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_finalmask_proxyprotocol_config_proto_rawDesc), len(file_transport_internet_finalmask_proxyprotocol_config_proto_rawDesc)), + NumEnums: 0, + NumMessages: 1, + NumExtensions: 0, + NumServices: 0, + }, + GoTypes: file_transport_internet_finalmask_proxyprotocol_config_proto_goTypes, + DependencyIndexes: file_transport_internet_finalmask_proxyprotocol_config_proto_depIdxs, + MessageInfos: file_transport_internet_finalmask_proxyprotocol_config_proto_msgTypes, + }.Build() + File_transport_internet_finalmask_proxyprotocol_config_proto = out.File + file_transport_internet_finalmask_proxyprotocol_config_proto_goTypes = nil + file_transport_internet_finalmask_proxyprotocol_config_proto_depIdxs = nil +} diff --git a/transport/internet/finalmask/proxyprotocol/config.proto b/transport/internet/finalmask/proxyprotocol/config.proto new file mode 100644 index 000000000..1b1030179 --- /dev/null +++ b/transport/internet/finalmask/proxyprotocol/config.proto @@ -0,0 +1,11 @@ +syntax = "proto3"; + +package xray.transport.internet.finalmask.proxyprotocol; +option csharp_namespace = "Xray.Transport.Internet.Finalmask.ProxyProtocol"; +option go_package = "github.com/xtls/xray-core/transport/internet/finalmask/proxyprotocol"; +option java_package = "com.xray.transport.internet.finalmask.proxyprotocol"; +option java_multiple_files = true; + +message Config { + uint32 version = 1; +} diff --git a/transport/internet/finalmask/proxyprotocol/config_test.go b/transport/internet/finalmask/proxyprotocol/config_test.go new file mode 100644 index 000000000..636de844f --- /dev/null +++ b/transport/internet/finalmask/proxyprotocol/config_test.go @@ -0,0 +1,93 @@ +package proxyprotocol + +import ( + "context" + "fmt" + "io" + "testing" + "time" + + "github.com/pires/go-proxyproto" + "github.com/xtls/xray-core/common/net" + "github.com/xtls/xray-core/common/session" + "github.com/xtls/xray-core/transport/internet/finalmask" +) + +func TestClientHeader(t *testing.T) { + for _, version := range []uint32{0, 1, 2} { + for _, sourceIP := range []string{"", "198.51.100.7", "2001:db8::7"} { + t.Run(fmt.Sprintf("version=%d/source=%s", version, sourceIP), func(t *testing.T) { + listener, err := net.Listen("tcp", "127.0.0.1:0") + if err != nil { + t.Fatal(err) + } + defer listener.Close() + ctx := context.Background() + if sourceIP != "" { + ctx = session.ContextWithInbound(ctx, &session.Inbound{ + Source: net.TCPDestination(net.ParseAddress(sourceIP), 12345), + }) + } + fm := finalmask.NewFinalMask([]finalmask.TCPMask{&Config{Version: version}}, nil, + func(ctx context.Context, dest net.Destination) (net.Conn, error) { + return net.Dial("tcp", dest.NetAddr()) + }, func(ctx context.Context, addr net.Addr) (net.Listener, error) { + return listener, nil + }, nil, nil) + maskedListener, err := fm.Listen(context.Background(), listener.Addr()) + if err != nil { + t.Fatal(err) + } + client, err := fm.DialTCP(ctx, net.DestinationFromAddr(listener.Addr())) + if err != nil { + t.Fatal(err) + } + defer client.Close() + server, err := maskedListener.Accept() + if err != nil { + t.Fatal(err) + } + defer server.Close() + deadline := time.Now().Add(5 * time.Second) + if err := client.SetDeadline(deadline); err != nil { + t.Fatal(err) + } + if err := server.SetDeadline(deadline); err != nil { + t.Fatal(err) + } + proxyConn, ok := server.(*proxyproto.Conn) + if !ok { + t.Fatalf("server connection type = %T, want *proxyproto.Conn", server) + } + header := proxyConn.ProxyHeader() + wantVersion := byte(version) + if wantVersion == 0 { + wantVersion = 2 + } + if header == nil || header.Version != wantVersion || header.Command != proxyproto.PROXY { + t.Fatalf("unexpected PROXY header: %v", header) + } + wantSource := client.LocalAddr() + if sourceIP != "" { + wantSource = &net.TCPAddr{IP: net.ParseIP(sourceIP), Port: 12345} + } + if server.RemoteAddr().String() != wantSource.String() || server.LocalAddr().String() != listener.Addr().String() { + t.Fatalf("addresses = %v -> %v, want %v -> %v", server.RemoteAddr(), server.LocalAddr(), wantSource, listener.Addr()) + } + for _, pair := range [][2]net.Conn{{client, server}, {client, server}, {server, client}} { + const payload = "application payload" + if _, err := io.WriteString(pair[0], payload); err != nil { + t.Fatal(err) + } + data := make([]byte, len(payload)) + if _, err := io.ReadFull(pair[1], data); err != nil { + t.Fatal(err) + } + if string(data) != payload { + t.Fatalf("payload = %q", data) + } + } + }) + } + } +} diff --git a/transport/internet/finalmask/sudoku/sudoku_test.go b/transport/internet/finalmask/sudoku/sudoku_test.go index 2c03a21f0..a2460f3e1 100644 --- a/transport/internet/finalmask/sudoku/sudoku_test.go +++ b/transport/internet/finalmask/sudoku/sudoku_test.go @@ -279,7 +279,7 @@ func runVLESSRealityCase(t *testing.T, bin string, mode trafficMode, payloadSize }, Outbound: []*core.OutboundHandlerConfig{ {ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, })}, }, }) @@ -398,7 +398,7 @@ func runHysteria2Case(t *testing.T, bin string, mode trafficMode, payloadSize in }, Outbound: []*core.OutboundHandlerConfig{ {ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, })}, }, }) @@ -514,7 +514,7 @@ func runVLesseEncCase(t *testing.T, bin string, mode trafficMode, payloadSize in }, Outbound: []*core.OutboundHandlerConfig{ {ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, })}, }, }) @@ -614,7 +614,7 @@ func runVLESSXHTTPCase(t *testing.T, bin string, mode trafficMode, payloadSize i }, Outbound: []*core.OutboundHandlerConfig{ {ProxySettings: serial.ToTypedMessage(&freedom.Config{ - FinalRules: []*freedom.FinalRuleConfig{{Action: freedom.RuleAction_Allow}}, + Firewall: []*freedom.FirewallConfig{{Action: freedom.RuleAction_Allow}}, })}, }, }) diff --git a/transport/internet/finalmask/xmc/client.go b/transport/internet/finalmask/xmc/client.go index 6159d09a1..0ed47a57d 100644 --- a/transport/internet/finalmask/xmc/client.go +++ b/transport/internet/finalmask/xmc/client.go @@ -32,6 +32,9 @@ type clientConn struct { paddingSchedule []paddingTurn packet *packetStream deadlines *connectionDeadlines + + done chan struct{} + closeOnce sync.Once } type clientState int @@ -41,16 +44,15 @@ var ( clientStateProxy clientState = 2 ) -func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPublicKey []byte, hostname string) (*clientConn, error) { +func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPublicKey []byte, hostname string, paddingSchedule []paddingTurn) (*clientConn, error) { if len(rsaPublicKey) == 0 { return nil, fmt.Errorf("empty rsa public key") } if len(profiles) == 0 { return nil, fmt.Errorf("empty profiles") } - paddingSchedule, err := newClientPaddingSchedule2612() - if err != nil { - return nil, fmt.Errorf("select padding profile: %w", err) + if len(password) > MaxLegacyPasswordLength { + return nil, fmt.Errorf("password is longer than %d bytes", MaxLegacyPasswordLength) } return &clientConn{ reader: bufio.NewReader(c), @@ -64,9 +66,15 @@ func newClientConn(c net.Conn, profiles []loginProfile, password string, rsaPubl hostname: hostname, paddingSchedule: paddingSchedule, deadlines: newConnectionDeadlines(c), + done: make(chan struct{}), }, nil } +// paddingPause applies one padding pause, stopping early on Close. +func (c *clientConn) paddingPause(d time.Duration) error { + return pausePadding(c.done, d) +} + func (c *clientConn) handshake() error { c.handshakeLock.Lock() defer c.handshakeLock.Unlock() @@ -195,6 +203,24 @@ func (c *clientConn) handshake() error { if err != nil { return fmt.Errorf("read login finished: %w", err) } + // Set Compression is not compressed itself and must be handled before the + // packet that follows it, which already uses the compressed framing. The + // threshold only decides whether the framing applies: this writer never + // compresses, so a server-side threshold does not shrink padding turns. + if pkt.packetID == 0x03 { + var threshold Varint + if thresholdErr := pkt.readFields(&threshold); thresholdErr != nil { + return fmt.Errorf("read login compression threshold: %w", thresholdErr) + } + if threshold >= 0 { + c.reader = newCompressionReader(c.reader) + c.writer = newCompressionWriter(c.writer) + } + pkt, err = readPacket(c.reader) + if err != nil { + return fmt.Errorf("read login finished: %w", err) + } + } if pkt.packetID == 0x00 { var reason String if readErr := pkt.readFields(&reason); readErr != nil { @@ -217,7 +243,9 @@ func (c *clientConn) handshake() error { if err != nil { return fmt.Errorf("write login acknowledged: %w", err) } - if err = runPaddingSchedule(c.reader, c.writer, true, loginAcknowledgedLength, c.paddingSchedule); err != nil { + c.reader = newPaddingReader(c.reader, true) + if err = runPaddingSchedule(c.writer, true, loginAcknowledgedLength, c.paddingSchedule, c.paddingPause); err != nil { + _ = c.Close() // Unblock the startup reader if writing failed. return fmt.Errorf("run startup padding: %w", err) } @@ -260,6 +288,7 @@ func (c *clientConn) Close() error { c.closed = true packet := c.packet c.lifecycleMu.Unlock() + c.closeOnce.Do(func() { close(c.done) }) if packet != nil { packet.Stop() } diff --git a/transport/internet/finalmask/xmc/compression.go b/transport/internet/finalmask/xmc/compression.go new file mode 100644 index 000000000..d22e6d7d7 --- /dev/null +++ b/transport/internet/finalmask/xmc/compression.go @@ -0,0 +1,180 @@ +// Minecraft compression framing, negotiated by the login Set Compression packet. +// The reader decodes whatever the peer sends, including deflated bodies; the +// writer always sends the uncompressed variant. +package xmc + +import ( + "bytes" + "compress/zlib" + "fmt" + "io" +) + +const ( + // Packet Length is a VarInt, so one frame cannot exceed 2^21-1 bytes. + maxCompressedFrameLength = (1 << 21) - 1 + // Vanilla caps serverbound uncompressed packet bodies at 2^23 bytes. + maxUncompressedFrameBody = 1 << 23 +) + +// compressionReader converts the post-Set Compression framing +// (Packet Length, Data Length, optional zlib body) back into the plain +// (VarInt body length, body) frame that readPacket expects. +// +// A zero Data Length means the body was sent uncompressed, which vanilla +// servers accept even when the body exceeds the negotiated threshold. +type compressionReader struct { + r io.Reader + frame bytes.Buffer +} + +func newCompressionReader(r io.Reader) io.Reader { + return &compressionReader{r: r} +} + +func (c *compressionReader) Read(p []byte) (int, error) { + if c.frame.Len() == 0 { + if err := c.readFrame(); err != nil { + return 0, err + } + } + return c.frame.Read(p) +} + +func (c *compressionReader) readFrame() error { + packetLength, _, err := readVarintWithLength(c.r) + if err != nil { + return fmt.Errorf("read compressed packet length: %w", err) + } + if packetLength < 1 || int(packetLength) > maxCompressedFrameLength { + return fmt.Errorf("read compressed packet: bad length: %d", packetLength) + } + + dataLength, dataLengthSize, err := readVarintWithLength(c.r) + if err != nil { + return fmt.Errorf("read compressed data length: %w", err) + } + if dataLength < 0 || int(dataLength) > maxUncompressedFrameBody { + return fmt.Errorf("read compressed packet: bad uncompressed length: %d", dataLength) + } + + payloadLength := int(packetLength) - dataLengthSize + if payloadLength < 0 { + return fmt.Errorf("read compressed packet: bad length: %d", packetLength) + } + payload := make([]byte, payloadLength) + if _, err := io.ReadFull(c.r, payload); err != nil { + return fmt.Errorf("read compressed packet data: %w", err) + } + + body := payload + if dataLength > 0 { + zr, err := zlib.NewReader(bytes.NewReader(payload)) + if err != nil { + return fmt.Errorf("open compressed packet: %w", err) + } + body = make([]byte, int(dataLength)) + _, readErr := io.ReadFull(zr, body) + closeErr := zr.Close() + if readErr != nil { + return fmt.Errorf("decompress packet: %w", readErr) + } + if closeErr != nil { + return fmt.Errorf("close decompressor: %w", closeErr) + } + } + if len(body) < 1 { + return fmt.Errorf("read compressed packet: empty body") + } + + var frame bytes.Buffer + frame.Grow(varintSize(Varint(len(body))) + len(body)) + bodyLength := Varint(len(body)) + if err := bodyLength.writeTo(&frame); err != nil { + return err + } + frame.Write(body) + c.frame = frame + return nil +} + +// compressionWriter converts a plain frame (VarInt body length, body) into the +// post-Set Compression framing. Frames are buffered until complete, because a +// caller may split one frame across several Write calls. +// +// It never compresses, whatever the negotiated threshold is. What XMC writes is +// padding and proxied bytes: the padding exists for its size on the wire, so +// deflating it would shrink a padded turn from tens of kilobytes to a hundred +// bytes and erase the shape it is there for, and proxied bytes are already +// encrypted or compressed by whoever produced them. Vanilla accepts an +// uncompressed body of any size when Data Length is zero, so the framing alone +// is enough to stay inside the protocol. +type compressionWriter struct { + w io.Writer + pending []byte +} + +func newCompressionWriter(w io.Writer) io.Writer { + return &compressionWriter{w: w} +} + +func (c *compressionWriter) Write(p []byte) (int, error) { + c.pending = append(c.pending, p...) + for { + body, ok, err := c.nextFrame() + if err != nil { + return 0, err + } + if !ok { + return len(p), nil + } + if err := c.writeFrame(body); err != nil { + return 0, err + } + } +} + +// nextFrame returns one complete frame body from the pending bytes. It only +// waits for more bytes while the length prefix or the body is still +// incomplete; a complete but invalid prefix is an error. +func (c *compressionWriter) nextFrame() ([]byte, bool, error) { + limit := len(c.pending) + if limit > 5 { + limit = 5 + } + bodyLength, prefixLength, err := readVarintWithLength(bytes.NewReader(c.pending[:limit])) + if err != nil { + if len(c.pending) < 5 { + return nil, false, nil + } + return nil, false, fmt.Errorf("read frame length: %w", err) + } + if bodyLength < 1 { + return nil, false, fmt.Errorf("read frame: bad length: %d", bodyLength) + } + end := prefixLength + int(bodyLength) + if end > len(c.pending) { + return nil, false, nil + } + + // The body stays valid after the reslice: appends only write past the + // remaining pending length and writeFrame consumes it immediately. + body := c.pending[prefixLength:end] + c.pending = c.pending[end:] + return body, true, nil +} + +func (c *compressionWriter) writeFrame(body []byte) error { + // Packet Length covers the Data Length varint and the body; a zero Data + // Length is the uncompressed variant. + packetLength := 1 + len(body) + var frame bytes.Buffer + frame.Grow(varintSize(Varint(packetLength)) + packetLength) + packetLengthVarint := Varint(packetLength) + if err := packetLengthVarint.writeTo(&frame); err != nil { + return err + } + frame.WriteByte(0) + frame.Write(body) + return writeFull(c.w, frame.Bytes()) +} diff --git a/transport/internet/finalmask/xmc/compression_test.go b/transport/internet/finalmask/xmc/compression_test.go new file mode 100644 index 000000000..5a26f13c2 --- /dev/null +++ b/transport/internet/finalmask/xmc/compression_test.go @@ -0,0 +1,253 @@ +package xmc + +import ( + "bytes" + "compress/zlib" + "crypto/rand" + "errors" + "io" + "testing" +) + +func plainFrame(body []byte) []byte { + frame := make([]byte, 0, 5+len(body)) + length := Varint(len(body)) + var buf bytes.Buffer + _ = length.writeTo(&buf) + frame = append(frame, buf.Bytes()...) + return append(frame, body...) +} + +type wireFrame struct { + packetLength int + dataLength int + payload []byte +} + +func readWireFrame(t *testing.T, r *bytes.Reader) wireFrame { + t.Helper() + packetLength, _, err := readVarintWithLength(r) + if err != nil { + t.Fatalf("read packet length: %v", err) + } + dataLength, dataLengthSize, err := readVarintWithLength(r) + if err != nil { + t.Fatalf("read data length: %v", err) + } + payload := make([]byte, int(packetLength)-dataLengthSize) + if _, err := io.ReadFull(r, payload); err != nil { + t.Fatalf("read payload: %v", err) + } + return wireFrame{packetLength: int(packetLength), dataLength: int(dataLength), payload: payload} +} + +func randomBody(t *testing.T, size int) []byte { + t.Helper() + body := make([]byte, size) + if _, err := rand.Read(body); err != nil { + t.Fatalf("random body: %v", err) + } + return body +} + +// TestCompressionWriterNeverCompresses pins the write policy: whatever the +// negotiated threshold is, XMC sends the uncompressed framing so that a padding +// turn keeps its wire size. A padded turn of zeros would otherwise deflate from +// tens of kilobytes to a hundred bytes and the shape would be gone. +func TestCompressionWriterNeverCompresses(t *testing.T) { + for _, size := range []int{1, 10, 255, 256, 257, 32768, 65535, 65536} { + for _, body := range [][]byte{bytes.Repeat([]byte{0}, size), randomBody(t, size)} { + var wire bytes.Buffer + w := newCompressionWriter(&wire) + if _, err := w.Write(plainFrame(body)); err != nil { + t.Fatalf("size %d: write: %v", size, err) + } + + frame := readWireFrame(t, bytes.NewReader(wire.Bytes())) + if frame.dataLength != 0 { + t.Fatalf("size %d: writer compressed the body (data length %d)", size, frame.dataLength) + } + if !bytes.Equal(frame.payload, body) { + t.Fatalf("size %d: payload mismatch", size) + } + if frame.packetLength != 1+size { + t.Fatalf("size %d: packet length %d, want %d", size, frame.packetLength, 1+size) + } + if wire.Len() != varintSize(Varint(1+size))+1+size { + t.Fatalf("size %d: frame is %d bytes on the wire, want %d", size, wire.Len(), varintSize(Varint(1+size))+1+size) + } + + decoded, _, err := readFrame(newCompressionReader(bytes.NewReader(wire.Bytes())), maxUncompressedFrameBody) + if err != nil { + t.Fatalf("size %d: decode: %v", size, err) + } + if !bytes.Equal(decoded, body) { + t.Fatalf("size %d: round trip mismatch", size) + } + } + } +} + +func TestCompressionRoundTripChunked(t *testing.T) { + cases := [][]byte{ + []byte("hello"), + randomBody(t, 255), + randomBody(t, 24*1024), + randomBody(t, 64*1024), + bytes.Repeat([]byte("xmc"), 8*1024), + } + + var wire bytes.Buffer + w := newCompressionWriter(&wire) + // One Write per frame, split into awkward chunk sizes. + for _, body := range cases { + frame := plainFrame(body) + for len(frame) > 0 { + n := 7 + if n > len(frame) { + n = len(frame) + } + if _, err := w.Write(frame[:n]); err != nil { + t.Fatalf("chunked write: %v", err) + } + frame = frame[n:] + } + } + + r := newCompressionReader(bytes.NewReader(wire.Bytes())) + for i, want := range cases { + got, _, err := readFrame(r, maxUncompressedFrameBody) + if err != nil { + t.Fatalf("frame %d: decode: %v", i, err) + } + if !bytes.Equal(got, want) { + t.Fatalf("frame %d: mismatch (%d vs %d bytes)", i, len(got), len(want)) + } + } + if _, _, err := readFrame(r, maxUncompressedFrameBody); !errors.Is(err, io.EOF) { + t.Fatalf("expected EOF after the last frame, got %v", err) + } +} + +func TestCompressionMultipleFramesOneWrite(t *testing.T) { + var plain []byte + bodies := [][]byte{[]byte("a"), randomBody(t, 1024), randomBody(t, 300)} + for _, body := range bodies { + plain = append(plain, plainFrame(body)...) + } + + var wire bytes.Buffer + w := newCompressionWriter(&wire) + if _, err := w.Write(plain); err != nil { + t.Fatalf("write: %v", err) + } + + r := newCompressionReader(bytes.NewReader(wire.Bytes())) + for i, want := range bodies { + got, _, err := readFrame(r, maxUncompressedFrameBody) + if err != nil { + t.Fatalf("frame %d: decode: %v", i, err) + } + if !bytes.Equal(got, want) { + t.Fatalf("frame %d: mismatch", i) + } + } +} + +// Vanilla servers accept uncompressed packets even when the body exceeds the +// negotiated threshold, which is what lets padding frames keep their wire size. +func TestCompressionReaderUncompressedOverThreshold(t *testing.T) { + body := randomBody(t, 64*1024) + var wire bytes.Buffer + length := Varint(1 + len(body)) + if err := length.writeTo(&wire); err != nil { + t.Fatal(err) + } + wire.WriteByte(0) + wire.Write(body) + + got, _, err := readFrame(newCompressionReader(bytes.NewReader(wire.Bytes())), maxUncompressedFrameBody) + if err != nil { + t.Fatalf("decode: %v", err) + } + if !bytes.Equal(got, body) { + t.Fatal("payload mismatch") + } +} + +// The writer stopped compressing, but a real server still does, so the reader +// must keep decoding deflated bodies. +func TestCompressionReaderDecodesCompressedBody(t *testing.T) { + body := append(bytes.Repeat([]byte("xmc"), 4096), 0, 1, 2, 3) + + var compressed bytes.Buffer + zw := zlib.NewWriter(&compressed) + if _, err := zw.Write(body); err != nil { + t.Fatal(err) + } + if err := zw.Close(); err != nil { + t.Fatal(err) + } + + var wire bytes.Buffer + packetLength := Varint(varintSize(Varint(len(body))) + compressed.Len()) + if err := packetLength.writeTo(&wire); err != nil { + t.Fatal(err) + } + dataLength := Varint(len(body)) + if err := dataLength.writeTo(&wire); err != nil { + t.Fatal(err) + } + wire.Write(compressed.Bytes()) + + got, _, err := readFrame(newCompressionReader(bytes.NewReader(wire.Bytes())), maxUncompressedFrameBody) + if err != nil { + t.Fatalf("decode: %v", err) + } + if !bytes.Equal(got, body) { + t.Fatal("payload mismatch") + } +} + +func TestCompressionReaderErrors(t *testing.T) { + // Compressed packet with a bogus body. + var badZlib bytes.Buffer + length := Varint(1 + 10) + _ = length.writeTo(&badZlib) + dataLength := Varint(64) + _ = dataLength.writeTo(&badZlib) + badZlib.Write(bytes.Repeat([]byte{0xff}, 10)) + if _, _, err := readFrame(newCompressionReader(bytes.NewReader(badZlib.Bytes())), maxUncompressedFrameBody); err == nil { + t.Fatal("expected an error for an invalid zlib body") + } + + // Uncompressed length beyond the vanilla limit. + var tooLong bytes.Buffer + length = Varint(1 + 4) + _ = length.writeTo(&tooLong) + dataLength = Varint(maxUncompressedFrameBody + 1) + _ = dataLength.writeTo(&tooLong) + tooLong.Write([]byte{1, 2, 3, 4}) + if _, _, err := readFrame(newCompressionReader(bytes.NewReader(tooLong.Bytes())), maxUncompressedFrameBody); err == nil { + t.Fatal("expected an error for an oversized uncompressed length") + } + + // Truncated payload. + var truncated bytes.Buffer + length = Varint(1 + 100) + _ = length.writeTo(&truncated) + var zero Varint + _ = zero.writeTo(&truncated) + truncated.Write([]byte{1, 2, 3}) + if _, _, err := readFrame(newCompressionReader(bytes.NewReader(truncated.Bytes())), maxUncompressedFrameBody); err == nil { + t.Fatal("expected an error for a truncated payload") + } +} + +func TestCompressionWriterInvalidFrameLength(t *testing.T) { + var wire bytes.Buffer + w := newCompressionWriter(&wire) + if _, err := w.Write([]byte{0xff, 0xff, 0xff, 0xff, 0xff}); err == nil { + t.Fatal("expected an error for an invalid frame length prefix") + } +} diff --git a/transport/internet/finalmask/xmc/config.go b/transport/internet/finalmask/xmc/config.go index 8ee16b2e4..0fc1d4121 100644 --- a/transport/internet/finalmask/xmc/config.go +++ b/transport/internet/finalmask/xmc/config.go @@ -2,17 +2,32 @@ package xmc import ( "fmt" + "math" + "time" "github.com/xtls/xray-core/common/net" "github.com/xtls/xray-core/transport/internet/finalmask" ) +// maxPaddingDelayMilliseconds keeps the millisecond value convertible to a +// time.Duration on every platform. +const maxPaddingDelayMilliseconds = int64(math.MaxInt64 / int64(time.Millisecond)) + +// MaxLegacyPasswordLength is the longest pre-shared password the login can +// carry. The verify token (4 random bytes) and the password travel together in +// one RSA-1024 PKCS#1 v1.5 block, which holds at most 128-11 bytes. +const MaxLegacyPasswordLength = 128 - 11 - 4 + func (c *Config) WrapConnClient(conn net.Conn, dest *net.Destination, dialer *finalmask.Dialer) (net.Conn, error) { profiles, err := profilesFromConfig(c.Profiles) if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } - cc, err := newClientConn(conn, profiles, c.Password, c.RsaPublicKey, c.Hostname) + paddingSchedule, err := c.paddingSchedule(true) + if err != nil { + return nil, fmt.Errorf("minecraft finalmask: %w", err) + } + cc, err := newClientConn(conn, profiles, c.Password, c.RsaPublicKey, c.Hostname, paddingSchedule) if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } @@ -25,10 +40,106 @@ func (c *Config) WrapConnServer(conn net.Conn) (net.Conn, error) { if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } - cc, err := wrapConnServer(conn, profiles, c.Password, c.RsaPrivateKey, c.RsaPublicKey) + paddingSchedule, err := c.paddingSchedule(false) + if err != nil { + return nil, fmt.Errorf("minecraft finalmask: %w", err) + } + cc, err := wrapConnServer(conn, profiles, c.Password, c.RsaPrivateKey, c.RsaPublicKey, paddingSchedule) if err != nil { return nil, fmt.Errorf("minecraft finalmask: %w", err) } return cc, nil } + +// ValidatePadding checks the configured startup turns (including their bounds) +// without selecting a built-in preset. +func (c *Config) ValidatePadding() error { + if c.NoPadding { + if len(c.Paddings) != 0 { + return fmt.Errorf("padding is disabled and configured at the same time") + } + return nil + } + _, err := paddingScheduleFromConfig(c.Paddings) + return err +} + +// paddingSchedule selects the padding turns for one connection. An explicit +// empty configuration disables padding; an absent one keeps the built-in +// preset. +// +// A configured list is the complete schedule, not a replacement for its startup +// part: the built-in preset also carries a Play-state join tail, and that tail +// runs only with the preset. A user who captured their own login decides the +// whole shape, including whether it has a tail. +func (c *Config) paddingSchedule(isClient bool) ([]paddingTurn, error) { + if c.NoPadding { + if len(c.Paddings) != 0 { + return nil, fmt.Errorf("padding is disabled and configured at the same time") + } + return nil, nil + } + if len(c.Paddings) > 0 { + return paddingScheduleFromConfig(c.Paddings) + } + if isClient { + return newClientPaddingSchedule2612() + } + return newServerPaddingSchedule2612() +} + +// paddingScheduleFromConfig builds the complete schedule from a configured list. +// The list replaces the preset entirely, including its Play-state join tail. +func paddingScheduleFromConfig(paddings []*Padding) ([]paddingTurn, error) { + if len(paddings) == 0 { + return nil, nil + } + if len(paddings) > maxPaddingTurns { + return nil, fmt.Errorf("too many padding turns: %d (at most %d)", len(paddings), maxPaddingTurns) + } + var totalLength, totalDelayMilliseconds int64 + schedule := make([]paddingTurn, len(paddings)) + for i, turn := range paddings { + if turn == nil || turn.LengthMin < 1 || turn.LengthMax < turn.LengthMin || turn.LengthMax > maxPaddingTurnLength { + return nil, fmt.Errorf("invalid padding length range at turn %d", i) + } + if turn.DelayMin < 0 || turn.DelayMax < turn.DelayMin { + return nil, fmt.Errorf("invalid padding delay range %d-%d at turn %d (must be non-negative and ordered)", turn.DelayMin, turn.DelayMax, i) + } + if turn.DelayMax > maxPaddingDelayMilliseconds { + return nil, fmt.Errorf("padding delay range %d-%d at turn %d is too large", turn.DelayMin, turn.DelayMax, i) + } + totalLength += turn.LengthMax + if totalLength > maxPaddingTotalLength { + return nil, fmt.Errorf("padding turns are longer than %d bytes in total", maxPaddingTotalLength) + } + totalDelayMilliseconds += turn.DelayMax + if totalDelayMilliseconds > int64(maxPaddingScheduleDelay/time.Millisecond) { + return nil, fmt.Errorf("padding pauses are longer than %s in total", maxPaddingScheduleDelay) + } + var direction paddingDirection + switch turn.Direction { + case 1: + direction = paddingClientToServer + case 2: + direction = paddingServerToClient + default: + return nil, fmt.Errorf("invalid padding direction %d at turn %d (1=client-to-server, 2=server-to-client)", turn.Direction, i) + } + schedule[i] = paddingTurn{ + direction: direction, + minLength: int(turn.LengthMin), + maxLength: int(turn.LengthMax), + delay: paddingDelayRange{ + min: time.Duration(turn.DelayMin) * time.Millisecond, + max: time.Duration(turn.DelayMax) * time.Millisecond, + }, + } + } + // The first turn includes the two-byte Login Acknowledged packet. + if err := validatePaddingSchedule(schedule, 2); err != nil { + return nil, err + } + return schedule, nil +} diff --git a/transport/internet/finalmask/xmc/config.pb.go b/transport/internet/finalmask/xmc/config.pb.go index 0f670ea9d..f1afd8fb4 100644 --- a/transport/internet/finalmask/xmc/config.pb.go +++ b/transport/internet/finalmask/xmc/config.pb.go @@ -99,6 +99,13 @@ type Config struct { RsaPublicKey []byte `protobuf:"bytes,9,opt,name=rsa_public_key,json=rsaPublicKey,proto3" json:"rsa_public_key,omitempty"` Hostname string `protobuf:"bytes,10,opt,name=hostname,proto3" json:"hostname,omitempty"` Profiles []*Profile `protobuf:"bytes,11,rep,name=profiles,proto3" json:"profiles,omitempty"` + // Padding turns. Empty uses the built-in preset, unless no_padding is set. + // A configured list is the complete schedule and replaces the preset + // entirely: the preset's Play-state join tail runs only with the preset. + Paddings []*Padding `protobuf:"bytes,12,rep,name=paddings,proto3" json:"paddings,omitempty"` + // Disables startup padding. The configuration sets this for an explicit + // empty "paddings" array, which an unset repeated field cannot express. + NoPadding bool `protobuf:"varint,14,opt,name=no_padding,json=noPadding,proto3" json:"no_padding,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } @@ -168,6 +175,105 @@ func (x *Config) GetProfiles() []*Profile { return nil } +func (x *Config) GetPaddings() []*Padding { + if x != nil { + return x.Paddings + } + return nil +} + +func (x *Config) GetNoPadding() bool { + if x != nil { + return x.NoPadding + } + return false +} + +type Padding struct { + state protoimpl.MessageState `protogen:"open.v1"` + LengthMin int64 `protobuf:"varint,1,opt,name=length_min,json=lengthMin,proto3" json:"length_min,omitempty"` + LengthMax int64 `protobuf:"varint,2,opt,name=length_max,json=lengthMax,proto3" json:"length_max,omitempty"` + // 1 = client to server, 2 = server to client + Direction int32 `protobuf:"varint,3,opt,name=direction,proto3" json:"direction,omitempty"` + // Millisecond pause that leads into this turn: it sits between the previous + // padding turn (or Login Acknowledged, for the first turn) and this turn's + // bytes, so a captured gap is written on the turn that follows it. The side + // that sends the turn waits for a uniformly selected value in + // [delay_min, delay_max]; the peer spends exactly delay_min at the same + // place, so only the sending side jitters: use delay_min == delay_max to + // reproduce a captured gap. Nothing pauses after the last turn. Zero means + // no pause. + DelayMin int64 `protobuf:"varint,4,opt,name=delay_min,json=delayMin,proto3" json:"delay_min,omitempty"` + DelayMax int64 `protobuf:"varint,5,opt,name=delay_max,json=delayMax,proto3" json:"delay_max,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *Padding) Reset() { + *x = Padding{} + mi := &file_transport_internet_finalmask_xmc_config_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *Padding) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Padding) ProtoMessage() {} + +func (x *Padding) ProtoReflect() protoreflect.Message { + mi := &file_transport_internet_finalmask_xmc_config_proto_msgTypes[2] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Padding.ProtoReflect.Descriptor instead. +func (*Padding) Descriptor() ([]byte, []int) { + return file_transport_internet_finalmask_xmc_config_proto_rawDescGZIP(), []int{2} +} + +func (x *Padding) GetLengthMin() int64 { + if x != nil { + return x.LengthMin + } + return 0 +} + +func (x *Padding) GetLengthMax() int64 { + if x != nil { + return x.LengthMax + } + return 0 +} + +func (x *Padding) GetDirection() int32 { + if x != nil { + return x.Direction + } + return 0 +} + +func (x *Padding) GetDelayMin() int64 { + if x != nil { + return x.DelayMin + } + return 0 +} + +func (x *Padding) GetDelayMax() int64 { + if x != nil { + return x.DelayMax + } + return 0 +} + var File_transport_internet_finalmask_xmc_config_proto protoreflect.FileDescriptor const file_transport_internet_finalmask_xmc_config_proto_rawDesc = "" + @@ -177,14 +283,25 @@ const file_transport_internet_finalmask_xmc_config_proto_rawDesc = "" + "\busername\x18\x01 \x01(\tR\busername\x12\x12\n" + "\x04uuid\x18\x02 \x01(\fR\x04uuid\x12%\n" + "\x0etextures_value\x18\x03 \x01(\tR\rtexturesValue\x12-\n" + - "\x12textures_signature\x18\x04 \x01(\tR\x11texturesSignature\"\xe0\x01\n" + + "\x12textures_signature\x18\x04 \x01(\tR\x11texturesSignature\"\xcb\x02\n" + "\x06Config\x12\x1a\n" + "\bpassword\x18\x01 \x01(\tR\bpassword\x12&\n" + "\x0frsa_private_key\x18\b \x01(\fR\rrsaPrivateKey\x12$\n" + "\x0ersa_public_key\x18\t \x01(\fR\frsaPublicKey\x12\x1a\n" + "\bhostname\x18\n" + " \x01(\tR\bhostname\x12J\n" + - "\bprofiles\x18\v \x03(\v2..xray.transport.internet.finalmask.xmc.ProfileR\bprofilesJ\x04\b\x02\x10\x03B\x91\x01\n" + + "\bprofiles\x18\v \x03(\v2..xray.transport.internet.finalmask.xmc.ProfileR\bprofiles\x12J\n" + + "\bpaddings\x18\f \x03(\v2..xray.transport.internet.finalmask.xmc.PaddingR\bpaddings\x12\x1d\n" + + "\n" + + "no_padding\x18\x0e \x01(\bR\tnoPaddingJ\x04\b\x02\x10\x03\"\x9f\x01\n" + + "\aPadding\x12\x1d\n" + + "\n" + + "length_min\x18\x01 \x01(\x03R\tlengthMin\x12\x1d\n" + + "\n" + + "length_max\x18\x02 \x01(\x03R\tlengthMax\x12\x1c\n" + + "\tdirection\x18\x03 \x01(\x05R\tdirection\x12\x1b\n" + + "\tdelay_min\x18\x04 \x01(\x03R\bdelayMin\x12\x1b\n" + + "\tdelay_max\x18\x05 \x01(\x03R\bdelayMaxB\x91\x01\n" + ")com.xray.transport.internet.finalmask.xmcP\x01Z:github.com/xtls/xray-core/transport/internet/finalmask/xmc\xaa\x02%Xray.Transport.Internet.Finalmask.XMCb\x06proto3" var ( @@ -199,18 +316,20 @@ func file_transport_internet_finalmask_xmc_config_proto_rawDescGZIP() []byte { return file_transport_internet_finalmask_xmc_config_proto_rawDescData } -var file_transport_internet_finalmask_xmc_config_proto_msgTypes = make([]protoimpl.MessageInfo, 2) +var file_transport_internet_finalmask_xmc_config_proto_msgTypes = make([]protoimpl.MessageInfo, 3) var file_transport_internet_finalmask_xmc_config_proto_goTypes = []any{ (*Profile)(nil), // 0: xray.transport.internet.finalmask.xmc.Profile (*Config)(nil), // 1: xray.transport.internet.finalmask.xmc.Config + (*Padding)(nil), // 2: xray.transport.internet.finalmask.xmc.Padding } var file_transport_internet_finalmask_xmc_config_proto_depIdxs = []int32{ 0, // 0: xray.transport.internet.finalmask.xmc.Config.profiles:type_name -> xray.transport.internet.finalmask.xmc.Profile - 1, // [1:1] is the sub-list for method output_type - 1, // [1:1] is the sub-list for method input_type - 1, // [1:1] is the sub-list for extension type_name - 1, // [1:1] is the sub-list for extension extendee - 0, // [0:1] is the sub-list for field type_name + 2, // 1: xray.transport.internet.finalmask.xmc.Config.paddings:type_name -> xray.transport.internet.finalmask.xmc.Padding + 2, // [2:2] is the sub-list for method output_type + 2, // [2:2] is the sub-list for method input_type + 2, // [2:2] is the sub-list for extension type_name + 2, // [2:2] is the sub-list for extension extendee + 0, // [0:2] is the sub-list for field type_name } func init() { file_transport_internet_finalmask_xmc_config_proto_init() } @@ -224,7 +343,7 @@ func file_transport_internet_finalmask_xmc_config_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_transport_internet_finalmask_xmc_config_proto_rawDesc), len(file_transport_internet_finalmask_xmc_config_proto_rawDesc)), NumEnums: 0, - NumMessages: 2, + NumMessages: 3, NumExtensions: 0, NumServices: 0, }, diff --git a/transport/internet/finalmask/xmc/config.proto b/transport/internet/finalmask/xmc/config.proto index c880439d0..6c36d688b 100644 --- a/transport/internet/finalmask/xmc/config.proto +++ b/transport/internet/finalmask/xmc/config.proto @@ -23,4 +23,28 @@ message Config { bytes rsa_public_key = 9; string hostname = 10; repeated Profile profiles = 11; + // Padding turns. Empty uses the built-in preset, unless no_padding is set. + // A configured list is the complete schedule and replaces the preset + // entirely: the preset's Play-state join tail runs only with the preset. + repeated Padding paddings = 12; + // Disables startup padding. The configuration sets this for an explicit + // empty "paddings" array, which an unset repeated field cannot express. + bool no_padding = 14; +} + +message Padding { + int64 length_min = 1; + int64 length_max = 2; + // 1 = client to server, 2 = server to client + int32 direction = 3; + // Millisecond pause that leads into this turn: it sits between the previous + // padding turn (or Login Acknowledged, for the first turn) and this turn's + // bytes, so a captured gap is written on the turn that follows it. The side + // that sends the turn waits for a uniformly selected value in + // [delay_min, delay_max]; the peer spends exactly delay_min at the same + // place, so only the sending side jitters: use delay_min == delay_max to + // reproduce a captured gap. Nothing pauses after the last turn. Zero means + // no pause. + int64 delay_min = 4; + int64 delay_max = 5; } diff --git a/transport/internet/finalmask/xmc/config_test.go b/transport/internet/finalmask/xmc/config_test.go new file mode 100644 index 000000000..dcfd739c4 --- /dev/null +++ b/transport/internet/finalmask/xmc/config_test.go @@ -0,0 +1,148 @@ +package xmc + +import ( + "errors" + "net" + "strings" + "testing" + "time" +) + +func TestClientRejectsLongLegacyPassword(t *testing.T) { + client, server := net.Pipe() + defer client.Close() + defer server.Close() + + profiles := []loginProfile{{Username: "TestUser"}} + publicKey := []byte{0x01} + + if _, err := newClientConn(client, profiles, strings.Repeat("p", MaxLegacyPasswordLength), publicKey, "localhost", nil); err != nil { + t.Fatalf("password of %d bytes was rejected: %v", MaxLegacyPasswordLength, err) + } + if _, err := newClientConn(client, profiles, strings.Repeat("p", MaxLegacyPasswordLength+1), publicKey, "localhost", nil); err == nil { + t.Fatal("expected the long password to be rejected") + } +} + +func TestPaddingScheduleCaps(t *testing.T) { + turn := func(length, delay int64) *Padding { + return &Padding{LengthMin: length, LengthMax: length, Direction: 1, DelayMin: delay, DelayMax: delay} + } + + t.Run("too many turns", func(t *testing.T) { + paddings := make([]*Padding, maxPaddingTurns+1) + for i := range paddings { + paddings[i] = turn(3, 0) + } + if _, err := paddingScheduleFromConfig(paddings); err == nil { + t.Fatal("expected a turn count error") + } + }) + + t.Run("too many bytes", func(t *testing.T) { + paddings := make([]*Padding, maxPaddingTotalLength/maxPaddingTurnLength+1) + for i := range paddings { + paddings[i] = turn(maxPaddingTurnLength, 0) + } + if _, err := paddingScheduleFromConfig(paddings); err == nil { + t.Fatal("expected a total length error") + } + }) + + t.Run("too much delay", func(t *testing.T) { + tooLong := int64(maxPaddingScheduleDelay/time.Millisecond) + 1 + if _, err := paddingScheduleFromConfig([]*Padding{turn(3, tooLong)}); err == nil { + t.Fatal("expected a total delay error") + } + if _, err := paddingScheduleFromConfig([]*Padding{turn(3, int64(maxPaddingScheduleDelay/time.Millisecond))}); err != nil { + t.Fatalf("delay at the limit was rejected: %v", err) + } + }) +} + +func TestPaddingDisabled(t *testing.T) { + config := &Config{NoPadding: true} + if err := config.ValidatePadding(); err != nil { + t.Fatalf("disabled padding failed validation: %v", err) + } + schedule, err := config.paddingSchedule(true) + if err != nil { + t.Fatal(err) + } + if schedule != nil { + t.Fatalf("disabled padding returned %d turns", len(schedule)) + } + config.Paddings = []*Padding{{LengthMin: 3, LengthMax: 3, Direction: 1}} + if err := config.ValidatePadding(); err == nil { + t.Fatal("expected a conflict between disabled and configured padding") + } + if _, err := config.paddingSchedule(false); err == nil { + t.Fatal("expected a conflict between disabled and configured padding") + } + + preset := &Config{} + if schedule, err := preset.paddingSchedule(true); err != nil || len(schedule) == 0 { + t.Fatalf("client preset = %d turns, err %v", len(schedule), err) + } + if schedule, err := preset.paddingSchedule(false); err != nil || len(schedule) == 0 { + t.Fatalf("server preset = %d turns, err %v", len(schedule), err) + } +} + +// TestConfiguredPaddingsReplaceTheWholePreset pins the documented policy: a +// configured list is the complete schedule, so the preset's Play-state join tail +// does not run behind it on either end. +func TestConfiguredPaddingsReplaceTheWholePreset(t *testing.T) { + config := &Config{Paddings: []*Padding{ + {LengthMin: 44, LengthMax: 44, Direction: 1}, + {LengthMin: 64, LengthMax: 64, Direction: 2}, + }} + for _, isClient := range []bool{true, false} { + schedule, err := config.paddingSchedule(isClient) + if err != nil { + t.Fatal(err) + } + if len(schedule) != len(config.Paddings) { + t.Fatalf("isClient=%v: schedule has %d turns, want the %d configured turns", isClient, len(schedule), len(config.Paddings)) + } + for i, turn := range schedule { + want := paddingClientToServer + if config.Paddings[i].Direction == 2 { + want = paddingServerToClient + } + if turn.direction != want || turn.minLength != int(config.Paddings[i].LengthMin) { + t.Fatalf("isClient=%v: turn %d = %+v, want the configured %+v", isClient, i, turn, config.Paddings[i]) + } + } + } + + // The preset, in contrast, carries the join tail behind the startup turns. + preset, err := (&Config{}).paddingSchedule(true) + if err != nil { + t.Fatal(err) + } + if len(preset) <= len(startupPaddingSchedule2612) { + t.Fatalf("preset has %d turns, want the startup turns plus the join tail", len(preset)) + } +} + +func TestCloseCancelsPaddingPause(t *testing.T) { + client, server := net.Pipe() + defer server.Close() + + conn, err := newClientConn(client, []loginProfile{{Username: "TestUser"}}, "password", []byte{0x01}, "localhost", nil) + if err != nil { + t.Fatal(err) + } + if err := conn.Close(); err != nil { + t.Fatal(err) + } + + started := time.Now() + if err := conn.paddingPause(time.Hour); !errors.Is(err, net.ErrClosed) { + t.Fatalf("expected net.ErrClosed, got %v", err) + } + if time.Since(started) > time.Second { + t.Fatal("closing the connection did not cancel the pause") + } +} diff --git a/transport/internet/finalmask/xmc/deadline_test.go b/transport/internet/finalmask/xmc/deadline_test.go deleted file mode 100644 index 2a56c3e2c..000000000 --- a/transport/internet/finalmask/xmc/deadline_test.go +++ /dev/null @@ -1,81 +0,0 @@ -package xmc - -import ( - "net" - "sync" - "testing" - "time" -) - -func TestConnectionDeadlinesRestoreCallerValues(t *testing.T) { - client, server := net.Pipe() - defer client.Close() - defer server.Close() - - recording := &deadlineRecordingConn{Conn: client} - deadlines := newConnectionDeadlines(recording) - callerDeadline := time.Now().Add(10 * time.Minute) - if err := deadlines.setDeadline(callerDeadline); err != nil { - t.Fatal(err) - } - if err := deadlines.beginHandshake(); err != nil { - t.Fatal(err) - } - - read, write := recording.currentDeadlines() - if !read.Before(callerDeadline) || !write.Before(callerDeadline) { - t.Fatalf("handshake deadlines = %s/%s, caller = %s", read, write, callerDeadline) - } - - shortReadDeadline := time.Now().Add(time.Second) - if err := deadlines.setReadDeadline(shortReadDeadline); err != nil { - t.Fatal(err) - } - read, _ = recording.currentDeadlines() - if !read.Equal(shortReadDeadline) { - t.Fatalf("read deadline = %s, want %s", read, shortReadDeadline) - } - - if err := deadlines.endHandshake(); err != nil { - t.Fatal(err) - } - read, write = recording.currentDeadlines() - if !read.Equal(shortReadDeadline) || !write.Equal(callerDeadline) { - t.Fatalf("restored deadlines = %s/%s, want %s/%s", read, write, shortReadDeadline, callerDeadline) - } -} - -type deadlineRecordingConn struct { - net.Conn - mu sync.Mutex - read time.Time - write time.Time -} - -func (c *deadlineRecordingConn) SetDeadline(t time.Time) error { - c.mu.Lock() - c.read = t - c.write = t - c.mu.Unlock() - return c.Conn.SetDeadline(t) -} - -func (c *deadlineRecordingConn) SetReadDeadline(t time.Time) error { - c.mu.Lock() - c.read = t - c.mu.Unlock() - return c.Conn.SetReadDeadline(t) -} - -func (c *deadlineRecordingConn) SetWriteDeadline(t time.Time) error { - c.mu.Lock() - c.write = t - c.mu.Unlock() - return c.Conn.SetWriteDeadline(t) -} - -func (c *deadlineRecordingConn) currentDeadlines() (time.Time, time.Time) { - c.mu.Lock() - defer c.mu.Unlock() - return c.read, c.write -} diff --git a/transport/internet/finalmask/xmc/derivation_test.go b/transport/internet/finalmask/xmc/derivation_test.go deleted file mode 100644 index b436d46dc..000000000 --- a/transport/internet/finalmask/xmc/derivation_test.go +++ /dev/null @@ -1,58 +0,0 @@ -package xmc - -import ( - "crypto/sha256" - "crypto/x509" - "encoding/hex" - "testing" -) - -func TestDeriveRSAKey(t *testing.T) { - password := "my-very-secret-password-12345" - - key1, err := DeriveRSAKey(password) - if err != nil { - t.Fatalf("failed to derive key: %v", err) - } - - err = key1.Validate() - if err != nil { - t.Fatalf("key is not valid RSA key: %v", err) - } - - key2, err := DeriveRSAKey(password) - if err != nil { - t.Fatalf("failed to derive key second time: %v", err) - } - - // Verify determinism - if key1.D.Cmp(key2.D) != 0 || key1.N.Cmp(key2.N) != 0 { - t.Errorf("derived keys are not identical for the same password") - } - - // Verify different passwords yield different keys - keyDifferent, err := DeriveRSAKey(password + "-different") - if err != nil { - t.Fatalf("failed to derive different key: %v", err) - } - - if key1.D.Cmp(keyDifferent.D) == 0 || key1.N.Cmp(keyDifferent.N) == 0 { - t.Errorf("derived keys are identical for different passwords") - } -} - -func TestDeriveRSAKeyGoldenPrivateKey(t *testing.T) { - const password = "deterministic-rsa-key-golden" - const wantPKCS1DERHash = "3a8c4ad56a6fb42dab73c4d5fc3af754460a2db1441edc0970cbc7f4e0798d2f" - - key, err := DeriveRSAKey(password) - if err != nil { - t.Fatalf("failed to derive key: %v", err) - } - - gotHash := sha256.Sum256(x509.MarshalPKCS1PrivateKey(key)) - got := hex.EncodeToString(gotHash[:]) - if got != wantPKCS1DERHash { - t.Fatalf("derived private key changed\nwant sha256: %s\n got sha256: %s", wantPKCS1DERHash, got) - } -} diff --git a/transport/internet/finalmask/xmc/handshake_test.go b/transport/internet/finalmask/xmc/handshake_test.go index b2db51ef9..c6acd2d58 100644 --- a/transport/internet/finalmask/xmc/handshake_test.go +++ b/transport/internet/finalmask/xmc/handshake_test.go @@ -2,389 +2,113 @@ package xmc import ( "bytes" - "crypto/sha256" "crypto/x509" - "errors" - "fmt" "io" "net" - "strings" - "sync" "testing" "time" ) -func deriveTestRSAKey(t *testing.T, password string) ([]byte, []byte) { - t.Helper() - - key, err := DeriveRSAKey(password) - if err != nil { - t.Fatalf("failed to derive rsa key: %v", err) - } - - publicKey, err := x509.MarshalPKIXPublicKey(&key.PublicKey) - if err != nil { - t.Fatalf("failed to marshal public key: %v", err) - } - - return x509.MarshalPKCS1PrivateKey(key), publicKey -} - -func testLoginProfile(username string) loginProfile { - profile := loginProfile{ - Username: username, - TexturesValue: strings.Repeat("texture-value-", 40), - TexturesSignature: strings.Repeat("texture-signature-", 24), - } - digest := sha256.Sum256([]byte(username)) - copy(profile.UUID[:], digest[:16]) - profile.UUID[6] = (profile.UUID[6] & 0x0f) | 0x40 - profile.UUID[8] = (profile.UUID[8] & 0x3f) | 0x80 - return profile -} - -func TestHandshakeSuccess(t *testing.T) { - ln, err := net.Listen("tcp", "127.0.0.1:0") - if err != nil { - t.Fatalf("failed to listen: %v", err) - } - defer ln.Close() - - password := "super-secure-shared-key-12345" - profiles := []loginProfile{testLoginProfile("test_user")} - privateKey, publicKey := deriveTestRSAKey(t, password) - - go func() { - rawConn, err := ln.Accept() - if err != nil { - return - } - defer rawConn.Close() - - server, err := wrapConnServer(rawConn, profiles, password, privateKey, publicKey) - if err != nil { - t.Errorf("failed to wrap server: %v", err) - return - } - - buf := make([]byte, 1024) - n, err := server.Read(buf) - if err != nil { - t.Errorf("server read error: %v", err) - return - } - - if !bytes.Equal(buf[:n], []byte("hello server")) { - t.Errorf("unexpected payload from client: %s", string(buf[:n])) - return - } - - _, err = server.Write([]byte("hello client")) - if err != nil { - t.Errorf("server write error: %v", err) - return - } - }() - - clientRaw, err := net.Dial("tcp", ln.Addr().String()) - if err != nil { - t.Fatalf("failed to dial: %v", err) - } - defer clientRaw.Close() - - client, err := newClientConn(clientRaw, profiles, password, publicKey, "localhost") - if err != nil { - t.Fatalf("failed to create client: %v", err) - } - - _, err = client.Write([]byte("hello server")) - if err != nil { - t.Fatalf("client write error: %v", err) - } - - buf := make([]byte, 1024) - n, err := client.Read(buf) - if err != nil { - t.Fatalf("client read error: %v", err) - } - - if !bytes.Equal(buf[:n], []byte("hello client")) { - t.Errorf("unexpected payload from server: %s", string(buf[:n])) - } -} - -func TestHandshakePasswordMismatch(t *testing.T) { - ln, err := net.Listen("tcp", "127.0.0.1:0") - if err != nil { - t.Fatalf("failed to listen: %v", err) - } - defer ln.Close() - - clientPassword := "client-secret-123" - serverPassword := "server-secret-456" - profiles := []loginProfile{testLoginProfile("test_user")} - serverPrivateKey, serverPublicKey := deriveTestRSAKey(t, serverPassword) - - var wg sync.WaitGroup - wg.Add(1) - go func() { - defer wg.Done() - - rawConn, err := ln.Accept() - if err != nil { - return - } - defer rawConn.Close() - - server, err := wrapConnServer(rawConn, profiles, serverPassword, serverPrivateKey, serverPublicKey) - if err != nil { - // Wrapping is synchronous and shouldn't fail initially simply because key derivation works with any string - t.Logf("wrapped server: %v", err) - } - - // When client sends data, handshake happens and should fail - buf := make([]byte, 1024) - _, err = server.Read(buf) - if err == nil { - t.Errorf("expected handshake to fail due to password mismatch, but it succeeded") - } else { - t.Logf("server read failed as expected: %v", err) - } - }() - - clientRaw, err := net.Dial("tcp", ln.Addr().String()) - if err != nil { - t.Fatalf("failed to dial: %v", err) - } - defer clientRaw.Close() - - client, err := newClientConn(clientRaw, profiles, clientPassword, serverPublicKey, "localhost") - if err != nil { - t.Fatalf("failed to create client: %v", err) - } - - err = client.handshake() - if err == nil { - t.Fatal("expected client handshake to fail due to password mismatch") - } - - wg.Wait() - - // Check if we lost connection or received error - t.Log("Handshake mismatch tested") -} - -func TestHandshakeNetPipeWithKeepAlive(t *testing.T) { - clientRaw, serverRaw := net.Pipe() - defer clientRaw.Close() - defer serverRaw.Close() - - const password = "net-pipe-shared-key" - profiles := []loginProfile{testLoginProfile("pipe_user")} - privateKey, publicKey := deriveTestRSAKey(t, password) - serverDone := make(chan error, 1) - - go func() { - server, err := wrapConnServer(serverRaw, profiles, password, privateKey, publicKey) - if err != nil { - serverDone <- err - return - } - - request := make([]byte, len("hello server")) - if _, err = io.ReadFull(server, request); err != nil { - serverDone <- fmt.Errorf("read request: %w", err) - return - } - if string(request) != "hello server" { - serverDone <- fmt.Errorf("unexpected request: %q", request) - return - } - - followupDone := make(chan error, 1) - go func() { - followup := make([]byte, len("after keepalive")) - _, readErr := io.ReadFull(server, followup) - if readErr == nil && string(followup) != "after keepalive" { - readErr = fmt.Errorf("unexpected followup: %q", followup) - } - followupDone <- readErr - }() - - if err = server.packet.writeKeepAlive(Long(42)); err != nil { - serverDone <- fmt.Errorf("write keep-alive: %w", err) - return - } - if _, err = server.Write([]byte("hello client")); err != nil { - serverDone <- fmt.Errorf("write response: %w", err) - return - } - serverDone <- <-followupDone - }() - - client, err := newClientConn(clientRaw, profiles, password, publicKey, "localhost") - if err != nil { - t.Fatal(err) - } - if _, err = client.Write([]byte("hello server")); err != nil { - t.Fatalf("write request: %v", err) - } - response := make([]byte, len("hello client")) - if _, err = io.ReadFull(client, response); err != nil { - t.Fatalf("read response: %v", err) - } - if string(response) != "hello client" { - t.Fatalf("unexpected response: %q", response) - } - if _, err = client.Write([]byte("after keepalive")); err != nil { - t.Fatalf("write followup: %v", err) - } - - select { - case err = <-serverDone: +func TestHandshakeWithBidirectionalPadding(t *testing.T) { + t.Run("pipe", func(t *testing.T) { + client, server := net.Pipe() + testHandshakeWithPadding(t, client, server, 64*1024) + }) + t.Run("tcp", func(t *testing.T) { + listener, err := net.ListenTCP("tcp", &net.TCPAddr{IP: net.IPv4(127, 0, 0, 1)}) if err != nil { t.Fatal(err) } - case <-time.After(5 * time.Second): - t.Fatal("net.Pipe handshake timed out") - } + defer listener.Close() + client, err := net.DialTCP("tcp", nil, listener.Addr().(*net.TCPAddr)) + if err != nil { + t.Fatal(err) + } + defer client.Close() + server, err := listener.AcceptTCP() + if err != nil { + t.Fatal(err) + } + defer server.Close() + for _, conn := range []*net.TCPConn{client, server} { + if err := conn.SetWriteBuffer(16 * 1024); err != nil { + t.Fatal(err) + } + if err := conn.SetReadBuffer(64 * 1024); err != nil { + t.Fatal(err) + } + } + testHandshakeWithPadding(t, client, server, maxPaddingTurnLength) + }) } -func TestStatusQueryUnaffected(t *testing.T) { - clientRaw, serverRaw := net.Pipe() +func testHandshakeWithPadding(t *testing.T, clientRaw, serverRaw net.Conn, length int64) { + t.Helper() defer clientRaw.Close() defer serverRaw.Close() - const password = "status-shared-key" - profiles := []loginProfile{testLoginProfile("status_user")} - privateKey, publicKey := deriveTestRSAKey(t, password) - serverDone := make(chan error, 1) - go func() { - server, err := wrapConnServer(serverRaw, profiles, password, privateKey, publicKey) - if err == nil { - err = server.handshake() + key, err := DeriveRSAKey("padding-regression") + if err != nil { + t.Fatal(err) + } + publicKey, err := x509.MarshalPKIXPublicKey(&key.PublicKey) + if err != nil { + t.Fatal(err) + } + profiles := []loginProfile{{Username: "TestUser", TexturesValue: "texture", TexturesSignature: "signature"}} + padding := []*Padding{ + {Direction: 1, LengthMin: length, LengthMax: length}, + {Direction: 2, LengthMin: length, LengthMax: length}, + } + paddingSchedule, err := paddingScheduleFromConfig(padding) + if err != nil { + t.Fatal(err) + } + client, err := newClientConn(clientRaw, profiles, "password", publicKey, "localhost", paddingSchedule) + if err != nil { + t.Fatal(err) + } + defer client.Close() + server, err := wrapConnServer(serverRaw, profiles, "password", x509.MarshalPKCS1PrivateKey(key), publicKey, paddingSchedule) + if err != nil { + t.Fatal(err) + } + defer server.Close() + for _, conn := range []net.Conn{client, server} { + if err := conn.SetDeadline(time.Now().Add(15 * time.Second)); err != nil { + t.Fatal(err) } - serverDone <- err - }() - - protocolVersion := Varint(775) - serverAddress := String("localhost") - serverPort := UnsignedShort(25565) - nextState := Varint(1) - if err := writePacket(clientRaw, 0x00, &protocolVersion, &serverAddress, &serverPort, &nextState); err != nil { - t.Fatal(err) - } - if err := writePacket(clientRaw, 0x00); err != nil { - t.Fatal(err) - } - response, err := readPacket(clientRaw) - if err != nil { - t.Fatal(err) - } - if response.packetID != 0x00 { - t.Fatalf("status packet id = %d", response.packetID) - } - var responseJSON String - if err = response.readFields(&responseJSON); err != nil { - t.Fatal(err) - } - if string(responseJSON) != statusResponse { - t.Fatalf("status response = %q", responseJSON) } - payload := Long(0x0102030405060708) - if err = writePacket(clientRaw, 0x01, &payload); err != nil { - t.Fatal(err) - } - pong, err := readPacket(clientRaw) - if err != nil { - t.Fatal(err) - } - var receivedPayload Long - if pong.packetID != 0x01 { - t.Fatalf("pong packet id = %d", pong.packetID) - } - if err = pong.readFields(&receivedPayload); err != nil { - t.Fatal(err) - } - if receivedPayload != payload { - t.Fatalf("pong payload = %x", receivedPayload) - } - - select { - case err = <-serverDone: - if err == nil || !strings.Contains(err.Error(), "ping") { - t.Fatalf("server error = %v", err) + results := make(chan error, 2) + go func() { results <- client.handshake() }() + go func() { results <- server.handshake() }() + for range 2 { + if err := <-results; err != nil { + t.Errorf("handshake: %v", err) } - case <-time.After(time.Second): - t.Fatal("status handshake timed out") } -} - -func TestClientHandshakeHonorsCallerDeadline(t *testing.T) { - clientRaw, serverRaw := net.Pipe() - defer clientRaw.Close() - defer serverRaw.Close() - - const password = "deadline-shared-key" - profiles := []loginProfile{testLoginProfile("deadline_user")} - _, publicKey := deriveTestRSAKey(t, password) - client, err := newClientConn(clientRaw, profiles, password, publicKey, "localhost") - if err != nil { - t.Fatal(err) - } - if err = client.SetDeadline(time.Now().Add(30 * time.Millisecond)); err != nil { - t.Fatal(err) + if t.Failed() { + return } - started := time.Now() - _, err = client.Write([]byte("blocked")) - var netErr net.Error - if !errors.As(err, &netErr) || !netErr.Timeout() { - t.Fatalf("error = %v, want network timeout", err) - } - if elapsed := time.Since(started); elapsed > 500*time.Millisecond { - t.Fatalf("caller deadline took %s", elapsed) - } -} - -func TestClientCloseInterruptsHandshake(t *testing.T) { - clientRaw, serverRaw := net.Pipe() - defer serverRaw.Close() - - const password = "close-shared-key" - profiles := []loginProfile{testLoginProfile("close_user")} - _, publicKey := deriveTestRSAKey(t, password) - client, err := newClientConn(clientRaw, profiles, password, publicKey, "localhost") - if err != nil { - t.Fatal(err) - } - - done := make(chan error, 1) - go func() { - _, writeErr := client.Write([]byte("blocked")) - done <- writeErr - }() - time.Sleep(20 * time.Millisecond) - if err = client.Close(); err != nil { - t.Fatal(err) - } - - select { - case err = <-done: - if err == nil { - t.Fatal("handshake unexpectedly succeeded after close") + // Both startup readers can already be waiting for the next packet. The + // first proxy payload in either direction must survive the handoff. + for _, pair := range [][2]net.Conn{{client, server}, {server, client}} { + want := bytes.Repeat([]byte("proxy payload"), 4096) + go func() { + _, err := pair[0].Write(want) + results <- err + }() + got := make([]byte, len(want)) + if _, err := io.ReadFull(pair[1], got); err != nil { + t.Fatal(err) + } + if err := <-results; err != nil { + t.Fatal(err) + } + if !bytes.Equal(got, want) { + t.Fatal("proxy payload changed after startup padding") } - case <-time.After(time.Second): - t.Fatal("close did not interrupt handshake") - } -} - -func TestValidateLoginAcknowledgedPacketRejectsData(t *testing.T) { - if err := validateLoginAcknowledgedPacket(&mcPacket{packetID: 0x03}); err != nil { - t.Fatalf("valid login acknowledged packet: %v", err) - } - if err := validateLoginAcknowledgedPacket(&mcPacket{packetID: 0x03, data: []byte{0x00}}); err == nil { - t.Fatal("login acknowledged packet with trailing data was accepted") } } diff --git a/transport/internet/finalmask/xmc/packet_stream_test.go b/transport/internet/finalmask/xmc/packet_stream_test.go deleted file mode 100644 index ea605249f..000000000 --- a/transport/internet/finalmask/xmc/packet_stream_test.go +++ /dev/null @@ -1,102 +0,0 @@ -package xmc - -import ( - "bytes" - "io" - "net" - "testing" -) - -func TestPacketStreamUsesPlainFraming(t *testing.T) { - payload := []byte("hello") - var wire bytes.Buffer - stream := newPacketStream(bytes.NewReader(nil), &wire, true) - - written, err := stream.Write(payload) - if err != nil { - t.Fatalf("write payload: %v", err) - } - if written != len(payload) { - t.Fatalf("written = %d, want %d", written, len(payload)) - } - wantOutbound := []byte{0x0f, 0x02, 0x08, 'x', 'm', 'c', ':', 'd', 'a', 't', 'a', 'h', 'e', 'l', 'l', 'o'} - if !bytes.Equal(wire.Bytes(), wantOutbound) { - t.Fatalf("wire frame = %x, want %x", wire.Bytes(), wantOutbound) - } - - wantInbound := append([]byte(nil), wantOutbound...) - wantInbound[1] = configurationClientboundCustomPayload - reader := newPacketStream(bytes.NewReader(wantInbound), io.Discard, true) - got := make([]byte, len(payload)) - if _, err = io.ReadFull(reader, got); err != nil { - t.Fatalf("read payload: %v", err) - } - if !bytes.Equal(got, payload) { - t.Fatalf("payload = %q, want %q", got, payload) - } -} - -func TestPacketStreamRoundTrip(t *testing.T) { - ln, err := net.Listen("tcp", "127.0.0.1:0") - if err != nil { - t.Fatal(err) - } - defer ln.Close() - - const password = "packet-stream-shared-key" - privateKey, publicKey := deriveTestRSAKey(t, password) - profiles := []loginProfile{testLoginProfile("packet_user")} - clientPayload := bytes.Repeat([]byte("client-payload-"), 5000) - serverPayload := bytes.Repeat([]byte("server-payload-"), 5000) - serverDone := make(chan error, 1) - - go func() { - rawConn, acceptErr := ln.Accept() - if acceptErr != nil { - serverDone <- acceptErr - return - } - defer rawConn.Close() - - server, wrapErr := wrapConnServer(rawConn, profiles, password, privateKey, publicKey) - if wrapErr != nil { - serverDone <- wrapErr - return - } - got := make([]byte, len(clientPayload)) - if _, readErr := io.ReadFull(server, got); readErr != nil { - serverDone <- readErr - return - } - if !bytes.Equal(got, clientPayload) { - serverDone <- io.ErrUnexpectedEOF - return - } - _, writeErr := server.Write(serverPayload) - serverDone <- writeErr - }() - - rawClient, err := net.Dial("tcp", ln.Addr().String()) - if err != nil { - t.Fatal(err) - } - defer rawClient.Close() - - client, err := newClientConn(rawClient, profiles, password, publicKey, "localhost") - if err != nil { - t.Fatal(err) - } - if _, err = client.Write(clientPayload); err != nil { - t.Fatalf("write payload: %v", err) - } - got := make([]byte, len(serverPayload)) - if _, err = io.ReadFull(client, got); err != nil { - t.Fatalf("read payload: %v", err) - } - if !bytes.Equal(got, serverPayload) { - t.Fatal("server payload mismatch") - } - if err = <-serverDone; err != nil { - t.Fatalf("server: %v", err) - } -} diff --git a/transport/internet/finalmask/xmc/padding.go b/transport/internet/finalmask/xmc/padding.go index eb7114a09..cd9846903 100644 --- a/transport/internet/finalmask/xmc/padding.go +++ b/transport/internet/finalmask/xmc/padding.go @@ -1,11 +1,11 @@ package xmc import ( - "bytes" "crypto/rand" "fmt" "io" "math/big" + "net" "time" ) @@ -18,8 +18,31 @@ const ( paddingBufferLength = 16 * 1024 maxPaddingChunkLength = 48 * 1024 maxPaddingTurnLength = 8 * 1024 * 1024 + + // A configured schedule is bounded so that one handshake cannot be told to + // send an arbitrary amount of padding: maxPaddingTurns limits the number of + // turns and maxPaddingTotalLength the worst-case sum of their lengths. + maxPaddingTurns = 256 + maxPaddingTotalLength = 64 << 20 + // maxPaddingScheduleDelay keeps the configured pauses inside the handshake + // deadline. A schedule that cannot finish before the deadline would fail + // every connection, so it is rejected when the configuration is built. + maxPaddingScheduleDelay = handshakeTimeout - 10*time.Second + + // Frame padding carries the startup padding in ordinary Minecraft custom + // payload packets so that a vanilla server can parse the whole connection + // without taking the pipeline over. The channel is deliberately different + // from the packet stream channel: both ends drop unknown payloads. + paddingFrameChannel = "xmc:pad" + // Serverbound custom payload data is capped at 32767 bytes by + // ServerboundCustomPayloadPacket; keep the same budget in both directions. + maxPaddingFrameDataLength = 32767 + // Length varint, packet id, channel length varint and the channel itself. + paddingFrameOverhead = 1 + 1 + 1 + len(paddingFrameChannel) ) +var maxPaddingFrameLength = paddingFrameLength(maxPaddingFrameDataLength) + type paddingVariant struct { chunks []int delays []paddingDelayRange @@ -31,9 +54,12 @@ type paddingDelayRange struct { } type paddingTurn struct { - direction paddingDirection - minLength int - maxLength int + direction paddingDirection + minLength int + maxLength int + // delay leads into this turn: the side that sends it samples the range, the + // peer spends its minimum, and no pause follows the last turn. + delay paddingDelayRange variants []paddingVariant startDelay paddingDelayRange chunkDelay paddingDelayRange @@ -44,27 +70,66 @@ type paddingTurn struct { sendVariants []int } -func runPaddingSchedule(reader io.Reader, writer io.Writer, isClient bool, firstTurnPrefixLength int, schedule []paddingTurn) error { +// pausePadding waits for one padding pause. It returns as soon as the +// connection is closed so that a handshake cannot keep sleeping after its +// connection is gone. +func pausePadding(done <-chan struct{}, d time.Duration) error { + if d <= 0 { + return nil + } + timer := time.NewTimer(d) + defer timer.Stop() + select { + case <-timer.C: + return nil + case <-done: + return net.ErrClosed + } +} + +// runPaddingSchedule sends the local turns of the schedule and applies the +// configured pauses. A turn's pause leads into the turn, so the bytes of a turn +// always follow the pause that was configured next to it, and nothing pauses +// after the last turn: the proxy stream follows it directly. An empty schedule +// means padding is disabled and nothing is written or waited for. +// +// Nothing here checks when a peer's turn arrives: the turns are ordinary +// Minecraft packets that carry nothing to compare an early arrival against, and +// the startup reader drains them on its own while this schedule writes. A peer +// that stalls is bounded by maxPaddingScheduleDelay instead. +func runPaddingSchedule(writer io.Writer, isClient bool, firstTurnPrefixLength int, schedule []paddingTurn, sleep func(time.Duration) error) error { + if len(schedule) == 0 { + return nil + } if err := validatePaddingSchedule(schedule, firstTurnPrefixLength); err != nil { return err } - var writeBuffer []byte for i, turn := range schedule { prefixLength := 0 if i == 0 { prefixLength = firstTurnPrefixLength } - localSends := isClient == (turn.direction == paddingClientToServer) - if localSends { - if err := writePaddingTurnWithBuffer(writer, turn, prefixLength, time.Sleep, &writeBuffer); err != nil { - return fmt.Errorf("write padding turn %d: %w", i, err) + if isClient != (turn.direction == paddingClientToServer) { + // The startup reader drains peer padding independently so writes + // cannot fill both connection buffers. The peer still spends the + // same pause at the same place in the schedule, which keeps both + // timelines in phase; it only knows the minimum. + if err := sleep(turn.delay.min); err != nil { + return err } continue } - if err := readPaddingTurn(reader, turn, prefixLength); err != nil { - return fmt.Errorf("read padding turn %d: %w", i, err) + delay, err := randomPaddingDelay(turn.delay) + if err != nil { + return fmt.Errorf("select padding turn %d delay: %w", i, err) + } + if err := sleep(delay); err != nil { + return err + } + if _, err := writePaddingTurnFrames(writer, turn, prefixLength, sleep, paddingFramePacketID(isClient)); err != nil { + return fmt.Errorf("write padding turn %d: %w", i, err) } } return nil @@ -91,6 +156,9 @@ func validatePaddingSchedule(schedule []paddingTurn, firstTurnPrefixLength int) if err := validatePaddingDelayRange(turn.chunkDelay); err != nil { return fmt.Errorf("padding turn %d has an invalid chunk delay: %w", i, err) } + if err := validatePaddingDelayRange(turn.delay); err != nil { + return fmt.Errorf("padding turn %d has an invalid inter-turn delay: %w", i, err) + } if turn.writeChunkMinLength < 0 || turn.writeChunkLength < turn.writeChunkMinLength || turn.writeChunkLength > maxPaddingChunkLength { return fmt.Errorf("padding turn %d has an invalid write chunk range: %d-%d", i, turn.writeChunkMinLength, turn.writeChunkLength) } @@ -121,43 +189,39 @@ func validatePaddingSchedule(schedule []paddingTurn, firstTurnPrefixLength int) } } } - if i > 0 && turn.direction == schedule[i-1].direction { - return fmt.Errorf("padding turns %d and %d have the same direction", i-1, i) - } } return nil } -func writePaddingTurn(w io.Writer, turn paddingTurn, prefixLength int) error { - return writePaddingTurnWithSleep(w, turn, prefixLength, time.Sleep) +// paddingFramePacketID returns the configuration-state custom payload packet id +// used by the side that sends the padding bytes; both values come from the +// vanilla configuration protocol, so no proxy-specific id ever reaches the wire. +func paddingFramePacketID(isClient bool) int { + if isClient { + return configurationServerboundCustomPayload + } + return configurationClientboundCustomPayload } -func writePaddingTurnWithSleep(w io.Writer, turn paddingTurn, prefixLength int, sleep func(time.Duration)) error { - return writePaddingTurnWithBuffer(w, turn, prefixLength, sleep, nil) -} - -func writePaddingTurnWithBuffer(w io.Writer, turn paddingTurn, prefixLength int, sleep func(time.Duration), reusableBuffer *[]byte) error { +// writePaddingTurnFrames writes one padding turn as a sequence of valid +// Minecraft custom payload frames. Only the framing is native: payload bodies +// stay zero-filled, so the captured traffic shape is kept. +func writePaddingTurnFrames(w io.Writer, turn paddingTurn, prefixLength int, sleep func(time.Duration) error, packetID int) (int, error) { startDelay, err := randomPaddingDelay(turn.startDelay) if err != nil { - return fmt.Errorf("select padding start delay: %w", err) + return 0, fmt.Errorf("select padding start delay: %w", err) } - if startDelay > 0 { - sleep(startDelay) + if err := sleep(startDelay); err != nil { + return 0, err } targetLength, chunks, delays, err := selectPaddingVariant(turn, prefixLength) if err != nil { - return err + return 0, err } - recordLength := targetLength - prefixLength - if recordLength < 1 { - return fmt.Errorf("target length %d leaves an invalid record length %d", targetLength, recordLength) - } - - encodedLength := Varint(recordLength) - var header bytes.Buffer - if err = encodedLength.writeTo(&header); err != nil { - return fmt.Errorf("write padding header: %w", err) + payloadLength := targetLength - prefixLength + if payloadLength < 1 { + return 0, fmt.Errorf("target length %d leaves an invalid padding payload of %d bytes", targetLength, payloadLength) } if len(chunks) == 0 { writeChunkLength := turn.writeChunkLength @@ -166,89 +230,103 @@ func writePaddingTurnWithBuffer(w io.Writer, turn paddingTurn, prefixLength int, } else if turn.writeChunkMinLength > 0 { writeChunkLength, err = randomPaddingTarget(turn.writeChunkMinLength, writeChunkLength) if err != nil { - return fmt.Errorf("select padding write chunk length: %w", err) + return 0, fmt.Errorf("select padding write chunk length: %w", err) } } - chunks = defaultPaddingChunks(recordLength, writeChunkLength) + chunks = defaultPaddingChunks(payloadLength, writeChunkLength) delays = make([]paddingDelayRange, len(chunks)) for i := 1; i < len(delays); i++ { delays[i] = turn.chunkDelay } } - if chunks[0] < header.Len() { - return fmt.Errorf("first padding chunk %d is shorter than header %d", chunks[0], header.Len()) - } - maxChunkLength := 0 - for _, chunkLength := range chunks { - if chunkLength < 1 || chunkLength > maxPaddingChunkLength { - return fmt.Errorf("invalid padding chunk length: %d", chunkLength) - } - maxChunkLength = max(maxChunkLength, chunkLength) - } - var buffer []byte - if reusableBuffer == nil { - buffer = make([]byte, maxChunkLength) - } else { - if cap(*reusableBuffer) < maxChunkLength { - *reusableBuffer = make([]byte, maxChunkLength) - } - buffer = (*reusableBuffer)[:maxChunkLength] - clear(buffer) - } - copy(buffer, header.Bytes()) + zeros := make([]byte, maxPaddingFrameDataLength) + channel := String(paddingFrameChannel) written := 0 for i, chunkLength := range chunks { if i < len(delays) { delay, delayErr := randomPaddingDelay(delays[i]) if delayErr != nil { - return fmt.Errorf("select padding chunk %d delay: %w", i, delayErr) + return written, fmt.Errorf("select padding chunk %d delay: %w", i, delayErr) } - if delay > 0 { - sleep(delay) + if delayErr = sleep(delay); delayErr != nil { + return written, delayErr } } - if err = writeFull(w, buffer[:chunkLength]); err != nil { - return fmt.Errorf("write padding chunk %d: %w", i, err) + frameLengths, planErr := paddingFramePlan(chunkLength) + if planErr != nil { + return written, planErr } - written += chunkLength - if i == 0 { - clear(buffer[:header.Len()]) + for _, frameLength := range frameLengths { + dataLength, ok := paddingFrameDataLength(frameLength) + if !ok { + return written, fmt.Errorf("unframed padding length %d", frameLength) + } + payload := RestBytes(zeros[:dataLength]) + if err = writePacket(w, packetID, &channel, &payload); err != nil { + return written, fmt.Errorf("write padding frame: %w", err) + } + written += frameLength } } - if written != recordLength { - return fmt.Errorf("padding chunks total %d, want %d", written, recordLength) - } - return nil + return written, nil } -func readPaddingTurn(r io.Reader, turn paddingTurn, prefixLength int) error { - encodedLength, headerLength, err := readVarintWithLength(r) - if err != nil { - return fmt.Errorf("read padding header: %w", err) - } - recordLength := int(encodedLength) - if recordLength < headerLength || recordLength > maxPaddingTurnLength { - return fmt.Errorf("invalid padding record length: %d", recordLength) - } - totalLength := prefixLength + recordLength - if !paddingTurnAcceptsLength(turn, totalLength) { - if len(turn.variants) > 0 { - return fmt.Errorf("padding turn length %d is not an allowed variant", totalLength) - } - return fmt.Errorf("padding turn length %d is outside %d-%d", totalLength, turn.minLength, turn.maxLength) - } +// paddingFrameLength is the wire size of a custom payload frame whose payload +// body is dataLength bytes long. +func paddingFrameLength(dataLength int) int { + bodyLength := 1 + 1 + len(paddingFrameChannel) + dataLength + return varintSize(Varint(bodyLength)) + bodyLength +} - var buffer [paddingBufferLength]byte - remaining := recordLength - headerLength - for remaining > 0 { - chunkLength := min(remaining, len(buffer)) - if _, err := io.ReadFull(r, buffer[:chunkLength]); err != nil { - return fmt.Errorf("read padding body: %w", err) +// paddingFrameDataLength is the payload body that makes a frame exactly +// frameLength bytes long. Some lengths are unreachable because the length +// varint grows in steps. +func paddingFrameDataLength(frameLength int) (int, bool) { + for overhead := paddingFrameOverhead; overhead <= paddingFrameOverhead+2; overhead++ { + dataLength := frameLength - overhead + if dataLength < 0 || dataLength > maxPaddingFrameDataLength { + continue + } + if paddingFrameLength(dataLength) == frameLength { + return dataLength, true } - remaining -= chunkLength } - return nil + return 0, false +} + +// paddingFramePlan splits length bytes into reachable frame sizes. The result is +// exact whenever a partition exists; a length below the smallest frame (the +// captured 2-byte turns) is rounded up to that frame. +func paddingFramePlan(length int) ([]int, error) { + if length <= 0 { + return nil, nil + } + if length < paddingFrameOverhead { + return []int{paddingFrameOverhead}, nil + } + frameLengths := make([]int, 0, length/paddingBufferLength+1) + for remaining := length; remaining > 0; { + candidate := min(remaining, maxPaddingFrameLength) + picked := 0 + for ; candidate >= paddingFrameOverhead; candidate-- { + if _, ok := paddingFrameDataLength(candidate); !ok { + continue + } + rest := remaining - candidate + if rest > 0 && rest < paddingFrameOverhead { + continue + } + picked = candidate + break + } + if picked == 0 { + return nil, fmt.Errorf("cannot frame %d padding bytes", length) + } + frameLengths = append(frameLengths, picked) + remaining -= picked + } + return frameLengths, nil } func selectPaddingVariant(turn paddingTurn, prefixLength int) (int, []int, []paddingDelayRange, error) { diff --git a/transport/internet/finalmask/xmc/padding_frames_test.go b/transport/internet/finalmask/xmc/padding_frames_test.go new file mode 100644 index 000000000..a419a6494 --- /dev/null +++ b/transport/internet/finalmask/xmc/padding_frames_test.go @@ -0,0 +1,288 @@ +package xmc + +import ( + "bytes" + "errors" + "io" + "net" + "strings" + "testing" + "time" +) + +func TestPaddingFrameDataLengthRoundTrip(t *testing.T) { + for dataLength := 0; dataLength <= maxPaddingFrameDataLength; dataLength++ { + frameLength := paddingFrameLength(dataLength) + got, ok := paddingFrameDataLength(frameLength) + if !ok || got != dataLength { + t.Fatalf("data length %d -> frame %d -> data %d (ok=%v)", dataLength, frameLength, got, ok) + } + } +} + +func TestPaddingFramePlanTotals(t *testing.T) { + lengths := []int{paddingFrameOverhead, paddingFrameOverhead + 1, 128, 129, 130, 131, 140, 1024, 48 * 1024, maxPaddingFrameLength - 1, maxPaddingFrameLength, maxPaddingFrameLength + 1, 3 * maxPaddingFrameLength, 1024 * 1024} + for _, length := range lengths { + plan, err := paddingFramePlan(length) + if err != nil { + t.Fatalf("plan %d: %v", length, err) + } + total := 0 + for _, frameLength := range plan { + if _, ok := paddingFrameDataLength(frameLength); !ok { + t.Fatalf("plan %d contains unreachable frame %d", length, frameLength) + } + if frameLength > maxPaddingFrameLength { + t.Fatalf("plan %d contains oversized frame %d", length, frameLength) + } + total += frameLength + } + if total != length { + t.Fatalf("plan %d totals %d", length, total) + } + } +} + +func TestPaddingFramePlanRoundsUpShortTurn(t *testing.T) { + plan, err := paddingFramePlan(2) + if err != nil { + t.Fatal(err) + } + if len(plan) != 1 || plan[0] != paddingFrameOverhead { + t.Fatalf("short turn plan = %v", plan) + } +} + +func TestWritePaddingTurnFramesIsMinecraftTraffic(t *testing.T) { + turns := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44}, + {direction: paddingClientToServer, minLength: 2, maxLength: 2}, + {direction: paddingClientToServer, minLength: maxPaddingFrameLength, maxLength: maxPaddingFrameLength}, + {direction: paddingClientToServer, minLength: 3*maxPaddingFrameLength + 7, maxLength: 3*maxPaddingFrameLength + 7}, + } + for i, turn := range turns { + var buffer bytes.Buffer + written, err := writePaddingTurnFrames(&buffer, turn, 0, noPaddingPause, configurationServerboundCustomPayload) + if err != nil { + t.Fatalf("turn %d: %v", i, err) + } + if written != buffer.Len() { + t.Fatalf("turn %d wrote %d bytes, buffer has %d", i, written, buffer.Len()) + } + target := turn.minLength + if written < target { + t.Fatalf("turn %d wrote %d bytes, want at least %d", i, written, target) + } + + reader := bytes.NewReader(buffer.Bytes()) + frames := 0 + for reader.Len() > 0 { + packet, err := readPacket(reader) + if err != nil { + t.Fatalf("turn %d frame %d is not a valid packet: %v", i, frames, err) + } + if packet.packetID != configurationServerboundCustomPayload { + t.Fatalf("turn %d frame %d has packet id %d", i, frames, packet.packetID) + } + _, ok, err := parseCustomPayload(packet) + if err != nil { + t.Fatalf("turn %d frame %d: %v", i, frames, err) + } + if ok { + t.Fatalf("turn %d frame %d uses the packet stream channel", i, frames) + } + if len(packet.data) == 0 { + t.Fatalf("turn %d frame %d has no channel", i, frames) + } + frames++ + } + } +} + +func TestRunPaddingScheduleLeavesPeerTurnsAlone(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44}, + {direction: paddingServerToClient, minLength: 64, maxLength: 64}, + {direction: paddingClientToServer, minLength: 25, maxLength: 25}, + } + + var out bytes.Buffer + if err := runPaddingSchedule(&out, true, 2, schedule, noPaddingPause); err != nil { + t.Fatal(err) + } + + reader := bytes.NewReader(out.Bytes()) + total := 0 + for reader.Len() > 0 { + before := reader.Len() + packet, err := readPacket(reader) + if err != nil { + t.Fatalf("padding stream is not a valid packet stream: %v", err) + } + if packet.packetID != configurationServerboundCustomPayload { + t.Fatalf("unexpected packet id %d in padding stream", packet.packetID) + } + total += before - reader.Len() + } + // Turn 0 carries the 2 byte Login Acknowledged prefix, turn 1 is the peer's. + want := 44 - 2 + 25 + if total != want { + t.Fatalf("padding stream carries %d payload bytes, want %d", total, want) + } +} + +func TestRunPaddingScheduleRejectsInvalidSchedule(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingServerToClient, minLength: 10, maxLength: 10}, + } + if err := runPaddingSchedule(&bytes.Buffer{}, true, 2, schedule, noPaddingPause); err == nil { + t.Fatal("expected an error for a prefixed server-to-client first turn") + } +} + +func noPaddingPause(time.Duration) error { return nil } + +func TestRunPaddingScheduleWithoutTurns(t *testing.T) { + var out bytes.Buffer + if err := runPaddingSchedule(&out, true, 2, nil, noPaddingPause); err != nil { + t.Fatal(err) + } + if out.Len() != 0 { + t.Fatalf("disabled padding wrote %d bytes", out.Len()) + } +} + +func TestRunPaddingScheduleStopsWhenClosed(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(1000, 1000)}, + {direction: paddingClientToServer, minLength: 44, maxLength: 44}, + } + + var out bytes.Buffer + pauses := 0 + sleep := func(d time.Duration) error { + if d <= 0 { + return nil + } + pauses++ + return net.ErrClosed + } + err := runPaddingSchedule(&out, true, 2, schedule, sleep) + if !errors.Is(err, net.ErrClosed) { + t.Fatalf("expected net.ErrClosed, got %v", err) + } + if pauses != 1 { + t.Fatalf("pauses = %d, want 1", pauses) + } + // The pause leads into turn 0, so the cancelled pause came before its bytes. + if out.Len() != 0 { + t.Fatalf("schedule kept writing after a cancelled pause: %d bytes", out.Len()) + } +} + +// recordingWriter records one event per write, so a test can see where the +// pauses fall relative to the padding bytes. +type recordingWriter struct { + events *[]string +} + +func (w recordingWriter) Write(p []byte) (int, error) { + *w.events = append(*w.events, "write") + return len(p), nil +} + +// TestPaddingDelayLeadsIntoTheTurn pins the placement of a configured pause: +// it belongs to the turn it precedes, the peer spends its minimum at the same +// place, and the last turn is not followed by one. +func TestPaddingDelayLeadsIntoTheTurn(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(10, 10)}, + {direction: paddingServerToClient, minLength: 20, maxLength: 20, delay: millisecondRange(20, 20)}, + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(30, 30)}, + } + run := func(isClient bool) []string { + var events []string + sleep := func(d time.Duration) error { + if d > 0 { + events = append(events, "pause "+d.String()) + } + return nil + } + if err := runPaddingSchedule(recordingWriter{events: &events}, isClient, 2, schedule, sleep); err != nil { + t.Fatal(err) + } + return events + } + + // The client sends turns 0 and 2, so it pauses before each of them and + // spends the minimum of turn 1 while the server sends it. + client := strings.Join(run(true), ",") + wantClient := "pause 10ms,write,pause 20ms,pause 30ms,write" + if client != wantClient { + t.Fatalf("client events = %q, want %q", client, wantClient) + } + + // The server sends turn 1, so the same pauses lead into its bytes. The last + // turn's pause still happens, but nothing follows the final write. + server := strings.Join(run(false), ",") + wantServer := "pause 10ms,pause 20ms,write,pause 30ms" + if server != wantServer { + t.Fatalf("server events = %q, want %q", server, wantServer) + } +} + +// TestPaddingDelayRangeJittersOnlyTheSender pins which value each end waits: +// the side that sends the turn samples the range, the peer spends the minimum. +func TestPaddingDelayRangeJittersOnlyTheSender(t *testing.T) { + schedule := []paddingTurn{ + {direction: paddingClientToServer, minLength: 44, maxLength: 44, delay: millisecondRange(20, 200)}, + {direction: paddingClientToServer, minLength: 44, maxLength: 44}, + } + run := func(isClient bool) []time.Duration { + var pauses []time.Duration + sleep := func(d time.Duration) error { + if d > 0 { + pauses = append(pauses, d) + } + return nil + } + if err := runPaddingSchedule(io.Discard, isClient, 2, schedule, sleep); err != nil { + t.Fatal(err) + } + return pauses + } + + // The peer, which sends nothing here, spends exactly the minimum. + if got := run(false); len(got) != 1 || got[0] != 20*time.Millisecond { + t.Fatalf("peer pauses = %v, want exactly [20ms]", got) + } + + seenLarge := false + for i := 0; i < 64; i++ { + pauses := run(true) + if len(pauses) != 1 { + t.Fatalf("sender pauses = %v, want exactly one pause", pauses) + } + if pauses[0] < 20*time.Millisecond || pauses[0] > 200*time.Millisecond { + t.Fatalf("sender pause %s is outside the configured range", pauses[0]) + } + if pauses[0] >= 20*time.Millisecond && pauses[0] <= 200*time.Millisecond && pauses[0] != 20*time.Millisecond { + seenLarge = true + } + } + if !seenLarge { + t.Fatal("the sender never sampled a value above the minimum") + } +} + +func TestPaddingPauseReturnsOnClose(t *testing.T) { + done := make(chan struct{}) + close(done) + started := time.Now() + if err := pausePadding(done, time.Hour); !errors.Is(err, net.ErrClosed) { + t.Fatalf("expected net.ErrClosed, got %v", err) + } + if time.Since(started) > time.Second { + t.Fatal("pausePadding did not return on close") + } +} diff --git a/transport/internet/finalmask/xmc/padding_reader.go b/transport/internet/finalmask/xmc/padding_reader.go new file mode 100644 index 000000000..7f70e3c6a --- /dev/null +++ b/transport/internet/finalmask/xmc/padding_reader.go @@ -0,0 +1,61 @@ +package xmc + +import ( + "bytes" + "io" +) + +type paddingReadResult struct { + frame []byte + err error +} + +type paddingReader struct { + reader io.Reader + first <-chan paddingReadResult +} + +// newPaddingReader drains startup padding while the local padding schedule is +// writing. Buffer only the first non-padding packet, then let the caller resume +// reading the underlying stream. This keeps memory bounded without requiring +// matching padding lengths or an extra end-of-padding packet on the wire. +func newPaddingReader(reader io.Reader, isClient bool) io.Reader { + first := make(chan paddingReadResult, 1) + go func() { + frame, err := readPastPadding(reader, paddingFramePacketID(!isClient)) + first <- paddingReadResult{frame: frame, err: err} + }() + return &paddingReader{reader: reader, first: first} +} + +func readPastPadding(reader io.Reader, packetID int) ([]byte, error) { + for { + packet, err := readPacket(reader) + if err != nil { + return nil, err + } + if packet.packetID == packetID { + var channel String + if err := channel.readFrom(bytes.NewReader(packet.data)); err == nil && channel == paddingFrameChannel { + continue + } + } + payload := RestBytes(packet.data) + return encodePacket(packet.packetID, &payload) + } +} + +func (r *paddingReader) Read(p []byte) (int, error) { + if len(p) == 0 { + return 0, nil + } + if r.first != nil { + result := <-r.first + r.first = nil + if result.err != nil { + return 0, result.err + } + r.reader = io.MultiReader(bytes.NewReader(result.frame), r.reader) + } + return r.reader.Read(p) +} diff --git a/transport/internet/finalmask/xmc/padding_reader_test.go b/transport/internet/finalmask/xmc/padding_reader_test.go new file mode 100644 index 000000000..8ccdef16a --- /dev/null +++ b/transport/internet/finalmask/xmc/padding_reader_test.go @@ -0,0 +1,76 @@ +package xmc + +import ( + "bytes" + "errors" + "io" + "net" + "testing" +) + +func TestPaddingReaderPreservesFollowingPackets(t *testing.T) { + for _, isClient := range []bool{true, false} { + packetID := paddingFramePacketID(!isClient) + var wire bytes.Buffer + paddingChannel := String(paddingFrameChannel) + padding := RestBytes(make([]byte, 1024)) + if err := writePacket(&wire, packetID, &paddingChannel, &padding); err != nil { + t.Fatal(err) + } + var want bytes.Buffer + unknownChannel := String("other:channel") + payload := RestBytes("preserve unknown custom payloads") + if err := writePacket(&want, packetID, &unknownChannel, &payload); err != nil { + t.Fatal(err) + } + id := Long(42) + if err := writePacket(&want, configurationKeepAlive, &id); err != nil { + t.Fatal(err) + } + channel := String(packetChannel) + if err := writePacket(&want, packetID, &channel, &payload); err != nil { + t.Fatal(err) + } + wire.Write(want.Bytes()) + got, err := io.ReadAll(newPaddingReader(&wire, isClient)) + if err != nil { + t.Fatal(err) + } + if !bytes.Equal(got, want.Bytes()) { + t.Fatalf("client=%v: non-padding packets changed", isClient) + } + } +} + +func TestPaddingReaderReadErrors(t *testing.T) { + for _, test := range []struct { + name string + wire []byte + err error + }{ + {name: "eof", err: io.EOF}, + {name: "truncated", wire: []byte{2, 1}, err: io.ErrUnexpectedEOF}, + } { + t.Run(test.name, func(t *testing.T) { + reader := newPaddingReader(bytes.NewReader(test.wire), true) + if _, err := reader.Read(make([]byte, 1)); !errors.Is(err, test.err) { + t.Fatalf("got %v, want %v", err, test.err) + } + }) + } +} + +func TestPaddingReaderUnblocksOnClose(t *testing.T) { + client, server := net.Pipe() + defer server.Close() + reader := newPaddingReader(client, true) + if n, err := reader.Read(nil); n != 0 || err != nil { + t.Fatalf("empty read = %d, %v", n, err) + } + if err := client.Close(); err != nil { + t.Fatal(err) + } + if _, err := reader.Read(make([]byte, 1)); !errors.Is(err, io.ErrClosedPipe) { + t.Fatalf("closed read = %v", err) + } +} diff --git a/transport/internet/finalmask/xmc/padding_test.go b/transport/internet/finalmask/xmc/padding_test.go deleted file mode 100644 index 493306aaa..000000000 --- a/transport/internet/finalmask/xmc/padding_test.go +++ /dev/null @@ -1,618 +0,0 @@ -package xmc - -import ( - "bytes" - "errors" - "io" - "net" - "strconv" - "strings" - "testing" - "time" -) - -func TestPaddingTurnReachesFinalTargetLength(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: 128, maxLength: 128} - const prefixLength = 3 - var encoded bytes.Buffer - if err := writePaddingTurn(&encoded, turn, prefixLength); err != nil { - t.Fatal(err) - } - if got := prefixLength + encoded.Len(); got != turn.minLength { - t.Fatalf("total turn length = %d, want %d", got, turn.minLength) - } - encodedReader := bytes.NewReader(encoded.Bytes()) - var recordLength Varint - if err := recordLength.readFrom(encodedReader); err != nil { - t.Fatal(err) - } - if got := int(recordLength); got != encoded.Len() { - t.Fatalf("record length = %d, encoded = %d", got, encoded.Len()) - } - if err := readPaddingTurn(bytes.NewReader(encoded.Bytes()), turn, prefixLength); err != nil { - t.Fatal(err) - } -} - -func TestPaddingTurnSupportsThreeByteTarget(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: 3, maxLength: 3} - var encoded bytes.Buffer - if err := writePaddingTurn(&encoded, turn, 0); err != nil { - t.Fatal(err) - } - if got := encoded.Len(); got != 3 { - t.Fatalf("padding length = %d, want 3", got) - } - if err := readPaddingTurn(bytes.NewReader(encoded.Bytes()), turn, 0); err != nil { - t.Fatal(err) - } -} - -func TestPaddingTurnVarintBoundaries(t *testing.T) { - for _, targetLength := range []int{127, 128, 16383, 16384} { - t.Run(strconv.Itoa(targetLength), func(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: targetLength, maxLength: targetLength} - var encoded bytes.Buffer - if err := writePaddingTurn(&encoded, turn, 0); err != nil { - t.Fatal(err) - } - if encoded.Len() != targetLength { - t.Fatalf("padding length = %d, want %d", encoded.Len(), targetLength) - } - if err := readPaddingTurn(bytes.NewReader(encoded.Bytes()), turn, 0); err != nil { - t.Fatal(err) - } - }) - } -} - -func TestPaddingTurnRandomRange(t *testing.T) { - turn := paddingTurn{direction: paddingServerToClient, minLength: 127, maxLength: 129} - seen := make(map[int]bool) - for range 100 { - var encoded bytes.Buffer - if err := writePaddingTurn(&encoded, turn, 0); err != nil { - t.Fatal(err) - } - if encoded.Len() < turn.minLength || encoded.Len() > turn.maxLength { - t.Fatalf("padding length = %d", encoded.Len()) - } - seen[encoded.Len()] = true - } - if len(seen) < 2 { - t.Fatalf("padding range did not vary: %v", seen) - } -} - -func TestPaddingTurnUsesRestrictedSendRange(t *testing.T) { - turn := paddingTurn{ - direction: paddingServerToClient, - minLength: 3, - maxLength: 100, - sendMinLength: 90, - sendMaxLength: 100, - } - seen := make(map[int]bool) - for range 100 { - var encoded bytes.Buffer - if err := writePaddingTurn(&encoded, turn, 0); err != nil { - t.Fatal(err) - } - if encoded.Len() < turn.sendMinLength || encoded.Len() > turn.sendMaxLength { - t.Fatalf("padding length = %d", encoded.Len()) - } - seen[encoded.Len()] = true - if err := readPaddingTurn(bytes.NewReader(encoded.Bytes()), turn, 0); err != nil { - t.Fatal(err) - } - } - if len(seen) < 2 { - t.Fatalf("restricted send range did not vary: %v", seen) - } -} - -func TestPaddingScheduleSynchronizesDirections(t *testing.T) { - client, server := net.Pipe() - defer client.Close() - defer server.Close() - - schedule := []paddingTurn{ - {direction: paddingClientToServer, minLength: 33, maxLength: 33}, - {direction: paddingServerToClient, minLength: 4097, maxLength: 4097}, - {direction: paddingClientToServer, minLength: 16385, maxLength: 16385}, - } - serverDone := make(chan error, 1) - go func() { - serverDone <- runPaddingSchedule(server, server, false, 3, schedule) - }() - if err := runPaddingSchedule(client, client, true, 3, schedule); err != nil { - t.Fatal(err) - } - select { - case err := <-serverDone: - if err != nil { - t.Fatal(err) - } - case <-time.After(time.Second): - t.Fatal("server padding schedule did not complete") - } -} - -func TestReadPaddingTurnHandlesFragmentedInput(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: 1024, maxLength: 1024} - var encoded bytes.Buffer - if err := writePaddingTurn(&encoded, turn, 0); err != nil { - t.Fatal(err) - } - if err := readPaddingTurn(&oneByteReader{reader: bytes.NewReader(encoded.Bytes())}, turn, 0); err != nil { - t.Fatal(err) - } -} - -func TestReadPaddingTurnRejectsInvalidLength(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: 64, maxLength: 96} - data := encodePaddingLength(t, 63) - if err := readPaddingTurn(bytes.NewReader(data), turn, 0); err == nil || !strings.Contains(err.Error(), "outside") { - t.Fatalf("error = %v", err) - } -} - -func TestReadPaddingTurnRejectsNonCanonicalHeader(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: 3, maxLength: 3} - err := readPaddingTurn(bytes.NewReader([]byte{0x83, 0x00, 0x00}), turn, 0) - if err == nil || !strings.Contains(err.Error(), "non-canonical") { - t.Fatalf("error = %v", err) - } -} - -func TestReadPaddingTurnRejectsTruncatedBody(t *testing.T) { - turn := paddingTurn{direction: paddingClientToServer, minLength: 64, maxLength: 64} - data := encodePaddingLength(t, 64) - if err := readPaddingTurn(bytes.NewReader(data), turn, 0); err == nil || !strings.Contains(err.Error(), "body") { - t.Fatalf("error = %v", err) - } -} - -func TestReadPaddingTurnHonorsConnectionTimeout(t *testing.T) { - client, server := net.Pipe() - defer client.Close() - defer server.Close() - - if err := server.SetReadDeadline(time.Now().Add(20 * time.Millisecond)); err != nil { - t.Fatal(err) - } - turn := paddingTurn{direction: paddingClientToServer, minLength: 64, maxLength: 64} - err := readPaddingTurn(server, turn, 0) - var netErr net.Error - if !errors.As(err, &netErr) || !netErr.Timeout() { - t.Fatalf("error = %v, want network timeout", err) - } -} - -func TestValidatePaddingSchedule(t *testing.T) { - tests := []struct { - name string - schedule []paddingTurn - prefix int - }{ - {name: "empty"}, - {name: "bad direction", schedule: []paddingTurn{{direction: 99, minLength: 4, maxLength: 4}}}, - {name: "too small", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 0, maxLength: 4}}}, - {name: "reversed range", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 7}}}, - {name: "wrong first direction", prefix: 3, schedule: []paddingTurn{{direction: paddingServerToClient, minLength: 8, maxLength: 8}}}, - {name: "prefix leaves no header", prefix: 8, schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8}}}, - {name: "same direction", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8}, {direction: paddingClientToServer, minLength: 8, maxLength: 8}}}, - {name: "range with variants", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8, variants: []paddingVariant{paddingVariantFromChunks(8)}}}}, - {name: "empty variant", schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{{}}}}}, - {name: "bad chunk", schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{paddingVariantFromChunks(maxPaddingChunkLength + 1)}}}}, - { - name: "delay mismatch", - schedule: []paddingTurn{{ - direction: paddingClientToServer, - variants: []paddingVariant{{ - chunks: []int{4, 4}, - delays: []paddingDelayRange{{min: time.Millisecond, max: time.Millisecond}}, - }}, - }}, - }, - {name: "reversed start delay", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8, startDelay: paddingDelayRange{min: 2 * time.Millisecond, max: time.Millisecond}}}}, - {name: "reversed generated chunk delay", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8, chunkDelay: paddingDelayRange{min: 2 * time.Millisecond, max: time.Millisecond}}}}, - {name: "oversized generated chunk", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8, writeChunkLength: maxPaddingChunkLength + 1}}}, - {name: "reversed generated chunk range", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 8, writeChunkMinLength: 9, writeChunkLength: 8}}}, - {name: "variant with generated chunks", schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{paddingVariantFromChunks(8)}, writeChunkLength: 8}}}, - {name: "send range outside accepted range", schedule: []paddingTurn{{direction: paddingClientToServer, minLength: 8, maxLength: 16, sendMinLength: 7, sendMaxLength: 12}}}, - {name: "variant with send range", schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{paddingVariantFromChunks(8)}, sendMinLength: 8, sendMaxLength: 8}}}, - {name: "negative chunk delay", schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{{chunks: []int{8}, delays: []paddingDelayRange{{min: -time.Millisecond}}}}}}}, - {name: "bad send variant", schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{paddingVariantFromChunks(8)}, sendVariants: []int{1}}}}, - {name: "prefix splits chunk", prefix: 3, schedule: []paddingTurn{{direction: paddingClientToServer, variants: []paddingVariant{paddingVariantFromChunks(8, 4)}}}}, - } - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - if err := validatePaddingSchedule(test.schedule, test.prefix); err == nil { - t.Fatal("expected invalid padding schedule") - } - }) - } -} - -func TestPaddingSchedule2612MatchesCapturedTemplates(t *testing.T) { - wantDirections := []paddingDirection{ - paddingClientToServer, - paddingServerToClient, - paddingClientToServer, - paddingServerToClient, - paddingClientToServer, - paddingServerToClient, - } - wantLengths := [][]int{ - {44}, - {72}, - {25}, - {41172}, - {2}, - {7464, 8267, 8790, 8153, 7375, 7347, 8184, 6633, 7670, 8241, 7857, 7254, 8407, 8283, 6804, 8177, 8177, 7929, 8296, 8177}, - } - if len(paddingSchedule2612) != len(wantDirections)+33 { - t.Fatalf("padding schedule has %d turns, want %d", len(paddingSchedule2612), len(wantDirections)+33) - } - for i, turn := range paddingSchedule2612[:len(wantDirections)] { - if turn.direction != wantDirections[i] { - t.Fatalf("padding turn %d direction = %d, want %d", i, turn.direction, wantDirections[i]) - } - if len(turn.variants) != len(wantLengths[i]) { - t.Fatalf("padding turn %d has %d variants, want %d", i, len(turn.variants), len(wantLengths[i])) - } - for j, variant := range turn.variants { - if got := paddingVariantLength(variant); got != wantLengths[i][j] { - t.Fatalf("padding turn %d variant %d length = %d, want %d", i, j, got, wantLengths[i][j]) - } - } - } - wantPlayBounds := [][2]int{ - {6, 883}, - {346, 58638}, - {6, 887}, - {388, 61077}, - {2, 50}, - {575, 65584}, - {6, 45}, - {86, 63563}, - {2, 44}, - {42, 51983}, - {2, 851}, - {309, 25083}, - {2, 19}, - {74, 63885}, - {8, 24}, - {30, 66128}, - {2, 19}, - {26, 35818}, - {6, 19}, - {35, 59407}, - {6, 19}, - {37, 65328}, - {2, 19}, - {26, 60622}, - {6, 19}, - {11, 60808}, - {8, 43}, - {55, 62027}, - {2, 19}, - {427, 65622}, - {5, 19}, - {35, 59401}, - {6, 19}, - } - for i, want := range wantPlayBounds { - turn := paddingSchedule2612[len(wantDirections)+i] - wantDirection := paddingClientToServer - if i%2 == 1 { - wantDirection = paddingServerToClient - } - if turn.direction != wantDirection { - t.Fatalf("play turn %d direction = %d, want %d", i, turn.direction, wantDirection) - } - if turn.minLength != want[0] || turn.maxLength != want[1] { - t.Fatalf("play turn %d bounds = %d-%d, want %d-%d", i, turn.minLength, turn.maxLength, want[0], want[1]) - } - if len(turn.variants) != 0 { - t.Fatalf("play turn %d unexpectedly has captured variants", i) - } - } - if got := len(paddingSchedule2612[3].variants[0].chunks); got != 30 { - t.Fatalf("registry turn chunks = %d, want 30", got) - } - minimumPlayStart := maxPaddingTurnLength - maximumPlayStart := 0 - for _, variant := range paddingSchedule2612[5].variants { - length := paddingVariantLength(variant) - minimumPlayStart = min(minimumPlayStart, length) - maximumPlayStart = max(maximumPlayStart, length) - if variant.chunks[0] != 4941 { - t.Fatalf("play start first chunk = %d, want 4941", variant.chunks[0]) - } - } - if minimumPlayStart != 6633 || maximumPlayStart != 8790 { - t.Fatalf("play start bounds = %d-%d, want 6633-8790", minimumPlayStart, maximumPlayStart) - } - if err := validatePaddingSchedule(paddingSchedule2612, 2); err != nil { - t.Fatalf("captured schedule is invalid: %v", err) - } - - serverSchedule, err := newServerPaddingSchedule2612() - if err != nil { - t.Fatal(err) - } - if err = validatePaddingSchedule(serverSchedule, 2); err != nil { - t.Fatalf("server schedule is invalid: %v", err) - } - for i, branches := range serverPlayBranches2612 { - turn := serverSchedule[len(startupPaddingSchedule2612)+1+i*2] - got := paddingLengthRange2612{turn.sendMinLength, turn.sendMaxLength} - if got != branches.small && got != branches.large { - t.Fatalf("server play turn %d send range = %v, want %v or %v", i, got, branches.small, branches.large) - } - } - - for range 20 { - clientSchedule, clientErr := newClientPaddingSchedule2612() - if clientErr != nil { - t.Fatal(clientErr) - } - if clientErr = validatePaddingSchedule(clientSchedule, 2); clientErr != nil { - t.Fatalf("client schedule is invalid: %v", clientErr) - } - burstCount := 0 - for _, burst := range clientPlayBursts2612 { - turn := clientSchedule[len(startupPaddingSchedule2612)+burst.playIndex] - got := paddingLengthRange2612{turn.sendMinLength, turn.sendMaxLength} - switch got { - case burst.regular: - case burst.burst: - burstCount++ - default: - t.Fatalf("client play turn %d send range = %v", burst.playIndex, got) - } - } - if burstCount != 1 { - t.Fatalf("client schedule has %d initialization bursts, want 1", burstCount) - } - } - - for variantIndex := range paddingSchedule2612[3].variants { - turn := paddingSchedule2612[3] - turn.sendVariants = []int{variantIndex} - var encoded bytes.Buffer - if err = writePaddingTurnWithSleep(&encoded, turn, 0, func(time.Duration) {}); err != nil { - t.Fatal(err) - } - if err = readPaddingTurn(bytes.NewReader(encoded.Bytes()), paddingSchedule2612[3], 0); err != nil { - t.Fatalf("registry variant %d was rejected: %v", variantIndex, err) - } - } -} - -func TestPaddingVariantPreservesWriteBoundaries(t *testing.T) { - tests := []struct { - name string - turn paddingTurn - prefix int - want []int - }{ - {name: "login acknowledged turn", turn: paddingSchedule2612[0], prefix: 2, want: []int{26, 16}}, - {name: "server response turn", turn: paddingSchedule2612[1], want: []int{26, 21, 25}}, - {name: "single packet turn", turn: paddingSchedule2612[2], want: []int{25}}, - {name: "fixed registry profile", turn: paddingSchedule2612[3], want: paddingSchedule2612[3].variants[0].chunks}, - } - for _, test := range tests { - t.Run(test.name, func(t *testing.T) { - var writer recordingWriter - if err := writePaddingTurnWithSleep(&writer, test.turn, test.prefix, func(time.Duration) {}); err != nil { - t.Fatal(err) - } - if len(writer.writes) != len(test.want) { - t.Fatalf("writes = %v, want %v", writer.writes, test.want) - } - for i := range test.want { - if writer.writes[i] != test.want[i] { - t.Fatalf("writes = %v, want %v", writer.writes, test.want) - } - } - if err := readPaddingTurn(bytes.NewReader(writer.Bytes()), test.turn, test.prefix); err != nil { - t.Fatal(err) - } - }) - } -} - -func TestPaddingVariantAppliesPacing(t *testing.T) { - turn := paddingTurn{ - direction: paddingClientToServer, - startDelay: paddingDelayRange{min: 3 * time.Millisecond, max: 3 * time.Millisecond}, - variants: []paddingVariant{{ - chunks: []int{3, 5, 7}, - delays: []paddingDelayRange{ - {}, - {min: 2 * time.Millisecond, max: 2 * time.Millisecond}, - {min: 4 * time.Millisecond, max: 4 * time.Millisecond}, - }, - }}, - } - var slept []time.Duration - var writer recordingWriter - if err := writePaddingTurnWithSleep(&writer, turn, 3, func(delay time.Duration) { - slept = append(slept, delay) - }); err != nil { - t.Fatal(err) - } - want := []time.Duration{3 * time.Millisecond, 2 * time.Millisecond, 4 * time.Millisecond} - if len(slept) != len(want) { - t.Fatalf("delays = %v, want %v", slept, want) - } - for i := range want { - if slept[i] != want[i] { - t.Fatalf("delays = %v, want %v", slept, want) - } - } -} - -func TestGeneratedPaddingChunksApplyPacing(t *testing.T) { - turn := paddingTurn{ - direction: paddingServerToClient, - minLength: 100, - maxLength: 100, - writeChunkLength: 32, - chunkDelay: paddingDelayRange{min: 2 * time.Millisecond, max: 2 * time.Millisecond}, - } - var slept []time.Duration - var writer recordingWriter - if err := writePaddingTurnWithSleep(&writer, turn, 0, func(delay time.Duration) { - slept = append(slept, delay) - }); err != nil { - t.Fatal(err) - } - wantWrites := []int{32, 32, 32, 4} - if !slicesEqual(writer.writes, wantWrites) { - t.Fatalf("writes = %v, want %v", writer.writes, wantWrites) - } - wantSleeps := []time.Duration{2 * time.Millisecond, 2 * time.Millisecond, 2 * time.Millisecond} - if !slicesEqual(slept, wantSleeps) { - t.Fatalf("delays = %v, want %v", slept, wantSleeps) - } - if err := readPaddingTurn(bytes.NewReader(writer.Bytes()), turn, 0); err != nil { - t.Fatal(err) - } -} - -func TestGeneratedPaddingChunkLengthIsRandomized(t *testing.T) { - turn := paddingTurn{ - direction: paddingServerToClient, - minLength: 100, - maxLength: 100, - writeChunkMinLength: 16, - writeChunkLength: 32, - } - seen := make(map[int]bool) - for range 100 { - var writer recordingWriter - if err := writePaddingTurnWithSleep(&writer, turn, 0, func(time.Duration) {}); err != nil { - t.Fatal(err) - } - firstWrite := writer.writes[0] - if firstWrite < turn.writeChunkMinLength || firstWrite > turn.writeChunkLength { - t.Fatalf("first write = %d", firstWrite) - } - seen[firstWrite] = true - } - if len(seen) < 2 { - t.Fatalf("generated write chunk length did not vary: %v", seen) - } -} - -func TestPaddingDelayRangeIsRandomized(t *testing.T) { - delayRange := millisecondRange(25, 40) - seen := make(map[time.Duration]bool) - for range 100 { - delay, err := randomPaddingDelay(delayRange) - if err != nil { - t.Fatal(err) - } - if delay < delayRange.min || delay > delayRange.max { - t.Fatalf("delay = %s, want %s-%s", delay, delayRange.min, delayRange.max) - } - seen[delay] = true - } - if len(seen) < 2 { - t.Fatalf("padding delay did not vary: %v", seen) - } -} - -func TestPaddingSchedule2612UsesCoarseTimingBands(t *testing.T) { - assertDelayRange(t, "turn 3 to 4", paddingSchedule2612[3].startDelay, 20*time.Millisecond, 50*time.Millisecond) - assertDelayRange(t, "turn 5 to 6", paddingSchedule2612[5].startDelay, 35*time.Millisecond, 50*time.Millisecond) - assertDelayRange(t, "first play client turn", paddingSchedule2612[6].startDelay, time.Millisecond, 30*time.Millisecond) - assertDelayRange(t, "first play server turn", paddingSchedule2612[7].startDelay, time.Millisecond, 45*time.Millisecond) - assertDelayRange(t, "play server chunk pacing", paddingSchedule2612[7].chunkDelay, time.Millisecond, 4*time.Millisecond) - if paddingSchedule2612[6].writeChunkLength != 1024 { - t.Fatalf("play client write chunk = %d, want 1024", paddingSchedule2612[6].writeChunkLength) - } - if paddingSchedule2612[7].writeChunkLength != maxPaddingChunkLength { - t.Fatalf("play server write chunk = %d, want %d", paddingSchedule2612[7].writeChunkLength, maxPaddingChunkLength) - } - if paddingSchedule2612[7].writeChunkMinLength != 32*1024 { - t.Fatalf("play server minimum write chunk = %d, want %d", paddingSchedule2612[7].writeChunkMinLength, 32*1024) - } - - for i, variant := range paddingSchedule2612[3].variants { - minimum, maximum := paddingVariantDelayBounds(variant) - if minimum != 45*time.Millisecond || maximum != 65*time.Millisecond { - t.Fatalf("turn 4 variant %d duration = %s-%s, want 45ms-65ms", i, minimum, maximum) - } - } - for i, variant := range paddingSchedule2612[5].variants { - minimum, maximum := paddingVariantDelayBounds(variant) - if minimum != 10*time.Millisecond || maximum != 25*time.Millisecond { - t.Fatalf("turn 6 variant %d duration = %s-%s, want 10ms-25ms", i, minimum, maximum) - } - } -} - -func assertDelayRange(t *testing.T, name string, got paddingDelayRange, minimum, maximum time.Duration) { - t.Helper() - if got.min != minimum || got.max != maximum { - t.Fatalf("%s delay = %s-%s, want %s-%s", name, got.min, got.max, minimum, maximum) - } -} - -func paddingVariantDelayBounds(variant paddingVariant) (time.Duration, time.Duration) { - var minimum time.Duration - var maximum time.Duration - for _, delay := range variant.delays { - minimum += delay.min - maximum += delay.max - } - return minimum, maximum -} - -func slicesEqual[T comparable](left, right []T) bool { - if len(left) != len(right) { - return false - } - for i := range left { - if left[i] != right[i] { - return false - } - } - return true -} - -func encodePaddingLength(t *testing.T, length int) []byte { - t.Helper() - var encoded bytes.Buffer - value := Varint(length) - if err := value.writeTo(&encoded); err != nil { - t.Fatal(err) - } - return encoded.Bytes() -} - -type oneByteReader struct { - reader io.Reader -} - -func (r *oneByteReader) Read(p []byte) (int, error) { - if len(p) > 1 { - p = p[:1] - } - return r.reader.Read(p) -} - -type recordingWriter struct { - bytes.Buffer - writes []int -} - -func (w *recordingWriter) Write(p []byte) (int, error) { - w.writes = append(w.writes, len(p)) - return w.Buffer.Write(p) -} diff --git a/transport/internet/finalmask/xmc/profile_test.go b/transport/internet/finalmask/xmc/profile_test.go deleted file mode 100644 index 35dd41286..000000000 --- a/transport/internet/finalmask/xmc/profile_test.go +++ /dev/null @@ -1,33 +0,0 @@ -package xmc - -import ( - "bytes" - "testing" -) - -func TestProfilesFromConfigRejectsEmpty(t *testing.T) { - if _, err := profilesFromConfig(nil); err == nil { - t.Fatal("expected empty profiles error") - } -} - -func TestProfilesFromConfig(t *testing.T) { - uuid := bytes.Repeat([]byte{0x2a}, 16) - profiles, err := profilesFromConfig([]*Profile{ - { - Username: "SignedUser", - Uuid: uuid, - TexturesValue: "textures-value", - TexturesSignature: "textures-signature", - }, - }) - if err != nil { - t.Fatalf("build explicit profile: %v", err) - } - if len(profiles) != 1 || profiles[0].Username != "SignedUser" { - t.Fatalf("unexpected profile: %+v", profiles) - } - if profiles[0].TexturesValue != "textures-value" || profiles[0].TexturesSignature != "textures-signature" { - t.Fatalf("textures were not preserved: %+v", profiles[0]) - } -} diff --git a/transport/internet/finalmask/xmc/protocol.go b/transport/internet/finalmask/xmc/protocol.go index a636d413d..8b53b4442 100644 --- a/transport/internet/finalmask/xmc/protocol.go +++ b/transport/internet/finalmask/xmc/protocol.go @@ -8,7 +8,11 @@ import ( ) const ( - maxPacketDataLength = 32 * 1024 + // Clientbound custom payloads are allowed up to 1 MiB by vanilla, and a + // vanilla configuration state can send large registry data packets. This is + // only an upper bound for decoding; the XMC payload stream keeps its own, + // much smaller, chunk size. + maxPacketDataLength = 1024 * 1024 maxPacketBodyLength = maxPacketDataLength + 5 ) diff --git a/transport/internet/finalmask/xmc/protocol_test.go b/transport/internet/finalmask/xmc/protocol_test.go deleted file mode 100644 index 3aa68d488..000000000 --- a/transport/internet/finalmask/xmc/protocol_test.go +++ /dev/null @@ -1,56 +0,0 @@ -package xmc - -import ( - "bytes" - "strings" - "testing" -) - -func TestReadPacketDoesNotConsumeFollowingPacket(t *testing.T) { - data := []byte{0x01, 0x80, 0x01, 0x00} - r := bytes.NewReader(data) - if _, err := readPacket(r); err == nil { - t.Fatal("expected truncated packet ID to fail") - } - pkt, err := readPacket(r) - if err != nil { - t.Fatalf("read following packet: %v", err) - } - if pkt.packetID != 0 { - t.Fatalf("packet ID = %d", pkt.packetID) - } -} - -func TestPacketWithLengthReportsWireBytes(t *testing.T) { - var wire bytes.Buffer - written, err := writePacketWithLength(&wire, 0x03) - if err != nil { - t.Fatal(err) - } - if written != 2 || !bytes.Equal(wire.Bytes(), []byte{0x01, 0x03}) { - t.Fatalf("wire = %x, length = %d", wire.Bytes(), written) - } - - packet, read, err := readPacketWithLength(bytes.NewReader(wire.Bytes())) - if err != nil { - t.Fatal(err) - } - if packet.packetID != 0x03 || read != written { - t.Fatalf("packet ID = %d, read = %d, written = %d", packet.packetID, read, written) - } -} - -func TestReadPacketRejectsNonCanonicalLengthVarint(t *testing.T) { - _, _, err := readPacketWithLength(bytes.NewReader([]byte{0x81, 0x00, 0x03})) - if err == nil || !strings.Contains(err.Error(), "non-canonical") { - t.Fatalf("error = %v", err) - } -} - -func TestVarintRejectsOversizedFifthByte(t *testing.T) { - var value Varint - err := value.readFrom(bytes.NewReader([]byte{0xff, 0xff, 0xff, 0xff, 0x1f})) - if err == nil || !strings.Contains(err.Error(), "too large") { - t.Fatalf("error = %v", err) - } -} diff --git a/transport/internet/finalmask/xmc/server.go b/transport/internet/finalmask/xmc/server.go index 43fba9593..40c050a85 100644 --- a/transport/internet/finalmask/xmc/server.go +++ b/transport/internet/finalmask/xmc/server.go @@ -41,6 +41,9 @@ type serverConn struct { paddingSchedule []paddingTurn packet *packetStream deadlines *connectionDeadlines + + done chan struct{} + closeOnce sync.Once } func (c *serverConn) handshake() error { @@ -245,7 +248,9 @@ func (c *serverConn) handshake() error { if err = validateLoginAcknowledgedPacket(pkt); err != nil { return err } - if err = runPaddingSchedule(c.reader, c.writer, false, loginAcknowledgedLength, c.paddingSchedule); err != nil { + c.reader = newPaddingReader(c.reader, false) + if err = runPaddingSchedule(c.writer, false, loginAcknowledgedLength, c.paddingSchedule, c.paddingPause); err != nil { + _ = c.Close() // Unblock the startup reader if writing failed. return fmt.Errorf("run startup padding: %w", err) } @@ -302,12 +307,18 @@ func (c *serverConn) Close() error { c.closed = true packet := c.packet c.lifecycleMu.Unlock() + c.closeOnce.Do(func() { close(c.done) }) if packet != nil { packet.Stop() } return c.c.Close() } +// paddingPause applies one padding pause, stopping early on Close. +func (c *serverConn) paddingPause(d time.Duration) error { + return pausePadding(c.done, d) +} + func (c *serverConn) LocalAddr() net.Addr { return c.c.LocalAddr() } @@ -328,7 +339,7 @@ func (c *serverConn) SetWriteDeadline(t time.Time) error { return c.deadlines.setWriteDeadline(t) } -func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPrivateKeyDER []byte, rsaPublicKey []byte) (*serverConn, error) { +func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPrivateKeyDER []byte, rsaPublicKey []byte, paddingSchedule []paddingTurn) (*serverConn, error) { if len(profiles) == 0 { return nil, fmt.Errorf("empty profiles") } @@ -342,10 +353,6 @@ func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPri if err != nil { return nil, fmt.Errorf("parse rsa private key: %w", err) } - paddingSchedule, err := newServerPaddingSchedule2612() - if err != nil { - return nil, fmt.Errorf("select padding profile: %w", err) - } s := &serverConn{ reader: bufio.NewReader(c), @@ -358,6 +365,7 @@ func wrapConnServer(c net.Conn, profiles []loginProfile, password string, rsaPri rsaPublicKey: rsaPublicKey, paddingSchedule: paddingSchedule, deadlines: newConnectionDeadlines(c), + done: make(chan struct{}), } return s, nil diff --git a/transport/internet/finalmask/xmc/stream_test.go b/transport/internet/finalmask/xmc/stream_test.go deleted file mode 100644 index bd75d7b86..000000000 --- a/transport/internet/finalmask/xmc/stream_test.go +++ /dev/null @@ -1,81 +0,0 @@ -package xmc - -import ( - "bytes" - "io" - "testing" -) - -type dataAndEOFReader struct { - data []byte -} - -func (r *dataAndEOFReader) Read(p []byte) (int, error) { - if len(r.data) == 0 { - return 0, io.EOF - } - n := copy(p, r.data) - r.data = r.data[n:] - return n, io.EOF -} - -type shortWriter struct { - bytes.Buffer -} - -func (w *shortWriter) Write(p []byte) (int, error) { - if len(p) > 1 { - p = p[:len(p)/2] - } - return w.Buffer.Write(p) -} - -func TestCryptoReaderPreservesDataReturnedWithEOF(t *testing.T) { - secret := []byte("0123456789abcdef") - plaintext := []byte("payload returned with EOF") - var encrypted bytes.Buffer - writer, err := newCryptoWriter(&encrypted, secret) - if err != nil { - t.Fatal(err) - } - if _, err = writer.Write(plaintext); err != nil { - t.Fatal(err) - } - - reader, err := newCryptoReader(&dataAndEOFReader{data: encrypted.Bytes()}, secret) - if err != nil { - t.Fatal(err) - } - got := make([]byte, len(plaintext)) - n, err := reader.Read(got) - if err == nil || n != len(plaintext) { - t.Fatalf("Read = %d, %v", n, err) - } - if !bytes.Equal(got[:n], plaintext) { - t.Fatalf("plaintext = %q", got[:n]) - } -} - -func TestCryptoWriterHandlesShortWrites(t *testing.T) { - secret := []byte("0123456789abcdef") - plaintext := bytes.Repeat([]byte("short-write"), 100) - var dst shortWriter - writer, err := newCryptoWriter(&dst, secret) - if err != nil { - t.Fatal(err) - } - if n, err := writer.Write(plaintext); err != nil || n != len(plaintext) { - t.Fatalf("Write = %d, %v", n, err) - } - reader, err := newCryptoReader(bytes.NewReader(dst.Bytes()), secret) - if err != nil { - t.Fatal(err) - } - got, err := io.ReadAll(reader) - if err != nil { - t.Fatal(err) - } - if !bytes.Equal(got, plaintext) { - t.Fatal("decrypted payload mismatch") - } -} diff --git a/transport/internet/udp/dispatcher.go b/transport/internet/udp/dispatcher.go index 963ce662a..df8a8d74f 100644 --- a/transport/internet/udp/dispatcher.go +++ b/transport/internet/udp/dispatcher.go @@ -5,6 +5,7 @@ import ( goerrors "errors" "io" "sync" + "sync/atomic" "time" "github.com/xtls/xray-core/common" @@ -24,7 +25,7 @@ type connEntry struct { link *transport.Link timer *signal.ActivityTimer cancel context.CancelFunc - closed bool + closed atomic.Bool } func (c *connEntry) Close() error { @@ -33,10 +34,9 @@ func (c *connEntry) Close() error { } func (c *connEntry) terminate() { - if c.closed { + if c.closed.Swap(true) { panic("terminate called more than once") } - c.closed = true c.cancel() common.Interrupt(c.link.Reader) common.Interrupt(c.link.Writer) @@ -77,7 +77,7 @@ func (v *Dispatcher) getInboundRay(ctx context.Context, dest net.Destination) (* } if v.conn != nil { - if v.conn.closed { + if v.conn.closed.Load() { v.conn = nil } else { return v.conn, nil @@ -144,7 +144,9 @@ func handleInput(ctx context.Context, conn *connEntry, dest net.Destination, cal mb, err := input.ReadMultiBuffer() if err != nil { - if !goerrors.Is(err, io.EOF) { + if conn.closed.Load() { + errors.LogDebugInner(ctx, err, "UDP input closed locally") + } else if !goerrors.Is(err, io.EOF) { errors.LogInfoInner(ctx, err, "failed to handle UDP input") } return