HansenITSolutions/ExploreDNS
4
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

feat: DNS host selection - system resolver, --dns-upstream flag, root hints

Browse Source 
- Replace hardcoded 127.0.0.1:53 in systemResolver() with actual system
  DNS from /etc/resolv.conf (falls back to 127.0.0.1:53 if unavailable)
- Add Resolver field to RootDiscoveryConfig so callers can override the
  upstream resolver used during root server discovery
- Add --dns-upstream flag (e.g. --dns-upstream 8.8.8.8:53) to exploredns
  CLI and DNSUpstream field to Config
- Add internal/dns/hints.go with all 13 IANA root server IPv4/IPv6
  addresses as embedded constants (RootHints []RootServer)
- Update tests: fix real_exchange_test.go call site; add hints_test.go
  covering RootHints correctness and resolver helper functions

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: multica-agent <github@multica.ai>
This commit is contained in:
Gary Hansen
2026-06-08 13:10:22 +10:00
co-authored by Copilot multica-agent
parent 93959c9f11
commit 87898d5eb3
6 changed files with 290 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/dns/roots.go
+38 -21
View File
@@ -26,7 +26,13 @@ func (rs *RootServer) AllIPs(includeAAAA bool) []net.IP {
}
type RootDiscoveryConfig struct {
Server string
// Server overrides which root server to use as the traversal starting point.
// When empty, a root server is discovered via the upstream resolver.
Server string
// Resolver is the upstream DNS resolver used to resolve root server names.
// When empty, the system resolver from /etc/resolv.conf is used.
// Format: "host:port" (e.g. "8.8.8.8:53" or "1.1.1.1:53").
Resolver string
AllRoots bool
IncludeAAAA bool
}
@@ -43,20 +49,20 @@ func DiscoverRoots(ctx context.Context, cfg *RootDiscoveryConfig) ([]RootServer,
cfg = DefaultRootDiscoveryConfig()
}
resolver := resolverFromConfig(cfg)
if cfg.Server != "" {
return discoverRootOverride(ctx, cfg.Server, cfg.IncludeAAAA)
return discoverRootOverride(ctx, resolver, cfg.Server, cfg.IncludeAAAA)
}
if cfg.AllRoots {
return discoverAllRoots(ctx, cfg.IncludeAAAA)
return discoverAllRoots(ctx, resolver, cfg.IncludeAAAA)
}
return discoverSingleRoot(ctx, cfg.IncludeAAAA)
return discoverSingleRoot(ctx, resolver, cfg.IncludeAAAA)
}
func discoverRootOverride(ctx context.Context, server string, includeAAAA bool) ([]RootServer, error) {
resolver := systemResolver()
func discoverRootOverride(ctx context.Context, resolver, server string, includeAAAA bool) ([]RootServer, error) {
nsMsg, err := queryResolver(ctx, resolver, ".", dns.TypeNS)
if err != nil {
return nil, fmt.Errorf("query root NS records: %w", err)
@@ -70,16 +76,14 @@ func discoverRootOverride(ctx context.Context, server string, includeAAAA bool)
normalized := normalizeServerName(server)
for _, name := range nsSet {
if normalizeServerName(name) == normalized {
return resolveRootServer(ctx, name, includeAAAA)
return resolveRootServer(ctx, resolver, name, includeAAAA)
}
}
return resolveRootServer(ctx, server, includeAAAA)
return resolveRootServer(ctx, resolver, server, includeAAAA)
}
func discoverSingleRoot(ctx context.Context, includeAAAA bool) ([]RootServer, error) {
resolver := systemResolver()
func discoverSingleRoot(ctx context.Context, resolver string, includeAAAA bool) ([]RootServer, error) {
nsMsg, err := queryResolver(ctx, resolver, ".", dns.TypeNS)
if err != nil {
return nil, fmt.Errorf("query root NS records: %w", err)
@@ -95,12 +99,10 @@ func discoverSingleRoot(ctx context.Context, includeAAAA bool) ([]RootServer, er
}
pick := nsSet[0]
return resolveRootServer(ctx, pick, includeAAAA)
return resolveRootServer(ctx, resolver, pick, includeAAAA)
}
func discoverAllRoots(ctx context.Context, includeAAAA bool) ([]RootServer, error) {
resolver := systemResolver()
func discoverAllRoots(ctx context.Context, resolver string, includeAAAA bool) ([]RootServer, error) {
nsMsg, err := queryResolver(ctx, resolver, ".", dns.TypeNS)
if err != nil {
return nil, fmt.Errorf("query root NS records: %w", err)
@@ -117,7 +119,7 @@ func discoverAllRoots(ctx context.Context, includeAAAA bool) ([]RootServer, erro
var servers []RootServer
for _, name := range nsSet {
resolved, err := resolveRootServer(ctx, name, includeAAAA)
resolved, err := resolveRootServer(ctx, resolver, name, includeAAAA)
if err != nil {
servers = append(servers, RootServer{Name: name})
continue
@@ -132,9 +134,7 @@ func discoverAllRoots(ctx context.Context, includeAAAA bool) ([]RootServer, erro
return servers, nil
}
func resolveRootServer(ctx context.Context, name string, includeAAAA bool) ([]RootServer, error) {
resolver := systemResolver()
func resolveRootServer(ctx context.Context, resolver, name string, includeAAAA bool) ([]RootServer, error) {
var ipv4 []net.IP
aMsg, err := queryResolver(ctx, resolver, name, dns.TypeA)
if err == nil {
@@ -156,8 +156,25 @@ func resolveRootServer(ctx context.Context, name string, includeAAAA bool) ([]Ro
return []RootServer{{Name: name, IPv4: ipv4, IPv6: ipv6}}, nil
}
// resolverFromConfig returns the upstream DNS resolver address to use.
// If cfg.Resolver is set, it is used directly. Otherwise the system resolver
// is read from /etc/resolv.conf. Falls back to 127.0.0.1:53 if neither is available.
func resolverFromConfig(cfg *RootDiscoveryConfig) string {
if cfg != nil && cfg.Resolver != "" {
return cfg.Resolver
}
return systemResolver()
}
// systemResolver returns the first nameserver from the system DNS configuration.
// On Unix-like systems this reads /etc/resolv.conf. Falls back to 127.0.0.1:53
// when the system configuration is unavailable or contains no servers.
func systemResolver() string {
return "127.0.0.1:53"
cc, err := dns.ClientConfigFromFile("/etc/resolv.conf")
if err != nil || len(cc.Servers) == 0 {
return "127.0.0.1:53"
}
return net.JoinHostPort(cc.Servers[0], cc.Port)
}
func queryResolver(ctx context.Context, resolverAddr, name string, qtype uint16) (*dns.Msg, error) {