From 36ea8d9e81be68d6c8f97bc32e34acbfc8dbc858 Mon Sep 17 00:00:00 2001 From: Kristoffer Dalby Date: Wed, 4 Nov 2026 13:26:30 +0000 Subject: [PATCH] policy/v2: refuse autogroup:member as SSH destination Tailscale answers invalid dst "autogroup:member" for every source. Updates #3335 --- CHANGELOG.md | 1 + cmd/headscale/cli/root_test.go | 4 +- hscontrol/policy/v2/filter_test.go | 2 +- hscontrol/policy/v2/policy_test.go | 4 +- hscontrol/policy/v2/types.go | 7 +- hscontrol/policy/v2/types_test.go | 27 +- integration/cli_policy_test.go | 5 +- integration/ssh_test.go | 639 +++++++++++++---------------- 8 files changed, 321 insertions(+), 368 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9bde4d073..dfcfac387 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -107,6 +107,7 @@ the ACME DNS-01 challenge through a built-in DNS provider: `acmedns`, - Use `{}` to allow all. Headscale rejects empty policy writes. [#3619](https://github.com/juanfont/headscale/pull/3619) - A policy without `acls` or `grants` allows only tailnet addresses and approved routes. Hosts outside the tailnet cannot connect to nodes. Use `autogroup:danger-all` to allow all addresses. [#3649](https://github.com/juanfont/headscale/pull/3649) - A user's devices are always peers of each other. The packet filter still controls access. [#3649](https://github.com/juanfont/headscale/pull/3649) +- SSH `dst` rejects `autogroup:member`, as Tailscale does. Use `autogroup:self`, tags, or the source's own user. A policy file that still uses it stops headscale at startup. [#3343](https://github.com/juanfont/headscale/pull/3343) #### Nodes and routes diff --git a/cmd/headscale/cli/root_test.go b/cmd/headscale/cli/root_test.go index dc3185ed4..9f444ee45 100644 --- a/cmd/headscale/cli/root_test.go +++ b/cmd/headscale/cli/root_test.go @@ -341,8 +341,8 @@ func TestOfflineSetPolicyRunsTests(t *testing.T) { name: "failing SSH test preserves stored policy", policy: `{ "acls": [{"action":"accept","src":["*"],"dst":["*:*"]}], - "ssh": [{"action":"accept","src":["alice@"],"dst":["autogroup:member"],"users":["root"]}], - "sshTests": [{"src":"bob@","dst":["autogroup:member"],"accept":["root"]}] + "ssh": [{"action":"accept","src":["alice@"],"dst":["autogroup:self"],"users":["root"]}], + "sshTests": [{"src":"bob@","dst":["alice@"],"accept":["root"]}] }`, invalid: true, }, diff --git a/hscontrol/policy/v2/filter_test.go b/hscontrol/policy/v2/filter_test.go index 09dc40235..232661ea4 100644 --- a/hscontrol/policy/v2/filter_test.go +++ b/hscontrol/policy/v2/filter_test.go @@ -2643,7 +2643,7 @@ func TestCompileSSHPolicy_CheckPeriodVariants(t *testing.T) { { Action: SSHActionCheck, Sources: SSHSrcAliases{up("user1@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: tt.checkPeriod, }, diff --git a/hscontrol/policy/v2/policy_test.go b/hscontrol/policy/v2/policy_test.go index 9aaa5337a..4a2d38393 100644 --- a/hscontrol/policy/v2/policy_test.go +++ b/hscontrol/policy/v2/policy_test.go @@ -1063,8 +1063,8 @@ func TestSSHPolicySharedBetweenNodes(t *testing.T) { } pm, err := NewPolicyManager([]byte(`{"ssh": [ - {"action": "accept", "src": ["autogroup:member"], "dst": ["autogroup:member"], "users": ["a"]}, - {"action": "accept", "src": ["user1@headscale.net"], "dst": ["autogroup:member"], "users": ["b"]} + {"action": "accept", "src": ["autogroup:member"], "dst": ["autogroup:self"], "users": ["a"]}, + {"action": "accept", "src": ["user1@headscale.net"], "dst": ["autogroup:self"], "users": ["b"]} ]}`), users, nodes[:2].ViewSlice()) require.NoError(t, err) diff --git a/hscontrol/policy/v2/types.go b/hscontrol/policy/v2/types.go index ceae72205..8ce44cc55 100644 --- a/hscontrol/policy/v2/types.go +++ b/hscontrol/policy/v2/types.go @@ -46,7 +46,6 @@ var ( ErrSSHTagSourceToUserDest = errors.New("tags in SSH source cannot access user-owned devices") ErrSSHUserDestRequiresSameUser = errors.New("user destination requires source to contain only that same user") ErrSSHAutogroupSelfRequiresUserSource = errors.New("autogroup:self destination requires source to contain only users or groups, not tags or autogroup:tagged") - ErrSSHTagSourceToAutogroupMember = errors.New("tags in SSH source cannot access autogroup:member (user-owned devices)") ErrSSHCheckPeriodAboveMax = errors.New("is above the max (168h)") ErrSSHCheckPeriodNegative = errors.New("must be a positive duration") ErrSSHCheckPeriodOnNonCheck = errors.New(`"checkPeriod" can only be specified for the "check" action`) @@ -2214,7 +2213,7 @@ var ( autogroupForSrc = []AutoGroup{AutoGroupMember, AutoGroupTagged, AutoGroupDangerAll} autogroupForDst = []AutoGroup{AutoGroupInternet, AutoGroupMember, AutoGroupTagged, AutoGroupSelf} autogroupForSSHSrc = []AutoGroup{AutoGroupMember, AutoGroupTagged} - autogroupForSSHDst = []AutoGroup{AutoGroupMember, AutoGroupTagged, AutoGroupSelf} + autogroupForSSHDst = []AutoGroup{AutoGroupTagged, AutoGroupSelf} autogroupForNodeAttrs = []AutoGroup{AutoGroupMember, AutoGroupTagged} autogroupNotSupported = []AutoGroup{} @@ -2393,10 +2392,6 @@ func validateSSHSrcDstCombination(sources SSHSrcAliases, destinations SSHDstAlia if v.Is(AutoGroupSelf) && srcHasTaggedEntities { return ErrSSHAutogroupSelfRequiresUserSource } - // Rule: autogroup:member (user-owned devices) cannot be accessed by tagged entities - if v.Is(AutoGroupMember) && srcHasTaggedEntities { - return ErrSSHTagSourceToAutogroupMember - } } } diff --git a/hscontrol/policy/v2/types_test.go b/hscontrol/policy/v2/types_test.go index 5550deebb..4e25dcda5 100644 --- a/hscontrol/policy/v2/types_test.go +++ b/hscontrol/policy/v2/types_test.go @@ -1700,7 +1700,7 @@ func TestUnmarshalPolicy(t *testing.T) { }] } `, - wantErr: "tags in SSH source cannot access autogroup:member", + wantErr: `[ssh] invalid dst "autogroup:member"`, }, { name: "ssh-autogroup-tagged-to-autogroup-tagged-allowed", @@ -4550,7 +4550,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, }, }, @@ -4559,7 +4559,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Always: true}, }, @@ -4569,7 +4569,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: time.Hour}, }, @@ -4579,7 +4579,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionAccept, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: time.Hour}, }, @@ -4590,7 +4590,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: 30 * time.Second}, }, @@ -4600,7 +4600,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: 168 * time.Hour}, }, @@ -4610,7 +4610,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: 168*time.Hour + time.Second}, }, @@ -4621,7 +4621,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: 200 * time.Hour}, }, @@ -4632,7 +4632,7 @@ func TestSSHCheckPeriodPolicyValidation(t *testing.T) { ssh: SSH{ Action: SSHActionCheck, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, CheckPeriod: &SSHCheckPeriod{Duration: -time.Minute}, }, @@ -4663,7 +4663,7 @@ func TestSSHRuleSaaSValidation(t *testing.T) { ssh := SSH{ Action: SSHActionAccept, Sources: SSHSrcAliases{up("user@")}, - Destinations: SSHDstAliases{agp("autogroup:member")}, + Destinations: SSHDstAliases{agp("autogroup:self")}, Users: SSHUsers{"root"}, } if modify != nil { @@ -4842,6 +4842,11 @@ func TestSSHRuleErrorsLabelled(t *testing.T) { rules: `{"action": "accept", "src": ["odin@"], "dst": ["group:admins"], "users": ["root"]}`, wantErr: `[ssh] groups are not allowed dst`, }, + { + name: "autogroup:member dst", + rules: `{"action": "accept", "src": ["odin@"], "dst": ["autogroup:member"], "users": ["root"]}`, + wantErr: `[ssh] invalid dst "autogroup:member"`, + }, { name: "autogroup:internet dst", rules: `{"action": "accept", "src": ["odin@"], "dst": ["autogroup:internet"], "users": ["root"]}`, diff --git a/integration/cli_policy_test.go b/integration/cli_policy_test.go index 4811355c1..0c826c4c2 100644 --- a/integration/cli_policy_test.go +++ b/integration/cli_policy_test.go @@ -211,14 +211,15 @@ func TestSSHTestsRejectFailingPolicy(t *testing.T) { user2 = "user2@" ) - // Good policy: user1@ may SSH as root, and the sshTests asserts it. + // Good policy: user1@ may SSH as root to its own devices, and the + // sshTests asserts it. goodPolicy := policyv2.Policy{ SSHs: []policyv2.SSH{ { Action: policyv2.SSHActionAccept, Sources: policyv2.SSHSrcAliases{usernamep(user1)}, Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), }, Users: []policyv2.SSHUser{policyv2.SSHUser("root")}, }, diff --git a/integration/ssh_test.go b/integration/ssh_test.go index ca6085381..94fce0dd4 100644 --- a/integration/ssh_test.go +++ b/integration/ssh_test.go @@ -95,10 +95,10 @@ func TestSSHOneUserToAll(t *testing.T) { { Action: "accept", Sources: policyv2.SSHSrcAliases{groupp("group:integration-test")}, - // Use autogroup:member and autogroup:tagged instead of wildcard - // since wildcard (*) is no longer supported for SSH destinations + // SSH dst refuses * and autogroup:member; self+tagged is the + // widest reach a user source can get. Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), new(policyv2.AutoGroupTagged), }, Users: []policyv2.SSHUser{policyv2.SSHUser("ssh-it-user")}, @@ -126,8 +126,9 @@ func TestSSHOneUserToAll(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) + // Even the widest rule never lets user1 into user2's devices. for _, client := range user1Clients { - for _, peer := range allClients { + for _, peer := range user1Clients { if client.Hostname() == peer.Hostname() { continue } @@ -135,6 +136,10 @@ func TestSSHOneUserToAll(t *testing.T) { assertSSHHostname(t, client, peer) assertSSHAcceptEnv(t, client, peer) } + + for _, peer := range user2Clients { + assertSSHPermissionDenied(t, client, peer) + } } for _, client := range user2Clients { @@ -307,7 +312,7 @@ func TestSSHRulesRemovedDeniesAccess(t *testing.T) { Action: "accept", Sources: policyv2.SSHSrcAliases{groupp("group:integration-test")}, Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), new(policyv2.AutoGroupTagged), }, Users: []policyv2.SSHUser{policyv2.SSHUser("ssh-it-user")}, @@ -320,9 +325,8 @@ func TestSSHRulesRemovedDeniesAccess(t *testing.T) { ) defer scenario.ShutdownAssertNoPanics(t) - allClients, err := scenario.ListTailscaleClients() - requireNoErrListClients(t, err) - + // user1 holds one client per version, so its own devices cover every + // version as a destination. user1Clients, err := scenario.ListTailscaleClients("user1") requireNoErrListClients(t, err) @@ -330,7 +334,7 @@ func TestSSHRulesRemovedDeniesAccess(t *testing.T) { require.NoError(t, err) for _, client := range user1Clients { - for _, peer := range allClients { + for _, peer := range user1Clients { if client.Hostname() == peer.Hostname() { continue } @@ -345,7 +349,7 @@ func TestSSHRulesRemovedDeniesAccess(t *testing.T) { assert.EventuallyWithT(t, func(ct *assert.CollectT) { for _, client := range user1Clients { - for _, peer := range allClients { + for _, peer := range user1Clients { if client.Hostname() == peer.Hostname() { continue } @@ -840,7 +844,8 @@ func findSSHCheckAuthID(t *testing.T, headscale ControlServer) string { } // sshCheckPolicy returns a [policyv2.Policy] with SSH "check" mode for group:integration-test -// targeting autogroup:member and autogroup:tagged destinations. +// targeting autogroup:self and autogroup:tagged destinations. With no tagged +// nodes, user1 can only target its own devices, so callers need two per user. func sshCheckPolicy() *policyv2.Policy { return &policyv2.Policy{ Groups: policyv2.Groups{ @@ -863,7 +868,7 @@ func sshCheckPolicy() *policyv2.Policy { Action: "check", Sources: policyv2.SSHSrcAliases{groupp("group:integration-test")}, Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), new(policyv2.AutoGroupTagged), }, Users: []policyv2.SSHUser{policyv2.SSHUser("ssh-it-user")}, @@ -896,7 +901,7 @@ func sshCheckPolicyWithPeriod(period time.Duration) *policyv2.Policy { Action: "check", Sources: policyv2.SSHSrcAliases{groupp("group:integration-test")}, Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), new(policyv2.AutoGroupTagged), }, Users: []policyv2.SSHUser{policyv2.SSHUser("ssh-it-user")}, @@ -951,7 +956,7 @@ func findNewSSHCheckAuthID( func TestSSHOneUserToOneCheckModeCLI(t *testing.T) { IntegrationSkip(t) - scenario := sshScenario(t, sshCheckPolicy(), "ssh-checkcli", 1) + scenario := sshScenario(t, sshCheckPolicy(), "ssh-checkcli", 2) // defer scenario.ShutdownAssertNoPanics(t) allClients, err := scenario.ListTailscaleClients() @@ -972,40 +977,43 @@ func TestSSHOneUserToOneCheckModeCLI(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) - // user1 can SSH (via check) to all peers + // One pair only: findSSHCheckAuthID returns the newest auth-id in the + // log, so a second check in the same run would pick up a stale one. + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] + + // Start SSH — will block waiting for check auth + sshResult := doSSHCheck(t, client, peer) + + // Find the auth-id from headscale logs + authID := findSSHCheckAuthID(t, headscale) + + // Approve via CLI + _, err = headscale.Execute( + []string{ + "headscale", "auth", "approve", + "--auth-id", authID, + }, + ) + require.NoError(t, err) + + // Wait for SSH to complete + select { + case result := <-sshResult: + require.NoError(t, result.err) + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result.stdout, "\n", ""), + ) + case <-time.After(30 * time.Second): + t.Fatal("SSH did not complete after auth approval") + } + + // autogroup:self never reaches another user's devices. for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } - - // Start SSH — will block waiting for check auth - sshResult := doSSHCheck(t, client, peer) - - // Find the auth-id from headscale logs - authID := findSSHCheckAuthID(t, headscale) - - // Approve via CLI - _, err := headscale.Execute( - []string{ - "headscale", "auth", "approve", - "--auth-id", authID, - }, - ) - require.NoError(t, err) - - // Wait for SSH to complete - select { - case result := <-sshResult: - require.NoError(t, result.err) - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result.stdout, "\n", ""), - ) - case <-time.After(30 * time.Second): - t.Fatal("SSH did not complete after auth approval") - } + for _, peer := range user2Clients { + assertSSHPermissionDenied(t, client, peer) } } @@ -1025,12 +1033,14 @@ func TestSSHOneUserToOneCheckModeOIDC(t *testing.T) { IntegrationSkip(t) spec := ScenarioSpec{ - NodesPerUser: 1, + NodesPerUser: 2, Users: []string{"user1", "user2"}, OIDCSkipUserCreation: true, OIDCUsers: []mockoidc.MockUser{ - // First 2: consumed during node registration + // First 4: consumed during node registration, user by user oidcMockUser("user1", true), + oidcMockUser("user1", true), + oidcMockUser("user2", true), oidcMockUser("user2", true), // Extra: consumed during SSH check auth flows. // Each SSH check pops one user from the queue. @@ -1085,40 +1095,43 @@ func TestSSHOneUserToOneCheckModeOIDC(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) - // user1 can SSH (via check) to all peers + // One pair only: findSSHCheckAuthID returns the newest auth-id in the + // log, and the OIDC queue holds a single extra login. + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] + + // Start SSH — will block waiting for check auth + sshResult := doSSHCheck(t, client, peer) + + // Find the auth-id from headscale logs + authID := findSSHCheckAuthID(t, headscale) + + // Build auth URL and visit it to trigger OIDC flow. + // The mock OIDC server auto-authenticates from the user queue. + authURL := headscale.GetEndpoint() + "/auth/" + authID + parsedURL, err := url.Parse(authURL) + require.NoError(t, err) + + _, err = doLoginURL("ssh-check-oidc", parsedURL) + require.NoError(t, err) + + // Wait for SSH to complete + select { + case result := <-sshResult: + require.NoError(t, result.err) + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result.stdout, "\n", ""), + ) + case <-time.After(30 * time.Second): + t.Fatal("SSH did not complete after OIDC auth") + } + + // autogroup:self never reaches another user's devices. for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } - - // Start SSH — will block waiting for check auth - sshResult := doSSHCheck(t, client, peer) - - // Find the auth-id from headscale logs - authID := findSSHCheckAuthID(t, headscale) - - // Build auth URL and visit it to trigger OIDC flow. - // The mock OIDC server auto-authenticates from the user queue. - authURL := headscale.GetEndpoint() + "/auth/" + authID - parsedURL, err := url.Parse(authURL) - require.NoError(t, err) - - _, err = doLoginURL("ssh-check-oidc", parsedURL) - require.NoError(t, err) - - // Wait for SSH to complete - select { - case result := <-sshResult: - require.NoError(t, result.err) - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result.stdout, "\n", ""), - ) - case <-time.After(30 * time.Second): - t.Fatal("SSH did not complete after OIDC auth") - } + for _, peer := range user2Clients { + assertSSHPermissionDenied(t, client, peer) } } @@ -1140,7 +1153,7 @@ func TestSSHCheckModeUnapprovedTimeout(t *testing.T) { IntegrationSkip(t) spec := ScenarioSpec{ - NodesPerUser: 1, + NodesPerUser: 2, Users: []string{"user1", "user2"}, } @@ -1184,27 +1197,23 @@ func TestSSHCheckModeUnapprovedTimeout(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) - // user1 attempts SSH — enters check flow, but nobody approves - for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } + // user1 attempts SSH to its other device — enters check flow, but + // nobody approves + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] - sshResult := doSSHCheck(t, client, peer) + sshResult := doSSHCheck(t, client, peer) - // Confirm the check flow was entered - _ = findSSHCheckAuthID(t, headscale) + // Confirm the check flow was entered + _ = findSSHCheckAuthID(t, headscale) - // Do NOT approve — wait for cache expiry and SSH rejection - select { - case result := <-sshResult: - require.Error(t, result.err, "SSH should be rejected when unapproved") - assert.Empty(t, result.stdout, "no command output expected on rejection") - case <-time.After(60 * time.Second): - t.Fatal("SSH did not complete after cache expiry timeout") - } - } + // Do NOT approve — wait for cache expiry and SSH rejection + select { + case result := <-sshResult: + require.Error(t, result.err, "SSH should be rejected when unapproved") + assert.Empty(t, result.stdout, "no command output expected on rejection") + case <-time.After(60 * time.Second): + t.Fatal("SSH did not complete after cache expiry timeout") } // user2 still gets immediate Permission Denied @@ -1226,12 +1235,9 @@ func TestSSHCheckModeCheckPeriodCLI(t *testing.T) { IntegrationSkip(t) // 1 minute is the documented minimum checkPeriod - scenario := sshScenario(t, sshCheckPolicyWithPeriod(time.Minute), "ssh-checkperiod", 1) + scenario := sshScenario(t, sshCheckPolicyWithPeriod(time.Minute), "ssh-checkperiod", 2) defer scenario.ShutdownAssertNoPanics(t) - allClients, err := scenario.ListTailscaleClients() - requireNoErrListClients(t, err) - user1Clients, err := scenario.ListTailscaleClients("user1") requireNoErrListClients(t, err) @@ -1244,74 +1250,69 @@ func TestSSHCheckModeCheckPeriodCLI(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] + // === Phase 1: First SSH check — approve, verify success === - for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } + sshResult := doSSHCheck(t, client, peer) + firstAuthID := findSSHCheckAuthID(t, headscale) - sshResult := doSSHCheck(t, client, peer) - firstAuthID := findSSHCheckAuthID(t, headscale) + _, err = headscale.Execute( + []string{ + "headscale", "auth", "approve", + "--auth-id", firstAuthID, + }, + ) + require.NoError(t, err) - _, err := headscale.Execute( - []string{ - "headscale", "auth", "approve", - "--auth-id", firstAuthID, - }, - ) - require.NoError(t, err) + select { + case result := <-sshResult: + require.NoError(t, result.err, "first SSH should succeed after approval") + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result.stdout, "\n", ""), + ) + case <-time.After(30 * time.Second): + t.Fatal("first SSH did not complete after auth approval") + } - select { - case result := <-sshResult: - require.NoError(t, result.err, "first SSH should succeed after approval") - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result.stdout, "\n", ""), - ) - case <-time.After(30 * time.Second): - t.Fatal("first SSH did not complete after auth approval") - } + // === Phase 2: Wait for checkPeriod to expire === + //nolint:forbidigo // Intentional sleep: waiting for the check period session + // to expire. This is a time-based expiry, not a pollable condition — the + // Tailscale client caches the approval for SessionDuration and only + // re-triggers the check flow after it elapses. + time.Sleep(70 * time.Second) - // === Phase 2: Wait for checkPeriod to expire === - //nolint:forbidigo // Intentional sleep: waiting for the check period session - // to expire. This is a time-based expiry, not a pollable condition — the - // Tailscale client caches the approval for SessionDuration and only - // re-triggers the check flow after it elapses. - time.Sleep(70 * time.Second) + // === Phase 3: Second SSH — must re-authenticate === + sshResult2 := doSSHCheck(t, client, peer) + secondAuthID := findNewSSHCheckAuthID(t, headscale, firstAuthID) - // === Phase 3: Second SSH — must re-authenticate === - sshResult2 := doSSHCheck(t, client, peer) - secondAuthID := findNewSSHCheckAuthID(t, headscale, firstAuthID) + require.NotEqual( + t, + firstAuthID, + secondAuthID, + "second SSH should trigger a new auth flow after checkPeriod expiry", + ) - require.NotEqual( - t, - firstAuthID, - secondAuthID, - "second SSH should trigger a new auth flow after checkPeriod expiry", - ) + _, err = headscale.Execute( + []string{ + "headscale", "auth", "approve", + "--auth-id", secondAuthID, + }, + ) + require.NoError(t, err) - _, err = headscale.Execute( - []string{ - "headscale", "auth", "approve", - "--auth-id", secondAuthID, - }, - ) - require.NoError(t, err) - - select { - case result := <-sshResult2: - require.NoError(t, result.err, "second SSH should succeed after re-approval") - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result.stdout, "\n", ""), - ) - case <-time.After(30 * time.Second): - t.Fatal("second SSH did not complete after re-auth approval") - } - } + select { + case result := <-sshResult2: + require.NoError(t, result.err, "second SSH should succeed after re-approval") + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result.stdout, "\n", ""), + ) + case <-time.After(30 * time.Second): + t.Fatal("second SSH did not complete after re-auth approval") } } @@ -1321,12 +1322,9 @@ func TestSSHCheckModeAutoApprove(t *testing.T) { IntegrationSkip(t) // 5 minute checkPeriod — long enough not to expire during test - scenario := sshScenario(t, sshCheckPolicyWithPeriod(5*time.Minute), "ssh-autoapprove", 1) + scenario := sshScenario(t, sshCheckPolicyWithPeriod(5*time.Minute), "ssh-autoapprove", 2) defer scenario.ShutdownAssertNoPanics(t) - allClients, err := scenario.ListTailscaleClients() - requireNoErrListClients(t, err) - user1Clients, err := scenario.ListTailscaleClients("user1") requireNoErrListClients(t, err) @@ -1339,46 +1337,41 @@ func TestSSHCheckModeAutoApprove(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] + // === Phase 1: First SSH check — approve, verify success === - for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } + sshResult := doSSHCheck(t, client, peer) + firstAuthID := findSSHCheckAuthID(t, headscale) - sshResult := doSSHCheck(t, client, peer) - firstAuthID := findSSHCheckAuthID(t, headscale) + _, err = headscale.Execute( + []string{ + "headscale", "auth", "approve", + "--auth-id", firstAuthID, + }, + ) + require.NoError(t, err) - _, err := headscale.Execute( - []string{ - "headscale", "auth", "approve", - "--auth-id", firstAuthID, - }, - ) - require.NoError(t, err) - - select { - case result := <-sshResult: - require.NoError(t, result.err, "first SSH should succeed after approval") - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result.stdout, "\n", ""), - ) - case <-time.After(30 * time.Second): - t.Fatal("first SSH did not complete after auth approval") - } - - // === Phase 2: Immediate retry — should auto-approve === - result, _, err := doSSH(t, client, peer) - require.NoError(t, err, "second SSH should auto-approve without manual auth") - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result, "\n", ""), - ) - } + select { + case result := <-sshResult: + require.NoError(t, result.err, "first SSH should succeed after approval") + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result.stdout, "\n", ""), + ) + case <-time.After(30 * time.Second): + t.Fatal("first SSH did not complete after auth approval") } + + // === Phase 2: Immediate retry — should auto-approve === + result, _, err := doSSH(t, client, peer) + require.NoError(t, err, "second SSH should auto-approve without manual auth") + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result, "\n", ""), + ) } // TestSSHCheckModeSessionLossReDelegates reproduces the failure in @@ -1391,12 +1384,9 @@ func TestSSHCheckModeAutoApprove(t *testing.T) { func TestSSHCheckModeSessionLossReDelegates(t *testing.T) { IntegrationSkip(t) - scenario := sshScenario(t, sshCheckPolicy(), "ssh-sessionloss", 1) + scenario := sshScenario(t, sshCheckPolicy(), "ssh-sessionloss", 2) defer scenario.ShutdownAssertNoPanics(t) - allClients, err := scenario.ListTailscaleClients() - requireNoErrListClients(t, err) - user1Clients, err := scenario.ListTailscaleClients("user1") requireNoErrListClients(t, err) @@ -1409,59 +1399,54 @@ func TestSSHCheckModeSessionLossReDelegates(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) - for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] - // Start SSH — blocks waiting for the check verdict while the - // pending auth session sits in the control plane's cache. Allow a - // generous window: the flow spans a full control-plane restart. - sshResult := doSSHCheckWithTimeout(t, client, peer, 120*time.Second) + // Start SSH — blocks waiting for the check verdict while the + // pending auth session sits in the control plane's cache. Allow a + // generous window: the flow spans a full control-plane restart. + sshResult := doSSHCheckWithTimeout(t, client, peer, 120*time.Second) - firstAuthID := findSSHCheckAuthID(t, headscale) + firstAuthID := findSSHCheckAuthID(t, headscale) - // Restart the control plane: the in-memory auth cache is dropped - // (the on-disk database and keys persist), so the auth_id the - // client is still polling for no longer exists. - err := headscale.Restart() - require.NoError(t, err, "restarting headscale should succeed") + // Restart the control plane: the in-memory auth cache is dropped + // (the on-disk database and keys persist), so the auth_id the + // client is still polling for no longer exists. + err = headscale.Restart() + require.NoError(t, err, "restarting headscale should succeed") - err = scenario.WaitForTailscaleSync() - requireNoErrSync(t, err) + err = scenario.WaitForTailscaleSync() + requireNoErrSync(t, err) - // The client keeps polling the now-missing auth_id; with the fix the - // server re-delegates a fresh session instead of returning an error - // the client cannot recover from. A new auth_id only appears if the - // re-delegation happened. - secondAuthID := findNewSSHCheckAuthID(t, headscale, firstAuthID) - require.NotEqual(t, firstAuthID, secondAuthID, - "a lost session under an active check must re-delegate with a new auth_id") + // The client keeps polling the now-missing auth_id; with the fix the + // server re-delegates a fresh session instead of returning an error + // the client cannot recover from. A new auth_id only appears if the + // re-delegation happened. + secondAuthID := findNewSSHCheckAuthID(t, headscale, firstAuthID) + require.NotEqual(t, firstAuthID, secondAuthID, + "a lost session under an active check must re-delegate with a new auth_id") - // Approve the re-delegated session; the SSH connection must now - // complete instead of hanging until it times out. - _, err = headscale.Execute( - []string{ - "headscale", "auth", "approve", - "--auth-id", secondAuthID, - }, - ) - require.NoError(t, err) + // Approve the re-delegated session; the SSH connection must now + // complete instead of hanging until it times out. + _, err = headscale.Execute( + []string{ + "headscale", "auth", "approve", + "--auth-id", secondAuthID, + }, + ) + require.NoError(t, err) - select { - case result := <-sshResult: - require.NoError(t, result.err, - "SSH should succeed after re-delegation recovers the lost session") - require.Contains( - t, - peer.ContainerID(), - strings.ReplaceAll(result.stdout, "\n", ""), - ) - case <-time.After(90 * time.Second): - t.Fatal("SSH did not complete after session-loss re-delegation") - } - } + select { + case result := <-sshResult: + require.NoError(t, result.err, + "SSH should succeed after re-delegation recovers the lost session") + require.Contains( + t, + peer.ContainerID(), + strings.ReplaceAll(result.stdout, "\n", ""), + ) + case <-time.After(90 * time.Second): + t.Fatal("SSH did not complete after session-loss re-delegation") } } @@ -1470,12 +1455,9 @@ func TestSSHCheckModeSessionLossReDelegates(t *testing.T) { func TestSSHCheckModeNegativeCLI(t *testing.T) { IntegrationSkip(t) - scenario := sshScenario(t, sshCheckPolicy(), "ssh-negcli", 1) + scenario := sshScenario(t, sshCheckPolicy(), "ssh-negcli", 2) defer scenario.ShutdownAssertNoPanics(t) - allClients, err := scenario.ListTailscaleClients() - requireNoErrListClients(t, err) - user1Clients, err := scenario.ListTailscaleClients("user1") requireNoErrListClients(t, err) @@ -1488,32 +1470,27 @@ func TestSSHCheckModeNegativeCLI(t *testing.T) { _, err = scenario.ListTailscaleClientsFQDNs() requireNoErrListFQDN(t, err) - for _, client := range user1Clients { - for _, peer := range allClients { - if client.Hostname() == peer.Hostname() { - continue - } + require.Len(t, user1Clients, 2) + client, peer := user1Clients[0], user1Clients[1] - sshResult := doSSHCheck(t, client, peer) - authID := findSSHCheckAuthID(t, headscale) + sshResult := doSSHCheck(t, client, peer) + authID := findSSHCheckAuthID(t, headscale) - // Reject via CLI - _, err := headscale.Execute( - []string{ - "headscale", "auth", "reject", - "--auth-id", authID, - }, - ) - require.NoError(t, err) + // Reject via CLI + _, err = headscale.Execute( + []string{ + "headscale", "auth", "reject", + "--auth-id", authID, + }, + ) + require.NoError(t, err) - select { - case result := <-sshResult: - require.Error(t, result.err, "SSH should be rejected") - assert.Empty(t, result.stdout, "no command output expected on rejection") - case <-time.After(30 * time.Second): - t.Fatal("SSH did not complete after auth rejection") - } - } + select { + case result := <-sshResult: + require.Error(t, result.err, "SSH should be rejected") + assert.Empty(t, result.stdout, "no command output expected on rejection") + case <-time.After(30 * time.Second): + t.Fatal("SSH did not complete after auth rejection") } } @@ -1541,7 +1518,7 @@ func TestSSHLocalpart(t *testing.T) { testFn func(t *testing.T, scenario *Scenario) }{ { - name: "MemberAndTagged", + name: "SelfAndTagged", policy: &policyv2.Policy{ ACLs: baseACLs, SSHs: []policyv2.SSH{ @@ -1549,7 +1526,7 @@ func TestSSHLocalpart(t *testing.T) { Action: "accept", Sources: policyv2.SSHSrcAliases{new(policyv2.AutoGroupMember)}, Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), new(policyv2.AutoGroupTagged), }, Users: []policyv2.SSHUser{"localpart:*@headscale.net"}, @@ -1559,37 +1536,22 @@ func TestSSHLocalpart(t *testing.T) { testFn: func(t *testing.T, scenario *Scenario) { t.Helper() - user1Clients, err := scenario.ListTailscaleClients("user1") - requireNoErrListClients(t, err) + // On its own devices each user logs in as its own localpart and + // not as the other user's: localpart maps the source, not the + // destination. + for user, other := range map[string]string{"user1": "user2", "user2": "user1"} { + clients, err := scenario.ListTailscaleClients(user) + requireNoErrListClients(t, err) - user2Clients, err := scenario.ListTailscaleClients("user2") - requireNoErrListClients(t, err) + for _, client := range clients { + for _, peer := range clients { + if client.Hostname() == peer.Hostname() { + continue + } - // user1 can SSH to user2's nodes as "user1" (localpart of user1@headscale.net) - for _, client := range user1Clients { - for _, peer := range user2Clients { - assertSSHHostnameAsUser(t, client, peer, "user1") - } - } - - // user2 can SSH to user1's nodes as "user2" (localpart of user2@headscale.net) - for _, client := range user2Clients { - for _, peer := range user1Clients { - assertSSHHostnameAsUser(t, client, peer, "user2") - } - } - - // user1 CANNOT SSH as "user2" — no rule maps user1's IPs to user2 - for _, client := range user1Clients { - for _, peer := range user2Clients { - assertSSHPermissionDeniedAsUser(t, client, peer, "user2") - } - } - - // user2 CANNOT SSH as "user1" — no rule maps user2's IPs to user1 - for _, client := range user2Clients { - for _, peer := range user1Clients { - assertSSHPermissionDeniedAsUser(t, client, peer, "user1") + assertSSHHostnameAsUser(t, client, peer, user) + assertSSHPermissionDeniedAsUser(t, client, peer, other) + } } } }, @@ -1648,7 +1610,7 @@ func TestSSHLocalpart(t *testing.T) { Action: "accept", Sources: policyv2.SSHSrcAliases{new(policyv2.AutoGroupMember)}, Destinations: policyv2.SSHDstAliases{ - new(policyv2.AutoGroupMember), + new(policyv2.AutoGroupSelf), new(policyv2.AutoGroupTagged), }, Users: []policyv2.SSHUser{ @@ -1661,37 +1623,21 @@ func TestSSHLocalpart(t *testing.T) { testFn: func(t *testing.T, scenario *Scenario) { t.Helper() - user1Clients, err := scenario.ListTailscaleClients("user1") - requireNoErrListClients(t, err) + // A localpart entry does not crowd out a literal user in the + // same rule. + for _, user := range []string{"user1", "user2"} { + clients, err := scenario.ListTailscaleClients(user) + requireNoErrListClients(t, err) - user2Clients, err := scenario.ListTailscaleClients("user2") - requireNoErrListClients(t, err) + for _, client := range clients { + for _, peer := range clients { + if client.Hostname() == peer.Hostname() { + continue + } - // localpart works: user1 can SSH to user2's nodes as "user1" - for _, client := range user1Clients { - for _, peer := range user2Clients { - assertSSHHostnameAsUser(t, client, peer, "user1") - } - } - - // root also works: user1 can SSH to user2's nodes as "root" - for _, client := range user1Clients { - for _, peer := range user2Clients { - assertSSHHostnameAsUser(t, client, peer, "root") - } - } - - // user2 can SSH as "user2" (localpart) - for _, client := range user2Clients { - for _, peer := range user1Clients { - assertSSHHostnameAsUser(t, client, peer, "user2") - } - } - - // user2 can SSH as "root" - for _, client := range user2Clients { - for _, peer := range user1Clients { - assertSSHHostnameAsUser(t, client, peer, "root") + assertSSHHostnameAsUser(t, client, peer, user) + assertSSHHostnameAsUser(t, client, peer, "root") + } } } }, @@ -1700,11 +1646,16 @@ func TestSSHLocalpart(t *testing.T) { for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { + // Two nodes per user: autogroup:self gives each user only its own + // devices to SSH into. spec := ScenarioSpec{ - NodesPerUser: 1, + NodesPerUser: 2, Users: []string{"user1", "user2"}, + // Registration logs in user by user, popping one per node. OIDCUsers: []mockoidc.MockUser{ oidcMockUser("user1", true), + oidcMockUser("user1", true), + oidcMockUser("user2", true), oidcMockUser("user2", true), }, }