policy/v2: write filter rules as Tailscale does

Each alias written on its own: node addresses one by one, internet as
ranges. Via rules merge only with via rules; exit nodes get every
user's self rules in user order. Drops 63 FILTER_ADDRESS_FORM,
SELF_DST_REPEAT and VIA_RULE_MERGED skips.

Updates #3562
This commit is contained in:
Kristoffer Dalby committed 2026-11-05 12:32:04 +01:00
1 parent 137a66d59c
commit 5bcbb73f68
13 files changed
+341 -539

No files matched your search

+4 -43
View File
@@ -11,11 +11,9 @@ import (
)
// ReduceFilterRules takes a node and a set of global filter rules and removes all rules
// and destinations that are not relevant to that particular node.
//
// nodeAddrs holds every node's addresses. A destination prefix made only of
// them merges several nodes' addresses, and the node keeps just its own, as
// Tailscale lists them; any other prefix stays whole. nil keeps all whole.
// and destinations that are not relevant to that particular node. Rules list
// node addresses one by one, so a node keeps its own and those its routes
// cover, as Tailscale sends them.
//
// IMPORTANT: This function is designed for global filters only. Per-node filters
// (from autogroup:self policies) are already node-specific and should not be passed
@@ -24,7 +22,6 @@ import (
func ReduceFilterRules(
node types.NodeView,
rules []tailcfg.FilterRule,
nodeAddrs *netipx.IPSet,
) []tailcfg.FilterRule {
ret := []tailcfg.FilterRule{}
nodeIPs := node.IPs()
@@ -48,7 +45,7 @@ func ReduceFilterRules(
for _, dest := range rule.DstPorts {
if destReachesNode(dest.IP, nodeIPs, subnetRoutes, exitRoutes) {
dests = appendOwnDests(dests, dest, nodeIPs, subnetRoutes, exitRoutes, nodeAddrs)
dests = append(dests, dest)
}
}
@@ -91,42 +88,6 @@ func destReachesNode(dst string, nodeIPs []netip.Addr, subnetRoutes, exitRoutes
slices.ContainsFunc(exitRoutes, overlaps)
}
// appendOwnDests appends dest, which reaches the node, to dests. A prefix
// made only of node addresses, which no route of the node overlaps, becomes
// one entry per node address inside it; anything else stays whole.
func appendOwnDests(
dests []tailcfg.NetPortRange,
dest tailcfg.NetPortRange,
nodeIPs []netip.Addr,
subnetRoutes, exitRoutes []netip.Prefix,
nodeAddrs *netipx.IPSet,
) []tailcfg.NetPortRange {
pfx, err := netip.ParsePrefix(dest.IP)
if err != nil || !destinationNeedsOwnAddressExpansion(pfx, subnetRoutes, exitRoutes, nodeAddrs) {
return append(dests, dest)
}
for _, ip := range nodeIPs {
if pfx.Contains(ip) {
own := dest
own.IP = ip.String()
dests = append(dests, own)
}
}
return dests
}
func destinationNeedsOwnAddressExpansion(
pfx netip.Prefix,
subnetRoutes, exitRoutes []netip.Prefix,
nodeAddrs *netipx.IPSet,
) bool {
return !pfx.IsSingleIP() && nodeAddrs != nil && nodeAddrs.ContainsPrefix(pfx) &&
!slices.ContainsFunc(subnetRoutes, pfx.Overlaps) &&
!slices.ContainsFunc(exitRoutes, pfx.Overlaps)
}
// reduceCapGrantRule filters a [tailcfg.CapGrant] rule to only include
// [tailcfg.CapGrant] entries whose Dsts match the given node's IPs. When a
// broad prefix (e.g. 100.64.0.0/10 from dst:*) contains a node's IP, it is
+35 -41
View File
@@ -13,7 +13,6 @@ import (
"github.com/juanfont/headscale/hscontrol/util"
"github.com/rs/zerolog/log"
"github.com/stretchr/testify/require"
"go4.org/netipx"
"tailscale.com/net/tsaddr"
"tailscale.com/tailcfg"
"tailscale.com/util/must"
@@ -211,8 +210,10 @@ func TestReduceFilterRules(t *testing.T) {
// Merged: Both ACL rules combined (same SrcIPs)
{
SrcIPs: []string{
"100.64.0.1-100.64.0.2",
"fd7a:115c:a1e0::1-fd7a:115c:a1e0::2",
"100.64.0.1",
"100.64.0.2",
"fd7a:115c:a1e0::1",
"fd7a:115c:a1e0::2",
},
DstPorts: []tailcfg.NetPortRange{
{
@@ -356,8 +357,10 @@ func TestReduceFilterRules(t *testing.T) {
// by exit node routing via AllowedIPs, not by packet filtering.
{
SrcIPs: []string{
"100.64.0.1-100.64.0.2",
"fd7a:115c:a1e0::1-fd7a:115c:a1e0::2",
"100.64.0.1",
"100.64.0.2",
"fd7a:115c:a1e0::1",
"fd7a:115c:a1e0::2",
},
DstPorts: []tailcfg.NetPortRange{
{
@@ -462,8 +465,10 @@ func TestReduceFilterRules(t *testing.T) {
// Here, 64.0.0.0/2 contains 100.64.0.100 (CGNAT range), so it matches.
{
SrcIPs: []string{
"100.64.0.1-100.64.0.2",
"fd7a:115c:a1e0::1-fd7a:115c:a1e0::2",
"100.64.0.1",
"100.64.0.2",
"fd7a:115c:a1e0::1",
"fd7a:115c:a1e0::2",
},
DstPorts: []tailcfg.NetPortRange{
{
@@ -539,8 +544,10 @@ func TestReduceFilterRules(t *testing.T) {
// Merged: Both ACL rules combined (same SrcIPs)
{
SrcIPs: []string{
"100.64.0.1-100.64.0.2",
"fd7a:115c:a1e0::1-fd7a:115c:a1e0::2",
"100.64.0.1",
"100.64.0.2",
"fd7a:115c:a1e0::1",
"fd7a:115c:a1e0::2",
},
DstPorts: []tailcfg.NetPortRange{
{
@@ -623,8 +630,10 @@ func TestReduceFilterRules(t *testing.T) {
// Merged: Both ACL rules combined (same SrcIPs)
{
SrcIPs: []string{
"100.64.0.1-100.64.0.2",
"fd7a:115c:a1e0::1-fd7a:115c:a1e0::2",
"100.64.0.1",
"100.64.0.2",
"fd7a:115c:a1e0::1",
"fd7a:115c:a1e0::2",
},
DstPorts: []tailcfg.NetPortRange{
{
@@ -779,7 +788,7 @@ func TestReduceFilterRules(t *testing.T) {
got, _ := pm.Filter()
t.Logf("full filter:\n%s", must.Get(json.MarshalIndent(got, "", " ")))
got = policyutil.ReduceFilterRules(tt.node.View(), got, nil)
got = policyutil.ReduceFilterRules(tt.node.View(), got)
if diff := cmp.Diff(tt.want, got); diff != "" {
log.Trace().Interface("got", got).Msg("result")
@@ -952,7 +961,7 @@ func TestReduceFilterRulesPartialApproval(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := policyutil.ReduceFilterRules(
tt.node.View(), tt.rules, nil,
tt.node.View(), tt.rules,
)
require.Len(t, got, tt.wantCount,
"rule count mismatch")
@@ -1299,7 +1308,7 @@ func TestReduceFilterRulesCapGrant(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
got := policyutil.ReduceFilterRules(tt.node.View(), tt.rules, nil)
got := policyutil.ReduceFilterRules(tt.node.View(), tt.rules)
require.Len(t, got, len(tt.want),
"rule count mismatch")
@@ -1361,7 +1370,7 @@ func TestReduceFilterRulesDestForms(t *testing.T) {
rule.DstPorts = append(rule.DstPorts, tailcfg.NetPortRange{IP: dst, Ports: tailcfg.PortRangeAny})
}
got := policyutil.ReduceFilterRules(node.View(), []tailcfg.FilterRule{rule}, nil)
got := policyutil.ReduceFilterRules(node.View(), []tailcfg.FilterRule{rule})
require.Len(t, got, 1)
kept := make(map[string]bool)
@@ -1381,13 +1390,6 @@ func TestReduceFilterRulesDestForms(t *testing.T) {
func TestReduceFilterRulesAllocsIndependentOfDests(t *testing.T) {
node := (&types.Node{IPv4: ap("100.64.0.1"), IPv6: ap("fd7a:115c:a1e0::1")}).View()
var b netipx.IPSetBuilder
node.AppendToIPSet(&b)
nodeAddrs, err := b.IPSet()
require.NoError(t, err)
allocs := func(n int) int {
rule := tailcfg.FilterRule{SrcIPs: []string{"*"}}
for i := range n {
@@ -1399,48 +1401,40 @@ func TestReduceFilterRulesAllocsIndependentOfDests(t *testing.T) {
rules := []tailcfg.FilterRule{rule}
return int(testing.AllocsPerRun(10, func() { policyutil.ReduceFilterRules(node, rules, nodeAddrs) }))
return int(testing.AllocsPerRun(10, func() { policyutil.ReduceFilterRules(node, rules) }))
}
require.Equal(t, allocs(10), allocs(1000),
"reducing a filter must not allocate per DstPorts entry")
}
// TestReduceFilterRulesMergedNodeDests checks that a destination merged from
// node addresses shrinks to the node's own addresses, while a written prefix,
// and any destination a router serves, stays whole.
func TestReduceFilterRulesMergedNodeDests(t *testing.T) {
// TestReduceFilterRulesKeepsDestsAsWritten checks that a node keeps the
// destinations that reach it exactly as written: its own addresses, not a
// neighbour's, and a written prefix whole; an exit node keeps them all.
func TestReduceFilterRulesKeepsDestsAsWritten(t *testing.T) {
node := &types.Node{IPv4: ap("100.64.0.6"), IPv6: ap("fd7a:115c:a1e0::6")}
neighbour := &types.Node{IPv4: ap("100.64.0.7"), IPv6: ap("fd7a:115c:a1e0::7")}
var b netipx.IPSetBuilder
node.AppendToIPSet(&b)
neighbour.AppendToIPSet(&b)
nodeAddrs, err := b.IPSet()
require.NoError(t, err)
rules := []tailcfg.FilterRule{{
SrcIPs: []string{"100.64.0.1"},
DstPorts: []tailcfg.NetPortRange{
{IP: "100.64.0.6/31", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "fd7a:115c:a1e0::6/127", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "100.64.0.6", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "100.64.0.7", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "fd7a:115c:a1e0::6", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "100.64.0.0/12", Ports: tailcfg.PortRangeAny},
},
}}
got := policyutil.ReduceFilterRules(node.View(), rules, nodeAddrs)
got := policyutil.ReduceFilterRules(node.View(), rules)
require.Equal(t, []tailcfg.NetPortRange{
{IP: "100.64.0.6", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "fd7a:115c:a1e0::6", Ports: tailcfg.PortRange{First: 22, Last: 22}},
{IP: "100.64.0.0/12", Ports: tailcfg.PortRangeAny},
}, got[0].DstPorts)
// An exit node forwards to every destination, so it keeps them whole.
// An exit node forwards to every destination, so it keeps them all.
node.Hostinfo = &tailcfg.Hostinfo{RoutableIPs: tsaddr.ExitRoutes()}
node.ApprovedRoutes = tsaddr.ExitRoutes()
got = policyutil.ReduceFilterRules(node.View(), rules, nodeAddrs)
got = policyutil.ReduceFilterRules(node.View(), rules)
require.Equal(t, rules[0].DstPorts, got[0].DstPorts)
}
+131 -170
View File
@@ -7,14 +7,12 @@ import (
"slices"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/juanfont/headscale/hscontrol/util"
"github.com/rs/zerolog/log"
"go4.org/netipx"
"tailscale.com/tailcfg"
"tailscale.com/tailcfg/nodecap"
"tailscale.com/tailcfg/peercap"
"tailscale.com/types/views"
"tailscale.com/util/set"
)
// grantCategory classifies a grant by what per-node work it needs.
@@ -144,20 +142,6 @@ func nodeHasUserIdentity(node types.NodeView) bool {
return !node.IsTagged() && node.User().Valid()
}
// nodeAddrSet is the addresses of every node.
func nodeAddrSet(nodes views.Slice[types.NodeView]) *netipx.IPSet {
var b netipx.IPSetBuilder
for _, n := range nodes.All() {
n.AppendToIPSet(&b)
}
// The builder only fails on invalid addresses, which nodes never hold.
set, _ := b.IPSet()
return set
}
// compileNodeAttrs returns the per-node CapMap derived from policy
// nodeAttrs plus the tailnet-wide [Policy.RandomizeClientPort] flag.
//
@@ -368,26 +352,6 @@ func (pol *Policy) compileOneGrant(
return cg, nil
}
// mergeResolvedSrcs merges every prefix from the resolved sources into a
// single [resolved] address set.
func mergeResolvedSrcs(resolvedSrcs []ResolvedAddresses) (resolved, error) {
var b netipx.IPSetBuilder
for _, ips := range resolvedSrcs {
if r, ok := ips.(resolved); ok {
b.AddSet(&r.ips)
continue
}
for _, pref := range ips.Prefixes() {
b.AddPrefix(pref)
}
}
return newResolved(&b)
}
// sourceCache holds each source list's resolution for one compile: an ACL
// compiles to one grant per destination, all sharing its sources, and
// resolving and merging them is most of a wide ACL's compile.
@@ -400,11 +364,11 @@ type sourcesKey struct {
n int
}
// grantSources is a source list resolved per alias, all and without
// wildcards, and its SrcIPs once built.
// grantSources is a source list resolved per alias, and its SrcIPs once
// built.
type grantSources struct {
all, nonWild []ResolvedAddresses
err error
all []ResolvedAddresses
err error
built bool
strs []string
@@ -427,7 +391,7 @@ func (c sourceCache) get(
}
s := &grantSources{}
s.all, s.nonWild, s.err = resolveSources(pol, sources, users, nodes)
s.all, s.err = resolveSources(pol, sources, users, nodes)
if c != nil {
c[key] = s
@@ -441,7 +405,7 @@ func (c sourceCache) get(
// and clipped, so a caller appending to it copies.
func (s *grantSources) strings(hasWildcard, hasDangerAll bool, nodes views.Slice[types.NodeView]) []string {
if !s.built {
s.strs = slices.Clip(buildSrcIPStrings(s.all, s.nonWild, hasWildcard, hasDangerAll, nodes))
s.strs = slices.Clip(buildSrcIPStrings(s.all, hasWildcard, hasDangerAll, nodes))
s.built = true
}
@@ -456,30 +420,21 @@ func (pol *Policy) compileOneViaGrant(
users types.Users,
nodes views.Slice[types.NodeView],
) (*compiledGrant, error) {
resolvedSrcs, _, err := resolveSources(
resolvedSrcs, err := resolveSources(
pol, grant.Sources, users, nodes,
)
if err != nil {
return nil, err
}
if len(resolvedSrcs) == 0 {
return nil, nil //nolint:nilnil
}
// Build merged SrcIPs.
srcResolved, err := mergeResolvedSrcs(resolvedSrcs)
if err != nil {
return nil, err
}
if srcResolved.Empty() {
return nil, nil //nolint:nilnil
}
hasWildcard := sourcesHaveWildcard(grant.Sources)
hasDangerAll := sourcesHaveDangerAll(grant.Sources)
srcIPStrings := buildSrcIPStrings(resolvedSrcs, hasWildcard, hasDangerAll, nodes)
if len(srcIPStrings) == 0 {
return nil, nil //nolint:nilnil
}
resolvedDsts, hasAutoGroupInternet := resolveViaDestinations(
pol, users, nodes, grant.Destinations,
)
@@ -491,29 +446,32 @@ func (pol *Policy) compileOneViaGrant(
resolvedDsts: resolvedDsts,
hasAutoGroupInternet: hasAutoGroupInternet,
internetProtocols: grant.InternetProtocols,
srcIPStrings: srcIPsWithRoutes(
srcResolved, hasWildcard, hasDangerAll, nodes,
),
srcIPStrings: srcIPStrings,
},
}, nil
}
// resolveSources resolves grant sources per-alias, returning the
// resolved addresses and a separate slice of non-wildcard sources.
// This is the canonical source-resolution path. Its output lands in
// [compiledGrant.srcIPStrings] (among other places) and callers on the
// hot path should prefer reading that over calling [Alias.Resolve] again.
// viaRuleKey returns the merge key of a rule of a via grant: Tailscale
// merges a via rule only with via rules through the same tags.
func viaRuleKey(cg *compiledGrant, rule tailcfg.FilterRule) string {
return fmt.Sprintf("via:%v|%s", cg.via.viaTags, filterRuleKey(rule))
}
// resolveSources resolves grant sources per alias. This is the canonical
// source-resolution path. Its output lands in [compiledGrant.srcIPStrings]
// (among other places) and callers on the hot path should prefer reading
// that over calling [Alias.Resolve] again.
func resolveSources(
pol *Policy,
sources Aliases,
users types.Users,
nodes views.Slice[types.NodeView],
) ([]ResolvedAddresses, []ResolvedAddresses, error) {
var all, nonWild []ResolvedAddresses
) ([]ResolvedAddresses, error) {
var all []ResolvedAddresses
for i, src := range sources {
for _, src := range sources {
if ag, ok := src.(*AutoGroup); ok && ag.Is(AutoGroupSelf) {
return nil, nil, errSelfInSources
return nil, errSelfInSources
}
ips, err := src.Resolve(pol, users, nodes)
@@ -524,51 +482,41 @@ func resolveSources(
if ips != nil {
all = append(all, ips)
if _, isWildcard := sources[i].(Asterix); !isWildcard {
nonWild = append(nonWild, ips)
}
}
}
return all, nonWild, nil
return all, nil
}
// buildSrcIPStrings builds the final SrcIPs string slice from
// resolved sources, preserving non-wildcard IPs alongside wildcard
// CGNAT ranges to match Tailscale SaaS behavior.
// buildSrcIPStrings writes sources as Tailscale does: each alias on its
// own, unioned and sorted as text, so a node address stays next to a
// wildcard range that contains it. A wildcard adds every approved subnet
// route; danger-all is "*".
func buildSrcIPStrings(
resolvedSrcs, nonWildcardSrcs []ResolvedAddresses,
resolvedSrcs []ResolvedAddresses,
hasWildcard, hasDangerAll bool,
nodes views.Slice[types.NodeView],
) []string {
srcResolved, err := mergeResolvedSrcs(resolvedSrcs)
if err != nil || srcResolved.Empty() {
var strs []string
for _, src := range resolvedSrcs {
strs = append(strs, src.Strings()...)
}
if len(strs) == 0 {
return nil
}
srcIPStrs := srcIPsWithRoutes(
srcResolved, hasWildcard, hasDangerAll, nodes,
)
// When sources include a wildcard (*) alongside explicit
// sources (tags, groups, etc.), Tailscale preserves the
// individual IPs from non-wildcard sources alongside the
// merged CGNAT ranges rather than absorbing them.
if hasWildcard && len(nonWildcardSrcs) > 0 {
seen := set.SetOf(srcIPStrs)
for _, ips := range nonWildcardSrcs {
for _, s := range ips.Strings() {
if !seen.Contains(s) {
seen.Add(s)
srcIPStrs = append(srcIPStrs, s)
}
}
}
if hasDangerAll {
return []string{"*"}
}
return srcIPStrs
if hasWildcard {
strs = append(strs, approvedSubnetRoutes(nodes)...)
}
slices.Sort(strs)
return slices.Compact(strs)
}
type resolvedDestination struct {
@@ -792,7 +740,7 @@ func filterRulesForNode(
node types.NodeView,
userIdx userNodeIndex,
) []tailcfg.FilterRule {
return rulesForNode(grants, node, userIdx, compileViaForNode)
return rulesForNode(grants, node, userIdx, filterSelfRules, compileViaForNode)
}
// peerRulesForNode returns the rules that decide a node's peers: its
@@ -802,7 +750,7 @@ func peerRulesForNode(
node types.NodeView,
userIdx userNodeIndex,
) []tailcfg.FilterRule {
return rulesForNode(grants, node, userIdx, viaPeerRule)
return rulesForNode(grants, node, userIdx, compileAutogroupSelf, viaPeerRule)
}
// nodeOnlyRules returns the self and via rules a node adds to the
@@ -834,9 +782,13 @@ func rulesForNode(
grants []compiledGrant,
node types.NodeView,
userIdx userNodeIndex,
selfRules func(*compiledGrant, types.NodeView, userNodeIndex) []tailcfg.FilterRule,
viaRules func(*compiledGrant, types.NodeView) []tailcfg.FilterRule,
) []tailcfg.FilterRule {
var rules []tailcfg.FilterRule
var (
rules []tailcfg.FilterRule
keys []string
)
for i := range grants {
cg := &grants[i]
@@ -844,26 +796,26 @@ func rulesForNode(
// Pre-compiled rules apply to all grant categories
// (empty for via-only grants).
rules = append(rules, cg.rules...)
keys = append(keys, ruleKeys(cg.rules)...)
switch cg.category {
case grantCategoryRegular:
// Nothing more to do.
case grantCategorySelf:
rules = append(
rules,
compileAutogroupSelf(cg, node, userIdx)...,
)
self := selfRules(cg, node, userIdx)
rules = append(rules, self...)
keys = append(keys, ruleKeys(self)...)
case grantCategoryVia:
rules = append(
rules,
viaRules(cg, node)...,
)
for _, rule := range viaRules(cg, node) {
rules = append(rules, rule)
keys = append(keys, viaRuleKey(cg, rule))
}
}
}
return mergeFilterRules(rules)
return mergeKeyedRules(rules, keys)
}
// compileAutogroupSelf produces filter rules for autogroup:self
@@ -881,36 +833,27 @@ func compileAutogroupSelf(
return compileSelfForUser(cg, userIdx[node.User().ID()])
}
// exitNodeSelfRules returns the autogroup:self rules of every user
// other than the node's own for an exit node, whose exit routes contain
// every self destination. Only the packet filter needs them: they never
// make the exit node a peer, and expanding every user for peer matching
// would cost O(users) per exit node on each peer map build.
func exitNodeSelfRules(
grants []compiledGrant,
// filterSelfRules returns the autogroup:self rules a node's packet filter
// holds: its own user's, or, on an exit node, whose exit routes contain
// every self destination, every user's in user order, as Tailscale sends
// them. Only the packet filter needs other users' rules: they never make
// the exit node a peer, so the peer paths use [compileAutogroupSelf].
func filterSelfRules(
cg *compiledGrant,
node types.NodeView,
userIdx userNodeIndex,
) []tailcfg.FilterRule {
if !node.IsExitNode() {
return compileAutogroupSelf(cg, node, userIdx)
}
if cg.self == nil {
return nil
}
var rules []tailcfg.FilterRule
for i := range grants {
cg := &grants[i]
if cg.self == nil {
continue
}
for _, uid := range slices.Sorted(maps.Keys(userIdx)) {
// compileAutogroupSelf already covers an untagged node's own user.
if nodeHasUserIdentity(node) && node.User().ID() == uid {
continue
}
rules = append(rules, compileSelfForUser(cg, userIdx[uid])...)
}
for _, uid := range slices.Sorted(maps.Keys(userIdx)) {
rules = append(rules, compileSelfForUser(cg, userIdx[uid])...)
}
return rules
@@ -928,11 +871,10 @@ func compileSelfForUser(
var rules []tailcfg.FilterRule
// Filter sources to only same-user untagged devices.
srcResolved := filterSourcesToSameUser(
cg.self.resolvedSrcs, sameUserNodes,
)
if srcResolved == nil || srcResolved.Empty() {
// Tailscale writes autogroup:self once per source alias, each with the
// same-user devices that alias names.
perSrc, srcResolved := sameUserSources(cg.self.resolvedSrcs, sameUserNodes)
if len(perSrc) == 0 {
return nil
}
@@ -955,11 +897,13 @@ func compileSelfForUser(
}
if len(destPorts) > 0 {
rules = append(rules, tailcfg.FilterRule{
SrcIPs: srcResolved.Strings(),
DstPorts: destPorts,
IPProto: ipp.Protocol.toIANAProtocolNumbers(),
})
for _, src := range perSrc {
rules = append(rules, tailcfg.FilterRule{
SrcIPs: src.Strings(),
DstPorts: destPorts,
IPProto: ipp.Protocol.toIANAProtocolNumbers(),
})
}
}
}
@@ -1008,29 +952,44 @@ func compileSelfForUser(
return rules
}
// filterSourcesToSameUser intersects resolved source addresses with
// same-user untagged device IPs, returning only the addresses that
// belong to those devices.
func filterSourcesToSameUser(
// sameUserSources returns, per source alias, the same-user untagged
// devices it names, and all of them together.
func sameUserSources(
resolvedSrcs []ResolvedAddresses,
sameUserNodes []types.NodeView,
) ResolvedAddresses {
var srcIPs netipx.IPSetBuilder
) ([]ResolvedAddresses, ResolvedAddresses) {
var (
perSrc []ResolvedAddresses
all netipx.IPSetBuilder
)
for _, ips := range resolvedSrcs {
var named netipx.IPSetBuilder
for _, n := range sameUserNodes {
if slices.ContainsFunc(n.IPs(), ips.Contains) {
n.AppendToIPSet(&srcIPs)
n.AppendToIPSet(&named)
n.AppendToIPSet(&all)
}
}
set, err := named.IPSet()
if err != nil || len(set.Ranges()) == 0 {
continue
}
src, _ := newNodeAddresses(set, nil)
perSrc = append(perSrc, src)
}
srcResolved, err := newResolved(&srcIPs)
set, err := all.IPSet()
if err != nil {
return nil
return nil, nil
}
return srcResolved
union, _ := newNodeAddresses(set, nil)
return perSrc, union
}
// viaDstsForNode returns the destinations node serves for a via grant: none
@@ -1039,9 +998,9 @@ func filterSourcesToSameUser(
func viaDstsForNode(
cg *compiledGrant,
node types.NodeView,
) []netip.Prefix {
) ([]netip.Prefix, bool) {
if cg.via == nil {
return nil
return nil, false
}
// Check if node matches any via tag.
@@ -1056,7 +1015,7 @@ func viaDstsForNode(
}
if !matchesVia {
return nil
return nil, false
}
// [types.NodeView.SubnetRoutes] excludes exit routes, so the overlap
@@ -1087,14 +1046,7 @@ func viaDstsForNode(
// to the grant source via [matcher.Match.DestsIsTheInternet].
// [policyutil.ReduceFilterRules] strips the rule from the wire format
// on non-exit advertisers, preserving SaaS PacketFilter encoding.
if cg.via.hasAutoGroupInternet && node.IsExitNode() {
viaDstPrefixes = append(
viaDstPrefixes,
util.TheInternet().Prefixes()...,
)
}
return viaDstPrefixes
return viaDstPrefixes, cg.via.hasAutoGroupInternet && node.IsExitNode()
}
// compileViaForNode produces via-grant filter rules for a specific
@@ -1104,23 +1056,32 @@ func compileViaForNode(
cg *compiledGrant,
node types.NodeView,
) []tailcfg.FilterRule {
viaDstPrefixes := viaDstsForNode(cg, node)
if len(viaDstPrefixes) == 0 {
viaDstPrefixes, internet := viaDstsForNode(cg, node)
if len(viaDstPrefixes) == 0 && !internet {
return nil
}
dsts := make([]string, 0, len(viaDstPrefixes))
for _, prefix := range viaDstPrefixes {
dsts = append(dsts, filterIP(prefix))
}
if internet {
dsts = append(dsts, internetStrings()...)
}
// Build rules using pre-resolved srcIPStrings.
var rules []tailcfg.FilterRule
for _, ipp := range cg.via.internetProtocols {
var destPorts []tailcfg.NetPortRange
for _, prefix := range viaDstPrefixes {
for _, ip := range dsts {
for _, port := range ipp.Ports {
destPorts = append(
destPorts,
tailcfg.NetPortRange{
IP: filterIP(prefix),
IP: ip,
Ports: port,
},
)
@@ -1150,7 +1111,7 @@ func viaPeerRule(
cg *compiledGrant,
node types.NodeView,
) []tailcfg.FilterRule {
if len(viaDstsForNode(cg, node)) == 0 {
if prefixes, internet := viaDstsForNode(cg, node); len(prefixes) == 0 && !internet {
return nil
}
+5 -6
View File
@@ -205,10 +205,10 @@ func assertCompileOtherDestsReference(
) {
t.Helper()
srcs, nonWild, err := resolveSources(pol, grant.Sources, users, nodes.ViewSlice())
srcs, err := resolveSources(pol, grant.Sources, users, nodes.ViewSlice())
require.NoError(t, err)
srcStrings := buildSrcIPStrings(srcs, nonWild,
srcStrings := buildSrcIPStrings(srcs,
sourcesHaveWildcard(grant.Sources), sourcesHaveDangerAll(grant.Sources),
nodes.ViewSlice())
if grant.Sources != nil && len(grant.Sources) == 0 {
@@ -446,10 +446,10 @@ func (dst *countedDestination) Resolve(
func TestCompileOtherDestsResolvesOnce(t *testing.T) {
pol, users, nodes := compileOtherDestsFixture(t, 4, 24)
grant := pol.Grants[0]
srcs, nonWild, err := resolveSources(pol, grant.Sources, users, nodes.ViewSlice())
srcs, err := resolveSources(pol, grant.Sources, users, nodes.ViewSlice())
require.NoError(t, err)
srcStrings := buildSrcIPStrings(srcs, nonWild, true, false, nodes.ViewSlice())
srcStrings := buildSrcIPStrings(srcs, true, false, nodes.ViewSlice())
dst := &countedDestination{Alias: gp("group:all")}
grant.Destinations = Aliases{dst}
@@ -501,7 +501,7 @@ func BenchmarkCompileOtherDests(b *testing.B) {
grant.InternetProtocols, grant.App = grant.InternetProtocols[:1], nil
}
srcs, nonWild, err := resolveSources(
srcs, err := resolveSources(
pol,
grant.Sources,
users,
@@ -511,7 +511,6 @@ func BenchmarkCompileOtherDests(b *testing.B) {
srcStrings := buildSrcIPStrings(
srcs,
nonWild,
true,
false,
nodes.ViewSlice(),
+62 -71
View File
@@ -105,27 +105,6 @@ func sourcesHaveDangerAll(srcs Aliases) bool {
return false
}
// srcIPsWithRoutes returns the [tailcfg.FilterRule.SrcIPs] string slice,
// appending approved subnet routes when the sources include a wildcard.
// When hasDangerAll is true, returns ["*"] to represent all IPs.
func srcIPsWithRoutes(
resolved ResolvedAddresses,
hasWildcard bool,
hasDangerAll bool,
nodes views.Slice[types.NodeView],
) []string {
if hasDangerAll {
return []string{"*"}
}
ips := resolved.Strings()
if hasWildcard {
ips = append(ips, approvedSubnetRoutes(nodes)...)
}
return ips
}
// compileFilterRules takes a set of nodes and a [Policy] and generates a
// set of Tailscale compatible [tailcfg.FilterRule]s used to allow traffic
// on clients.
@@ -188,12 +167,10 @@ func (pol *Policy) destinationsToNetPortRange(
continue
}
prefixes := ips.Prefixes()
for _, pref := range prefixes {
for _, ip := range ips.Strings() {
for _, port := range ports {
ret = append(ret, tailcfg.NetPortRange{
IP: filterIP(pref),
IP: ip,
Ports: port,
})
}
@@ -226,10 +203,7 @@ func (pol *Policy) compileFilterRulesForNode(
grants := pol.compileGrants(users, nodes)
userIdx := buildUserNodeIndex(nodes)
return append(
filterRulesForNode(grants, node, userIdx),
exitNodeSelfRules(grants, node, userIdx)...,
)
return filterRulesForNode(grants, node, userIdx)
}
var sshAccept = tailcfg.SSHAction{
@@ -746,6 +720,45 @@ func filterRuleKey(rule tailcfg.FilterRule) string {
return fmt.Sprintf("%s|%v", strings.Join(rule.SrcIPs, ","), rule.IPProto)
}
// ruleKeys returns each rule's merge key, see [filterRuleKey]. Rules
// sharing a SrcIPs slice, as an ACL's rules do, build its key once.
// [tailcfg.CapGrant] rules get no key: they are never merged.
func ruleKeys(rules []tailcfg.FilterRule) []string {
// sharedSrcIPs identifies a SrcIPs slice by its backing array.
type sharedSrcIPs struct {
first *string
n int
ipProto string
}
built := make(map[sharedSrcIPs]string)
keys := make([]string, len(rules))
for i, rule := range rules {
if len(rule.CapGrant) > 0 {
continue
}
shared := sharedSrcIPs{
n: len(rule.SrcIPs),
ipProto: fmt.Sprint(rule.IPProto),
}
if len(rule.SrcIPs) > 0 {
shared.first = &rule.SrcIPs[0]
}
key, ok := built[shared]
if !ok {
key = filterRuleKey(rule)
built[shared] = key
}
keys[i] = key
}
return keys
}
// mergeFilterRules merges rules with identical [tailcfg.FilterRule.SrcIPs] and
// [tailcfg.FilterRule.IPProto] by combining their [tailcfg.FilterRule.DstPorts].
// DstPorts are NOT deduplicated to match Tailscale behavior.
@@ -758,61 +771,39 @@ func mergeFilterRules(rules []tailcfg.FilterRule) []tailcfg.FilterRule {
return rules
}
// sharedSrcIPs identifies a SrcIPs slice by its backing array.
type sharedSrcIPs struct {
first *string
n int
ipProto string
return mergeKeyedRules(rules, ruleKeys(rules))
}
// mergeKeyedRules merges rules whose keys are equal into the first of them,
// keeping first-appearance order, as Tailscale does. keys[i] is rules[i]'s
// key; [tailcfg.CapGrant] rules pass through.
func mergeKeyedRules(rules []tailcfg.FilterRule, keys []string) []tailcfg.FilterRule {
if len(rules) <= 1 {
return rules
}
keyToIdx := make(map[string]int)
sharedToIdx := make(map[sharedSrcIPs]int)
result := make([]tailcfg.FilterRule, 0, len(rules))
for _, rule := range rules {
// CapGrant rules are not merged — they are structurally
// different from DstPorts rules and passed through as-is.
for i, rule := range rules {
if len(rule.CapGrant) > 0 {
result = append(result, rule)
continue
}
// An ACL compiles to one rule per destination, all with the same
// SrcIPs slice. Build the key of a slice once, or merging them is
// len(src) × len(dst) work.
shared := sharedSrcIPs{
n: len(rule.SrcIPs),
ipProto: fmt.Sprint(rule.IPProto),
}
if len(rule.SrcIPs) > 0 {
shared.first = &rule.SrcIPs[0]
}
idx, exists := sharedToIdx[shared]
if !exists {
key := filterRuleKey(rule)
idx, exists = keyToIdx[key]
if !exists {
idx = len(result)
keyToIdx[key] = idx
}
sharedToIdx[shared] = idx
}
if exists {
// Merge: append DstPorts to existing rule
if idx, ok := keyToIdx[keys[i]]; ok {
result[idx].DstPorts = append(result[idx].DstPorts, rule.DstPorts...)
} else {
// New unique combination
result = append(result, tailcfg.FilterRule{
SrcIPs: rule.SrcIPs,
DstPorts: slices.Clone(rule.DstPorts),
IPProto: rule.IPProto,
})
continue
}
keyToIdx[keys[i]] = len(result)
result = append(result, tailcfg.FilterRule{
SrcIPs: rule.SrcIPs,
DstPorts: slices.Clone(rule.DstPorts),
IPProto: rule.IPProto,
})
}
return result
+42 -27
View File
@@ -153,21 +153,21 @@ func TestParsing(t *testing.T) {
}`,
want: []tailcfg.FilterRule{
{
SrcIPs: []string{"100.64.0.0-100.115.91.255", "100.115.94.0-100.127.255.255", "fd7a:115c:a1e0::/48"},
SrcIPs: []string{"100.115.94.0-100.127.255.255", "100.64.0.0-100.115.91.255", "fd7a:115c:a1e0::/48"},
DstPorts: []tailcfg.NetPortRange{
{IP: "100.100.100.100", Ports: tailcfg.PortRangeAny},
},
IPProto: []int{ProtocolTCP},
},
{
SrcIPs: []string{"100.64.0.0-100.115.91.255", "100.115.94.0-100.127.255.255", "fd7a:115c:a1e0::/48"},
SrcIPs: []string{"100.115.94.0-100.127.255.255", "100.64.0.0-100.115.91.255", "fd7a:115c:a1e0::/48"},
DstPorts: []tailcfg.NetPortRange{
{IP: "100.100.100.100", Ports: tailcfg.PortRange{First: 53, Last: 53}},
},
IPProto: []int{ProtocolUDP},
},
{
SrcIPs: []string{"100.64.0.0-100.115.91.255", "100.115.94.0-100.127.255.255", "fd7a:115c:a1e0::/48"},
SrcIPs: []string{"100.115.94.0-100.127.255.255", "100.64.0.0-100.115.91.255", "fd7a:115c:a1e0::/48"},
DstPorts: []tailcfg.NetPortRange{
{IP: "100.100.100.100", Ports: tailcfg.PortRangeAny},
},
@@ -202,7 +202,7 @@ func TestParsing(t *testing.T) {
`,
want: []tailcfg.FilterRule{
{
SrcIPs: []string{"100.64.0.0-100.115.91.255", "100.115.94.0-100.127.255.255", "fd7a:115c:a1e0::/48"},
SrcIPs: []string{"100.115.94.0-100.127.255.255", "100.64.0.0-100.115.91.255", "fd7a:115c:a1e0::/48"},
DstPorts: []tailcfg.NetPortRange{
{IP: "100.100.100.100", Ports: tailcfg.PortRangeAny},
},
@@ -343,7 +343,7 @@ func TestParsing(t *testing.T) {
`,
want: []tailcfg.FilterRule{
{
SrcIPs: []string{"100.64.0.0-100.115.91.255", "100.115.94.0-100.127.255.255", "fd7a:115c:a1e0::/48"},
SrcIPs: []string{"100.115.94.0-100.127.255.255", "100.64.0.0-100.115.91.255", "fd7a:115c:a1e0::/48"},
DstPorts: []tailcfg.NetPortRange{
{IP: "100.100.100.100", Ports: tailcfg.PortRangeAny},
},
@@ -1497,7 +1497,7 @@ func TestTagUserMutualExclusivity(t *testing.T) {
compiled := pol.compileFilterRulesForNode(users, userNode, nodes.ViewSlice())
userRules := policyutil.ReduceFilterRules(userNode, compiled, nodeAddrSet(nodes.ViewSlice()))
userRules := policyutil.ReduceFilterRules(userNode, compiled)
for _, rule := range userRules {
for _, dst := range rule.DstPorts {
@@ -1519,7 +1519,7 @@ func TestTagUserMutualExclusivity(t *testing.T) {
compiled = pol.compileFilterRulesForNode(users, dbNode, nodes.ViewSlice())
dbRules := policyutil.ReduceFilterRules(dbNode, compiled, nodeAddrSet(nodes.ViewSlice()))
dbRules := policyutil.ReduceFilterRules(dbNode, compiled)
foundServerSrc := false
@@ -1590,7 +1590,7 @@ func TestUserToTagCrossIdentityGrant(t *testing.T) {
compiled := pol.compileFilterRulesForNode(users, taggedNode, nodes.ViewSlice())
rules := policyutil.ReduceFilterRules(taggedNode, compiled, nodeAddrSet(nodes.ViewSlice()))
rules := policyutil.ReduceFilterRules(taggedNode, compiled)
// user1's IP should appear as a source that can reach tag:server.
foundUser1Src := false
@@ -3513,7 +3513,7 @@ func TestSourcesHaveDangerAll(t *testing.T) {
}
}
func TestSrcIPsWithRoutes(t *testing.T) {
func TestBuildSrcIPStrings(t *testing.T) {
t.Parallel()
// Build a resolved address set for a single IP.
@@ -3586,7 +3586,7 @@ func TestSrcIPsWithRoutes(t *testing.T) {
nodes = nodeWithRoutes
}
got := srcIPsWithRoutes(tt.resolved, tt.hasWildcard, tt.hasDangerAll, nodes)
got := buildSrcIPStrings([]ResolvedAddresses{tt.resolved}, tt.hasWildcard, tt.hasDangerAll, nodes)
if tt.hasDangerAll {
assert.Equal(t, []string{"*"}, got)
@@ -3598,6 +3598,26 @@ func TestSrcIPsWithRoutes(t *testing.T) {
}
})
}
// Each alias is written on its own: node addresses stay listed one by
// one next to the wildcard range that contains them, sorted as text.
var pair netipx.IPSetBuilder
pair.AddPrefix(netip.MustParsePrefix("100.64.0.2/31"))
pairSet, err := pair.IPSet()
require.NoError(t, err)
nodeAddrs, err := newNodeAddresses(pairSet, nil)
require.NoError(t, err)
wildcard, err := Asterix(0).Resolve(nil, nil, emptyNodes)
require.NoError(t, err)
want := append(wildcard.Strings(), "100.64.0.2", "100.64.0.3")
slices.Sort(want)
got := buildSrcIPStrings([]ResolvedAddresses{wildcard, nodeAddrs}, true, false, emptyNodes)
assert.Equal(t, want, got, "node addresses must stay listed beside the wildcard range")
}
func TestFilterAllowAllFix(t *testing.T) {
@@ -3771,15 +3791,13 @@ func TestCompileViaGrant(t *testing.T) {
}
// Expected rule for autogroup:internet on a via-tagged exit
// advertiser: SrcIPs scoped to the grant source, DstPorts
// enumerating util.TheInternet() prefixes.
internetDstPorts := make(
[]tailcfg.NetPortRange, 0, len(util.TheInternet().Prefixes()),
)
// advertiser: SrcIPs scoped to the grant source, DstPorts the
// internet's address ranges, as Tailscale writes them.
internetDstPorts := make([]tailcfg.NetPortRange, 0, len(internetStrings()))
for _, p := range util.TheInternet().Prefixes() {
for _, r := range internetStrings() {
internetDstPorts = append(internetDstPorts, tailcfg.NetPortRange{
IP: p.String(),
IP: r,
Ports: tailcfg.PortRangeAny,
})
}
@@ -4262,14 +4280,12 @@ func TestCompileGrantWithAutogroupSelf_GrantPaths(t *testing.T) {
switch tt.name {
case "autogroup:self destination for untagged node produces same-user devices":
// Should produce rules; sources and destinations should only
// include user1's untagged devices (node1 and node2).
// IPs are merged into ranges by IPSet (e.g. "100.64.0.1-100.64.0.2").
// include user1's untagged devices (node1 and node2), each
// address on its own, as Tailscale writes them.
require.NotEmpty(t, got, "expected rules for autogroup:self")
rule := got[0]
// SrcIPs from IPSet may be a merged range.
require.Len(t, rule.SrcIPs, 1)
assert.Equal(t, "100.64.0.1-100.64.0.2", rule.SrcIPs[0],
"SrcIPs should contain merged range for user1 untagged devices")
assert.Equal(t, []string{"100.64.0.1", "100.64.0.2"}, rule.SrcIPs,
"SrcIPs should list user1's untagged devices")
var destIPs []string
for _, dp := range rule.DstPorts {
@@ -4326,10 +4342,9 @@ func TestDestinationsToNetPortRange_AutogroupInternet(t *testing.T) {
// autogroup:internet must surface as DstPorts (not be skipped at
// compile time). The matcher derived from these FilterRules is
// what makes Node.CanAccess return true for exit-node peers via
// DestsIsTheInternet (#3212). The wire format is currently the
// canonical CIDR breakdown of util.TheInternet(); aligning it to
// the SaaS range form is tracked separately.
internetPrefixCount := len(util.TheInternet().Prefixes())
// DestsIsTheInternet (#3212). They are written as the internet's
// address ranges, as Tailscale writes them.
internetPrefixCount := len(internetStrings())
tests := []struct {
name string
+2 -9
View File
@@ -44,9 +44,6 @@ type PolicyManager struct {
nodes views.Slice[types.NodeView]
// nodesByID indexes nodes; see [PolicyManager.cacheableLocked].
nodesByID map[types.NodeID]types.NodeView
// nodeAddrs is every node's addresses, for
// [policyutil.ReduceFilterRules].
nodeAddrs *netipx.IPSet
// resolvedPol is pol with its tags indexed and its groups resolved
// against users and nodes, see [Policy.withNodesByTag] and
@@ -335,7 +332,6 @@ func (pm *PolicyManager) updateLocked() (bool, error) {
pm.resolvedPol = pol
pm.compiledGrants = grants
pm.userNodeIdx = buildUserNodeIndex(pm.nodes)
pm.nodeAddrs = nodeAddrSet(pm.nodes)
pm.needsPerNodeFilter = hasPerNodeGrants(pm.compiledGrants)
pm.viaTargetTags = collectViaTargetTags(pm.compiledGrants)
pm.relayTargetIPs = relayTargetIPs
@@ -1056,13 +1052,10 @@ func (pm *PolicyManager) filterForNodeLocked(
if !pm.needsPerNodeFilter {
unreduced = pm.filter
} else {
unreduced = append(
pm.filterRulesForNodeLocked(node),
exitNodeSelfRules(pm.compiledGrants, node, pm.userNodeIdx)...,
)
unreduced = pm.filterRulesForNodeLocked(node)
}
reduced := policyutil.ReduceFilterRules(node, unreduced, pm.nodeAddrs)
reduced := policyutil.ReduceFilterRules(node, unreduced)
if pm.cacheableLocked(node) {
pm.filterRulesMap.Store(node.ID(), reduced)
}
@@ -19,7 +19,6 @@ import (
"fmt"
"net/netip"
"path/filepath"
"slices"
"strings"
"testing"
@@ -28,10 +27,7 @@ import (
"github.com/juanfont/headscale/hscontrol/policy/policyutil"
"github.com/juanfont/headscale/hscontrol/types"
"github.com/juanfont/headscale/hscontrol/types/testcapture"
"github.com/juanfont/headscale/hscontrol/util"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"go4.org/netipx"
"tailscale.com/tailcfg"
)
@@ -208,90 +204,11 @@ func loadACLTestFile(t *testing.T, path string) *testcapture.Capture {
// aclSkipReasons lists checks where headscale differs from SaaS, keyed
// <test_id>[/<node>]/<check>.
var aclSkipReasons = map[string]string{
"acl-au06/beedrill/filter": srcAddressForm,
"acl-k03/beedrill/filter": srcAddressForm,
"acl-k03/bulbasaur/filter": srcAddressForm,
"acl-k03/charmander/filter": srcAddressForm,
"acl-k03/ivysaur/filter": srcAddressForm,
"acl-k03/kakuna/filter": srcAddressForm,
"acl-k03/squirtle/filter": srcAddressForm,
"acl-k03/venusaur/filter": srcAddressForm,
"acl-k03/weedle/filter": srcAddressForm,
"acl-mr09/beedrill/filter": srcAddressForm,
"acl-mr20/beedrill/filter": srcAddressForm,
"acl-mu07/beedrill/filter": srcAddressForm,
"acl-mu07/bulbasaur/filter": srcAddressForm,
"acl-mu07/charmander/filter": srcAddressForm,
"acl-mu07/ivysaur/filter": srcAddressForm,
"acl-mu07/kakuna/filter": srcAddressForm,
"acl-mu07/squirtle/filter": srcAddressForm,
"acl-mu07/venusaur/filter": srcAddressForm,
"acl-mu07/weedle/filter": srcAddressForm,
"acl-self-plus-dsts/kakuna/filter": srcAddressForm,
"acl-self-plus-dsts/beedrill/filter": srcAddressForm,
"acl-self-plus-dsts/bulbasaur/filter": srcAndSelfDstForm,
"routes-exit-family-ipv4/refused": aclDefaultRouteAccepted,
"routes-exit-family-ipv6/refused": aclDefaultRouteAccepted,
}
const (
srcAddressForm = "FILTER_ADDRESS_FORM: SaaS lists contiguous source addresses one by one, headscale as a range"
srcAndSelfDstForm = "FILTER_ADDRESS_FORM+SELF_DST_REPEAT: sources listed one by one, the autogroup:self destination written once per source alias"
aclDefaultRouteAccepted = "ACL_DEFAULT_ROUTE_ACCEPTED: headscale accepts literal 0.0.0.0/0 and ::/0 ACL destinations; SaaS rejects them and requires * or autogroup:internet"
)
// sourcesAsRanges rewrites each rule's sources as the ranges they cover, so
// that one list of addresses and one range of them compare equal.
func sourcesAsRanges(t *testing.T, rules []tailcfg.FilterRule) []tailcfg.FilterRule {
t.Helper()
out := make([]tailcfg.FilterRule, len(rules))
for i, rule := range rules {
var builder netipx.IPSetBuilder
for _, src := range rule.SrcIPs {
set, err := util.ParseIPSet(src, nil)
require.NoError(t, err)
builder.AddSet(set)
}
set, err := builder.IPSet()
require.NoError(t, err)
rule.SrcIPs = nil
for _, r := range set.Ranges() {
rule.SrcIPs = append(rule.SrcIPs, r.String())
}
out[i] = rule
}
return out
}
// withoutRepeatedDsts drops each rule's repeated destinations, keeping the
// first of each.
func withoutRepeatedDsts(rules []tailcfg.FilterRule) []tailcfg.FilterRule {
out := make([]tailcfg.FilterRule, len(rules))
for i, rule := range rules {
seen := map[string]bool{}
rule.DstPorts = slices.DeleteFunc(slices.Clone(rule.DstPorts), func(dst tailcfg.NetPortRange) bool {
key := dst.IP + ":" + dst.Ports.String()
repeat := seen[key]
seen[key] = true
return repeat
})
out[i] = rule
}
return out
}
const aclDefaultRouteAccepted = "ACL_DEFAULT_ROUTE_ACCEPTED: headscale accepts literal 0.0.0.0/0 and ::/0 ACL destinations; SaaS rejects them and requires * or autogroup:internet"
// TestACLCompat is a data-driven test that loads all ACL-*.json test files
// and compares headscale's ACL engine output against the expected behavior.
@@ -441,29 +358,9 @@ func testACLSuccess(
return policyutil.ReduceFilterRules(
node.View(),
pol.compileFilterRulesForNode(users, node.View(), nodes.ViewSlice()),
nodeAddrSet(nodes.ViewSlice()),
)
}
// How sources and their repeats are written is all this skip may hide.
if reason := aclSkipReasons[key]; reason == srcAddressForm || reason == srcAndSelfDstForm {
pmRules, err := pm.FilterForNode(node.View())
require.NoError(t, err)
want := sourcesAsRanges(t, wantRules)
if reason == srcAndSelfDstForm {
want = withoutRepeatedDsts(want)
}
assert.Empty(t, cmp.Diff(want, sourcesAsRanges(t, pmRules), opts...),
"manager filter differs in more than how it is written")
if compiles {
assert.Empty(t, cmp.Diff(want, sourcesAsRanges(t, compiled()), opts...),
"compiled filter differs in more than how it is written")
}
}
compatCheck(t, aclSkipReasons, key, func() string {
var diffs []string
@@ -139,47 +139,10 @@ func loadGrantTestFile(t *testing.T, path string) *testcapture.Capture {
return c
}
// Skip categories document WHY tests are expected to differ from Tailscale SaaS.
// Tests are grouped by root cause.
var grantSkipReasons = map[string]string{
// SaaS lists contiguous source addresses one by one and writes
// autogroup:internet as address ranges; headscale merges sources into
// ranges and writes the internet as prefixes. The address sets match;
// TestViaGrantMapCompat compares these captures' filters by address.
"via-grant-v52": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v53": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v54": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v55": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v56": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v57": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v58": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v59": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v60": "FILTER_ADDRESS_FORM: same addresses, different wire form and rule order",
"via-grant-v61": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v62": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v93": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v94": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v95": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v96": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v97": "FILTER_ADDRESS_FORM: same addresses, different wire form",
"via-grant-v98": "FILTER_ADDRESS_FORM: same addresses, different wire form",
// Checks keyed <test_id>/<node>/filter: a listed check that matches
// fails, so a fix must delete its entry. Contiguous pinned addresses;
// TestViaGrantHACompat compares these filters by address.
"via-grant-v64/client-a/filter": srcAddressForm,
"via-grant-v64/client-b/filter": srcAddressForm,
"via-grant-v64/plain/filter": srcAddressForm,
"via-grant-v64/srv/filter": srcAddressForm,
"via-grant-v64/via-empty/filter": srcAddressForm,
"via-grant-v64/via-r/filter": srcAddressForm,
"via-grant-v65/client-a/filter": srcAddressForm,
"via-grant-v65/client-b/filter": srcAddressForm,
"via-grant-v65/plain/filter": srcAddressForm,
"via-grant-v65/srv/filter": srcAddressForm,
"via-grant-v65/via-empty/filter": srcAddressForm,
"via-grant-v65/via-r/filter": srcAddressForm,
}
// grantSkipReasons lists checks where headscale differs from SaaS, keyed
// <test_id>[/<node>/<check>]. A listed check that matches fails, so a fix
// must delete its entry.
var grantSkipReasons = map[string]string{}
// TestGrantsCompat is a data-driven test that loads all GRANT-*.json
// test files captured from Tailscale SaaS and compares headscale's grants
@@ -275,7 +238,6 @@ func testGrantSuccess(
gotRules := policyutil.ReduceFilterRules(
node.View(),
pol.compileFilterRulesForNode(users, node.View(), nodes.ViewSlice()),
nodeAddrSet(nodes.ViewSlice()),
)
pmRules, err := pm.FilterForNode(node.View())
@@ -184,11 +184,6 @@ func buildRoutesUsersAndNodes(
var routesSkipReasons = map[string]string{
// SaaS lists contiguous source addresses one by one; headscale merges
// them into ranges.
"routes-m2-member-partial-subnet/r-exit/filter": filterAddressForm,
"routes-m2-member-partial-subnet/r-multi/filter": filterAddressForm,
"routes-m4-member-self/m-odin1/filter": filterAddressForm,
"routes-m4-member-self/m-odin2/filter": filterAddressForm,
"routes-m4-member-self/r-exit/filter": "FILTER_ADDRESS_FORM: same addresses, different wire form and rule order",
}
// routesNotCompared lists, by key prefix, checks left out: SaaS's answer
@@ -265,8 +260,6 @@ func notCompared(prefixes []string, key string) bool {
})
}
const filterAddressForm = "FILTER_ADDRESS_FORM: same addresses, different wire form"
// routesSetByAPI reports whether the capture's routes were approved through
// the routes API rather than by the policy.
func routesSetByAPI(c *testcapture.Capture) bool {
@@ -357,7 +350,6 @@ func TestRoutesCompat(t *testing.T) {
gotRules := policyutil.ReduceFilterRules(
node.View(),
compiledRules,
nodeAddrSet(nodes.ViewSlice()),
)
wantRules := capture.PacketFilterRules
@@ -33,17 +33,7 @@ import (
// policySequenceSkipReasons lists checks where headscale differs from SaaS,
// keyed <test_id>/<step>/<node>/<check>. A listed check that matches fails,
// so a fix must delete its entry.
var policySequenceSkipReasons = map[string]string{
"policy-generation/G0/rt/filter": viaRuleMerged,
"policy-generation/G1/rt/filter": viaRuleMerged,
"policy-generation/G2/rt/filter": viaRuleMerged,
"policy-generation/G3/rt/filter": viaRuleMerged,
"policy-generation/G3/rt-b/filter": viaRuleMerged,
"policy-generation/G4/rt-b/filter": viaRuleMerged,
"policy-generation/G5/rt-b/filter": viaRuleMerged,
}
const viaRuleMerged = "VIA_RULE_MERGED: on a via router headscale merges the via grant's filter rule with an ACL rule of the same sources; SaaS sends the two apart"
var policySequenceSkipReasons = map[string]string{}
// policySequenceNotCompared lists, by key prefix, checks left out: SaaS's
// answer there is in doubt, so it is no reference.
+52 -5
View File
@@ -211,6 +211,10 @@ var (
type resolved struct {
ips netipx.IPSet
// wire is the alias as Tailscale writes it in a filter rule; nil
// writes ips as ranges and prefixes.
wire []string
}
func newResolved(ipb *netipx.IPSetBuilder) (resolved, error) {
@@ -230,6 +234,35 @@ func newResolvedAddresses(ips *netipx.IPSet, err error) (ResolvedAddresses, erro
return resolved{ips: *ips}, err
}
// newNodeAddresses wraps the addresses of the nodes an alias names.
// Tailscale writes each node address on its own, never merged into a
// range with its neighbours.
func newNodeAddresses(ips *netipx.IPSet, err error) (ResolvedAddresses, error) {
if ips == nil {
return nil, err
}
res := resolved{ips: *ips}
for addr := range util.IPSetAddrIter(ips) {
res.wire = append(res.wire, addr.String())
}
return res, err
}
// internetStrings writes [util.TheInternet] as Tailscale does: one address
// range per span, also where a span is a prefix.
var internetStrings = sync.OnceValue(func() []string {
ranges := util.TheInternet().Ranges()
out := make([]string, 0, len(ranges))
for _, r := range ranges {
out = append(out, r.String())
}
return out
})
func ipSetToStrings(ips *netipx.IPSet) []string {
var result []string
@@ -251,6 +284,10 @@ func ipSetToStrings(ips *netipx.IPSet) []string {
}
func (res resolved) Strings() []string {
if res.wire != nil {
return slices.Clip(res.wire)
}
return ipSetToStrings(&res.ips)
}
@@ -492,7 +529,7 @@ func (u *Username) resolveUser(users types.Users) (types.User, error) {
}
func (u *Username) Resolve(_ *Policy, users types.Users, nodes views.Slice[types.NodeView]) (ResolvedAddresses, error) {
return newResolvedAddresses(u.resolve(nil, users, nodes))
return newNodeAddresses(u.resolve(nil, users, nodes))
}
func (u *Username) resolve(_ *Policy, users types.Users, nodes views.Slice[types.NodeView]) (*netipx.IPSet, error) {
@@ -591,7 +628,7 @@ func (g *Group) MarshalJSON() ([]byte, error) {
}
func (g *Group) Resolve(p *Policy, users types.Users, nodes views.Slice[types.NodeView]) (ResolvedAddresses, error) {
return newResolvedAddresses(g.resolve(p, users, nodes))
return newNodeAddresses(g.resolve(p, users, nodes))
}
func (g *Group) resolve(p *Policy, users types.Users, nodes views.Slice[types.NodeView]) (*netipx.IPSet, error) {
@@ -657,7 +694,7 @@ func (t *Tag) UnmarshalJSON(b []byte) error {
}
func (t *Tag) Resolve(p *Policy, users types.Users, nodes views.Slice[types.NodeView]) (ResolvedAddresses, error) {
return newResolvedAddresses(t.resolve(p, users, nodes))
return newNodeAddresses(t.resolve(p, users, nodes))
}
func (t *Tag) resolve(p *Policy, users types.Users, nodes views.Slice[types.NodeView]) (*netipx.IPSet, error) {
@@ -875,7 +912,17 @@ func (ag *AutoGroup) MarshalJSON() ([]byte, error) {
}
func (ag *AutoGroup) Resolve(p *Policy, users types.Users, nodes views.Slice[types.NodeView]) (ResolvedAddresses, error) {
return newResolvedAddresses(ag.resolve(p, users, nodes))
ips, err := ag.resolve(p, users, nodes)
switch *ag {
case AutoGroupMember, AutoGroupTagged:
return newNodeAddresses(ips, err)
case AutoGroupInternet:
return resolved{ips: *ips, wire: internetStrings()}, err
case AutoGroupSelf, AutoGroupDangerAll, AutoGroupNonRoot:
}
return newResolvedAddresses(ips, err)
}
func (ag *AutoGroup) resolve(p *Policy, users types.Users, nodes views.Slice[types.NodeView]) (*netipx.IPSet, error) {
@@ -2502,7 +2549,7 @@ func validateGrantSrcDstCombination(sources Aliases, destinations Aliases) error
// not known before the policy is compiled.
func minDstPrefixes(dst Alias) int64 {
if ag, ok := dst.(*AutoGroup); ok && ag.Is(AutoGroupInternet) {
return int64(len(util.TheInternet().Prefixes()))
return int64(len(internetStrings()))
}
return 1
+2 -2
View File
@@ -6550,9 +6550,9 @@ func TestUnmarshalPolicyMaxDstPorts(t *testing.T) {
wantErr: true,
},
{
name: "autogroup:internet counts as its prefixes",
name: "autogroup:internet counts as its address ranges",
policy: `{"grants": [` +
grant("", "autogroup:internet", 100, ports(100)) + `]}`,
grant("", "autogroup:internet", 150, ports(100)) + `]}`,
wantErr: true,
},
{