世界
295 lines
10 KiB
Go
295 lines
10 KiB
Go
package hysteria2
|
|
|
|
import (
|
|
"context"
|
|
"net"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/netip"
|
|
"net/url"
|
|
"os"
|
|
"time"
|
|
|
|
"github.com/sagernet/sing-box/adapter"
|
|
"github.com/sagernet/sing-box/adapter/inbound"
|
|
"github.com/sagernet/sing-box/common/listener"
|
|
"github.com/sagernet/sing-box/common/tls"
|
|
C "github.com/sagernet/sing-box/constant"
|
|
"github.com/sagernet/sing-box/log"
|
|
"github.com/sagernet/sing-box/option"
|
|
qtls "github.com/sagernet/sing-quic"
|
|
"github.com/sagernet/sing-quic/hysteria"
|
|
"github.com/sagernet/sing-quic/hysteria2"
|
|
"github.com/sagernet/sing-quic/hysteria2/realm"
|
|
"github.com/sagernet/sing/common"
|
|
"github.com/sagernet/sing/common/auth"
|
|
E "github.com/sagernet/sing/common/exceptions"
|
|
M "github.com/sagernet/sing/common/metadata"
|
|
N "github.com/sagernet/sing/common/network"
|
|
"github.com/sagernet/sing/service"
|
|
"github.com/sagernet/sing/service/filemanager"
|
|
)
|
|
|
|
func RegisterInbound(registry *inbound.Registry) {
|
|
inbound.Register[option.Hysteria2InboundOptions](registry, C.TypeHysteria2, NewInbound)
|
|
}
|
|
|
|
type Inbound struct {
|
|
inbound.Adapter
|
|
router adapter.Router
|
|
logger log.ContextLogger
|
|
listener *listener.Listener
|
|
tlsConfig tls.ServerConfig
|
|
service *hysteria2.Service[int]
|
|
userNameList []string
|
|
}
|
|
|
|
func NewInbound(ctx context.Context, router adapter.Router, logger log.ContextLogger, tag string, options option.Hysteria2InboundOptions) (adapter.Inbound, error) {
|
|
options.UDPFragmentDefault = true
|
|
if options.TLS == nil || !options.TLS.Enabled {
|
|
return nil, C.ErrTLSRequired
|
|
}
|
|
tlsConfig, err := tls.NewServer(ctx, logger, common.PtrValueOrDefault(options.TLS))
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
var salamanderPassword string
|
|
var geckoPassword string
|
|
var geckoMinPacketSize, geckoMaxPacketSize int
|
|
if options.Obfs != nil {
|
|
if options.Obfs.Password == "" {
|
|
return nil, E.New("missing obfs password")
|
|
}
|
|
switch options.Obfs.Type {
|
|
case hysteria2.ObfsTypeSalamander:
|
|
salamanderPassword = options.Obfs.Password
|
|
case hysteria2.ObfsTypeGecko:
|
|
geckoPassword = options.Obfs.Password
|
|
geckoMinPacketSize = options.Obfs.GeckoOptions.MinPacketSize
|
|
geckoMaxPacketSize = options.Obfs.GeckoOptions.MaxPacketSize
|
|
default:
|
|
return nil, E.New("unknown obfs type: ", options.Obfs.Type)
|
|
}
|
|
}
|
|
var masqueradeHandler http.Handler
|
|
if options.Masquerade != nil && options.Masquerade.Type != "" {
|
|
switch options.Masquerade.Type {
|
|
case C.Hysterai2MasqueradeTypeFile:
|
|
masqueradeDirectory := filemanager.BasePath(ctx, os.ExpandEnv(options.Masquerade.FileOptions.Directory))
|
|
_, err = filemanager.ReadDir(ctx, masqueradeDirectory)
|
|
if err != nil && !os.IsNotExist(err) {
|
|
return nil, E.Cause(err, "read masquerade directory")
|
|
}
|
|
masqueradeHandler = http.FileServer(http.Dir(masqueradeDirectory))
|
|
case C.Hysterai2MasqueradeTypeProxy:
|
|
masqueradeURL, err := url.Parse(options.Masquerade.ProxyOptions.URL)
|
|
if err != nil {
|
|
return nil, E.Cause(err, "parse masquerade URL")
|
|
}
|
|
masqueradeHandler = &httputil.ReverseProxy{
|
|
Rewrite: func(r *httputil.ProxyRequest) {
|
|
r.SetURL(masqueradeURL)
|
|
if !options.Masquerade.ProxyOptions.RewriteHost {
|
|
r.Out.Host = r.In.Host
|
|
}
|
|
},
|
|
ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) {
|
|
w.WriteHeader(http.StatusBadGateway)
|
|
},
|
|
}
|
|
case C.Hysterai2MasqueradeTypeString:
|
|
masqueradeHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if options.Masquerade.StringOptions.StatusCode != 0 {
|
|
w.WriteHeader(options.Masquerade.StringOptions.StatusCode)
|
|
}
|
|
for key, values := range options.Masquerade.StringOptions.Headers {
|
|
for _, value := range values {
|
|
w.Header().Add(key, value)
|
|
}
|
|
}
|
|
w.Write([]byte(options.Masquerade.StringOptions.Content))
|
|
})
|
|
default:
|
|
return nil, E.New("unknown masquerade type: ", options.Masquerade.Type)
|
|
}
|
|
}
|
|
inbound := &Inbound{
|
|
Adapter: inbound.NewAdapter(C.TypeHysteria2, tag),
|
|
router: router,
|
|
logger: logger,
|
|
listener: listener.New(listener.Options{
|
|
Context: ctx,
|
|
Logger: logger,
|
|
Listen: options.ListenOptions,
|
|
}),
|
|
tlsConfig: tlsConfig,
|
|
}
|
|
var udpTimeout time.Duration
|
|
if options.UDPTimeout != 0 {
|
|
udpTimeout = time.Duration(options.UDPTimeout)
|
|
} else {
|
|
udpTimeout = C.UDPTimeout
|
|
}
|
|
var realmOptions *realm.Options
|
|
if options.Realm != nil {
|
|
if options.Realm.IPVersion != 0 && options.ListenOptions.Listen != nil {
|
|
listenAddr := netip.Addr(*options.ListenOptions.Listen).Unmap()
|
|
if options.Realm.IPVersion == 6 && listenAddr.Is4() {
|
|
return nil, E.New("realm.ip_version 6 conflicts with listen address ", listenAddr)
|
|
}
|
|
if options.Realm.IPVersion == 4 && listenAddr.Is6() && !listenAddr.IsUnspecified() {
|
|
return nil, E.New("realm.ip_version 4 conflicts with listen address ", listenAddr)
|
|
}
|
|
}
|
|
queryOptions, err := adapter.DNSQueryOptionsFrom(ctx, options.Realm.STUNDomainResolver)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
httpClientTransport, err := service.FromContext[adapter.HTTPClientManager](ctx).ResolveTransport(ctx, logger, common.PtrValueOrDefault(options.Realm.HTTPClient))
|
|
if err != nil {
|
|
return nil, E.Cause(err, "create realm http client")
|
|
}
|
|
dnsRouter := service.FromContext[adapter.DNSRouter](ctx)
|
|
realmOptions = &realm.Options{
|
|
ServerURL: options.Realm.ServerURL,
|
|
Token: options.Realm.Token,
|
|
RealmID: options.Realm.RealmID,
|
|
STUNServers: options.Realm.STUNServers,
|
|
HTTPClient: &http.Client{Transport: httpClientTransport},
|
|
Resolver: func(ctx context.Context, host string, ipv4, ipv6 bool) ([]netip.Addr, error) {
|
|
dnsOptions := queryOptions
|
|
switch {
|
|
case ipv4 && !ipv6:
|
|
dnsOptions.Strategy = C.DomainStrategyIPv4Only
|
|
case !ipv4 && ipv6:
|
|
dnsOptions.Strategy = C.DomainStrategyIPv6Only
|
|
}
|
|
return dnsRouter.Lookup(ctx, host, dnsOptions)
|
|
},
|
|
Logger: logger,
|
|
IPVersion: options.Realm.IPVersion,
|
|
}
|
|
if options.Realm.PortMapping != nil && options.Realm.PortMapping.Enabled {
|
|
realmOptions.PortMapping = &realm.PortMappingOptions{
|
|
Timeout: time.Duration(options.Realm.PortMapping.Timeout),
|
|
Lifetime: time.Duration(options.Realm.PortMapping.Lifetime),
|
|
}
|
|
}
|
|
}
|
|
hysteriaService, err := hysteria2.NewService[int](hysteria2.ServiceOptions{
|
|
Context: ctx,
|
|
Logger: logger,
|
|
BrutalDebug: options.BrutalDebug,
|
|
SendBPS: uint64(options.UpMbps * hysteria.MbpsToBps),
|
|
ReceiveBPS: uint64(options.DownMbps * hysteria.MbpsToBps),
|
|
SalamanderPassword: salamanderPassword,
|
|
GeckoPassword: geckoPassword,
|
|
GeckoMinPacketSize: geckoMinPacketSize,
|
|
GeckoMaxPacketSize: geckoMaxPacketSize,
|
|
TLSConfig: tlsConfig,
|
|
QUICOptions: qtls.QUICOptions{
|
|
IdleTimeout: options.IdleTimeout.Build(),
|
|
KeepAlivePeriod: options.KeepAlivePeriod.Build(),
|
|
StreamReceiveWindow: options.StreamReceiveWindow.Value(),
|
|
ConnectionReceiveWindow: options.ConnectionReceiveWindow.Value(),
|
|
MaxConcurrentStreams: options.MaxConcurrentStreams,
|
|
InitialPacketSize: options.InitialPacketSize,
|
|
DisablePathMTUDiscovery: options.DisablePathMTUDiscovery,
|
|
},
|
|
IgnoreClientBandwidth: options.IgnoreClientBandwidth,
|
|
UDPTimeout: udpTimeout,
|
|
Handler: inbound,
|
|
MasqueradeHandler: masqueradeHandler,
|
|
BBRProfile: options.BBRProfile,
|
|
RealmOptions: realmOptions,
|
|
})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
userList := make([]int, 0, len(options.Users))
|
|
userNameList := make([]string, 0, len(options.Users))
|
|
userPasswordList := make([]string, 0, len(options.Users))
|
|
for index, user := range options.Users {
|
|
userList = append(userList, index)
|
|
userNameList = append(userNameList, user.Name)
|
|
userPasswordList = append(userPasswordList, user.Password)
|
|
}
|
|
hysteriaService.UpdateUsers(userList, userPasswordList)
|
|
inbound.service = hysteriaService
|
|
inbound.userNameList = userNameList
|
|
return inbound, nil
|
|
}
|
|
|
|
func (h *Inbound) NewConnectionEx(ctx context.Context, conn net.Conn, source M.Socksaddr, destination M.Socksaddr, onClose N.CloseHandlerFunc) {
|
|
ctx = log.ContextWithNewID(ctx)
|
|
var metadata adapter.InboundContext
|
|
metadata.Inbound = h.Tag()
|
|
metadata.InboundType = h.Type()
|
|
//nolint:staticcheck
|
|
metadata.InboundDetour = h.listener.ListenOptions().Detour
|
|
//nolint:staticcheck
|
|
metadata.OriginDestination = h.listener.UDPAddr()
|
|
metadata.Source = source
|
|
metadata.Destination = destination
|
|
h.logger.InfoContext(ctx, "inbound connection from ", metadata.Source)
|
|
userID, _ := auth.UserFromContext[int](ctx)
|
|
if userName := h.userNameList[userID]; userName != "" {
|
|
metadata.User = userName
|
|
h.logger.InfoContext(ctx, "[", userName, "] inbound connection to ", metadata.Destination)
|
|
} else {
|
|
h.logger.InfoContext(ctx, "inbound connection to ", metadata.Destination)
|
|
}
|
|
h.router.RouteConnectionEx(ctx, conn, metadata, onClose)
|
|
}
|
|
|
|
func (h *Inbound) NewPacketConnectionEx(ctx context.Context, conn N.PacketConn, source M.Socksaddr, destination M.Socksaddr, onClose N.CloseHandlerFunc) {
|
|
ctx = log.ContextWithNewID(ctx)
|
|
var metadata adapter.InboundContext
|
|
metadata.Inbound = h.Tag()
|
|
metadata.InboundType = h.Type()
|
|
//nolint:staticcheck
|
|
metadata.InboundDetour = h.listener.ListenOptions().Detour
|
|
//nolint:staticcheck
|
|
metadata.OriginDestination = h.listener.UDPAddr()
|
|
metadata.Source = source
|
|
metadata.Destination = destination
|
|
h.logger.InfoContext(ctx, "inbound packet connection from ", metadata.Source)
|
|
userID, _ := auth.UserFromContext[int](ctx)
|
|
if userName := h.userNameList[userID]; userName != "" {
|
|
metadata.User = userName
|
|
h.logger.InfoContext(ctx, "[", userName, "] inbound packet connection to ", metadata.Destination)
|
|
} else {
|
|
h.logger.InfoContext(ctx, "inbound packet connection to ", metadata.Destination)
|
|
}
|
|
h.router.RoutePacketConnectionEx(ctx, conn, metadata, onClose)
|
|
}
|
|
|
|
func (h *Inbound) Start(stage adapter.StartStage) error {
|
|
if stage != adapter.StartStateStart {
|
|
return nil
|
|
}
|
|
if h.tlsConfig != nil {
|
|
err := h.tlsConfig.Start()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
packetConn, err := h.listener.ListenUDP()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return h.service.Start(packetConn)
|
|
}
|
|
|
|
func (h *Inbound) InterfaceUpdated() {
|
|
h.service.Reset()
|
|
}
|
|
|
|
func (h *Inbound) Close() error {
|
|
return common.Close(
|
|
h.listener,
|
|
h.tlsConfig,
|
|
common.PtrOrNil(h.service),
|
|
)
|
|
}
|