From 70c68bee01e9973e0caae2942714649828bcf170 Mon Sep 17 00:00:00 2001 From: Michael Gooden Date: Mon, 14 Sep 2026 14:52:48 +0200 Subject: [PATCH] Add tests for octet-aligned and -unaligned PTR generation --- hscontrol/util/dns_test.go | 112 ++++++++++++++++++++++++++++++++++++- 1 file changed, 110 insertions(+), 2 deletions(-) diff --git a/hscontrol/util/dns_test.go b/hscontrol/util/dns_test.go index f16ab8dda..56cc05739 100644 --- a/hscontrol/util/dns_test.go +++ b/hscontrol/util/dns_test.go @@ -20,8 +20,116 @@ func TestMagicDNSRootDomains100(t *testing.T) { func TestMagicDNSRootDomains172(t *testing.T) { domains := GenerateIPv4DNSRootDomain(netip.MustParsePrefix("172.16.0.0/16")) - assert.Contains(t, domains, must.Get(dnsname.ToFQDN("0.16.172.in-addr.arpa."))) - assert.Contains(t, domains, must.Get(dnsname.ToFQDN("255.16.172.in-addr.arpa."))) + assert.Len(t, domains, 1) + assert.Contains(t, domains, must.Get(dnsname.ToFQDN("16.172.in-addr.arpa."))) +} + +// An octet-aligned mask has no wildcard bits, so it must yield exactly one +// reverse-DNS name. Enumerating the next octet instead emits all 256 children +// of that name, which overruns the search-domain limits of stub resolvers. +func TestMagicDNSRootDomainsOctetAligned(t *testing.T) { + for _, tt := range []struct { + prefix string + want string + }{ + {prefix: "100.0.0.0/8", want: "100.in-addr.arpa."}, + {prefix: "100.120.0.0/16", want: "120.100.in-addr.arpa."}, + {prefix: "100.120.0.0/24", want: "0.120.100.in-addr.arpa."}, + {prefix: "100.120.0.5/32", want: "5.0.120.100.in-addr.arpa."}, + } { + t.Run(tt.prefix, func(t *testing.T) { + domains := GenerateIPv4DNSRootDomain(netip.MustParsePrefix(tt.prefix)) + + assert.Len(t, domains, 1) + assert.Contains(t, domains, must.Get(dnsname.ToFQDN(tt.want))) + }) + } +} + +// An unaligned mask stops inside an octet, leaving wildcard bits that must +// enumerate every value that octet takes within the prefix. RFC1035 reverse +// delegation is per-octet, so a mask longer than /24 enumerates host names +// rather than delegating classlessly (RFC2317), which is what Tailscale +// expects. These counts and boundaries are unchanged by the aligned-mask case. +func TestMagicDNSRootDomainsUnaligned(t *testing.T) { + for _, tt := range []struct { + prefix string + count int + first string + last string + absent []string + }{ + { + prefix: "10.0.0.0/9", + count: 128, + first: "0.10.in-addr.arpa.", + last: "127.10.in-addr.arpa.", + absent: []string{"128.10.in-addr.arpa."}, + }, + { + prefix: "100.64.0.0/10", + count: 64, + first: "64.100.in-addr.arpa.", + last: "127.100.in-addr.arpa.", + absent: []string{ + "63.100.in-addr.arpa.", + "128.100.in-addr.arpa.", + }, + }, + { + prefix: "172.16.0.0/12", + count: 16, + first: "16.172.in-addr.arpa.", + last: "31.172.in-addr.arpa.", + absent: []string{ + "15.172.in-addr.arpa.", + "32.172.in-addr.arpa.", + }, + }, + { + prefix: "100.120.0.0/17", + count: 128, + first: "0.120.100.in-addr.arpa.", + last: "127.120.100.in-addr.arpa.", + absent: []string{"128.120.100.in-addr.arpa."}, + }, + { + prefix: "192.168.0.0/23", + count: 2, + first: "0.168.192.in-addr.arpa.", + last: "1.168.192.in-addr.arpa.", + absent: []string{"2.168.192.in-addr.arpa."}, + }, + { + prefix: "100.120.0.0/25", + count: 128, + first: "0.0.120.100.in-addr.arpa.", + last: "127.0.120.100.in-addr.arpa.", + absent: []string{"128.0.120.100.in-addr.arpa."}, + }, + { + prefix: "100.120.0.4/30", + count: 4, + first: "4.0.120.100.in-addr.arpa.", + last: "7.0.120.100.in-addr.arpa.", + absent: []string{ + "3.0.120.100.in-addr.arpa.", + "8.0.120.100.in-addr.arpa.", + }, + }, + } { + t.Run(tt.prefix, func(t *testing.T) { + domains := GenerateIPv4DNSRootDomain(netip.MustParsePrefix(tt.prefix)) + + assert.Len(t, domains, tt.count) + assert.Contains(t, domains, must.Get(dnsname.ToFQDN(tt.first))) + assert.Contains(t, domains, must.Get(dnsname.ToFQDN(tt.last))) + + for _, dom := range tt.absent { + assert.NotContains(t, domains, must.Get(dnsname.ToFQDN(dom))) + } + }) + } } // Happens when netmask is a multiple of 4 bits (sounds likely).