Local DNS Server for client.

Author: masterking32

client_config.toml.simple

@@ -13,6 +13,12 @@ PROTOCOL_TYPE = "SOCKS5"
 # Must match server DOMAIN values.
 DOMAINS = ["v.domain.com"]
 
+LOCAL_DNS_ENABLED = false
+LOCAL_DNS_IP = "127.0.0.1"
+LOCAL_DNS_PORT = 5353
+LOCAL_DNS_WORKERS = 2
+LOCAL_DNS_QUEUE_SIZE = 512
+
 # Resolver balancing strategy:
 # 0=Round Robin (default), 1=Random, 2=Round Robin, 3=Least Loss, 4=Lowest Latency
 RESOLVER_BALANCING_STRATEGY = 0

cmd/client/main.go

@@ -8,8 +8,11 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"os"
+	"os/signal"
+	"syscall"
 
 	"masterdnsvpn-go/internal/client"
 )
@@ -41,6 +44,12 @@ func main() {
 		"📡 <green>Loaded Resolvers</green> <magenta>|</magenta> <magenta>%d</magenta> <blue>endpoints</blue>",
 		len(cfg.Resolvers),
 	)
+	log.Infof(
+		"🧭 <green>Local DNS Listener</green> <magenta>|</magenta> <blue>Enabled</blue>: <yellow>%t</yellow> <magenta>|</magenta> <blue>Addr</blue>: <cyan>%s:%d</cyan>",
+		cfg.LocalDNSEnabled,
+		cfg.LocalDNSIP,
+		cfg.LocalDNSPort,
+	)
 	log.Infof(
 		"🗂️ <green>Connection Catalog</green> <magenta>|</magenta> <magenta>%d</magenta> <blue>domain-resolver pairs</blue>",
 		len(app.Connections()),
@@ -72,4 +81,16 @@ func main() {
 		app.SessionCookie(),
 	)
 	log.Infof("🎯 <green>Client Bootstrap Ready</green>")
+
+	if !cfg.LocalDNSEnabled {
+		return
+	}
+
+	runCtx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	if err := app.RunLocalDNSListener(runCtx); err != nil {
+		_, _ = fmt.Fprintf(os.Stderr, "Local DNS listener failed: %v\n", err)
+		os.Exit(1)
+	}
 }

internal/client/client_test.go

@@ -218,3 +218,20 @@ func TestApplySessionCompressionPolicyKeepsLargeMTUDirections(t *testing.T) {
 		t.Fatalf("download compression should stay off, got=%d", c.downloadCompression)
 	}
 }
+
+func TestNewKeepsLocalDNSDefaults(t *testing.T) {
+	c := New(config.ClientConfig{
+		LocalDNSEnabled:   true,
+		LocalDNSIP:        "127.0.0.1",
+		LocalDNSPort:      5353,
+		LocalDNSWorkers:   2,
+		LocalDNSQueueSize: 512,
+	}, nil, nil)
+
+	if !c.cfg.LocalDNSEnabled {
+		t.Fatal("expected local dns listener to stay enabled in config")
+	}
+	if c.cfg.LocalDNSIP != "127.0.0.1" || c.cfg.LocalDNSPort != 5353 {
+		t.Fatalf("unexpected local dns bind config: %s:%d", c.cfg.LocalDNSIP, c.cfg.LocalDNSPort)
+	}
+}

internal/client/local_dns.go

@@ -0,0 +1,104 @@
+// ==============================================================================
+// MasterDnsVPN
+// Author: MasterkinG32
+// Github: https://github.com/masterking32
+// Year: 2026
+// ==============================================================================
+
+package client
+
+import (
+	"context"
+	"net"
+	"sync"
+
+	DnsParser "masterdnsvpn-go/internal/dnsparser"
+)
+
+type localDNSRequest struct {
+	packet []byte
+	addr   *net.UDPAddr
+}
+
+func (c *Client) RunLocalDNSListener(ctx context.Context) error {
+	if c == nil || !c.cfg.LocalDNSEnabled {
+		return nil
+	}
+
+	conn, err := net.ListenUDP("udp", &net.UDPAddr{
+		IP:   net.ParseIP(c.cfg.LocalDNSIP),
+		Port: c.cfg.LocalDNSPort,
+	})
+	if err != nil {
+		return err
+	}
+	defer conn.Close()
+
+	c.log.Infof(
+		"📡 <green>Local DNS Listener Ready</green> <magenta>|</magenta> <blue>Addr</blue>: <cyan>%s:%d</cyan> <magenta>|</magenta> <blue>Workers</blue>: <magenta>%d</magenta>",
+		c.cfg.LocalDNSIP,
+		c.cfg.LocalDNSPort,
+		c.cfg.LocalDNSWorkers,
+	)
+
+	queue := make(chan localDNSRequest, c.cfg.LocalDNSQueueSize)
+	var workerWG sync.WaitGroup
+	for range c.cfg.LocalDNSWorkers {
+		workerWG.Add(1)
+		go func() {
+			defer workerWG.Done()
+			c.localDNSWorker(ctx, conn, queue)
+		}()
+	}
+
+	go func() {
+		<-ctx.Done()
+		_ = conn.Close()
+	}()
+
+	buffer := make([]byte, EDnsSafeUDPSize)
+	for {
+		n, addr, err := conn.ReadFromUDP(buffer)
+		if err != nil {
+			if ctx.Err() != nil {
+				break
+			}
+			return err
+		}
+
+		packet := append([]byte(nil), buffer[:n]...)
+		select {
+		case queue <- localDNSRequest{packet: packet, addr: addr}:
+		case <-ctx.Done():
+			close(queue)
+			workerWG.Wait()
+			return nil
+		default:
+			response, responseErr := DnsParser.BuildRefusedResponse(packet)
+			if responseErr == nil {
+				_, _ = conn.WriteToUDP(response, addr)
+			}
+		}
+	}
+
+	close(queue)
+	workerWG.Wait()
+	return nil
+}
+
+func (c *Client) localDNSWorker(ctx context.Context, conn *net.UDPConn, queue <-chan localDNSRequest) {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case req, ok := <-queue:
+			if !ok {
+				return
+			}
+			response, err := DnsParser.BuildRefusedResponse(req.packet)
+			if err == nil {
+				_, _ = conn.WriteToUDP(response, req.addr)
+			}
+		}
+	}
+}

internal/config/client.go

@@ -24,6 +24,11 @@ type ClientConfig struct {
 	ConfigPath                string            `toml:"-"`
 	ProtocolType              string            `toml:"PROTOCOL_TYPE"`
 	Domains                   []string          `toml:"DOMAINS"`
+	LocalDNSEnabled           bool              `toml:"LOCAL_DNS_ENABLED"`
+	LocalDNSIP                string            `toml:"LOCAL_DNS_IP"`
+	LocalDNSPort              int               `toml:"LOCAL_DNS_PORT"`
+	LocalDNSWorkers           int               `toml:"LOCAL_DNS_WORKERS"`
+	LocalDNSQueueSize         int               `toml:"LOCAL_DNS_QUEUE_SIZE"`
 	ResolverBalancingStrategy int               `toml:"RESOLVER_BALANCING_STRATEGY"`
 	BaseEncodeData            bool              `toml:"BASE_ENCODE_DATA"`
 	UploadCompressionType     int               `toml:"UPLOAD_COMPRESSION_TYPE"`
@@ -47,6 +52,11 @@ func defaultClientConfig() ClientConfig {
 	return ClientConfig{
 		ProtocolType:              "SOCKS5",
 		Domains:                   nil,
+		LocalDNSEnabled:           false,
+		LocalDNSIP:                "127.0.0.1",
+		LocalDNSPort:              5353,
+		LocalDNSWorkers:           2,
+		LocalDNSQueueSize:         512,
 		ResolverBalancingStrategy: 0,
 		BaseEncodeData:            false,
 		UploadCompressionType:     compression.TypeOff,
@@ -99,6 +109,19 @@ func LoadClientConfig(filename string) (ClientConfig, error) {
 	if cfg.DataEncryptionMethod < 0 || cfg.DataEncryptionMethod > 5 {
 		return cfg, fmt.Errorf("invalid DATA_ENCRYPTION_METHOD: %d", cfg.DataEncryptionMethod)
 	}
+	cfg.LocalDNSIP = strings.TrimSpace(cfg.LocalDNSIP)
+	if cfg.LocalDNSIP == "" {
+		cfg.LocalDNSIP = "127.0.0.1"
+	}
+	if cfg.LocalDNSPort < 0 || cfg.LocalDNSPort > 65535 {
+		return cfg, fmt.Errorf("invalid LOCAL_DNS_PORT: %d", cfg.LocalDNSPort)
+	}
+	if cfg.LocalDNSWorkers < 1 {
+		cfg.LocalDNSWorkers = 1
+	}
+	if cfg.LocalDNSQueueSize < 1 {
+		cfg.LocalDNSQueueSize = 512
+	}
 	if cfg.UploadCompressionType < compression.TypeOff || cfg.UploadCompressionType > compression.TypeZLIB {
 		return cfg, fmt.Errorf("invalid UPLOAD_COMPRESSION_TYPE: %d", cfg.UploadCompressionType)
 	}