Shadowsocks inbound fails to initialize timeFunc properly due to NTP server startup order

[domaingts]

Operating system

Linux

System version

Debian 12.8

Installation type

Original sing-box Command Line

If you are using a graphical client, please provide the version of the client.

No response

Version

sing-box version 1.11.0-beta.9

Environment: go1.23.4 linux/amd64
Tags: with_gvisor,with_quic,with_dhcp,with_wireguard,with_ech,with_utls,with_reality_server,with_acme,with_clash_api
Revision: 4d9f2a4801dbd6c29049005eb3dc196b113678ad
CGO: disabled

Description

The timeFunc for the Shadowsocks inbound is supposed to retrieve its value from the NTP server when it is created.

sing-box/protocol/shadowsocks/inbound.go

Line 80 in d2f5109

inbound.service, err = shadowaead_2022.NewServiceWithPassword(options.Method, options.Password, int64(udpTimeout.Seconds()), adapter.NewUpstreamHandler(adapter.InboundContext{}, inbound.newConnection, inbound.newPacketConnection, inbound), ntp.TimeFuncFromContext(ctx))

However, the timeFunc is always nil because the inbound creation process occurs before the NTP server is started.

sing-box/box.go

Lines 170 to 273 in d2f5109

	for i, inboundOptions := range options.Inbounds {
	var tag string
	if inboundOptions.Tag != "" {
	tag = inboundOptions.Tag
	} else {
	tag = F.ToString(i)
	}
	err = inboundManager.Create(ctx,
	router,
	logFactory.NewLogger(F.ToString("inbound/", inboundOptions.Type, "[", tag, "]")),
	tag,
	inboundOptions.Type,
	inboundOptions.Options,
	)
	if err != nil {
	return nil, E.Cause(err, "initialize inbound[", i, "]")
	}
	}
	for i, outboundOptions := range options.Outbounds {
	var tag string
	if outboundOptions.Tag != "" {
	tag = outboundOptions.Tag
	} else {
	tag = F.ToString(i)
	}
	outboundCtx := ctx
	if tag != "" {
	// TODO: remove this
	outboundCtx = adapter.WithContext(outboundCtx, &adapter.InboundContext{
	Outbound: tag,
	})
	}
	err = outboundManager.Create(
	outboundCtx,
	router,
	logFactory.NewLogger(F.ToString("outbound/", outboundOptions.Type, "[", tag, "]")),
	tag,
	outboundOptions.Type,
	outboundOptions.Options,
	)
	if err != nil {
	return nil, E.Cause(err, "initialize outbound[", i, "]")
	}
	}
	outboundManager.Initialize(common.Must1(
	direct.NewOutbound(
	ctx,
	router,
	logFactory.NewLogger("outbound/direct"),
	"direct",
	option.DirectOutboundOptions{},
	),
	))
	if platformInterface != nil {
	err = platformInterface.Initialize(networkManager)
	if err != nil {
	return nil, E.Cause(err, "initialize platform interface")
	}
	}
	var services []adapter.LifecycleService
	if needCacheFile {
	cacheFile := cachefile.New(ctx, common.PtrValueOrDefault(experimentalOptions.CacheFile))
	service.MustRegister[adapter.CacheFile](ctx, cacheFile)
	services = append(services, cacheFile)
	}
	if needClashAPI {
	clashAPIOptions := common.PtrValueOrDefault(experimentalOptions.ClashAPI)
	clashAPIOptions.ModeList = experimental.CalculateClashModeList(options.Options)
	clashServer, err := experimental.NewClashServer(ctx, logFactory.(log.ObservableFactory), clashAPIOptions)
	if err != nil {
	return nil, E.Cause(err, "create clash-server")
	}
	router.SetTracker(clashServer)
	service.MustRegister[adapter.ClashServer](ctx, clashServer)
	services = append(services, clashServer)
	}
	if needV2RayAPI {
	v2rayServer, err := experimental.NewV2RayServer(logFactory.NewLogger("v2ray-api"), common.PtrValueOrDefault(experimentalOptions.V2RayAPI))
	if err != nil {
	return nil, E.Cause(err, "create v2ray-server")
	}
	if v2rayServer.StatsService() != nil {
	router.SetTracker(v2rayServer.StatsService())
	services = append(services, v2rayServer)
	service.MustRegister[adapter.V2RayServer](ctx, v2rayServer)
	}
	}
	ntpOptions := common.PtrValueOrDefault(options.NTP)
	if ntpOptions.Enabled {
	ntpDialer, err := dialer.New(ctx, ntpOptions.DialerOptions)
	if err != nil {
	return nil, E.Cause(err, "create NTP service")
	}
	timeService := ntp.NewService(ntp.Options{
	Context: ctx,
	Dialer: ntpDialer,
	Logger: logFactory.NewLogger("ntp"),
	Server: ntpOptions.ServerOptions.Build(),
	Interval: time.Duration(ntpOptions.Interval),
	WriteToSystem: ntpOptions.WriteToSystem,
	})
	service.MustRegister[ntp.TimeService](ctx, timeService)
	services = append(services, adapter.NewLifecycleService(timeService, "ntp service"))
	}

Reproduction

{
  "ntp": {
    "enabled": true,
    "server": "time.apple.com",
    "server_port": 123,
    "interval": "30m"
  },
  "inbounds": [
    {
      "type": "shadowsocks",
      "listen": "::",
      "listen_port": 8080,
      "network": "tcp",
      "method": "2022-blake3-aes-128-gcm",
      "password": "8JCsPssfgS8tiRwiMlhARg=="
    }
  ]
}

Logs

No response

Supporter

• I am a sponsor

Integrity requirements

• I confirm that I have read the documentation, understand the meaning of all the configuration items I wrote, and did not pile up seemingly useful options or default values.
• I confirm that I have provided the server and client configuration files and process that can be reproduced locally, instead of a complicated client configuration file that has been stripped of sensitive data.
• I confirm that I have provided the simplest configuration that can be used to reproduce the error I reported, instead of depending on remote servers, TUN, graphical interface clients, or other closed-source software.
• I confirm that I have provided the complete configuration files and logs, rather than just providing parts I think are useful out of confidence in my own intelligence.