Merge branch 'main' into fix/quickstart-subnet-and-domain-alias

client/anonymize/anonymize.go

@@ -305,12 +305,6 @@ func (a *Anonymizer) AnonymizeDomain(domain string) string {
 		return domain
 	}
 
-	// A reverse zone names an address prefix, so it follows the address rules,
-	// which also keeps its digit labels intact.
-	if zone, ok := a.anonymizeReverseZone(baseDomain); ok {
-		return withTrailingDot(zone, hasDot)
-	}
-
 	if suffix := protectedSuffix(baseDomain); suffix != "" {
 		if a.level < LevelStrict || baseDomain == suffix || suffix == infraDomain {
 			return domain
@@ -411,10 +405,6 @@ func (a *Anonymizer) AnonymizeString(str string) string {
 	ipv4Regex := regexp.MustCompile(`\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b`)
 	ipv6Regex := regexp.MustCompile(`\b([0-9a-fA-F:]+:+[0-9a-fA-F]{0,4})(?:%[0-9a-zA-Z]+)?(?:\/[0-9]{1,3})?(?::[0-9]{1,5})?\b`)
 
-	// Reverse zones go first and are then held out of the passes below: their
-	// labels are digits, which the address patterns would otherwise consume.
-	str, restoreZones := a.replaceReverseZones(str)
-
 	str = ipv4Regex.ReplaceAllStringFunc(str, a.AnonymizeIPString)
 	str = ipv6Regex.ReplaceAllStringFunc(str, a.AnonymizeIPString)
 
@@ -435,7 +425,7 @@ func (a *Anonymizer) AnonymizeString(str string) string {
 		str = wgKeyRegex.ReplaceAllStringFunc(str, a.AnonymizeWGKey)
 	}
 
-	return restoreZones(str)
+	return str
 }
 
 // sortedDomains returns the domain mappings longest-first, so a full-FQDN

client/anonymize/reverse_zone.go

@@ -1,174 +0,0 @@
-package anonymize
-
-import (
-	"encoding/hex"
-	"net/netip"
-	"regexp"
-	"strconv"
-	"strings"
-)
-
-const (
-	reverseZoneSuffixV4 = ".in-addr.arpa"
-	reverseZoneSuffixV6 = ".ip6.arpa"
-
-	v6Nibbles = 32
-	v4Octets  = 4
-)
-
-// reverseZoneRegexes match a reverse zone or a full reverse name in free text.
-// They are applied before the address passes of AnonymizeString, whose IPv4
-// pattern would otherwise consume the digit labels of a zone and replace parts
-// of it with unrelated addresses.
-var reverseZoneRegexes = []*regexp.Regexp{
-	regexp.MustCompile(`(?:[0-9]{1,3}\.){1,4}in-addr\.arpa\b`),
-	regexp.MustCompile(`(?:[0-9a-fA-F]\.){1,32}ip6\.arpa\b`),
-}
-
-// anonymizeReverseZone maps a reverse zone to the zone of the anonymized form
-// of the prefix it encodes, so it follows the address rules rather than the
-// domain ones: the zone of an address that is preserved is preserved too, and
-// the zone of one that is replaced names the replacement. This keeps a reverse
-// zone recognizable as such, and consistent with the addresses it belongs to
-// elsewhere in the same output. It reports false for anything that is not a
-// reverse zone.
-func (a *Anonymizer) anonymizeReverseZone(domain string) (string, bool) {
-	prefix, labelCount, suffix, ok := parseReverseZone(domain)
-	if !ok {
-		return "", false
-	}
-
-	anonymized := a.AnonymizeIP(prefix)
-	if anonymized == prefix {
-		return domain, true
-	}
-
-	return reverseZoneName(anonymized, labelCount) + suffix, true
-}
-
-// replaceReverseZones anonymizes every reverse zone in str and swaps each one
-// for a placeholder, returning a function that puts the anonymized zones back.
-// The placeholders carry no dots, digits or colons, so no later pass matches
-// them.
-func (a *Anonymizer) replaceReverseZones(str string) (string, func(string) string) {
-	var zones []string
-
-	for _, re := range reverseZoneRegexes {
-		str = re.ReplaceAllStringFunc(str, func(match string) string {
-			zone, ok := a.anonymizeReverseZone(match)
-			if !ok {
-				return match
-			}
-
-			zones = append(zones, zone)
-			return reverseZonePlaceholder(len(zones) - 1)
-		})
-	}
-
-	if len(zones) == 0 {
-		return str, func(s string) string { return s }
-	}
-
-	return str, func(s string) string {
-		for i, zone := range zones {
-			s = strings.ReplaceAll(s, reverseZonePlaceholder(i), zone)
-		}
-		return s
-	}
-}
-
-func reverseZonePlaceholder(index int) string {
-	return "\x00reversezone" + strconv.Itoa(index) + "\x00"
-}
-
-// parseReverseZone turns a reverse zone into the address of the prefix its
-// labels spell backwards, padding the absent low-order part with zeroes, and
-// returns the label count and zone suffix so the name can be rebuilt.
-func parseReverseZone(domain string) (netip.Addr, int, string, bool) {
-	lower := strings.ToLower(domain)
-
-	switch {
-	case strings.HasSuffix(lower, reverseZoneSuffixV4):
-		labels := strings.Split(strings.TrimSuffix(lower, reverseZoneSuffixV4), ".")
-		addr, ok := reverseZoneAddrV4(labels)
-		return addr, len(labels), reverseZoneSuffixV4, ok
-	case strings.HasSuffix(lower, reverseZoneSuffixV6):
-		labels := strings.Split(strings.TrimSuffix(lower, reverseZoneSuffixV6), ".")
-		addr, ok := reverseZoneAddrV6(labels)
-		return addr, len(labels), reverseZoneSuffixV6, ok
-	default:
-		return netip.Addr{}, 0, "", false
-	}
-}
-
-func reverseZoneAddrV4(labels []string) (netip.Addr, bool) {
-	if len(labels) == 0 || len(labels) > v4Octets {
-		return netip.Addr{}, false
-	}
-
-	var octets [v4Octets]byte
-	for i, label := range labels {
-		octet, err := strconv.ParseUint(label, 10, 8)
-		if err != nil {
-			return netip.Addr{}, false
-		}
-		octets[len(labels)-1-i] = byte(octet)
-	}
-
-	return netip.AddrFrom4(octets), true
-}
-
-func reverseZoneAddrV6(labels []string) (netip.Addr, bool) {
-	if len(labels) == 0 || len(labels) > v6Nibbles {
-		return netip.Addr{}, false
-	}
-
-	nibbles := make([]byte, 0, v6Nibbles)
-	for i := len(labels) - 1; i >= 0; i-- {
-		if len(labels[i]) != 1 || !isHexDigit(labels[i][0]) {
-			return netip.Addr{}, false
-		}
-		nibbles = append(nibbles, labels[i][0])
-	}
-	for len(nibbles) < v6Nibbles {
-		nibbles = append(nibbles, '0')
-	}
-
-	var groups []string
-	for i := 0; i < len(nibbles); i += 4 {
-		groups = append(groups, string(nibbles[i:i+4]))
-	}
-
-	addr, err := netip.ParseAddr(strings.Join(groups, ":"))
-	if err != nil {
-		return netip.Addr{}, false
-	}
-
-	return addr, true
-}
-
-// reverseZoneName spells the first labelCount labels of addr backwards, the
-// inverse of parseReverseZone, without the zone suffix.
-func reverseZoneName(addr netip.Addr, labelCount int) string {
-	labels := make([]string, 0, labelCount)
-
-	if addr.Is4() {
-		octets := addr.As4()
-		for i := labelCount - 1; i >= 0; i-- {
-			labels = append(labels, strconv.Itoa(int(octets[i])))
-		}
-		return strings.Join(labels, ".")
-	}
-
-	address := addr.As16()
-	nibbles := hex.EncodeToString(address[:])
-	for i := labelCount - 1; i >= 0; i-- {
-		labels = append(labels, string(nibbles[i]))
-	}
-
-	return strings.Join(labels, ".")
-}
-
-func isHexDigit(c byte) bool {
-	return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F'
-}

client/anonymize/reverse_zone_test.go

@@ -1,171 +0,0 @@
-package anonymize
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-)
-
-func newLeveledAnonymizer(level Level) *Anonymizer {
-	a := NewAnonymizer(DefaultAddresses())
-	a.SetLevel(level)
-	return a
-}
-
-// TestAnonymizeDomainReverseZone covers reverse zones going through the address
-// rules instead of the domain ones, so a zone stays a zone and an address that
-// is preserved keeps the zone that names it.
-func TestAnonymizeDomainReverseZone(t *testing.T) {
-	// 100.64.0.0/10 is the overlay range, which is CGNAT: preserved at the
-	// default level and replaced from the internal pool at the strict one
-	const overlayZone = "64.100.in-addr.arpa"
-
-	t.Run("overlay zone preserved at the default level", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-		assert.Equal(t, overlayZone, a.AnonymizeDomain(overlayZone), "should keep the zone of a preserved address")
-	})
-
-	t.Run("private zone preserved at the default level", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-		assert.Equal(t, "168.192.in-addr.arpa", a.AnonymizeDomain("168.192.in-addr.arpa"), "should keep the zone of a private address")
-	})
-
-	t.Run("overlay zone replaced at the strict level", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelStrict)
-
-		got := a.AnonymizeDomain(overlayZone)
-		require.True(t, strings.HasSuffix(got, reverseZoneSuffixV4), "should stay a reverse zone, got %q", got)
-		assert.NotEqual(t, overlayZone, got, "should replace the encoded prefix")
-		assert.Len(t, strings.Split(strings.TrimSuffix(got, reverseZoneSuffixV4), "."), 2,
-			"should keep the label count, got %q", got)
-	})
-
-	t.Run("public zone replaced at the default level", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		got := a.AnonymizeDomain("113.0.203.in-addr.arpa")
-		require.True(t, strings.HasSuffix(got, reverseZoneSuffixV4), "should stay a reverse zone, got %q", got)
-		assert.NotEqual(t, "113.0.203.in-addr.arpa", got, "should replace a public prefix")
-	})
-
-	t.Run("zone of an address keeps that address mapping", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		anonymizedAddr := a.AnonymizeIPString("203.0.113.7")
-		got := a.AnonymizeDomain("7.113.0.203.in-addr.arpa")
-
-		octets := strings.Split(anonymizedAddr, ".")
-		want := octets[3] + "." + octets[2] + "." + octets[1] + "." + octets[0] + reverseZoneSuffixV4
-		assert.Equal(t, want, got, "should name the same replacement as the address itself")
-	})
-
-	t.Run("ipv6 nibble labels stay single digits", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		zone := "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0" + reverseZoneSuffixV6
-		got := a.AnonymizeDomain(zone)
-
-		require.True(t, strings.HasSuffix(got, reverseZoneSuffixV6), "should stay a reverse zone, got %q", got)
-		labels := strings.Split(strings.TrimSuffix(got, reverseZoneSuffixV6), ".")
-		assert.Len(t, labels, 28, "should keep every nibble label, got %q", got)
-		for _, label := range labels {
-			assert.Len(t, label, 1, "nibble label %q should stay a single digit", label)
-		}
-	})
-
-	t.Run("trailing dot is kept", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-		assert.Equal(t, "64.100.in-addr.arpa.", a.AnonymizeDomain("64.100.in-addr.arpa."), "should keep the trailing dot")
-	})
-
-	t.Run("a domain that only looks like a zone is anonymized as a domain", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		got := a.AnonymizeDomain("not-a-zone.in-addr.arpa")
-		assert.NotContains(t, got, "in-addr.arpa", "should fall back to domain anonymization")
-	})
-}
-
-// TestAnonymizeStringReverseZone verifies that a zone inside free text, such as
-// a DNS log line, is not chewed up by the address passes. The IPv4 pattern
-// matches any run of dotted digits, which a reverse zone is made of.
-func TestAnonymizeStringReverseZone(t *testing.T) {
-	t.Run("ipv6 zone survives the address passes", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		zone := "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0" + reverseZoneSuffixV6
-		got := a.AnonymizeString("question: domain=" + zone + " type=PTR")
-
-		assert.Contains(t, got, "type=PTR", "should keep the rest of the line")
-		assert.NotContains(t, got, "198.51.100", "should not rewrite nibble labels as an address")
-
-		labels := strings.Split(strings.TrimSuffix(strings.TrimPrefix(got, "question: domain="), reverseZoneSuffixV6+" type=PTR"), ".")
-		assert.Len(t, labels, 28, "should keep every nibble label, got %q", got)
-	})
-
-	t.Run("preserved ipv4 zone is untouched", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		line := "reverse zone 64.100.in-addr.arpa registered"
-		assert.Equal(t, line, a.AnonymizeString(line), "should keep the zone of a preserved address")
-	})
-
-	t.Run("public ipv4 zone is replaced consistently", func(t *testing.T) {
-		a := newLeveledAnonymizer(LevelDefault)
-
-		got := a.AnonymizeString("zone 113.0.203.in-addr.arpa and address 203.0.113.7")
-		assert.NotContains(t, got, "113.0.203.in-addr.arpa", "should replace the zone")
-		assert.NotContains(t, got, "203.0.113.7", "should replace the address")
-		assert.Contains(t, got, reverseZoneSuffixV4, "should keep the zone suffix")
-	})
-}
-
-func TestParseReverseZone(t *testing.T) {
-	tests := []struct {
-		name   string
-		zone   string
-		addr   string
-		labels int
-	}{
-		{name: "v4 two labels", zone: "0.100" + reverseZoneSuffixV4, addr: "100.0.0.0", labels: 2},
-		{name: "v4 three labels", zone: "1.168.192" + reverseZoneSuffixV4, addr: "192.168.1.0", labels: 3},
-		{name: "v4 full address", zone: "7.113.0.203" + reverseZoneSuffixV4, addr: "203.0.113.7", labels: 4},
-		{
-			name:   "v6 prefix",
-			zone:   "0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.2.0.0.0" + reverseZoneSuffixV6,
-			addr:   "2::",
-			labels: 28,
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			addr, labels, suffix, ok := parseReverseZone(tc.zone)
-			require.True(t, ok, "should decode the reverse zone")
-			assert.Equal(t, tc.addr, addr.String(), "should decode to the encoded prefix")
-			assert.Equal(t, tc.labels, labels, "should count the labels")
-			assert.Equal(t, tc.zone, reverseZoneName(addr, labels)+suffix, "should re-encode to the original zone")
-		})
-	}
-}
-
-func TestParseReverseZoneRejectsNonZones(t *testing.T) {
-	tests := []string{
-		"example.com",
-		"in-addr.arpa",
-		"x.100" + reverseZoneSuffixV4,
-		"256" + reverseZoneSuffixV4,
-		"1.2.3.4.5" + reverseZoneSuffixV4,
-		"ab" + reverseZoneSuffixV6,
-		"g" + reverseZoneSuffixV6,
-	}
-
-	for _, zone := range tests {
-		t.Run(zone, func(t *testing.T) {
-			_, _, _, ok := parseReverseZone(zone)
-			assert.False(t, ok, "should reject %q", zone)
-		})
-	}
-}

client/cmd/login.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"os"
 	"os/user"
+	"runtime"
 	"strings"
 
 	log "github.com/sirupsen/logrus"
@@ -120,7 +121,7 @@ func doDaemonLogin(ctx context.Context, cmd *cobra.Command, providedSetupKey str
 	loginRequest := proto.LoginRequest{
 		SetupKey:            providedSetupKey,
 		ManagementUrl:       managementURL,
-		IsUnixDesktopClient: util.HasGraphicalSession(),
+		IsUnixDesktopClient: isUnixRunningDesktop(),
 		Hostname:            hostName,
 		DnsLabels:           dnsLabelsReq,
 		ProfileName:         &handle,
@@ -188,8 +189,7 @@ func doExtendSession(ctx context.Context, cmd *cobra.Command) error {
 
 	client := proto.NewDaemonServiceClient(conn)
 
-	// the CLI runs in the user's session, the daemon does not: tell it what we can see
-	req := &proto.RequestExtendAuthSessionRequest{HasGraphicalSession: util.HasGraphicalSession()}
+	req := &proto.RequestExtendAuthSessionRequest{}
 	// Pre-fill the IdP login hint from the active profile so the user
 	// doesn't have to retype their email. Best-effort: we still proceed
 	// without a hint if the lookup fails.
@@ -408,7 +408,7 @@ func foregroundGetTokenInfo(ctx context.Context, cmd *cobra.Command, config *pro
 		hint = profileState.Email
 	}
 
-	oAuthFlow, err := auth.NewOAuthFlow(ctx, config, util.HasGraphicalSession(), false, hint)
+	oAuthFlow, err := auth.NewOAuthFlow(ctx, config, isUnixRunningDesktop(), false, hint)
 	if err != nil {
 		return nil, err
 	}
@@ -458,6 +458,14 @@ func openURL(cmd *cobra.Command, verificationURIComplete, userCode string, noBro
 	}
 }
 
+// isUnixRunningDesktop checks if a Linux OS is running desktop environment
+func isUnixRunningDesktop() bool {
+	if runtime.GOOS != "linux" && runtime.GOOS != "freebsd" {
+		return false
+	}
+	return os.Getenv("DESKTOP_SESSION") != "" || os.Getenv("XDG_CURRENT_DESKTOP") != ""
+}
+
 func setEnvAndFlags(cmd *cobra.Command) error {
 	SetFlagsFromEnvVars(rootCmd)
 

client/cmd/up.go

@@ -21,8 +21,8 @@ import (
 	"github.com/netbirdio/netbird/client/internal"
 	"github.com/netbirdio/netbird/client/internal/peer"
 	"github.com/netbirdio/netbird/client/internal/profilemanager"
-	nbnet "github.com/netbirdio/netbird/client/net"
 	"github.com/netbirdio/netbird/client/proto"
+	nbnet "github.com/netbirdio/netbird/client/net"
 	"github.com/netbirdio/netbird/client/server"
 	"github.com/netbirdio/netbird/client/system"
 	"github.com/netbirdio/netbird/shared/management/domain"
@@ -626,7 +626,7 @@ func setupLoginRequest(providedSetupKey string, customDNSAddressConverted []byte
 		NatExternalIPs:      natExternalIPs,
 		CleanNATExternalIPs: natExternalIPs != nil && len(natExternalIPs) == 0,
 		CustomDNSAddress:    customDNSAddressConverted,
-		IsUnixDesktopClient: util.HasGraphicalSession(),
+		IsUnixDesktopClient: isUnixRunningDesktop(),
 		Hostname:            hostName,
 		ExtraIFaceBlacklist: extraIFaceBlackList,
 		DnsLabels:           dnsLabels,

client/internal/debug/debug.go

@@ -51,7 +51,6 @@ nftables.txt: Anonymized nftables rules with packet counters across all families
 sysctls.txt: Forwarding, reverse-path filter, source-validation, and conntrack accounting sysctl values that the NetBird client may read or modify, if --system-info flag was provided (Linux only).
 resolv.conf: DNS resolver configuration from /etc/resolv.conf (Unix systems only), if --system-info flag was provided.
 scutil_dns.txt: DNS configuration from scutil --dns (macOS only), if --system-info flag was provided.
-dns_windows.txt: Anonymized NRPT rules and policy table in effect, DNS client policy, and per-interface and per-adapter DNS configuration (Windows only), if --system-info flag was provided.
 resolved_domains.txt: Anonymized resolved domain IP addresses from the status recorder.
 config.txt: Anonymized configuration information of the NetBird client.
 network_map.json: Anonymized sync response containing peer configurations, routes, DNS settings, and firewall rules.
@@ -238,13 +237,6 @@ scutil_dns.txt (macOS only):
 - Shows DNS configuration for all network interfaces
 - Includes search domains, nameservers, and DNS resolver settings
 - All IP addresses and domain names are anonymized
-
-dns_windows.txt (Windows only):
-- Lists the NRPT rules of both policy stores, the local one and the group policy one, marking the rules the client created
-- Follows them with the policy table the resolver has loaded, which differs from the rules while a change has not been picked up yet
-- Includes the DNS client group policy, the global TCP/IP and Dnscache parameters, and the DNS values of every interface that has any
-- Ends with the resolver configuration in effect per adapter, from GetAdaptersAddresses
-- All IP addresses and domain names are anonymized
 `
 
 const (

client/internal/debug/debug_nonunix.go

@@ -1,4 +1,4 @@
-//go:build !unix && !windows
+//go:build !unix
 
 package debug
 

client/internal/debug/debug_windows.go

@@ -1,443 +0,0 @@
-//go:build windows
-
-package debug
-
-import (
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"net/netip"
-	"strings"
-	"unsafe"
-
-	log "github.com/sirupsen/logrus"
-	"golang.org/x/sys/windows"
-	"golang.org/x/sys/windows/registry"
-
-	nbdns "github.com/netbirdio/netbird/client/internal/dns"
-)
-
-const dnsInfoFileName = "dns_windows.txt"
-
-const (
-	gpoDNSClientRoot = `SOFTWARE\Policies\Microsoft\Windows NT\DNSClient`
-	tcpipParamsPath  = `SYSTEM\CurrentControlSet\Services\Tcpip\Parameters`
-	dnscacheParams   = `SYSTEM\CurrentControlSet\Services\Dnscache\Parameters`
-)
-
-// interfaceDNSValues are the per-interface values that decide how a name is
-// resolved and registered. Everything the DNS host manager writes is in here,
-// so a bundle shows both what we set and what it replaced.
-var interfaceDNSValues = []string{
-	"NameServer",
-	"DhcpNameServer",
-	"Domain",
-	"DhcpDomain",
-	"SearchList",
-	"RegistrationEnabled",
-	"DisableDynamicUpdate",
-	"MaxNumberOfAddressesToRegister",
-	"EnableDHCP",
-}
-
-// addDNSInfo collects and adds DNS configuration information to the archive
-func (g *BundleGenerator) addDNSInfo() error {
-	if err := g.addFileToZip(strings.NewReader(g.collectDNSInfo()), dnsInfoFileName); err != nil {
-		return fmt.Errorf("add DNS info to zip: %w", err)
-	}
-
-	return nil
-}
-
-// collectDNSInfo renders the report. Everything below it reaches the platform
-// through COM and through lazily resolved procedures, which panic when a
-// procedure is missing rather than returning an error, and a debug bundle is not
-// allowed to take the daemon down. The panic is contained here, and whatever was
-// collected before it is kept and reported with it.
-func (g *BundleGenerator) collectDNSInfo() (content string) {
-	var sb strings.Builder
-
-	defer func() {
-		if r := recover(); r != nil {
-			log.Errorf("collecting Windows DNS configuration panicked: %v", r)
-			fmt.Fprintf(&sb, "\nerror: collection stopped: %v\n", r)
-		}
-		content = sb.String()
-	}()
-
-	sb.WriteString("Windows DNS configuration\n")
-	sb.WriteString("=========================\n")
-
-	adapters, adaptersErr := adapterAddresses()
-
-	g.writeNRPTRules(&sb, "NRPT rules, local policy store", nbdns.DNSPolicyConfigRoot)
-	g.writeNRPTRules(&sb, "NRPT rules, group policy store", nbdns.GPODNSPolicyConfigRoot)
-	g.writeEffectiveNRPTPolicies(&sb)
-	g.writeRegistryKey(&sb, "DNS client group policy", gpoDNSClientRoot)
-	g.writeRegistryKey(&sb, "Global TCP/IP parameters", tcpipParamsPath)
-	g.writeRegistryKey(&sb, "Dnscache parameters", dnscacheParams)
-	g.writeInterfaceDNS(&sb, "Per-interface DNS, IPv4", nbdns.InterfaceConfigPath, adapterNames(adapters))
-	g.writeInterfaceDNS(&sb, "Per-interface DNS, IPv6", nbdns.InterfaceConfigPathV6, adapterNames(adapters))
-	g.writeAdapterDNS(&sb, adapters, adaptersErr)
-
-	return sb.String()
-}
-
-// writeNRPTRules lists every rule in a policy store, ours and any other
-// product's, since a foreign rule for the same namespace decides resolution
-// just as ours does. Rules the client wrote are marked.
-func (g *BundleGenerator) writeNRPTRules(sb *strings.Builder, title, root string) {
-	writeSection(sb, title, root)
-
-	names, err := subKeyNames(root)
-	if err != nil {
-		fmt.Fprintf(sb, "error: %v\n", err)
-		return
-	}
-
-	if len(names) == 0 {
-		sb.WriteString("no rules\n")
-		return
-	}
-
-	for _, name := range names {
-		owner := ""
-		if strings.HasPrefix(strings.ToLower(name), strings.ToLower(nbdns.NRPTKeyPrefix)) {
-			owner = "  (netbird)"
-		}
-		fmt.Fprintf(sb, "%s%s\n", name, owner)
-		g.writeValues(sb, root+`\`+name, nil, "  ")
-	}
-}
-
-// writeEffectiveNRPTPolicies reports the table the resolver answers from, which
-// the registry cannot show: a rule is written before it is loaded, and it keeps
-// being enforced after its key is gone until the resolver reloads its policy.
-func (g *BundleGenerator) writeEffectiveNRPTPolicies(sb *strings.Builder) {
-	writeSection(sb, "NRPT policy table in effect", nrptPolicyClass+"."+nrptPolicyMethod+" in "+nrptPolicyNamespace)
-
-	entries, err := effectiveNRPTPolicies()
-	if err != nil {
-		fmt.Fprintf(sb, "error: %v\n", err)
-		return
-	}
-
-	if len(entries) == 0 {
-		sb.WriteString("no policies\n")
-		return
-	}
-
-	for _, entry := range entries {
-		fmt.Fprintf(sb, "%s\n", g.anonymizeValue("Namespace", entry.namespace))
-		for _, value := range entry.values {
-			fmt.Fprintf(sb, "  %s: %s\n", value.name, g.anonymizeValue(value.name, value.value))
-		}
-	}
-}
-
-// writeInterfaceDNS reports the DNS values of every interface that has any, so
-// the netbird interface can be compared against the physical ones. The registry
-// keys the values by GUID, so each is named from the adapter list; a GUID with
-// no adapter is a leftover key of an interface that no longer exists.
-func (g *BundleGenerator) writeInterfaceDNS(sb *strings.Builder, title, root string, names map[string]string) {
-	writeSection(sb, title, root)
-
-	guids, err := subKeyNames(root)
-	if err != nil {
-		fmt.Fprintf(sb, "error: %v\n", err)
-		return
-	}
-
-	var reported int
-	for _, guid := range guids {
-		var iface strings.Builder
-		g.writeValues(&iface, root+`\`+guid, interfaceDNSValues, "  ")
-		if iface.Len() == 0 {
-			continue
-		}
-
-		name, ok := names[strings.ToLower(guid)]
-		if !ok {
-			name = "no adapter with this GUID"
-		}
-
-		reported++
-		fmt.Fprintf(sb, "%s (%s)\n%s", guid, name, iface.String())
-	}
-
-	if reported == 0 {
-		sb.WriteString("no interface holds DNS values\n")
-	}
-}
-
-// writeRegistryKey reports the values of a single key, without its subkeys.
-func (g *BundleGenerator) writeRegistryKey(sb *strings.Builder, title, path string) {
-	writeSection(sb, title, path)
-
-	var values strings.Builder
-	g.writeValues(&values, path, nil, "")
-	if values.Len() == 0 {
-		sb.WriteString("no values\n")
-		return
-	}
-
-	sb.WriteString(values.String())
-}
-
-// writeValues renders the values of a key. A nil names list reports every
-// value, otherwise only those named and present.
-func (g *BundleGenerator) writeValues(sb *strings.Builder, path string, names []string, indent string) {
-	k, err := registry.OpenKey(registry.LOCAL_MACHINE, path, registry.QUERY_VALUE)
-	switch {
-	case errors.Is(err, registry.ErrNotExist), errors.Is(err, windows.ERROR_PATH_NOT_FOUND):
-		// an absent key is the normal state for the GPO store and for
-		// interfaces without DNS settings
-		log.Debugf("HKEY_LOCAL_MACHINE\\%s does not exist", path)
-		return
-	case err != nil:
-		fmt.Fprintf(sb, "%serror: open HKEY_LOCAL_MACHINE\\%s: %v\n", indent, path, err)
-		return
-	}
-	defer closeKey(k)
-
-	if names == nil {
-		names, err = k.ReadValueNames(-1)
-		if err != nil {
-			fmt.Fprintf(sb, "%serror: read value names: %v\n", indent, err)
-			return
-		}
-	}
-
-	for _, name := range names {
-		value, err := readRegistryValue(k, name)
-		switch {
-		case errors.Is(err, registry.ErrNotExist):
-			// the caller asks for a fixed set of values, most of which a
-			// given interface does not carry
-			continue
-		case err != nil:
-			// report rather than omit: a value that is there but cannot be
-			// read reads as unset otherwise
-			fmt.Fprintf(sb, "%s%s: error: %v\n", indent, name, err)
-			continue
-		}
-
-		fmt.Fprintf(sb, "%s%s: %s\n", indent, name, g.anonymizeValue(name, value))
-	}
-}
-
-// anonymizeValue redacts a registry value according to what its name says it
-// holds. Domains and addresses are handled per entry rather than by the string
-// pass: the pass only replaces domains something else in the bundle already
-// seeded, and its address regex would eat the digit labels of a reverse zone.
-func (g *BundleGenerator) anonymizeValue(name, value string) string {
-	if !g.anonymize || value == "" {
-		return value
-	}
-
-	switch {
-	case holdsDomains(name):
-		return joinValueEntries(splitValueEntries(value), g.anonymizeDomain)
-	case holdsAddresses(name):
-		return joinValueEntries(splitValueEntries(value), g.anonymizer.AnonymizeIPString)
-	default:
-		return g.anonymizer.AnonymizeString(value)
-	}
-}
-
-// holdsDomains reports whether a value name holds domains: the domain list of
-// an NRPT rule (Name) or of the policy table (Namespace), a search list, the
-// DNS suffix values of the TCP/IP and policy keys, which all end in "Domain"
-// (Domain, DhcpDomain, NV Domain, ICSDomain), and a proxy host name.
-func holdsDomains(name string) bool {
-	lower := strings.ToLower(name)
-	return lower == "name" || lower == "namespace" || lower == "searchlist" ||
-		strings.HasSuffix(lower, "domain") || strings.HasSuffix(lower, "proxyname")
-}
-
-// holdsAddresses reports whether a value name holds DNS server addresses
-// (NameServer, DhcpNameServer, GenericDNSServers, NameServers).
-func holdsAddresses(name string) bool {
-	lower := strings.ToLower(name)
-	return strings.Contains(lower, "nameserver") || strings.Contains(lower, "dnsserver")
-}
-
-// adapterNames maps adapter GUIDs, as the registry keys the interfaces, to the
-// names an operator sees.
-func adapterNames(adapters []*windows.IpAdapterAddresses) map[string]string {
-	names := make(map[string]string, len(adapters))
-	for _, adapter := range adapters {
-		guid := windows.BytePtrToString(adapter.AdapterName)
-		names[strings.ToLower(guid)] = windows.UTF16PtrToString(adapter.FriendlyName)
-	}
-	return names
-}
-
-// writeAdapterDNS reports the resolver configuration in effect per adapter,
-// which is what the resolver uses for a name no NRPT rule matches.
-func (g *BundleGenerator) writeAdapterDNS(sb *strings.Builder, adapters []*windows.IpAdapterAddresses, err error) {
-	writeSection(sb, "Adapter DNS configuration", "GetAdaptersAddresses")
-
-	if err != nil {
-		fmt.Fprintf(sb, "error: %v\n", err)
-		return
-	}
-
-	for _, adapter := range adapters {
-		name := windows.UTF16PtrToString(adapter.FriendlyName)
-		suffix := g.anonymizeDomain(windows.UTF16PtrToString(adapter.DnsSuffix))
-
-		fmt.Fprintf(sb, "%s (index %d, oper status %d)\n", name, adapter.IfIndex, adapter.OperStatus)
-		fmt.Fprintf(sb, "  DNS suffix: %s\n", suffix)
-
-		var servers []string
-		for server := adapter.FirstDnsServerAddress; server != nil; server = server.Next {
-			addr, ok := netip.AddrFromSlice(server.Address.IP())
-			if !ok {
-				continue
-			}
-
-			addr = addr.Unmap()
-			if g.anonymize {
-				addr = g.anonymizer.AnonymizeIP(addr)
-			}
-			servers = append(servers, addr.String())
-		}
-
-		fmt.Fprintf(sb, "  DNS servers: %s\n", strings.Join(servers, ", "))
-	}
-}
-
-// anonymizeDomain anonymizes a single domain, keeping the leading dot an NRPT
-// match domain carries.
-func (g *BundleGenerator) anonymizeDomain(entry string) string {
-	if !g.anonymize {
-		return entry
-	}
-
-	domain, dot := strings.CutPrefix(entry, ".")
-	if domain == "" {
-		return entry
-	}
-
-	anonymized := g.anonymizer.AnonymizeDomain(domain)
-	if dot {
-		anonymized = "." + anonymized
-	}
-	return anonymized
-}
-
-// splitValueEntries splits a registry value that holds a list. The separator
-// differs per value: a REG_MULTI_SZ arrives joined with ", ", a SearchList is
-// comma separated and a NameServer may use commas or spaces.
-func splitValueEntries(value string) []string {
-	return strings.FieldsFunc(value, func(r rune) bool {
-		return r == ',' || r == ';' || r == ' ' || r == '\t'
-	})
-}
-
-func joinValueEntries(entries []string, anonymize func(string) string) string {
-	for i, entry := range entries {
-		entries[i] = anonymize(entry)
-	}
-	return strings.Join(entries, ", ")
-}
-
-func writeSection(sb *strings.Builder, title, source string) {
-	fmt.Fprintf(sb, "\n%s\n%s\n%s\n", title, strings.Repeat("-", len(title)), source)
-}
-
-func subKeyNames(root string) ([]string, error) {
-	k, err := registry.OpenKey(registry.LOCAL_MACHINE, root, registry.ENUMERATE_SUB_KEYS)
-	if err != nil {
-		return nil, fmt.Errorf("open HKEY_LOCAL_MACHINE\\%s: %w", root, err)
-	}
-	defer closeKey(k)
-
-	names, err := k.ReadSubKeyNames(-1)
-	if err != nil {
-		return nil, fmt.Errorf("read subkey names: %w", err)
-	}
-
-	return names, nil
-}
-
-// readRegistryValue renders a value as text regardless of its type, so an
-// unexpected type in a policy key still shows up instead of being dropped.
-func readRegistryValue(k registry.Key, name string) (string, error) {
-	_, valueType, err := k.GetValue(name, nil)
-	if err != nil {
-		return "", fmt.Errorf("get value %s: %w", name, err)
-	}
-
-	switch valueType {
-	case registry.SZ, registry.EXPAND_SZ:
-		value, _, err := k.GetStringValue(name)
-		if err != nil {
-			return "", fmt.Errorf("get string value %s: %w", name, err)
-		}
-		return value, nil
-	case registry.MULTI_SZ:
-		values, _, err := k.GetStringsValue(name)
-		if err != nil {
-			return "", fmt.Errorf("get strings value %s: %w", name, err)
-		}
-		return strings.Join(values, ", "), nil
-	case registry.DWORD, registry.QWORD:
-		value, _, err := k.GetIntegerValue(name)
-		if err != nil {
-			return "", fmt.Errorf("get integer value %s: %w", name, err)
-		}
-		return fmt.Sprintf("%d (0x%x)", value, value), nil
-	case registry.BINARY:
-		value, _, err := k.GetBinaryValue(name)
-		if err != nil {
-			return "", fmt.Errorf("get binary value %s: %w", name, err)
-		}
-		return hex.EncodeToString(value), nil
-	default:
-		return fmt.Sprintf("<unhandled registry type %d>", valueType), nil
-	}
-}
-
-// adapterAddresses returns the adapter list including DNS servers. The call
-// reports the size it needs, so grow the buffer and retry until it fits.
-func adapterAddresses() (adapters []*windows.IpAdapterAddresses, err error) {
-	// GetAdaptersAddresses is resolved on first use and panics when it is
-	// missing, so this reports it as an error and leaves the rest of the
-	// report intact.
-	defer func() {
-		if r := recover(); r != nil {
-			adapters, err = nil, fmt.Errorf("GetAdaptersAddresses: %v", r)
-		}
-	}()
-
-	const flags = windows.GAA_FLAG_SKIP_ANYCAST | windows.GAA_FLAG_SKIP_MULTICAST
-
-	size := uint32(15000)
-	for range 3 {
-		buf := make([]byte, size)
-		first := (*windows.IpAdapterAddresses)(unsafe.Pointer(&buf[0]))
-
-		err := windows.GetAdaptersAddresses(windows.AF_UNSPEC, flags, 0, first, &size)
-		if errors.Is(err, windows.ERROR_BUFFER_OVERFLOW) {
-			continue
-		}
-		if err != nil {
-			return nil, fmt.Errorf("GetAdaptersAddresses: %w", err)
-		}
-
-		for adapter := first; adapter != nil; adapter = adapter.Next {
-			adapters = append(adapters, adapter)
-		}
-		return adapters, nil
-	}
-
-	return nil, fmt.Errorf("GetAdaptersAddresses: buffer kept growing")
-}
-
-func closeKey(k registry.Key) {
-	if err := k.Close(); err != nil {
-		log.Debugf("close registry key: %v", err)
-	}
-}

client/internal/debug/debug_windows_test.go

@@ -1,146 +0,0 @@
-//go:build windows
-
-package debug
-
-import (
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-
-	"github.com/netbirdio/netbird/client/anonymize"
-)
-
-func newDNSValueGenerator(level anonymize.Level) *BundleGenerator {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-	anonymizer.SetLevel(level)
-
-	return &BundleGenerator{
-		anonymize:      true,
-		anonymizeLevel: level,
-		anonymizer:     anonymizer,
-	}
-}
-
-// TestAnonymizeValueByName covers the value kinds of the DNS registry keys. The
-// names decide the treatment, because the string pass alone replaces only
-// domains another part of the bundle already seeded.
-func TestAnonymizeValueByName(t *testing.T) {
-	tests := []struct {
-		name      string
-		valueName string
-		value     string
-		assert    func(t *testing.T, got string)
-	}{
-		{
-			name:      "NRPT match domains keep the leading dot",
-			valueName: "Name",
-			value:     ".internal.example.com, .corp.example.org",
-			assert: func(t *testing.T, got string) {
-				t.Helper()
-				for _, entry := range strings.Split(got, ", ") {
-					assert.True(t, strings.HasPrefix(entry, "."), "entry %q should keep its leading dot", entry)
-					assert.NotContains(t, entry, "example", "entry %q should not keep the original domain", entry)
-				}
-			},
-		},
-		{
-			name:      "any value name ending in Domain is treated as a domain",
-			valueName: "ICSDomain",
-			value:     "mshome.net",
-			assert: func(t *testing.T, got string) {
-				t.Helper()
-				assert.NotContains(t, got, "mshome", "should anonymize a domain suffix value")
-			},
-		},
-		{
-			name:      "search list is a comma separated domain list",
-			valueName: "SearchList",
-			value:     "corp.example.com,branch.example.com",
-			assert: func(t *testing.T, got string) {
-				t.Helper()
-				assert.NotContains(t, got, "example", "should anonymize every search domain")
-				assert.Len(t, strings.Split(got, ", "), 2, "should keep both search domains")
-			},
-		},
-		{
-			name:      "name servers are anonymized as addresses",
-			valueName: "DhcpNameServer",
-			value:     "203.0.113.10 8.8.8.8",
-			assert: func(t *testing.T, got string) {
-				t.Helper()
-				assert.NotContains(t, got, "203.0.113.10", "should anonymize a public resolver address")
-				// well-known resolvers stay readable at every level
-				assert.Contains(t, got, "8.8.8.8", "should keep a well-known resolver address")
-			},
-		},
-		{
-			name:      "opaque values are left to the string pass",
-			valueName: "DataBasePath",
-			value:     `%SystemRoot%\System32\drivers\etc`,
-			assert: func(t *testing.T, got string) {
-				t.Helper()
-				assert.Equal(t, `%SystemRoot%\System32\drivers\etc`, got, "should not alter a path")
-			},
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			g := newDNSValueGenerator(anonymize.LevelDefault)
-			tc.assert(t, g.anonymizeValue(tc.valueName, tc.value))
-		})
-	}
-}
-
-// TestParseNRPTPolicyTable parses the MOF text of the policy table out
-// parameters, as the provider on a client with one NRPT rule renders it.
-func TestParseNRPTPolicyTable(t *testing.T) {
-	const text = `[abstract]
-class __PARAMETERS
-{
-	[Out, EmbeddedInstance("DnsClientPolicyConfiguration"): ToSubClass, ID(2): DisableOverride ToInstance] DnsClientPolicyConfiguration cmdletOutput[] = {
-instance of DnsClientPolicyConfiguration
-{
-	DirectAccessProxyType = "NoProxy";
-	DirectAccessQueryIPsecRequired = FALSE;
-	NameEncoding = "Utf8WithoutMapping";
-	Namespace = ".0.100.in-addr.arpa";
-}, 
-instance of DnsClientPolicyConfiguration
-{
-	DirectAccessProxyType = "NoProxy";
-	NameEncoding = "Utf8WithoutMapping";
-	NameServers = {"100.0.255.254", "100.0.255.253"};
-	Namespace = ".nb.internal";
-}};
-	[in] boolean Effective;
-	[out] uint32 ReturnValue = 0;
-};
-`
-
-	entries := parseNRPTPolicyTable(text)
-	require.Len(t, entries, 2, "should parse both embedded instances")
-
-	assert.Equal(t, ".0.100.in-addr.arpa", entries[0].namespace, "should read the namespace of the first instance")
-	assert.Equal(t, ".nb.internal", entries[1].namespace, "should read the namespace of the second instance")
-
-	assert.Equal(t, []registryValue{
-		{name: "DirectAccessProxyType", value: "NoProxy"},
-		{name: "DirectAccessQueryIPsecRequired", value: "FALSE"},
-		{name: "NameEncoding", value: "Utf8WithoutMapping"},
-	}, entries[0].values, "should keep the remaining values in order")
-
-	assert.Contains(t, entries[1].values, registryValue{name: "NameServers", value: "100.0.255.254, 100.0.255.253"},
-		"should flatten a MOF array")
-
-	for _, value := range entries[1].values {
-		assert.NotContains(t, value.name, "ReturnValue", "should not read the class level parameters as values")
-	}
-}
-
-func TestParseNRPTPolicyTableEmpty(t *testing.T) {
-	assert.Empty(t, parseNRPTPolicyTable(""), "should parse no entries from empty text")
-	assert.Empty(t, parseNRPTPolicyTable("class __PARAMETERS\n{\n};\n"), "should parse no entries from a table with no instances")
-}

client/internal/debug/nrpt_windows.go

@@ -1,317 +0,0 @@
-//go:build windows
-
-package debug
-
-import (
-	"errors"
-	"fmt"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/go-ole/go-ole"
-	"github.com/go-ole/go-ole/oleutil"
-	log "github.com/sirupsen/logrus"
-)
-
-const (
-	// The NRPT policy table is reachable through the CIM class that backs
-	// Get-DnsClientNrptPolicy. Unlike the rules in the registry, the table is
-	// what the resolver currently has loaded, which is the only way to tell an
-	// applied rule from one that is merely written, in either direction.
-	nrptPolicyNamespace = `root\Microsoft\Windows\DNS`
-	nrptPolicyClass     = "PS_DnsClientNrptPolicy"
-	nrptPolicyMethod    = "Get"
-
-	// The class has no instances, so the table comes from the out parameters
-	// of a static method call, rendered as MOF text: the embedded instances
-	// arrive as a safe array of objects, which cannot be read back through the
-	// COM bindings, and the text form carries all of them.
-	nrptPolicyInstanceKeyword = "instance of DnsClientPolicyConfiguration"
-
-	nrptPolicyTimeout = 15 * time.Second
-)
-
-// COM initialization results that leave the calling thread usable: S_FALSE for
-// a thread this process already initialized, RPC_E_CHANGED_MODE for one that
-// belongs to another apartment.
-const (
-	sFalse          = 0x00000001
-	rpcEChangedMode = 0x80010106
-)
-
-// nrptQueryInFlight admits one read of the policy table at a time. A provider
-// that stops answering keeps its goroutine and the OS thread that goroutine
-// pinned, so a later bundle reports that instead of pinning another one.
-var nrptQueryInFlight = make(chan struct{}, 1)
-
-// nrptPolicyEntry is one namespace of the effective policy table, holding the
-// values of an embedded DnsClientPolicyConfiguration instance in the order the
-// provider reported them.
-type nrptPolicyEntry struct {
-	namespace string
-	values    []registryValue
-}
-
-// registryValue is a name and its rendered value, shared by the registry and
-// policy table readers so both anonymize by value name the same way.
-type registryValue struct {
-	name  string
-	value string
-}
-
-// effectiveNRPTPolicies reads the effective NRPT table. The call is bounded
-// because a WMI provider can block indefinitely and a debug bundle must not.
-func effectiveNRPTPolicies() ([]nrptPolicyEntry, error) {
-	type result struct {
-		text string
-		err  error
-	}
-
-	select {
-	case nrptQueryInFlight <- struct{}{}:
-	default:
-		return nil, errors.New("an earlier read of the policy table has not returned")
-	}
-
-	done := make(chan result, 1)
-	go func() {
-		// the slot is released here rather than by the caller, so a read that
-		// outlives the timeout holds it until the provider answers
-		defer func() { <-nrptQueryInFlight }()
-
-		text, err := nrptPolicyTableText()
-		done <- result{text: text, err: err}
-	}()
-
-	select {
-	case res := <-done:
-		if res.err != nil {
-			return nil, res.err
-		}
-		return parseNRPTPolicyTable(res.text), nil
-	case <-time.After(nrptPolicyTimeout):
-		return nil, errors.New("read of the policy table timed out")
-	}
-}
-
-// nrptPolicyTableText calls the policy table method and returns the MOF text of
-// its out parameters.
-func nrptPolicyTableText() (text string, err error) {
-	// COM is per thread, and the collection is short lived, so the thread is
-	// pinned for the duration rather than initialized for the process.
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
-
-	defer func() {
-		// The COM call chain is dynamically typed, so a provider that answers
-		// with an unexpected shape must not take the daemon down with it.
-		if r := recover(); r != nil {
-			err = fmt.Errorf("read NRPT policy table: %v", r)
-		}
-	}()
-
-	owns, err := coInitialize()
-	if err != nil {
-		return "", err
-	}
-	if owns {
-		defer ole.CoUninitialize()
-	}
-
-	locator, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
-	if err != nil {
-		return "", fmt.Errorf("create WMI locator: %w", err)
-	}
-	defer locator.Release()
-
-	dispatch, err := locator.QueryInterface(ole.IID_IDispatch)
-	if err != nil {
-		return "", fmt.Errorf("query WMI locator interface: %w", err)
-	}
-	defer dispatch.Release()
-
-	service, err := dispatchCall(dispatch, "ConnectServer", nil, nrptPolicyNamespace)
-	if err != nil {
-		return "", fmt.Errorf("connect to %s: %w", nrptPolicyNamespace, err)
-	}
-	defer service.Release()
-
-	inParams, err := spawnMethodInParams(service)
-	if err != nil {
-		return "", err
-	}
-	defer inParams.Release()
-
-	// The effective table is the merge of the local and the group policy
-	// store, which is what the resolver answers from.
-	if _, err := oleutil.PutProperty(inParams, "Effective", true); err != nil {
-		return "", fmt.Errorf("set Effective parameter: %w", err)
-	}
-
-	outParams, err := dispatchCall(service, "ExecMethod", nrptPolicyClass, nrptPolicyMethod, inParams)
-	if err != nil {
-		return "", fmt.Errorf("call %s.%s: %w", nrptPolicyClass, nrptPolicyMethod, err)
-	}
-	defer outParams.Release()
-
-	textVariant, err := oleutil.CallMethod(outParams, "GetObjectText_")
-	if err != nil {
-		return "", fmt.Errorf("render policy table: %w", err)
-	}
-	defer func() {
-		if err := textVariant.Clear(); err != nil {
-			log.Debugf("clear policy table variant: %v", err)
-		}
-	}()
-
-	return textVariant.ToString(), nil
-}
-
-// spawnMethodInParams builds the in parameters instance the method needs. The
-// provider rejects the call without one, even when every parameter is optional.
-func spawnMethodInParams(service *ole.IDispatch) (*ole.IDispatch, error) {
-	class, err := dispatchCall(service, "Get", nrptPolicyClass)
-	if err != nil {
-		return nil, fmt.Errorf("get class %s: %w", nrptPolicyClass, err)
-	}
-	defer class.Release()
-
-	methods, err := dispatchProperty(class, "Methods_")
-	if err != nil {
-		return nil, fmt.Errorf("get class methods: %w", err)
-	}
-	defer methods.Release()
-
-	method, err := dispatchCall(methods, "Item", nrptPolicyMethod)
-	if err != nil {
-		return nil, fmt.Errorf("get method %s: %w", nrptPolicyMethod, err)
-	}
-	defer method.Release()
-
-	params, err := dispatchProperty(method, "InParameters")
-	if err != nil {
-		return nil, fmt.Errorf("get method parameters: %w", err)
-	}
-	defer params.Release()
-
-	inParams, err := dispatchCall(params, "SpawnInstance_")
-	if err != nil {
-		return nil, fmt.Errorf("spawn parameter instance: %w", err)
-	}
-
-	return inParams, nil
-}
-
-// parseNRPTPolicyTable pulls the embedded instances out of the MOF text. Each
-// instance is a namespace of the table, with one name and value per line.
-func parseNRPTPolicyTable(text string) []nrptPolicyEntry {
-	var entries []nrptPolicyEntry
-	var current *nrptPolicyEntry
-
-	for _, line := range strings.Split(text, "\n") {
-		line = strings.TrimSpace(strings.TrimSuffix(strings.TrimSpace(line), ";"))
-
-		switch {
-		case strings.HasPrefix(line, nrptPolicyInstanceKeyword):
-			entries = append(entries, nrptPolicyEntry{})
-			current = &entries[len(entries)-1]
-			continue
-		case strings.HasPrefix(line, "}"):
-			// closes an instance, and the array with the last one, so the
-			// class level parameters that follow are not read as values
-			current = nil
-			continue
-		case current == nil, line == "{":
-			continue
-		}
-
-		name, value, ok := strings.Cut(line, " = ")
-		if !ok {
-			continue
-		}
-
-		value = unquoteMOFValue(value)
-		if name == "Namespace" {
-			current.namespace = value
-			continue
-		}
-
-		current.values = append(current.values, registryValue{name: name, value: value})
-	}
-
-	return entries
-}
-
-// unquoteMOFValue renders a MOF scalar or array as plain text: "a" becomes a,
-// and {"a", "b"} becomes a, b.
-func unquoteMOFValue(value string) string {
-	value = strings.TrimSpace(value)
-
-	if inner, ok := strings.CutPrefix(value, "{"); ok {
-		value = strings.TrimSuffix(inner, "}")
-
-		entries := strings.Split(value, ",")
-		for i, entry := range entries {
-			entries[i] = strings.Trim(strings.TrimSpace(entry), `"`)
-		}
-		return strings.Join(entries, ", ")
-	}
-
-	return strings.Trim(value, `"`)
-}
-
-// coInitialize prepares the calling thread for COM and reports whether this
-// call owns the initialization, which decides whether it may be balanced with
-// CoUninitialize. S_FALSE took a reference on a thread this process had already
-// initialized and so has to be released, while RPC_E_CHANGED_MODE took none:
-// the thread belongs to another apartment, which is usable but is not ours to
-// uninitialize.
-func coInitialize() (bool, error) {
-	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
-	if err == nil {
-		return true, nil
-	}
-
-	var oleErr *ole.OleError
-	if errors.As(err, &oleErr) {
-		switch oleErr.Code() {
-		case sFalse:
-			return true, nil
-		case rpcEChangedMode:
-			return false, nil
-		}
-	}
-
-	return false, fmt.Errorf("initialize COM: %w", err)
-}
-
-// dispatchCall calls a COM method that returns an object.
-func dispatchCall(dispatch *ole.IDispatch, method string, params ...any) (*ole.IDispatch, error) {
-	variant, err := oleutil.CallMethod(dispatch, method, params...)
-	if err != nil {
-		return nil, err
-	}
-
-	object := variant.ToIDispatch()
-	if object == nil {
-		return nil, fmt.Errorf("%s returned no object", method)
-	}
-
-	return object, nil
-}
-
-// dispatchProperty reads a COM property that holds an object.
-func dispatchProperty(dispatch *ole.IDispatch, property string) (*ole.IDispatch, error) {
-	variant, err := oleutil.GetProperty(dispatch, property)
-	if err != nil {
-		return nil, err
-	}
-
-	object := variant.ToIDispatch()
-	if object == nil {
-		return nil, fmt.Errorf("property %s holds no object", property)
-	}
-
-	return object, nil
-}

client/internal/dns/host_windows.go

@@ -31,28 +31,10 @@ var (
 	dnsFlushResolverCacheFn = dnsapi.NewProc("DnsFlushResolverCache")
 )
 
-// Registry locations of the host DNS configuration this package programs,
-// exported so a diagnostic reader reports the same locations that are written.
 const (
-	// NRPTKeyPrefix starts the name of every NRPT rule key this client creates.
-	NRPTKeyPrefix = "NetBird-Match"
-
-	// DNSPolicyConfigRoot holds the NRPT rules of the local policy store.
-	DNSPolicyConfigRoot = `SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\DnsPolicyConfig`
-
-	// GPODNSPolicyConfigRoot holds the NRPT rules of the group policy store,
-	// which takes precedence over the local one when it is present.
-	GPODNSPolicyConfigRoot = `SOFTWARE\Policies\Microsoft\Windows NT\DNSClient\DnsPolicyConfig`
-
-	// InterfaceConfigPath and InterfaceConfigPathV6 hold the per-interface DNS
-	// settings, keyed by interface GUID, in separate hives per address family.
-	InterfaceConfigPath   = `SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces`
-	InterfaceConfigPathV6 = `SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces`
-)
-
-const (
-	dnsPolicyConfigMatchPath    = DNSPolicyConfigRoot + `\` + NRPTKeyPrefix
-	gpoDnsPolicyConfigMatchPath = GPODNSPolicyConfigRoot + `\` + NRPTKeyPrefix
+	dnsPolicyConfigMatchPath    = `SYSTEM\CurrentControlSet\Services\Dnscache\Parameters\DnsPolicyConfig\NetBird-Match`
+	gpoDnsPolicyRoot            = `SOFTWARE\Policies\Microsoft\Windows NT\DNSClient\DnsPolicyConfig`
+	gpoDnsPolicyConfigMatchPath = gpoDnsPolicyRoot + `\NetBird-Match`
 
 	dnsPolicyConfigVersionKey           = "Version"
 	dnsPolicyConfigVersionValue         = 2
@@ -63,6 +45,8 @@ const (
 
 	nrptMaxDomainsPerRule = 50
 
+	interfaceConfigPath           = `SYSTEM\CurrentControlSet\Services\Tcpip\Parameters\Interfaces`
+	interfaceConfigPathV6         = `SYSTEM\CurrentControlSet\Services\Tcpip6\Parameters\Interfaces`
 	interfaceConfigNameServerKey  = "NameServer"
 	interfaceConfigDhcpNameSrvKey = "DhcpNameServer"
 	interfaceConfigSearchListKey  = "SearchList"
@@ -100,7 +84,7 @@ func newHostManager(wgInterface WGIface) (*registryConfigurator, error) {
 	}
 
 	var useGPO bool
-	k, err := registry.OpenKey(registry.LOCAL_MACHINE, GPODNSPolicyConfigRoot, registry.QUERY_VALUE)
+	k, err := registry.OpenKey(registry.LOCAL_MACHINE, gpoDnsPolicyRoot, registry.QUERY_VALUE)
 	if err != nil {
 		log.Debugf("failed to open GPO DNS policy root: %v", err)
 	} else {
@@ -139,7 +123,7 @@ func (r *registryConfigurator) captureOriginalNameservers() ([]netip.Addr, error
 	seen := make(map[netip.Addr]struct{})
 	var out []netip.Addr
 	var merr *multierror.Error
-	for _, root := range []string{InterfaceConfigPath, InterfaceConfigPathV6} {
+	for _, root := range []string{interfaceConfigPath, interfaceConfigPathV6} {
 		addrs, err := r.captureFromTcpipRoot(root)
 		if err != nil {
 			merr = multierror.Append(merr, fmt.Errorf("%s: %w", root, err))
@@ -512,7 +496,7 @@ func (r *registryConfigurator) deleteInterfaceRegistryKeyProperty(propertyKey st
 }
 
 func (r *registryConfigurator) getInterfaceRegistryKey() (registry.Key, error) {
-	regKeyPath := InterfaceConfigPath + "\\" + r.guid
+	regKeyPath := interfaceConfigPath + "\\" + r.guid
 	regKey, err := registry.OpenKey(registry.LOCAL_MACHINE, regKeyPath, registry.SET_VALUE)
 	if err != nil {
 		return regKey, fmt.Errorf("open HKEY_LOCAL_MACHINE\\%s: %w", regKeyPath, err)

client/proto/daemon.pb.go

@@ -5628,13 +5628,9 @@ func (x *GetPeerSSHHostKeyResponse) GetFound() bool {
 type RequestJWTAuthRequest struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// hint for OIDC login_hint parameter (typically email address)
-	Hint *string `protobuf:"bytes,1,opt,name=hint,proto3,oneof" json:"hint,omitempty"`
-	// hasGraphicalSession tells the daemon that the caller has a graphical session,
-	// which decides whether PKCE or the device code flow is preferred. The daemon
-	// cannot detect this itself: it does not inherit the session environment.
-	HasGraphicalSession bool `protobuf:"varint,2,opt,name=hasGraphicalSession,proto3" json:"hasGraphicalSession,omitempty"`
-	unknownFields       protoimpl.UnknownFields
-	sizeCache           protoimpl.SizeCache
+	Hint          *string `protobuf:"bytes,1,opt,name=hint,proto3,oneof" json:"hint,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *RequestJWTAuthRequest) Reset() {
@@ -5674,13 +5670,6 @@ func (x *RequestJWTAuthRequest) GetHint() string {
 	return ""
 }
 
-func (x *RequestJWTAuthRequest) GetHasGraphicalSession() bool {
-	if x != nil {
-		return x.HasGraphicalSession
-	}
-	return false
-}
-
 // RequestJWTAuthResponse contains authentication flow information
 type RequestJWTAuthResponse struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
@@ -5905,13 +5894,9 @@ type RequestExtendAuthSessionRequest struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
 	// Optional OIDC login_hint (typically the user's email) to pre-fill the
 	// IdP login form.
-	Hint *string `protobuf:"bytes,1,opt,name=hint,proto3,oneof" json:"hint,omitempty"`
-	// hasGraphicalSession tells the daemon that the caller has a graphical session,
-	// which decides whether PKCE or the device code flow is preferred. The daemon
-	// cannot detect this itself: it does not inherit the session environment.
-	HasGraphicalSession bool `protobuf:"varint,2,opt,name=hasGraphicalSession,proto3" json:"hasGraphicalSession,omitempty"`
-	unknownFields       protoimpl.UnknownFields
-	sizeCache           protoimpl.SizeCache
+	Hint          *string `protobuf:"bytes,1,opt,name=hint,proto3,oneof" json:"hint,omitempty"`
+	unknownFields protoimpl.UnknownFields
+	sizeCache     protoimpl.SizeCache
 }
 
 func (x *RequestExtendAuthSessionRequest) Reset() {
@@ -5951,13 +5936,6 @@ func (x *RequestExtendAuthSessionRequest) GetHint() string {
 	return ""
 }
 
-func (x *RequestExtendAuthSessionRequest) GetHasGraphicalSession() bool {
-	if x != nil {
-		return x.HasGraphicalSession
-	}
-	return false
-}
-
 // RequestExtendAuthSessionResponse carries the verification URI the UI
 // should open in a browser. The daemon retains the flow state and resolves
 // it via WaitExtendAuthSession.
@@ -7525,10 +7503,9 @@ const file_daemon_proto_rawDesc = "" +
 	"sshHostKey\x12\x16\n" +
 	"\x06peerIP\x18\x02 \x01(\tR\x06peerIP\x12\x1a\n" +
 	"\bpeerFQDN\x18\x03 \x01(\tR\bpeerFQDN\x12\x14\n" +
-	"\x05found\x18\x04 \x01(\bR\x05found\"k\n" +
+	"\x05found\x18\x04 \x01(\bR\x05found\"9\n" +
 	"\x15RequestJWTAuthRequest\x12\x17\n" +
-	"\x04hint\x18\x01 \x01(\tH\x00R\x04hint\x88\x01\x01\x120\n" +
-	"\x13hasGraphicalSession\x18\x02 \x01(\bR\x13hasGraphicalSessionB\a\n" +
+	"\x04hint\x18\x01 \x01(\tH\x00R\x04hint\x88\x01\x01B\a\n" +
 	"\x05_hint\"\x9a\x02\n" +
 	"\x16RequestJWTAuthResponse\x12(\n" +
 	"\x0fverificationURI\x18\x01 \x01(\tR\x0fverificationURI\x128\n" +
@@ -7548,10 +7525,9 @@ const file_daemon_proto_rawDesc = "" +
 	"\x14WaitJWTTokenResponse\x12\x14\n" +
 	"\x05token\x18\x01 \x01(\tR\x05token\x12\x1c\n" +
 	"\ttokenType\x18\x02 \x01(\tR\ttokenType\x12\x1c\n" +
-	"\texpiresIn\x18\x03 \x01(\x03R\texpiresIn\"u\n" +
+	"\texpiresIn\x18\x03 \x01(\x03R\texpiresIn\"C\n" +
 	"\x1fRequestExtendAuthSessionRequest\x12\x17\n" +
-	"\x04hint\x18\x01 \x01(\tH\x00R\x04hint\x88\x01\x01\x120\n" +
-	"\x13hasGraphicalSession\x18\x02 \x01(\bR\x13hasGraphicalSessionB\a\n" +
+	"\x04hint\x18\x01 \x01(\tH\x00R\x04hint\x88\x01\x01B\a\n" +
 	"\x05_hint\"\xe0\x01\n" +
 	" RequestExtendAuthSessionResponse\x12(\n" +
 	"\x0fverificationURI\x18\x01 \x01(\tR\x0fverificationURI\x128\n" +

client/proto/daemon.proto

@@ -894,10 +894,6 @@ message GetPeerSSHHostKeyResponse {
 message RequestJWTAuthRequest {
   // hint for OIDC login_hint parameter (typically email address)
   optional string hint = 1;
-  // hasGraphicalSession tells the daemon that the caller has a graphical session,
-  // which decides whether PKCE or the device code flow is preferred. The daemon
-  // cannot detect this itself: it does not inherit the session environment.
-  bool hasGraphicalSession = 2;
 }
 
 // RequestJWTAuthResponse contains authentication flow information
@@ -941,10 +937,6 @@ message RequestExtendAuthSessionRequest {
   // Optional OIDC login_hint (typically the user's email) to pre-fill the
   // IdP login form.
   optional string hint = 1;
-  // hasGraphicalSession tells the daemon that the caller has a graphical session,
-  // which decides whether PKCE or the device code flow is preferred. The daemon
-  // cannot detect this itself: it does not inherit the session environment.
-  bool hasGraphicalSession = 2;
 }
 
 // RequestExtendAuthSessionResponse carries the verification URI the UI

client/server/server.go

@@ -1723,8 +1723,8 @@ func (s *Server) RequestJWTAuth(
 		hint = profilemanager.GetLoginHint()
 	}
 
-	// the daemon has no graphical session of its own, only the caller can answer this
-	oAuthFlow, err := auth.NewOAuthFlow(ctx, config, msg.GetHasGraphicalSession(), false, hint)
+	isDesktop := isUnixRunningDesktop()
+	oAuthFlow, err := auth.NewOAuthFlow(ctx, config, isDesktop, false, hint)
 	if err != nil {
 		return nil, gstatus.Errorf(codes.Internal, "failed to create OAuth flow: %v", err)
 	}
@@ -1827,8 +1827,8 @@ func (s *Server) RequestExtendAuthSession(
 		hint = profilemanager.GetLoginHint()
 	}
 
-	// the daemon has no graphical session of its own, only the caller can answer this
-	oAuthFlow, err := auth.NewOAuthFlow(ctx, config, msg.GetHasGraphicalSession(), false, hint)
+	isDesktop := isUnixRunningDesktop()
+	oAuthFlow, err := auth.NewOAuthFlow(ctx, config, isDesktop, false, hint)
 	if err != nil {
 		return nil, gstatus.Errorf(codes.Internal, "failed to create OAuth flow: %v", err)
 	}
@@ -2000,6 +2000,13 @@ func (s *Server) ExposeService(req *proto.ExposeServiceRequest, srv proto.Daemon
 	return nil
 }
 
+func isUnixRunningDesktop() bool {
+	if runtime.GOOS != "linux" && runtime.GOOS != "freebsd" {
+		return false
+	}
+	return os.Getenv("DESKTOP_SESSION") != "" || os.Getenv("XDG_CURRENT_DESKTOP") != ""
+}
+
 func (s *Server) runProbes(ctx context.Context, waitForProbeResult bool) {
 	if s.connectClient == nil {
 		return

client/ssh/common.go

@@ -13,7 +13,6 @@ import (
 	"golang.org/x/crypto/ssh"
 
 	"github.com/netbirdio/netbird/client/proto"
-	"github.com/netbirdio/netbird/util"
 )
 
 const (
@@ -93,8 +92,7 @@ func printAuthInstructions(stderr io.Writer, authResponse *proto.RequestJWTAuthR
 
 // RequestJWTToken requests or retrieves a JWT token for SSH authentication
 func RequestJWTToken(ctx context.Context, client proto.DaemonServiceClient, stdout, stderr io.Writer, useCache bool, hint string, openBrowser func(string) error) (string, error) {
-	// the ssh client runs in the user's session, the daemon does not: tell it what we can see
-	req := &proto.RequestJWTAuthRequest{HasGraphicalSession: util.HasGraphicalSession()}
+	req := &proto.RequestJWTAuthRequest{}
 	if hint != "" {
 		req.Hint = &hint
 	}
@@ -195,3 +193,4 @@ func buildAddressList(hostname string, remote net.Addr) []string {
 	}
 	return addresses
 }
+

client/ui/authsession/service.go

@@ -58,8 +58,7 @@ func (s *Session) RequestExtend(ctx context.Context, p ExtendStartParams) (Exten
 		return ExtendStartResult{}, err
 	}
 
-	// a request from the UI implies a graphical session, which the daemon cannot detect itself
-	req := &proto.RequestExtendAuthSessionRequest{HasGraphicalSession: true}
+	req := &proto.RequestExtendAuthSessionRequest{}
 	if p.Hint != "" {
 		h := p.Hint
 		req.Hint = &h

client/ui/services/connection.go

@@ -108,11 +108,10 @@ func (s *Connection) Login(ctx context.Context, p LoginParams) (LoginResult, err
 	}
 
 	req := &proto.LoginRequest{
-		ManagementUrl: p.ManagementURL,
-		SetupKey:      p.SetupKey,
-		Hostname:      p.Hostname,
-		// a login driven by the UI always has a graphical session available
-		IsUnixDesktopClient: true,
+		ManagementUrl:       p.ManagementURL,
+		SetupKey:            p.SetupKey,
+		Hostname:            p.Hostname,
+		IsUnixDesktopClient: runtime.GOOS == "linux",
 	}
 	if profileName != "" {
 		req.ProfileName = ptrStr(profileName)

go.mod

@@ -57,7 +57,6 @@ require (
 	github.com/fsnotify/fsnotify v1.9.0
 	github.com/gliderlabs/ssh v0.3.8
 	github.com/go-jose/go-jose/v4 v4.1.4
-	github.com/go-ole/go-ole v1.3.0
 	github.com/gobwas/ws v1.4.0
 	github.com/goccy/go-yaml v1.18.0
 	github.com/godbus/dbus/v5 v5.2.2
@@ -200,6 +199,7 @@ require (
 	github.com/go-ldap/ldap/v3 v3.4.13 // indirect
 	github.com/go-logr/logr v1.4.3 // indirect
 	github.com/go-logr/stdr v1.2.2 // indirect
+	github.com/go-ole/go-ole v1.3.0 // indirect
 	github.com/go-openapi/analysis v0.23.0 // indirect
 	github.com/go-openapi/errors v0.22.2 // indirect
 	github.com/go-openapi/jsonpointer v0.21.1 // indirect

infrastructure_files/getting-started-enterprise.sh

@@ -12,7 +12,10 @@ SED_STRIP_PADDING='s/=//g'
 NETBIRD_EULA_URL="https://netbird.io/self-hosted-EULA"
 
 # Static IP for Traefik inside the compose bridge network. The management
-# server trusts X-Forwarded-* headers from this address only.
+# server trusts X-Forwarded-* headers from this address only, so all three
+# values derive from the same /24. Override with NETBIRD_DOCKER_SUBNET.
+DOCKER_SUBNET="172.30.0.0/24"
+DOCKER_GATEWAY="172.30.0.1"
 TRAEFIK_IP="172.30.0.10"
 
 check_docker_compose() {
@@ -43,6 +46,127 @@ rand_b64_key() {
   openssl rand -base64 32
 }
 
+# ------------------------------------------------------------------
+# Docker network subnet override and conflict check
+# (kept in sync with getting-started.sh; only the compose network
+# name differs)
+# ------------------------------------------------------------------
+
+ip_to_int() {
+  local a b c d
+  IFS=. read -r a b c d <<< "$1"
+  echo $(( (10#$a << 24) + (10#$b << 16) + (10#$c << 8) + 10#$d ))
+}
+
+# cidrs_overlap <cidr> <cidr> — succeeds if the networks overlap
+cidrs_overlap() {
+  local net1="${1%/*}" len1="${1#*/}" net2="${2%/*}" len2="${2#*/}"
+  local min_len=$(( len1 < len2 ? len1 : len2 ))
+  local mask=0
+  if [[ "$min_len" -gt 0 ]]; then
+    mask=$(( (0xFFFFFFFF << (32 - min_len)) & 0xFFFFFFFF ))
+  fi
+  [[ $(( $(ip_to_int "$net1") & mask )) -eq $(( $(ip_to_int "$net2") & mask )) ]]
+}
+
+# valid_ipv4_slash24 <cidr> — accepts a unicast IPv4 /24 like 10.123.45.0/24
+valid_ipv4_slash24() {
+  local octet='(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])'
+  local re="^${octet}\.${octet}\.${octet}\.0/24$"
+  [[ "$1" =~ $re ]] || return 1
+  # Reject non-unicast/reserved ranges: 0/8, loopback, link-local, 224+.
+  # 100.64/10 is rejected too: NetBird allocates overlay peer addresses from
+  # it by default, and a bridge there shadows the overlay without any Docker
+  # network overlapping, so the conflict check below would not catch it.
+  case "$1" in
+    0.*|127.*|169.254.*|22[4-9].*|2[34][0-9].*|25[0-5].*) return 1 ;;
+    100.6[4-9].*|100.[7-9][0-9].*|100.1[01][0-9].*|100.12[0-7].*) return 1 ;;
+  esac
+  return 0
+}
+
+# Apply NETBIRD_DOCKER_SUBNET and derive the gateway (.1) and Traefik IP (.10)
+apply_docker_subnet_override() {
+  if [[ -n "${NETBIRD_DOCKER_SUBNET:-}" ]]; then
+    if ! valid_ipv4_slash24 "$NETBIRD_DOCKER_SUBNET"; then
+      echo "NETBIRD_DOCKER_SUBNET must be a unicast IPv4 /24 network like 10.123.45.0/24 (0/8, 127/8, 169.254/16, 100.64/10, and 224+ are not allowed), got: $NETBIRD_DOCKER_SUBNET" > /dev/stderr
+      exit 1
+    fi
+    DOCKER_SUBNET="$NETBIRD_DOCKER_SUBNET"
+  fi
+  local base="${DOCKER_SUBNET%.0/24}"
+  DOCKER_GATEWAY="${base}.1"
+  TRAEFIK_IP="${base}.10"
+  return 0
+}
+
+# check_docker_subnet_conflicts <compose network name>
+# Fail early if an existing Docker network overlaps DOCKER_SUBNET, instead
+# of letting "docker compose up" fail later. Host routes are not checked;
+# NETBIRD_DOCKER_SUBNET covers those cases.
+check_docker_subnet_conflicts() {
+  local expected_network="$1"
+  command -v docker &> /dev/null || return 0
+
+  # docker's own stderr is left visible on purpose: "is the daemon running"
+  # and socket permission errors are the actionable part. Only the exit status
+  # is handled here, because skipping the check silently would resurface later
+  # as a confusing "docker compose up" failure.
+  local ids_raw ls_status=0
+  ids_raw="$(docker network ls -q)" || ls_status=$?
+  if [[ "$ls_status" -ne 0 ]]; then
+    echo "ERROR: could not list the existing Docker networks (docker network ls exited $ls_status)." > /dev/stderr
+    echo "Without it this script cannot verify that $DOCKER_SUBNET is free." > /dev/stderr
+    echo "Make sure the Docker daemon is running and reachable by this user, then run this script again." > /dev/stderr
+    exit 1
+  fi
+
+  # Collect the IDs in an array so they reach docker as separate arguments
+  local network_ids=() id
+  while IFS= read -r id; do
+    if [[ -n "$id" ]]; then
+      network_ids+=("$id")
+    fi
+  done <<< "$ids_raw"
+
+  # No Docker networks at all: nothing can overlap, so there is nothing to check
+  [[ "${#network_ids[@]}" -gt 0 ]] || return 0
+
+  local inspect_output inspect_status=0
+  inspect_output="$(docker network inspect --format '{{.Name}}|{{range .IPAM.Config}}{{.Subnet}} {{end}}' "${network_ids[@]}")" || inspect_status=$?
+  if [[ "$inspect_status" -ne 0 ]]; then
+    echo "ERROR: could not inspect the existing Docker networks (docker network inspect exited $inspect_status)." > /dev/stderr
+    echo "Without it this script cannot verify that $DOCKER_SUBNET is free." > /dev/stderr
+    echo "If a Docker network was removed while this script was running, run the script again." > /dev/stderr
+    exit 1
+  fi
+
+  local name subnets subnet
+  while IFS='|' read -r name subnets; do
+    for subnet in $subnets; do
+      [[ "$subnet" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/[0-9]+$ ]] || continue
+      if [[ "$name" == "$expected_network" ]]; then
+        # Our own leftover network: compose reuses it as-is, so its subnet
+        # must match the one we render
+        if [[ "$subnet" != "$DOCKER_SUBNET" ]]; then
+          echo "ERROR: the Docker network '$name', left over from a previous NetBird install, uses $subnet instead of $DOCKER_SUBNET." > /dev/stderr
+          echo "docker compose would reuse it as-is, and the generated configuration would not match it." > /dev/stderr
+          echo "Remove it and run this script again:" > /dev/stderr
+          echo "  docker network rm $name" > /dev/stderr
+          exit 1
+        fi
+      elif cidrs_overlap "$DOCKER_SUBNET" "$subnet"; then
+        echo "ERROR: the existing Docker network '$name' ($subnet) overlaps $DOCKER_SUBNET, the subnet NetBird would use." > /dev/stderr
+        echo "That network is not managed by this script and is left untouched." > /dev/stderr
+        echo "Pick a free /24 for NetBird instead and run this script again:" > /dev/stderr
+        echo "  NETBIRD_DOCKER_SUBNET=10.123.45.0/24 ./getting-started-enterprise.sh" > /dev/stderr
+        exit 1
+      fi
+    done
+  done <<< "$inspect_output"
+  return 0
+}
+
 check_nb_domain() {
   local domain="$1"
   if [[ -z "$domain" ]]; then
@@ -224,6 +348,9 @@ wait_postgres() {
 init_environment() {
   check_openssl
   DOCKER_COMPOSE_COMMAND=$(check_docker_compose)
+  # Settle the subnet (and fail on conflicts) before the EULA and prompts
+  apply_docker_subnet_override
+  check_docker_subnet_conflicts "netbird"
 
   if [[ -f .env ]] || [[ -f docker-compose.yml ]] || [[ -f config.yaml ]]; then
     echo "Generated files already exist in $(pwd)."
@@ -273,6 +400,7 @@ init_environment() {
   echo "  Traffic flow: ${NETBIRD_TRAFFIC_FLOW}"
   echo "  Domain:       ${NETBIRD_DOMAIN}"
   echo "  ACME email:   ${NETBIRD_LETSENCRYPT_EMAIL}"
+  echo "  Subnet:       ${DOCKER_SUBNET} (Traefik at ${TRAEFIK_IP})"
   echo ""
   echo "Rendering files into $(pwd) ..."
   install -m 600 /dev/null .env
@@ -334,7 +462,12 @@ NETBIRD_DOMAIN=${NETBIRD_DOMAIN}
 # Reverse proxy (Traefik)
 NETBIRD_LETSENCRYPT_EMAIL=${NETBIRD_LETSENCRYPT_EMAIL}
 NETBIRD_TRAEFIK_TAG=${NETBIRD_TRAEFIK_TAG:-v3.6}
+# These three must stay in step with the /32 trust pins in config.yaml
+# (reverseProxy.trustedPeers/trustedHTTPProxies). Shell env vars override
+# this file at compose time.
 NETBIRD_TRAEFIK_IP=${TRAEFIK_IP}
+NETBIRD_NETWORK_SUBNET=${DOCKER_SUBNET}
+NETBIRD_NETWORK_GATEWAY=${DOCKER_GATEWAY}
 
 # Image tags. Default to "latest"
 NETBIRD_DASHBOARD_TAG=${NETBIRD_DASHBOARD_TAG:-latest}
@@ -417,6 +550,9 @@ render_compose_common() {
     networks:
       netbird:
         ipv4_address: ${NETBIRD_TRAEFIK_IP}
+        # Resolve the public domain inside this network (avoids hairpin NAT)
+        aliases:
+          - "${NETBIRD_DOMAIN}"
     command:
       # Logging
       - "--log.level=INFO"
@@ -660,8 +796,8 @@ networks:
     driver: bridge
     ipam:
       config:
-        - subnet: 172.30.0.0/24
-          gateway: 172.30.0.1
+        - subnet: ${NETBIRD_NETWORK_SUBNET}
+          gateway: ${NETBIRD_NETWORK_GATEWAY}
 EOF
 }
 

infrastructure_files/getting-started.sh

@@ -108,6 +108,20 @@ check_nb_domain() {
     echo "The NETBIRD_DOMAIN cannot be netbird.example.com" > /dev/stderr
     return 1
   fi
+
+  # Letters, digits, dots, and hyphens only; the domain is embedded in
+  # generated YAML and env files. This is not FQDN validation: "use-ip" and
+  # bare IP addresses are valid inputs here and both satisfy the pattern.
+  local re='^[A-Za-z0-9]([A-Za-z0-9.-]*[A-Za-z0-9])?$'
+  if [[ ! "$DOMAIN" =~ $re ]] || [[ "$DOMAIN" == *..* ]]; then
+    echo "The NETBIRD_DOMAIN may only contain letters, digits, dots, and hyphens, and cannot begin or end with a dot or hyphen." > /dev/stderr
+    return 1
+  fi
+
+  if [[ "${#DOMAIN}" -gt 253 ]]; then
+    echo "The NETBIRD_DOMAIN cannot be longer than 253 characters." > /dev/stderr
+    return 1
+  fi
   return 0
 }
 
@@ -337,6 +351,145 @@ wait_management_direct() {
   return 0
 }
 
+############################################
+# Docker Network Subnet Override and Conflict Check
+############################################
+
+ip_to_int() {
+  local a b c d
+  IFS=. read -r a b c d <<< "$1"
+  echo $(( (10#$a << 24) + (10#$b << 16) + (10#$c << 8) + 10#$d ))
+}
+
+# cidrs_overlap <cidr> <cidr> — succeeds if the networks overlap
+cidrs_overlap() {
+  local net1="${1%/*}" len1="${1#*/}" net2="${2%/*}" len2="${2#*/}"
+  local min_len=$(( len1 < len2 ? len1 : len2 ))
+  local mask=0
+  if [[ "$min_len" -gt 0 ]]; then
+    mask=$(( (0xFFFFFFFF << (32 - min_len)) & 0xFFFFFFFF ))
+  fi
+  [[ $(( $(ip_to_int "$net1") & mask )) -eq $(( $(ip_to_int "$net2") & mask )) ]]
+}
+
+# valid_ipv4_slash24 <cidr> — accepts a unicast IPv4 /24 like 10.123.45.0/24
+valid_ipv4_slash24() {
+  local octet='(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])'
+  local re="^${octet}\.${octet}\.${octet}\.0/24$"
+  [[ "$1" =~ $re ]] || return 1
+  # Reject non-unicast/reserved ranges: 0/8, loopback, link-local, 224+.
+  # 100.64/10 is rejected too: NetBird allocates overlay peer addresses from
+  # it by default, and a bridge there shadows the overlay without any Docker
+  # network overlapping, so the conflict check below would not catch it.
+  case "$1" in
+    0.*|127.*|169.254.*|22[4-9].*|2[34][0-9].*|25[0-5].*) return 1 ;;
+    100.6[4-9].*|100.[7-9][0-9].*|100.1[01][0-9].*|100.12[0-7].*) return 1 ;;
+  esac
+  return 0
+}
+
+# Apply NETBIRD_DOCKER_SUBNET and derive the gateway (.1) and Traefik IP (.10)
+apply_docker_subnet_override() {
+  if [[ -n "${NETBIRD_DOCKER_SUBNET:-}" ]]; then
+    if ! valid_ipv4_slash24 "$NETBIRD_DOCKER_SUBNET"; then
+      echo "NETBIRD_DOCKER_SUBNET must be a unicast IPv4 /24 network like 10.123.45.0/24 (0/8, 127/8, 169.254/16, 100.64/10, and 224+ are not allowed), got: $NETBIRD_DOCKER_SUBNET" > /dev/stderr
+      exit 1
+    fi
+    DOCKER_SUBNET="$NETBIRD_DOCKER_SUBNET"
+  fi
+  local base="${DOCKER_SUBNET%.0/24}"
+  DOCKER_GATEWAY="${base}.1"
+  TRAEFIK_IP="${base}.10"
+  return 0
+}
+
+# check_docker_subnet_conflicts <compose network name>
+# Fail early if an existing Docker network overlaps DOCKER_SUBNET, instead
+# of letting "docker compose up" fail later. Host routes are not checked;
+# NETBIRD_DOCKER_SUBNET covers those cases.
+check_docker_subnet_conflicts() {
+  local expected_network="$1"
+  command -v docker &> /dev/null || return 0
+
+  # docker's own stderr is left visible on purpose: "is the daemon running"
+  # and socket permission errors are the actionable part. Only the exit status
+  # is handled here, because skipping the check silently would resurface later
+  # as a confusing "docker compose up" failure.
+  local ids_raw ls_status=0
+  ids_raw="$(docker network ls -q)" || ls_status=$?
+  if [[ "$ls_status" -ne 0 ]]; then
+    echo "ERROR: could not list the existing Docker networks (docker network ls exited $ls_status)." > /dev/stderr
+    echo "Without it this script cannot verify that $DOCKER_SUBNET is free." > /dev/stderr
+    echo "Make sure the Docker daemon is running and reachable by this user, then run this script again." > /dev/stderr
+    exit 1
+  fi
+
+  # Collect the IDs in an array so they reach docker as separate arguments
+  local network_ids=() id
+  while IFS= read -r id; do
+    if [[ -n "$id" ]]; then
+      network_ids+=("$id")
+    fi
+  done <<< "$ids_raw"
+
+  # No Docker networks at all: nothing can overlap, so there is nothing to check
+  [[ "${#network_ids[@]}" -gt 0 ]] || return 0
+
+  local inspect_output inspect_status=0
+  inspect_output="$(docker network inspect --format '{{.Name}}|{{range .IPAM.Config}}{{.Subnet}} {{end}}' "${network_ids[@]}")" || inspect_status=$?
+  if [[ "$inspect_status" -ne 0 ]]; then
+    echo "ERROR: could not inspect the existing Docker networks (docker network inspect exited $inspect_status)." > /dev/stderr
+    echo "Without it this script cannot verify that $DOCKER_SUBNET is free." > /dev/stderr
+    echo "If a Docker network was removed while this script was running, run the script again." > /dev/stderr
+    exit 1
+  fi
+
+  local name subnets subnet
+  while IFS='|' read -r name subnets; do
+    for subnet in $subnets; do
+      [[ "$subnet" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/[0-9]+$ ]] || continue
+      if [[ "$name" == "$expected_network" ]]; then
+        # Our own leftover network: compose reuses it as-is, so its subnet
+        # must match the one we render
+        if [[ "$subnet" != "$DOCKER_SUBNET" ]]; then
+          echo "ERROR: the Docker network '$name', left over from a previous NetBird install, uses $subnet instead of $DOCKER_SUBNET." > /dev/stderr
+          echo "docker compose would reuse it as-is, and the generated configuration would not match it." > /dev/stderr
+          echo "Remove it and run this script again:" > /dev/stderr
+          echo "  docker network rm $name" > /dev/stderr
+          exit 1
+        fi
+      elif cidrs_overlap "$DOCKER_SUBNET" "$subnet"; then
+        echo "ERROR: the existing Docker network '$name' ($subnet) overlaps $DOCKER_SUBNET, the subnet NetBird would use." > /dev/stderr
+        echo "That network is not managed by this script and is left untouched." > /dev/stderr
+        echo "Pick a free /24 for NetBird instead and run this script again:" > /dev/stderr
+        echo "  NETBIRD_DOCKER_SUBNET=10.123.45.0/24 ./getting-started.sh" > /dev/stderr
+        exit 1
+      fi
+    done
+  done <<< "$inspect_output"
+  return 0
+}
+
+configure_docker_subnet() {
+  # Only the built-in Traefik mode pins a subnet; other modes let Docker pick
+  if [[ "$REVERSE_PROXY_TYPE" != "0" ]]; then
+    return 0
+  fi
+
+  # Skip our own network (<project>_netbird) in the conflict check. Compose
+  # derives the project name from the basename of the logical working directory
+  # (verified against Compose v5.4.0: a symlinked directory yields the symlink
+  # name, not its target), lowercases it, deletes every character outside
+  # [a-z0-9_-], then trims leading "_" and "-". Verified: "nb.test" -> "nbtest",
+  # "my nb" -> "mynb", "NetBird-1.0" -> "netbird-10". Networks are then named
+  # <project>_<key>.
+  local project
+  project="${COMPOSE_PROJECT_NAME:-$(basename "$PWD")}"
+  project=$(echo "$project" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9_-]//g; s/^[_-]*//')
+  check_docker_subnet_conflicts "${project}_netbird"
+  return 0
+}
+
 ############################################
 # Initialization and Configuration
 ############################################
@@ -369,7 +522,11 @@ initialize_default_values() {
   BIND_LOCALHOST_ONLY="true"
   EXTERNAL_PROXY_NETWORK=""
 
-  # Traefik static IP within the internal bridge network
+  # Internal bridge network. Management and proxy trust forwarded headers
+  # from TRAEFIK_IP only, so all three values derive from the same /24.
+  # Override with NETBIRD_DOCKER_SUBNET.
+  DOCKER_SUBNET="172.30.0.0/24"
+  DOCKER_GATEWAY="172.30.0.1"
   TRAEFIK_IP="172.30.0.10"
 
   # NetBird Proxy configuration
@@ -665,8 +822,23 @@ init_environment() {
   check_docker_sock_perms
 
   initialize_default_values
+  apply_docker_subnet_override
+
+  # The agent-network preset pins built-in Traefik up front, so the subnet is
+  # already settled and a conflict can be reported before the prompts.
+  local subnet_checked="false"
+  if [[ "${NETBIRD_AGENT_NETWORK}" == "true" ]]; then
+    configure_docker_subnet
+    subnet_checked="true"
+  fi
+
   configure_domain
   configure_reverse_proxy
+  # Interactive runs only learn the proxy type above, and modes 1-5 never pin a
+  # subnet, so their check has to wait for that choice.
+  if [[ "$subnet_checked" != "true" ]]; then
+    configure_docker_subnet
+  fi
 
   check_jq
 
@@ -886,8 +1058,8 @@ networks:
     driver: bridge
     ipam:
       config:
-        - subnet: 172.30.0.0/24
-          gateway: 172.30.0.1
+        - subnet: $DOCKER_SUBNET
+          gateway: $DOCKER_GATEWAY
 EOF
   return 0
 }

infrastructure_files/migrate.sh

@@ -10,6 +10,9 @@
 #
 # Usage:
 #   ./migrate.sh [--install-dir /path/to/netbird] [--non-interactive]
+#
+# Environment:
+#   NETBIRD_DOCKER_SUBNET   /24 for the generated Docker network (default 172.30.0.0/24)
 
 set -euo pipefail
 
@@ -64,6 +67,14 @@ TRUSTED_PEERS=""
 MANAGEMENT_JSON_PATH=""
 BACKUP_DIR=""
 
+# Docker network for the generated Traefik compose. The Traefik container needs
+# a static address so the generated config can trust it, and Traefik's IP is
+# derived from the subnet, so both values stay in the same /24. Override with
+# NETBIRD_DOCKER_SUBNET.
+DOCKER_SUBNET="172.30.0.0/24"
+DOCKER_GATEWAY="172.30.0.1"
+TRAEFIK_IP="172.30.0.10"
+
 ############################################
 # Utility Functions
 ############################################
@@ -117,6 +128,159 @@ confirm_action() {
   return 0
 }
 
+############################################
+# Docker Network Subnet Override and Conflict Check
+############################################
+
+ip_to_int() {
+  local a b c d
+  IFS=. read -r a b c d <<< "$1"
+  echo $(( (10#$a << 24) + (10#$b << 16) + (10#$c << 8) + 10#$d ))
+}
+
+# cidrs_overlap <cidr> <cidr> — succeeds if the networks overlap
+cidrs_overlap() {
+  local net1="${1%/*}" len1="${1#*/}" net2="${2%/*}" len2="${2#*/}"
+  local min_len=$(( len1 < len2 ? len1 : len2 ))
+  local mask=0
+  if [[ "$min_len" -gt 0 ]]; then
+    mask=$(( (0xFFFFFFFF << (32 - min_len)) & 0xFFFFFFFF ))
+  fi
+  [[ $(( $(ip_to_int "$net1") & mask )) -eq $(( $(ip_to_int "$net2") & mask )) ]]
+}
+
+# valid_ipv4_slash24 <cidr> — accepts a unicast IPv4 /24 like 10.123.45.0/24
+valid_ipv4_slash24() {
+  local octet='(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])'
+  local re="^${octet}\.${octet}\.${octet}\.0/24$"
+  [[ "$1" =~ $re ]] || return 1
+  # Reject non-unicast/reserved ranges: 0/8, loopback, link-local, 224+.
+  # 100.64/10 is rejected too: NetBird allocates overlay peer addresses from
+  # it by default, and a bridge there shadows the overlay without any Docker
+  # network overlapping, so the conflict check below would not catch it.
+  case "$1" in
+    0.*|127.*|169.254.*|22[4-9].*|2[34][0-9].*|25[0-5].*) return 1 ;;
+    100.6[4-9].*|100.[7-9][0-9].*|100.1[01][0-9].*|100.12[0-7].*) return 1 ;;
+  esac
+  return 0
+}
+
+# Apply NETBIRD_DOCKER_SUBNET and derive the gateway (.1) and Traefik IP (.10).
+# Runs during preflight so a bad value fails before anything is touched.
+#
+# Unlike the getting-started scripts, the subnet has a single consumer here: the
+# generated docker-compose.yml. The reverseProxy trust pins in the generated
+# config.yaml are carried over verbatim from the old management.json (see
+# extract_config_values), so TRAEFIK_IP is deliberately not wired into them. If
+# an old config already pinned an address inside the default 172.30.0.0/24,
+# overriding the subnet will not update that pin.
+apply_docker_subnet_override() {
+  if [[ -n "${NETBIRD_DOCKER_SUBNET:-}" ]]; then
+    if ! valid_ipv4_slash24 "$NETBIRD_DOCKER_SUBNET"; then
+      log_error "NETBIRD_DOCKER_SUBNET must be a unicast IPv4 /24 network like 10.123.45.0/24 (0/8, 127/8, 169.254/16, 100.64/10, and 224+ are not allowed), got: $NETBIRD_DOCKER_SUBNET"
+      exit 1
+    fi
+    DOCKER_SUBNET="$NETBIRD_DOCKER_SUBNET"
+  fi
+  local base="${DOCKER_SUBNET%.0/24}"
+  DOCKER_GATEWAY="${base}.1"
+  TRAEFIK_IP="${base}.10"
+  return 0
+}
+
+# check_docker_subnet_conflicts <compose network name>
+# Fail before the new docker-compose.yml is written if an existing Docker
+# network overlaps DOCKER_SUBNET, instead of letting "docker compose up" fail
+# later. Host routes are not checked; NETBIRD_DOCKER_SUBNET covers those cases.
+check_docker_subnet_conflicts() {
+  local expected_network="$1"
+  command -v docker &> /dev/null || return 0
+
+  # docker's own stderr is left visible on purpose: "is the daemon running"
+  # and socket permission errors are the actionable part. Only the exit status
+  # is handled here, because skipping the check silently would resurface later
+  # as a confusing "docker compose up" failure.
+  local ids_raw ls_status=0
+  ids_raw="$(docker network ls -q)" || ls_status=$?
+  if [[ "$ls_status" -ne 0 ]]; then
+    log_error "Could not list the existing Docker networks (docker network ls exited $ls_status)."
+    echo "Without it this script cannot verify that $DOCKER_SUBNET is free."
+    echo "Make sure the Docker daemon is running and reachable by this user, then run this script again."
+    echo "The old deployment is stopped at this point; restart it with:"
+    echo "  bash $BACKUP_DIR/rollback.sh"
+    exit 1
+  fi
+
+  # Collect the IDs in an array so they reach docker as separate arguments
+  local network_ids=() id
+  while IFS= read -r id; do
+    if [[ -n "$id" ]]; then
+      network_ids+=("$id")
+    fi
+  done <<< "$ids_raw"
+
+  # No Docker networks at all: nothing can overlap, so there is nothing to check
+  [[ "${#network_ids[@]}" -gt 0 ]] || return 0
+
+  local inspect_output inspect_status=0
+  inspect_output="$(docker network inspect --format '{{.Name}}|{{range .IPAM.Config}}{{.Subnet}} {{end}}' "${network_ids[@]}")" || inspect_status=$?
+  if [[ "$inspect_status" -ne 0 ]]; then
+    log_error "Could not inspect the existing Docker networks (docker network inspect exited $inspect_status)."
+    echo "Without it this script cannot verify that $DOCKER_SUBNET is free."
+    echo "If a Docker network was removed while this script was running, run the script again."
+    echo "The old deployment is stopped at this point; restart it with:"
+    echo "  bash $BACKUP_DIR/rollback.sh"
+    exit 1
+  fi
+
+  local name subnets subnet
+  while IFS='|' read -r name subnets; do
+    for subnet in $subnets; do
+      [[ "$subnet" =~ ^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+/[0-9]+$ ]] || continue
+      if [[ "$name" == "$expected_network" ]]; then
+        # Our own leftover network: compose reuses it as-is, so its subnet
+        # must match the one we render
+        if [[ "$subnet" != "$DOCKER_SUBNET" ]]; then
+          log_error "The Docker network '$name', left over from an earlier run, uses $subnet instead of $DOCKER_SUBNET."
+          echo "docker compose would reuse it as-is, and the generated configuration would not match it."
+          echo "Remove it and run this script again:"
+          echo "  docker network rm $name"
+          exit 1
+        fi
+      elif cidrs_overlap "$DOCKER_SUBNET" "$subnet"; then
+        log_error "The existing Docker network '$name' ($subnet) overlaps $DOCKER_SUBNET, the subnet NetBird would use."
+        echo "That network is not managed by this script and is left untouched."
+        echo "If it belongs to the old NetBird deployment and is no longer in use, remove it:"
+        echo "  docker network rm $name"
+        echo "Otherwise pick a free /24 for NetBird instead and run this script again:"
+        echo "  NETBIRD_DOCKER_SUBNET=10.123.45.0/24 ./migrate.sh"
+        exit 1
+      fi
+    done
+  done <<< "$inspect_output"
+  return 0
+}
+
+# Only reached on the automatic (embedded Caddy) path, which is the only one
+# that generates a compose file pinning a subnet; the exposed-ports compose for
+# custom proxies lets Docker pick.
+configure_docker_subnet() {
+  # Skip our own network (<project>_netbird) in the conflict check. start_new_services
+  # runs "cd $INSTALL_DIR && compose up", a logical cd, and compose derives the
+  # project name from the basename of that logical path -- so resolve it the same
+  # way with a plain "pwd" (a relative --install-dir still yields an absolute
+  # path, and a symlinked install dir keeps the symlink name, which is what
+  # compose sees). "pwd -P" here would resolve the symlink target and no longer
+  # match. Compose then lowercases, deletes every character outside [a-z0-9_-],
+  # and trims leading "_" and "-"; verified against Compose v5.4.0 that
+  # "nb.test" -> "nbtest" and "my nb" -> "mynb".
+  local project
+  project="${COMPOSE_PROJECT_NAME:-$(basename "$(cd -- "$INSTALL_DIR" && pwd)")}"
+  project=$(echo "$project" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9_-]//g; s/^[_-]*//')
+  check_docker_subnet_conflicts "${project}_netbird"
+  return 0
+}
+
 ############################################
 # Phase 0: Preflight & Detection
 ############################################
@@ -577,6 +741,7 @@ print_detection_summary() {
     echo "  Migration mode:     AUTOMATIC"
     echo "  A Traefik-based docker-compose.yml will be generated and services"
     echo "  will be stopped and restarted automatically."
+    echo "  Docker subnet:      $DOCKER_SUBNET (Traefik at $TRAEFIK_IP)"
   else
     echo "  Migration mode:     MANUAL"
     echo "  New config files will be generated. You will need to stop old"
@@ -843,7 +1008,7 @@ services:
     restart: unless-stopped
     networks:
       netbird:
-        ipv4_address: 172.30.0.10
+        ipv4_address: ${TRAEFIK_IP}
     command:
       # Logging
       - "--log.level=INFO"
@@ -952,8 +1117,8 @@ networks:
     driver: bridge
     ipam:
       config:
-        - subnet: 172.30.0.0/24
-          gateway: 172.30.0.1
+        - subnet: ${DOCKER_SUBNET}
+          gateway: ${DOCKER_GATEWAY}
 EOF
 
   log_success "Generated docker-compose.yml"
@@ -1226,6 +1391,10 @@ main() {
         echo "  --install-dir DIR    Path to existing NetBird installation"
         echo "  --non-interactive    Skip confirmation prompts (for automation)"
         echo "  -h, --help           Show this help message"
+        echo ""
+        echo "Environment:"
+        echo "  NETBIRD_DOCKER_SUBNET  /24 for the generated Docker network"
+        echo "                         (default $DOCKER_SUBNET; Traefik takes .10)"
         exit 0
         ;;
       *)
@@ -1240,6 +1409,7 @@ main() {
 
   # Phase 0: Preflight & Detection
   check_dependencies
+  apply_docker_subnet_override
   detect_install_dir
   validate_old_setup
   check_already_migrated
@@ -1261,6 +1431,10 @@ main() {
     # Stop old containers BEFORE overwriting docker-compose.yml
     stop_old_services
 
+    # "compose down" above released the old deployment's networks, so anything
+    # still overlapping now is a network this script must not touch
+    configure_docker_subnet
+
     # Phase 2 + 3: Generate new configuration files
     generate_config_yaml
     generate_dashboard_env

util/common.go

@@ -3,69 +3,18 @@ package util
 import (
 	"os"
 	"os/exec"
-	"runtime"
-	"slices"
 
 	"github.com/skratchdot/open-golang/open"
 )
 
-const (
-	// envBrowser overrides the browser OpenBrowser launches
-	envBrowser = "BROWSER"
-	// envDesktopSession and envXDGCurrentDesktop are what xdg-open uses to pick a handler
-	envDesktopSession    = "DESKTOP_SESSION"
-	envXDGCurrentDesktop = "XDG_CURRENT_DESKTOP"
-	// envDisplay and envWaylandDisplay are what a graphical browser needs to reach a display
-	envDisplay        = "DISPLAY"
-	envWaylandDisplay = "WAYLAND_DISPLAY"
-	// envXDGSessionType names the session kind, e.g. tty, x11 or wayland
-	envXDGSessionType = "XDG_SESSION_TYPE"
-)
-
 // OpenBrowser opens the URL in a browser, respecting the BROWSER environment variable.
 func OpenBrowser(url string) error {
-	if browser := os.Getenv(envBrowser); browser != "" {
+	if browser := os.Getenv("BROWSER"); browser != "" {
 		return exec.Command(browser, url).Start()
 	}
 	return open.Run(url)
 }
 
-// browserSessionEnvVars returns the variables that decide whether OpenBrowser can open a URL.
-// DISPLAY and WAYLAND_DISPLAY are exactly what xdg-open's own has_display() checks, and without
-// them it degrades to terminal browsers. BROWSER is the explicit override both xdg-open and
-// OpenBrowser honor first. DESKTOP_SESSION and XDG_CURRENT_DESKTOP only tell xdg-open which
-// desktop-specific opener to prefer, so they are weaker evidence, kept because the previous
-// detection relied on them alone and dropping them would demote sessions that work today.
-func browserSessionEnvVars() []string {
-	return []string{envDisplay, envWaylandDisplay, envBrowser, envDesktopSession, envXDGCurrentDesktop}
-}
-
-// graphicalXDGSessionTypes are the systemd-logind session types that come with a display. The
-// other documented values are "tty" and "unspecified"; anything unrecognized is treated as no
-// display, so an unknown value picks the device code flow, which works without a browser.
-func graphicalXDGSessionTypes() []string {
-	return []string{"x11", "wayland", "mir"}
-}
-
-// HasGraphicalSession reports whether this process can open a browser and serve a loopback
-// redirect back to it. Windows and macOS always can. On Linux and FreeBSD the answer is env
-// based, so it only holds for a process started from the graphical session itself: a service
-// does not inherit those variables and always reports false, which is why callers running in
-// the user's session pass their own answer to the daemon.
-func HasGraphicalSession() bool {
-	if runtime.GOOS != "linux" && runtime.GOOS != "freebsd" {
-		return true
-	}
-
-	for _, env := range browserSessionEnvVars() {
-		if os.Getenv(env) != "" {
-			return true
-		}
-	}
-
-	return slices.Contains(graphicalXDGSessionTypes(), os.Getenv(envXDGSessionType))
-}
-
 // SliceDiff returns the elements in slice `x` that are not in slice `y`
 func SliceDiff(x, y []string) []string {
 	mapY := make(map[string]struct{}, len(y))

util/session_test.go

@@ -1,50 +0,0 @@
-package util
-
-import (
-	"os"
-	"runtime"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-)
-
-func TestHasGraphicalSession(t *testing.T) {
-	if runtime.GOOS != "linux" && runtime.GOOS != "freebsd" {
-		assert.True(t, HasGraphicalSession(), "%s always has a graphical session", runtime.GOOS)
-		return
-	}
-
-	// clear anything inherited from the session running the test, restored on cleanup
-	for _, env := range append(browserSessionEnvVars(), envXDGSessionType) {
-		t.Setenv(env, "")
-		os.Unsetenv(env)
-	}
-
-	assert.False(t, HasGraphicalSession(), "no session variables means no graphical session")
-
-	tests := []struct {
-		env      string
-		value    string
-		expected bool
-	}{
-		{env: envDisplay, value: ":0", expected: true},
-		{env: envWaylandDisplay, value: "wayland-0", expected: true},
-		{env: envDesktopSession, value: "gnome", expected: true},
-		{env: envXDGCurrentDesktop, value: "KDE", expected: true},
-		{env: envBrowser, value: "firefox", expected: true},
-		{env: envXDGSessionType, value: "wayland", expected: true},
-		{env: envXDGSessionType, value: "x11", expected: true},
-		{env: envXDGSessionType, value: "mir", expected: true},
-		{env: envXDGSessionType, value: "tty", expected: false},
-		{env: envXDGSessionType, value: "unspecified", expected: false},
-		// an unrecognized type must not be read as a display: the device code flow works anyway
-		{env: envXDGSessionType, value: "something-new", expected: false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.env+"="+tt.value, func(t *testing.T) {
-			t.Setenv(tt.env, tt.value)
-			assert.Equal(t, tt.expected, HasGraphicalSession(), "%s=%s", tt.env, tt.value)
-		})
-	}
-}