diff --git a/cmd/headscale/cli/check.go b/cmd/headscale/cli/check.go index 233a1ad6d..826662f7e 100644 --- a/cmd/headscale/cli/check.go +++ b/cmd/headscale/cli/check.go @@ -189,7 +189,7 @@ func loadCheckedConfig(cmd *cobra.Command) (*types.Config, string, error) { return nil, src, err } - cfg, err := types.CheckServerConfig() + cfg, err := types.LoadServerConfig() return cfg, src, err } diff --git a/cmd/headscale/cli/oauth_client.go b/cmd/headscale/cli/oauth_client.go index 3ccb752ab..7eb58441b 100644 --- a/cmd/headscale/cli/oauth_client.go +++ b/cmd/headscale/cli/oauth_client.go @@ -201,10 +201,11 @@ func newV2Client() (context.Context, *clientv2.ClientWithResponses, context.Canc return ctx, client, cancel, nil } - if cfg.CLI.APIKey == "" { + apiKey, err := cliAPIKey(cfg.CLI) + if err != nil { cancel() - return nil, nil, nil, errAPIKeyNotSet + return nil, nil, nil, err } transport := &http.Transport{} @@ -213,8 +214,6 @@ func newV2Client() (context.Context, *clientv2.ClientWithResponses, context.Canc transport.TLSClientConfig = &tls.Config{InsecureSkipVerify: true} } - apiKey := cfg.CLI.APIKey - client, err := clientv2.NewClientWithResponses( clientBaseURL(cfg.CLI.Address), clientv2.WithHTTPClient(&http.Client{Transport: transport}), diff --git a/cmd/headscale/cli/root.go b/cmd/headscale/cli/root.go index 97f6aa314..144eb3c05 100644 --- a/cmd/headscale/cli/root.go +++ b/cmd/headscale/cli/root.go @@ -99,7 +99,7 @@ func initConfig() { zerolog.SetGlobalLevel(zerolog.Disabled) } - if types.LogFormat() == types.JSONLogFormat { + if types.LogFormatSetting() == types.JSONLogFormat { log.Logger = log.Output(os.Stdout) } diff --git a/cmd/headscale/cli/utils.go b/cmd/headscale/cli/utils.go index 9a5c311c2..f38768353 100644 --- a/cmd/headscale/cli/utils.go +++ b/cmd/headscale/cli/utils.go @@ -173,11 +173,11 @@ func newHeadscaleCLIWithConfig() (context.Context, *clientv1.ClientWithResponses } // Remote connections require an API key for authentication. - apiKey := cfg.CLI.APIKey - if apiKey == "" { + apiKey, err := cliAPIKey(cfg.CLI) + if err != nil { cancel() - return nil, nil, nil, errAPIKeyNotSet + return nil, nil, nil, err } client, err := newRemoteClient(address, apiKey, cfg.CLI.Insecure) @@ -192,6 +192,21 @@ func newHeadscaleCLIWithConfig() (context.Context, *clientv1.ClientWithResponses return ctx, client, cancel, nil } +// cliAPIKey reads the key a remote CLI sends; over the unix socket the CLI +// needs none, so it must not call this. +func cliAPIKey(cfg types.CLIConfig) (string, error) { + key, err := types.ResolveSecret("cli.api_key", string(cfg.APIKey)) + if err != nil { + return "", err + } + + if key == "" { + return "", errAPIKeyNotSet + } + + return key, nil +} + // newSocketClient builds an API client that dials the local unix socket. The // base-URL host is irrelevant; the custom dialer routes every request to the // socket. diff --git a/cmd/headscale/cli/utils_test.go b/cmd/headscale/cli/utils_test.go index 845d676c5..87bc46aaa 100644 --- a/cmd/headscale/cli/utils_test.go +++ b/cmd/headscale/cli/utils_test.go @@ -1,6 +1,14 @@ package cli -import "testing" +import ( + "os" + "path/filepath" + "testing" + + "github.com/juanfont/headscale/hscontrol/types" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) func TestClientBaseURL(t *testing.T) { tests := []struct { @@ -33,3 +41,63 @@ func TestClientBaseURL(t *testing.T) { }) } } + +// TestCLIAPIKey pins that only a remote CLI reads cli.api_key; over the unix +// socket the key is never read. +func TestCLIAPIKey(t *testing.T) { + dir := t.TempDir() + keyFile := filepath.Join(dir, "key") + require.NoError(t, os.WriteFile(keyFile, []byte("from-file\n"), 0o600)) + + missing := "file:" + filepath.Join(dir, "missing") + + tests := []struct { + name string + address string + apiKey string + want string // the key a remote CLI sends + wantErr string + }{ + {name: "remote literal", address: "headscale.example.com:443", apiKey: "literal", want: "literal"}, + {name: "remote reads the file", address: "headscale.example.com:443", apiKey: "file:" + keyFile, want: "from-file"}, + {name: "remote file missing", address: "headscale.example.com:443", apiKey: missing, wantErr: "cli.api_key: "}, + {name: "remote without a key", address: "headscale.example.com:443", wantErr: errAPIKeyNotSet.Error()}, + {name: "socket never reads", apiKey: missing}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + cfgDir := t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(cfgDir, "config.yaml"), + []byte("unix_socket: "+filepath.Join(cfgDir, "headscale.sock")+"\n"), 0o600)) + t.Setenv("HEADSCALE_CLI_ADDRESS", tt.address) + t.Setenv("HEADSCALE_CLI_API_KEY", tt.apiKey) + require.NoError(t, types.LoadConfig(cfgDir, false)) + + if tt.address != "" && tt.wantErr == "" { + cfg, err := types.LoadCLIConfig() + require.NoError(t, err) + + got, err := cliAPIKey(cfg.CLI) + require.NoError(t, err) + assert.Equal(t, tt.want, got) + } + + _, _, cancel, err := newHeadscaleCLIWithConfig() + _, _, cancelV2, errV2 := newV2Client() + + for _, err := range []error{err, errV2} { + if tt.wantErr != "" { + require.ErrorContains(t, err, tt.wantErr) + } else { + require.NoError(t, err) + } + } + + if err == nil { + cancel() + cancelV2() + } + }) + } +} diff --git a/cmd/headscale/headscale_test.go b/cmd/headscale/headscale_test.go index 9341211c0..6f908e5f6 100644 --- a/cmd/headscale/headscale_test.go +++ b/cmd/headscale/headscale_test.go @@ -1,7 +1,6 @@ package main import ( - "io/fs" "os" "path/filepath" "testing" @@ -62,13 +61,13 @@ func assertExampleConfig(t *testing.T) { require.NoError(t, err) assert.Equal(t, "http://127.0.0.1:8080", cfg.ServerURL) - assert.Equal(t, "127.0.0.1:8080", cfg.Addr) - assert.Equal(t, "127.0.0.1:9090", cfg.MetricsAddr) + assert.Equal(t, types.ListenAddr("127.0.0.1:8080"), cfg.Addr) + assert.Equal(t, types.ListenAddr("127.0.0.1:9090"), cfg.MetricsAddr) assert.True(t, cfg.Database.IsSQLite(), cfg.Database.Type) assert.Equal(t, "/var/lib/headscale/db.sqlite", cfg.SQLitePath()) assert.Empty(t, cfg.TLS.ACME.Hostname) - assert.Equal(t, ":http", cfg.TLS.ACME.HTTPListen) - assert.Equal(t, "HTTP-01", cfg.TLS.ACME.ChallengeType) - assert.Equal(t, fs.FileMode(0o770), cfg.UnixSocketPermission) + assert.Equal(t, types.ListenAddr(":http"), cfg.TLS.ACME.HTTPListen) + assert.Equal(t, types.HTTP01ChallengeType, cfg.TLS.ACME.ChallengeType) + assert.Equal(t, types.FileMode(0o770), cfg.UnixSocketPermission) assert.False(t, cfg.LogTail.Enabled) } diff --git a/hscontrol/api/v2/devices.go b/hscontrol/api/v2/devices.go index 98d042e0f..1ab6b5003 100644 --- a/hscontrol/api/v2/devices.go +++ b/hscontrol/api/v2/devices.go @@ -212,7 +212,7 @@ func registerDevices(api huma.API, b Backend) { return nil, err } - return &deviceOutput{Body: deviceFromView(node, in.Fields == "all", b.Cfg.BaseDomain)}, nil + return &deviceOutput{Body: deviceFromView(node, in.Fields == "all", b.Cfg.DNSConfig.BaseDomain)}, nil }) huma.Register(api, requireScope(huma.Operation{ @@ -253,7 +253,7 @@ func registerDevices(api huma.API, b Backend) { out.Body.Devices = make([]Device, 0, nodes.Len()) for _, node := range nodes.All() { - out.Body.Devices = append(out.Body.Devices, deviceFromView(node, allFields, b.Cfg.BaseDomain)) + out.Body.Devices = append(out.Body.Devices, deviceFromView(node, allFields, b.Cfg.DNSConfig.BaseDomain)) } // The NodeStore holds no order, and Tailscale lists devices by name. diff --git a/hscontrol/apiv1_policy_test.go b/hscontrol/apiv1_policy_test.go index b48047233..1d184d2f8 100644 --- a/hscontrol/apiv1_policy_test.go +++ b/hscontrol/apiv1_policy_test.go @@ -202,8 +202,8 @@ func createFilePolicyApp(t *testing.T) *Headscale { tmpDir := t.TempDir() cfg := types.Config{ - ServerURL: "http://localhost:8080", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", + ServerURL: "http://localhost:8080", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, Database: types.DatabaseConfig{ Type: "sqlite3", Sqlite: types.SqliteConfig{ diff --git a/hscontrol/apiv2_compat_test.go b/hscontrol/apiv2_compat_test.go index 110418bfb..c1f7d8f38 100644 --- a/hscontrol/apiv2_compat_test.go +++ b/hscontrol/apiv2_compat_test.go @@ -297,11 +297,9 @@ func newAddressedTestApp(t *testing.T) *Headscale { prefixV6 := netip.MustParsePrefix("fd7a:115c:a1e0::/48") cfg := types.Config{ - ServerURL: "http://localhost:8080", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", - PrefixV4: &prefixV4, - PrefixV6: &prefixV6, - IPAllocation: types.IPAllocationStrategySequential, + ServerURL: "http://localhost:8080", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, + Prefixes: types.PrefixesConfig{V4: &prefixV4, V6: &prefixV6, Allocation: types.IPAllocationStrategySequential}, Database: types.DatabaseConfig{ Type: "sqlite3", Sqlite: types.SqliteConfig{Path: tmpDir + "/headscale_test.db"}, diff --git a/hscontrol/apiv2_devices_test.go b/hscontrol/apiv2_devices_test.go index 56e635ac9..30234c943 100644 --- a/hscontrol/apiv2_devices_test.go +++ b/hscontrol/apiv2_devices_test.go @@ -187,7 +187,7 @@ func TestAPIv2Device_EmptyRouteLists(t *testing.T) { // MagicDNS FQDN, in a read and in the list. func TestAPIv2Device_NameIsFQDN(t *testing.T) { e := newDeviceTestEnv(t) - e.app.cfg.BaseDomain = "tailnet.example.com" + e.app.cfg.DNSConfig.BaseDomain = "tailnet.example.com" assert.Equal(t, "contract-dut.tailnet.example.com", getDevice(t, e.api, e.deviceID).Name) diff --git a/hscontrol/app.go b/hscontrol/app.go index e71333bd6..f729cf172 100644 --- a/hscontrol/app.go +++ b/hscontrol/app.go @@ -11,6 +11,7 @@ import ( "crypto/x509/pkix" "errors" "fmt" + "io/fs" "math/big" "net" "net/http" @@ -128,14 +129,25 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { runtime.SetBlockProfileRate(1) } - noisePrivateKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.NoisePrivateKeyPath)) + // Unreadable is a config error, not an unavailable provider: it stops + // startup, before anything is written, whatever + // only_start_if_oidc_is_available says. + var oidcClientSecret string + if cfg.OIDC.Issuer != "" { + oidcClientSecret, err = types.ResolveSecret("oidc.client_secret", string(cfg.OIDC.ClientSecret)) + if err != nil { + return nil, err + } + } + + noisePrivateKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.Noise.PrivateKeyPath)) if err != nil { return nil, fmt.Errorf("reading or creating Noise protocol private key: %w", err) } - provider := cfg.DNSChallenge.Provider - if provider == nil && cfg.DNSChallenge.ProviderName() != "" { - provider, err = cfg.DNSChallenge.NewProvider(types.ResolveSecret) + provider := cfg.DNSConfig.Challenge.Provider + if provider == nil && cfg.DNSConfig.Challenge.ProviderName() != "" { + provider, err = cfg.DNSConfig.Challenge.NewProvider(types.ResolveSecret) if err != nil { return nil, fmt.Errorf("building dns.challenge.provider: %w", err) } @@ -147,7 +159,7 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { err = iso.CheckIsolation() if err != nil { // A Go-only provider may have no name. - name := cmp.Or(cfg.DNSChallenge.ProviderName(), fmt.Sprintf("%T", provider)) + name := cmp.Or(cfg.DNSConfig.Challenge.ProviderName(), fmt.Sprintf("%T", provider)) return nil, fmt.Errorf("%w for %s: %w", dns.ErrProviderConfig, name, err) } @@ -171,8 +183,8 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { app.challenges = dns.NewChallenges( provider, cfg.DNSConfig.CertificateZone(), - cfg.DNSChallenge.ResolverAddrs(), - cfg.DNSChallenge.PropagationTimeout, + cfg.DNSConfig.Challenge.ResolverAddrs(), + cfg.DNSConfig.Challenge.PropagationTimeout, ) } @@ -240,6 +252,7 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { &app, cfg.ServerURL, &cfg.OIDC, + oidcClientSecret, ) if err != nil { if cfg.OIDC.OnlyStartIfOIDCIsAvailable { @@ -254,8 +267,8 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { app.authProvider = authProvider - if cfg.DERP.ServerEnabled { - derpServerKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath)) + if cfg.DERP.Server.Enabled { + derpServerKey, err := readOrCreatePrivateKey(cfg.AbsPath(cfg.DERP.Server.PrivateKeyPath)) if err != nil { return nil, fmt.Errorf("reading or creating DERP server private key: %w", err) } @@ -264,7 +277,7 @@ func NewHeadscale(cfg *types.Config) (*Headscale, error) { return nil, config.ErrSameKey } - if cfg.DERP.ServerVerifyClients { + if cfg.DERP.Server.VerifyClients { t := http.DefaultTransport.(*http.Transport) //nolint:forcetypeassert t.RegisterProtocol( derpServer.DerpVerifyScheme, @@ -395,12 +408,12 @@ func (h *Headscale) scheduledTasks(ctx context.Context) { log.Info().Msg("fetching DERPMap updates") derpMap, err := backoff.Retry(ctx, func() (*tailcfg.DERPMap, error) { //nolint:contextcheck - derpMap, err := derp.GetDERPMap(h.cfg.DERP, h.cfg.BaseDomain) + derpMap, err := derp.GetDERPMap(h.cfg.DERP, h.cfg.DNSConfig.BaseDomain) if err != nil { return nil, err } - if h.cfg.DERP.ServerEnabled && h.cfg.DERP.AutomaticallyAddEmbeddedDerpRegion { + if h.cfg.DERP.Server.Enabled && h.cfg.DERP.Server.AutomaticallyAddEmbeddedDerpRegion { region, err := h.DERPServer.GenerateRegion() if err != nil { return nil, fmt.Errorf("generating embedded DERP region: %w", err) @@ -517,7 +530,7 @@ func (h *Headscale) createRouter(apiV1Mux, apiV2Mux http.Handler) *chi.Mux { r.Post("/verify", h.VerifyHandler) - if h.cfg.DERP.ServerEnabled { + if h.cfg.DERP.Server.Enabled { r.HandleFunc("/derp", h.DERPServer.DERPHandler) r.HandleFunc("/derp/probe", derpServer.DERPProbeHandler) r.HandleFunc("/derp/latency-check", derpServer.DERPProbeHandler) @@ -578,9 +591,9 @@ func (h *Headscale) Serve() error { h.mapBatcher.Start() defer h.mapBatcher.Close() - if h.cfg.DERP.ServerEnabled { + if h.cfg.DERP.Server.Enabled { // When embedded DERP is enabled we always need a STUN server - if h.cfg.DERP.STUNAddr == "" { + if h.cfg.DERP.Server.STUNAddr == "" { return errSTUNAddressNotSet } @@ -589,12 +602,12 @@ func (h *Headscale) Serve() error { // Start on the sources that loaded; only a map with no region at all, // after the embedded region and the policy's derpMap, is fatal. - derpMap, derpErr := derp.GetDERPMap(h.cfg.DERP, h.cfg.BaseDomain) + derpMap, derpErr := derp.GetDERPMap(h.cfg.DERP, h.cfg.DNSConfig.BaseDomain) if derpErr != nil { log.Warn().Err(derpErr).Msg("skipping DERP map sources that failed to load") } - if h.cfg.DERP.ServerEnabled && h.cfg.DERP.AutomaticallyAddEmbeddedDerpRegion { + if h.cfg.DERP.Server.Enabled && h.cfg.DERP.Server.AutomaticallyAddEmbeddedDerpRegion { region, err := h.DERPServer.GenerateRegion() if err != nil { return fmt.Errorf("generating embedded DERP region: %w", err) @@ -673,7 +686,7 @@ func (h *Headscale) Serve() error { } // Change socket permissions - if err := os.Chmod(h.cfg.UnixSocket, h.cfg.UnixSocketPermission); err != nil { //nolint:noinlineerr + if err := os.Chmod(h.cfg.UnixSocket, fs.FileMode(h.cfg.UnixSocketPermission)); err != nil { //nolint:noinlineerr return fmt.Errorf("changing socket permission: %w", err) } @@ -733,7 +746,7 @@ func (h *Headscale) Serve() error { router := h.createRouter(humaMux, humaV2Mux) httpServer := &http.Server{ - Addr: h.cfg.Addr, + Addr: string(h.cfg.Addr), Handler: router, ReadTimeout: types.HTTPTimeout, @@ -746,16 +759,16 @@ func (h *Headscale) Serve() error { if tlsConfig != nil { httpServer.TLSConfig = tlsConfig - httpListener, err = tls.Listen("tcp", h.cfg.Addr, tlsConfig) + httpListener, err = tls.Listen("tcp", string(h.cfg.Addr), tlsConfig) } else { - httpListener, err = new(net.ListenConfig).Listen(context.Background(), "tcp", h.cfg.Addr) + httpListener, err = new(net.ListenConfig).Listen(context.Background(), "tcp", string(h.cfg.Addr)) } if err != nil { return &types.ListenerBindError{ Listener: "main HTTP", YAMLKey: "listen_addr", - Addr: h.cfg.Addr, + Addr: string(h.cfg.Addr), Err: err, } } @@ -826,12 +839,12 @@ func (h *Headscale) Serve() error { var debugHTTPListener net.Listener if h.cfg.MetricsAddr != "" { - debugHTTPListener, err = (&net.ListenConfig{}).Listen(ctx, "tcp", h.cfg.MetricsAddr) + debugHTTPListener, err = (&net.ListenConfig{}).Listen(ctx, "tcp", string(h.cfg.MetricsAddr)) if err != nil { return &types.ListenerBindError{ Listener: "metrics", YAMLKey: "metrics_listen_addr", - Addr: h.cfg.MetricsAddr, + Addr: string(h.cfg.MetricsAddr), Err: err, } } @@ -852,7 +865,7 @@ func (h *Headscale) Serve() error { if !h.cfg.Database.IsSQLite() { //nolint:gocritic // exitAfterDefer: Fatal exits during initialization before servers start log.Fatal(). - Str("type", h.cfg.Database.Type). + Str("type", string(h.cfg.Database.Type)). Msgf("tailsql only support %q", types.DatabaseSqlite) } @@ -1069,7 +1082,7 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { logger := zlog.Zap(log.Logger).Named("acme") issuer := certmagic.ACMEIssuer{ - CA: acmeCfg.URL, + CA: string(acmeCfg.URL), Email: acmeCfg.Email, Agreed: true, TrustedRoots: acmeTrustedRoots, @@ -1080,7 +1093,7 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { switch acmeCfg.ChallengeType { case types.DNS01ChallengeType: - resolvers := h.cfg.DNSChallenge.ResolverAddrs() + resolvers := h.cfg.DNSConfig.Challenge.ResolverAddrs() issuer.DNS01Solver = dns01Solver{ DNS01Solver: &certmagic.DNS01Solver{ DNSProvider: h.cfg.DNSProvider(), @@ -1088,15 +1101,15 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { Resolvers: resolvers, Logger: logger, }, - wait: dns.AwaitTXT(resolvers, h.cfg.DNSChallenge.PropagationTimeout), + wait: dns.AwaitTXT(resolvers, h.cfg.DNSConfig.Challenge.PropagationTimeout), } case types.TLSALPN01ChallengeType: // Validated on the main listener, which must be reachable on port 443. issuer.DisableHTTPChallenge = true - issuer.ListenHost, _, _ = net.SplitHostPort(h.cfg.Addr) + issuer.ListenHost, _, _ = net.SplitHostPort(string(h.cfg.Addr)) - issuer.AltTLSALPNPort, err = types.PortFromAddr(h.cfg.Addr) + issuer.AltTLSALPNPort, err = types.PortFromAddr(string(h.cfg.Addr)) if err != nil { return nil, fmt.Errorf("parsing listen_addr: %w", err) } @@ -1104,14 +1117,14 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { case types.HTTP01ChallengeType: // TLS-ALPN-01 stays on, as with autocert: setups that only open // port 443 have always been validated that way. - issuer.AltTLSALPNPort, err = types.PortFromAddr(h.cfg.Addr) + issuer.AltTLSALPNPort, err = types.PortFromAddr(string(h.cfg.Addr)) if err != nil { return nil, fmt.Errorf("parsing listen_addr: %w", err) } - issuer.ListenHost, _, _ = net.SplitHostPort(acmeCfg.HTTPListen) + issuer.ListenHost, _, _ = net.SplitHostPort(string(acmeCfg.HTTPListen)) - issuer.AltHTTPPort, err = types.PortFromAddr(acmeCfg.HTTPListen) + issuer.AltHTTPPort, err = types.PortFromAddr(string(acmeCfg.HTTPListen)) if err != nil { return nil, fmt.Errorf("parsing tls.acme.http_listen: %w", err) } @@ -1148,19 +1161,19 @@ func (h *Headscale) acmeTLSSettings(ctx context.Context) (*tlsBundle, error) { if acmeCfg.ChallengeType == types.HTTP01ChallengeType { bundle.ACMEServer = &http.Server{ - Addr: acmeCfg.HTTPListen, + Addr: string(acmeCfg.HTTPListen), Handler: acmeIssuer.HTTPChallengeHandler(http.HandlerFunc(h.redirect)), ReadTimeout: types.HTTPTimeout, } - bundle.ACMEListener, err = (&net.ListenConfig{}).Listen(ctx, "tcp", acmeCfg.HTTPListen) + bundle.ACMEListener, err = (&net.ListenConfig{}).Listen(ctx, "tcp", string(acmeCfg.HTTPListen)) if err != nil { cache.Stop() return nil, &types.ListenerBindError{ Listener: "ACME HTTP-01 challenge", YAMLKey: "tls.acme.http_listen", - Addr: acmeCfg.HTTPListen, + Addr: string(acmeCfg.HTTPListen), Err: err, } } diff --git a/hscontrol/app_test.go b/hscontrol/app_test.go index b0d180cbd..e0f563c15 100644 --- a/hscontrol/app_test.go +++ b/hscontrol/app_test.go @@ -35,7 +35,7 @@ func TestDebugHostGuard(t *testing.T) { app := createTestApp(t) app.cfg.ServerURL = "https://Control.Example.COM:443/headscale" app.cfg.MetricsAddr = "Debug.Internal:9090" - app.cfg.BaseDomain = "tailnet.invalid" + app.cfg.DNSConfig.BaseDomain = "tailnet.invalid" handler := app.debugHTTPServer().Handler for _, tt := range []struct { @@ -146,8 +146,8 @@ func TestNewHeadscaleDNSProvider(t *testing.T) { t.Run(tt.name, func(t *testing.T) { tmpDir := t.TempDir() cfg := types.Config{ - ServerURL: "http://localhost:8080", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", + ServerURL: "http://localhost:8080", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, Database: types.DatabaseConfig{ Type: "sqlite3", Sqlite: types.SqliteConfig{Path: tmpDir + "/headscale_test.db"}, @@ -157,8 +157,8 @@ func TestNewHeadscaleDNSProvider(t *testing.T) { MagicDNS: true, BaseDomain: "ts.example.com", Certificates: types.CertificatesConfig{Enabled: tt.certificates}, + Challenge: tt.challenge, }, - DNSChallenge: tt.challenge, } app, err := NewHeadscale(&cfg) @@ -177,3 +177,80 @@ func TestNewHeadscaleDNSProvider(t *testing.T) { }) } } + +// TestNewHeadscaleSecrets pins that startup reads a file: secret only where +// it is used, and that one it cannot read stops startup, even when OIDC may +// be unavailable. +func TestNewHeadscaleSecrets(t *testing.T) { + missing := types.Secret("file:" + filepath.Join(t.TempDir(), "missing")) + + tests := []struct { + name string + set func(*types.Config) + wantErr string + noFiles bool // fails before startup writes anything + }{ + { + name: "oidc client secret file missing", + set: func(c *types.Config) { + // Unreachable, so discovery would fail and fall back, were the + // secret read only there. + c.OIDC = types.OIDCConfig{Issuer: "http://127.0.0.1:1", ClientID: "headscale", ClientSecret: missing} + }, + wantErr: "oidc.client_secret: ", + noFiles: true, + }, + { + name: "postgres pass file missing", + set: func(c *types.Config) { + c.Database = types.DatabaseConfig{ + Type: types.DatabasePostgres, + Postgres: types.PostgresConfig{Host: "127.0.0.1", Port: 1, Name: "headscale", Pass: missing}, + } + }, + wantErr: "database.postgres.pass: ", + }, + { + name: "inactive consumers read nothing", + set: func(c *types.Config) { + c.Database.Postgres.Pass = missing + c.OIDC.ClientSecret = missing + }, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + tmpDir := t.TempDir() + cfg := types.Config{ + ServerURL: "http://localhost:8080", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, + Database: types.DatabaseConfig{ + Type: "sqlite3", + Sqlite: types.SqliteConfig{Path: tmpDir + "/headscale_test.db"}, + }, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + } + tt.set(&cfg) + + app, err := NewHeadscale(&cfg) + if tt.wantErr != "" { + require.ErrorContains(t, err, tt.wantErr) + require.ErrorContains(t, err, "readable by the user running headscale") + // Read before connecting: a connection error would not name the key. + assert.NotContains(t, err.Error(), "connect") + + if tt.noFiles { + entries, err := os.ReadDir(tmpDir) + require.NoError(t, err) + assert.Empty(t, entries, "no noise key or database before the secret is read") + } + + return + } + + require.NoError(t, err) + t.Cleanup(func() { _ = app.state.Close() }) + }) + } +} diff --git a/hscontrol/app_tls_test.go b/hscontrol/app_tls_test.go index 870d1bd4e..1a0298096 100644 --- a/hscontrol/app_tls_test.go +++ b/hscontrol/app_tls_test.go @@ -200,29 +200,29 @@ func TestDNS01SolverWait(t *testing.T) { // TestACMETLSSettings obtains headscale's own certificate from Pebble with // each challenge type, serving it the way [Headscale.Serve] does. func TestACMETLSSettings(t *testing.T) { - for _, challenge := range []string{ + for _, challenge := range []types.ACMEChallenge{ types.DNS01ChallengeType, types.HTTP01ChallengeType, types.TLSALPN01ChallengeType, } { - t.Run(challenge, func(t *testing.T) { + t.Run(string(challenge), func(t *testing.T) { httpPort, tlsPort := freePort(t), freePort(t) acme := startTestACME(t, httpPort, tlsPort) h := &Headscale{cfg: &types.Config{ ServerURL: "https://" + acmeTestHost, - Addr: net.JoinHostPort("127.0.0.1", strconv.Itoa(tlsPort)), + Addr: types.ListenAddr(net.JoinHostPort("127.0.0.1", strconv.Itoa(tlsPort))), TLS: types.TLSConfig{ACME: types.ACMEConfig{ Hostname: acmeTestHost, ChallengeType: challenge, - HTTPListen: net.JoinHostPort("127.0.0.1", strconv.Itoa(httpPort)), - URL: acme.directory, + HTTPListen: types.ListenAddr(net.JoinHostPort("127.0.0.1", strconv.Itoa(httpPort))), + URL: types.HTTPURL(acme.directory), CacheDir: t.TempDir(), }}, - DNSChallenge: types.DNSChallengeConfig{ + DNSConfig: types.DNSConfig{Challenge: types.DNSChallengeConfig{ Provider: acme.provider, Resolvers: []string{acme.resolver}, - }, + }}, }} bundle, err := h.getTLSSettings(t.Context()) @@ -230,7 +230,7 @@ func TestACMETLSSettings(t *testing.T) { t.Cleanup(bundle.Stop) assert.Nil(t, bundle.Reload, "certmagic renews the certificate itself") - ln, err := tls.Listen("tcp", h.cfg.Addr, bundle.Config) + ln, err := tls.Listen("tcp", string(h.cfg.Addr), bundle.Config) require.NoError(t, err) t.Cleanup(func() { _ = ln.Close() }) @@ -262,7 +262,7 @@ func TestACMETLSSettings(t *testing.T) { d.Config = &tls.Config{ServerName: acmeTestHost, RootCAs: acme.roots, MinVersion: tls.VersionTLS12} - conn, err := d.DialContext(t.Context(), "tcp", h.cfg.Addr) + conn, err := d.DialContext(t.Context(), "tcp", string(h.cfg.Addr)) if assert.NoError(c, err) { _ = conn.Close() } @@ -310,17 +310,17 @@ func TestACMERetryStaysOnConfiguredCA(t *testing.T) { h := &Headscale{cfg: &types.Config{ ServerURL: "https://" + acmeTestHost, - Addr: net.JoinHostPort("127.0.0.1", strconv.Itoa(freePort(t))), + Addr: types.ListenAddr(net.JoinHostPort("127.0.0.1", strconv.Itoa(freePort(t)))), TLS: types.TLSConfig{ACME: types.ACMEConfig{ Hostname: acmeTestHost, ChallengeType: types.DNS01ChallengeType, - URL: acme.directory, + URL: types.HTTPURL(acme.directory), CacheDir: t.TempDir(), }}, - DNSChallenge: types.DNSChallengeConfig{ + DNSConfig: types.DNSConfig{Challenge: types.DNSChallengeConfig{ Provider: published, Resolvers: []string{acme.resolver}, - }, + }}, }} bundle, err := h.getTLSSettings(t.Context()) diff --git a/hscontrol/auth_tags_test.go b/hscontrol/auth_tags_test.go index f39d748f9..862db06ec 100644 --- a/hscontrol/auth_tags_test.go +++ b/hscontrol/auth_tags_test.go @@ -20,8 +20,8 @@ func createTestAppWithNodeExpiry(t *testing.T, nodeExpiry time.Duration) *Headsc tmpDir := t.TempDir() cfg := types.Config{ - ServerURL: "http://localhost:8080", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", + ServerURL: "http://localhost:8080", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, Node: types.NodeConfig{ Expiry: nodeExpiry, }, diff --git a/hscontrol/auth_test.go b/hscontrol/auth_test.go index d536a25a4..77433b482 100644 --- a/hscontrol/auth_test.go +++ b/hscontrol/auth_test.go @@ -3365,8 +3365,8 @@ func createTestApp(t *testing.T, options ...func(*types.Config)) *Headscale { tmpDir := t.TempDir() cfg := types.Config{ - ServerURL: "http://localhost:8080", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", + ServerURL: "http://localhost:8080", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, Database: types.DatabaseConfig{ Type: "sqlite3", Sqlite: types.SqliteConfig{ diff --git a/hscontrol/config/files.go b/hscontrol/config/files.go index b3bee537e..cd81de4be 100644 --- a/hscontrol/config/files.go +++ b/hscontrol/config/files.go @@ -7,6 +7,7 @@ import ( "errors" "fmt" "os" + "slices" "strings" "github.com/juanfont/headscale/hscontrol/derp" @@ -26,7 +27,7 @@ var ( // File is one file the configuration names. type File struct { Key string // config key, e.g. "policy.path" - Path string // as startup resolves it + Path string // as startup resolves it; a secret's as written // CreatedAtStartup marks key files: startup creates them when missing, // so a missing one is not an error. @@ -62,7 +63,7 @@ func Files(cfg *types.Config) []File { }) } - noise := cfg.AbsPath(cfg.NoisePrivateKeyPath) + noise := cfg.AbsPath(cfg.Noise.PrivateKeyPath) if noise != "" { files = append(files, File{ Key: "noise.private_key_path", Path: noise, CreatedAtStartup: true, @@ -70,20 +71,53 @@ func Files(cfg *types.Config) []File { }) } - if d := cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath); cfg.DERP.ServerEnabled && d != "" { + if d := cfg.AbsPath(cfg.DERP.Server.PrivateKeyPath); cfg.DERP.Server.Enabled && d != "" { files = append(files, File{ Key: "derp.server.private_key_path", Path: d, CreatedAtStartup: true, Check: func() error { return checkDERPKey(d, noise) }, }) } - for _, kv := range cfg.UnreadSecrets { - files = append(files, File{ - Key: kv.Key, Path: fmt.Sprint(kv.Value), - Check: func() error { return ErrSecretNotRead }, + return append(files, secretFiles(cfg)...) +} + +// secretFiles lists, by key, each file: secret startup reads, unread. +func secretFiles(cfg *types.Config) []File { + var files []File + + add := func(key string, s types.Secret) { + if s.IsFile() { + files = append(files, File{ + Key: key, Path: strings.TrimPrefix(string(s), "file:"), + Check: func() error { return ErrSecretNotRead }, + }) + } + } + + if cfg.Database.Type == types.DatabasePostgres { + add("database.postgres.pass", cfg.Database.Postgres.Pass) + } + + if cfg.OIDC.Issuer != "" { + add("oidc.client_secret", cfg.OIDC.ClientSecret) + } + + // Startup builds the provider from its settings only without a Go-only + // one. Bad settings are the loader's to report; this only collects keys. + if cfg.DNSConfig.Challenge.Provider == nil && cfg.DNSConfig.Challenge.ProviderName() != "" { + _, _ = cfg.DNSConfig.Challenge.NewProvider(func(key, value string) (string, error) { + add(key, types.Secret(value)) + + if types.Secret(value).IsFile() { + return value, dns.ErrSecretUnread + } + + return value, nil }) } + slices.SortFunc(files, func(a, b File) int { return strings.Compare(a.Key, b.Key) }) + return files } diff --git a/hscontrol/config/files_test.go b/hscontrol/config/files_test.go index eeaed6412..508a1714e 100644 --- a/hscontrol/config/files_test.go +++ b/hscontrol/config/files_test.go @@ -8,6 +8,7 @@ import ( "github.com/google/go-cmp/cmp" policyv2 "github.com/juanfont/headscale/hscontrol/policy/v2" "github.com/juanfont/headscale/hscontrol/types" + "github.com/libdns/cloudflare" "github.com/stretchr/testify/require" "tailscale.com/types/key" ) @@ -33,12 +34,11 @@ const badGroup = `{"acls":[{"action":"accept","src":["group:missing"],"dst":["*: func TestFiles(t *testing.T) { dir := t.TempDir() cfg := &types.Config{ - NoisePrivateKeyPath: filepath.Join(dir, "noise.key"), - Policy: types.PolicyConfig{Mode: types.PolicyModeFile, Path: filepath.Join(dir, "policy.hujson")}, + Noise: types.NoiseConfig{PrivateKeyPath: filepath.Join(dir, "noise.key")}, + Policy: types.PolicyConfig{Mode: types.PolicyModeFile, Path: filepath.Join(dir, "policy.hujson")}, DERP: types.DERPConfig{ - Paths: []string{"a.yaml", "b.yaml"}, - ServerEnabled: true, - ServerPrivateKeyPath: filepath.Join(dir, "derp.key"), + Paths: []string{"a.yaml", "b.yaml"}, + Server: types.DERPServerConfig{Enabled: true, PrivateKeyPath: filepath.Join(dir, "derp.key")}, }, DNSConfig: types.DNSConfig{ExtraRecordsPath: "records.json"}, TLS: types.TLSConfig{CertPath: "c.pem", KeyPath: "k.pem"}, @@ -71,11 +71,68 @@ func TestFiles(t *testing.T) { // A policy in the database and a disabled DERP server name no file. cfg.Policy.Mode = types.PolicyModeDB - cfg.DERP.ServerEnabled = false + cfg.DERP.Server.Enabled = false for _, f := range Files(cfg) { require.NotContains(t, []string{"policy.path", "derp.server.private_key_path"}, f.Key) } + + // A file: secret is listed, unread, only where startup reads it. + missing := types.Secret("file:" + filepath.Join(dir, "missing")) + postgres := types.DatabaseConfig{Type: types.DatabasePostgres, Postgres: types.PostgresConfig{Pass: missing}} + oidc := types.OIDCConfig{Issuer: "https://idp.example.com", ClientSecret: missing} + provider := types.DNSChallengeConfig{ProviderSettings: map[string]any{ + "name": "cloudflare", "zone_token": string(missing), "api_token": string(missing), + }} + + for _, tt := range []struct { + name string + cfg types.Config + want []string + }{ + {name: "postgres pass", cfg: types.Config{Database: postgres}, want: []string{"database.postgres.pass"}}, + {name: "sqlite reads no postgres pass", cfg: types.Config{Database: types.DatabaseConfig{Type: types.DatabaseSqlite, Postgres: postgres.Postgres}}}, + {name: "oidc with an issuer", cfg: types.Config{OIDC: oidc}, want: []string{"oidc.client_secret"}}, + {name: "oidc without an issuer", cfg: types.Config{OIDC: types.OIDCConfig{ClientSecret: missing}}}, + {name: "literal secrets", cfg: types.Config{ + Database: types.DatabaseConfig{Type: types.DatabasePostgres, Postgres: types.PostgresConfig{Pass: "literal"}}, + OIDC: types.OIDCConfig{Issuer: oidc.Issuer, ClientSecret: "literal"}, + }}, + { + name: "provider settings", + cfg: types.Config{DNSConfig: types.DNSConfig{Challenge: provider}}, + want: []string{"dns.challenge.provider.api_token", "dns.challenge.provider.zone_token"}, + }, + { + name: "go-only provider reads no settings", + cfg: types.Config{ + DNSConfig: types.DNSConfig{Challenge: types.DNSChallengeConfig{ + ProviderSettings: provider.ProviderSettings, Provider: &cloudflare.Provider{}, + }}, + }, + }, + { + name: "sorted by key", + cfg: types.Config{Database: postgres, OIDC: oidc, DNSConfig: types.DNSConfig{Challenge: provider}}, + want: []string{ + "database.postgres.pass", "dns.challenge.provider.api_token", + "dns.challenge.provider.zone_token", "oidc.client_secret", + }, + }, + } { + t.Run(tt.name, func(t *testing.T) { + var keys []string + + for _, f := range Files(&tt.cfg) { + require.ErrorIs(t, f.Check(), ErrSecretNotRead, f.Key) + require.Equal(t, filepath.Join(dir, "missing"), f.Path, f.Key) + + keys = append(keys, f.Key) + } + + require.Equal(t, tt.want, keys) + }) + } } func TestFilesChecks(t *testing.T) { @@ -183,7 +240,7 @@ func TestFilesChecks(t *testing.T) { { name: "noise key missing", build: func(_ *testing.T, dir string) *types.Config { - return &types.Config{NoisePrivateKeyPath: filepath.Join(dir, "sub", "noise.key")} + return &types.Config{Noise: types.NoiseConfig{PrivateKeyPath: filepath.Join(dir, "sub", "noise.key")}} }, key: "noise.private_key_path", wantErr: os.ErrNotExist, @@ -193,7 +250,7 @@ func TestFilesChecks(t *testing.T) { build: func(t *testing.T, dir string) *types.Config { t.Helper() - return &types.Config{NoisePrivateKeyPath: write(t, filepath.Join(dir, "noise.key"), "garbage")} + return &types.Config{Noise: types.NoiseConfig{PrivateKeyPath: write(t, filepath.Join(dir, "noise.key"), "garbage")}} }, key: "noise.private_key_path", wantMsg: "parsing private key", @@ -206,10 +263,9 @@ func TestFilesChecks(t *testing.T) { k := keyText(t) return &types.Config{ - NoisePrivateKeyPath: write(t, filepath.Join(dir, "noise.key"), k), + Noise: types.NoiseConfig{PrivateKeyPath: write(t, filepath.Join(dir, "noise.key"), k)}, DERP: types.DERPConfig{ - ServerEnabled: true, - ServerPrivateKeyPath: write(t, filepath.Join(dir, "derp.key"), k+"\n"), + Server: types.DERPServerConfig{Enabled: true, PrivateKeyPath: write(t, filepath.Join(dir, "derp.key"), k+"\n")}, }, } }, @@ -222,10 +278,9 @@ func TestFilesChecks(t *testing.T) { t.Helper() return &types.Config{ - NoisePrivateKeyPath: write(t, filepath.Join(dir, "noise.key"), keyText(t)), + Noise: types.NoiseConfig{PrivateKeyPath: write(t, filepath.Join(dir, "noise.key"), keyText(t))}, DERP: types.DERPConfig{ - ServerEnabled: true, - ServerPrivateKeyPath: write(t, filepath.Join(dir, "derp.key"), keyText(t)), + Server: types.DERPServerConfig{Enabled: true, PrivateKeyPath: write(t, filepath.Join(dir, "derp.key"), keyText(t))}, }, } }, diff --git a/hscontrol/db/db.go b/hscontrol/db/db.go index fef18228a..ee3e91ff9 100644 --- a/hscontrol/db/db.go +++ b/hscontrol/db/db.go @@ -502,7 +502,7 @@ func openDB(cfg types.DatabaseConfig, sqlitePath string) (*gorm.DB, error) { // TODO(kradalby): Integrate this with zerolog var dbLogger logger.Interface if cfg.Debug { - dbLogger = util.NewDBLogWrapper(&log.Logger, cfg.Gorm.SlowThreshold, cfg.Gorm.SkipErrRecordNotFound, cfg.Gorm.ParameterizedQueries) + dbLogger = util.NewDBLogWrapper(&log.Logger, time.Duration(cfg.Gorm.SlowThreshold)*time.Millisecond, cfg.Gorm.SkipErrRecordNotFound, cfg.Gorm.ParameterizedQueries) } else { dbLogger = logger.Default.LogMode(logger.Silent) } @@ -517,7 +517,7 @@ func openDB(cfg types.DatabaseConfig, sqlitePath string) (*gorm.DB, error) { } log.Info(). - Str("database", types.DatabaseSqlite). + Str("database", string(types.DatabaseSqlite)). Str("path", sqlitePath). Msg("Opening database") @@ -564,15 +564,22 @@ func openDB(cfg types.DatabaseConfig, sqlitePath string) (*gorm.DB, error) { case cfg.Type == types.DatabasePostgres: // Log the DSN without the password. - redacted := cfg.Postgres - redacted.Pass = "" + pg := cfg.Postgres + pg.Pass = "" log.Info(). - Str(zf.Database, types.DatabasePostgres). - Str(zf.Path, redacted.DSN()). + Str(zf.Database, string(types.DatabasePostgres)). + Str(zf.Path, pg.DSN()). Msg("Opening database") - db, err := gorm.Open(postgres.Open(cfg.Postgres.DSN()), &gorm.Config{ + pass, err := types.ResolveSecret("database.postgres.pass", string(cfg.Postgres.Pass)) + if err != nil { + return nil, err + } + + pg.Pass = types.Secret(pass) + + db, err := gorm.Open(postgres.Open(pg.DSN()), &gorm.Config{ Logger: dbLogger, }) if err != nil { diff --git a/hscontrol/db/suite_test.go b/hscontrol/db/suite_test.go index 2482f4ef1..a2e755aa9 100644 --- a/hscontrol/db/suite_test.go +++ b/hscontrol/db/suite_test.go @@ -83,7 +83,7 @@ func newHeadscaleDBFromPostgresURL(t *testing.T, pu *url.URL) *HSDatabase { Host: pu.Hostname(), User: pu.User.Username(), Name: strings.TrimLeft(pu.Path, "/"), - Pass: pass, + Pass: types.Secret(pass), Port: port, Ssl: "disable", }, diff --git a/hscontrol/debug.go b/hscontrol/debug.go index e89809235..5c63329b2 100644 --- a/hscontrol/debug.go +++ b/hscontrol/debug.go @@ -88,7 +88,7 @@ func (h *Headscale) debugHostGuard(next http.Handler) http.Handler { return strings.TrimSuffix(strings.ToLower(strings.Trim(host, "[]")), ".") } - allowed := []string{"localhost", normalize(h.cfg.MetricsAddr)} + allowed := []string{"localhost", normalize(string(h.cfg.MetricsAddr))} serverURL, err := url.Parse(h.cfg.ServerURL) if err == nil { @@ -274,7 +274,7 @@ func (h *Headscale) debugHTTPServer() *http.Server { debugMux.Handle("/metrics", promhttp.Handler()) debugHTTPServer := &http.Server{ - Addr: h.cfg.MetricsAddr, + Addr: string(h.cfg.MetricsAddr), Handler: securityHeaders(h.debugHostGuard(debugMux)), ReadTimeout: types.HTTPTimeout, WriteTimeout: 0, diff --git a/hscontrol/derp/derp.go b/hscontrol/derp/derp.go index dd6e494ce..7f7192f7b 100644 --- a/hscontrol/derp/derp.go +++ b/hscontrol/derp/derp.go @@ -27,6 +27,7 @@ import ( var ( errEmptyDERPMapFile = errors.New("DERP map file has no regions or homeparams") errDERPMapStatus = errors.New("unexpected HTTP status") + errDERPURLSyntax = errors.New("invalid URL syntax") ErrRegionIDKey = errors.New("doesn't match its key") ErrRegionNoNodes = errors.New("must specify at least one node in DERP Region") @@ -249,8 +250,17 @@ func GetDERPMap(cfg types.DERPConfig, shuffleSeed string) (*tailcfg.DERPMap, err derpMaps = append(derpMaps, cfg.DERPMap) } - for _, addr := range cfg.URLs { - derpMap, err := loadDERPMapFromURL(addr) + for i, u := range cfg.URLs { + addr, err := url.Parse(string(u)) + if err != nil { + // The parser's error quotes the URL or parts of it, credentials + // included. + errs = append(errs, fmt.Errorf("derp.urls[%d]: %w", i, errDERPURLSyntax)) + + continue + } + + derpMap, err := loadDERPMapFromURL(*addr) if err != nil { errs = append(errs, err) continue diff --git a/hscontrol/derp/derp_test.go b/hscontrol/derp/derp_test.go index 10f937795..5025c5a65 100644 --- a/hscontrol/derp/derp_test.go +++ b/hscontrol/derp/derp_test.go @@ -522,7 +522,7 @@ regions: require.NoError(t, os.WriteFile(brokenPath, []byte("regions: [\n"), 0o600)) dm, err := GetDERPMap(types.DERPConfig{ - URLs: []url.URL{*goodURL, *downURL}, + URLs: []types.HTTPURL{types.HTTPURL(goodURL.String()), types.HTTPURL(downURL.String())}, Paths: []string{goodPath, brokenPath, filepath.Join(t.TempDir(), "missing.yaml")}, }, "") require.ErrorIs(t, err, errDERPMapStatus) @@ -533,6 +533,25 @@ regions: require.Contains(t, dm.Regions, tailcfg.DERPRegionID(2)) } +// TestGetDERPMapURLParseError: url.Parse errors quote the URL or parts of +// it, credentials included, so the error names only the setting. +func TestGetDERPMapURLParseError(t *testing.T) { + const marker = "derp-parse-password-marker" //nolint:gosec // test marker, not a real credential + + for _, u := range []string{ + "https://alice:" + marker + "@derp.example/%zz", + "https://alice:" + marker + "?@derp.example/map", + "https://alice:" + marker + "#@derp.example/map", + "https://alice:" + marker, + } { + t.Run(u, func(t *testing.T) { + _, err := GetDERPMap(types.DERPConfig{URLs: []types.HTTPURL{types.HTTPURL(u)}}, "") + require.EqualError(t, err, "derp.urls[0]: invalid URL syntax") + require.NotContains(t, err.Error(), marker) + }) + } +} + // TestLoadDERPMapFromURLRejectsHTTPError: an error page that happens to be // JSON must not pass as an empty map, or a refresh drops that URL's regions. func TestLoadDERPMapFromURLRejectsHTTPError(t *testing.T) { diff --git a/hscontrol/derp/server/derp_server.go b/hscontrol/derp/server/derp_server.go index 3e244f7b2..e48f52a35 100644 --- a/hscontrol/derp/server/derp_server.go +++ b/hscontrol/derp/server/derp_server.go @@ -68,7 +68,7 @@ func NewDERPServer( log.Trace().Caller().Msg("creating new embedded DERP server") server := derpserver.New(derpKey, util.TSLogfWrapper()) // nolint // zerolinter complains - if cfg.ServerVerifyClients { + if cfg.Server.VerifyClients { server.SetVerifyClientURL(DerpVerifyScheme + "://verify") server.SetVerifyClientURLFailOpen(false) } @@ -136,24 +136,24 @@ func (d *DERPServer) GenerateRegion() (tailcfg.DERPRegion, error) { } localDERPregion := tailcfg.DERPRegion{ - RegionID: d.cfg.ServerRegionID, - RegionCode: d.cfg.ServerRegionCode, - RegionName: d.cfg.ServerRegionName, + RegionID: d.cfg.Server.RegionID, + RegionCode: d.cfg.Server.RegionCode, + RegionName: d.cfg.Server.RegionName, Nodes: []*tailcfg.DERPNode{ { - Name: d.cfg.ServerRegionID.String(), - RegionID: d.cfg.ServerRegionID, + Name: d.cfg.Server.RegionID.String(), + RegionID: d.cfg.Server.RegionID, HostName: host, DERPPort: port, - IPv4: d.cfg.IPv4, - IPv6: d.cfg.IPv6, + IPv4: d.cfg.Server.IPv4, + IPv6: d.cfg.Server.IPv6, InsecureForTests: insecure, }, }, } - _, portSTUNStr, err := net.SplitHostPort(d.cfg.STUNAddr) + _, portSTUNStr, err := net.SplitHostPort(string(d.cfg.Server.STUNAddr)) if err != nil { return tailcfg.DERPRegion{}, err } @@ -380,7 +380,7 @@ func DERPBootstrapDNSHandler( // ServeSTUN starts a STUN server on the configured addr. func (d *DERPServer) ServeSTUN() { - packetConn, err := new(net.ListenConfig).ListenPacket(context.Background(), "udp", d.cfg.STUNAddr) + packetConn, err := new(net.ListenConfig).ListenPacket(context.Background(), "udp", string(d.cfg.Server.STUNAddr)) if err != nil { log.Fatal().Msgf("failed to open STUN listener: %v", err) } diff --git a/hscontrol/derp/server/derp_server_test.go b/hscontrol/derp/server/derp_server_test.go index c41e4ae5b..7e7c944b4 100644 --- a/hscontrol/derp/server/derp_server_test.go +++ b/hscontrol/derp/server/derp_server_test.go @@ -40,9 +40,7 @@ func TestGenerateRegionInsecureTLS(t *testing.T) { d := &DERPServer{ serverURL: "http://headscale", cfg: &types.DERPConfig{ - ServerRegionID: 999, - ServerRegionCode: "headscale", - STUNAddr: "[::]:3478", + Server: types.DERPServerConfig{RegionID: 999, RegionCode: "headscale", STUNAddr: "[::]:3478"}, }, } diff --git a/hscontrol/handlers_test.go b/hscontrol/handlers_test.go index 2e0d25020..86ba7deb2 100644 --- a/hscontrol/handlers_test.go +++ b/hscontrol/handlers_test.go @@ -73,11 +73,9 @@ func TestVerifyHandler_SuccessSetsJSONContentType(t *testing.T) { prefixV6 := netip.MustParsePrefix("fd7a:115c:a1e0::/48") cfg := &types.Config{ - ServerURL: "http://localhost:0", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", - PrefixV4: &prefixV4, - PrefixV6: &prefixV6, - IPAllocation: types.IPAllocationStrategySequential, + ServerURL: "http://localhost:0", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, + Prefixes: types.PrefixesConfig{V4: &prefixV4, V6: &prefixV6, Allocation: types.IPAllocationStrategySequential}, Database: types.DatabaseConfig{ Type: "sqlite3", Sqlite: types.SqliteConfig{ diff --git a/hscontrol/mapper/batcher_test.go b/hscontrol/mapper/batcher_test.go index d74078229..a7a995bde 100644 --- a/hscontrol/mapper/batcher_test.go +++ b/hscontrol/mapper/batcher_test.go @@ -182,15 +182,13 @@ func setupBatcherWithTestData( Path: dbPath, }, }, - PrefixV4: &prefixV4, - PrefixV6: &prefixV6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", + Prefixes: types.PrefixesConfig{V4: &prefixV4, V6: &prefixV6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, Policy: types.PolicyConfig{ Mode: types.PolicyModeDB, }, DERP: types.DERPConfig{ - ServerEnabled: false, + Server: types.DERPServerConfig{Enabled: false}, DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{ 999: { @@ -232,7 +230,7 @@ func setupBatcherWithTestData( tb.Fatalf("Failed to create state: %v", err) } - derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.BaseDomain) + derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.DNSConfig.BaseDomain) require.NoError(tb, err) require.NotNil(tb, derpMap) diff --git a/hscontrol/mapper/builder.go b/hscontrol/mapper/builder.go index 9cf89568a..8a1b08692 100644 --- a/hscontrol/mapper/builder.go +++ b/hscontrol/mapper/builder.go @@ -210,7 +210,7 @@ func (b *MapResponseBuilder) WithUserProfiles(peers views.Slice[types.NodeView]) b.resp.UserProfiles = generateUserProfiles(node, peers) if node.IsTagged() { - fqdn, err := node.GetFQDN(b.mapper.cfg.BaseDomain) + fqdn, err := node.GetFQDN(b.mapper.cfg.DNSConfig.BaseDomain) if err != nil { b.addError(err) return b diff --git a/hscontrol/mapper/builder_test.go b/hscontrol/mapper/builder_test.go index d282f542f..42d001d0b 100644 --- a/hscontrol/mapper/builder_test.go +++ b/hscontrol/mapper/builder_test.go @@ -14,7 +14,7 @@ import ( func TestMapResponseBuilder_Basic(t *testing.T) { cfg := &types.Config{ - BaseDomain: "example.com", + DNSConfig: types.DNSConfig{BaseDomain: "example.com"}, LogTail: types.LogTailConfig{ Enabled: true, }, @@ -60,8 +60,8 @@ func TestMapResponseBuilder_WithCapabilityVersion(t *testing.T) { func TestMapResponseBuilder_WithDomain(t *testing.T) { domain := "test.example.com" cfg := &types.Config{ - ServerURL: "https://test.example.com", - BaseDomain: domain, + ServerURL: "https://test.example.com", + DNSConfig: types.DNSConfig{BaseDomain: domain}, } mockState := &state.State{} @@ -245,8 +245,8 @@ func TestMapResponseBuilder_ErrorHandling(t *testing.T) { func TestMapResponseBuilder_ChainedCalls(t *testing.T) { domain := "chained.example.com" cfg := &types.Config{ - ServerURL: "https://chained.example.com", - BaseDomain: domain, + ServerURL: "https://chained.example.com", + DNSConfig: types.DNSConfig{BaseDomain: domain}, LogTail: types.LogTailConfig{ Enabled: false, }, diff --git a/hscontrol/mapper/initialmap_storm_test.go b/hscontrol/mapper/initialmap_storm_test.go index 8c00786f7..41f270b16 100644 --- a/hscontrol/mapper/initialmap_storm_test.go +++ b/hscontrol/mapper/initialmap_storm_test.go @@ -41,13 +41,11 @@ func setupStormBatcher(tb testing.TB, nodeCount, workers int, policy string) (*T Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmpDir + "/headscale_test.db"}, }, - PrefixV4: &prefixV4, - PrefixV6: &prefixV6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &prefixV4, V6: &prefixV6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ - ServerEnabled: false, + Server: types.DERPServerConfig{Enabled: false}, DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, }, @@ -79,7 +77,7 @@ func setupStormBatcher(tb testing.TB, nodeCount, workers int, policy string) (*T st, err := state.NewState(cfg) require.NoError(tb, err) - derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.BaseDomain) + derpMap, err := derp.GetDERPMap(cfg.DERP, cfg.DNSConfig.BaseDomain) require.NoError(tb, err) st.SetDERPMap(derpMap) diff --git a/hscontrol/mapper/mapper.go b/hscontrol/mapper/mapper.go index a10cc862a..d9f574061 100644 --- a/hscontrol/mapper/mapper.go +++ b/hscontrol/mapper/mapper.go @@ -138,8 +138,8 @@ func generateDNSConfig( // MagicDNS, base_domain can be a public domain whose names clients ask the // exit node for, so node names stay readable. Reverse lookups stay open, as // on Tailscale SaaS. - if dnsConfig.Proxied && cfg.BaseDomain != "" { - dnsConfig.ExitNodeFilteredSet = []string{"." + strings.ToLower(cfg.BaseDomain)} + if dnsConfig.Proxied && cfg.DNSConfig.BaseDomain != "" { + dnsConfig.ExitNodeFilteredSet = []string{"." + strings.ToLower(cfg.DNSConfig.BaseDomain)} } return dnsConfig diff --git a/hscontrol/mapper/mapper_test.go b/hscontrol/mapper/mapper_test.go index 96e84696d..0da9823a8 100644 --- a/hscontrol/mapper/mapper_test.go +++ b/hscontrol/mapper/mapper_test.go @@ -58,8 +58,7 @@ func TestExitNodeFilteredSet(t *testing.T) { t.Run(tt.name, func(t *testing.T) { got := generateDNSConfig( &types.Config{ - BaseDomain: tt.baseDomain, - DNSConfig: types.DNSConfig{MagicDNS: tt.magicDNS, BaseDomain: tt.baseDomain}, + DNSConfig: types.DNSConfig{MagicDNS: tt.magicDNS, BaseDomain: tt.baseDomain}, }, (&types.Node{}).View(), nil, @@ -82,7 +81,8 @@ func TestDNSConfigMapResponse(t *testing.T) { Domains: []string{ "foobar.headscale.net", }, - Proxied: true, + Proxied: true, + ExitNodeFilteredSet: []string{".foobar.headscale.net"}, }, }, { @@ -370,11 +370,9 @@ func TestBuildFromChangeFiltersPeerPatchesByVisibility(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -456,11 +454,9 @@ func TestBuildFromChangeFiltersUserProfilesByVisibility(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -541,11 +537,9 @@ func TestBuildFromChangeVisibilityMatchesFullMap(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -753,11 +747,9 @@ func TestFullMapResponseSurvivesPeerWithInvalidData(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -1016,11 +1008,9 @@ func TestBackfillNodeIPsReachesBackfilledNode(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -1091,11 +1081,9 @@ func TestFailedExpiryOfPrimaryAnnouncesBackup(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -1183,11 +1171,8 @@ func TestGenerateMapResponseDebugOnlyOnFullMaps(t *testing.T) { Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tmp + "/h.db"}, }, - PrefixV4: &p4, - PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, DERP: types.DERPConfig{ DERPMap: &tailcfg.DERPMap{ Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{999: {RegionID: 999}}, @@ -1195,7 +1180,7 @@ func TestGenerateMapResponseDebugOnlyOnFullMaps(t *testing.T) { }, // Without these the DERP map and DNS config renders carry // nothing and no frame is generated at all. - DNSConfig: types.DNSConfig{MagicDNS: true}, + DNSConfig: types.DNSConfig{MagicDNS: true, BaseDomain: "headscale.test"}, Tuning: types.Tuning{ NodeStoreBatchSize: state.TestBatchSize, NodeStoreBatchTimeout: state.TestBatchTimeout, @@ -1358,12 +1343,13 @@ func TestCertDomains(t *testing.T) { dnsCfg := tt.dns dnsCfg.MagicDNS = true + dnsCfg.BaseDomain = baseDomain dnsCfg.ExtraRecords = []tailcfg.DNSRecord{ {Name: "Grafana.ts.example.com", Type: "A", Value: "100.64.0.3"}, {Name: "grafana.svc.ts.example.com.", Type: "A", Value: "100.64.0.4"}, } - cfg := &types.Config{BaseDomain: baseDomain, DNSConfig: dnsCfg} + cfg := &types.Config{DNSConfig: dnsCfg} cfg.StartDNS(tt.provider) got := generateDNSConfig(cfg, tt.node.View(), nil) @@ -1862,10 +1848,9 @@ func capMapsMapperFixture(tb testing.TB, n int, attrs string) (*mapper, []types. Type: types.DatabaseSqlite, Sqlite: types.SqliteConfig{Path: tb.TempDir() + "/caps.db"}, }, - PrefixV4: &p4, PrefixV6: &p6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", - Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, + Prefixes: types.PrefixesConfig{V4: &p4, V6: &p6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, + Policy: types.PolicyConfig{Mode: types.PolicyModeDB}, Tuning: types.Tuning{ NodeStoreBatchSize: state.TestBatchSize, NodeStoreBatchTimeout: state.TestBatchTimeout, diff --git a/hscontrol/mapper/tail_test.go b/hscontrol/mapper/tail_test.go index a2cf9be71..4d5bae22a 100644 --- a/hscontrol/mapper/tail_test.go +++ b/hscontrol/mapper/tail_test.go @@ -199,8 +199,8 @@ func TestTailNode(t *testing.T) { t.Parallel() cfg := &types.Config{ - BaseDomain: tt.baseDomain, - Taildrop: types.TaildropConfig{Enabled: true}, + DNSConfig: types.DNSConfig{BaseDomain: tt.baseDomain}, + Taildrop: types.TaildropConfig{Enabled: true}, } // Stub primary-route lookup: tt.node owns its SubnetRoutes, diff --git a/hscontrol/noise_test.go b/hscontrol/noise_test.go index a94d9ce65..10c03eb1b 100644 --- a/hscontrol/noise_test.go +++ b/hscontrol/noise_test.go @@ -76,7 +76,7 @@ func TestNoiseRouter_DoesNotExposeAdministrativeEndpoints(t *testing.T) { serverKey := key.NewMachine() app := &Headscale{ - cfg: &types.Config{MetricsAddr: metricsAddr}, + cfg: &types.Config{MetricsAddr: types.ListenAddr(metricsAddr)}, noisePrivateKey: &serverKey, } server := httptest.NewServer(http.HandlerFunc(app.NoiseUpgradeHandler)) @@ -1665,7 +1665,7 @@ func setDNSTestApp(t *testing.T) (*Headscale, *dnstest.Provider) { t.Helper() app := createTestApp(t) - app.cfg.BaseDomain = setDNSZone + app.cfg.DNSConfig.BaseDomain = setDNSZone app.cfg.DNSConfig.Certificates = types.CertificatesConfig{Enabled: true, Zone: setDNSZone} provider := &dnstest.Provider{} diff --git a/hscontrol/oidc.go b/hscontrol/oidc.go index b7c3de81e..fa2607441 100644 --- a/hscontrol/oidc.go +++ b/hscontrol/oidc.go @@ -87,17 +87,18 @@ func NewAuthProviderOIDC( h *Headscale, serverURL string, cfg *types.OIDCConfig, + clientSecret string, // cfg.ClientSecret, resolved ) (*AuthProviderOIDC, error) { // Use the caller's context (bounded, see app.go) so a slow or unreachable // issuer fails discovery within the timeout instead of hanging startup. - oidcProvider, err := oidc.NewProvider(ctx, cfg.Issuer) + oidcProvider, err := oidc.NewProvider(ctx, string(cfg.Issuer)) if err != nil { return nil, fmt.Errorf("creating OIDC provider from issuer config: %w", err) } oauth2Config := &oauth2.Config{ ClientID: cfg.ClientID, - ClientSecret: cfg.ClientSecret, + ClientSecret: clientSecret, Endpoint: oidcProvider.Endpoint(), RedirectURL: oidcCallbackURL(serverURL), Scopes: cfg.Scope, diff --git a/hscontrol/oidc_test.go b/hscontrol/oidc_test.go index 0735fbb83..938985992 100644 --- a/hscontrol/oidc_test.go +++ b/hscontrol/oidc_test.go @@ -896,8 +896,8 @@ func TestOIDCPendingCallbackCookieBinding(t *testing.T) { } func TestOIDCPendingCallbackPKCEFlow(t *testing.T) { - for _, method := range []string{"", types.PKCEMethodPlain, types.PKCEMethodS256} { - t.Run("method="+method, func(t *testing.T) { + for _, method := range []types.PKCEMethod{"", types.PKCEMethodPlain, types.PKCEMethodS256} { + t.Run("method="+string(method), func(t *testing.T) { b := newOIDCBrowser(t) a, ok := b.app.authProvider.(*AuthProviderOIDC) require.True(t, ok) @@ -1103,11 +1103,11 @@ func newOIDCBrowserWithPrefix(t *testing.T, prefix string) *oidcBrowser { app, publicURL, &types.OIDCConfig{ - Issuer: idp.Issuer(), - ClientID: idp.ClientID, - ClientSecret: idp.ClientSecret, - Scope: []string{"openid", "profile", "email"}, + Issuer: types.HTTPURL(idp.Issuer()), + ClientID: idp.ClientID, + Scope: []string{"openid", "profile", "email"}, }, + idp.ClientSecret, ) require.NoError(t, err) t.Cleanup(provider.authCache.Close) diff --git a/hscontrol/servertest/server.go b/hscontrol/servertest/server.go index 36bed748d..df76b213c 100644 --- a/hscontrol/servertest/server.go +++ b/hscontrol/servertest/server.go @@ -167,17 +167,19 @@ func NewServer(tb testing.TB, opts ...ServerOption) *TestServer { cfg := types.Config{ // Placeholder; updated below once the in-memory server starts. - ServerURL: "http://localhost:0", - NoisePrivateKeyPath: tmpDir + "/noise_private.key", + ServerURL: "http://localhost:0", + Noise: types.NoiseConfig{PrivateKeyPath: tmpDir + "/noise_private.key"}, Node: types.NodeConfig{ Expiry: sc.nodeExpiry, Ephemeral: types.EphemeralConfig{ InactivityTimeout: sc.ephemeralTimeout, }, }, - PrefixV4: &prefixV4, - PrefixV6: &prefixV6, - IPAllocation: types.IPAllocationStrategySequential, + Prefixes: types.PrefixesConfig{ + V4: &prefixV4, + V6: &prefixV6, + Allocation: types.IPAllocationStrategySequential, + }, Database: types.DatabaseConfig{ Type: "sqlite3", Sqlite: types.SqliteConfig{ @@ -198,14 +200,13 @@ func NewServer(tb testing.TB, opts ...ServerOption) *TestServer { } if sc.magicDNSDomain != "" { - cfg.BaseDomain = sc.magicDNSDomain cfg.DNSConfig.MagicDNS = true cfg.DNSConfig.BaseDomain = sc.magicDNSDomain } if sc.certProvider != nil { - cfg.DNSConfig.Certificates = types.CertificatesConfig{Enabled: true, Zone: cfg.BaseDomain} - cfg.DNSChallenge.Provider = sc.certProvider + cfg.DNSConfig.Certificates = types.CertificatesConfig{Enabled: true, Zone: cfg.DNSConfig.BaseDomain} + cfg.DNSConfig.Challenge.Provider = sc.certProvider } if len(sc.dnsResolvers) > 0 { diff --git a/hscontrol/state/connect_test.go b/hscontrol/state/connect_test.go index 901ad214c..3595c66d8 100644 --- a/hscontrol/state/connect_test.go +++ b/hscontrol/state/connect_test.go @@ -377,7 +377,7 @@ func TestBackfillNodeIPsKeepsLiveSessions(t *testing.T) { // Dropping the IPv6 prefix gives the backfill work to do. cfg := persistTestConfig(dbPath) - cfg.PrefixV6 = nil + cfg.Prefixes.V6 = nil s, err := NewState(cfg) require.NoError(t, err) diff --git a/hscontrol/state/node_health.go b/hscontrol/state/node_health.go index c4347e7c5..5f7faac92 100644 --- a/hscontrol/state/node_health.go +++ b/hscontrol/state/node_health.go @@ -30,7 +30,7 @@ var nodeHealthChecks = []nodeHealthCheck{givenNameMapsToValidFQDN, expiryIsEncod var givenNameMapsToValidFQDN = nodeHealthCheck{ name: "given-name-maps-to-valid-fqdn", check: func(nv types.NodeView, cfg *types.Config) (string, string, bool) { - err := types.ValidateGivenName(nv.GivenName(), cfg.BaseDomain) + err := types.ValidateGivenName(nv.GivenName(), cfg.DNSConfig.BaseDomain) if err != nil { return err.Error(), fmt.Sprintf("headscale nodes rename %d ", nv.ID()), false } diff --git a/hscontrol/state/node_health_test.go b/hscontrol/state/node_health_test.go index 720a6cb72..88cd82609 100644 --- a/hscontrol/state/node_health_test.go +++ b/hscontrol/state/node_health_test.go @@ -10,7 +10,7 @@ import ( ) func TestGivenNameMapsToValidFQDNCheck(t *testing.T) { - cfg := &types.Config{BaseDomain: "example.com"} + cfg := &types.Config{DNSConfig: types.DNSConfig{BaseDomain: "example.com"}} _, _, ok := givenNameMapsToValidFQDN.check((&types.Node{ID: 1, GivenName: "valid"}).View(), cfg) require.True(t, ok, "a valid given name must pass the check") diff --git a/hscontrol/state/node_store_hostname_test.go b/hscontrol/state/node_store_hostname_test.go index 2a5effa55..a20a5b0a3 100644 --- a/hscontrol/state/node_store_hostname_test.go +++ b/hscontrol/state/node_store_hostname_test.go @@ -42,8 +42,8 @@ func TestNewNodeStoreBumpsDuplicateNames(t *testing.T) { func TestPutNodeBumpsPastReservedLabel(t *testing.T) { cfg := persistTestConfig(t.TempDir() + "/headscale.db") cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ - {Name: "laptop." + cfg.BaseDomain}, - {Name: "laptop-1." + cfg.BaseDomain}, + {Name: "laptop." + cfg.DNSConfig.BaseDomain}, + {Name: "laptop-1." + cfg.DNSConfig.BaseDomain}, } s, err := NewState(cfg) require.NoError(t, err) @@ -56,7 +56,7 @@ func TestPutNodeBumpsPastReservedLabel(t *testing.T) { func TestSetGivenNameRejectsReservedLabel(t *testing.T) { cfg := persistTestConfig(t.TempDir() + "/headscale.db") cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ - {Name: "laptop." + cfg.BaseDomain}, + {Name: "laptop." + cfg.DNSConfig.BaseDomain}, } s, err := NewState(cfg) require.NoError(t, err) diff --git a/hscontrol/state/persist_test.go b/hscontrol/state/persist_test.go index cca605ebe..8e52a1656 100644 --- a/hscontrol/state/persist_test.go +++ b/hscontrol/state/persist_test.go @@ -86,10 +86,8 @@ func persistTestConfig(dbPath string) *types.Config { Path: dbPath, }, }, - PrefixV4: &prefixV4, - PrefixV6: &prefixV6, - IPAllocation: types.IPAllocationStrategySequential, - BaseDomain: "headscale.test", + Prefixes: types.PrefixesConfig{V4: &prefixV4, V6: &prefixV6, Allocation: types.IPAllocationStrategySequential}, + DNSConfig: types.DNSConfig{BaseDomain: "headscale.test"}, Policy: types.PolicyConfig{ Mode: types.PolicyModeDB, }, @@ -104,7 +102,7 @@ func TestLoadedDuplicateNamesAreResolvedInMemory(t *testing.T) { dbPath := t.TempDir() + "/headscale.db" cfg := persistTestConfig(dbPath) cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ - {Name: "grafana." + cfg.BaseDomain, Type: "A", Value: "100.64.0.100"}, + {Name: "grafana." + cfg.DNSConfig.BaseDomain, Type: "A", Value: "100.64.0.100"}, } database, err := db.NewHeadscaleDatabase(cfg) require.NoError(t, err) @@ -737,9 +735,9 @@ func (failingSetNodesPolicyManager) SetNodes(views.Slice[types.NodeView]) (bool, func TestDeleteNodeTwiceReleasesAddressOnce(t *testing.T) { prefix := netip.MustParsePrefix("100.64.0.0/30") cfg := persistTestConfig(t.TempDir() + "/headscale.db") - cfg.PrefixV4 = &prefix - cfg.PrefixV6 = nil - cfg.IPAllocation = types.IPAllocationStrategyRandom + cfg.Prefixes.V4 = &prefix + cfg.Prefixes.V6 = nil + cfg.Prefixes.Allocation = types.IPAllocationStrategyRandom s, err := NewState(cfg) require.NoError(t, err) @@ -1555,7 +1553,7 @@ func TestPostgresUpdatePolicyConcurrentWrites(t *testing.T) { Port: port, Name: strings.TrimLeft(u.Path, "/"), User: u.User.Username(), - Pass: pass, + Pass: types.Secret(pass), Ssl: "disable", }, } @@ -1744,7 +1742,7 @@ func TestBackfillNodeIPsSurvivesConcurrentPersist(t *testing.T) { // Dropping the IPv6 prefix gives the backfill work to do. cfg := persistTestConfig(dbPath) - cfg.PrefixV6 = nil + cfg.Prefixes.V6 = nil s, err := NewState(cfg) require.NoError(t, err) diff --git a/hscontrol/state/rename_test.go b/hscontrol/state/rename_test.go index ebe935556..dc8caa539 100644 --- a/hscontrol/state/rename_test.go +++ b/hscontrol/state/rename_test.go @@ -15,7 +15,7 @@ import ( func TestNodeNameCannotShadowExtraRecord(t *testing.T) { cfg := persistTestConfig(t.TempDir() + "/headscale.db") cfg.DNSConfig.ExtraRecords = []tailcfg.DNSRecord{ - {Name: "grafana." + cfg.BaseDomain, Type: "A", Value: "100.64.0.100"}, + {Name: "grafana." + cfg.DNSConfig.BaseDomain, Type: "A", Value: "100.64.0.100"}, } cfg.StartDNS(nil) // as NewHeadscale does, so SetExtraRecords takes s, err := NewState(cfg) @@ -44,9 +44,9 @@ func TestNodeNameCannotShadowExtraRecord(t *testing.T) { existing := register("existing") cfg.SetExtraRecords([]tailcfg.DNSRecord{ - {Name: "SVC." + cfg.BaseDomain + ".", Type: "A", Value: "100.64.0.101"}, - {Name: "existing." + cfg.BaseDomain, Type: "A", Value: "100.64.0.102"}, - {Name: "child.parent." + cfg.BaseDomain, Type: "A", Value: "100.64.0.103"}, + {Name: "SVC." + cfg.DNSConfig.BaseDomain + ".", Type: "A", Value: "100.64.0.101"}, + {Name: "existing." + cfg.DNSConfig.BaseDomain, Type: "A", Value: "100.64.0.102"}, + {Name: "child.parent." + cfg.DNSConfig.BaseDomain, Type: "A", Value: "100.64.0.103"}, }) fresh, _ := s.GetNodeByID(existing.ID()) @@ -95,7 +95,7 @@ func TestRenameNodeRejectsNameExceedingFQDNLimit(t *testing.T) { dbPath := t.TempDir() + "/headscale.db" cfg := persistTestConfig(dbPath) // A long base domain so a 63-char label overflows the 255-char FQDN bound. - cfg.BaseDomain = strings.Repeat("b", 200) + ".example.com" + cfg.DNSConfig.BaseDomain = strings.Repeat("b", 200) + ".example.com" database, err := db.NewHeadscaleDatabase(cfg) require.NoError(t, err) diff --git a/hscontrol/state/state.go b/hscontrol/state/state.go index d95e4cb47..29d1d0097 100644 --- a/hscontrol/state/state.go +++ b/hscontrol/state/state.go @@ -369,7 +369,7 @@ func NewState(cfg *types.Config) (*State, error) { return nil, fmt.Errorf("initializing database: %w", err) } - ipAlloc, err := hsdb.NewIPAllocator(db, cfg.PrefixV4, cfg.PrefixV6, cfg.IPAllocation) + ipAlloc, err := hsdb.NewIPAllocator(db, cfg.Prefixes.V4, cfg.Prefixes.V6, cfg.Prefixes.Allocation) if err != nil { return nil, fmt.Errorf("initializing IP allocator: %w", err) } @@ -449,7 +449,7 @@ func NewState(cfg *types.Config) (*State, error) { nodeStore := NewNodeStore(nodes, policyPeersFunc(polMan), batchSize, batchTimeout) polMan.SetRouterSession(nodeStore.RouterSession) nodeStore.reservedLabel = func(label string) bool { - return cfg.BaseDomain != "" && cfg.HasExtraRecord(label+"."+cfg.BaseDomain) + return cfg.DNSConfig.BaseDomain != "" && cfg.HasExtraRecord(label+"."+cfg.DNSConfig.BaseDomain) } nodeStore.Start() @@ -1555,7 +1555,7 @@ func (s *State) RenameNode(nodeID types.NodeID, newName string) (types.NodeView, // Validate the label AND that the resulting FQDN fits MaxHostnameLength: // a valid 63-char label can still overflow under a long base_domain, and // an unmappable name would break this node and its peers (issue #3346). - err := types.ValidateGivenName(newName, s.cfg.BaseDomain) + err := types.ValidateGivenName(newName, s.cfg.DNSConfig.BaseDomain) if err != nil { return types.NodeView{}, change.Change{}, fmt.Errorf("%w: %w", ErrGivenNameInvalid, err) } @@ -1607,7 +1607,7 @@ func (s *State) WarnNodesHoldingExtraRecords() []types.NodeID { ids = append(ids, n.ID()) log.Warn(). Uint64(zf.NodeID, n.ID().Uint64()). - Str("record", n.GivenName()+"."+s.cfg.BaseDomain). + Str("record", n.GivenName()+"."+s.cfg.DNSConfig.BaseDomain). Msg("node keeps a name that is also an extra DNS record") } diff --git a/hscontrol/types/common.go b/hscontrol/types/common.go index 9b11b068a..cb28294ef 100644 --- a/hscontrol/types/common.go +++ b/hscontrol/types/common.go @@ -16,9 +16,9 @@ import ( ) const ( - SelfUpdateIdentifier = "self-update" - DatabasePostgres = "postgres" - DatabaseSqlite = "sqlite3" + SelfUpdateIdentifier = "self-update" + DatabasePostgres DatabaseType = "postgres" + DatabaseSqlite DatabaseType = "sqlite3" ) // Common errors. diff --git a/hscontrol/types/config.go b/hscontrol/types/config.go index 7f976a042..493fac14e 100644 --- a/hscontrol/types/config.go +++ b/hscontrol/types/config.go @@ -4,7 +4,6 @@ import ( "cmp" "errors" "fmt" - "io/fs" "maps" "net" "net/netip" @@ -32,8 +31,8 @@ import ( ) const ( - PKCEMethodPlain string = "plain" - PKCEMethodS256 string = "S256" + PKCEMethodPlain PKCEMethod = "plain" + PKCEMethodS256 PKCEMethod = "S256" defaultNodeStoreBatchSize = 100 @@ -48,6 +47,7 @@ var ( errServerURLSame = errors.New("server_url cannot use the same domain as base_domain in a way that could make the DERP and headscale server unreachable") errInvalidPKCEMethod = errors.New("pkce.method must be either 'plain' or 'S256'") errTrustedProxyZeroRange = errors.New("0.0.0.0/0 and ::/0 are not allowed") + errURLSyntax = errors.New("invalid URL syntax") ErrNoPrefixConfigured = errors.New("no IPv4 or IPv6 prefix configured, minimum one prefix is required") ErrInvalidAllocationStrategy = errors.New("invalid prefix allocation strategy") errConfigNotLoaded = errors.New("configuration not loaded: call types.LoadConfig first") @@ -59,41 +59,45 @@ var ( // asking the public zone. var defaultChallengeResolvers = []string{"1.1.1.1:53", "8.8.8.8:53"} -type IPAllocationStrategy string +// IPAllocationStrategy is how new node IPs are picked. "" decodes without +// error to the zero value (unset). +type IPAllocationStrategy string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value const ( IPAllocationStrategySequential IPAllocationStrategy = "sequential" IPAllocationStrategyRandom IPAllocationStrategy = "random" ) -type PolicyMode string +// PolicyMode is where the policy is stored. "" decodes without error to the +// zero value (unset). +type PolicyMode string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value const ( - PolicyModeDB = "database" - PolicyModeFile = "file" + PolicyModeDB PolicyMode = "database" + PolicyModeFile PolicyMode = "file" ) // EphemeralConfig contains configuration for ephemeral node lifecycle. type EphemeralConfig struct { // InactivityTimeout is how long an ephemeral node can be offline // before it is automatically deleted. - InactivityTimeout time.Duration + InactivityTimeout time.Duration `koanf:"inactivity_timeout"` } // HARouteConfig contains configuration for HA subnet router health probing. type HARouteConfig struct { // ProbeInterval is how often HA subnet routers are probed. // A zero or negative duration disables probing. - ProbeInterval time.Duration + ProbeInterval time.Duration `koanf:"probe_interval"` // ProbeTimeout is the maximum time to wait for a probe response // before declaring a node unhealthy. Must be less than [HARouteConfig.ProbeInterval]. - ProbeTimeout time.Duration + ProbeTimeout time.Duration `koanf:"probe_timeout"` } // RouteConfig contains configuration for route behaviour. type RouteConfig struct { - HA HARouteConfig + HA HARouteConfig `koanf:"ha"` } // PreAuthKeysConfig contains configuration for pre-auth key lifecycle. @@ -102,7 +106,7 @@ type PreAuthKeysConfig struct { // v2 API's DELETE) is kept retrievable before the background collector // hard-deletes it. Keys still backing a node are kept until the node is // deleted. A zero or negative duration disables the collector. - RevokedRetention time.Duration + RevokedRetention time.Duration `koanf:"revoked_retention"` } // NodeConfig contains configuration for node lifecycle and expiry. @@ -111,70 +115,61 @@ type NodeConfig struct { // Applies to all registration methods (auth key, CLI, web, OIDC). // Tagged nodes are exempt and never expire. // A zero/negative duration means no default expiry (nodes never expire). - Expiry time.Duration + Expiry time.Duration `koanf:"expiry"` // Ephemeral contains configuration for ephemeral node lifecycle. - Ephemeral EphemeralConfig + Ephemeral EphemeralConfig `koanf:"ephemeral"` // Routes contains configuration for route behaviour. - Routes RouteConfig + Routes RouteConfig `koanf:"routes"` } -// Config contains the initial Headscale configuration. +// Config is the Headscale configuration, nested like the configuration +// file; koanf tags name the keys. type Config struct { - ServerURL string - Addr string - MetricsAddr string - TrustedProxies []netip.Prefix - Node NodeConfig - PreAuthKeys PreAuthKeysConfig - PrefixV4 *netip.Prefix - PrefixV6 *netip.Prefix - IPAllocation IPAllocationStrategy - NoisePrivateKeyPath string - BaseDomain string - Log LogConfig - DisableUpdateCheck bool - - Database DatabaseConfig - - DERP DERPConfig - - TLS TLSConfig - - // DNSConfig is the headscale representation of the DNS configuration. - // It is kept in the config update for some settings that are - // not directly converted into a [tailcfg.DNSConfig]. - DNSConfig DNSConfig - - DNSChallenge DNSChallengeConfig - - UnixSocket string - UnixSocketPermission fs.FileMode - - OIDC OIDCConfig - - LogTail LogTailConfig - Taildrop TaildropConfig - AutoUpdate AutoUpdateConfig - - CLI CLIConfig - - Policy PolicyConfig - - Tuning Tuning + ServerURL string `koanf:"server_url"` + Addr ListenAddr `koanf:"listen_addr"` + MetricsAddr ListenAddr `koanf:"metrics_listen_addr"` + UnixSocket string `koanf:"unix_socket"` + UnixSocketPermission FileMode `koanf:"unix_socket_permission"` + TrustedProxies []netip.Prefix `koanf:"trusted_proxies"` + DisableUpdateCheck bool `koanf:"disable_check_updates"` + Noise NoiseConfig `koanf:"noise"` + Prefixes PrefixesConfig `koanf:"prefixes"` + Policy PolicyConfig `koanf:"policy"` + Log LogConfig `koanf:"log"` + Node NodeConfig `koanf:"node"` + PreAuthKeys PreAuthKeysConfig `koanf:"preauth_keys"` + DERP DERPConfig `koanf:"derp"` + Database DatabaseConfig `koanf:"database"` + DNSConfig DNSConfig `koanf:"dns"` + TLS TLSConfig `koanf:"tls"` + OIDC OIDCConfig `koanf:"oidc"` + LogTail LogTailConfig `koanf:"logtail"` + Taildrop TaildropConfig `koanf:"taildrop"` + AutoUpdate AutoUpdateConfig `koanf:"auto_update"` + CLI CLIConfig `koanf:"cli"` + Tuning Tuning `koanf:"tuning"` // ConfigDir is where [Config.AbsPath] resolves relative paths. - ConfigDir string `json:"-"` - - // UnreadSecrets are the file: secrets [CheckServerConfig] left unread, - // each as key and path. - UnreadSecrets []KV `json:"-"` + ConfigDir string `json:"-" koanf:"-"` // dns is nil until [Config.StartDNS]. dns *liveDNS } +// NoiseConfig is the key of the Noise protocol clients connect over. +type NoiseConfig struct { + PrivateKeyPath string `koanf:"private_key_path"` +} + +// PrefixesConfig are the ranges node IPs are allocated from. +type PrefixesConfig struct { + V4 *netip.Prefix `koanf:"v4"` + V6 *netip.Prefix `koanf:"v6"` + Allocation IPAllocationStrategy `koanf:"allocation"` +} + // liveDNS is the DNS state of a running server: the tailcfg form, whose // extra records the extra-records watcher replaces while map builds clone // it, and the provider startup built. @@ -185,24 +180,25 @@ type liveDNS struct { } type DNSConfig struct { - MagicDNS bool `mapstructure:"magic_dns"` - BaseDomain string `mapstructure:"base_domain"` - OverrideLocalDNS bool `mapstructure:"override_local_dns"` - Nameservers Nameservers - SearchDomains []string `mapstructure:"search_domains"` - ExtraRecords []tailcfg.DNSRecord `mapstructure:"extra_records"` - ExtraRecordsPath string `mapstructure:"extra_records_path"` - Certificates CertificatesConfig + MagicDNS bool `koanf:"magic_dns"` + BaseDomain string `koanf:"base_domain"` + OverrideLocalDNS bool `koanf:"override_local_dns"` + Nameservers Nameservers `koanf:"nameservers"` + SearchDomains []string `koanf:"search_domains"` + ExtraRecords []tailcfg.DNSRecord `koanf:"extra_records"` + ExtraRecordsPath string `koanf:"extra_records_path"` + Certificates CertificatesConfig `koanf:"certificates"` + Challenge DNSChallengeConfig `koanf:"challenge"` } // CertificatesConfig lets nodes get TLS certificates for their MagicDNS // name with `tailscale cert`. The node runs ACME itself; headscale // publishes its DNS-01 challenge through [DNSChallengeConfig]. type CertificatesConfig struct { - Enabled bool + Enabled bool `koanf:"enabled"` // Zone is the public DNS zone challenge records are written to, when // base_domain sits below the zone apex. See [DNSConfig.CertificateZone]. - Zone string + Zone string `koanf:"zone"` } // CertificateZone is the zone challenge records are written to: @@ -214,14 +210,14 @@ func (d DNSConfig) CertificateZone() string { // DNSChallengeConfig is the DNS provider answering ACME DNS-01 // challenges for node certificates and headscale's own certificate. type DNSChallengeConfig struct { - PropagationTimeout time.Duration - Resolvers []string + PropagationTimeout time.Duration `koanf:"propagation_timeout"` + Resolvers []string `koanf:"resolvers"` // ProviderSettings is dns.challenge.provider, name included. Never // serialised: its settings are credentials. - ProviderSettings map[string]any `json:"-"` + ProviderSettings map[string]any `json:"-" koanf:"provider"` // Provider is set only from Go, by an embedder or a test, and wins // over ProviderSettings. The loader never sets it. - Provider hsdns.Provider `json:"-"` + Provider hsdns.Provider `json:"-" koanf:"-"` } // ProviderName is the provider ProviderSettings names, or "". @@ -267,26 +263,26 @@ func (c DNSChallengeConfig) ResolverAddrs() []string { } type Nameservers struct { - Global []string - Split map[string][]string + Global []string `koanf:"global"` + Split map[string][]string `koanf:"split"` } type SqliteConfig struct { - Path string - WriteAheadLog bool - WALAutoCheckPoint int + Path string `koanf:"path"` + WriteAheadLog bool `koanf:"write_ahead_log"` + WALAutoCheckPoint int `koanf:"wal_autocheckpoint"` } type PostgresConfig struct { - Host string - Port int - Name string - User string - Pass string `json:"-"` // never serialise the database password - Ssl string - MaxOpenConnections int - MaxIdleConnections int - ConnMaxIdleTimeSecs int + Host string `koanf:"host"` + Port int `koanf:"port"` + Name string `koanf:"name"` + User string `koanf:"user"` + Pass Secret `json:"-" koanf:"pass"` // never serialise the database password + Ssl string `koanf:"ssl"` + MaxOpenConnections int `koanf:"max_open_conns"` + MaxIdleConnections int `koanf:"max_idle_conns"` + ConnMaxIdleTimeSecs int `koanf:"conn_max_idle_time_secs"` } // DSN returns the connection string for this configuration as a @@ -307,7 +303,7 @@ func (cfg PostgresConfig) DSN() string { switch { case cfg.Pass != "": - u.User = url.UserPassword(cfg.User, cfg.Pass) + u.User = url.UserPassword(cfg.User, string(cfg.Pass)) case cfg.User != "": u.User = url.User(cfg.User) } @@ -345,22 +341,21 @@ func (cfg PostgresConfig) DSN() string { } type GormConfig struct { - Debug bool - SlowThreshold time.Duration - SkipErrRecordNotFound bool - ParameterizedQueries bool + // SlowThreshold is in milliseconds. + SlowThreshold int `koanf:"slow_threshold"` + SkipErrRecordNotFound bool `koanf:"skip_err_record_not_found"` + ParameterizedQueries bool `koanf:"parameterized_queries"` } type DatabaseConfig struct { - // Type sets the database type: "sqlite", "sqlite3" or "postgres". - Type string - Debug bool + Type DatabaseType `koanf:"type"` + // Debug logs queries through [GormConfig]. + Debug bool `koanf:"debug"` - // Type sets the gorm configuration - Gorm GormConfig + Gorm GormConfig `koanf:"gorm"` - Sqlite SqliteConfig - Postgres PostgresConfig + Sqlite SqliteConfig `koanf:"sqlite"` + Postgres PostgresConfig `koanf:"postgres"` } // IsSQLite reports whether Type names SQLite, in either spelling. @@ -369,67 +364,73 @@ func (d DatabaseConfig) IsSQLite() bool { } type TLSConfig struct { - CertPath string - KeyPath string + CertPath string `koanf:"cert_path"` + KeyPath string `koanf:"key_path"` - ACME ACMEConfig + ACME ACMEConfig `koanf:"acme"` } // ACMEConfig gets headscale's own certificate from an ACME CA. type ACMEConfig struct { - Hostname string - ChallengeType string + Hostname string `koanf:"hostname"` + ChallengeType ACMEChallenge `koanf:"challenge_type"` // HTTPListen serves HTTP-01 challenges. - HTTPListen string - URL string - Email string - CacheDir string + HTTPListen ListenAddr `koanf:"http_listen"` + URL HTTPURL `koanf:"url"` + Email string `koanf:"email"` + CacheDir string `koanf:"cache_dir"` } type PKCEConfig struct { - Enabled bool - Method string + Enabled bool `koanf:"enabled"` + Method PKCEMethod `koanf:"method"` } type OIDCConfig struct { - OnlyStartIfOIDCIsAvailable bool - Issuer string - ClientID string - ClientSecret string `json:"-"` // never serialise the OIDC client secret - Scope []string - ExtraParams map[string]string - AllowedDomains []string - AllowedUsers []string - AllowedGroups []string - EmailVerifiedRequired bool - UseExpiryFromToken bool - PKCE PKCEConfig + OnlyStartIfOIDCIsAvailable bool `koanf:"only_start_if_oidc_is_available"` + Issuer HTTPURL `koanf:"issuer"` + ClientID string `koanf:"client_id"` + ClientSecret Secret `json:"-" koanf:"client_secret"` // never serialise the OIDC client secret + Scope []string `koanf:"scope"` + ExtraParams map[string]string `koanf:"extra_params"` + AllowedDomains []string `koanf:"allowed_domains"` + AllowedUsers []string `koanf:"allowed_users"` + AllowedGroups []string `koanf:"allowed_groups"` + EmailVerifiedRequired bool `koanf:"email_verified_required"` + UseExpiryFromToken bool `koanf:"use_expiry_from_token"` + PKCE PKCEConfig `koanf:"pkce"` } type DERPConfig struct { - ServerEnabled bool - AutomaticallyAddEmbeddedDerpRegion bool - ServerRegionID tailcfg.DERPRegionID - ServerRegionCode string - ServerRegionName string - ServerPrivateKeyPath string - ServerVerifyClients bool - STUNAddr string - URLs []url.URL - Paths []string - DERPMap *tailcfg.DERPMap - AutoUpdate bool - UpdateFrequency time.Duration - IPv4 string - IPv6 string + Server DERPServerConfig `koanf:"server"` + URLs []HTTPURL `koanf:"urls"` + Paths []string `koanf:"paths"` + AutoUpdate bool `koanf:"auto_update_enabled"` + UpdateFrequency time.Duration `koanf:"update_frequency"` + // DERPMap is set only from Go, by an embedder or a test. + DERPMap *tailcfg.DERPMap `json:"-" koanf:"-"` +} + +// DERPServerConfig is the embedded DERP server. +type DERPServerConfig struct { + Enabled bool `koanf:"enabled"` + RegionID tailcfg.DERPRegionID `koanf:"region_id"` + RegionCode string `koanf:"region_code"` + RegionName string `koanf:"region_name"` + VerifyClients bool `koanf:"verify_clients"` + STUNAddr ListenAddr `koanf:"stun_listen_addr"` + PrivateKeyPath string `koanf:"private_key_path"` + IPv4 string `koanf:"ipv4"` + IPv6 string `koanf:"ipv6"` + AutomaticallyAddEmbeddedDerpRegion bool `koanf:"automatically_add_embedded_derp_region"` } type LogTailConfig struct { - Enabled bool + Enabled bool `koanf:"enabled"` } type TaildropConfig struct { - Enabled bool + Enabled bool `koanf:"enabled"` } // AutoUpdateConfig controls the tailnet-wide default for client @@ -438,19 +439,19 @@ type TaildropConfig struct { // node's CapMap; clients fall back to that default unless they have // opted in or out locally. type AutoUpdateConfig struct { - Enabled bool + Enabled bool `koanf:"enabled"` } type CLIConfig struct { - Address string - APIKey string `json:"-"` // never serialise the headscale admin API key - Timeout time.Duration - Insecure bool + Address string `koanf:"address"` + APIKey Secret `json:"-" koanf:"api_key"` // never serialise the headscale admin API key + Timeout time.Duration `koanf:"timeout"` + Insecure bool `koanf:"insecure"` } type PolicyConfig struct { - Path string - Mode PolicyMode + Path string `koanf:"path"` + Mode PolicyMode `koanf:"mode"` } func (p *PolicyConfig) IsEmpty() bool { @@ -458,8 +459,8 @@ func (p *PolicyConfig) IsEmpty() bool { } type LogConfig struct { - Format string - Level zerolog.Level + Level LogLevel `koanf:"level"` + Format LogFormat `koanf:"format"` } // Tuning contains advanced performance tuning parameters for Headscale. @@ -470,29 +471,29 @@ type LogConfig struct { type Tuning struct { // NotifierSendTimeout is the maximum time to wait when sending notifications // to connected clients about network changes. - NotifierSendTimeout time.Duration + NotifierSendTimeout time.Duration `koanf:"notifier_send_timeout"` // BatchChangeDelay controls how long to wait before sending batched updates // to clients when multiple changes occur in rapid succession. - BatchChangeDelay time.Duration + BatchChangeDelay time.Duration `koanf:"batch_change_delay"` // NodeMapSessionBufferedChanSize sets the buffer size for the channel that // queues map updates to be sent to connected clients. - NodeMapSessionBufferedChanSize int + NodeMapSessionBufferedChanSize int `koanf:"node_mapsession_buffered_chan_size"` // BatcherWorkers controls the number of parallel workers processing map // updates for connected clients. See [Tuning.BatcherWorkerCount]. - BatcherWorkers int + BatcherWorkers int `koanf:"batcher_workers"` // RegisterCacheExpiration is how long registration cache entries remain // valid before being eligible for eviction. - RegisterCacheExpiration time.Duration + RegisterCacheExpiration time.Duration `koanf:"register_cache_expiration"` // RegisterCacheMaxEntries bounds pending registrations. At capacity, new // registrations are refused without evicting admitted sessions. SSH checks // can also use 64 reserved slots beyond this limit. // A value of 0 falls back to defaultRegisterCacheMaxEntries (1024). - RegisterCacheMaxEntries int + RegisterCacheMaxEntries int `koanf:"register_cache_max_entries"` // NodeStoreBatchSize controls how many write operations are accumulated // before rebuilding the in-memory node snapshot. @@ -508,7 +509,7 @@ type Tuning struct { // // Trade-off: Higher values reduce CPU usage from rebuilds but increase latency // for individual operations waiting for their batch to complete. - NodeStoreBatchSize int + NodeStoreBatchSize int `koanf:"node_store_batch_size"` // NodeStoreBatchTimeout is the maximum time to wait before processing a // partial batch of node operations. @@ -520,7 +521,7 @@ type Tuning struct { // Trade-off: Lower values provide faster response for individual operations // but trigger more frequent (expensive) peer map rebuilds. Higher values // optimize for bulk throughput at the cost of individual operation latency. - NodeStoreBatchTimeout time.Duration + NodeStoreBatchTimeout time.Duration `koanf:"node_store_batch_timeout"` } // BatcherWorkerCount is BatcherWorkers, or [DefaultBatcherWorkers] when unset. @@ -532,7 +533,7 @@ func (t Tuning) BatcherWorkerCount() int { return DefaultBatcherWorkers() } -func validatePKCEMethod(method string) error { +func validatePKCEMethod(method PKCEMethod) error { if method != PKCEMethodPlain && method != PKCEMethodS256 { return errInvalidPKCEMethod } @@ -546,7 +547,7 @@ func validatePKCEMethod(method string) error { // error or, worse, resolve to an unintended provider), or a missing client // id/secret. func validateOIDCConfig() error { - err := validatePKCEMethod(src.String("oidc.pkce.method")) + err := validatePKCEMethod(PKCEMethod(src.String("oidc.pkce.method"))) if err != nil { return err } @@ -570,11 +571,11 @@ func validateOIDCConfig() error { } // Domain returns the hostname/domain part of the [Config.ServerURL]. -// If the [Config.ServerURL] is not a valid URL, it returns the [Config.BaseDomain]. +// If the [Config.ServerURL] is not a valid URL, it returns dns.base_domain. func (c *Config) Domain() string { u, err := url.Parse(c.ServerURL) if err != nil { - return c.BaseDomain + return c.DNSConfig.BaseDomain } return u.Hostname() @@ -606,8 +607,8 @@ func (c *Config) ServesRoute(p netip.Prefix) bool { addr := p.Addr().Unmap() - return (c.PrefixV4 == nil || !c.PrefixV4.Contains(addr)) && - (c.PrefixV6 == nil || !c.PrefixV6.Contains(addr)) + return (c.Prefixes.V4 == nil || !c.Prefixes.V4.Contains(addr)) && + (c.Prefixes.V6 == nil || !c.Prefixes.V6.Contains(addr)) } // src is the configuration [LoadConfig] loaded. @@ -657,8 +658,8 @@ func configDir() string { // load, or "" when it found none. func ConfigFile() string { return configFile } -// LogFormat returns the configured log.format. -func LogFormat() string { return src.String("log.format") } +// LogFormatSetting returns the configured log.format. +func LogFormatSetting() LogFormat { return LogFormat(src.String("log.format")) } // UpdateCheckDisabled reports whether disable_check_updates is set. func UpdateCheckDisabled() bool { return src.Bool("disable_check_updates") } @@ -801,7 +802,7 @@ func validateServerConfigInto(v *configValidator) { } if src.String("tls.acme.hostname") != "" && - src.String("tls.acme.challenge_type") == TLSALPN01ChallengeType && + ACMEChallenge(src.String("tls.acme.challenge_type")) == TLSALPN01ChallengeType && !strings.HasSuffix(src.String("listen_addr"), ":443") { // this is only a warning because there could be something sitting in front of headscale that redirects the traffic (e.g. an iptables rule) log.Warn(). @@ -810,12 +811,12 @@ func validateServerConfigInto(v *configValidator) { validateListenerCollisions(v) - if ct := src.String("tls.acme.challenge_type"); ct != HTTP01ChallengeType && + if ct := ACMEChallenge(src.String("tls.acme.challenge_type")); ct != HTTP01ChallengeType && ct != TLSALPN01ChallengeType && ct != DNS01ChallengeType { v.Add(&ConfigError{ Reason: "tls.acme.challenge_type has an unsupported value", - Current: []KV{{"tls.acme.challenge_type", ct}}, - Allowed: []string{HTTP01ChallengeType, TLSALPN01ChallengeType, DNS01ChallengeType}, + Current: []KV{{"tls.acme.challenge_type", string(ct)}}, + Allowed: ct.Allowed(), Hint: "pick one of the allowed values; HTTP-01 is the default", }) } @@ -917,15 +918,15 @@ func validateServerConfigInto(v *configValidator) { // validatePolicyConfig records a ConfigError for an unknown policy.mode: // startup would load no policy at all and allow all traffic. func validatePolicyConfig(v *configValidator) { - m := src.String("policy.mode") + m := PolicyMode(src.String("policy.mode")) if m == PolicyModeFile || m == PolicyModeDB { return } v.Add(&ConfigError{ Reason: "policy.mode has an unsupported value", - Current: []KV{{"policy.mode", m}}, - Allowed: []string{PolicyModeFile, PolicyModeDB}, + Current: []KV{{"policy.mode", string(m)}}, + Allowed: m.Allowed(), See: "https://headscale.net/stable/ref/policy/", }) } @@ -990,7 +991,7 @@ func validateDERPConfig(v *configValidator) { // validateDatabaseConfig records a ConfigError when database.type is not // one of the supported backends. func validateDatabaseConfig(v *configValidator) { - t := src.String("database.type") + t := DatabaseType(src.String("database.type")) switch t { case DatabaseSqlite, DatabasePostgres, "sqlite": return @@ -998,8 +999,8 @@ func validateDatabaseConfig(v *configValidator) { v.Add(&ConfigError{ Reason: "database.type has an unsupported value", - Current: []KV{{"database.type", t}}, - Allowed: []string{"sqlite", "sqlite3", "postgres"}, + Current: []KV{{"database.type", string(t)}}, + Allowed: t.Allowed(), Hint: "pick one of the allowed values; sqlite is the default for single-host deployments", See: "https://headscale.net/stable/ref/database/", }) @@ -1038,13 +1039,13 @@ func validateCertificatesConfig(v *configValidator) { } enabled := src.Bool("dns.certificates.enabled") - challengeType := src.String("tls.acme.challenge_type") + challengeType := ACMEChallenge(src.String("tls.acme.challenge_type")) ownDNS01 := src.String("tls.acme.hostname") != "" && challengeType == DNS01ChallengeType if (enabled || ownDNS01) && src.String("dns.challenge.provider.name") == "" { v.Add(&ConfigError{ Reason: "dns.certificates and tls.acme DNS-01 require dns.challenge.provider", - Current: []KV{{"dns.certificates.enabled", enabled}, {"tls.acme.challenge_type", challengeType}}, + Current: []KV{{"dns.certificates.enabled", enabled}, {"tls.acme.challenge_type", string(challengeType)}}, Allowed: hsdns.ProviderNames(), Hint: "configure the DNS provider that hosts dns.base_domain or tls.acme.hostname under dns.challenge.provider", See: dnsDocsURL, @@ -1085,9 +1086,10 @@ func validateCertificatesConfig(v *configValidator) { } } -// dnsChallengeConfig reads dns.challenge and builds the provider it names -// only to report bad settings; startup builds the one it uses. -func dnsChallengeConfig(secret func(key, value string) (string, error)) (DNSChallengeConfig, error) { +// dnsChallengeConfig reads dns.challenge and builds the provider it names, +// its secrets unread, only to report bad settings; startup builds the one +// it uses. +func dnsChallengeConfig() (DNSChallengeConfig, error) { cfg := DNSChallengeConfig{ PropagationTimeout: src.Duration("dns.challenge.propagation_timeout"), Resolvers: src.StringSlice("dns.challenge.resolvers"), @@ -1098,7 +1100,7 @@ func dnsChallengeConfig(secret func(key, value string) (string, error)) (DNSChal return cfg, nil } - provider, err := cfg.NewProvider(secret) + provider, err := cfg.NewProvider(keepSecret) if err != nil { return cfg, err } @@ -1121,9 +1123,9 @@ func tlsConfig() TLSConfig { KeyPath: src.String("tls.key_path"), ACME: ACMEConfig{ Hostname: src.String("tls.acme.hostname"), - ChallengeType: src.String("tls.acme.challenge_type"), - HTTPListen: src.String("tls.acme.http_listen"), - URL: src.String("tls.acme.url"), + ChallengeType: ACMEChallenge(src.String("tls.acme.challenge_type")), + HTTPListen: ListenAddr(src.String("tls.acme.http_listen")), + URL: HTTPURL(src.String("tls.acme.url")), Email: src.String("tls.acme.email"), CacheDir: src.String("tls.acme.cache_dir"), }, @@ -1131,24 +1133,11 @@ func tlsConfig() TLSConfig { } func derpConfig() DERPConfig { - serverEnabled := src.Bool("derp.server.enabled") - serverRegionID := src.Int64("derp.server.region_id") - serverRegionCode := src.String("derp.server.region_code") - serverRegionName := src.String("derp.server.region_name") - serverVerifyClients := src.Bool("derp.server.verify_clients") - stunAddr := src.String("derp.server.stun_listen_addr") - privateKeyPath := src.String("derp.server.private_key_path") - ipv4 := src.String("derp.server.ipv4") - ipv6 := src.String("derp.server.ipv6") - automaticallyAddEmbeddedDerpRegion := src.Bool( - "derp.server.automatically_add_embedded_derp_region", - ) - urlStrs := src.StringSlice("derp.urls") - urls := make([]url.URL, 0, len(urlStrs)) + urls := make([]HTTPURL, 0, len(urlStrs)) for _, urlStr := range urlStrs { - urlAddr, err := url.Parse(urlStr) + _, err := url.Parse(urlStr) if err != nil { log.Error(). Caller(). @@ -1159,29 +1148,28 @@ func derpConfig() DERPConfig { continue } - urls = append(urls, *urlAddr) + urls = append(urls, HTTPURL(urlStr)) } - paths := src.StringSlice("derp.paths") - - autoUpdate := src.Bool("derp.auto_update_enabled") - updateFrequency := src.Duration("derp.update_frequency") - return DERPConfig{ - ServerEnabled: serverEnabled, - ServerRegionID: tailcfg.DERPRegionID(serverRegionID), - ServerRegionCode: serverRegionCode, - ServerRegionName: serverRegionName, - ServerVerifyClients: serverVerifyClients, - ServerPrivateKeyPath: privateKeyPath, - STUNAddr: stunAddr, - URLs: urls, - Paths: paths, - AutoUpdate: autoUpdate, - UpdateFrequency: updateFrequency, - IPv4: ipv4, - IPv6: ipv6, - AutomaticallyAddEmbeddedDerpRegion: automaticallyAddEmbeddedDerpRegion, + Server: DERPServerConfig{ + Enabled: src.Bool("derp.server.enabled"), + RegionID: tailcfg.DERPRegionID(src.Int64("derp.server.region_id")), + RegionCode: src.String("derp.server.region_code"), + RegionName: src.String("derp.server.region_name"), + VerifyClients: src.Bool("derp.server.verify_clients"), + STUNAddr: ListenAddr(src.String("derp.server.stun_listen_addr")), + PrivateKeyPath: src.String("derp.server.private_key_path"), + IPv4: src.String("derp.server.ipv4"), + IPv6: src.String("derp.server.ipv6"), + AutomaticallyAddEmbeddedDerpRegion: src.Bool( + "derp.server.automatically_add_embedded_derp_region", + ), + }, + URLs: urls, + Paths: src.StringSlice("derp.paths"), + AutoUpdate: src.Bool("derp.auto_update_enabled"), + UpdateFrequency: src.Duration("derp.update_frequency"), } } @@ -1203,17 +1191,12 @@ func policyConfig() PolicyConfig { } } +// logConfig keeps log.level as written; [LogLevel.Zerolog] reads one it +// does not know as debug. func logConfig() LogConfig { - logLevelStr := src.String("log.level") + logFormatOpt := LogFormat(src.String("log.format")) - logLevel, err := zerolog.ParseLevel(logLevelStr) - if err != nil { - logLevel = zerolog.DebugLevel - } - - logFormatOpt := src.String("log.format") - - var logFormat string + var logFormat LogFormat switch logFormatOpt { case JSONLogFormat: @@ -1230,33 +1213,19 @@ func logConfig() LogConfig { } return LogConfig{ + Level: LogLevel(src.String("log.level")), Format: logFormat, - Level: logLevel, } } -func databaseConfig(v *configValidator, secret func(key, value string) (string, error)) DatabaseConfig { - debug := src.Bool("database.debug") - - type_ := src.String("database.type") - - skipErrRecordNotFound := src.Bool("database.gorm.skip_err_record_not_found") - slowThreshold := time.Duration(src.Int64("database.gorm.slow_threshold")) * time.Millisecond - parameterizedQueries := src.Bool("database.gorm.parameterized_queries") - - pass := src.String("database.postgres.pass") - if type_ == DatabasePostgres { - pass = configSecret(v, secret, "database.postgres.pass", pass) - } - +func databaseConfig() DatabaseConfig { return DatabaseConfig{ - Type: type_, - Debug: debug, + Type: DatabaseType(src.String("database.type")), + Debug: src.Bool("database.debug"), Gorm: GormConfig{ - Debug: debug, - SkipErrRecordNotFound: skipErrRecordNotFound, - SlowThreshold: slowThreshold, - ParameterizedQueries: parameterizedQueries, + SkipErrRecordNotFound: src.Bool("database.gorm.skip_err_record_not_found"), + SlowThreshold: src.Int("database.gorm.slow_threshold"), + ParameterizedQueries: src.Bool("database.gorm.parameterized_queries"), }, Sqlite: SqliteConfig{ Path: src.String("database.sqlite.path"), @@ -1268,7 +1237,7 @@ func databaseConfig(v *configValidator, secret func(key, value string) (string, Port: src.Int("database.postgres.port"), Name: src.String("database.postgres.name"), User: src.String("database.postgres.user"), - Pass: pass, + Pass: Secret(src.String("database.postgres.pass")), Ssl: src.String("database.postgres.ssl"), MaxOpenConnections: src.Int("database.postgres.max_open_conns"), MaxIdleConnections: src.Int("database.postgres.max_idle_conns"), @@ -1417,12 +1386,12 @@ func (c *Config) TailcfgDNSConfig() *tailcfg.DNSConfig { } var reverse []dnsname.FQDN - if c.PrefixV4 != nil && outside(*c.PrefixV4, tsaddr.CGNATRange()) { - reverse = append(reverse, util.GenerateIPv4DNSRootDomain(*c.PrefixV4)...) + if v4 := c.Prefixes.V4; v4 != nil && outside(*v4, tsaddr.CGNATRange()) { + reverse = append(reverse, util.GenerateIPv4DNSRootDomain(*v4)...) } - if c.PrefixV6 != nil && outside(*c.PrefixV6, tsaddr.TailscaleULARange()) { - reverse = append(reverse, util.GenerateIPv6DNSRootDomain(*c.PrefixV6)...) + if v6 := c.Prefixes.V6; v6 != nil && outside(*v6, tsaddr.TailscaleULARange()) { + reverse = append(reverse, util.GenerateIPv6DNSRootDomain(*v6)...) } for _, d := range reverse { @@ -1526,11 +1495,6 @@ func LoadCLIConfig() (*Config, error) { v := &configValidator{} validateBoolConfig(v, "cli.insecure", "disable_check_updates") - // Over the unix socket the CLI needs no key, so it is not read. - cliAPIKey := src.String("cli.api_key") - if src.String("cli.address") != "" { - cliAPIKey = configSecret(v, ResolveSecret, "cli.api_key", cliAPIKey) - } err := v.Err() if err != nil { @@ -1538,14 +1502,14 @@ func LoadCLIConfig() (*Config, error) { } logConfig := logConfig() - zerolog.SetGlobalLevel(logConfig.Level) + zerolog.SetGlobalLevel(logConfig.Level.Zerolog()) return &Config{ DisableUpdateCheck: src.Bool("disable_check_updates"), UnixSocket: src.String("unix_socket"), CLI: CLIConfig{ Address: src.String("cli.address"), - APIKey: cliAPIKey, + APIKey: Secret(src.String("cli.api_key")), Timeout: src.Duration("cli.timeout"), Insecure: src.Bool("cli.insecure"), }, @@ -1553,36 +1517,9 @@ func LoadCLIConfig() (*Config, error) { }, nil } -// LoadServerConfig returns the full Headscale configuration to -// host a Headscale server. This is called as part of `headscale serve`. +// LoadServerConfig returns the full Headscale configuration to host a +// Headscale server. It reads no file: secret; each consumer reads its own. func LoadServerConfig() (*Config, error) { - return loadServerConfig(ResolveSecret) -} - -// CheckServerConfig validates the server configuration as -// LoadServerConfig does, without reading the files file: secrets name; it -// lists them in UnreadSecrets instead. -func CheckServerConfig() (*Config, error) { - var unread []KV - - cfg, err := loadServerConfig(func(key, value string) (string, error) { - s, err := keepSecret(key, value) - if errors.Is(err, hsdns.ErrSecretUnread) { - unread = append(unread, KV{key, strings.TrimPrefix(value, "file:")}) - } - - return s, err - }) - if cfg != nil { - // Provider settings are visited in map order. - slices.SortFunc(unread, func(a, b KV) int { return strings.Compare(a.Key, b.Key) }) - cfg.UnreadSecrets = unread - } - - return cfg, err -} - -func loadServerConfig(secret func(key, value string) (string, error)) (*Config, error) { if src == nil { return nil, errConfigNotLoaded } @@ -1591,7 +1528,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, validateServerConfigInto(v) logConfig := logConfig() - zerolog.SetGlobalLevel(logConfig.Level) + zerolog.SetGlobalLevel(logConfig.Level.Zerolog()) prefix4, v4NonStandard, err := parsePrefixConfig("prefixes.v4", tsaddr.CGNATRange(), "IPv4") if err != nil { @@ -1716,7 +1653,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, derpConfig := derpConfig() logTailConfig := logtailConfig() - dnsChallenge, err := dnsChallengeConfig(secret) + dnsChallenge, err := dnsChallengeConfig() if err != nil { // The provider names only help when the name is what is wrong. var allowed []string @@ -1735,13 +1672,8 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, }) } - // OIDC is active only with an issuer; see validateServerConfigInto. - oidcClientSecret := src.String("oidc.client_secret") - if src.String("oidc.issuer") != "" { - oidcClientSecret = configSecret(v, secret, "oidc.client_secret", oidcClientSecret) - } - - database := databaseConfig(v, secret) + dnsConfig.Challenge = dnsChallenge + database := databaseConfig() serverURL := strings.TrimRight(src.String("server_url"), "/") @@ -1766,18 +1698,19 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, return &Config{ ServerURL: serverURL, - Addr: src.String("listen_addr"), - MetricsAddr: src.String("metrics_listen_addr"), + Addr: ListenAddr(src.String("listen_addr")), + MetricsAddr: ListenAddr(src.String("metrics_listen_addr")), TrustedProxies: trusted, ConfigDir: dir, DisableUpdateCheck: src.Bool("disable_check_updates"), - PrefixV4: prefix4, - PrefixV6: prefix6, - IPAllocation: alloc, + Prefixes: PrefixesConfig{ + V4: prefix4, + V6: prefix6, + Allocation: alloc, + }, - NoisePrivateKeyPath: src.String("noise.private_key_path"), - BaseDomain: dnsConfig.BaseDomain, + Noise: NoiseConfig{PrivateKeyPath: src.String("noise.private_key_path")}, DERP: derpConfig, @@ -1802,19 +1735,18 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, TLS: tlsConfig(), - DNSConfig: dnsConfig, - DNSChallenge: dnsChallenge, + DNSConfig: dnsConfig, UnixSocket: src.String("unix_socket"), - UnixSocketPermission: socketPerm, + UnixSocketPermission: FileMode(socketPerm), OIDC: OIDCConfig{ OnlyStartIfOIDCIsAvailable: src.Bool( "oidc.only_start_if_oidc_is_available", ), - Issuer: src.String("oidc.issuer"), + Issuer: HTTPURL(src.String("oidc.issuer")), ClientID: src.String("oidc.client_id"), - ClientSecret: oidcClientSecret, + ClientSecret: Secret(src.String("oidc.client_secret")), Scope: src.StringSlice("oidc.scope"), ExtraParams: src.StringMapString("oidc.extra_params"), AllowedDomains: src.StringSlice("oidc.allowed_domains"), @@ -1824,7 +1756,7 @@ func loadServerConfig(secret func(key, value string) (string, error)) (*Config, UseExpiryFromToken: src.Bool("oidc.use_expiry_from_token"), PKCE: PKCEConfig{ Enabled: src.Bool("oidc.pkce.enabled"), - Method: src.String("oidc.pkce.method"), + Method: PKCEMethod(src.String("oidc.pkce.method")), }, }, @@ -1934,13 +1866,13 @@ func (c *Config) StartDNS(provider hsdns.Provider) { } // DNSProvider returns the provider [Config.StartDNS] was given, else the -// Go-only DNSChallenge.Provider. +// Go-only DNSConfig.Challenge.Provider. func (c *Config) DNSProvider() hsdns.Provider { if c.dns != nil { return c.dns.provider } - return c.DNSChallenge.Provider + return c.DNSConfig.Challenge.Provider } // CloneTailcfgDNSConfig returns a deep copy of the started DNS config, or a diff --git a/hscontrol/types/config_fields.go b/hscontrol/types/config_fields.go new file mode 100644 index 000000000..f7be84062 --- /dev/null +++ b/hscontrol/types/config_fields.go @@ -0,0 +1,52 @@ +package types + +import ( + "encoding" + "reflect" +) + +// ConfigField is one key of the configuration: a leaf value or an open map. +type ConfigField struct { + // Path is the dotted key, e.g. "dns.nameservers.global". + Path string + Field reflect.StructField + // Value is the field in the walked Config; it is settable. + Value reflect.Value + // Open marks a map, whose keys the user chooses. + Open bool +} + +var textUnmarshalerType = reflect.TypeFor[encoding.TextUnmarshaler]() + +// ConfigFields lists every leaf and open map of cfg reachable through koanf +// tags, in declaration order. A struct is a leaf when *T unmarshals text; +// otherwise it is descended into. Fields tagged koanf:"-" are skipped. +func ConfigFields(cfg *Config) []ConfigField { + return appendConfigFields(nil, "", reflect.ValueOf(cfg).Elem()) +} + +func appendConfigFields(fields []ConfigField, prefix string, v reflect.Value) []ConfigField { + for f, fv := range v.Fields() { + name := f.Tag.Get("koanf") + if !f.IsExported() || name == "" || name == "-" { + continue + } + + path := prefix + name + + if f.Type.Kind() == reflect.Struct && !reflect.PointerTo(f.Type).Implements(textUnmarshalerType) { + fields = appendConfigFields(fields, path+".", fv) + + continue + } + + fields = append(fields, ConfigField{ + Path: path, + Field: f, + Value: fv, + Open: f.Type.Kind() == reflect.Map, + }) + } + + return fields +} diff --git a/hscontrol/types/config_fields_test.go b/hscontrol/types/config_fields_test.go new file mode 100644 index 000000000..979ff52c5 --- /dev/null +++ b/hscontrol/types/config_fields_test.go @@ -0,0 +1,173 @@ +package types + +import ( + "reflect" + "testing" + + "github.com/google/go-cmp/cmp" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestConfigFields(t *testing.T) { + // Written out, not derived from the loader's key tables, so it pins the + // schema on its own. + wantPaths := []string{ + "server_url", + "listen_addr", + "metrics_listen_addr", + "unix_socket", + "unix_socket_permission", + "trusted_proxies", + "disable_check_updates", + "noise.private_key_path", + "prefixes.v4", + "prefixes.v6", + "prefixes.allocation", + "policy.path", + "policy.mode", + "log.level", + "log.format", + "node.expiry", + "node.ephemeral.inactivity_timeout", + "node.routes.ha.probe_interval", + "node.routes.ha.probe_timeout", + "preauth_keys.revoked_retention", + "derp.server.enabled", + "derp.server.region_id", + "derp.server.region_code", + "derp.server.region_name", + "derp.server.verify_clients", + "derp.server.stun_listen_addr", + "derp.server.private_key_path", + "derp.server.ipv4", + "derp.server.ipv6", + "derp.server.automatically_add_embedded_derp_region", + "derp.urls", + "derp.paths", + "derp.auto_update_enabled", + "derp.update_frequency", + "database.type", + "database.debug", + "database.gorm.slow_threshold", + "database.gorm.skip_err_record_not_found", + "database.gorm.parameterized_queries", + "database.sqlite.path", + "database.sqlite.write_ahead_log", + "database.sqlite.wal_autocheckpoint", + "database.postgres.host", + "database.postgres.port", + "database.postgres.name", + "database.postgres.user", + "database.postgres.pass", + "database.postgres.ssl", + "database.postgres.max_open_conns", + "database.postgres.max_idle_conns", + "database.postgres.conn_max_idle_time_secs", + "dns.magic_dns", + "dns.base_domain", + "dns.override_local_dns", + "dns.nameservers.global", + "dns.nameservers.split", + "dns.search_domains", + "dns.extra_records", + "dns.extra_records_path", + "dns.certificates.enabled", + "dns.certificates.zone", + "dns.challenge.propagation_timeout", + "dns.challenge.resolvers", + "dns.challenge.provider", + "tls.cert_path", + "tls.key_path", + "tls.acme.hostname", + "tls.acme.challenge_type", + "tls.acme.http_listen", + "tls.acme.url", + "tls.acme.email", + "tls.acme.cache_dir", + "oidc.only_start_if_oidc_is_available", + "oidc.issuer", + "oidc.client_id", + "oidc.client_secret", + "oidc.scope", + "oidc.extra_params", + "oidc.allowed_domains", + "oidc.allowed_users", + "oidc.allowed_groups", + "oidc.email_verified_required", + "oidc.use_expiry_from_token", + "oidc.pkce.enabled", + "oidc.pkce.method", + "logtail.enabled", + "taildrop.enabled", + "auto_update.enabled", + "cli.address", + "cli.api_key", + "cli.timeout", + "cli.insecure", + "tuning.notifier_send_timeout", + "tuning.batch_change_delay", + "tuning.node_mapsession_buffered_chan_size", + "tuning.batcher_workers", + "tuning.register_cache_expiration", + "tuning.register_cache_max_entries", + "tuning.node_store_batch_size", + "tuning.node_store_batch_timeout", + } + // dns.extra_records is a list, a leaf like any other. + wantOpen := []string{"dns.nameservers.split", "dns.challenge.provider", "oidc.extra_params"} + + var cfg Config + + fields := ConfigFields(&cfg) + gotPaths := make([]string, 0, len(fields)) + + var gotOpen []string + + for _, f := range fields { + gotPaths = append(gotPaths, f.Path) + if f.Open { + gotOpen = append(gotOpen, f.Path) + } + } + + if diff := cmp.Diff(wantPaths, gotPaths); diff != "" { + t.Errorf("ConfigFields paths (-want +got):\n%s", diff) + } + + assert.Equal(t, wantOpen, gotOpen) + + t.Run("values are the config's fields", func(t *testing.T) { + require.Equal(t, "server_url", fields[0].Path) + require.True(t, fields[0].Value.CanSet()) + + fields[0].Value.SetString("https://h") + assert.Equal(t, "https://h", cfg.ServerURL) + assert.Equal(t, "ServerURL", fields[0].Field.Name) + }) + + t.Run("every exported field has a koanf tag", func(t *testing.T) { + var check func(reflect.Type, string) + + check = func(typ reflect.Type, at string) { + for f := range typ.Fields() { + tag := f.Tag.Get("koanf") + if !f.IsExported() || tag == "-" { + continue + } + + if tag == "" { + t.Errorf("%s.%s has no koanf tag", at, f.Name) + + continue + } + + if f.Type.Kind() == reflect.Struct { + check(f.Type, at+"."+f.Name) + } + } + } + + check(reflect.TypeFor[Config](), "Config") + }) +} diff --git a/hscontrol/types/config_source_test.go b/hscontrol/types/config_source_test.go index 0e348f92f..249b07b39 100644 --- a/hscontrol/types/config_source_test.go +++ b/hscontrol/types/config_source_test.go @@ -685,16 +685,16 @@ dns: require.NoError(t, LoadConfig(dir, false)) assert.Empty(t, src.Warnings()) - cfg, err := CheckServerConfig() + cfg, err := LoadServerConfig() require.NoError(t, err) if len(tt.want) == 0 { - assert.Empty(t, cfg.DNSChallenge.ProviderSettings) + assert.Empty(t, cfg.DNSConfig.Challenge.ProviderSettings) return } - assert.Equal(t, tt.want, cfg.DNSChallenge.ProviderSettings) + assert.Equal(t, tt.want, cfg.DNSConfig.Challenge.ProviderSettings) }) } } diff --git a/hscontrol/types/config_test.go b/hscontrol/types/config_test.go index 43a456085..eae59f8e1 100644 --- a/hscontrol/types/config_test.go +++ b/hscontrol/types/config_test.go @@ -194,7 +194,7 @@ func TestReadConfig(t *testing.T) { return map[string]string{ "server_url": cfg.ServerURL, - "base_domain": cfg.BaseDomain, + "base_domain": cfg.DNSConfig.BaseDomain, }, err }, want: map[string]string{ @@ -589,10 +589,6 @@ prefixes: v4: not-a-cidr v6: also-not-a-cidr allocation: bogus -oidc: - issuer: https://idp.example.com - client_id: headscale - client_secret: file:/nonexistent/secret noise: private_key_path: noise_private.key database: @@ -617,8 +613,6 @@ dns: // Sentinels stay reachable through ConfigError.Cause. require.ErrorIs(t, err, ErrInvalidAllocationStrategy, "wrapped ErrInvalidAllocationStrategy not in chain") - require.ErrorIs(t, err, os.ErrNotExist, - "wrapped secret read error not in chain") // Each sub-builder failure surfaces its YAML key in the rendered output. rendered := err.Error() @@ -626,7 +620,6 @@ dns: "prefixes.v4", "prefixes.v6", "prefixes.allocation", - "oidc.client_secret", } { assert.Contains(t, rendered, want, "expected rendered error to mention %q", want) @@ -898,17 +891,11 @@ func TestRemovedKeysAreRejected(t *testing.T) { } } -// TestConfigSecrets pins that the secret settings take a value or file:, -// read only by the consumer that uses the secret. +// TestConfigSecrets pins that the loaders keep each secret as written, a +// value or file:, and read no file: its consumer does +// (TestNewHeadscaleSecrets, TestCLIAPIKey). func TestConfigSecrets(t *testing.T) { - dir := t.TempDir() - for _, name := range []string{"oidc", "pg", "api"} { - require.NoError(t, os.WriteFile(filepath.Join(dir, name), []byte(name+"-from-file\n"), 0o600)) - } - - require.NoError(t, os.WriteFile(filepath.Join(dir, "empty"), []byte(" \n"), 0o600)) - - missing := "file:" + filepath.Join(dir, "missing") + missing := "file:" + filepath.Join(t.TempDir(), "missing") base := `--- server_url: https://headscale.example.com @@ -917,121 +904,36 @@ noise: prefixes: v4: 100.64.0.0/10 database: - type: sqlite + type: postgres dns: magic_dns: false override_local_dns: false +cli: + address: headscale.example.com:443 oidc: issuer: https://idp.example.com client_id: headscale ` - // Postgres and a remote CLI are the consumers of the other two secrets. - active := map[string]string{ - "HEADSCALE_DATABASE_TYPE": "postgres", - "HEADSCALE_CLI_ADDRESS": "headscale.example.com:443", - } - tests := []struct { - name string - yaml string - env map[string]string - want [3]string // server oidc.client_secret, server database.postgres.pass, CLI cli.api_key - wantErr string // from LoadServerConfig - wantCLIErr string - }{ - { - name: "literal values", - yaml: base + " client_secret: oidc\n", - env: map[string]string{"HEADSCALE_DATABASE_POSTGRES_PASS": "pg", "HEADSCALE_CLI_API_KEY": "api"}, - want: [3]string{"oidc", "pg", "api"}, - }, - { - name: "file values for active consumers", - yaml: base + " client_secret: file:" + filepath.Join(dir, "oidc") + "\n", - //nolint:gosec // paths to test files, not credentials - env: map[string]string{ - "HEADSCALE_DATABASE_TYPE": active["HEADSCALE_DATABASE_TYPE"], - "HEADSCALE_CLI_ADDRESS": active["HEADSCALE_CLI_ADDRESS"], - "SECRET_DIR": dir, - "HEADSCALE_DATABASE_POSTGRES_PASS": "file:$SECRET_DIR/pg", - "HEADSCALE_CLI_API_KEY": "file:${SECRET_DIR}/api", - }, - want: [3]string{"oidc-from-file", "pg-from-file", "api-from-file"}, - }, - { - // sqlite and the unix socket use neither secret. - name: "inactive consumers read nothing", - yaml: base + " client_secret: oidc\n", - env: map[string]string{"HEADSCALE_DATABASE_POSTGRES_PASS": missing, "HEADSCALE_CLI_API_KEY": missing}, - want: [3]string{"oidc", missing, missing}, - }, - { - // OIDC is active only with an issuer. - name: "inactive oidc reads nothing", - yaml: strings.Replace(base, " issuer: https://idp.example.com\n", "", 1) + " client_secret: " + missing + "\n", - want: [3]string{missing, "", ""}, - }, - { - name: "missing oidc file", - yaml: base + " client_secret: " + missing + "\n", - wantErr: "oidc.client_secret cannot be read", - }, - { - name: "empty oidc file", - yaml: base + " client_secret: file:" + filepath.Join(dir, "empty") + "\n", - wantErr: "oidc.client_secret", - }, - { - name: "missing postgres file", - yaml: base + " client_secret: oidc\n", - env: map[string]string{ - "HEADSCALE_DATABASE_TYPE": active["HEADSCALE_DATABASE_TYPE"], - "HEADSCALE_DATABASE_POSTGRES_PASS": missing, - }, - wantErr: "database.postgres.pass cannot be read", - }, - { - name: "missing api key file for a remote CLI", - yaml: base + " client_secret: oidc\n", - env: map[string]string{ - "HEADSCALE_CLI_ADDRESS": active["HEADSCALE_CLI_ADDRESS"], - "HEADSCALE_CLI_API_KEY": missing, - }, - wantCLIErr: "cli.api_key cannot be read", - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - for k, v := range tt.env { - t.Setenv(k, v) - } + for name, value := range map[string]string{"literal": "literal", "missing file": missing} { + t.Run(name, func(t *testing.T) { + t.Setenv("HEADSCALE_DATABASE_POSTGRES_PASS", value) + t.Setenv("HEADSCALE_CLI_API_KEY", value) tmpDir := t.TempDir() - require.NoError(t, os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(tt.yaml), 0o600)) + require.NoError(t, os.WriteFile(filepath.Join(tmpDir, "config.yaml"), []byte(base+" client_secret: "+value+"\n"), 0o600)) require.NoError(t, LoadConfig(tmpDir, false)) cfg, err := LoadServerConfig() - if tt.wantErr != "" { - require.ErrorContains(t, err, tt.wantErr) - - return - } - require.NoError(t, err) - - // The server never uses the CLI's key, so never reads it. + assert.Equal(t, Secret(value), cfg.OIDC.ClientSecret) + assert.Equal(t, Secret(value), cfg.Database.Postgres.Pass) + // The server never uses the CLI's key. assert.Empty(t, cfg.CLI.APIKey) cli, err := LoadCLIConfig() - if tt.wantCLIErr != "" { - require.ErrorContains(t, err, tt.wantCLIErr) - - return - } - require.NoError(t, err) - assert.Equal(t, tt.want, [3]string{cfg.OIDC.ClientSecret, cfg.Database.Postgres.Pass, cli.CLI.APIKey}) + assert.Equal(t, Secret(value), cli.CLI.APIKey) }) } } @@ -1044,7 +946,7 @@ func TestUnixSocketPermission(t *testing.T) { name string yaml string env string - want fs.FileMode + want FileMode wantErr bool }{ {name: "unset-uses-default", want: 0o770}, @@ -1245,9 +1147,9 @@ func TestSafeServerURLWithPort(t *testing.T) { } // TestConfigJSONOmitsSecrets verifies that marshalling a [Config] to JSON -// (as /debug/config does via [state.State.DebugConfig]) does not leak the -// Postgres password, the OIDC client secret, or the headscale admin -// API key. Operators who widen metrics_listen_addr to 0.0.0.0 should +// (as /debug/config does via [state.State.DebugConfig]) or logging it does +// not leak the Postgres password, the OIDC client secret, or the headscale +// admin API key. Operators who widen metrics_listen_addr to 0.0.0.0 should // not be able to read these back via debug endpoints reachable over // CGNAT/loopback. func TestConfigJSONOmitsSecrets(t *testing.T) { @@ -1256,6 +1158,10 @@ func TestConfigJSONOmitsSecrets(t *testing.T) { secretClientSecret = "oidc-client-secret-marker" //nolint:gosec // test marker, not a real credential secretAPIKey = "headscale-cli-api-key-marker" //nolint:gosec // test marker, not a real credential secretDNSToken = "dns-provider-token-marker" //nolint:gosec // test marker, not a real credential + secretDERPUser = "derp-url-username-marker" //nolint:gosec // test marker, not a real credential + secretDERPPass = "derp-url-password-marker" //nolint:gosec // test marker, not a real credential + secretDERPToken = "derp-url-token-marker" //nolint:gosec // test marker, not a real credential + derpMapMarker = "go-only-derp-map-marker" ) cfg := &Config{ @@ -1270,20 +1176,59 @@ func TestConfigJSONOmitsSecrets(t *testing.T) { CLI: CLIConfig{ APIKey: secretAPIKey, }, - DNSChallenge: DNSChallengeConfig{ + DNSConfig: DNSConfig{Challenge: DNSChallengeConfig{ ProviderSettings: map[string]any{"name": "cloudflare", "api_token": secretDNSToken}, Provider: &cloudflare.Provider{APIToken: secretDNSToken}, + }}, + DERP: DERPConfig{ + URLs: []HTTPURL{ + "https://" + secretDERPUser + ":" + secretDERPPass + "@derp.example/map", + "https://" + secretDERPToken + "@derp.example/token-map", + }, + DERPMap: &tailcfg.DERPMap{Regions: map[tailcfg.DERPRegionID]*tailcfg.DERPRegion{ + 900: {RegionCode: derpMapMarker}, + }}, }, } + secrets := []string{ + secretPostgresPass, secretClientSecret, secretAPIKey, secretDNSToken, + secretDERPUser, secretDERPPass, secretDERPToken, + } + out, err := json.Marshal(cfg) require.NoError(t, err) - body := string(out) - for _, secret := range []string{secretPostgresPass, secretClientSecret, secretAPIKey, secretDNSToken} { - assert.NotContains(t, body, secret, + for _, secret := range secrets { + assert.NotContains(t, string(out), secret, "marshalled Config must not contain secret %q", secret) } + + // The URLs are still shown, without userinfo; the request keeps it. + assert.Contains(t, string(out), `"https://derp.example/map"`) + assert.Contains(t, string(out), `"https://derp.example/token-map"`) + assert.Contains(t, string(cfg.DERP.URLs[0]), secretDERPUser+":"+secretDERPPass) + assert.Contains(t, string(cfg.DERP.URLs[1]), secretDERPToken) + // DERPMap is Go-only. + assert.NotContains(t, string(out), derpMapMarker) + + // Secret redacts only through fmt's String; zerolog marshals it. Test + // binaries log at Error (testlog.go), which would drop this record. + oldLevel := zerolog.GlobalLevel() + + t.Cleanup(func() { zerolog.SetGlobalLevel(oldLevel) }) + zerolog.SetGlobalLevel(zerolog.InfoLevel) + + var logged bytes.Buffer + + logger := zerolog.New(&logged) + logger.Info().Interface("config", cfg).Send() + require.Contains(t, logged.String(), `"config":{`) + + for _, secret := range secrets { + assert.NotContains(t, logged.String(), secret, + "logged Config must not contain secret %q", secret) + } } //nolint:goconst // repeated CIDR strings are test fixtures, not refactor candidates @@ -1457,7 +1402,7 @@ func TestTailcfgDNSConfig(t *testing.T) { { name: "magic dns reverse routes outside cgnat", cfg: Config{ - PrefixV4: &ten, + Prefixes: PrefixesConfig{V4: &ten}, DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"}, }, want: &tailcfg.DNSConfig{ @@ -1469,7 +1414,7 @@ func TestTailcfgDNSConfig(t *testing.T) { { name: "magic dns reverse routes outside ula", cfg: Config{ - PrefixV6: &fd00, + Prefixes: PrefixesConfig{V6: &fd00}, DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"}, }, want: &tailcfg.DNSConfig{ @@ -1481,8 +1426,7 @@ func TestTailcfgDNSConfig(t *testing.T) { { name: "magic dns inside cgnat and ula", cfg: Config{ - PrefixV4: &cgnat, - PrefixV6: &ula, + Prefixes: PrefixesConfig{V4: &cgnat, V6: &ula}, DNSConfig: DNSConfig{MagicDNS: true, BaseDomain: "example.com"}, }, want: &tailcfg.DNSConfig{ @@ -1493,7 +1437,7 @@ func TestTailcfgDNSConfig(t *testing.T) { }, { name: "no reverse routes without magic dns", - cfg: Config{PrefixV4: &ten}, + cfg: Config{Prefixes: PrefixesConfig{V4: &ten}}, want: &tailcfg.DNSConfig{Routes: map[string][]*dnstype.Resolver{}}, }, { @@ -1525,8 +1469,8 @@ func TestLiveDNS(t *testing.T) { MagicDNS: true, BaseDomain: "example.com", ExtraRecords: []tailcfg.DNSRecord{{Name: "Old.example.com", Type: "A", Value: "100.64.0.1"}}, + Challenge: DNSChallengeConfig{Provider: goOnly}, }, - DNSChallenge: DNSChallengeConfig{Provider: goOnly}, } assert.Equal(t, cfg.TailcfgDNSConfig(), cfg.CloneTailcfgDNSConfig()) @@ -1589,7 +1533,7 @@ dns: zerolog.SetGlobalLevel(oldLevel) }) - cfg, err := CheckServerConfig() + cfg, err := LoadServerConfig() require.NoError(t, err) logged := buf.String() @@ -1627,7 +1571,7 @@ dns: yaml string env map[string]string wantErr string - fileErr bool // only reading a file: secret fails, so CheckServerConfig passes + fileErr bool // only reading a file: secret fails, so the load passes wantWarns []string wantZone string wantToken string @@ -1722,7 +1666,7 @@ dns: fileErr: true, }, { - // Unread by CheckServerConfig, a file: setting counts as present. + // Unread by the load, a file: setting counts as present. name: "token file missing", yaml: base + ` challenge: provider: @@ -2057,38 +2001,39 @@ tls: assert.Contains(t, src.Warnings()[i], w) } - _, checkErr := CheckServerConfig() - if tt.wantErr != "" && !tt.fileErr { - require.ErrorContains(t, checkErr, tt.wantErr) - assert.NotContains(t, checkErr.Error(), "marker-") - } else { - require.NoError(t, checkErr) - } - cfg, err := LoadServerConfig() - if tt.wantErr != "" { + if tt.wantErr != "" && !tt.fileErr { require.ErrorContains(t, err, tt.wantErr) + assert.NotContains(t, err.Error(), "marker-") return } require.NoError(t, err) - assert.Equal(t, tt.wantZone, cfg.DNSConfig.CertificateZone()) - if tt.wantResolvers != nil { - assert.Equal(t, tt.wantResolvers, cfg.DNSChallenge.ResolverAddrs()) - } - - // The loader only validates the provider; startup builds it. - assert.Nil(t, cfg.DNSChallenge.Provider) - - if tt.wantNoProv { - assert.Empty(t, cfg.DNSChallenge.ProviderName()) + if tt.fileErr { + _, err = cfg.DNSConfig.Challenge.NewProvider(ResolveSecret) + require.ErrorContains(t, err, tt.wantErr) return } - built, err := cfg.DNSChallenge.NewProvider(ResolveSecret) + assert.Equal(t, tt.wantZone, cfg.DNSConfig.CertificateZone()) + + if tt.wantResolvers != nil { + assert.Equal(t, tt.wantResolvers, cfg.DNSConfig.Challenge.ResolverAddrs()) + } + + // The loader only validates the provider; startup builds it. + assert.Nil(t, cfg.DNSConfig.Challenge.Provider) + + if tt.wantNoProv { + assert.Empty(t, cfg.DNSConfig.Challenge.ProviderName()) + + return + } + + built, err := cfg.DNSConfig.Challenge.NewProvider(ResolveSecret) require.NoError(t, err) if tt.wantProvider != "" { @@ -2324,7 +2269,7 @@ func TestPostgresConfigDSN(t *testing.T) { func TestServesRoute(t *testing.T) { v4 := netip.MustParsePrefix("100.64.0.0/10") v6 := netip.MustParsePrefix("fd7a:115c:a1e0::/48") - cfg := &Config{PrefixV4: &v4, PrefixV6: &v6} + cfg := &Config{Prefixes: PrefixesConfig{V4: &v4, V6: &v6}} for route, want := range map[string]bool{ "100.64.0.11/32": false, @@ -2348,7 +2293,7 @@ func TestServesRoute(t *testing.T) { // Only the configured ranges hold nodes. narrow := netip.MustParsePrefix("100.64.0.0/24") - assert.True(t, (&Config{PrefixV4: &narrow}).ServesRoute(netip.MustParsePrefix("100.100.0.1/32"))) + assert.True(t, (&Config{Prefixes: PrefixesConfig{V4: &narrow}}).ServesRoute(netip.MustParsePrefix("100.100.0.1/32"))) } func TestBoolConfigValidation(t *testing.T) { @@ -2854,21 +2799,30 @@ type compatTuning struct { func compatView(cfg *Config) compatConfig { pg := cfg.Database.Postgres oidc := cfg.OIDC - ch := cfg.DNSChallenge + ch := cfg.DNSConfig.Challenge acme := cfg.TLS.ACME + derp := cfg.DERP.Server dbType := cfg.Database.Type if cfg.Database.IsSQLite() { dbType = DatabaseSqlite } + derpURLs := make([]url.URL, 0, len(cfg.DERP.URLs)) + for _, s := range cfg.DERP.URLs { + u, err := url.Parse(string(s)) + if err == nil { + derpURLs = append(derpURLs, *u) + } + } + tuning := compatTuning(cfg.Tuning) tuning.BatcherWorkers = cfg.Tuning.BatcherWorkerCount() return compatConfig{ ServerURL: cfg.ServerURL, - Addr: cfg.Addr, - MetricsAddr: cfg.MetricsAddr, + Addr: string(cfg.Addr), + MetricsAddr: string(cfg.MetricsAddr), TrustedProxies: cfg.TrustedProxies, Node: compatNodeConfig{ Expiry: cfg.Node.Expiry, @@ -2876,17 +2830,25 @@ func compatView(cfg *Config) compatConfig { Routes: compatRouteConfig{HA: compatHARouteConfig(cfg.Node.Routes.HA)}, }, PreAuthKeys: compatPreAuthKeysConfig(cfg.PreAuthKeys), - PrefixV4: cfg.PrefixV4, - PrefixV6: cfg.PrefixV6, - IPAllocation: string(cfg.IPAllocation), - NoisePrivateKeyPath: cfg.AbsPath(cfg.NoisePrivateKeyPath), - BaseDomain: cfg.BaseDomain, - Log: compatLogConfig(cfg.Log), - DisableUpdateCheck: cfg.DisableUpdateCheck, + PrefixV4: cfg.Prefixes.V4, + PrefixV6: cfg.Prefixes.V6, + IPAllocation: string(cfg.Prefixes.Allocation), + NoisePrivateKeyPath: cfg.AbsPath(cfg.Noise.PrivateKeyPath), + BaseDomain: cfg.DNSConfig.BaseDomain, + Log: compatLogConfig{ + Format: string(cfg.Log.Format), + Level: cfg.Log.Level.Zerolog(), + }, + DisableUpdateCheck: cfg.DisableUpdateCheck, Database: compatDatabaseConfig{ - Type: dbType, + Type: string(dbType), Debug: cfg.Database.Debug, - Gorm: compatGormConfig(cfg.Database.Gorm), + Gorm: compatGormConfig{ + Debug: cfg.Database.Debug, + SlowThreshold: time.Duration(cfg.Database.Gorm.SlowThreshold) * time.Millisecond, + SkipErrRecordNotFound: cfg.Database.Gorm.SkipErrRecordNotFound, + ParameterizedQueries: cfg.Database.Gorm.ParameterizedQueries, + }, Sqlite: compatSqliteConfig{ Path: cfg.SQLitePath(), WriteAheadLog: cfg.Database.Sqlite.WriteAheadLog, @@ -2904,30 +2866,30 @@ func compatView(cfg *Config) compatConfig { }, }, DERP: compatDERPConfig{ - ServerEnabled: cfg.DERP.ServerEnabled, - AutomaticallyAddEmbeddedDerpRegion: cfg.DERP.AutomaticallyAddEmbeddedDerpRegion, - ServerRegionID: cfg.DERP.ServerRegionID, - ServerRegionCode: cfg.DERP.ServerRegionCode, - ServerRegionName: cfg.DERP.ServerRegionName, - ServerPrivateKeyPath: cfg.AbsPath(cfg.DERP.ServerPrivateKeyPath), - ServerVerifyClients: cfg.DERP.ServerVerifyClients, - STUNAddr: cfg.DERP.STUNAddr, - URLs: cfg.DERP.URLs, + ServerEnabled: derp.Enabled, + AutomaticallyAddEmbeddedDerpRegion: derp.AutomaticallyAddEmbeddedDerpRegion, + ServerRegionID: derp.RegionID, + ServerRegionCode: derp.RegionCode, + ServerRegionName: derp.RegionName, + ServerPrivateKeyPath: cfg.AbsPath(derp.PrivateKeyPath), + ServerVerifyClients: derp.VerifyClients, + STUNAddr: string(derp.STUNAddr), + URLs: derpURLs, Paths: cfg.DERP.Paths, DERPMap: cfg.DERP.DERPMap, AutoUpdate: cfg.DERP.AutoUpdate, UpdateFrequency: cfg.DERP.UpdateFrequency, - IPv4: cfg.DERP.IPv4, - IPv6: cfg.DERP.IPv6, + IPv4: derp.IPv4, + IPv6: derp.IPv6, }, TLS: compatTLSConfig{ CertPath: cfg.AbsPath(cfg.TLS.CertPath), KeyPath: cfg.AbsPath(cfg.TLS.KeyPath), ACME: compatACMEConfig{ Hostname: acme.Hostname, - ChallengeType: acme.ChallengeType, - HTTPListen: acme.HTTPListen, - URL: acme.URL, + ChallengeType: string(acme.ChallengeType), + HTTPListen: string(acme.HTTPListen), + URL: string(acme.URL), Email: acme.Email, CacheDir: cfg.AbsPath(acme.CacheDir), }, @@ -2952,10 +2914,10 @@ func compatView(cfg *Config) compatConfig { ProviderName: ch.ProviderName(), }, UnixSocket: cfg.UnixSocket, - UnixSocketPermission: cfg.UnixSocketPermission, + UnixSocketPermission: fs.FileMode(cfg.UnixSocketPermission), OIDC: compatOIDCConfig{ OnlyStartIfOIDCIsAvailable: oidc.OnlyStartIfOIDCIsAvailable, - Issuer: oidc.Issuer, + Issuer: string(oidc.Issuer), ClientID: oidc.ClientID, Scope: oidc.Scope, ExtraParams: oidc.ExtraParams, @@ -2964,7 +2926,7 @@ func compatView(cfg *Config) compatConfig { AllowedGroups: oidc.AllowedGroups, EmailVerifiedRequired: oidc.EmailVerifiedRequired, UseExpiryFromToken: oidc.UseExpiryFromToken, - PKCE: compatPKCEConfig(oidc.PKCE), + PKCE: compatPKCEConfig{Enabled: oidc.PKCE.Enabled, Method: string(oidc.PKCE.Method)}, }, LogTail: compatLogTailConfig(cfg.LogTail), Taildrop: compatTaildropConfig(cfg.Taildrop), @@ -3057,10 +3019,21 @@ func loadCompat(t *testing.T, file, envFile string, cli bool) compatRecord { require.NoError(t, err) rec.Config = json.RawMessage(norm(string(raw))) + // As its consumer reads it; one no consumer reads stays as written. + secret := func(s Secret, active bool) string { + if !active { + return string(s) + } + + v, err := s.Resolve() + require.NoError(t, err) + + return v + } rec.Secrets = map[string]string{ - "database.postgres.pass": cfg.Database.Postgres.Pass, - "oidc.client_secret": cfg.OIDC.ClientSecret, - "cli.api_key": cfg.CLI.APIKey, + "database.postgres.pass": secret(cfg.Database.Postgres.Pass, cfg.Database.Type == DatabasePostgres), + "oidc.client_secret": secret(cfg.OIDC.ClientSecret, cfg.OIDC.Issuer != ""), + "cli.api_key": secret(cfg.CLI.APIKey, cfg.CLI.Address != ""), } maps.DeleteFunc(rec.Secrets, func(_, v string) bool { return v == "" }) } @@ -3195,8 +3168,6 @@ func TestConfigNotLoaded(t *testing.T) { _, err := LoadServerConfig() require.ErrorIs(t, err, errConfigNotLoaded) - _, err = CheckServerConfig() - require.ErrorIs(t, err, errConfigNotLoaded) _, err = LoadCLIConfig() require.ErrorIs(t, err, errConfigNotLoaded) @@ -3244,8 +3215,8 @@ dns: cfg, err := LoadServerConfig() require.NoError(t, err) - assert.Equal(t, "./noise.key", cfg.NoisePrivateKeyPath) - assert.Equal(t, filepath.Join(dir, "noise.key"), cfg.AbsPath(cfg.NoisePrivateKeyPath)) + assert.Equal(t, "./noise.key", cfg.Noise.PrivateKeyPath) + assert.Equal(t, filepath.Join(dir, "noise.key"), cfg.AbsPath(cfg.Noise.PrivateKeyPath)) assert.Equal(t, "./policy.hujson", cfg.Policy.Path) assert.Equal(t, filepath.Join(dir, "policy.hujson"), cfg.AbsPath(cfg.Policy.Path)) } @@ -3277,7 +3248,7 @@ func TestSQLiteMemoryPath(t *testing.T) { cfg, err := LoadServerConfig() require.NoError(t, err) assert.Equal(t, ":memory:", cfg.SQLitePath()) - assert.True(t, filepath.IsAbs(cfg.AbsPath(cfg.NoisePrivateKeyPath)), cfg.AbsPath(cfg.NoisePrivateKeyPath)) + assert.True(t, filepath.IsAbs(cfg.AbsPath(cfg.Noise.PrivateKeyPath)), cfg.AbsPath(cfg.Noise.PrivateKeyPath)) }) } } diff --git a/hscontrol/types/config_values.go b/hscontrol/types/config_values.go new file mode 100644 index 000000000..8b010651b --- /dev/null +++ b/hscontrol/types/config_values.go @@ -0,0 +1,267 @@ +package types + +import ( + "encoding/json" + "fmt" + "io/fs" + "net/url" + "os" + "slices" + "strings" + + "github.com/juanfont/headscale/hscontrol/util" + "github.com/rs/zerolog" +) + +// Parse errors of the value types below are *ConfigError without the key; +// the loader adds the key and where the value came from. + +// Secret is a credential as written: a literal, or "file:" naming +// the file that holds it (Tailscale's form), which keeps the secret out of +// the config and the environment. Only fmt's String path redacts; JSON, +// %#v and zerolog's Interface print the raw value. +type Secret string + +// Resolve returns the literal, or the trimmed contents of the file. The +// path is expanded so a systemd credential can be named by +// ${CREDENTIALS_DIRECTORY}. Errors name the path; callers add the key. +func (s Secret) Resolve() (string, error) { + path, ok := strings.CutPrefix(string(s), "file:") + if !ok { + return string(s), nil + } + + path = os.ExpandEnv(path) + + b, err := os.ReadFile(path) + if err != nil { + return "", err + } + + // An empty file is a credential that was not written, not a choice. + secret := strings.TrimSpace(string(b)) + if secret == "" { + return "", fmt.Errorf("%s: %w", path, errSecretEmpty) + } + + return secret, nil +} + +// IsFile reports whether s names a file. +func (s Secret) IsFile() bool { return strings.HasPrefix(string(s), "file:") } + +// Redacted returns s safe to show: a file reference as written, a literal +// as . +func (s Secret) Redacted() string { + if s == "" || s.IsFile() { + return string(s) + } + + return "" +} + +func (s Secret) String() string { return s.Redacted() } + +// FileMode is a permission written as quoted octal text ("0770", "0o770"). +type FileMode fs.FileMode + +func (m *FileMode) UnmarshalText(text []byte) error { + mode, err := util.ParseFileMode(string(text)) + if err != nil { + return &ConfigError{ + Reason: "is not a quoted octal file mode", + Maximum: `"0777"`, + Hint: `quote the value, e.g. "0770"; unquoted, YAML reads 0770 as the number 504`, + Cause: err, + } + } + + *m = FileMode(mode) + + return nil +} + +func (m FileMode) MarshalText() ([]byte, error) { + return fmt.Appendf(nil, "%04o", uint32(m)), nil +} + +// HTTPURL is "" or an absolute http:// or https:// URL with a hostname, kept +// as written. JSON shows it without userinfo; it has no MarshalText, so the +// text form stays as written. +type HTTPURL string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value + +// MarshalJSON writes u without userinfo, for debug output and logs: a +// username can be a token too. One that does not parse is withheld, as its +// userinfo cannot be found. +func (u HTTPURL) MarshalJSON() ([]byte, error) { + s := string(u) + if s != "" { + p, err := url.Parse(s) + if err != nil { + s = "" + } else { + p.User = nil + s = p.String() + } + } + + return json.Marshal(s) +} + +func (u *HTTPURL) UnmarshalText(text []byte) error { + s := string(text) + if s != "" { + p, err := url.Parse(s) + if err != nil || (p.Scheme != "http" && p.Scheme != "https") || p.Hostname() == "" { + e := &ConfigError{ + Reason: "is not an http:// or https:// URL", + Hint: `write the scheme and host, e.g. "https://example.com"`, + } + if err != nil { + // Not the parser's error: it quotes the URL, userinfo included. + e.Cause = errURLSyntax + } + + return e + } + } + + *u = HTTPURL(s) + + return nil +} + +// ListenAddr is "" or a TCP host:port address; the port may be "http" or +// "https". +type ListenAddr string + +func (a *ListenAddr) UnmarshalText(text []byte) error { + s := string(text) + if s != "" { + _, err := PortFromAddr(s) + if err != nil { + return &ConfigError{ + Reason: "is not a host:port address", + Detail: err.Error(), + Hint: `use host:port form, e.g. "0.0.0.0:8080"`, + Cause: err, + } + } + } + + *a = ListenAddr(s) + + return nil +} + +// setEnum stores s in dst when it is "" (unset) or one of allowed; +// otherwise it returns e completed with the allowed values. +func setEnum[T ~string](dst *T, s string, allowed []string, e ConfigError) error { + if s != "" && !slices.Contains(allowed, s) { + e.Reason = "has an unsupported value" + e.Allowed = allowed + + return &e + } + + *dst = T(s) + + return nil +} + +// LogLevel is a zerolog level name, case-insensitive and stored lowercase. +// "" decodes without error to the zero value (unset). +type LogLevel string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value + +func (LogLevel) Allowed() []string { + return []string{"trace", "debug", "info", "warn", "error", "fatal", "panic", "disabled"} +} + +func (l *LogLevel) UnmarshalText(text []byte) error { + return setEnum(l, strings.ToLower(string(text)), l.Allowed(), ConfigError{}) +} + +// Zerolog returns the level: info when unset (zerolog's NoLevel would +// hide every line); one zerolog does not know is debug. +func (l LogLevel) Zerolog() zerolog.Level { + if l == "" { + return zerolog.InfoLevel + } + + lvl, err := zerolog.ParseLevel(string(l)) + if err != nil { + return zerolog.DebugLevel + } + + return lvl +} + +// LogFormat is the log output format. "" decodes without error to the zero +// value (unset). +type LogFormat string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value + +func (LogFormat) Allowed() []string { return []string{string(TextLogFormat), string(JSONLogFormat)} } + +func (f *LogFormat) UnmarshalText(text []byte) error { + return setEnum(f, string(text), f.Allowed(), ConfigError{}) +} + +// DatabaseType is the database backend. "" decodes without error to the +// zero value (unset). +type DatabaseType string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value + +func (DatabaseType) Allowed() []string { + return []string{"sqlite", string(DatabaseSqlite), string(DatabasePostgres)} +} + +func (d *DatabaseType) UnmarshalText(text []byte) error { + return setEnum(d, string(text), d.Allowed(), ConfigError{ + Hint: "pick one of the allowed values; sqlite is the default for single-host deployments", + See: "https://headscale.net/stable/ref/database/", + }) +} + +// ACMEChallenge is the ACME challenge type. "" decodes without error to the +// zero value (unset). +type ACMEChallenge string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value + +func (ACMEChallenge) Allowed() []string { + return []string{string(HTTP01ChallengeType), string(TLSALPN01ChallengeType), string(DNS01ChallengeType)} +} + +func (c *ACMEChallenge) UnmarshalText(text []byte) error { + return setEnum(c, string(text), c.Allowed(), ConfigError{ + Hint: "pick one of the allowed values; HTTP-01 is the default", + }) +} + +// PKCEMethod is the OIDC PKCE challenge method. "" decodes without error to +// the zero value (unset). +type PKCEMethod string //nolint:recvcheck // UnmarshalText needs a pointer; the rest read the value + +func (PKCEMethod) Allowed() []string { + return []string{string(PKCEMethodPlain), string(PKCEMethodS256)} +} + +func (p *PKCEMethod) UnmarshalText(text []byte) error { + return setEnum(p, string(text), p.Allowed(), ConfigError{Cause: errInvalidPKCEMethod}) +} + +func (PolicyMode) Allowed() []string { return []string{string(PolicyModeFile), string(PolicyModeDB)} } + +func (m *PolicyMode) UnmarshalText(text []byte) error { + return setEnum(m, string(text), m.Allowed(), ConfigError{ + See: "https://headscale.net/stable/ref/policy/", + }) +} + +func (IPAllocationStrategy) Allowed() []string { + return []string{string(IPAllocationStrategySequential), string(IPAllocationStrategyRandom)} +} + +func (s *IPAllocationStrategy) UnmarshalText(text []byte) error { + return setEnum(s, string(text), s.Allowed(), ConfigError{ + Hint: "pick one of the allowed values; sequential is the default", + Cause: ErrInvalidAllocationStrategy, + }) +} diff --git a/hscontrol/types/config_values_test.go b/hscontrol/types/config_values_test.go new file mode 100644 index 000000000..bd6cd941f --- /dev/null +++ b/hscontrol/types/config_values_test.go @@ -0,0 +1,276 @@ +package types + +import ( + "encoding" + "encoding/json" + "fmt" + "os" + "path/filepath" + "reflect" + "testing" + + "github.com/google/go-cmp/cmp" + "github.com/rs/zerolog" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/require" +) + +func TestConfigValues(t *testing.T) { + tests := []struct { + name string + // dst is a fresh pointer to decode into. + dst encoding.TextUnmarshaler + in string + want any + // wantErr is a substring of the ConfigError's Reason. + wantErr string + wantSee string + }{ + {name: "filemode/0770", dst: new(FileMode), in: "0770", want: FileMode(0o770)}, + {name: "filemode/0o770", dst: new(FileMode), in: "0o770", want: FileMode(0o770)}, + {name: "filemode/above perm bits", dst: new(FileMode), in: "17777", wantErr: "octal file mode"}, + + {name: "httpurl/empty", dst: new(HTTPURL), in: "", want: HTTPURL("")}, + {name: "httpurl/https", dst: new(HTTPURL), in: "https://h/x", want: HTTPURL("https://h/x")}, + {name: "httpurl/ftp", dst: new(HTTPURL), in: "ftp://h", wantErr: "is not an http:// or https:// URL"}, + {name: "httpurl/no scheme", dst: new(HTTPURL), in: "h.example.com", wantErr: "is not an http:// or https:// URL"}, + {name: "httpurl/host and port", dst: new(HTTPURL), in: "https://h:8443/x", want: HTTPURL("https://h:8443/x")}, + {name: "httpurl/ipv6", dst: new(HTTPURL), in: "http://[::1]:8080", want: HTTPURL("http://[::1]:8080")}, + {name: "httpurl/no host", dst: new(HTTPURL), in: "https://", wantErr: "is not an http:// or https:// URL"}, + {name: "httpurl/port without host", dst: new(HTTPURL), in: "https://:443/x", wantErr: "is not an http:// or https:// URL"}, + {name: "httpurl/http port without host", dst: new(HTTPURL), in: "http://:80", wantErr: "is not an http:// or https:// URL"}, + {name: "httpurl/unparsable", dst: new(HTTPURL), in: "https://alice:pw?@h", wantErr: "is not an http:// or https:// URL"}, + + {name: "listenaddr/empty", dst: new(ListenAddr), in: "", want: ListenAddr("")}, + {name: "listenaddr/port only", dst: new(ListenAddr), in: ":8080", want: ListenAddr(":8080")}, + {name: "listenaddr/named port", dst: new(ListenAddr), in: "0.0.0.0:http", want: ListenAddr("0.0.0.0:http")}, + {name: "listenaddr/no colon", dst: new(ListenAddr), in: "8080", wantErr: "host:port"}, + {name: "listenaddr/bad port", dst: new(ListenAddr), in: "h:abc", wantErr: "host:port"}, + + {name: "loglevel/trace", dst: new(LogLevel), in: "trace", want: LogLevel("trace")}, + {name: "loglevel/debug", dst: new(LogLevel), in: "debug", want: LogLevel("debug")}, + {name: "loglevel/info", dst: new(LogLevel), in: "info", want: LogLevel("info")}, + {name: "loglevel/warn", dst: new(LogLevel), in: "warn", want: LogLevel("warn")}, + {name: "loglevel/error", dst: new(LogLevel), in: "error", want: LogLevel("error")}, + {name: "loglevel/fatal", dst: new(LogLevel), in: "fatal", want: LogLevel("fatal")}, + {name: "loglevel/panic", dst: new(LogLevel), in: "panic", want: LogLevel("panic")}, + {name: "loglevel/disabled", dst: new(LogLevel), in: "disabled", want: LogLevel("disabled")}, + {name: "loglevel/upper case stored lower", dst: new(LogLevel), in: "INFO", want: LogLevel("info")}, + {name: "loglevel/empty", dst: new(LogLevel), in: "", want: LogLevel("")}, + {name: "loglevel/unknown", dst: new(LogLevel), in: "verbose", wantErr: "has an unsupported value"}, + + {name: "logformat/text", dst: new(LogFormat), in: "text", want: LogFormat("text")}, + {name: "logformat/json", dst: new(LogFormat), in: "json", want: LogFormat("json")}, + {name: "logformat/empty", dst: new(LogFormat), in: "", want: LogFormat("")}, + {name: "logformat/unknown", dst: new(LogFormat), in: "yaml", wantErr: "has an unsupported value"}, + + {name: "database/sqlite", dst: new(DatabaseType), in: "sqlite", want: DatabaseType("sqlite")}, + {name: "database/sqlite3", dst: new(DatabaseType), in: "sqlite3", want: DatabaseType("sqlite3")}, + {name: "database/postgres", dst: new(DatabaseType), in: "postgres", want: DatabaseType("postgres")}, + {name: "database/empty", dst: new(DatabaseType), in: "", want: DatabaseType("")}, + {name: "database/unknown", dst: new(DatabaseType), in: "mysql", wantErr: "has an unsupported value", wantSee: "https://headscale.net/stable/ref/database/"}, + + {name: "acme/HTTP-01", dst: new(ACMEChallenge), in: "HTTP-01", want: ACMEChallenge("HTTP-01")}, + {name: "acme/TLS-ALPN-01", dst: new(ACMEChallenge), in: "TLS-ALPN-01", want: ACMEChallenge("TLS-ALPN-01")}, + {name: "acme/DNS-01", dst: new(ACMEChallenge), in: "DNS-01", want: ACMEChallenge("DNS-01")}, + {name: "acme/empty", dst: new(ACMEChallenge), in: "", want: ACMEChallenge("")}, + {name: "acme/case-sensitive", dst: new(ACMEChallenge), in: "http-01", wantErr: "has an unsupported value"}, + + {name: "pkce/plain", dst: new(PKCEMethod), in: "plain", want: PKCEMethod("plain")}, + {name: "pkce/S256", dst: new(PKCEMethod), in: "S256", want: PKCEMethod("S256")}, + {name: "pkce/empty", dst: new(PKCEMethod), in: "", want: PKCEMethod("")}, + {name: "pkce/case-sensitive", dst: new(PKCEMethod), in: "s256", wantErr: "has an unsupported value"}, + + {name: "policy/file", dst: new(PolicyMode), in: "file", want: PolicyMode("file")}, + {name: "policy/database", dst: new(PolicyMode), in: "database", want: PolicyMode("database")}, + {name: "policy/empty", dst: new(PolicyMode), in: "", want: PolicyMode("")}, + {name: "policy/unknown", dst: new(PolicyMode), in: "db", wantErr: "has an unsupported value", wantSee: "https://headscale.net/stable/ref/policy/"}, + + {name: "allocation/sequential", dst: new(IPAllocationStrategy), in: "sequential", want: IPAllocationStrategySequential}, + {name: "allocation/random", dst: new(IPAllocationStrategy), in: "random", want: IPAllocationStrategyRandom}, + {name: "allocation/empty", dst: new(IPAllocationStrategy), in: "", want: IPAllocationStrategy("")}, + {name: "allocation/unknown", dst: new(IPAllocationStrategy), in: "linear", wantErr: "has an unsupported value"}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.dst.UnmarshalText([]byte(tt.in)) + + enum, isEnum := tt.dst.(interface{ Allowed() []string }) + if isEnum { + require.NotContains(t, enum.Allowed(), "", "Allowed lists only named values") + } + + if tt.wantErr == "" { + require.NoError(t, err) + + got := reflect.ValueOf(tt.dst).Elem().Interface() + if diff := cmp.Diff(tt.want, got); diff != "" { + t.Errorf("decoded value mismatch (-want +got):\n%s", diff) + } + + return + } + + require.ErrorIs(t, err, ErrConfig) + + var ce *ConfigError + require.ErrorAs(t, err, &ce) + require.Contains(t, ce.Reason, tt.wantErr) + require.Empty(t, ce.Current, "the loader adds the key") + require.Equal(t, tt.wantSee, ce.See) + + if isEnum { + require.Equal(t, enum.Allowed(), ce.Allowed) + } + }) + } +} + +func TestFileModeMarshalText(t *testing.T) { + tests := []struct { + mode FileMode + want string + }{ + {0, "0000"}, + {0o600, "0600"}, + {0o770, "0770"}, + {0o777, "0777"}, + } + + for _, tt := range tests { + t.Run(tt.want, func(t *testing.T) { + b, err := tt.mode.MarshalText() + require.NoError(t, err) + require.Equal(t, tt.want, string(b)) + + var got FileMode + require.NoError(t, got.UnmarshalText(b)) + require.Equal(t, tt.mode, got, "round trip") + }) + } +} + +func TestHTTPURLMarshalJSON(t *testing.T) { + tests := []struct { + url HTTPURL + want string + }{ + {"", `""`}, + {"https://derp.example/map", `"https://derp.example/map"`}, + {"https://alice:pw-marker@derp.example/map", `"https://derp.example/map"`}, + {"https://token-marker@derp.example/map?x=1", `"https://derp.example/map?x=1"`}, + {"https://alice:pw-marker@derp.example/%zz", `"\u003credacted\u003e"`}, + } + + for _, tt := range tests { + t.Run(string(tt.url), func(t *testing.T) { + b, err := json.Marshal(tt.url) + require.NoError(t, err) + assert.Equal(t, tt.want, string(b)) + }) + } +} + +// TestHTTPURLErrorHidesValue: a URL may hold credentials, so no error in +// the tree of its parse error, nor its JSON, holds the value. +func TestHTTPURLErrorHidesValue(t *testing.T) { + for _, in := range []string{ + "https://alice:marker-pass?@h.example.com", + "https://marker-user:marker-pass@h.example.com/%zz", + "https://marker-user:marker-pass@h.example.com:port", + "ftp://marker-user:marker-pass@h.example.com", + } { + t.Run(in, func(t *testing.T) { + var u HTTPURL + + err := u.UnmarshalText([]byte(in)) + require.Error(t, err) + requireHidden(t, err, "marker") + }) + } +} + +// requireHidden fails when an error in err's tree, its text or its JSON, +// or the JSON of its ConfigErrors holds hidden. +func requireHidden(t *testing.T, err error, hidden string) { + t.Helper() + + walkErrTree(err, func(e error) { + assert.NotContains(t, e.Error(), hidden) + + b, jerr := json.Marshal(e) + require.NoError(t, jerr) + assert.NotContains(t, string(b), hidden) + }) + + b, jerr := json.Marshal(ConfigErrors(err)) + require.NoError(t, jerr) + assert.NotContains(t, string(b), hidden) +} + +func TestLogLevelZerolog(t *testing.T) { + tests := []struct { + level LogLevel + want zerolog.Level + }{ + {"trace", zerolog.TraceLevel}, + {"warn", zerolog.WarnLevel}, + {"disabled", zerolog.Disabled}, + {"", zerolog.InfoLevel}, + {"verbose", zerolog.DebugLevel}, + } + + for _, tt := range tests { + t.Run(string(tt.level), func(t *testing.T) { + require.Equal(t, tt.want, tt.level.Zerolog()) + }) + } +} + +func TestSecret(t *testing.T) { + dir := t.TempDir() + require.NoError(t, os.WriteFile(filepath.Join(dir, "s"), []byte(" from-file\n"), 0o600)) + require.NoError(t, os.WriteFile(filepath.Join(dir, "empty"), []byte(" \n"), 0o600)) + t.Setenv("D", dir) + + missing := filepath.Join(dir, "missing") + empty := filepath.Join(dir, "empty") + + tests := []struct { + name string + in Secret + want string + wantErr string + wantFile bool + wantRedacted string + }{ + {name: "empty", in: "", want: "", wantRedacted: ""}, + {name: "literal", in: "literal-value", want: "literal-value", wantRedacted: ""}, + {name: "file trimmed", in: Secret("file:" + filepath.Join(dir, "s")), want: "from-file", wantFile: true, wantRedacted: "file:" + filepath.Join(dir, "s")}, + {name: "file path expanded", in: "file:$D/s", want: "from-file", wantFile: true, wantRedacted: "file:$D/s"}, + {name: "missing file names the path", in: Secret("file:" + missing), wantErr: missing, wantFile: true, wantRedacted: "file:" + missing}, + {name: "empty file names the path", in: Secret("file:" + empty), wantErr: empty + ": file is empty", wantFile: true, wantRedacted: "file:" + empty}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + require.Equal(t, tt.wantFile, tt.in.IsFile()) + require.Equal(t, tt.wantRedacted, tt.in.Redacted()) + require.Equal(t, tt.wantRedacted, fmt.Sprint(tt.in), "String redacts") + + got, err := tt.in.Resolve() + if tt.wantErr != "" { + require.ErrorContains(t, err, tt.wantErr) + + return + } + + require.NoError(t, err) + require.Equal(t, tt.want, got) + }) + } + + _, err := Secret("file:" + missing).Resolve() + require.ErrorIs(t, err, os.ErrNotExist) +} diff --git a/hscontrol/types/const.go b/hscontrol/types/const.go index baf6cd3f5..788831e8f 100644 --- a/hscontrol/types/const.go +++ b/hscontrol/types/const.go @@ -3,14 +3,14 @@ package types import "time" const ( - HTTPTimeout = 30 * time.Second - HTTPShutdownTimeout = 3 * time.Second - TLSALPN01ChallengeType = "TLS-ALPN-01" - HTTP01ChallengeType = "HTTP-01" - DNS01ChallengeType = "DNS-01" + HTTPTimeout = 30 * time.Second + HTTPShutdownTimeout = 3 * time.Second + TLSALPN01ChallengeType ACMEChallenge = "TLS-ALPN-01" + HTTP01ChallengeType ACMEChallenge = "HTTP-01" + DNS01ChallengeType ACMEChallenge = "DNS-01" - JSONLogFormat = "json" - TextLogFormat = "text" + JSONLogFormat LogFormat = "json" + TextLogFormat LogFormat = "text" MaxHostnameLength = 255 ) diff --git a/hscontrol/types/listener.go b/hscontrol/types/listener.go index 02ef8b506..87bebf0d5 100644 --- a/hscontrol/types/listener.go +++ b/hscontrol/types/listener.go @@ -116,7 +116,7 @@ func validateListenerCollisions(v *configValidator) { addr: acmeAddr, active: acmeAddr != "" && src.String("tls.acme.hostname") != "" && - src.String("tls.acme.challenge_type") == HTTP01ChallengeType, + ACMEChallenge(src.String("tls.acme.challenge_type")) == HTTP01ChallengeType, }, } diff --git a/hscontrol/types/node.go b/hscontrol/types/node.go index c03d1ba5c..84932c895 100644 --- a/hscontrol/types/node.go +++ b/hscontrol/types/node.go @@ -920,7 +920,7 @@ func (nv NodeView) CertDomain(cfg *Config) (string, bool) { return "", false } - fqdn, err := nv.GetFQDN(cfg.BaseDomain) + fqdn, err := nv.GetFQDN(cfg.DNSConfig.BaseDomain) if err != nil { return "", false } @@ -1380,7 +1380,7 @@ func (nv NodeView) TailNode( return nil, ErrInvalidNodeView } - hostname, err := nv.GetFQDN(cfg.BaseDomain) + hostname, err := nv.GetFQDN(cfg.DNSConfig.BaseDomain) if err != nil { return nil, err } diff --git a/hscontrol/types/secret.go b/hscontrol/types/secret.go index 916053428..c8d8b319c 100644 --- a/hscontrol/types/secret.go +++ b/hscontrol/types/secret.go @@ -3,7 +3,6 @@ package types import ( "errors" "fmt" - "os" "strings" hsdns "github.com/juanfont/headscale/hscontrol/dns" @@ -11,27 +10,12 @@ import ( var errSecretEmpty = errors.New("file is empty") -// ResolveSecret returns value, or the trimmed contents of the file named -// by "file:" (Tailscale's form), which keeps the secret out of the -// config and the environment. Variables in the path are expanded so a -// systemd credential can be named by ${CREDENTIALS_DIRECTORY}. +// ResolveSecret resolves the secret setting key as [Secret.Resolve] does; +// errors name the key and say what to fix. func ResolveSecret(key, value string) (string, error) { - path, ok := strings.CutPrefix(value, "file:") - if !ok { - return value, nil - } - - path = os.ExpandEnv(path) - - b, err := os.ReadFile(path) + secret, err := Secret(value).Resolve() if err != nil { - return "", fmt.Errorf("%s: %w", key, err) - } - - // An empty file is a credential that was not written, not a choice. - secret := strings.TrimSpace(string(b)) - if secret == "" { - return "", fmt.Errorf("%s: %s: %w", key, path, errSecretEmpty) + return "", fmt.Errorf("%s: %w; ensure the file exists, is not empty and is readable by the user running headscale", key, err) } return secret, nil @@ -46,23 +30,3 @@ func keepSecret(_, value string) (string, error) { return value, nil } - -// configSecret resolves the secret setting key, recording a failure in v. -func configSecret(v *configValidator, resolve func(key, value string) (string, error), key, value string) string { - secret, err := resolve(key, value) - if errors.Is(err, hsdns.ErrSecretUnread) { - return value - } - - if err != nil { - v.Add(&ConfigError{ - Reason: key + " cannot be read", - Current: []KV{{key, value}}, - Detail: err.Error(), - Hint: "ensure the file exists, is not empty and is readable by the user running headscale", - Cause: err, - }) - } - - return secret -} diff --git a/hscontrol/types/secret_test.go b/hscontrol/types/secret_test.go index fc78a23e2..9070e16ef 100644 --- a/hscontrol/types/secret_test.go +++ b/hscontrol/types/secret_test.go @@ -35,6 +35,7 @@ func TestResolveSecret(t *testing.T) { if tt.wantErr != "" { require.ErrorContains(t, err, tt.wantErr) require.ErrorContains(t, err, "oidc.client_secret: ") + require.ErrorContains(t, err, "readable by the user running headscale") return } diff --git a/integration/cli_policy_test.go b/integration/cli_policy_test.go index f15162254..8a3f5d928 100644 --- a/integration/cli_policy_test.go +++ b/integration/cli_policy_test.go @@ -74,7 +74,7 @@ func TestSSHTestsRejectFailingPolicy(t *testing.T) { []tsic.Option{}, hsic.WithTestName("cli-policyset-sshtests"), hsic.WithConfigEnv(map[string]string{ - "HEADSCALE_POLICY_MODE": types.PolicyModeDB, + "HEADSCALE_POLICY_MODE": string(types.PolicyModeDB), }), ) require.NoError(t, err) diff --git a/integration/scenario.go b/integration/scenario.go index 110225765..f85e841f1 100644 --- a/integration/scenario.go +++ b/integration/scenario.go @@ -1565,7 +1565,7 @@ func (o *scenarioOIDC) Issuer() string { panic("OIDC has not been created") } - return o.cfg.Issuer + return string(o.cfg.Issuer) } func (o *scenarioOIDC) ClientSecret() string { @@ -1573,7 +1573,7 @@ func (o *scenarioOIDC) ClientSecret() string { panic("OIDC has not been created") } - return o.cfg.ClientSecret + return string(o.cfg.ClientSecret) } func (o *scenarioOIDC) ClientID() string { @@ -1708,10 +1708,10 @@ func (s *Scenario) runMockOIDC(accessTTL time.Duration, users []mockoidc.MockUse } s.mockOIDC.cfg = &types.OIDCConfig{ - Issuer: fmt.Sprintf( + Issuer: types.HTTPURL(fmt.Sprintf( "http://%s/oidc", hostEndpoint, - ), + )), ClientID: "superclient", ClientSecret: "supersecret", OnlyStartIfOIDCIsAvailable: true,