Subnet docker conflict check; enterprice domain alias.

client/android/client.go

@@ -15,7 +15,6 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
-	nbAnonymize "github.com/netbirdio/netbird/client/anonymize"
 	"github.com/netbirdio/netbird/client/iface/device"
 	"github.com/netbirdio/netbird/client/internal"
 	"github.com/netbirdio/netbird/client/internal/debug"
@@ -279,10 +278,8 @@ func (c *Client) GetTunSettings() (*TunSettings, error) {
 }
 
 // DebugBundle generates a debug bundle, uploads it, and returns the upload key.
-// It works both with and without a running engine. anonymizeLevel is "default"
-// or "strict"; strict also anonymizes internal IP ranges, peer names, and
-// WireGuard public keys, and implies anonymize.
-func (c *Client) DebugBundle(platformFiles PlatformFiles, anonymize bool, anonymizeLevel string) (string, error) {
+// It works both with and without a running engine.
+func (c *Client) DebugBundle(platformFiles PlatformFiles, anonymize bool) (string, error) {
 	cfg, cacheDir, cc := c.stateSnapshot()
 
 	// If the engine hasn't been started, load config from disk
@@ -301,7 +298,6 @@ func (c *Client) DebugBundle(platformFiles PlatformFiles, anonymize bool, anonym
 		InternalConfig: cfg,
 		StatusRecorder: c.recorder,
 		TempDir:        cacheDir,
-		StatePath:      platformFiles.StateFilePath(),
 	}
 
 	if cc != nil {
@@ -325,7 +321,6 @@ func (c *Client) DebugBundle(platformFiles PlatformFiles, anonymize bool, anonym
 		deps,
 		debug.BundleConfig{
 			Anonymize:         anonymize,
-			AnonymizeLevel:    nbAnonymize.ParseLevel(anonymizeLevel),
 			IncludeSystemInfo: true,
 		},
 	)

client/anonymize/anonymize.go

@@ -2,7 +2,6 @@ package anonymize
 
 import (
 	"crypto/rand"
-	"encoding/base64"
 	"fmt"
 	"math/big"
 	"net"
@@ -16,81 +15,13 @@ import (
 
 const anonTLD = ".domain"
 
-// Level selects how much the anonymizer redacts. Levels are ordered: a higher
-// level redacts strictly more. On the wire (protos, flags) levels travel as
-// their string form.
-type Level int
-
-const (
-	// LevelDefault anonymizes public IP addresses, IPv6 ULA, domains, and MAC
-	// addresses. Internal IPv4 ranges (RFC 1918, CGNAT, link-local) are
-	// preserved so support can reason about the real topology.
-	LevelDefault Level = iota
-	// LevelStrict additionally anonymizes internal IP ranges, peer names, and
-	// WireGuard public keys.
-	LevelStrict
-)
-
-// ParseLevel maps s to a Level. Empty means LevelDefault; anything
-// unrecognized maps to LevelStrict so an unknown request never yields less
-// anonymization than intended.
-func ParseLevel(s string) Level {
-	switch strings.ToLower(s) {
-	case "", LevelDefault.String():
-		return LevelDefault
-	default:
-		return LevelStrict
-	}
-}
-
-// String returns the wire form of the level: "default" or "strict".
-func (l Level) String() string {
-	if l >= LevelStrict {
-		return "strict"
-	}
-	return "default"
-}
-
-// protectedDomains are NetBird-operated suffixes that stay recognizable in an
-// anonymized bundle. At LevelStrict the labels in front of them (the peer
-// name) are still replaced, except under netbird.io, which only hosts
-// NetBird infrastructure (api, signal, flow), never peer names.
-var protectedDomains = []string{"netbird.io", "netbird.selfhosted", "netbird.cloud", "netbird.stage"}
-
-const infraDomain = "netbird.io"
-
-var (
-	macColonRegex = regexp.MustCompile(`\b[0-9a-fA-F]{2}(?::[0-9a-fA-F]{2}){5}\b`)
-	macDashRegex  = regexp.MustCompile(`\b[0-9a-fA-F]{2}(?:-[0-9a-fA-F]{2}){5}\b`)
-	wgKeyRegex    = regexp.MustCompile(`\b[A-Za-z0-9+/]{43}=`)
-)
-
 type Anonymizer struct {
 	ipAnonymizer     map[netip.Addr]netip.Addr
 	domainAnonymizer map[string]string
-	// domainOrder caches the keys of domainAnonymizer sorted longest-first
-	// for AnonymizeString; it is rebuilt when the map gains entries.
-	domainOrder     []string
-	labelAnonymizer map[string]string
-	labelAnonymized map[string]struct{}
-	labelCounter    uint32
-	macAnonymizer   map[string]string
-	macCounter      uint32
-	wgKeyAnonymizer map[string]string
-	wgKeyAnonymized map[string]struct{}
-	currentAnonIPv4 netip.Addr
-	currentAnonIPv6 netip.Addr
-	startAnonIPv4   netip.Addr
-	startAnonIPv6   netip.Addr
-
-	// LevelStrict also anonymizes internal ranges (RFC 1918, CGNAT,
-	// link-local), replacing them from the dedicated internal pools below so
-	// a reader can still tell an internal address from a public one.
-	level                   Level
-	currentAnonInternalIPv4 netip.Addr
-	currentAnonInternalIPv6 netip.Addr
-	startAnonInternalIPv4   netip.Addr
-	startAnonInternalIPv6   netip.Addr
+	currentAnonIPv4  netip.Addr
+	currentAnonIPv6  netip.Addr
+	startAnonIPv4    netip.Addr
+	startAnonIPv6    netip.Addr
 
 	domainKeyRegex *regexp.Regexp
 }
@@ -101,50 +32,25 @@ func DefaultAddresses() (netip.Addr, netip.Addr) {
 	return netip.AddrFrom4([4]byte{198, 51, 100, 0}), netip.MustParseAddr("2001:db8:ffff::")
 }
 
-// InternalAddresses returns the pool starts used in strict mode for internal
-// ranges. Both are reserved ranges that cannot collide with real addressing:
-// 198.18.0.0 (RFC 2544 benchmarking), 2001:db8:1:: (RFC 3849 documentation).
-func InternalAddresses() (netip.Addr, netip.Addr) {
-	return netip.AddrFrom4([4]byte{198, 18, 0, 0}), netip.MustParseAddr("2001:db8:1::")
-}
-
 func NewAnonymizer(startIPv4, startIPv6 netip.Addr) *Anonymizer {
-	internalIPv4, internalIPv6 := InternalAddresses()
 	return &Anonymizer{
 		ipAnonymizer:     map[netip.Addr]netip.Addr{},
 		domainAnonymizer: map[string]string{},
-		labelAnonymizer:  map[string]string{},
-		labelAnonymized:  map[string]struct{}{},
-		macAnonymizer:    map[string]string{},
-		wgKeyAnonymizer:  map[string]string{},
-		wgKeyAnonymized:  map[string]struct{}{},
 		currentAnonIPv4:  startIPv4,
 		currentAnonIPv6:  startIPv6,
 		startAnonIPv4:    startIPv4,
 		startAnonIPv6:    startIPv6,
 
-		level:                   LevelDefault,
-		currentAnonInternalIPv4: internalIPv4,
-		currentAnonInternalIPv6: internalIPv6,
-		startAnonInternalIPv4:   internalIPv4,
-		startAnonInternalIPv6:   internalIPv6,
-
 		domainKeyRegex: regexp.MustCompile(`\bdomain=([^\s,:"]+)`),
 	}
 }
 
-// SetLevel selects the anonymization level. The zero value of a new
-// Anonymizer is LevelDefault.
-func (a *Anonymizer) SetLevel(level Level) {
-	a.level = level
-}
-
 func (a *Anonymizer) AnonymizeIP(ip netip.Addr) netip.Addr {
-	// Normalize 4-in-6 addresses so ::ffff:192.168.1.1 classifies and maps
-	// like 192.168.1.1.
-	ip = ip.Unmap()
-
 	if ip.IsLoopback() ||
+		ip.IsLinkLocalUnicast() ||
+		ip.IsLinkLocalMulticast() ||
+		ip.IsInterfaceLocalMulticast() ||
+		(ip.Is4() && ip.IsPrivate()) ||
 		ip.IsUnspecified() ||
 		ip.IsMulticast() ||
 		isWellKnown(ip) ||
@@ -153,100 +59,18 @@ func (a *Anonymizer) AnonymizeIP(ip netip.Addr) netip.Addr {
 		return ip
 	}
 
-	if isInternal(ip) && a.level < LevelStrict {
-		return ip
-	}
-
 	if _, ok := a.ipAnonymizer[ip]; !ok {
-		a.ipAnonymizer[ip] = a.nextAnonIP(ip)
+		if ip.Is4() {
+			a.ipAnonymizer[ip] = a.currentAnonIPv4
+			a.currentAnonIPv4 = a.currentAnonIPv4.Next()
+		} else {
+			a.ipAnonymizer[ip] = a.currentAnonIPv6
+			a.currentAnonIPv6 = a.currentAnonIPv6.Next()
+		}
 	}
 	return a.ipAnonymizer[ip]
 }
 
-func (a *Anonymizer) nextAnonIP(ip netip.Addr) netip.Addr {
-	// At the strict level, internal addresses (including IPv6 ULA, matched
-	// by IsPrivate) come from the internal pools so they remain recognizable
-	// as internal without disclosing the real values.
-	if a.level >= LevelStrict && (isInternal(ip) || ip.IsPrivate()) {
-		if ip.Is4() {
-			anon := a.currentAnonInternalIPv4
-			a.currentAnonInternalIPv4 = a.currentAnonInternalIPv4.Next()
-			return anon
-		}
-		anon := a.currentAnonInternalIPv6
-		a.currentAnonInternalIPv6 = a.currentAnonInternalIPv6.Next()
-		return anon
-	}
-
-	if ip.Is4() {
-		anon := a.currentAnonIPv4
-		a.currentAnonIPv4 = a.currentAnonIPv4.Next()
-		return anon
-	}
-	anon := a.currentAnonIPv6
-	a.currentAnonIPv6 = a.currentAnonIPv6.Next()
-	return anon
-}
-
-// AnonymizeMAC replaces a MAC address with a consistent placeholder from the
-// locally administered range starting at 02:00:00:00:00:01, at every
-// anonymization level. Broadcast, multicast, all-zero, and already assigned
-// placeholder addresses are preserved. The colon and dash spellings of the
-// same address share one placeholder; the output keeps the input's separator.
-func (a *Anonymizer) AnonymizeMAC(mac string) string {
-	hw, err := net.ParseMAC(mac)
-	if err != nil || len(hw) != 6 {
-		return mac
-	}
-
-	if isWellKnownMAC(hw) || a.isAnonymizedMAC(hw) {
-		return mac
-	}
-
-	key := hw.String()
-	anon, ok := a.macAnonymizer[key]
-	if !ok {
-		a.macCounter++
-		anon = fmt.Sprintf("02:00:00:%02x:%02x:%02x", byte(a.macCounter>>16), byte(a.macCounter>>8), byte(a.macCounter))
-		a.macAnonymizer[key] = anon
-	}
-
-	if strings.Contains(mac, "-") {
-		anon = strings.ReplaceAll(anon, ":", "-")
-	}
-	return anon
-}
-
-// isAnonymizedMAC reports whether hw is a placeholder this anonymizer already
-// handed out, so a second pass over anonymized output leaves it unchanged.
-func (a *Anonymizer) isAnonymizedMAC(hw net.HardwareAddr) bool {
-	if hw[0] != 0x02 || hw[1] != 0 || hw[2] != 0 {
-		return false
-	}
-	value := uint32(hw[3])<<16 | uint32(hw[4])<<8 | uint32(hw[5])
-	return value <= a.macCounter
-}
-
-// AnonymizeWGKey replaces a WireGuard public key with a consistent random
-// placeholder of the same shape. Keys are only anonymized at LevelStrict;
-// placeholders already handed out pass through unchanged.
-func (a *Anonymizer) AnonymizeWGKey(key string) string {
-	if a.level < LevelStrict || !looksLikeWGKey(key) {
-		return key
-	}
-	if _, ok := a.wgKeyAnonymized[key]; ok {
-		return key
-	}
-
-	anon, ok := a.wgKeyAnonymizer[key]
-	if !ok {
-		anon = generateAnonymousKey()
-		a.wgKeyAnonymizer[key] = anon
-		a.wgKeyAnonymized[anon] = struct{}{}
-	}
-	return anon
-}
-
 func (a *Anonymizer) AnonymizeUDPAddr(addr net.UDPAddr) net.UDPAddr {
 	// Convert IP to netip.Addr
 	ip, ok := netip.AddrFromSlice(addr.IP)
@@ -265,12 +89,12 @@ func (a *Anonymizer) AnonymizeUDPAddr(addr net.UDPAddr) net.UDPAddr {
 
 // isInAnonymizedRange checks if an IP is within the range of already assigned anonymized IPs
 func (a *Anonymizer) isInAnonymizedRange(ip netip.Addr) bool {
-	if ip.Is4() {
-		return inPoolRange(ip, a.startAnonIPv4, a.currentAnonIPv4) ||
-			inPoolRange(ip, a.startAnonInternalIPv4, a.currentAnonInternalIPv4)
+	if ip.Is4() && ip.Compare(a.startAnonIPv4) >= 0 && ip.Compare(a.currentAnonIPv4) <= 0 {
+		return true
+	} else if !ip.Is4() && ip.Compare(a.startAnonIPv6) >= 0 && ip.Compare(a.currentAnonIPv6) <= 0 {
+		return true
 	}
-	return inPoolRange(ip, a.startAnonIPv6, a.currentAnonIPv6) ||
-		inPoolRange(ip, a.startAnonInternalIPv6, a.currentAnonInternalIPv6)
+	return false
 }
 
 func (a *Anonymizer) AnonymizeIPString(ip string) string {
@@ -294,17 +118,14 @@ func (a *Anonymizer) AnonymizeDomain(domain string) string {
 		baseDomain = domain[:len(domain)-1]
 	}
 
-	if strings.HasSuffix(baseDomain, anonTLD) {
+	if strings.HasSuffix(baseDomain, "netbird.io") ||
+		strings.HasSuffix(baseDomain, "netbird.selfhosted") ||
+		strings.HasSuffix(baseDomain, "netbird.cloud") ||
+		strings.HasSuffix(baseDomain, "netbird.stage") ||
+		strings.HasSuffix(baseDomain, anonTLD) {
 		return domain
 	}
 
-	if suffix := protectedSuffix(baseDomain); suffix != "" {
-		if a.level < LevelStrict || baseDomain == suffix || suffix == infraDomain {
-			return domain
-		}
-		return withTrailingDot(a.anonymizePeerName(baseDomain, suffix), hasDot)
-	}
-
 	parts := strings.Split(baseDomain, ".")
 	if len(parts) < 2 {
 		return domain
@@ -320,53 +141,12 @@ func (a *Anonymizer) AnonymizeDomain(domain string) string {
 	}
 
 	result := strings.Replace(baseDomain, baseForLookup, anonymized, 1)
-	if a.level >= LevelStrict && len(parts) > 2 {
-		prefix := strings.TrimSuffix(baseDomain, "."+baseForLookup)
-		result = a.anonymizeLabels(prefix, "host") + "." + anonymized
-		// The full mapping feeds AnonymizeString so seeded FQDNs are caught
-		// in log lines as a whole, labels included.
-		a.domainAnonymizer[baseDomain] = result
-	}
-	return withTrailingDot(result, hasDot)
-}
-
-// anonymizePeerName replaces the labels in front of a protected suffix with
-// numbered peer placeholders, keeping the suffix, and records the full
-// mapping for string replacement in logs. The numbering keeps a peer
-// recognizable across the whole bundle without disclosing its name.
-func (a *Anonymizer) anonymizePeerName(baseDomain, suffix string) string {
-	prefix := strings.TrimSuffix(baseDomain, "."+suffix)
-	result := a.anonymizeLabels(prefix, "peer") + "." + suffix
-	if result != baseDomain {
-		a.domainAnonymizer[baseDomain] = result
+	if hasDot {
+		result += "."
 	}
 	return result
 }
 
-// anonymizeLabels replaces each dot-separated label with a consistent
-// numbered placeholder ("<placeholder>-<n>"). Wildcard labels and
-// placeholders already handed out pass through unchanged.
-func (a *Anonymizer) anonymizeLabels(prefix, placeholder string) string {
-	labels := strings.Split(prefix, ".")
-	for i, label := range labels {
-		if label == "*" {
-			continue
-		}
-		if _, ok := a.labelAnonymized[label]; ok {
-			continue
-		}
-		anon, ok := a.labelAnonymizer[label]
-		if !ok {
-			a.labelCounter++
-			anon = fmt.Sprintf("%s-%d", placeholder, a.labelCounter)
-			a.labelAnonymizer[label] = anon
-			a.labelAnonymized[anon] = struct{}{}
-		}
-		labels[i] = anon
-	}
-	return strings.Join(labels, ".")
-}
-
 func (a *Anonymizer) AnonymizeURI(uri string) string {
 	u, err := url.Parse(uri)
 	if err != nil {
@@ -401,70 +181,16 @@ func (a *Anonymizer) AnonymizeString(str string) string {
 	str = ipv4Regex.ReplaceAllStringFunc(str, a.AnonymizeIPString)
 	str = ipv6Regex.ReplaceAllStringFunc(str, a.AnonymizeIPString)
 
-	for _, domain := range a.sortedDomains() {
-		str = strings.ReplaceAll(str, domain, a.domainAnonymizer[domain])
+	for domain, anonDomain := range a.domainAnonymizer {
+		str = strings.ReplaceAll(str, domain, anonDomain)
 	}
 
 	str = a.AnonymizeSchemeURI(str)
 	str = a.AnonymizeDNSLogLine(str)
 
-	// MAC handling runs after the IP passes so preserved IPv6 addresses are
-	// already out of the way; the separator guard skips matches embedded in a
-	// longer colon- or dash-separated sequence (such as an IPv6 tail).
-	str = a.anonymizeMACsInString(str, macColonRegex, ':')
-	str = a.anonymizeMACsInString(str, macDashRegex, '-')
-
-	if a.level >= LevelStrict {
-		str = wgKeyRegex.ReplaceAllStringFunc(str, a.AnonymizeWGKey)
-	}
-
 	return str
 }
 
-// sortedDomains returns the domain mappings longest-first, so a full-FQDN
-// mapping (strict level) is applied before the base-domain mapping it
-// contains. The order is rebuilt only when domainAnonymizer has grown.
-func (a *Anonymizer) sortedDomains() []string {
-	if len(a.domainOrder) == len(a.domainAnonymizer) {
-		return a.domainOrder
-	}
-
-	a.domainOrder = a.domainOrder[:0]
-	for domain := range a.domainAnonymizer {
-		a.domainOrder = append(a.domainOrder, domain)
-	}
-	slices.SortFunc(a.domainOrder, func(x, y string) int {
-		if d := len(y) - len(x); d != 0 {
-			return d
-		}
-		return strings.Compare(x, y)
-	})
-	return a.domainOrder
-}
-
-// anonymizeMACsInString replaces MAC addresses matched by re, skipping
-// matches that directly adjoin another sep so a six-group run inside a longer
-// separated sequence is left alone.
-func (a *Anonymizer) anonymizeMACsInString(str string, re *regexp.Regexp, sep byte) string {
-	matches := re.FindAllStringIndex(str, -1)
-	if len(matches) == 0 {
-		return str
-	}
-
-	var b strings.Builder
-	last := 0
-	for _, m := range matches {
-		if (m[0] > 0 && str[m[0]-1] == sep) || (m[1] < len(str) && str[m[1]] == sep) {
-			continue
-		}
-		b.WriteString(str[last:m[0]])
-		b.WriteString(a.AnonymizeMAC(str[m[0]:m[1]]))
-		last = m[1]
-	}
-	b.WriteString(str[last:])
-	return b.String()
-}
-
 // AnonymizeSchemeURI finds and anonymizes URIs with ws, wss, rel, rels, stun, stuns, turn, and turns schemes.
 func (a *Anonymizer) AnonymizeSchemeURI(text string) string {
 	re := regexp.MustCompile(`(?i)\b(wss?://|rels?://|stuns?:|turns?:|https?://)\S+\b`)
@@ -513,79 +239,10 @@ func isWellKnown(addr netip.Addr) bool {
 		"128.0.0.0", "8000::", // 2nd split subnet for default routes
 	}
 
-	return slices.Contains(wellKnown, addr.String())
-}
-
-// isInternal reports whether ip identifies a host only within the local
-// network: IPv4 private (RFC 1918), CGNAT (RFC 6598), and link-local (v4 and
-// v6). These are preserved at the default level so support can reason about
-// the real topology, and replaced from the internal pools at the strict
-// level. IPv6 ULA is deliberately not internal: its random global ID uniquely
-// fingerprints the network, so it is anonymized at every level.
-func isInternal(ip netip.Addr) bool {
-	return (ip.Is4() && ip.IsPrivate()) ||
-		ip.IsLinkLocalUnicast() ||
-		isCGNAT(ip)
-}
-
-func inPoolRange(ip, start, current netip.Addr) bool {
-	return ip.Compare(start) >= 0 && ip.Compare(current) <= 0
-}
-
-// isWellKnownMAC reports whether hw carries no stable host identity: all-zero
-// or a group address (broadcast and multicast).
-func isWellKnownMAC(hw net.HardwareAddr) bool {
-	if hw[0]&1 == 1 {
+	if slices.Contains(wellKnown, addr.String()) {
 		return true
 	}
-	for _, b := range hw {
-		if b != 0 {
-			return false
-		}
-	}
-	return true
-}
 
-// looksLikeWGKey reports whether s has the shape of a WireGuard key:
-// 44 base64 characters decoding to 32 bytes.
-func looksLikeWGKey(s string) bool {
-	if len(s) != 44 || s[43] != '=' {
-		return false
-	}
-	decoded, err := base64.StdEncoding.DecodeString(s)
-	return err == nil && len(decoded) == 32
-}
-
-func generateAnonymousKey() string {
-	buf := make([]byte, 32)
-	if _, err := rand.Read(buf); err != nil {
-		return strings.Repeat("A", 43) + "="
-	}
-	return base64.StdEncoding.EncodeToString(buf)
-}
-
-// protectedSuffix returns the protected NetBird suffix baseDomain ends with,
-// or empty. The match is label-anchored so an unrelated domain that merely
-// ends in the same characters is not preserved.
-func protectedSuffix(baseDomain string) string {
-	for _, d := range protectedDomains {
-		if baseDomain == d || strings.HasSuffix(baseDomain, "."+d) {
-			return d
-		}
-	}
-	return ""
-}
-
-func withTrailingDot(domain string, hasDot bool) string {
-	if hasDot {
-		return domain + "."
-	}
-	return domain
-}
-
-// isCGNAT reports whether addr is in 100.64.0.0/10 (RFC 6598), the range
-// NetBird assigns overlay peer addresses from.
-func isCGNAT(addr netip.Addr) bool {
 	cgnatRangeStart := netip.AddrFrom4([4]byte{100, 64, 0, 0})
 	cgnatRange := netip.PrefixFrom(cgnatRangeStart, 10)
 

client/anonymize/anonymize_test.go

@@ -1,11 +1,8 @@
 package anonymize_test
 
 import (
-	"bytes"
-	"encoding/base64"
 	"net/netip"
 	"regexp"
-	"strings"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -47,301 +44,6 @@ func TestAnonymizeIP(t *testing.T) {
 	}
 }
 
-func TestParseLevel(t *testing.T) {
-	tests := []struct {
-		input  string
-		expect anonymize.Level
-	}{
-		{"", anonymize.LevelDefault},
-		{"default", anonymize.LevelDefault},
-		{"DEFAULT", anonymize.LevelDefault},
-		{"strict", anonymize.LevelStrict},
-		{"STRICT", anonymize.LevelStrict},
-		// Unknown values must never yield less anonymization than requested.
-		{"garbage", anonymize.LevelStrict},
-	}
-
-	for _, tc := range tests {
-		t.Run("input="+tc.input, func(t *testing.T) {
-			assert.Equal(t, tc.expect, anonymize.ParseLevel(tc.input), "parsed level should match")
-		})
-	}
-}
-
-func TestAnonymizeIP_DefaultLevelInternalRanges(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-
-	tests := []struct {
-		name   string
-		ip     string
-		expect string
-	}{
-		{"RFC1918 10/8", "10.1.2.3", "10.1.2.3"},
-		{"RFC1918 172.16/12", "172.16.5.5", "172.16.5.5"},
-		{"RFC1918 192.168/16", "192.168.1.1", "192.168.1.1"},
-		{"CGNAT", "100.64.0.5", "100.64.0.5"},
-		{"IPv4 link-local", "169.254.1.1", "169.254.1.1"},
-		{"IPv6 link-local", "fe80::1", "fe80::1"},
-		// ULA is anonymized even at the default level: its random global ID
-		// uniquely fingerprints the network, unlike shared RFC 1918 space.
-		{"IPv6 ULA", "fd12:3456:789a::1", "2001:db8:ffff::"},
-		// 4-in-6 addresses classify like their unmapped IPv4 form.
-		{"4-in-6 RFC1918", "::ffff:192.168.1.1", "192.168.1.1"},
-		{"4-in-6 CGNAT", "::ffff:100.64.0.5", "100.64.0.5"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := anonymizer.AnonymizeIP(netip.MustParseAddr(tc.ip))
-			assert.Equal(t, tc.expect, result.String(), "default level should preserve internal ranges except ULA")
-		})
-	}
-}
-
-func TestAnonymizeIP_StrictLevel(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-	anonymizer.SetLevel(anonymize.LevelStrict)
-
-	// Order matters: internal pool addresses are assigned sequentially.
-	tests := []struct {
-		name   string
-		ip     string
-		expect string
-	}{
-		{"RFC1918 192.168/16", "192.168.1.1", "198.18.0.0"},
-		{"Second RFC1918", "192.168.1.2", "198.18.0.1"},
-		{"Repeated RFC1918", "192.168.1.1", "198.18.0.0"},
-		{"RFC1918 10/8", "10.1.2.3", "198.18.0.2"},
-		{"RFC1918 172.16/12", "172.16.5.5", "198.18.0.3"},
-		{"CGNAT", "100.64.0.5", "198.18.0.4"},
-		{"IPv4 link-local", "169.254.1.1", "198.18.0.5"},
-		{"Public IPv4 uses public pool", "1.2.3.4", "198.51.100.0"},
-		{"IPv6 link-local", "fe80::1", "2001:db8:1::"},
-		{"IPv6 ULA", "fd12:3456:789a::1", "2001:db8:1::1"},
-		{"Public IPv6 uses public pool", "2607:f8b0:4005:805::200e", "2001:db8:ffff::"},
-		{"Loopback IPv4", "127.0.0.1", "127.0.0.1"},
-		{"Loopback IPv6", "::1", "::1"},
-		{"Unspecified", "0.0.0.0", "0.0.0.0"},
-		{"Multicast", "224.0.0.251", "224.0.0.251"},
-		{"Well known resolver", "8.8.8.8", "8.8.8.8"},
-		{"Well known split marker", "128.0.0.0", "128.0.0.0"},
-		{"In internal pool range", "198.18.0.3", "198.18.0.3"},
-		{"In public pool range", "198.51.100.0", "198.51.100.0"},
-		{"4-in-6 repeated RFC1918", "::ffff:192.168.1.1", "198.18.0.0"},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := anonymizer.AnonymizeIP(netip.MustParseAddr(tc.ip))
-			assert.Equal(t, tc.expect, result.String(), "strict level should replace internal ranges from the internal pools")
-		})
-	}
-}
-
-func TestAnonymizeString_StrictInternalIPs(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-	anonymizer.SetLevel(anonymize.LevelStrict)
-
-	input := "route 10.20.30.0/24 via 192.168.1.1 dev eth0 src 100.64.0.7"
-	firstPass := anonymizer.AnonymizeString(input)
-	secondPass := anonymizer.AnonymizeString(firstPass)
-
-	assert.NotContains(t, firstPass, "10.20.30.0", "private network address should be anonymized")
-	assert.NotContains(t, firstPass, "192.168.1.1", "private gateway should be anonymized")
-	assert.NotContains(t, firstPass, "100.64.0.7", "CGNAT address should be anonymized")
-	assert.Contains(t, firstPass, "/24", "prefix length should be preserved")
-	assert.Equal(t, firstPass, secondPass, "second pass should not further anonymize the string")
-}
-
-func TestAnonymizeMAC(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-
-	first := anonymizer.AnonymizeMAC("aa:bb:cc:dd:ee:0f")
-	assert.Equal(t, "02:00:00:00:00:01", first, "first MAC should get the first placeholder")
-	assert.Equal(t, first, anonymizer.AnonymizeMAC("aa:bb:cc:dd:ee:0f"), "repeated MAC should map to the same placeholder")
-	assert.Equal(t, first, anonymizer.AnonymizeMAC("AA:BB:CC:DD:EE:0F"), "case should not affect the mapping")
-	assert.Equal(t, "02-00-00-00-00-01", anonymizer.AnonymizeMAC("AA-BB-CC-DD-EE-0F"), "dash form should keep its separator but share the mapping")
-
-	second := anonymizer.AnonymizeMAC("10:22:33:44:55:66")
-	assert.Equal(t, "02:00:00:00:00:02", second, "second distinct MAC should get the next placeholder")
-
-	tests := []struct {
-		name string
-		mac  string
-	}{
-		{"Broadcast", "ff:ff:ff:ff:ff:ff"},
-		{"IPv4 multicast", "01:00:5e:00:00:fb"},
-		{"IPv6 multicast", "33:33:00:00:00:01"},
-		{"All zero", "00:00:00:00:00:00"},
-		{"Assigned placeholder", "02:00:00:00:00:01"},
-		{"Invalid", "not-a-mac"},
-	}
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			assert.Equal(t, tc.mac, anonymizer.AnonymizeMAC(tc.mac), "should be preserved")
-		})
-	}
-}
-
-func TestAnonymizeString_MACAddresses(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-
-	tests := []struct {
-		name   string
-		input  string
-		expect string
-	}{
-		{
-			name:   "nftables ether rule",
-			input:  "ether saddr aa:bb:cc:dd:ee:ff drop",
-			expect: "ether saddr 02:00:00:00:00:01 drop",
-		},
-		{
-			name:   "Windows dash form",
-			input:  "Physical Address : AA-BB-CC-DD-EE-FF",
-			expect: "Physical Address : 02-00-00-00-00-01",
-		},
-		{
-			name:   "IPv6 address tail is not treated as MAC",
-			input:  "addr fe80:0:11:22:33:44:55:66 scope link",
-			expect: "addr fe80:0:11:22:33:44:55:66 scope link",
-		},
-		{
-			name:   "broadcast MAC preserved",
-			input:  "dst ff:ff:ff:ff:ff:ff type ARP",
-			expect: "dst ff:ff:ff:ff:ff:ff type ARP",
-		},
-	}
-
-	for _, tc := range tests {
-		t.Run(tc.name, func(t *testing.T) {
-			result := anonymizer.AnonymizeString(tc.input)
-			assert.Equal(t, tc.expect, result, "MAC addresses should be anonymized at every level")
-			assert.Equal(t, result, anonymizer.AnonymizeString(result), "second pass should not change the result")
-		})
-	}
-}
-
-func TestAnonymizeWGKey(t *testing.T) {
-	key := base64.StdEncoding.EncodeToString(bytes.Repeat([]byte{0x42}, 32))
-
-	t.Run("default level preserves keys", func(t *testing.T) {
-		anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-		assert.Equal(t, key, anonymizer.AnonymizeWGKey(key), "default level should not touch WireGuard keys")
-	})
-
-	t.Run("strict level replaces keys", func(t *testing.T) {
-		anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-		anonymizer.SetLevel(anonymize.LevelStrict)
-
-		anon := anonymizer.AnonymizeWGKey(key)
-		assert.NotEqual(t, key, anon, "strict level should replace the key")
-		assert.Regexp(t, `^[A-Za-z0-9+/]{43}=$`, anon, "placeholder should keep the WireGuard key shape")
-		assert.Equal(t, anon, anonymizer.AnonymizeWGKey(key), "repeated key should map to the same placeholder")
-		assert.Equal(t, anon, anonymizer.AnonymizeWGKey(anon), "an assigned placeholder should pass through unchanged")
-
-		assert.Equal(t, "not-a-key", anonymizer.AnonymizeWGKey("not-a-key"), "non-key values should be preserved")
-	})
-}
-
-func TestAnonymizeString_WGKeys(t *testing.T) {
-	key := base64.StdEncoding.EncodeToString(bytes.Repeat([]byte{0x42}, 32))
-	input := "peer " + key + " handshake completed"
-
-	t.Run("default level preserves keys", func(t *testing.T) {
-		anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-		assert.Equal(t, input, anonymizer.AnonymizeString(input), "default level should not touch WireGuard keys in strings")
-	})
-
-	t.Run("strict level replaces keys", func(t *testing.T) {
-		anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-		anonymizer.SetLevel(anonymize.LevelStrict)
-
-		firstPass := anonymizer.AnonymizeString(input)
-		assert.NotContains(t, firstPass, key, "the key should not survive strict anonymization")
-		assert.Equal(t, anonymizer.AnonymizeWGKey(key), extractKey(t, firstPass), "string replacement should be consistent with AnonymizeWGKey")
-		assert.Equal(t, firstPass, anonymizer.AnonymizeString(firstPass), "second pass should not change the result")
-	})
-}
-
-func extractKey(t *testing.T, logLine string) string {
-	t.Helper()
-	fields := strings.Fields(logLine)
-	require.Len(t, fields, 4, "log line should keep its structure")
-	return fields[1]
-}
-
-func TestAnonymizeDomain_StrictLevel(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-	anonymizer.SetLevel(anonymize.LevelStrict)
-
-	t.Run("netbird peer name", func(t *testing.T) {
-		result := anonymizer.AnonymizeDomain("my-laptop.netbird.cloud")
-		assert.Regexp(t, `^peer-\d+\.netbird\.cloud$`, result, "peer name should be anonymized, suffix kept")
-		assert.NotContains(t, result, "my-laptop", "the peer name should not survive")
-		assert.Equal(t, result, anonymizer.AnonymizeDomain("my-laptop.netbird.cloud"), "repeated domain should map consistently")
-		assert.Equal(t, result, anonymizer.AnonymizeDomain(result), "an anonymized domain should pass through unchanged")
-	})
-
-	t.Run("bare netbird domain", func(t *testing.T) {
-		assert.Equal(t, "netbird.cloud", anonymizer.AnonymizeDomain("netbird.cloud"), "the bare protected suffix should be preserved")
-	})
-
-	t.Run("netbird infrastructure preserved", func(t *testing.T) {
-		assert.Equal(t, "api.netbird.io", anonymizer.AnonymizeDomain("api.netbird.io"),
-			"netbird.io hosts infrastructure, not peer names, and should stay readable")
-	})
-
-	t.Run("leading labels of other domains", func(t *testing.T) {
-		result := anonymizer.AnonymizeDomain("host1.corp.example.com")
-		assert.Regexp(t, `^host-\d+\.host-\d+\.anon-[a-zA-Z0-9]+\.domain$`, result, "every label should be anonymized")
-		for _, label := range []string{"host1", "corp", "example"} {
-			assert.NotContains(t, result, label, "no original label should survive")
-		}
-		assert.Equal(t, result, anonymizer.AnonymizeDomain("host1.corp.example.com"), "repeated domain should map consistently")
-	})
-
-	t.Run("same label maps consistently across domains", func(t *testing.T) {
-		first := anonymizer.AnonymizeDomain("shared.one.com")
-		second := anonymizer.AnonymizeDomain("shared.two.com")
-		assert.Equal(t, strings.Split(first, ".")[0], strings.Split(second, ".")[0], "the shared host label should get one placeholder")
-	})
-
-	t.Run("wildcard label preserved", func(t *testing.T) {
-		result := anonymizer.AnonymizeDomain("*.example.com")
-		assert.Regexp(t, `^\*\.anon-[a-zA-Z0-9]+\.domain$`, result, "the wildcard label should stay a wildcard")
-	})
-}
-
-func TestAnonymizeDomain_DefaultLevelKeepsPeerNames(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-
-	assert.Equal(t, "my-laptop.netbird.cloud", anonymizer.AnonymizeDomain("my-laptop.netbird.cloud"),
-		"default level should preserve netbird FQDNs including the peer name")
-	assert.Regexp(t, `^sub\.anon-[a-zA-Z0-9]+\.domain$`, anonymizer.AnonymizeDomain("sub.example.com"),
-		"default level should keep subdomain labels")
-}
-
-func TestAnonymizeString_StrictPeerNames(t *testing.T) {
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-	anonymizer.SetLevel(anonymize.LevelStrict)
-
-	// Seed like the bundle generator does from the status: base first, then
-	// the full FQDN, so replacement must prefer the longer mapping.
-	anonBase := anonymizer.AnonymizeDomain("example.com")
-	anonPeer := anonymizer.AnonymizeDomain("peer1.netbird.cloud")
-	anonHost := anonymizer.AnonymizeDomain("host1.example.com")
-
-	logLine := "connected to peer1.netbird.cloud via host1.example.com endpoint"
-	firstPass := anonymizer.AnonymizeString(logLine)
-	assert.NotContains(t, firstPass, "peer1", "the peer name should not survive in logs")
-	assert.NotContains(t, firstPass, "host1", "the host label should not survive in logs")
-	assert.Contains(t, firstPass, anonPeer, "the seeded peer mapping should be applied")
-	assert.Contains(t, firstPass, anonHost, "the seeded host mapping should be applied, not just the base mapping")
-	assert.NotContains(t, firstPass, "host1."+anonBase, "the base mapping must not preempt the longer FQDN mapping")
-	assert.Equal(t, firstPass, anonymizer.AnonymizeString(firstPass), "second pass should not change the result")
-}
-
 func TestAnonymizeDNSLogLine(t *testing.T) {
 	anonymizer := anonymize.NewAnonymizer(netip.Addr{}, netip.Addr{})
 	tests := []struct {

client/cmd/debug.go

@@ -27,8 +27,8 @@ import (
 const errCloseConnection = "Failed to close connection: %v"
 
 var (
-	logFileCount             uint32
-	systemInfoFlag           bool
+	logFileCount        uint32
+	systemInfoFlag      bool
 	uploadBundleFlag         bool
 	uploadBundleURLFlag      string
 	uploadBundleInsecureFlag bool
@@ -156,11 +156,6 @@ func debugConfigDump(cmd *cobra.Command, _ []string) error {
 // request. Returns an error if the RPC fails or if the daemon reports
 // an upload failure reason.
 func debugBundle(cmd *cobra.Command, _ []string) error {
-	anonymizeEnabled, anonymizeLevel, err := effectiveAnonymize()
-	if err != nil {
-		return err
-	}
-
 	conn, err := getClient(cmd)
 	if err != nil {
 		return err
@@ -173,11 +168,10 @@ func debugBundle(cmd *cobra.Command, _ []string) error {
 
 	client := proto.NewDaemonServiceClient(conn)
 	request := &proto.DebugBundleRequest{
-		Anonymize:      anonymizeEnabled,
-		AnonymizeLevel: anonymizeLevel.String(),
-		SystemInfo:     systemInfoFlag,
-		LogFileCount:   logFileCount,
-		CliVersion:     version.NetbirdVersion(),
+		Anonymize:    anonymizeFlag,
+		SystemInfo:   systemInfoFlag,
+		LogFileCount: logFileCount,
+		CliVersion:   version.NetbirdVersion(),
 	}
 	if uploadBundleFlag {
 		request.UploadURL = uploadBundleURLFlag
@@ -235,11 +229,6 @@ func runForDuration(cmd *cobra.Command, args []string) error {
 		return fmt.Errorf("invalid duration format: %v", err)
 	}
 
-	anonymizeEnabled, anonymizeLevel, err := effectiveAnonymize()
-	if err != nil {
-		return err
-	}
-
 	conn, err := getClient(cmd)
 	if err != nil {
 		return err
@@ -379,11 +368,10 @@ func runForDuration(cmd *cobra.Command, args []string) error {
 	cmd.Println("Creating debug bundle...")
 
 	request := &proto.DebugBundleRequest{
-		Anonymize:      anonymizeEnabled,
-		AnonymizeLevel: anonymizeLevel.String(),
-		SystemInfo:     systemInfoFlag,
-		LogFileCount:   logFileCount,
-		CliVersion:     version.NetbirdVersion(),
+		Anonymize:    anonymizeFlag,
+		SystemInfo:   systemInfoFlag,
+		LogFileCount: logFileCount,
+		CliVersion:   version.NetbirdVersion(),
 	}
 	if uploadBundleFlag {
 		request.UploadURL = uploadBundleURLFlag

client/cmd/root.go

@@ -21,7 +21,6 @@ import (
 	"github.com/spf13/pflag"
 	"google.golang.org/grpc"
 
-	"github.com/netbirdio/netbird/client/anonymize"
 	daddr "github.com/netbirdio/netbird/client/internal/daemonaddr"
 	"github.com/netbirdio/netbird/client/internal/profilemanager"
 )
@@ -70,7 +69,6 @@ var (
 	autoConnectDisabled     bool
 	extraIFaceBlackList     []string
 	anonymizeFlag           bool
-	anonymizeLevelFlag      string
 	dnsRouteInterval        time.Duration
 	// lazyConnEnabled is the parse target for the deprecated --enable-lazy-connection
 	// flag. The flag is inert; the value is no longer read (use NB_LAZY_CONN instead).
@@ -158,8 +156,7 @@ func init() {
 	rootCmd.MarkFlagsMutuallyExclusive("setup-key", "setup-key-file")
 	rootCmd.PersistentFlags().StringVar(&preSharedKey, preSharedKeyFlag, "", "Sets WireGuard PreSharedKey property. If set, then only peers that have the same key can communicate.")
 	rootCmd.PersistentFlags().StringVarP(&hostName, "hostname", "n", "", "Sets a custom hostname for the device")
-	rootCmd.PersistentFlags().BoolVarP(&anonymizeFlag, "anonymize", "A", false, "anonymize public IP addresses, MAC addresses, and non-netbird.io domains in logs and status output; private, CGNAT, and link-local IP ranges are kept (see --anonymize-level strict)")
-	rootCmd.PersistentFlags().StringVar(&anonymizeLevelFlag, "anonymize-level", "", "anonymization level: \"default\" or \"strict\"; strict also anonymizes private, CGNAT, and link-local IP ranges, peer names, and WireGuard public keys. Setting this flag implies --anonymize")
+	rootCmd.PersistentFlags().BoolVarP(&anonymizeFlag, "anonymize", "A", false, "anonymize IP addresses and non-netbird.io domains in logs and status output")
 	rootCmd.PersistentFlags().StringVarP(&configPath, "config", "c", profilemanager.DefaultConfigPath, "Overrides the default profile file location")
 
 	rootCmd.AddCommand(upCmd)
@@ -296,19 +293,6 @@ var CLIBackOffSettings = &backoff.ExponentialBackOff{
 	Clock:               backoff.SystemClock,
 }
 
-// effectiveAnonymize resolves the --anonymize and --anonymize-level flags:
-// setting a level implies anonymization, and an invalid level is rejected.
-func effectiveAnonymize() (bool, anonymize.Level, error) {
-	if anonymizeLevelFlag == "" {
-		return anonymizeFlag, anonymize.LevelDefault, nil
-	}
-	level := anonymize.ParseLevel(anonymizeLevelFlag)
-	if !strings.EqualFold(anonymizeLevelFlag, level.String()) {
-		return false, anonymize.LevelDefault, fmt.Errorf("invalid anonymize level %q: use %q or %q", anonymizeLevelFlag, anonymize.LevelDefault.String(), anonymize.LevelStrict.String())
-	}
-	return true, level, nil
-}
-
 func getSetupKey() (string, error) {
 	if setupKeyPath != "" && setupKey == "" {
 		return getSetupKeyFromFile(setupKeyPath)

client/cmd/status.go

@@ -121,14 +121,8 @@ func statusFunc(cmd *cobra.Command, args []string) error {
 		sessionExpiresAt = ts.AsTime().UTC()
 	}
 
-	anonymizeEnabled, anonymizeLevel, err := effectiveAnonymize()
-	if err != nil {
-		return err
-	}
-
 	var outputInformationHolder = nbstatus.ConvertToStatusOutputOverview(resp.GetFullStatus(), nbstatus.ConvertOptions{
-		Anonymize:            anonymizeEnabled,
-		AnonymizeLevel:       anonymizeLevel,
+		Anonymize:            anonymizeFlag,
 		DaemonVersion:        resp.GetDaemonVersion(),
 		DaemonStatus:         nbstatus.ParseDaemonStatus(status),
 		StatusFilter:         statusFilter,

client/internal/debug/debug.go

@@ -34,8 +34,9 @@ import (
 	"github.com/netbirdio/netbird/shared/netiputil"
 )
 
-const readmeContent = `This debug bundle contains the following files.
-If anonymization is enabled (--anonymize / --anonymize-level), the files are anonymized to protect sensitive information.
+const readmeContent = `Netbird debug bundle
+This debug bundle contains the following files.
+If the --anonymize flag is set, the files are anonymized to protect sensitive information.
 
 status.txt: Anonymized status information of the NetBird client.
 client.log: Most recent, anonymized client log file of the NetBird client.
@@ -69,34 +70,21 @@ capture.pcap: Packet capture in pcap format. Only present when capture was runni
 
 
 Anonymization Process
-The files in this bundle have been anonymized to protect sensitive information. The level applied to this bundle is recorded at the top of this file. Here's how the anonymization was applied:
+The files in this bundle have been anonymized to protect sensitive information. Here's how the anonymization was applied:
 
 IP Addresses
 
-Default level:
-- Public IPv4 addresses are replaced with addresses starting from 198.51.100.0
-- Public IPv6 addresses are replaced with addresses starting from 2001:db8:ffff::
-- IPv6 unique local addresses (fc00::/7) are anonymized as well: their random global ID uniquely identifies the network.
-- IP addresses from internal IPv4 ranges and well-known addresses are not anonymized (e.g. 8.8.8.8, 100.64.0.0/10, addresses starting with 192.168., 172.16., 10., 169.254., fe80::).
-
-Strict level (--anonymize-level strict), in addition to the default level:
-- Private (RFC 1918), CGNAT (100.64.0.0/10), and link-local (169.254.0.0/16, fe80::/10) addresses are anonymized too.
-- Internal IPv4 addresses are replaced with addresses starting from 198.18.0.0 and internal IPv6 addresses with addresses starting from 2001:db8:1::, so internal addresses remain distinguishable from public ones.
-- Addresses are mapped in order of first appearance: subnet structure, allocation scheme, and gateway conventions are not preserved. Prefix lengths of networks are preserved.
-- Peer names in front of NetBird domains are replaced with numbered placeholders (e.g. peer-1.netbird.cloud), and subdomain labels of other domains with host-N placeholders.
-- WireGuard public keys are replaced with consistent placeholder keys.
+IPv4 addresses are replaced with addresses starting from 198.51.100.0
+IPv6 addresses are replaced with addresses starting from 100::
 
+IP addresses from non public ranges and well known addresses are not anonymized (e.g. 8.8.8.8, 100.64.0.0/10, addresses starting with 192.168., 172.16., 10., etc.).
 Reoccuring IP addresses are replaced with the same anonymized address.
 
 Note: The anonymized IP addresses in the status file do not match those in the log and routes files. However, the anonymized IP addresses are consistent within the status file and across the routes and log files.
 
-MAC Addresses
-MAC addresses are replaced at every anonymization level with consistent placeholders counting up from 02:00:00:00:00:01. Broadcast, multicast, and all-zero addresses are kept. At the default level a preserved IPv6 link-local address may still embed a MAC address (EUI-64); the strict level anonymizes those addresses.
-
 Domains
 All domain names (except for the netbird domains) are replaced with randomly generated strings ending in ".domain". Anonymized domains are consistent across all files in the bundle.
 Reoccuring domain names are replaced with the same anonymized domain.
-At the strict level, the peer name labels in front of netbird domains are anonymized as well.
 
 Sync Response
 The network_map.json file contains the following anonymized information:
@@ -293,7 +281,6 @@ type BundleGenerator struct {
 	cliVersion     string
 
 	anonymize         bool
-	anonymizeLevel    anonymize.Level
 	includeSystemInfo bool
 	logFileCount      uint32
 
@@ -301,10 +288,7 @@ type BundleGenerator struct {
 }
 
 type BundleConfig struct {
-	Anonymize bool
-	// AnonymizeLevel selects how much the anonymizer redacts.
-	// anonymize.LevelStrict implies Anonymize.
-	AnonymizeLevel    anonymize.Level
+	Anonymize         bool
 	IncludeSystemInfo bool
 	LogFileCount      uint32
 }
@@ -343,11 +327,8 @@ func NewBundleGenerator(deps GeneratorDependencies, cfg BundleConfig) *BundleGen
 		uiLogOpener = openLogFile
 	}
 
-	anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-	anonymizer.SetLevel(cfg.AnonymizeLevel)
-
 	return &BundleGenerator{
-		anonymizer: anonymizer,
+		anonymizer: anonymize.NewAnonymizer(anonymize.DefaultAddresses()),
 
 		internalConfig: deps.InternalConfig,
 		statusRecorder: deps.StatusRecorder,
@@ -364,8 +345,7 @@ func NewBundleGenerator(deps GeneratorDependencies, cfg BundleConfig) *BundleGen
 		daemonVersion:  deps.DaemonVersion,
 		cliVersion:     deps.CliVersion,
 
-		anonymize:         cfg.Anonymize || cfg.AnonymizeLevel >= anonymize.LevelStrict,
-		anonymizeLevel:    cfg.AnonymizeLevel,
+		anonymize:         cfg.Anonymize,
 		includeSystemInfo: cfg.IncludeSystemInfo,
 		logFileCount:      logFileCount,
 	}
@@ -505,13 +485,7 @@ func (g *BundleGenerator) addSystemInfo() {
 }
 
 func (g *BundleGenerator) addReadme() error {
-	level := "none (anonymization disabled)"
-	if g.anonymize {
-		level = g.anonymizeLevel.String()
-	}
-	header := fmt.Sprintf("Netbird debug bundle\nAnonymization level applied to this bundle: %s\n", level)
-
-	readmeReader := strings.NewReader(header + readmeContent)
+	readmeReader := strings.NewReader(readmeContent)
 	if err := g.addFileToZip(readmeReader, "README.txt"); err != nil {
 		return fmt.Errorf("add README file to zip: %w", err)
 	}
@@ -533,10 +507,9 @@ func (g *BundleGenerator) addStatus() error {
 		fullStatus := g.statusRecorder.GetFullStatus()
 		protoFullStatus := nbstatus.ToProtoFullStatus(fullStatus)
 		overview := nbstatus.ConvertToStatusOutputOverview(protoFullStatus, nbstatus.ConvertOptions{
-			Anonymize:      g.anonymize,
-			AnonymizeLevel: g.anonymizeLevel,
-			ProfileName:    profName,
-			DaemonVersion:  g.daemonVersion,
+			Anonymize:     g.anonymize,
+			ProfileName:   profName,
+			DaemonVersion: g.daemonVersion,
 		})
 		overview.CliVersion = g.cliVersion
 		statusOutput := overview.FullDetailSummary()
@@ -689,7 +662,7 @@ func (g *BundleGenerator) addCommonConfigFields(configContent *strings.Builder)
 	configContent.WriteString("NetBird Client Configuration:\n\n")
 
 	if key, err := wgtypes.ParseKey(g.internalConfig.PrivateKey); err == nil {
-		configContent.WriteString(fmt.Sprintf("PublicKey: %s\n", g.anonymizer.AnonymizeWGKey(key.PublicKey().String())))
+		configContent.WriteString(fmt.Sprintf("PublicKey: %s\n", key.PublicKey().String()))
 	}
 	configContent.WriteString(fmt.Sprintf("WgIface: %s\n", g.internalConfig.WgIface))
 	configContent.WriteString(fmt.Sprintf("WgPort: %d\n", g.internalConfig.WgPort))
@@ -979,11 +952,6 @@ func (g *BundleGenerator) addUpdateLogs() error {
 		}
 
 		baseName := filepath.Base(logFile)
-		data, err = g.anonymizeBytes(data)
-		if err != nil {
-			log.Warnf("skipping update log file %s: %v", baseName, err)
-			continue
-		}
 		if err := g.addFileToZip(bytes.NewReader(data), filepath.Join("update-logs", baseName)); err != nil {
 			return fmt.Errorf("add update log file %s to zip: %w", baseName, err)
 		}
@@ -1011,13 +979,6 @@ func (g *BundleGenerator) addCorruptedStateFiles() error {
 		}
 
 		fileName := filepath.Base(match)
-		// Corrupted state files usually fail structured JSON anonymization,
-		// so run them through the string anonymizer instead.
-		data, err = g.anonymizeBytes(data)
-		if err != nil {
-			log.Warnf("skipping corrupted state file %s: %v", fileName, err)
-			continue
-		}
 		if err := g.addFileToZip(bytes.NewReader(data), "corrupted_states/"+fileName); err != nil {
 			log.Warnf("Failed to add corrupted state file %s to zip: %v", fileName, err)
 			continue
@@ -1029,27 +990,6 @@ func (g *BundleGenerator) addCorruptedStateFiles() error {
 	return nil
 }
 
-// anonymizeBytes runs raw file content through the string anonymizer line by
-// line when anonymization is enabled. It errors instead of returning partial
-// content, so a caller never adds an unanonymized fallback to the bundle.
-func (g *BundleGenerator) anonymizeBytes(data []byte) ([]byte, error) {
-	if !g.anonymize {
-		return data, nil
-	}
-
-	var buf bytes.Buffer
-	scanner := bufio.NewScanner(bytes.NewReader(data))
-	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
-	for scanner.Scan() {
-		buf.WriteString(g.anonymizer.AnonymizeString(scanner.Text()))
-		buf.WriteByte('\n')
-	}
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("anonymize content: %w", err)
-	}
-	return buf.Bytes(), nil
-}
-
 func (g *BundleGenerator) addMetrics() error {
 	if g.clientMetrics == nil {
 		log.Debugf("skipping metrics in debug bundle: no metrics collector")
@@ -1522,7 +1462,6 @@ func anonymizeRemotePeer(peer *mgmProto.RemotePeerConfig, anonymizer *anonymize.
 	}
 
 	peer.Fqdn = anonymizer.AnonymizeDomain(peer.Fqdn)
-	peer.WgPubKey = anonymizer.AnonymizeWGKey(peer.WgPubKey)
 
 	anonymizeSSHConfig(peer.SshConfig)
 }

client/internal/debug/wgshow.go

@@ -35,14 +35,14 @@ func (g *BundleGenerator) toWGShowFormat(s *configurer.Stats) string {
 	var sb strings.Builder
 
 	sb.WriteString(fmt.Sprintf("interface: %s\n", s.DeviceName))
-	sb.WriteString(fmt.Sprintf("  public key: %s\n", g.anonymizer.AnonymizeWGKey(s.PublicKey)))
+	sb.WriteString(fmt.Sprintf("  public key: %s\n", s.PublicKey))
 	sb.WriteString(fmt.Sprintf("  listen port: %d\n", s.ListenPort))
 	if s.FWMark != 0 {
 		sb.WriteString(fmt.Sprintf("  fwmark: %#x\n", s.FWMark))
 	}
 
 	for _, peer := range s.Peers {
-		sb.WriteString(fmt.Sprintf("\npeer: %s\n", g.anonymizer.AnonymizeWGKey(peer.PublicKey)))
+		sb.WriteString(fmt.Sprintf("\npeer: %s\n", peer.PublicKey))
 		if peer.Endpoint.IP != nil {
 			if g.anonymize {
 				anonEndpoint := g.anonymizer.AnonymizeUDPAddr(peer.Endpoint)
@@ -54,11 +54,7 @@ func (g *BundleGenerator) toWGShowFormat(s *configurer.Stats) string {
 		if len(peer.AllowedIPs) > 0 {
 			var ipStrings []string
 			for _, ipnet := range peer.AllowedIPs {
-				ipStr := ipnet.String()
-				if g.anonymize {
-					ipStr = g.anonymizer.AnonymizeIPString(ipStr)
-				}
-				ipStrings = append(ipStrings, ipStr)
+				ipStrings = append(ipStrings, ipnet.String())
 			}
 			sb.WriteString(fmt.Sprintf("  allowed ips: %s\n", strings.Join(ipStrings, ", ")))
 		}

client/internal/engine.go

@@ -23,7 +23,6 @@ import (
 	"golang.zx2c4.com/wireguard/tun/netstack"
 	"golang.zx2c4.com/wireguard/wgctrl/wgtypes"
 
-	"github.com/netbirdio/netbird/client/anonymize"
 	nberrors "github.com/netbirdio/netbird/client/errors"
 	"github.com/netbirdio/netbird/client/firewall"
 	"github.com/netbirdio/netbird/client/firewall/firewalld"
@@ -1386,7 +1385,6 @@ func (e *Engine) handleBundle(params *mgmProto.BundleParameters) (*mgmProto.JobR
 
 	bundleJobParams := debug.BundleConfig{
 		Anonymize:         params.Anonymize,
-		AnonymizeLevel:    anonymize.ParseLevel(params.AnonymizeLevel),
 		IncludeSystemInfo: true,
 		LogFileCount:      uint32(params.LogFileCount),
 	}

client/ios/NetBirdSDK/client.go

@@ -14,7 +14,6 @@ import (
 
 	log "github.com/sirupsen/logrus"
 
-	nbAnonymize "github.com/netbirdio/netbird/client/anonymize"
 	"github.com/netbirdio/netbird/client/internal"
 	"github.com/netbirdio/netbird/client/internal/auth"
 	"github.com/netbirdio/netbird/client/internal/debug"
@@ -201,10 +200,8 @@ func (c *Client) Stop() {
 // DebugBundle generates a debug bundle, uploads it and returns the upload key.
 // It works with or without a running engine: when the engine is up it reuses
 // the live config, sync response and client metrics; otherwise it loads the
-// config from disk (or the preloaded tvOS config). anonymizeLevel is "default"
-// or "strict"; strict also anonymizes internal IP ranges, peer names, and
-// WireGuard public keys, and implies anonymize.
-func (c *Client) DebugBundle(anonymize bool, anonymizeLevel string) (string, error) {
+// config from disk (or the preloaded tvOS config).
+func (c *Client) DebugBundle(anonymize bool) (string, error) {
 	cfg, cc := c.stateSnapshot()
 
 	// If the engine hasn't been started, load config so we can reach management.
@@ -254,7 +251,6 @@ func (c *Client) DebugBundle(anonymize bool, anonymizeLevel string) (string, err
 		deps,
 		debug.BundleConfig{
 			Anonymize:         anonymize,
-			AnonymizeLevel:    nbAnonymize.ParseLevel(anonymizeLevel),
 			IncludeSystemInfo: true,
 		},
 	)

client/proto/daemon.pb.go

@@ -2781,11 +2781,6 @@ type DebugBundleRequest struct {
 	// untrusted TLS certificate. Restricted to privileged callers; for
 	// self-hosted upload servers.
 	UploadInsecure bool `protobuf:"varint,7,opt,name=uploadInsecure,proto3" json:"uploadInsecure,omitempty"`
-	// anonymizeLevel selects how much the anonymizer redacts: "default"
-	// (or empty) keeps internal IP ranges, "strict" also anonymizes them.
-	// Unknown values are treated as "strict". Only meaningful with anonymize;
-	// "strict" implies it.
-	AnonymizeLevel string `protobuf:"bytes,8,opt,name=anonymizeLevel,proto3" json:"anonymizeLevel,omitempty"`
 	unknownFields  protoimpl.UnknownFields
 	sizeCache      protoimpl.SizeCache
 }
@@ -2862,13 +2857,6 @@ func (x *DebugBundleRequest) GetUploadInsecure() bool {
 	return false
 }
 
-func (x *DebugBundleRequest) GetAnonymizeLevel() string {
-	if x != nil {
-		return x.AnonymizeLevel
-	}
-	return ""
-}
-
 type DebugBundleResponse struct {
 	state               protoimpl.MessageState `protogen:"open.v1"`
 	Path                string                 `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
@@ -7265,7 +7253,7 @@ const file_daemon_proto_rawDesc = "" +
 	"\x12translatedHostname\x18\x04 \x01(\tR\x12translatedHostname\x128\n" +
 	"\x0etranslatedPort\x18\x05 \x01(\v2\x10.daemon.PortInfoR\x0etranslatedPort\"G\n" +
 	"\x17ForwardingRulesResponse\x12,\n" +
-	"\x05rules\x18\x01 \x03(\v2\x16.daemon.ForwardingRuleR\x05rules\"\x84\x02\n" +
+	"\x05rules\x18\x01 \x03(\v2\x16.daemon.ForwardingRuleR\x05rules\"\xdc\x01\n" +
 	"\x12DebugBundleRequest\x12\x1c\n" +
 	"\tanonymize\x18\x01 \x01(\bR\tanonymize\x12\x1e\n" +
 	"\n" +
@@ -7276,8 +7264,7 @@ const file_daemon_proto_rawDesc = "" +
 	"\n" +
 	"cliVersion\x18\x06 \x01(\tR\n" +
 	"cliVersion\x12&\n" +
-	"\x0euploadInsecure\x18\a \x01(\bR\x0euploadInsecure\x12&\n" +
-	"\x0eanonymizeLevel\x18\b \x01(\tR\x0eanonymizeLevel\"}\n" +
+	"\x0euploadInsecure\x18\a \x01(\bR\x0euploadInsecure\"}\n" +
 	"\x13DebugBundleResponse\x12\x12\n" +
 	"\x04path\x18\x01 \x01(\tR\x04path\x12 \n" +
 	"\vuploadedKey\x18\x02 \x01(\tR\vuploadedKey\x120\n" +

client/proto/daemon.proto

@@ -540,11 +540,6 @@ message DebugBundleRequest {
   // untrusted TLS certificate. Restricted to privileged callers; for
   // self-hosted upload servers.
   bool uploadInsecure = 7;
-  // anonymizeLevel selects how much the anonymizer redacts: "default"
-  // (or empty) keeps internal IP ranges, "strict" also anonymizes them.
-  // Unknown values are treated as "strict". Only meaningful with anonymize;
-  // "strict" implies it.
-  string anonymizeLevel = 8;
 }
 
 message DebugBundleResponse {

client/server/debug.go

@@ -16,7 +16,6 @@ import (
 	"google.golang.org/grpc/codes"
 	gstatus "google.golang.org/grpc/status"
 
-	"github.com/netbirdio/netbird/client/anonymize"
 	"github.com/netbirdio/netbird/client/internal/debug"
 	"github.com/netbirdio/netbird/client/internal/ipcauth"
 	"github.com/netbirdio/netbird/client/proto"
@@ -123,7 +122,6 @@ func (s *Server) generateDebugBundle(req *proto.DebugBundleRequest, uiOpener deb
 		},
 		debug.BundleConfig{
 			Anonymize:         req.GetAnonymize(),
-			AnonymizeLevel:    anonymize.ParseLevel(req.GetAnonymizeLevel()),
 			IncludeSystemInfo: req.GetSystemInfo(),
 			LogFileCount:      req.GetLogFileCount(),
 		},

client/status/status.go

@@ -46,10 +46,7 @@ func ParseDaemonStatus(s string) DaemonStatus {
 
 // ConvertOptions holds parameters for ConvertToStatusOutputOverview.
 type ConvertOptions struct {
-	Anonymize bool
-	// AnonymizeLevel selects how much the anonymizer redacts. Only
-	// meaningful when Anonymize is set.
-	AnonymizeLevel       anonymize.Level
+	Anonymize            bool
 	DaemonVersion        string
 	DaemonStatus         DaemonStatus
 	StatusFilter         string
@@ -220,7 +217,6 @@ func ConvertToStatusOutputOverview(pbFullStatus *proto.FullStatus, opts ConvertO
 
 	if opts.Anonymize {
 		anonymizer := anonymize.NewAnonymizer(anonymize.DefaultAddresses())
-		anonymizer.SetLevel(opts.AnonymizeLevel)
 		anonymizeOverview(anonymizer, &overview)
 	}
 
@@ -980,7 +976,6 @@ func timeAgo(t time.Time) string {
 
 func anonymizePeerDetail(a *anonymize.Anonymizer, peer *PeerStateDetailOutput) {
 	peer.FQDN = a.AnonymizeDomain(peer.FQDN)
-	peer.PubKey = a.AnonymizeWGKey(peer.PubKey)
 	if localIP, port, err := net.SplitHostPort(peer.IceCandidateEndpoint.Local); err == nil {
 		peer.IceCandidateEndpoint.Local = fmt.Sprintf("%s:%s", a.AnonymizeIPString(localIP), port)
 	}
@@ -1012,7 +1007,6 @@ func anonymizeOverview(a *anonymize.Anonymizer, overview *OutputOverview) {
 	overview.SignalState.URL = a.AnonymizeURI(overview.SignalState.URL)
 	overview.SignalState.Error = a.AnonymizeString(overview.SignalState.Error)
 
-	overview.PubKey = a.AnonymizeWGKey(overview.PubKey)
 	overview.IP = a.AnonymizeIPString(overview.IP)
 	overview.IPv6 = a.AnonymizeIPString(overview.IPv6)
 	for i, detail := range overview.Relays.Details {

client/ui/frontend/src/contexts/DebugBundleContext.tsx

@@ -71,12 +71,10 @@ type BundleOptions = {
     hasWindow: boolean;
     totalSec: number;
     uploadUrl: string;
-    anonymizeLevel: AnonymizeLevel;
+    anonymize: boolean;
     systemInfo: boolean;
 };
 
-export type AnonymizeLevel = "none" | "default" | "strict";
-
 const startCaptureBestEffort = async (totalSec: number, pcap: CaptureState) => {
     try {
         // Mirror the CLI's safety margin: window + 30s, server caps at 10m.
@@ -189,10 +187,7 @@ const runBundleFlow = async (
 
     if (opts.uploadUrl) setStage({ kind: "uploading" });
     const result = await DebugSvc.Bundle({
-        anonymize: opts.anonymizeLevel !== "none",
-        // The daemon only knows "default" and "strict"; "none" is expressed
-        // through the anonymize flag being off.
-        anonymizeLevel: opts.anonymizeLevel === "strict" ? "strict" : "default",
+        anonymize: opts.anonymize,
         systemInfo: opts.systemInfo,
         uploadUrl: opts.uploadUrl,
         logFileCount,
@@ -203,7 +198,7 @@ const runBundleFlow = async (
 };
 
 const useDebugBundle = () => {
-    const [anonymizeLevel, setAnonymizeLevel] = useState<AnonymizeLevel>("none");
+    const [anonymize, setAnonymize] = useState(false);
     const [systemInfo, setSystemInfo] = useState(true);
     const [upload, setUpload] = useState(true);
     const [trace, setTrace] = useState(true);
@@ -245,7 +240,7 @@ const useDebugBundle = () => {
             hasWindow: capture && totalSec > 0,
             totalSec,
             uploadUrl: upload ? NETBIRD_UPLOAD_URL : "",
-            anonymizeLevel,
+            anonymize,
             systemInfo,
         };
 
@@ -277,8 +272,8 @@ const useDebugBundle = () => {
     };
 
     return {
-        anonymizeLevel,
-        setAnonymizeLevel,
+        anonymize,
+        setAnonymize,
         systemInfo,
         setSystemInfo,
         upload,

client/ui/frontend/src/modules/settings/SettingsTroubleshooting.tsx

@@ -1,6 +1,6 @@
 import { useId, type ReactNode } from "react";
 import { Trans, useTranslation } from "react-i18next";
-import { ChevronDown, CircleCheckBig, FolderOpen, Info, Loader2 } from "lucide-react";
+import { CircleCheckBig, FolderOpen, Loader2 } from "lucide-react";
 import { Browser } from "@wailsio/runtime";
 import { Debug as DebugSvc } from "@bindings/services";
 import type { DebugBundleResult } from "@bindings/services/models.js";
@@ -8,22 +8,13 @@ import { Button } from "@/components/buttons/Button";
 import { DialogActions } from "@/components/dialog/DialogActions";
 import { DialogDescription } from "@/components/dialog/DialogDescription";
 import { DialogHeading } from "@/components/dialog/DialogHeading";
-import {
-    DropdownMenu,
-    DropdownMenuContent,
-    DropdownMenuRadioGroup,
-    DropdownMenuRadioItem,
-    DropdownMenuTrigger,
-} from "@/components/DropdownMenu";
 import FancyToggleSwitch from "@/components/switches/FancyToggleSwitch";
 import HelpText from "@/components/typography/HelpText.tsx";
 import { Input } from "@/components/inputs/Input";
 import { Label } from "@/components/typography/Label";
 import { SquareIcon } from "@/components/SquareIcon";
-import { Tooltip } from "@/components/Tooltip";
-import { cn } from "@/lib/cn";
 import { formatRemaining } from "@/lib/formatters";
-import type { AnonymizeLevel, DebugStage } from "@/contexts/DebugBundleContext";
+import type { DebugStage } from "@/contexts/DebugBundleContext";
 import { useDebugBundleContext } from "@/contexts/DebugBundleContext";
 import { SectionGroup, SettingsBottomBar } from "@/modules/settings/SettingsSection.tsx";
 
@@ -33,8 +24,8 @@ export function SettingsTroubleshooting() {
     const { t } = useTranslation();
     const durationId = useId();
     const {
-        anonymizeLevel,
-        setAnonymizeLevel,
+        anonymize,
+        setAnonymize,
         systemInfo,
         setSystemInfo,
         upload,
@@ -64,71 +55,12 @@ export function SettingsTroubleshooting() {
 
     return (
         <SectionGroup title={t("settings.troubleshooting.section.title")}>
-            <div className={"flex items-center justify-between gap-6"}>
-                <div className={"max-w-md flex-1"}>
-                    <Label as={"div"}>
-                        <span className={"inline-flex items-center gap-1.5"}>
-                            {t("settings.troubleshooting.anonymize.label")}
-                            <Tooltip
-                                content={
-                                    <div className={"max-w-xs whitespace-normal leading-relaxed"}>
-                                        {t("settings.troubleshooting.anonymize.info")}
-                                    </div>
-                                }
-                            >
-                                <Info
-                                    size={14}
-                                    aria-label={t("settings.troubleshooting.anonymize.label")}
-                                    className={"shrink-0 cursor-default text-nb-gray-400"}
-                                />
-                            </Tooltip>
-                        </span>
-                    </Label>
-                    <HelpText margin={false}>
-                        {t("settings.troubleshooting.anonymize.help")}
-                    </HelpText>
-                </div>
-                <div className={"shrink-0"}>
-                    <DropdownMenu>
-                        <DropdownMenuTrigger asChild>
-                            <button
-                                type={"button"}
-                                aria-label={t("settings.troubleshooting.anonymize.label")}
-                                className={cn(
-                                    "inline-flex h-[40px] min-w-[160px] items-center justify-between gap-2 px-3",
-                                    "rounded-md border bg-white dark:bg-nb-gray-900",
-                                    "border-neutral-200 dark:border-nb-gray-700",
-                                    "cursor-default text-xs font-semibold text-nb-gray-100 outline-none",
-                                    "hover:border-nb-gray-600 data-[state=open]:border-nb-gray-600",
-                                )}
-                            >
-                                {t(`settings.troubleshooting.anonymize.${anonymizeLevel}`)}
-                                <ChevronDown
-                                    size={16}
-                                    aria-hidden={"true"}
-                                    className={"shrink-0 text-nb-gray-200"}
-                                />
-                            </button>
-                        </DropdownMenuTrigger>
-                        <DropdownMenuContent align={"end"} className={"min-w-[160px]"}>
-                            <DropdownMenuRadioGroup
-                                value={anonymizeLevel}
-                                onValueChange={(v) => setAnonymizeLevel(v as AnonymizeLevel)}
-                            >
-                                <DropdownMenuRadioItem value={"none"}>
-                                    {t("settings.troubleshooting.anonymize.none")}
-                                </DropdownMenuRadioItem>
-                                <DropdownMenuRadioItem value={"default"}>
-                                    {t("settings.troubleshooting.anonymize.default")}
-                                </DropdownMenuRadioItem>
-                                <DropdownMenuRadioItem value={"strict"}>
-                                    {t("settings.troubleshooting.anonymize.strict")}
-                                </DropdownMenuRadioItem>
-                            </DropdownMenuRadioGroup>
-                        </DropdownMenuContent>
-                    </DropdownMenu>
-                </div>
-            </div>
+            <FancyToggleSwitch
+                value={anonymize}
+                onChange={setAnonymize}
+                label={t("settings.troubleshooting.anonymize.label")}
+                helpText={t("settings.troubleshooting.anonymize.help")}
+            />
             <FancyToggleSwitch
                 value={systemInfo}
                 onChange={setSystemInfo}

client/ui/i18n/locales/en/common.json

@@ -1005,27 +1005,11 @@
     },
     "settings.troubleshooting.anonymize.label": {
         "message": "Anonymize Sensitive Information",
-        "description": "Label for the anonymization level dropdown (None, Default, Strict)."
+        "description": "Toggle label: anonymize sensitive information in the bundle."
     },
     "settings.troubleshooting.anonymize.help": {
-        "message": "Hides IP addresses, domains, and other sensitive values.",
-        "description": "Helper text under the anonymization dropdown. The level details live in the info tooltip."
-    },
-    "settings.troubleshooting.anonymize.info": {
-        "message": "Default keeps internal IPv4 addresses and peer names readable for support. Strict additionally anonymizes private (RFC 1918), CGNAT, and link-local IP addresses, peer names, and WireGuard public keys. Recurring values map to the same placeholder, so peers stay distinguishable. Use Strict when sharing the bundle outside your organization.",
-        "description": "Info tooltip explaining the anonymization levels. 'RFC 1918', 'CGNAT', 'link-local', and 'WireGuard' are technical terms — keep them."
-    },
-    "settings.troubleshooting.anonymize.none": {
-        "message": "None",
-        "description": "Dropdown option: no anonymization."
-    },
-    "settings.troubleshooting.anonymize.default": {
-        "message": "Default",
-        "description": "Dropdown option: default anonymization level."
-    },
-    "settings.troubleshooting.anonymize.strict": {
-        "message": "Strict",
-        "description": "Dropdown option: strict anonymization level."
+        "message": "Hides public IP addresses and non-NetBird domains from logs.",
+        "description": "Helper text for anonymizing logs (hides public IPs and non-NetBird domains)."
     },
     "settings.troubleshooting.systemInfo.label": {
         "message": "Include System Information",

client/ui/services/debug.go

@@ -15,13 +15,10 @@ import (
 )
 
 type DebugBundleParams struct {
-	Anonymize bool `json:"anonymize"`
-	// AnonymizeLevel is "default" or "strict"; strict also anonymizes
-	// private IP ranges, peer names, and WireGuard public keys.
-	AnonymizeLevel string `json:"anonymizeLevel"`
-	SystemInfo     bool   `json:"systemInfo"`
-	UploadURL      string `json:"uploadUrl"`
-	LogFileCount   uint32 `json:"logFileCount"`
+	Anonymize    bool   `json:"anonymize"`
+	SystemInfo   bool   `json:"systemInfo"`
+	UploadURL    string `json:"uploadUrl"`
+	LogFileCount uint32 `json:"logFileCount"`
 }
 
 // DebugBundleResult: Path is set for local-only bundles, UploadedKey on upload
@@ -51,12 +48,11 @@ func (s *Debug) Bundle(ctx context.Context, p DebugBundleParams) (DebugBundleRes
 		return DebugBundleResult{}, err
 	}
 	resp, err := cli.DebugBundle(ctx, &proto.DebugBundleRequest{
-		Anonymize:      p.Anonymize,
-		AnonymizeLevel: p.AnonymizeLevel,
-		SystemInfo:     p.SystemInfo,
-		UploadURL:      p.UploadURL,
-		LogFileCount:   p.LogFileCount,
-		CliVersion:     version.NetbirdVersion(),
+		Anonymize:    p.Anonymize,
+		SystemInfo:   p.SystemInfo,
+		UploadURL:    p.UploadURL,
+		LogFileCount: p.LogFileCount,
+		CliVersion:   version.NetbirdVersion(),
 	})
 	if err != nil {
 		return DebugBundleResult{}, err

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,90 @@ 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+
+  case "$1" in
+    0.*|127.*|169.254.*|22[4-9].*|2[34][0-9].*|25[0-5].*) 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, 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
+
+  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 < <(docker network inspect --format '{{.Name}}|{{range .IPAM.Config}}{{.Subnet}} {{end}}' $(docker network ls -q 2>/dev/null) 2>/dev/null || true)
+  return 0
+}
+
 check_nb_domain() {
   local domain="$1"
   if [[ -z "$domain" ]]; then
@@ -224,6 +311,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)."
@@ -272,6 +362,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
@@ -333,7 +424,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}
@@ -416,6 +512,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"
@@ -659,8 +758,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,14 @@ 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
+  local re='^[A-Za-z0-9]([A-Za-z0-9.-]*[A-Za-z0-9])?$'
+  if [[ "$DOMAIN" != "use-ip" ]] && [[ ! "$DOMAIN" =~ $re ]]; then
+    echo "The NETBIRD_DOMAIN may only contain letters, digits, dots, and hyphens." > /dev/stderr
+    return 1
+  fi
   return 0
 }
 
@@ -337,6 +345,103 @@ 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+
+  case "$1" in
+    0.*|127.*|169.254.*|22[4-9].*|2[34][0-9].*|25[0-5].*) 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, 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
+
+  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 < <(docker network inspect --format '{{.Name}}|{{range .IPAM.Config}}{{.Subnet}} {{end}}' $(docker network ls -q 2>/dev/null) 2>/dev/null || true)
+  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;
+  # normalization matches compose-go's NormalizeProjectName
+  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
 ############################################
@@ -368,7 +473,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
@@ -663,8 +772,10 @@ init_environment() {
   check_docker_sock_perms
 
   initialize_default_values
+  apply_docker_subnet_override
   configure_domain
   configure_reverse_proxy
+  configure_docker_subnet
 
   check_jq
 
@@ -686,6 +797,7 @@ render_docker_compose_traefik_builtin() {
   local crowdsec_volumes=""
   local traefik_file_provider=""
   local traefik_dynamic_volume=""
+
   if [[ "$ENABLE_PROXY" == "true" ]]; then
     traefik_file_provider='      - "--providers.file.filename=/etc/traefik/dynamic.yaml"'
     traefik_dynamic_volume="      - ./traefik-dynamic.yaml:/etc/traefik/dynamic.yaml:ro"
@@ -884,8 +996,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
 }

shared/management/proto/management.proto

@@ -110,10 +110,6 @@ message BundleParameters {
   int64  bundle_for_time  = 2;
   int32  log_file_count   = 3;
   bool   anonymize        = 4;
-  // anonymize_level selects how much the anonymizer redacts: "default"
-  // (or empty) keeps internal IP ranges, "strict" also anonymizes them.
-  // Unknown values are treated as "strict".
-  string anonymize_level  = 5;
 }
 
 message BundleResult {