policy/v2: refuse autogroup:member as SSH destination

Tailscale answers invalid dst "autogroup:member" for every source.

Updates #3335
This commit is contained in:
Kristoffer Dalby committed 2026-11-05 13:43:48 +01:00
1 parent e93046aa68
commit 36ea8d9e81
8 files changed
+321 -368

No files matched your search

+1
View File
@@ -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
+2 -2
View File
@@ -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,
},
+1 -1
View File
@@ -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,
},
+2 -2
View File
@@ -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)
+1 -6
View File
@@ -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
}
}
}
+16 -11
View File
@@ -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"]}`,
+3 -2
View File
@@ -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")},
},
+295 -344
View File
@@ -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),
},
}