Add back release and binaries

Former-commit-id: a21a8e90fa

.env.example

@@ -1,5 +1,5 @@
 # Copy this file to .env and fill in your values
 # Required for connecting to Pangolin service
-PANGOLIN_ENDPOINT=https://app.pangolin.net
+PANGOLIN_ENDPOINT=https://example.com
 NEWT_ID=changeme-id
 NEWT_SECRET=changeme-secret

.github/CODEOWNERS

@@ -1 +0,0 @@
-* @oschwartz10612 @miloschwartz

.github/workflows/mirror.yaml

@@ -23,7 +23,7 @@ jobs:
           skopeo --version
 
       - name: Install cosign
-        uses: sigstore/cosign-installer@cad07c2e89fa2edd6e2d7bab4c1aa38e53f76003 # v4.1.1
+        uses: sigstore/cosign-installer@faadad0cce49287aee09b3a48701e75088a2c6ad # v4.0.0
 
       - name: Input check
         run: |

.github/workflows/nix-build.yml

@@ -1,23 +0,0 @@
-name: Build Nix package
-
-on:
-  workflow_dispatch:
-  pull_request:
-    paths:
-      - go.mod
-      - go.sum
-
-jobs:
-  nix-build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@main
-
-      - name: Build flake package
-        run: |
-          nix build .#pangolin-newt -L

.github/workflows/nix-dependabot-update-hash.yml

@@ -1,48 +0,0 @@
-name: Update Nix Package Hash On Dependabot PRs
-
-on:
-  pull_request:
-    types: [opened, synchronize]
-    branches:
-      - main
-
-jobs:
-  nix-update:
-    if: github.actor == 'dependabot[bot]'
-    runs-on: ubuntu-latest
-
-    permissions:
-      contents: write
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-        with:
-          ref: ${{ github.head_ref }}
-          token: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Install Nix
-        uses: DeterminateSystems/nix-installer-action@main
-
-      - name: Run nix-update
-        run: |
-          nix run nixpkgs#nix-update -- --flake pangolin-newt --no-src --version skip
-
-      - name: Check for changes
-        id: changes
-        run: |
-          if git diff --quiet; then
-            echo "changed=false" >> "$GITHUB_OUTPUT"
-          else
-            echo "changed=true" >> "$GITHUB_OUTPUT"
-          fi
-
-      - name: Commit and push changes
-        if: steps.changes.outputs.changed == 'true'
-        run: |
-          git config user.name "dependabot[bot]"
-          git config user.email "dependabot[bot]@users.noreply.github.com"
-
-          git add .
-          git commit -m "chore(nix): fix hash for updated go dependencies"
-          git push

.github/workflows/stale-bot.yml

@@ -1,37 +0,0 @@
-name: Mark and Close Stale Issues
-
-on:
-  schedule:
-    - cron: '0 0 * * *'
-  workflow_dispatch: # Allow manual trigger
-
-permissions:
-  contents: write # only for delete-branch option
-  issues: write
-  pull-requests: write
-
-jobs:
-  stale:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/stale@b5d41d4e1d5dceea10e7104786b73624c18a190f # v10.2.0
-        with:
-          days-before-stale: 14
-          days-before-close: 14
-          stale-issue-message: 'This issue has been automatically marked as stale due to 14 days of inactivity. It will be closed in 14 days if no further activity occurs.'
-          close-issue-message: 'This issue has been automatically closed due to inactivity. If you believe this is still relevant, please open a new issue with up-to-date information.'
-          stale-issue-label: 'stale'
-          
-          exempt-issue-labels: 'needs investigating, networking, new feature, reverse proxy, bug, api, authentication, documentation, enhancement, help wanted, good first issue, question'
-          
-          exempt-all-issue-assignees: true
-          
-          only-labels: ''
-          exempt-pr-labels: ''
-          days-before-pr-stale: -1
-          days-before-pr-close: -1
-          
-          operations-per-run: 100
-          remove-stale-when-updated: true
-          delete-branch: false
-          enable-statistics: true

.github/workflows/test.yml

@@ -28,10 +28,10 @@ jobs:
           - go-build-release-windows-amd64
     steps:
       - name: Checkout repository
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@08c6903cd8c0fde910a37f88322edcfb5dd907a8 # v5.0.0
 
       - name: Set up Go
-        uses: actions/setup-go@7a3fe6cf4cb3a834922a1244abfce67bcef6a0c5 # v6.2.0
+        uses: actions/setup-go@4dc6199c7b1a012772edbd06daecab0f50c9053c # v6.1.0
         with:
           go-version: 1.25
 

.gitignore

@@ -5,6 +5,4 @@ nohup.out
 *.iml
 certs/
 newt_arm64
-key
-/.direnv/
-/result*
+key

Dockerfile

@@ -1,5 +1,4 @@
-# FROM golang:1.25-alpine AS builder
-FROM public.ecr.aws/docker/library/golang:1.25-alpine AS builder
+FROM golang:1.25-alpine AS builder
 
 # Install git and ca-certificates
 RUN apk --no-cache add ca-certificates git tzdata
@@ -17,10 +16,9 @@ RUN go mod download
 COPY . .
 
 # Build the application
-ARG VERSION=dev
-RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w -X main.newtVersion=${VERSION}" -o /newt
+RUN CGO_ENABLED=0 GOOS=linux go build -ldflags="-s -w" -o /newt
 
-FROM public.ecr.aws/docker/library/alpine:3.23 AS runner
+FROM alpine:3.23 AS runner
 
 RUN apk --no-cache add ca-certificates tzdata iputils
 

Makefile

@@ -2,11 +2,8 @@
 
 all: local
 
-VERSION ?= dev
-LDFLAGS = -X main.newtVersion=$(VERSION)
-
 local:
-	CGO_ENABLED=0 go build -ldflags "$(LDFLAGS)" -o ./bin/newt
+	CGO_ENABLED=0 go build -o ./bin/newt
 
 docker-build:
 	docker build -t fosrl/newt:latest .
@@ -30,44 +27,32 @@ docker-build-release:
         go-build-release-darwin-amd64 go-build-release-windows-amd64 \
         go-build-release-freebsd-amd64 go-build-release-freebsd-arm64
 
-go-build-release: \
-    go-build-release-linux-arm64 \
-    go-build-release-linux-arm32-v7 \
-    go-build-release-linux-arm32-v6 \
-    go-build-release-linux-amd64 \
-    go-build-release-linux-riscv64 \
-    go-build-release-darwin-arm64 \
-    go-build-release-darwin-amd64 \
-    go-build-release-windows-amd64 \
-    go-build-release-freebsd-amd64 \
-    go-build-release-freebsd-arm64
-
 go-build-release-linux-arm64:
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -ldflags "$(LDFLAGS)" -o bin/newt_linux_arm64
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm64 go build -o bin/newt_linux_arm64
 
 go-build-release-linux-arm32-v7:
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -ldflags "$(LDFLAGS)" -o bin/newt_linux_arm32
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=7 go build -o bin/newt_linux_arm32
 
 go-build-release-linux-arm32-v6:
-	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -ldflags "$(LDFLAGS)" -o bin/newt_linux_arm32v6
+	CGO_ENABLED=0 GOOS=linux GOARCH=arm GOARM=6 go build -o bin/newt_linux_arm32v6
 
 go-build-release-linux-amd64:
-	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -ldflags "$(LDFLAGS)" -o bin/newt_linux_amd64
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o bin/newt_linux_amd64
 
 go-build-release-linux-riscv64:
-	CGO_ENABLED=0 GOOS=linux GOARCH=riscv64 go build -ldflags "$(LDFLAGS)" -o bin/newt_linux_riscv64
+	CGO_ENABLED=0 GOOS=linux GOARCH=riscv64 go build -o bin/newt_linux_riscv64
 
 go-build-release-darwin-arm64:
-	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -ldflags "$(LDFLAGS)" -o bin/newt_darwin_arm64
+	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 go build -o bin/newt_darwin_arm64
 
 go-build-release-darwin-amd64:
-	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -ldflags "$(LDFLAGS)" -o bin/newt_darwin_amd64
+	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 go build -o bin/newt_darwin_amd64
 
 go-build-release-windows-amd64:
-	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -ldflags "$(LDFLAGS)" -o bin/newt_windows_amd64.exe
+	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 go build -o bin/newt_windows_amd64.exe
 
 go-build-release-freebsd-amd64:
-	CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -ldflags "$(LDFLAGS)" -o bin/newt_freebsd_amd64
+	CGO_ENABLED=0 GOOS=freebsd GOARCH=amd64 go build -o bin/newt_freebsd_amd64
 
 go-build-release-freebsd-arm64:
-	CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -ldflags "$(LDFLAGS)" -o bin/newt_freebsd_arm64
+	CGO_ENABLED=0 GOOS=freebsd GOARCH=arm64 go build -o bin/newt_freebsd_arm64

authdaemon.go

@@ -1,150 +0,0 @@
-package main
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-
-	"github.com/fosrl/newt/authdaemon"
-	"github.com/fosrl/newt/logger"
-)
-
-const (
-	defaultPrincipalsPath = "/var/run/auth-daemon/principals"
-	defaultCACertPath     = "/etc/ssh/ca.pem"
-)
-
-var (
-	errPresharedKeyRequired = errors.New("auth-daemon-key is required when --auth-daemon is enabled")
-	errRootRequired         = errors.New("auth-daemon must be run as root (use sudo)")
-	authDaemonServer        *authdaemon.Server // Global auth daemon server instance
-)
-
-// startAuthDaemon initializes and starts the auth daemon in the background.
-// It validates requirements (Linux, root, preshared key) and starts the server
-// in a goroutine so it runs alongside normal newt operation.
-func startAuthDaemon(ctx context.Context) error {
-	// Validation
-	if runtime.GOOS != "linux" {
-		return fmt.Errorf("auth-daemon is only supported on Linux, not %s", runtime.GOOS)
-	}
-	if os.Geteuid() != 0 {
-		return errRootRequired
-	}
-
-	// Use defaults if not set
-	principalsFile := authDaemonPrincipalsFile
-	if principalsFile == "" {
-		principalsFile = defaultPrincipalsPath
-	}
-	caCertPath := authDaemonCACertPath
-	if caCertPath == "" {
-		caCertPath = defaultCACertPath
-	}
-
-	// Create auth daemon server
-	cfg := authdaemon.Config{
-		DisableHTTPS:           true,                   // We run without HTTP server in newt
-		PresharedKey:           "this-key-is-not-used", // Not used in embedded mode, but set to non-empty to satisfy validation
-		PrincipalsFilePath:     principalsFile,
-		CACertPath:             caCertPath,
-		Force:                  true,
-		GenerateRandomPassword: authDaemonGenerateRandomPassword,
-	}
-
-	srv, err := authdaemon.NewServer(cfg)
-	if err != nil {
-		return fmt.Errorf("create auth daemon server: %w", err)
-	}
-
-	authDaemonServer = srv
-
-	// Start the auth daemon in a goroutine so it runs alongside newt
-	go func() {
-		logger.Info("Auth daemon starting (native mode, no HTTP server)")
-		if err := srv.Run(ctx); err != nil {
-			logger.Error("Auth daemon error: %v", err)
-		}
-		logger.Info("Auth daemon stopped")
-	}()
-
-	return nil
-}
-
-// runPrincipalsCmd executes the principals subcommand logic
-func runPrincipalsCmd(args []string) {
-	opts := struct {
-		PrincipalsFile string
-		Username       string
-	}{
-		PrincipalsFile: defaultPrincipalsPath,
-	}
-
-	// Parse flags manually
-	for i := 0; i < len(args); i++ {
-		switch args[i] {
-		case "--principals-file":
-			if i+1 >= len(args) {
-				fmt.Fprintf(os.Stderr, "Error: --principals-file requires a value\n")
-				os.Exit(1)
-			}
-			opts.PrincipalsFile = args[i+1]
-			i++
-		case "--username":
-			if i+1 >= len(args) {
-				fmt.Fprintf(os.Stderr, "Error: --username requires a value\n")
-				os.Exit(1)
-			}
-			opts.Username = args[i+1]
-			i++
-		case "--help", "-h":
-			printPrincipalsHelp()
-			os.Exit(0)
-		default:
-			fmt.Fprintf(os.Stderr, "Error: unknown flag: %s\n", args[i])
-			printPrincipalsHelp()
-			os.Exit(1)
-		}
-	}
-
-	// Validation
-	if opts.Username == "" {
-		fmt.Fprintf(os.Stderr, "Error: username is required\n")
-		printPrincipalsHelp()
-		os.Exit(1)
-	}
-
-	// Get principals
-	list, err := authdaemon.GetPrincipals(opts.PrincipalsFile, opts.Username)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error: %v\n", err)
-		os.Exit(1)
-	}
-	if len(list) == 0 {
-		fmt.Println("")
-		return
-	}
-	for _, principal := range list {
-		fmt.Println(principal)
-	}
-}
-
-func printPrincipalsHelp() {
-	fmt.Fprintf(os.Stderr, `Usage: newt principals [flags]
-
-Output principals for a username (for AuthorizedPrincipalsCommand in sshd_config).
-Read the principals file and print principals that match the given username, one per line.
-Configure in sshd_config with AuthorizedPrincipalsCommand and %%u for the username.
-
-Flags:
-  --principals-file string   Path to the principals file (default "%s")
-  --username string          Username to look up (required)
-  --help, -h                 Show this help message
-
-Example:
-  newt principals --username alice
-
-`, defaultPrincipalsPath)
-}

authdaemon/connection.go

@@ -1,27 +0,0 @@
-package authdaemon
-
-import (
-	"github.com/fosrl/newt/logger"
-)
-
-// ProcessConnection runs the same logic as POST /connection: CA cert, user create/reconcile, principals.
-// Use this when DisableHTTPS is true (e.g. embedded in Newt) instead of calling the API.
-func (s *Server) ProcessConnection(req ConnectionRequest) {
-	logger.Info("connection: niceId=%q username=%q metadata.sudoMode=%q metadata.sudoCommands=%v metadata.homedir=%v metadata.groups=%v",
-		req.NiceId, req.Username, req.Metadata.SudoMode, req.Metadata.SudoCommands, req.Metadata.Homedir, req.Metadata.Groups)
-
-	cfg := &s.cfg
-	if cfg.CACertPath != "" {
-		if err := writeCACertIfNotExists(cfg.CACertPath, req.CaCert, cfg.Force); err != nil {
-			logger.Warn("auth-daemon: write CA cert: %v", err)
-		}
-	}
-	if err := ensureUser(req.Username, req.Metadata, s.cfg.GenerateRandomPassword); err != nil {
-		logger.Warn("auth-daemon: ensure user: %v", err)
-	}
-	if cfg.PrincipalsFilePath != "" {
-		if err := writePrincipals(cfg.PrincipalsFilePath, req.Username, req.NiceId); err != nil {
-			logger.Warn("auth-daemon: write principals: %v", err)
-		}
-	}
-}

authdaemon/host_linux.go

@@ -1,396 +0,0 @@
-//go:build linux
-
-package authdaemon
-
-import (
-	"bufio"
-	"crypto/rand"
-	"encoding/hex"
-	"encoding/json"
-	"fmt"
-	"os"
-	"os/exec"
-	"os/user"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/fosrl/newt/logger"
-)
-
-// writeCACertIfNotExists writes contents to path. If the file already exists: when force is false, skip; when force is true, overwrite only if content differs.
-func writeCACertIfNotExists(path, contents string, force bool) error {
-	contents = strings.TrimSpace(contents)
-	if contents != "" && !strings.HasSuffix(contents, "\n") {
-		contents += "\n"
-	}
-	existing, err := os.ReadFile(path)
-	if err == nil {
-		existingStr := strings.TrimSpace(string(existing))
-		if existingStr != "" && !strings.HasSuffix(existingStr, "\n") {
-			existingStr += "\n"
-		}
-		if existingStr == contents {
-			logger.Debug("auth-daemon: CA cert unchanged at %s, skipping write", path)
-			return nil
-		}
-		if !force {
-			logger.Debug("auth-daemon: CA cert already exists at %s, skipping write (Force disabled)", path)
-			return nil
-		}
-	} else if !os.IsNotExist(err) {
-		return fmt.Errorf("read %s: %w", path, err)
-	}
-	dir := filepath.Dir(path)
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		return fmt.Errorf("mkdir %s: %w", dir, err)
-	}
-	if err := os.WriteFile(path, []byte(contents), 0644); err != nil {
-		return fmt.Errorf("write CA cert: %w", err)
-	}
-	logger.Info("auth-daemon: wrote CA cert to %s", path)
-	return nil
-}
-
-// writePrincipals updates the principals file at path: JSON object keyed by username, value is array of principals. Adds username and niceId to that user's list (deduped).
-func writePrincipals(path, username, niceId string) error {
-	if path == "" {
-		return nil
-	}
-	username = strings.TrimSpace(username)
-	niceId = strings.TrimSpace(niceId)
-	if username == "" {
-		return nil
-	}
-	data := make(map[string][]string)
-	if raw, err := os.ReadFile(path); err == nil {
-		_ = json.Unmarshal(raw, &data)
-	}
-	list := data[username]
-	seen := make(map[string]struct{}, len(list)+2)
-	for _, p := range list {
-		seen[p] = struct{}{}
-	}
-	for _, p := range []string{username, niceId} {
-		if p == "" {
-			continue
-		}
-		if _, ok := seen[p]; !ok {
-			seen[p] = struct{}{}
-			list = append(list, p)
-		}
-	}
-	data[username] = list
-	body, err := json.Marshal(data)
-	if err != nil {
-		return fmt.Errorf("marshal principals: %w", err)
-	}
-	dir := filepath.Dir(path)
-	if err := os.MkdirAll(dir, 0755); err != nil {
-		return fmt.Errorf("mkdir %s: %w", dir, err)
-	}
-	if err := os.WriteFile(path, body, 0644); err != nil {
-		return fmt.Errorf("write principals: %w", err)
-	}
-	logger.Debug("auth-daemon: wrote principals to %s", path)
-	return nil
-}
-
-// sudoGroup returns the name of the sudo group (wheel or sudo) that exists on the system. Prefers wheel.
-func sudoGroup() string {
-	f, err := os.Open("/etc/group")
-	if err != nil {
-		return "sudo"
-	}
-	defer f.Close()
-	sc := bufio.NewScanner(f)
-	hasWheel := false
-	hasSudo := false
-	for sc.Scan() {
-		line := sc.Text()
-		if strings.HasPrefix(line, "wheel:") {
-			hasWheel = true
-		}
-		if strings.HasPrefix(line, "sudo:") {
-			hasSudo = true
-		}
-	}
-	if hasWheel {
-		return "wheel"
-	}
-	if hasSudo {
-		return "sudo"
-	}
-	return "sudo"
-}
-
-// setRandomPassword generates a random password and sets it for username via chpasswd.
-// Used when GenerateRandomPassword is true so SSH with PermitEmptyPasswords no can accept the user.
-func setRandomPassword(username string) error {
-	b := make([]byte, 16)
-	if _, err := rand.Read(b); err != nil {
-		return fmt.Errorf("generate password: %w", err)
-	}
-	password := hex.EncodeToString(b)
-	cmd := exec.Command("chpasswd")
-	cmd.Stdin = strings.NewReader(username + ":" + password)
-	if out, err := cmd.CombinedOutput(); err != nil {
-		return fmt.Errorf("chpasswd: %w (output: %s)", err, string(out))
-	}
-	return nil
-}
-
-const skelDir = "/etc/skel"
-
-// copySkelInto copies files from srcDir (e.g. /etc/skel) into dstDir (e.g. user's home).
-// Only creates files that don't already exist. All created paths are chowned to uid:gid.
-func copySkelInto(srcDir, dstDir string, uid, gid int) {
-	entries, err := os.ReadDir(srcDir)
-	if err != nil {
-		if !os.IsNotExist(err) {
-			logger.Warn("auth-daemon: read %s: %v", srcDir, err)
-		}
-		return
-	}
-	for _, e := range entries {
-		name := e.Name()
-		src := filepath.Join(srcDir, name)
-		dst := filepath.Join(dstDir, name)
-		if e.IsDir() {
-			if st, err := os.Stat(dst); err == nil && st.IsDir() {
-				copySkelInto(src, dst, uid, gid)
-				continue
-			}
-			if err := os.MkdirAll(dst, 0755); err != nil {
-				logger.Warn("auth-daemon: mkdir %s: %v", dst, err)
-				continue
-			}
-			if err := os.Chown(dst, uid, gid); err != nil {
-				logger.Warn("auth-daemon: chown %s: %v", dst, err)
-			}
-			copySkelInto(src, dst, uid, gid)
-			continue
-		}
-		if _, err := os.Stat(dst); err == nil {
-			continue
-		}
-		data, err := os.ReadFile(src)
-		if err != nil {
-			logger.Warn("auth-daemon: read %s: %v", src, err)
-			continue
-		}
-		if err := os.WriteFile(dst, data, 0644); err != nil {
-			logger.Warn("auth-daemon: write %s: %v", dst, err)
-			continue
-		}
-		if err := os.Chown(dst, uid, gid); err != nil {
-			logger.Warn("auth-daemon: chown %s: %v", dst, err)
-		}
-	}
-}
-
-// ensureUser creates the system user if missing, or reconciles sudo and homedir to match meta.
-func ensureUser(username string, meta ConnectionMetadata, generateRandomPassword bool) error {
-	if username == "" {
-		return nil
-	}
-	u, err := user.Lookup(username)
-	if err != nil {
-		if _, ok := err.(user.UnknownUserError); !ok {
-			return fmt.Errorf("lookup user %s: %w", username, err)
-		}
-		return createUser(username, meta, generateRandomPassword)
-	}
-	return reconcileUser(u, meta)
-}
-
-// desiredGroups returns the exact list of supplementary groups the user should have:
-// meta.Groups plus the sudo group when meta.SudoMode is "full" (deduped).
-func desiredGroups(meta ConnectionMetadata) []string {
-	seen := make(map[string]struct{})
-	var out []string
-	for _, g := range meta.Groups {
-		g = strings.TrimSpace(g)
-		if g == "" {
-			continue
-		}
-		if _, ok := seen[g]; ok {
-			continue
-		}
-		seen[g] = struct{}{}
-		out = append(out, g)
-	}
-	if meta.SudoMode == "full" {
-		sg := sudoGroup()
-		if _, ok := seen[sg]; !ok {
-			out = append(out, sg)
-		}
-	}
-	return out
-}
-
-// setUserGroups sets the user's supplementary groups to exactly groups (local mirrors metadata).
-// When groups is empty, clears all supplementary groups (usermod -G "").
-func setUserGroups(username string, groups []string) {
-	list := strings.Join(groups, ",")
-	cmd := exec.Command("usermod", "-G", list, username)
-	if out, err := cmd.CombinedOutput(); err != nil {
-		logger.Warn("auth-daemon: usermod -G %s: %v (output: %s)", list, err, string(out))
-	} else {
-		logger.Info("auth-daemon: set %s supplementary groups to %s", username, list)
-	}
-}
-
-func createUser(username string, meta ConnectionMetadata, generateRandomPassword bool) error {
-	args := []string{"-s", "/bin/bash"}
-	if meta.Homedir {
-		args = append(args, "-m")
-	} else {
-		args = append(args, "-M")
-	}
-	args = append(args, username)
-	cmd := exec.Command("useradd", args...)
-	if out, err := cmd.CombinedOutput(); err != nil {
-		return fmt.Errorf("useradd %s: %w (output: %s)", username, err, string(out))
-	}
-	logger.Info("auth-daemon: created user %s (homedir=%v)", username, meta.Homedir)
-	if generateRandomPassword {
-		if err := setRandomPassword(username); err != nil {
-			logger.Warn("auth-daemon: set random password for %s: %v", username, err)
-		} else {
-			logger.Info("auth-daemon: set random password for %s (PermitEmptyPasswords no)", username)
-		}
-	}
-	if meta.Homedir {
-		if u, err := user.Lookup(username); err == nil && u.HomeDir != "" {
-			uid, gid := mustAtoi(u.Uid), mustAtoi(u.Gid)
-			copySkelInto(skelDir, u.HomeDir, uid, gid)
-		}
-	}
-	setUserGroups(username, desiredGroups(meta))
-	switch meta.SudoMode {
-	case "full":
-		if err := configurePasswordlessSudo(username); err != nil {
-			logger.Warn("auth-daemon: configure passwordless sudo for %s: %v", username, err)
-		}
-	case "commands":
-		if len(meta.SudoCommands) > 0 {
-			if err := configureSudoCommands(username, meta.SudoCommands); err != nil {
-				logger.Warn("auth-daemon: configure sudo commands for %s: %v", username, err)
-			}
-		}
-	default:
-		removeSudoers(username)
-	}
-	return nil
-}
-
-const sudoersFilePrefix = "90-pangolin-"
-
-func sudoersPath(username string) string {
-	return filepath.Join("/etc/sudoers.d", sudoersFilePrefix+username)
-}
-
-// writeSudoersFile writes content to the user's sudoers.d file and validates with visudo.
-func writeSudoersFile(username, content string) error {
-	sudoersFile := sudoersPath(username)
-	tmpFile := sudoersFile + ".tmp"
-	if err := os.WriteFile(tmpFile, []byte(content), 0440); err != nil {
-		return fmt.Errorf("write temp sudoers file: %w", err)
-	}
-	cmd := exec.Command("visudo", "-c", "-f", tmpFile)
-	if out, err := cmd.CombinedOutput(); err != nil {
-		os.Remove(tmpFile)
-		return fmt.Errorf("visudo validation failed: %w (output: %s)", err, string(out))
-	}
-	if err := os.Rename(tmpFile, sudoersFile); err != nil {
-		os.Remove(tmpFile)
-		return fmt.Errorf("move sudoers file: %w", err)
-	}
-	return nil
-}
-
-// configurePasswordlessSudo creates a sudoers.d file to allow passwordless sudo for the user.
-func configurePasswordlessSudo(username string) error {
-	content := fmt.Sprintf("# Created by Pangolin auth-daemon\n%s ALL=(ALL) NOPASSWD:ALL\n", username)
-	if err := writeSudoersFile(username, content); err != nil {
-		return err
-	}
-	logger.Info("auth-daemon: configured passwordless sudo for %s", username)
-	return nil
-}
-
-// configureSudoCommands creates a sudoers.d file allowing only the listed commands (NOPASSWD).
-// Each command should be a full path (e.g. /usr/bin/systemctl).
-func configureSudoCommands(username string, commands []string) error {
-	var b strings.Builder
-	b.WriteString("# Created by Pangolin auth-daemon (restricted commands)\n")
-	n := 0
-	for _, c := range commands {
-		c = strings.TrimSpace(c)
-		if c == "" {
-			continue
-		}
-		fmt.Fprintf(&b, "%s ALL=(ALL) NOPASSWD: %s\n", username, c)
-		n++
-	}
-	if n == 0 {
-		return fmt.Errorf("no valid sudo commands")
-	}
-	if err := writeSudoersFile(username, b.String()); err != nil {
-		return err
-	}
-	logger.Info("auth-daemon: configured restricted sudo for %s (%d commands)", username, len(commands))
-	return nil
-}
-
-// removeSudoers removes the sudoers.d file for the user.
-func removeSudoers(username string) {
-	sudoersFile := sudoersPath(username)
-	if err := os.Remove(sudoersFile); err != nil && !os.IsNotExist(err) {
-		logger.Warn("auth-daemon: remove sudoers for %s: %v", username, err)
-	} else if err == nil {
-		logger.Info("auth-daemon: removed sudoers for %s", username)
-	}
-}
-
-func mustAtoi(s string) int {
-	n, _ := strconv.Atoi(s)
-	return n
-}
-
-func reconcileUser(u *user.User, meta ConnectionMetadata) error {
-	setUserGroups(u.Username, desiredGroups(meta))
-	switch meta.SudoMode {
-	case "full":
-		if err := configurePasswordlessSudo(u.Username); err != nil {
-			logger.Warn("auth-daemon: configure passwordless sudo for %s: %v", u.Username, err)
-		}
-	case "commands":
-		if len(meta.SudoCommands) > 0 {
-			if err := configureSudoCommands(u.Username, meta.SudoCommands); err != nil {
-				logger.Warn("auth-daemon: configure sudo commands for %s: %v", u.Username, err)
-			}
-		} else {
-			removeSudoers(u.Username)
-		}
-	default:
-		removeSudoers(u.Username)
-	}
-	if meta.Homedir && u.HomeDir != "" {
-		uid, gid := mustAtoi(u.Uid), mustAtoi(u.Gid)
-		if st, err := os.Stat(u.HomeDir); err != nil || !st.IsDir() {
-			if err := os.MkdirAll(u.HomeDir, 0755); err != nil {
-				logger.Warn("auth-daemon: mkdir %s: %v", u.HomeDir, err)
-			} else {
-				_ = os.Chown(u.HomeDir, uid, gid)
-				copySkelInto(skelDir, u.HomeDir, uid, gid)
-				logger.Info("auth-daemon: created home %s for %s", u.HomeDir, u.Username)
-			}
-		} else {
-			// Ensure .bashrc etc. exist (e.g. home existed but was empty or skel was minimal)
-			copySkelInto(skelDir, u.HomeDir, uid, gid)
-		}
-	}
-	return nil
-}

authdaemon/host_stub.go

@@ -1,22 +0,0 @@
-//go:build !linux
-
-package authdaemon
-
-import "fmt"
-
-var errLinuxOnly = fmt.Errorf("auth-daemon PAM agent is only supported on Linux")
-
-// writeCACertIfNotExists returns an error on non-Linux.
-func writeCACertIfNotExists(path, contents string, force bool) error {
-	return errLinuxOnly
-}
-
-// ensureUser returns an error on non-Linux.
-func ensureUser(username string, meta ConnectionMetadata, generateRandomPassword bool) error {
-	return errLinuxOnly
-}
-
-// writePrincipals returns an error on non-Linux.
-func writePrincipals(path, username, niceId string) error {
-	return errLinuxOnly
-}

authdaemon/principals.go

@@ -1,28 +0,0 @@
-package authdaemon
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-)
-
-// GetPrincipals reads the principals data file at path, looks up the given user, and returns that user's principals as a string slice.
-// The file format is JSON: object with username keys and array-of-principals values, e.g. {"alice":["alice","usr-123"],"bob":["bob","usr-456"]}.
-// If the user is not found or the file is missing, returns nil and nil.
-func GetPrincipals(path, user string) ([]string, error) {
-	if path == "" {
-		return nil, fmt.Errorf("principals file path is required")
-	}
-	data, err := os.ReadFile(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return nil, nil
-		}
-		return nil, fmt.Errorf("read principals file: %w", err)
-	}
-	var m map[string][]string
-	if err := json.Unmarshal(data, &m); err != nil {
-		return nil, fmt.Errorf("parse principals file: %w", err)
-	}
-	return m[user], nil
-}

authdaemon/routes.go

@@ -1,58 +0,0 @@
-package authdaemon
-
-import (
-	"encoding/json"
-	"net/http"
-)
-
-// registerRoutes registers all API routes. Add new endpoints here.
-func (s *Server) registerRoutes() {
-	s.mux.HandleFunc("/health", s.handleHealth)
-	s.mux.HandleFunc("/connection", s.handleConnection)
-}
-
-// ConnectionMetadata is the metadata object in POST /connection.
-type ConnectionMetadata struct {
-	SudoMode     string   `json:"sudoMode"`     // "none" | "full" | "commands"
-	SudoCommands []string `json:"sudoCommands"`  // used when sudoMode is "commands"
-	Homedir      bool     `json:"homedir"`
-	Groups       []string `json:"groups"`        // system groups to add the user to
-}
-
-// ConnectionRequest is the JSON body for POST /connection.
-type ConnectionRequest struct {
-	CaCert   string             `json:"caCert"`
-	NiceId   string             `json:"niceId"`
-	Username string             `json:"username"`
-	Metadata ConnectionMetadata `json:"metadata"`
-}
-
-// healthResponse is the JSON body for GET /health.
-type healthResponse struct {
-	Status string `json:"status"`
-}
-
-// handleHealth responds with 200 and {"status":"ok"}.
-func (s *Server) handleHealth(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodGet {
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	w.Header().Set("Content-Type", "application/json")
-	_ = json.NewEncoder(w).Encode(healthResponse{Status: "ok"})
-}
-
-// handleConnection accepts POST with connection payload and delegates to ProcessConnection.
-func (s *Server) handleConnection(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
-		return
-	}
-	var req ConnectionRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		http.Error(w, "Bad Request", http.StatusBadRequest)
-		return
-	}
-	s.ProcessConnection(req)
-	w.WriteHeader(http.StatusOK)
-}

authdaemon/server.go

@@ -1,180 +0,0 @@
-package authdaemon
-
-import (
-	"context"
-	"crypto/ecdsa"
-	"crypto/elliptic"
-	"crypto/rand"
-	"crypto/subtle"
-	"crypto/tls"
-	"crypto/x509"
-	"crypto/x509/pkix"
-	"encoding/pem"
-	"fmt"
-	"math/big"
-	"net/http"
-	"os"
-	"runtime"
-	"strings"
-	"time"
-
-	"github.com/fosrl/newt/logger"
-)
-
-type Config struct {
-	// DisableHTTPS: when true, Run() does not start the HTTPS server (for embedded use inside Newt). Call ProcessConnection directly for connection events.
-	DisableHTTPS       bool
-	Port               int    // Required when DisableHTTPS is false. Listen port for the HTTPS server. No default.
-	PresharedKey       string // Required when DisableHTTPS is false. HTTP auth (Authorization: Bearer <key> or X-Preshared-Key: <key>). No default.
-	CACertPath         string // Required. Where to write the CA cert (e.g. /etc/ssh/ca.pem). No default.
-	Force                   bool   // If true, overwrite existing CA cert (and other items) when content differs. Default false.
-	PrincipalsFilePath      string // Required. Path to the principals data file (JSON: username -> array of principals). No default.
-	GenerateRandomPassword  bool   // If true, set a random password on users when they are provisioned (for SSH PermitEmptyPasswords no).
-}
-
-type Server struct {
-	cfg          Config
-	addr         string
-	presharedKey string
-	mux          *http.ServeMux
-	tlsCert      tls.Certificate
-}
-
-// generateTLSCert creates a self-signed certificate and key in memory (no disk).
-func generateTLSCert() (tls.Certificate, error) {
-	key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
-	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("generate key: %w", err)
-	}
-	serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
-	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("serial: %w", err)
-	}
-	tmpl := &x509.Certificate{
-		SerialNumber: serial,
-		Subject: pkix.Name{
-			CommonName: "localhost",
-		},
-		NotBefore:             time.Now(),
-		NotAfter:              time.Now().Add(365 * 24 * time.Hour),
-		KeyUsage:              x509.KeyUsageDigitalSignature,
-		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
-		BasicConstraintsValid: true,
-		DNSNames:              []string{"localhost", "127.0.0.1"},
-	}
-	certDER, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, key.Public(), key)
-	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("create certificate: %w", err)
-	}
-	keyDER, err := x509.MarshalECPrivateKey(key)
-	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("marshal key: %w", err)
-	}
-	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: certDER})
-	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: keyDER})
-	cert, err := tls.X509KeyPair(certPEM, keyPEM)
-	if err != nil {
-		return tls.Certificate{}, fmt.Errorf("x509 key pair: %w", err)
-	}
-	return cert, nil
-}
-
-// authMiddleware wraps next and requires a valid preshared key on every request.
-// Accepts Authorization: Bearer <key> or X-Preshared-Key: <key>.
-func (s *Server) authMiddleware(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		key := ""
-		if v := r.Header.Get("Authorization"); strings.HasPrefix(v, "Bearer ") {
-			key = strings.TrimSpace(strings.TrimPrefix(v, "Bearer "))
-		}
-		if key == "" {
-			key = strings.TrimSpace(r.Header.Get("X-Preshared-Key"))
-		}
-		if key == "" || subtle.ConstantTimeCompare([]byte(key), []byte(s.presharedKey)) != 1 {
-			http.Error(w, "Unauthorized", http.StatusUnauthorized)
-			return
-		}
-		next.ServeHTTP(w, r)
-	})
-}
-
-// NewServer builds a new auth-daemon server from cfg. Port, PresharedKey, CACertPath, and PrincipalsFilePath are required (no defaults).
-func NewServer(cfg Config) (*Server, error) {
-	if runtime.GOOS != "linux" {
-		return nil, fmt.Errorf("auth-daemon is only supported on Linux, not %s", runtime.GOOS)
-	}
-	if !cfg.DisableHTTPS {
-		if cfg.Port <= 0 {
-			return nil, fmt.Errorf("port is required and must be positive")
-		}
-		if cfg.PresharedKey == "" {
-			return nil, fmt.Errorf("preshared key is required")
-		}
-	}
-	if cfg.CACertPath == "" {
-		return nil, fmt.Errorf("CACertPath is required")
-	}
-	if cfg.PrincipalsFilePath == "" {
-		return nil, fmt.Errorf("PrincipalsFilePath is required")
-	}
-	s := &Server{cfg: cfg}
-	if !cfg.DisableHTTPS {
-		cert, err := generateTLSCert()
-		if err != nil {
-			return nil, err
-		}
-		s.addr = fmt.Sprintf(":%d", cfg.Port)
-		s.presharedKey = cfg.PresharedKey
-		s.mux = http.NewServeMux()
-		s.tlsCert = cert
-		s.registerRoutes()
-	}
-	return s, nil
-}
-
-// Run starts the HTTPS server (unless DisableHTTPS) and blocks until ctx is cancelled or the server errors.
-// When DisableHTTPS is true, Run() blocks on ctx only and does not listen; use ProcessConnection for connection events.
-func (s *Server) Run(ctx context.Context) error {
-	if s.cfg.DisableHTTPS {
-		logger.Info("auth-daemon running (HTTPS disabled)")
-		<-ctx.Done()
-		s.cleanupPrincipalsFile()
-		return nil
-	}
-	tcfg := &tls.Config{
-		Certificates: []tls.Certificate{s.tlsCert},
-		MinVersion:   tls.VersionTLS12,
-	}
-	handler := s.authMiddleware(s.mux)
-	srv := &http.Server{
-		Addr:              s.addr,
-		Handler:           handler,
-		TLSConfig:         tcfg,
-		ReadTimeout:       10 * time.Second,
-		WriteTimeout:      10 * time.Second,
-		ReadHeaderTimeout: 5 * time.Second,
-		IdleTimeout:       60 * time.Second,
-	}
-	go func() {
-		<-ctx.Done()
-		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-		defer cancel()
-		if err := srv.Shutdown(shutdownCtx); err != nil {
-			logger.Warn("auth-daemon shutdown: %v", err)
-		}
-	}()
-	logger.Info("auth-daemon listening on https://127.0.0.1%s", s.addr)
-	if err := srv.ListenAndServeTLS("", ""); err != nil && err != http.ErrServerClosed {
-		return err
-	}
-	s.cleanupPrincipalsFile()
-	return nil
-}
-
-func (s *Server) cleanupPrincipalsFile() {
-	if s.cfg.PrincipalsFilePath != "" {
-		if err := os.Remove(s.cfg.PrincipalsFilePath); err != nil && !os.IsNotExist(err) {
-			logger.Warn("auth-daemon: remove principals file: %v", err)
-		}
-	}
-}

bind/shared_bind.go

@@ -144,10 +144,6 @@ type SharedBind struct {
 
 	// Callback for magic test responses (used for holepunch testing)
 	magicResponseCallback atomic.Pointer[func(addr netip.AddrPort, echoData []byte)]
-
-	// Rebinding state - used to keep receive goroutines alive during socket transition
-	rebinding     bool       // true when socket is being replaced
-	rebindingCond *sync.Cond // signaled when rebind completes
 }
 
 // MagicResponseCallback is the function signature for magic packet response callbacks
@@ -167,9 +163,6 @@ func New(udpConn *net.UDPConn) (*SharedBind, error) {
 		closeChan:       make(chan struct{}),
 	}
 
-	// Initialize the rebinding condition variable
-	bind.rebindingCond = sync.NewCond(&bind.mu)
-
 	// Initialize reference count to 1 (the creator holds the first reference)
 	bind.refCount.Store(1)
 
@@ -317,109 +310,6 @@ func (b *SharedBind) IsClosed() bool {
 	return b.closed.Load()
 }
 
-// GetPort returns the current UDP port the bind is using.
-// This is useful when rebinding to try to reuse the same port.
-func (b *SharedBind) GetPort() uint16 {
-	b.mu.RLock()
-	defer b.mu.RUnlock()
-	return b.port
-}
-
-// CloseSocket closes the underlying UDP connection to release the port,
-// but keeps the SharedBind in a state where it can accept a new connection via Rebind.
-// This allows the caller to close the old socket first, then bind a new socket
-// to the same port before calling Rebind.
-//
-// Returns the port that was being used, so the caller can attempt to rebind to it.
-// Sets the rebinding flag so receive goroutines will wait for the new socket
-// instead of exiting.
-func (b *SharedBind) CloseSocket() (uint16, error) {
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if b.closed.Load() {
-		return 0, fmt.Errorf("bind is closed")
-	}
-
-	port := b.port
-
-	// Set rebinding flag BEFORE closing the socket so receive goroutines
-	// know to wait instead of exit
-	b.rebinding = true
-
-	// Close the old connection to release the port
-	if b.udpConn != nil {
-		logger.Debug("Closing UDP connection to release port %d (rebinding)", port)
-		b.udpConn.Close()
-		b.udpConn = nil
-	}
-
-	return port, nil
-}
-
-// Rebind replaces the underlying UDP connection with a new one.
-// This is necessary when network connectivity changes (e.g., WiFi to cellular
-// transition on macOS/iOS) and the old socket becomes stale.
-//
-// The caller is responsible for creating the new UDP connection and passing it here.
-// After rebind, the caller should trigger a hole punch to re-establish NAT mappings.
-//
-// Note: Call CloseSocket() first if you need to rebind to the same port, as the
-// old socket must be closed before a new socket can bind to the same port.
-func (b *SharedBind) Rebind(newConn *net.UDPConn) error {
-	if newConn == nil {
-		return fmt.Errorf("newConn cannot be nil")
-	}
-
-	b.mu.Lock()
-	defer b.mu.Unlock()
-
-	if b.closed.Load() {
-		return fmt.Errorf("bind is closed")
-	}
-
-	// Close the old connection if it's still open
-	// (it may have already been closed via CloseSocket)
-	if b.udpConn != nil {
-		logger.Debug("Closing old UDP connection during rebind")
-		b.udpConn.Close()
-	}
-
-	// Set up the new connection
-	b.udpConn = newConn
-
-	// Update packet connections for the new socket
-	if runtime.GOOS == "linux" || runtime.GOOS == "android" {
-		b.ipv4PC = ipv4.NewPacketConn(newConn)
-		b.ipv6PC = ipv6.NewPacketConn(newConn)
-
-		// Re-initialize message buffers for batch operations
-		batchSize := wgConn.IdealBatchSize
-		b.ipv4Msgs = make([]ipv4.Message, batchSize)
-		for i := range b.ipv4Msgs {
-			b.ipv4Msgs[i].OOB = make([]byte, 0)
-		}
-	} else {
-		// For non-Linux platforms, still set up ipv4PC for consistency
-		b.ipv4PC = ipv4.NewPacketConn(newConn)
-		b.ipv6PC = ipv6.NewPacketConn(newConn)
-	}
-
-	// Update the port
-	if addr, ok := newConn.LocalAddr().(*net.UDPAddr); ok {
-		b.port = uint16(addr.Port)
-		logger.Info("Rebound UDP socket to port %d", b.port)
-	}
-
-	// Clear the rebinding flag and wake up any waiting receive goroutines
-	b.rebinding = false
-	b.rebindingCond.Broadcast()
-
-	logger.Debug("Rebind complete, signaled waiting receive goroutines")
-
-	return nil
-}
-
 // SetMagicResponseCallback sets a callback function that will be called when
 // a magic test response packet is received. This is used for holepunch testing.
 // Pass nil to clear the callback.
@@ -502,77 +392,24 @@ func (b *SharedBind) Open(uport uint16) ([]wgConn.ReceiveFunc, uint16, error) {
 // makeReceiveSocket creates a receive function for physical UDP socket packets
 func (b *SharedBind) makeReceiveSocket() wgConn.ReceiveFunc {
 	return func(bufs [][]byte, sizes []int, eps []wgConn.Endpoint) (n int, err error) {
-		for {
-			if b.closed.Load() {
-				return 0, net.ErrClosed
-			}
-
-			b.mu.RLock()
-			conn := b.udpConn
-			pc := b.ipv4PC
-			b.mu.RUnlock()
-
-			if conn == nil {
-				// Socket is nil - check if we're rebinding or truly closed
-				if b.closed.Load() {
-					return 0, net.ErrClosed
-				}
-
-				// Wait for rebind to complete
-				b.mu.Lock()
-				for b.rebinding && !b.closed.Load() {
-					logger.Debug("Receive goroutine waiting for socket rebind to complete")
-					b.rebindingCond.Wait()
-				}
-				b.mu.Unlock()
-
-				// Check again after waking up
-				if b.closed.Load() {
-					return 0, net.ErrClosed
-				}
-
-				// Loop back to retry with new socket
-				continue
-			}
-
-			// Use batch reading on Linux for performance
-			var n int
-			var err error
-			if pc != nil && (runtime.GOOS == "linux" || runtime.GOOS == "android") {
-				n, err = b.receiveIPv4Batch(pc, bufs, sizes, eps)
-			} else {
-				n, err = b.receiveIPv4Simple(conn, bufs, sizes, eps)
-			}
-
-			if err != nil {
-				// Check if this error is due to rebinding
-				b.mu.RLock()
-				rebinding := b.rebinding
-				b.mu.RUnlock()
-
-				if rebinding {
-					logger.Debug("Receive got error during rebind, waiting for new socket: %v", err)
-					// Wait for rebind to complete and retry
-					b.mu.Lock()
-					for b.rebinding && !b.closed.Load() {
-						b.rebindingCond.Wait()
-					}
-					b.mu.Unlock()
-
-					if b.closed.Load() {
-						return 0, net.ErrClosed
-					}
-
-					// Retry with new socket
-					continue
-				}
-
-				// Not rebinding, return the error
-				return 0, err
-			}
-
-			return n, nil
+		if b.closed.Load() {
+			return 0, net.ErrClosed
 		}
+
+		b.mu.RLock()
+		conn := b.udpConn
+		pc := b.ipv4PC
+		b.mu.RUnlock()
+
+		if conn == nil {
+			return 0, net.ErrClosed
+		}
+
+		// Use batch reading on Linux for performance
+		if pc != nil && (runtime.GOOS == "linux" || runtime.GOOS == "android") {
+			return b.receiveIPv4Batch(pc, bufs, sizes, eps)
+		}
+		return b.receiveIPv4Simple(conn, bufs, sizes, eps)
 	}
 }
 
@@ -655,8 +492,6 @@ func (b *SharedBind) receiveIPv4Batch(pc *ipv4.PacketConn, bufs [][]byte, sizes
 
 // receiveIPv4Simple uses simple ReadFromUDP for non-Linux platforms
 func (b *SharedBind) receiveIPv4Simple(conn *net.UDPConn, bufs [][]byte, sizes []int, eps []wgConn.Endpoint) (int, error) {
-	// No read deadline - we rely on socket close to unblock during rebind.
-	// The caller (makeReceiveSocket) handles rebind state when errors occur.
 	for {
 		n, addr, err := conn.ReadFromUDP(bufs[0])
 		if err != nil {
@@ -688,7 +523,7 @@ func (b *SharedBind) receiveIPv4Simple(conn *net.UDPConn, bufs [][]byte, sizes [
 func (b *SharedBind) handleMagicPacket(data []byte, addr *net.UDPAddr) bool {
 	// Check if this is a test request packet
 	if len(data) >= MagicTestRequestLen && bytes.HasPrefix(data, MagicTestRequest) {
-		// logger.Debug("Received magic test REQUEST from %s, sending response", addr.String())
+		logger.Debug("Received magic test REQUEST from %s, sending response", addr.String())
 		// Extract the random data portion to echo back
 		echoData := data[len(MagicTestRequest) : len(MagicTestRequest)+MagicPacketDataLen]
 
@@ -711,7 +546,7 @@ func (b *SharedBind) handleMagicPacket(data []byte, addr *net.UDPAddr) bool {
 
 	// Check if this is a test response packet
 	if len(data) >= MagicTestResponseLen && bytes.HasPrefix(data, MagicTestResponse) {
-		// logger.Debug("Received magic test RESPONSE from %s", addr.String())
+		logger.Debug("Received magic test RESPONSE from %s", addr.String())
 		// Extract the echoed data
 		echoData := data[len(MagicTestResponse) : len(MagicTestResponse)+MagicPacketDataLen]
 

blueprint.yaml

@@ -0,0 +1,37 @@
+resources:
+  resource-nice-id:
+    name: this is my resource
+    protocol: http
+    full-domain: level1.test3.example.com
+    host-header: example.com
+    tls-server-name: example.com
+    auth:
+      pincode: 123456
+      password: sadfasdfadsf
+      sso-enabled: true
+      sso-roles:
+      - Member
+      sso-users:
+      - owen@pangolin.net
+      whitelist-users:
+      - owen@pangolin.net
+    targets:
+    # - site: glossy-plains-viscacha-rat
+    - hostname: localhost
+      method: http
+      port: 8000
+      healthcheck:
+        port: 8000
+        hostname: localhost
+    # - site: glossy-plains-viscacha-rat
+    - hostname: localhost
+      method: http
+      port: 8001
+  resource-nice-id2:
+    name: this is other resource
+    protocol: tcp
+    proxy-port: 3000
+    targets:
+    # - site: glossy-plains-viscacha-rat
+    - hostname: localhost
+      port: 3000

clients.go

@@ -24,7 +24,7 @@ func setupClients(client *websocket.Client) {
 
 	host = strings.TrimSuffix(host, "/")
 
-	logger.Debug("Setting up clients with netstack2...")
+	logger.Info("Setting up clients with netstack2...")
 
 	// if useNativeInterface is true make sure we have permission to use native interface
 	if useNativeInterface {

clients/clients.go

@@ -2,8 +2,6 @@ package clients
 
 import (
 	"context"
-	"crypto/rand"
-	"encoding/hex"
 	"encoding/json"
 	"fmt"
 	"net"
@@ -36,21 +34,14 @@ type WgConfig struct {
 	IpAddress string   `json:"ipAddress"`
 	Peers     []Peer   `json:"peers"`
 	Targets   []Target `json:"targets"`
-	ChainId   string   `json:"chainId"`
 }
 
 type Target struct {
-	SourcePrefix   string                 `json:"sourcePrefix"`
-	SourcePrefixes []string               `json:"sourcePrefixes"`
-	DestPrefix     string                 `json:"destPrefix"`
-	RewriteTo      string                 `json:"rewriteTo,omitempty"`
-	DisableIcmp    bool                   `json:"disableIcmp,omitempty"`
-	PortRange      []PortRange            `json:"portRange,omitempty"`
-	ResourceId     int                    `json:"resourceId,omitempty"`
-	Protocol       string                 `json:"protocol,omitempty"`    // for now practicably either http or https
-	HTTPTargets    []netstack2.HTTPTarget `json:"httpTargets,omitempty"` // for http protocol, list of downstream services to load balance across
-	TLSCert        string                 `json:"tlsCert,omitempty"`     // PEM-encoded certificate for incoming HTTPS termination
-	TLSKey         string                 `json:"tlsKey,omitempty"`      // PEM-encoded private key for incoming HTTPS termination
+	SourcePrefix string      `json:"sourcePrefix"`
+	DestPrefix   string      `json:"destPrefix"`
+	RewriteTo    string      `json:"rewriteTo,omitempty"`
+	DisableIcmp  bool        `json:"disableIcmp,omitempty"`
+	PortRange    []PortRange `json:"portRange,omitempty"`
 }
 
 type PortRange struct {
@@ -78,20 +69,19 @@ type PeerReading struct {
 }
 
 type WireGuardService struct {
-	interfaceName        string
-	mtu                  int
-	client               *websocket.Client
-	config               WgConfig
-	key                  wgtypes.Key
-	newtId               string
-	lastReadings         map[string]PeerReading
-	mu                   sync.Mutex
-	Port                 uint16
-	host                 string
-	serverPubKey         string
-	token                string
-	stopGetConfig        func()
-	pendingConfigChainId string
+	interfaceName string
+	mtu           int
+	client        *websocket.Client
+	config        WgConfig
+	key           wgtypes.Key
+	newtId        string
+	lastReadings  map[string]PeerReading
+	mu            sync.Mutex
+	Port          uint16
+	host          string
+	serverPubKey  string
+	token         string
+	stopGetConfig func()
 	// Netstack fields
 	tun    tun.Device
 	tnet   *netstack2.Net
@@ -116,13 +106,6 @@ type WireGuardService struct {
 	wgTesterServer     *wgtester.Server
 }
 
-// generateChainId generates a random chain ID for deduplicating round-trip messages.
-func generateChainId() string {
-	b := make([]byte, 8)
-	_, _ = rand.Read(b)
-	return hex.EncodeToString(b)
-}
-
 func NewWireGuardService(interfaceName string, port uint16, mtu int, host string, newtId string, wsClient *websocket.Client, dns string, useNativeInterface bool) (*WireGuardService, error) {
 	key, err := wgtypes.GeneratePrivateKey()
 	if err != nil {
@@ -158,7 +141,7 @@ func NewWireGuardService(interfaceName string, port uint16, mtu int, host string
 	// Add a reference for the hole punch manager (creator already has one reference for WireGuard)
 	sharedBind.AddRef()
 
-	logger.Debug("Created shared UDP socket on port %d (refcount: %d)", port, sharedBind.GetRefCount())
+	logger.Info("Created shared UDP socket on port %d (refcount: %d)", port, sharedBind.GetRefCount())
 
 	// Parse DNS addresses
 	dnsAddrs := []netip.Addr{netip.MustParseAddr(dns)}
@@ -177,8 +160,9 @@ func NewWireGuardService(interfaceName string, port uint16, mtu int, host string
 		useNativeInterface: useNativeInterface,
 	}
 
-	// Create the holepunch manager
-	service.holePunchManager = holepunch.NewManager(sharedBind, newtId, "newt", key.PublicKey().String(), nil)
+	// Create the holepunch manager with ResolveDomain function
+	// We'll need to pass a domain resolver function
+	service.holePunchManager = holepunch.NewManager(sharedBind, newtId, "newt", key.PublicKey().String())
 
 	// Register websocket handlers
 	wsClient.RegisterHandler("newt/wg/receive-config", service.handleConfig)
@@ -188,7 +172,6 @@ func NewWireGuardService(interfaceName string, port uint16, mtu int, host string
 	wsClient.RegisterHandler("newt/wg/targets/add", service.handleAddTarget)
 	wsClient.RegisterHandler("newt/wg/targets/remove", service.handleRemoveTarget)
 	wsClient.RegisterHandler("newt/wg/targets/update", service.handleUpdateTarget)
-	wsClient.RegisterHandler("newt/wg/sync", service.handleSyncConfig)
 
 	return service, nil
 }
@@ -211,15 +194,6 @@ func (s *WireGuardService) Close() {
 		s.stopGetConfig = nil
 	}
 
-	// Flush access logs before tearing down the tunnel
-	if s.tnet != nil {
-		if ph := s.tnet.GetProxyHandler(); ph != nil {
-			if al := ph.GetAccessLogger(); al != nil {
-				al.Close()
-			}
-		}
-	}
-
 	// Stop the direct UDP relay first
 	s.StopDirectUDPRelay()
 
@@ -303,7 +277,7 @@ func (s *WireGuardService) StartHolepunch(publicKey string, endpoint string, rel
 	}
 
 	if relayPort == 0 {
-		relayPort = 21820
+	    relayPort = 21820
 	}
 
 	// Convert websocket.ExitNode to holepunch.ExitNode
@@ -320,7 +294,7 @@ func (s *WireGuardService) StartHolepunch(publicKey string, endpoint string, rel
 		logger.Warn("Failed to start hole punch: %v", err)
 	}
 
-	logger.Debug("Starting hole punch to %s with public key: %s", endpoint, publicKey)
+	logger.Info("Starting hole punch to %s with public key: %s", endpoint, publicKey)
 }
 
 // StartDirectUDPRelay starts a direct UDP relay from the main tunnel netstack to the clients' WireGuard.
@@ -367,7 +341,7 @@ func (s *WireGuardService) StartDirectUDPRelay(tunnelIP string) error {
 	// Set the netstack connection on the SharedBind so responses go back through the tunnel
 	s.sharedBind.SetNetstackConn(listener)
 
-	logger.Debug("Started direct UDP relay on %s:%d (bidirectional via SharedBind)", tunnelIP, s.Port)
+	logger.Info("Started direct UDP relay on %s:%d (bidirectional via SharedBind)", tunnelIP, s.Port)
 
 	// Start the relay goroutine to read from netstack and inject into SharedBind
 	s.directRelayWg.Add(1)
@@ -385,7 +359,7 @@ func (s *WireGuardService) runDirectUDPRelay(listener net.PacketConn) {
 	// Note: Don't close listener here - it's also used by SharedBind for sending responses
 	// It will be closed when the relay is stopped
 
-	logger.Debug("Direct UDP relay started (bidirectional through SharedBind)")
+	logger.Info("Direct UDP relay started (bidirectional through SharedBind)")
 
 	buf := make([]byte, 65535) // Max UDP packet size
 
@@ -466,15 +440,12 @@ func (s *WireGuardService) LoadRemoteConfig() error {
 		s.stopGetConfig()
 		s.stopGetConfig = nil
 	}
-	chainId := generateChainId()
-	s.pendingConfigChainId = chainId
 	s.stopGetConfig = s.client.SendMessageInterval("newt/wg/get-config", map[string]interface{}{
 		"publicKey": s.key.PublicKey().String(),
 		"port":      s.Port,
-		"chainId":   chainId,
 	}, 2*time.Second)
 
-	logger.Debug("Requesting WireGuard configuration from remote server")
+	logger.Info("Requesting WireGuard configuration from remote server")
 	go s.periodicBandwidthCheck()
 
 	return nil
@@ -484,7 +455,7 @@ func (s *WireGuardService) handleConfig(msg websocket.WSMessage) {
 	var config WgConfig
 
 	logger.Debug("Received message: %v", msg)
-	logger.Debug("Received WireGuard clients configuration from remote server")
+	logger.Info("Received WireGuard clients configuration from remote server")
 
 	jsonData, err := json.Marshal(msg.Data)
 	if err != nil {
@@ -496,17 +467,6 @@ func (s *WireGuardService) handleConfig(msg websocket.WSMessage) {
 		logger.Info("Error unmarshaling target data: %v", err)
 		return
 	}
-
-	// Deduplicate using chainId: discard responses that don't match the
-	// pending request, or that we have already processed.
-	if config.ChainId != "" {
-		if config.ChainId != s.pendingConfigChainId {
-			logger.Debug("Discarding duplicate/stale newt/wg/get-config response (chainId=%s, expected=%s)", config.ChainId, s.pendingConfigChainId)
-			return
-		}
-		s.pendingConfigChainId = "" // consume – further duplicates are rejected
-	}
-
 	s.config = config
 
 	if s.stopGetConfig != nil {
@@ -528,196 +488,6 @@ func (s *WireGuardService) handleConfig(msg websocket.WSMessage) {
 	if err := s.ensureTargets(config.Targets); err != nil {
 		logger.Error("Failed to ensure WireGuard targets: %v", err)
 	}
-
-	logger.Info("Client connectivity setup. Ready to accept connections from clients!")
-}
-
-// SyncConfig represents the configuration sent from server for syncing
-type SyncConfig struct {
-	Targets []Target `json:"targets"`
-	Peers   []Peer   `json:"peers"`
-}
-
-func (s *WireGuardService) handleSyncConfig(msg websocket.WSMessage) {
-	var syncConfig SyncConfig
-
-	logger.Debug("Received sync message: %v", msg)
-	logger.Info("Received sync configuration from remote server")
-
-	jsonData, err := json.Marshal(msg.Data)
-	if err != nil {
-		logger.Error("Error marshaling sync data: %v", err)
-		return
-	}
-
-	if err := json.Unmarshal(jsonData, &syncConfig); err != nil {
-		logger.Error("Error unmarshaling sync data: %v", err)
-		return
-	}
-
-	// Sync peers
-	if err := s.syncPeers(syncConfig.Peers); err != nil {
-		logger.Error("Failed to sync peers: %v", err)
-	}
-
-	// Sync targets
-	if err := s.syncTargets(syncConfig.Targets); err != nil {
-		logger.Error("Failed to sync targets: %v", err)
-	}
-}
-
-// syncPeers synchronizes the current peers with the desired state
-// It removes peers not in the desired list and adds missing ones
-func (s *WireGuardService) syncPeers(desiredPeers []Peer) error {
-	if s.device == nil {
-		return fmt.Errorf("WireGuard device is not initialized")
-	}
-
-	// Get current peers from the device
-	currentConfig, err := s.device.IpcGet()
-	if err != nil {
-		return fmt.Errorf("failed to get current device config: %v", err)
-	}
-
-	// Parse current peer public keys
-	lines := strings.Split(currentConfig, "\n")
-	currentPeerKeys := make(map[string]bool)
-	for _, line := range lines {
-		if strings.HasPrefix(line, "public_key=") {
-			pubKey := strings.TrimPrefix(line, "public_key=")
-			currentPeerKeys[pubKey] = true
-		}
-	}
-
-	// Build a map of desired peers by their public key (normalized)
-	desiredPeerMap := make(map[string]Peer)
-	for _, peer := range desiredPeers {
-		// Normalize the public key for comparison
-		pubKey, err := wgtypes.ParseKey(peer.PublicKey)
-		if err != nil {
-			logger.Warn("Invalid public key in desired peers: %s", peer.PublicKey)
-			continue
-		}
-		normalizedKey := util.FixKey(pubKey.String())
-		desiredPeerMap[normalizedKey] = peer
-	}
-
-	// Remove peers that are not in the desired list
-	for currentKey := range currentPeerKeys {
-		if _, exists := desiredPeerMap[currentKey]; !exists {
-			// Parse the key back to get the original format for removal
-			removeConfig := fmt.Sprintf("public_key=%s\nremove=true", currentKey)
-			if err := s.device.IpcSet(removeConfig); err != nil {
-				logger.Warn("Failed to remove peer %s during sync: %v", currentKey, err)
-			} else {
-				logger.Info("Removed peer %s during sync", currentKey)
-			}
-		}
-	}
-
-	// Add peers that are missing
-	for normalizedKey, peer := range desiredPeerMap {
-		if _, exists := currentPeerKeys[normalizedKey]; !exists {
-			if err := s.addPeerToDevice(peer); err != nil {
-				logger.Warn("Failed to add peer %s during sync: %v", peer.PublicKey, err)
-			} else {
-				logger.Info("Added peer %s during sync", peer.PublicKey)
-			}
-		}
-	}
-
-	return nil
-}
-
-// syncTargets synchronizes the current targets with the desired state
-// It removes targets not in the desired list and adds missing ones
-func (s *WireGuardService) syncTargets(desiredTargets []Target) error {
-	if s.tnet == nil {
-		// Native interface mode - proxy features not available, skip silently
-		logger.Debug("Skipping target sync - using native interface (no proxy support)")
-		return nil
-	}
-
-	// Get current rules from the proxy handler
-	currentRules := s.tnet.GetProxySubnetRules()
-
-	// Build a map of current rules by source+dest prefix
-	type ruleKey struct {
-		sourcePrefix string
-		destPrefix   string
-	}
-	currentRuleMap := make(map[ruleKey]bool)
-	for _, rule := range currentRules {
-		key := ruleKey{
-			sourcePrefix: rule.SourcePrefix.String(),
-			destPrefix:   rule.DestPrefix.String(),
-		}
-		currentRuleMap[key] = true
-	}
-
-	// Build a map of desired targets
-	desiredTargetMap := make(map[ruleKey]Target)
-	for _, target := range desiredTargets {
-		key := ruleKey{
-			sourcePrefix: target.SourcePrefix,
-			destPrefix:   target.DestPrefix,
-		}
-		desiredTargetMap[key] = target
-	}
-
-	// Remove targets that are not in the desired list
-	for _, rule := range currentRules {
-		key := ruleKey{
-			sourcePrefix: rule.SourcePrefix.String(),
-			destPrefix:   rule.DestPrefix.String(),
-		}
-		if _, exists := desiredTargetMap[key]; !exists {
-			s.tnet.RemoveProxySubnetRule(rule.SourcePrefix, rule.DestPrefix)
-			logger.Info("Removed target %s -> %s during sync", rule.SourcePrefix.String(), rule.DestPrefix.String())
-		}
-	}
-
-	// Add targets that are missing
-	for key, target := range desiredTargetMap {
-		if _, exists := currentRuleMap[key]; !exists {
-			sourcePrefix, err := netip.ParsePrefix(target.SourcePrefix)
-			if err != nil {
-				logger.Warn("Invalid source prefix %s during sync: %v", target.SourcePrefix, err)
-				continue
-			}
-
-			destPrefix, err := netip.ParsePrefix(target.DestPrefix)
-			if err != nil {
-				logger.Warn("Invalid dest prefix %s during sync: %v", target.DestPrefix, err)
-				continue
-			}
-
-			var portRanges []netstack2.PortRange
-			for _, pr := range target.PortRange {
-				portRanges = append(portRanges, netstack2.PortRange{
-					Min:      pr.Min,
-					Max:      pr.Max,
-					Protocol: pr.Protocol,
-				})
-			}
-
-			s.tnet.AddProxySubnetRule(netstack2.SubnetRule{
-				SourcePrefix: sourcePrefix,
-				DestPrefix:   destPrefix,
-				RewriteTo:    target.RewriteTo,
-				PortRanges:   portRanges,
-				DisableIcmp:  target.DisableIcmp,
-				ResourceId:   target.ResourceId,
-				Protocol:     target.Protocol,
-				HTTPTargets:  target.HTTPTargets,
-				TLSCert:      target.TLSCert,
-				TLSKey:       target.TLSKey,
-			})
-			logger.Info("Added target %s -> %s during sync", target.SourcePrefix, target.DestPrefix)
-		}
-	}
-
-	return nil
 }
 
 func (s *WireGuardService) ensureWireguardInterface(wgconfig WgConfig) error {
@@ -843,20 +613,6 @@ func (s *WireGuardService) ensureWireguardInterface(wgconfig WgConfig) error {
 
 	s.TunnelIP = tunnelIP.String()
 
-	// Configure the access log sender to ship compressed session logs via websocket
-	s.tnet.SetAccessLogSender(func(data string) error {
-		return s.client.SendMessageNoLog("newt/access-log", map[string]interface{}{
-			"compressed": data,
-		})
-	})
-
-	// Configure the HTTP request log sender to ship compressed request logs via websocket
-	s.tnet.SetHTTPRequestLogSender(func(data string) error {
-		return s.client.SendMessageNoLog("newt/request-log", map[string]interface{}{
-			"compressed": data,
-		})
-	})
-
 	// Create WireGuard device using the shared bind
 	s.device = device.NewDevice(s.tun, s.sharedBind, device.NewLogger(
 		device.LogLevelSilent, // Use silent logging by default - could be made configurable
@@ -879,7 +635,7 @@ func (s *WireGuardService) ensureWireguardInterface(wgconfig WgConfig) error {
 		return fmt.Errorf("failed to bring up WireGuard device: %v", err)
 	}
 
-	logger.Debug("WireGuard netstack device created and configured")
+	logger.Info("WireGuard netstack device created and configured")
 
 	// Release the mutex before calling the callback
 	s.mu.Unlock()
@@ -937,19 +693,6 @@ func (s *WireGuardService) ensureWireguardPeers(peers []Peer) error {
 	return nil
 }
 
-// resolveSourcePrefixes returns the effective list of source prefixes for a target,
-// supporting both the legacy single SourcePrefix field and the new SourcePrefixes array.
-// If SourcePrefixes is non-empty it takes precedence; otherwise SourcePrefix is used.
-func resolveSourcePrefixes(target Target) []string {
-	if len(target.SourcePrefixes) > 0 {
-		return target.SourcePrefixes
-	}
-	if target.SourcePrefix != "" {
-		return []string{target.SourcePrefix}
-	}
-	return nil
-}
-
 func (s *WireGuardService) ensureTargets(targets []Target) error {
 	if s.tnet == nil {
 		// Native interface mode - proxy features not available, skip silently
@@ -958,6 +701,11 @@ func (s *WireGuardService) ensureTargets(targets []Target) error {
 	}
 
 	for _, target := range targets {
+		sourcePrefix, err := netip.ParsePrefix(target.SourcePrefix)
+		if err != nil {
+			return fmt.Errorf("invalid CIDR %s: %v", target.SourcePrefix, err)
+		}
+
 		destPrefix, err := netip.ParsePrefix(target.DestPrefix)
 		if err != nil {
 			return fmt.Errorf("invalid CIDR %s: %v", target.DestPrefix, err)
@@ -972,25 +720,9 @@ func (s *WireGuardService) ensureTargets(targets []Target) error {
 			})
 		}
 
-		for _, sp := range resolveSourcePrefixes(target) {
-			sourcePrefix, err := netip.ParsePrefix(sp)
-			if err != nil {
-				return fmt.Errorf("invalid CIDR %s: %v", sp, err)
-			}
-			s.tnet.AddProxySubnetRule(netstack2.SubnetRule{
-				SourcePrefix: sourcePrefix,
-				DestPrefix:   destPrefix,
-				RewriteTo:    target.RewriteTo,
-				PortRanges:   portRanges,
-				DisableIcmp:  target.DisableIcmp,
-				ResourceId:   target.ResourceId,
-				Protocol:     target.Protocol,
-				HTTPTargets:  target.HTTPTargets,
-				TLSCert:      target.TLSCert,
-				TLSKey:       target.TLSKey,
-			})
-			logger.Info("Added target subnet from %s to %s rewrite to %s with port ranges: %v", sp, target.DestPrefix, target.RewriteTo, target.PortRange)
-		}
+		s.tnet.AddProxySubnetRule(sourcePrefix, destPrefix, target.RewriteTo, portRanges, target.DisableIcmp)
+
+		logger.Info("Added target subnet from %s to %s rewrite to %s with port ranges: %v", target.SourcePrefix, target.DestPrefix, target.RewriteTo, target.PortRange)
 	}
 
 	return nil
@@ -1301,22 +1033,21 @@ func (s *WireGuardService) processPeerBandwidth(publicKey string, rxBytes, txByt
 			// Update the last reading
 			s.lastReadings[publicKey] = currentReading
 
-			// Only return bandwidth data if there was an increase
-			if bytesInDiff > 0 || bytesOutDiff > 0 {
-				return &PeerBandwidth{
-					PublicKey: publicKey,
-					BytesIn:   bytesInMB,
-					BytesOut:  bytesOutMB,
-				}
+			return &PeerBandwidth{
+				PublicKey: publicKey,
+				BytesIn:   bytesInMB,
+				BytesOut:  bytesOutMB,
 			}
-
-			return nil
 		}
 	}
 
-	// For first reading or if readings are too close together, don't report
+	// For first reading or if readings are too close together, report 0
 	s.lastReadings[publicKey] = currentReading
-	return nil
+	return &PeerBandwidth{
+		PublicKey: publicKey,
+		BytesIn:   0,
+		BytesOut:  0,
+	}
 }
 
 func (s *WireGuardService) reportPeerBandwidth() error {
@@ -1360,6 +1091,12 @@ func (s *WireGuardService) handleAddTarget(msg websocket.WSMessage) {
 
 	// Process all targets
 	for _, target := range targets {
+		sourcePrefix, err := netip.ParsePrefix(target.SourcePrefix)
+		if err != nil {
+			logger.Info("Invalid CIDR %s: %v", target.SourcePrefix, err)
+			continue
+		}
+
 		destPrefix, err := netip.ParsePrefix(target.DestPrefix)
 		if err != nil {
 			logger.Info("Invalid CIDR %s: %v", target.DestPrefix, err)
@@ -1369,32 +1106,15 @@ func (s *WireGuardService) handleAddTarget(msg websocket.WSMessage) {
 		var portRanges []netstack2.PortRange
 		for _, pr := range target.PortRange {
 			portRanges = append(portRanges, netstack2.PortRange{
-				Min:      pr.Min,
-				Max:      pr.Max,
-				Protocol: pr.Protocol,
+				Min: pr.Min,
+				Max: pr.Max,
+				Protocol:    pr.Protocol,
 			})
 		}
 
-		for _, sp := range resolveSourcePrefixes(target) {
-			sourcePrefix, err := netip.ParsePrefix(sp)
-			if err != nil {
-				logger.Info("Invalid CIDR %s: %v", sp, err)
-				continue
-			}
-			s.tnet.AddProxySubnetRule(netstack2.SubnetRule{
-				SourcePrefix: sourcePrefix,
-				DestPrefix:   destPrefix,
-				RewriteTo:    target.RewriteTo,
-				PortRanges:   portRanges,
-				DisableIcmp:  target.DisableIcmp,
-				ResourceId:   target.ResourceId,
-				Protocol:     target.Protocol,
-				HTTPTargets:  target.HTTPTargets,
-				TLSCert:      target.TLSCert,
-				TLSKey:       target.TLSKey,
-			})
-			logger.Info("Added target subnet from %s to %s rewrite to %s with port ranges: %v", sp, target.DestPrefix, target.RewriteTo, target.PortRange)
-		}
+		s.tnet.AddProxySubnetRule(sourcePrefix, destPrefix, target.RewriteTo, portRanges, target.DisableIcmp)
+
+		logger.Info("Added target subnet from %s to %s rewrite to %s with port ranges: %v", target.SourcePrefix, target.DestPrefix, target.RewriteTo, target.PortRange)
 	}
 }
 
@@ -1423,21 +1143,21 @@ func (s *WireGuardService) handleRemoveTarget(msg websocket.WSMessage) {
 
 	// Process all targets
 	for _, target := range targets {
+		sourcePrefix, err := netip.ParsePrefix(target.SourcePrefix)
+		if err != nil {
+			logger.Info("Invalid CIDR %s: %v", target.SourcePrefix, err)
+			continue
+		}
+
 		destPrefix, err := netip.ParsePrefix(target.DestPrefix)
 		if err != nil {
 			logger.Info("Invalid CIDR %s: %v", target.DestPrefix, err)
 			continue
 		}
 
-		for _, sp := range resolveSourcePrefixes(target) {
-			sourcePrefix, err := netip.ParsePrefix(sp)
-			if err != nil {
-				logger.Info("Invalid CIDR %s: %v", sp, err)
-				continue
-			}
-			s.tnet.RemoveProxySubnetRule(sourcePrefix, destPrefix)
-			logger.Info("Removed target subnet %s with destination %s", sp, target.DestPrefix)
-		}
+		s.tnet.RemoveProxySubnetRule(sourcePrefix, destPrefix)
+
+		logger.Info("Removed target subnet %s with destination %s", target.SourcePrefix, target.DestPrefix)
 	}
 }
 
@@ -1471,24 +1191,30 @@ func (s *WireGuardService) handleUpdateTarget(msg websocket.WSMessage) {
 
 	// Process all update requests
 	for _, target := range requests.OldTargets {
+		sourcePrefix, err := netip.ParsePrefix(target.SourcePrefix)
+		if err != nil {
+			logger.Info("Invalid CIDR %s: %v", target.SourcePrefix, err)
+			continue
+		}
+
 		destPrefix, err := netip.ParsePrefix(target.DestPrefix)
 		if err != nil {
 			logger.Info("Invalid CIDR %s: %v", target.DestPrefix, err)
 			continue
 		}
 
-		for _, sp := range resolveSourcePrefixes(target) {
-			sourcePrefix, err := netip.ParsePrefix(sp)
-			if err != nil {
-				logger.Info("Invalid CIDR %s: %v", sp, err)
-				continue
-			}
-			s.tnet.RemoveProxySubnetRule(sourcePrefix, destPrefix)
-			logger.Info("Removed target subnet %s with destination %s", sp, target.DestPrefix)
-		}
+		s.tnet.RemoveProxySubnetRule(sourcePrefix, destPrefix)
+		logger.Info("Removed target subnet %s with destination %s", target.SourcePrefix, target.DestPrefix)
 	}
 
 	for _, target := range requests.NewTargets {
+		// Now add the new target
+		sourcePrefix, err := netip.ParsePrefix(target.SourcePrefix)
+		if err != nil {
+			logger.Info("Invalid CIDR %s: %v", target.SourcePrefix, err)
+			continue
+		}
+
 		destPrefix, err := netip.ParsePrefix(target.DestPrefix)
 		if err != nil {
 			logger.Info("Invalid CIDR %s: %v", target.DestPrefix, err)
@@ -1498,32 +1224,14 @@ func (s *WireGuardService) handleUpdateTarget(msg websocket.WSMessage) {
 		var portRanges []netstack2.PortRange
 		for _, pr := range target.PortRange {
 			portRanges = append(portRanges, netstack2.PortRange{
-				Min:      pr.Min,
-				Max:      pr.Max,
-				Protocol: pr.Protocol,
+				Min:         pr.Min,
+				Max:         pr.Max,
+				Protocol:    pr.Protocol,
 			})
 		}
 
-		for _, sp := range resolveSourcePrefixes(target) {
-			sourcePrefix, err := netip.ParsePrefix(sp)
-			if err != nil {
-				logger.Info("Invalid CIDR %s: %v", sp, err)
-				continue
-			}
-			s.tnet.AddProxySubnetRule(netstack2.SubnetRule{
-				SourcePrefix: sourcePrefix,
-				DestPrefix:   destPrefix,
-				RewriteTo:    target.RewriteTo,
-				PortRanges:   portRanges,
-				DisableIcmp:  target.DisableIcmp,
-				ResourceId:   target.ResourceId,
-				Protocol:     target.Protocol,
-				HTTPTargets:  target.HTTPTargets,
-				TLSCert:      target.TLSCert,
-				TLSKey:       target.TLSKey,
-			})
-			logger.Info("Added target subnet from %s to %s rewrite to %s with port ranges: %v", sp, target.DestPrefix, target.RewriteTo, target.PortRange)
-		}
+		s.tnet.AddProxySubnetRule(sourcePrefix, destPrefix, target.RewriteTo, portRanges, target.DisableIcmp)
+		logger.Info("Added target subnet from %s to %s rewrite to %s with port ranges: %v", target.SourcePrefix, target.DestPrefix, target.RewriteTo, target.PortRange)
 	}
 }
 

clients/permissions/permissions_android.go

@@ -1,8 +0,0 @@
-//go:build android
-
-package permissions
-
-// CheckNativeInterfacePermissions always allows permission on Android.
-func CheckNativeInterfacePermissions() error {
-	return nil
-}

clients/permissions/permissions_darwin.go

@@ -1,4 +1,4 @@
-//go:build darwin && !ios
+//go:build darwin
 
 package permissions
 

clients/permissions/permissions_ios.go

@@ -1,8 +0,0 @@
-//go:build ios
-
-package permissions
-
-// CheckNativeInterfacePermissions always allows permission on iOS.
-func CheckNativeInterfacePermissions() error {
-	return nil
-}

clients/permissions/permissions_linux.go

@@ -1,4 +1,4 @@
-//go:build linux && !android
+//go:build linux
 
 package permissions
 

common.go

@@ -5,10 +5,8 @@ import (
 	"context"
 	"encoding/json"
 	"fmt"
-	"net"
 	"os"
 	"os/exec"
-	"regexp"
 	"strings"
 	"time"
 
@@ -286,18 +284,11 @@ func startPingCheck(tnet *netstack.Net, serverIP string, client *websocket.Clien
 							if tunnelID != "" {
 								telemetry.IncReconnect(context.Background(), tunnelID, "client", telemetry.ReasonTimeout)
 							}
-							pingChainId := generateChainId()
-							pendingPingChainId = pingChainId
-							stopFunc = client.SendMessageInterval("newt/ping/request", map[string]interface{}{
-								"chainId": pingChainId,
-							}, 3*time.Second)
+							stopFunc = client.SendMessageInterval("newt/ping/request", map[string]interface{}{}, 3*time.Second)
 							// Send registration message to the server for backward compatibility
-							bcChainId := generateChainId()
-							pendingRegisterChainId = bcChainId
 							err := client.SendMessage("newt/wg/register", map[string]interface{}{
 								"publicKey":           publicKey.String(),
 								"backwardsCompatible": true,
-								"chainId":             bcChainId,
 							})
 							if err != nil {
 								logger.Error("Failed to send registration message: %v", err)
@@ -372,62 +363,27 @@ func parseTargetData(data interface{}) (TargetData, error) {
 	return targetData, nil
 }
 
-// parseTargetString parses a target string in the format "listenPort:host:targetPort"
-// It properly handles IPv6 addresses which must be in brackets: "listenPort:[ipv6]:targetPort"
-// Examples:
-//   - IPv4: "3001:192.168.1.1:80"
-//   - IPv6: "3001:[::1]:8080" or "3001:[fd70:1452:b736:4dd5:caca:7db9:c588:f5b3]:80"
-//
-// Returns listenPort, targetAddress (in host:port format suitable for net.Dial), and error
-func parseTargetString(target string) (int, string, error) {
-	// Find the first colon to extract the listen port
-	firstColon := strings.Index(target, ":")
-	if firstColon == -1 {
-		return 0, "", fmt.Errorf("invalid target format, no colon found: %s", target)
-	}
-
-	listenPortStr := target[:firstColon]
-	var listenPort int
-	_, err := fmt.Sscanf(listenPortStr, "%d", &listenPort)
-	if err != nil {
-		return 0, "", fmt.Errorf("invalid listen port: %s", listenPortStr)
-	}
-	if listenPort <= 0 || listenPort > 65535 {
-		return 0, "", fmt.Errorf("listen port out of range: %d", listenPort)
-	}
-
-	// The remainder is host:targetPort - use net.SplitHostPort which handles IPv6 brackets
-	remainder := target[firstColon+1:]
-	host, targetPort, err := net.SplitHostPort(remainder)
-	if err != nil {
-		return 0, "", fmt.Errorf("invalid host:port format '%s': %w", remainder, err)
-	}
-
-	// Reject empty host or target port
-	if host == "" {
-		return 0, "", fmt.Errorf("empty host in target: %s", target)
-	}
-	if targetPort == "" {
-		return 0, "", fmt.Errorf("empty target port in target: %s", target)
-	}
-
-	// Reconstruct the target address using JoinHostPort (handles IPv6 properly)
-	targetAddr := net.JoinHostPort(host, targetPort)
-
-	return listenPort, targetAddr, nil
-}
-
 func updateTargets(pm *proxy.ProxyManager, action string, tunnelIP string, proto string, targetData TargetData) error {
 	for _, t := range targetData.Targets {
-		// Parse the target string, handling both IPv4 and IPv6 addresses
-		port, target, err := parseTargetString(t)
+		// Split the first number off of the target with : separator and use as the port
+		parts := strings.Split(t, ":")
+		if len(parts) != 3 {
+			logger.Info("Invalid target format: %s", t)
+			continue
+		}
+
+		// Get the port as an int
+		port := 0
+		_, err := fmt.Sscanf(parts[0], "%d", &port)
 		if err != nil {
-			logger.Info("Invalid target format: %s (%v)", t, err)
+			logger.Info("Invalid port: %s", parts[0])
 			continue
 		}
 
 		switch action {
 		case "add":
+			target := parts[1] + ":" + parts[2]
+
 			// Call updown script if provided
 			processedTarget := target
 			if updownScript != "" {
@@ -454,6 +410,8 @@ func updateTargets(pm *proxy.ProxyManager, action string, tunnelIP string, proto
 		case "remove":
 			logger.Info("Removing target with port %d", port)
 
+			target := parts[1] + ":" + parts[2]
+
 			// Call updown script if provided
 			if updownScript != "" {
 				_, err := executeUpdownScript(action, proto, target)
@@ -462,7 +420,7 @@ func updateTargets(pm *proxy.ProxyManager, action string, tunnelIP string, proto
 				}
 			}
 
-			err = pm.RemoveTarget(proto, tunnelIP, port)
+			err := pm.RemoveTarget(proto, tunnelIP, port)
 			if err != nil {
 				logger.Error("Failed to remove target: %v", err)
 				return err
@@ -517,41 +475,15 @@ func executeUpdownScript(action, proto, target string) (string, error) {
 	return target, nil
 }
 
-// interpolateBlueprint finds all {{...}} tokens in the raw blueprint bytes and
-// replaces recognised schemes with their resolved values. Currently supported:
-//
-//   - env.<VAR>  – replaced with the value of the named environment variable
-//
-// Any token that does not match a supported scheme is left as-is so that
-// future schemes (e.g. tag., api.) are preserved rather than silently dropped.
-func interpolateBlueprint(data []byte) []byte {
-	re := regexp.MustCompile(`\{\{([^}]+)\}\}`)
-	return re.ReplaceAllFunc(data, func(match []byte) []byte {
-		// strip the surrounding {{ }}
-		inner := strings.TrimSpace(string(match[2 : len(match)-2]))
-
-		if strings.HasPrefix(inner, "env.") {
-			varName := strings.TrimPrefix(inner, "env.")
-			return []byte(os.Getenv(varName))
-		}
-
-		// unrecognised scheme – leave the token untouched
-		return match
-	})
-}
-
-func sendBlueprint(client *websocket.Client, file string) error {
-	if file == "" {
+func sendBlueprint(client *websocket.Client) error {
+	if blueprintFile == "" {
 		return nil
 	}
 	// try to read the blueprint file
-	blueprintData, err := os.ReadFile(file)
+	blueprintData, err := os.ReadFile(blueprintFile)
 	if err != nil {
 		logger.Error("Failed to read blueprint file: %v", err)
 	} else {
-		// interpolate {{env.VAR}} (and any future schemes) before parsing
-		blueprintData = interpolateBlueprint(blueprintData)
-
 		// first we should convert the yaml to json and error if the yaml is bad
 		var yamlObj interface{}
 		var blueprintJsonData string

common_test.go

@@ -1,212 +0,0 @@
-package main
-
-import (
-	"net"
-	"testing"
-)
-
-func TestParseTargetString(t *testing.T) {
-	tests := []struct {
-		name           string
-		input          string
-		wantListenPort int
-		wantTargetAddr string
-		wantErr        bool
-	}{
-		// IPv4 test cases
-		{
-			name:           "valid IPv4 basic",
-			input:          "3001:192.168.1.1:80",
-			wantListenPort: 3001,
-			wantTargetAddr: "192.168.1.1:80",
-			wantErr:        false,
-		},
-		{
-			name:           "valid IPv4 localhost",
-			input:          "8080:127.0.0.1:3000",
-			wantListenPort: 8080,
-			wantTargetAddr: "127.0.0.1:3000",
-			wantErr:        false,
-		},
-		{
-			name:           "valid IPv4 same ports",
-			input:          "443:10.0.0.1:443",
-			wantListenPort: 443,
-			wantTargetAddr: "10.0.0.1:443",
-			wantErr:        false,
-		},
-
-		// IPv6 test cases
-		{
-			name:           "valid IPv6 loopback",
-			input:          "3001:[::1]:8080",
-			wantListenPort: 3001,
-			wantTargetAddr: "[::1]:8080",
-			wantErr:        false,
-		},
-		{
-			name:           "valid IPv6 full address",
-			input:          "80:[fd70:1452:b736:4dd5:caca:7db9:c588:f5b3]:8080",
-			wantListenPort: 80,
-			wantTargetAddr: "[fd70:1452:b736:4dd5:caca:7db9:c588:f5b3]:8080",
-			wantErr:        false,
-		},
-		{
-			name:           "valid IPv6 link-local",
-			input:          "443:[fe80::1]:443",
-			wantListenPort: 443,
-			wantTargetAddr: "[fe80::1]:443",
-			wantErr:        false,
-		},
-		{
-			name:           "valid IPv6 all zeros compressed",
-			input:          "8000:[::]:9000",
-			wantListenPort: 8000,
-			wantTargetAddr: "[::]:9000",
-			wantErr:        false,
-		},
-		{
-			name:           "valid IPv6 mixed notation",
-			input:          "5000:[::ffff:192.168.1.1]:6000",
-			wantListenPort: 5000,
-			wantTargetAddr: "[::ffff:192.168.1.1]:6000",
-			wantErr:        false,
-		},
-
-		// Hostname test cases
-		{
-			name:           "valid hostname",
-			input:          "8080:example.com:80",
-			wantListenPort: 8080,
-			wantTargetAddr: "example.com:80",
-			wantErr:        false,
-		},
-		{
-			name:           "valid hostname with subdomain",
-			input:          "443:api.example.com:8443",
-			wantListenPort: 443,
-			wantTargetAddr: "api.example.com:8443",
-			wantErr:        false,
-		},
-		{
-			name:           "valid localhost hostname",
-			input:          "3000:localhost:3000",
-			wantListenPort: 3000,
-			wantTargetAddr: "localhost:3000",
-			wantErr:        false,
-		},
-
-		// Error cases
-		{
-			name:    "invalid - no colons",
-			input:   "invalid",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - empty string",
-			input:   "",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - non-numeric listen port",
-			input:   "abc:192.168.1.1:80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - missing target port",
-			input:   "3001:192.168.1.1",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - IPv6 without brackets",
-			input:   "3001:fd70:1452:b736:4dd5:caca:7db9:c588:f5b3:80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - only listen port",
-			input:   "3001:",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - missing host",
-			input:   "3001::80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - IPv6 unclosed bracket",
-			input:   "3001:[::1:80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - listen port zero",
-			input:   "0:192.168.1.1:80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - listen port negative",
-			input:   "-1:192.168.1.1:80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - listen port out of range",
-			input:   "70000:192.168.1.1:80",
-			wantErr: true,
-		},
-		{
-			name:    "invalid - empty target port",
-			input:   "3001:192.168.1.1:",
-			wantErr: true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			listenPort, targetAddr, err := parseTargetString(tt.input)
-
-			if (err != nil) != tt.wantErr {
-				t.Errorf("parseTargetString(%q) error = %v, wantErr %v", tt.input, err, tt.wantErr)
-				return
-			}
-
-			if tt.wantErr {
-				return // Don't check other values if we expected an error
-			}
-
-			if listenPort != tt.wantListenPort {
-				t.Errorf("parseTargetString(%q) listenPort = %d, want %d", tt.input, listenPort, tt.wantListenPort)
-			}
-
-			if targetAddr != tt.wantTargetAddr {
-				t.Errorf("parseTargetString(%q) targetAddr = %q, want %q", tt.input, targetAddr, tt.wantTargetAddr)
-			}
-		})
-	}
-}
-
-// TestParseTargetStringNetDialCompatibility verifies that the output is compatible with net.Dial
-func TestParseTargetStringNetDialCompatibility(t *testing.T) {
-	tests := []struct {
-		name  string
-		input string
-	}{
-		{"IPv4", "8080:127.0.0.1:80"},
-		{"IPv6 loopback", "8080:[::1]:80"},
-		{"IPv6 full", "8080:[2001:db8::1]:80"},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			_, targetAddr, err := parseTargetString(tt.input)
-			if err != nil {
-				t.Fatalf("parseTargetString(%q) unexpected error: %v", tt.input, err)
-			}
-
-			// Verify the format is valid for net.Dial by checking it can be split back
-			// This doesn't actually dial, just validates the format
-			_, _, err = net.SplitHostPort(targetAddr)
-			if err != nil {
-				t.Errorf("parseTargetString(%q) produced invalid net.Dial format %q: %v", tt.input, targetAddr, err)
-			}
-		})
-	}
-}

docker-compose.yml

@@ -4,7 +4,7 @@ services:
     container_name: newt
     restart: unless-stopped
     environment:
-      - PANGOLIN_ENDPOINT=https://app.pangolin.net
+      - PANGOLIN_ENDPOINT=https://example.com
       - NEWT_ID=2ix2t8xk22ubpfy 
       - NEWT_SECRET=nnisrfsdfc7prqsp9ewo1dvtvci50j5uiqotez00dgap0ii2 
       - LOG_LEVEL=DEBUG

flake.nix

@@ -25,7 +25,7 @@
           inherit (pkgs) lib;
 
           # Update version when releasing
-          version = "1.11.0";
+          version = "1.7.0";
         in
         {
           default = self.packages.${system}.pangolin-newt;
@@ -35,28 +35,16 @@
             inherit version;
             src = pkgs.nix-gitignore.gitignoreSource [ ] ./.;
 
-            vendorHash = "sha256-+zMSzNbqmWm/DXL2xMUd5uPP5tSIybsRokwJ2zd0pf0=";
-
-            nativeInstallCheckInputs = [ pkgs.versionCheckHook ];
+            vendorHash = "sha256-5Xr6mwPtsqEliKeKv2rhhp6JC7u3coP4nnhIxGMqccU=";
 
             env = {
               CGO_ENABLED = 0;
             };
 
             ldflags = [
-              "-s"
-              "-w"
               "-X main.newtVersion=${version}"
             ];
 
-            # Tests are broken due to a lack of Internet.
-            # Disable running `go test`, and instead do
-            # a simple version check instead.
-            doCheck = false;
-            doInstallCheck = true;
-
-            versionCheckProgramArg = [ "-version" ];
-
             meta = {
               description = "A tunneling client for Pangolin";
               homepage = "https://github.com/fosrl/newt";
@@ -64,7 +52,6 @@
               maintainers = [
                 lib.maintainers.water-sucks
               ];
-              mainProgram = "newt";
             };
           };
         }

get-newt.sh

@@ -1,7 +1,7 @@
-#!/bin/sh
+#!/bin/bash
 
 # Get Newt - Cross-platform installation script
-# Usage: curl -fsSL https://raw.githubusercontent.com/fosrl/newt/refs/heads/main/get-newt.sh | sh
+# Usage: curl -fsSL https://raw.githubusercontent.com/fosrl/newt/refs/heads/main/get-newt.sh | bash
 
 set -e
 
@@ -17,51 +17,54 @@ GITHUB_API_URL="https://api.github.com/repos/${REPO}/releases/latest"
 
 # Function to print colored output
 print_status() {
-    printf '%b[INFO]%b %s\n' "${GREEN}" "${NC}" "$1"
+    echo -e "${GREEN}[INFO]${NC} $1"
 }
 
 print_warning() {
-    printf '%b[WARN]%b %s\n' "${YELLOW}" "${NC}" "$1"
+    echo -e "${YELLOW}[WARN]${NC} $1"
 }
 
 print_error() {
-    printf '%b[ERROR]%b %s\n' "${RED}" "${NC}" "$1"
+    echo -e "${RED}[ERROR]${NC} $1"
 }
 
 # Function to get latest version from GitHub API
 get_latest_version() {
-    latest_info=""
-
+    local latest_info
+    
     if command -v curl >/dev/null 2>&1; then
         latest_info=$(curl -fsSL "$GITHUB_API_URL" 2>/dev/null)
     elif command -v wget >/dev/null 2>&1; then
         latest_info=$(wget -qO- "$GITHUB_API_URL" 2>/dev/null)
     else
-        print_error "Neither curl nor wget is available."
+        print_error "Neither curl nor wget is available. Please install one of them." >&2
         exit 1
     fi
-
+    
     if [ -z "$latest_info" ]; then
-        print_error "Failed to fetch latest version info"
+        print_error "Failed to fetch latest version information" >&2
         exit 1
     fi
-
-    version=$(printf '%s' "$latest_info" | grep '"tag_name"' | head -1 | sed 's/.*"tag_name": *"\([^"]*\)".*/\1/')
-
+    
+    # Extract version from JSON response (works without jq)
+    local version=$(echo "$latest_info" | grep '"tag_name"' | head -1 | sed 's/.*"tag_name": *"\([^"]*\)".*/\1/')
+    
     if [ -z "$version" ]; then
-        print_error "Could not parse version from GitHub API response"
+        print_error "Could not parse version from GitHub API response" >&2
         exit 1
     fi
-
-    version=$(printf '%s' "$version" | sed 's/^v//')
-    printf '%s' "$version"
+    
+    # Remove 'v' prefix if present
+    version=$(echo "$version" | sed 's/^v//')
+    
+    echo "$version"
 }
 
 # Detect OS and architecture
 detect_platform() {
-    os=""
-    arch=""
-
+    local os arch
+    
+    # Detect OS
     case "$(uname -s)" in
         Linux*)     os="linux" ;;
         Darwin*)    os="darwin" ;;
@@ -72,11 +75,12 @@ detect_platform() {
             exit 1
             ;;
     esac
-
+    
+    # Detect architecture
     case "$(uname -m)" in
         x86_64|amd64)   arch="amd64" ;;
         arm64|aarch64)  arch="arm64" ;;
-        armv7l|armv6l)
+        armv7l|armv6l)  
             if [ "$os" = "linux" ]; then
                 if [ "$(uname -m)" = "armv6l" ]; then
                     arch="arm32v6"
@@ -84,10 +88,10 @@ detect_platform() {
                     arch="arm32"
                 fi
             else
-                arch="arm64"
+                arch="arm64"  # Default for non-Linux ARM
             fi
             ;;
-        riscv64)
+        riscv64)        
             if [ "$os" = "linux" ]; then
                 arch="riscv64"
             else
@@ -100,166 +104,90 @@ detect_platform() {
             exit 1
             ;;
     esac
-
-    printf '%s_%s' "$os" "$arch"
+    
+    echo "${os}_${arch}"
 }
 
-# Determine installation directory (default fallback)
+# Get installation directory
 get_install_dir() {
-    case "$PLATFORM" in
-        *windows*)
-            echo "$HOME/bin"
-            ;;
-        *)
-            echo "/usr/local/bin"
-            ;;
-    esac
-}
-
-# Parse --path argument from args
-# Returns the value after --path, or empty string if not provided
-parse_path_arg() {
-    while [ $# -gt 0 ]; do
-        case "$1" in
-            --path)
-                if [ -n "$2" ]; then
-                    printf '%s' "$2"
-                    return
-                fi
-                ;;
-            --path=*)
-                printf '%s' "${1#--path=}"
-                return
-                ;;
-        esac
-        shift
-    done
-}
-
-# Detect an existing newt binary location.
-# Tries unprivileged which first, then sudo which (for binaries only visible to root).
-# Returns the full path of the binary, or empty string if not found.
-detect_existing_binary() {
-    existing=""
-
-    # Try unprivileged which first
-    existing=$(command -v newt 2>/dev/null || true)
-    if [ -n "$existing" ]; then
-        printf '%s' "$existing"
-        return
-    fi
-
-    # Try sudo which — some installations land in paths only root can see in $PATH
-    if command -v sudo >/dev/null 2>&1; then
-        existing=$(sudo which newt 2>/dev/null || true)
-        if [ -n "$existing" ]; then
-            printf '%s' "$existing"
-            return
-        fi
-    fi
-}
-
-# Check if we need sudo for installation
-needs_sudo() {
-    install_dir="$1"
-    if [ -w "$install_dir" ] 2>/dev/null; then
-        return 1  # No sudo needed
+    if [ "$OS" = "windows" ]; then
+        echo "$HOME/bin"
     else
-        return 0  # Sudo needed
-    fi
-}
-
-# Get the appropriate command prefix (sudo or empty)
-get_sudo_cmd() {
-    install_dir="$1"
-    if needs_sudo "$install_dir"; then
-        if command -v sudo >/dev/null 2>&1; then
-            echo "sudo"
+        # Try to use a directory in PATH, fallback to ~/.local/bin
+        if echo "$PATH" | grep -q "/usr/local/bin"; then
+            if [ -w "/usr/local/bin" ] 2>/dev/null; then
+                echo "/usr/local/bin"
+            else
+                echo "$HOME/.local/bin"
+            fi
         else
-            print_error "Cannot write to ${install_dir} and sudo is not available."
-            print_error "Please run this script as root or install sudo."
-            exit 1
+            echo "$HOME/.local/bin"
         fi
-    else
-        echo ""
     fi
 }
 
 # Download and install newt
 install_newt() {
-    platform="$1"
-    install_dir="$2"
-    sudo_cmd="$3"
-    custom_path="$4"
-    binary_name="newt_${platform}"
-    final_name="newt"
-
-    case "$platform" in
-        *windows*)
-            binary_name="${binary_name}.exe"
-            final_name="newt.exe"
-            ;;
-    esac
-
-    download_url="${BASE_URL}/${binary_name}"
-    temp_file="/tmp/${final_name}"
-
-    # If a custom path is provided, use it directly; otherwise use install_dir/final_name
-    if [ -n "$custom_path" ]; then
-        final_path="$custom_path"
-        install_dir=$(dirname "$final_path")
-    else
-        final_path="${install_dir}/${final_name}"
+    local platform="$1"
+    local install_dir="$2"
+    local binary_name="newt_${platform}"
+    local exe_suffix=""
+    
+    # Add .exe suffix for Windows
+    if [[ "$platform" == *"windows"* ]]; then
+        binary_name="${binary_name}.exe"
+        exe_suffix=".exe"
     fi
-
+    
+    local download_url="${BASE_URL}/${binary_name}"
+    local temp_file="/tmp/newt${exe_suffix}"
+    local final_path="${install_dir}/newt${exe_suffix}"
+    
     print_status "Downloading newt from ${download_url}"
-
+    
+    # Download the binary
     if command -v curl >/dev/null 2>&1; then
         curl -fsSL "$download_url" -o "$temp_file"
     elif command -v wget >/dev/null 2>&1; then
         wget -q "$download_url" -O "$temp_file"
     else
-        print_error "Neither curl nor wget is available."
+        print_error "Neither curl nor wget is available. Please install one of them."
         exit 1
     fi
-
-    # Make executable before moving
-    chmod +x "$temp_file"
-
-    # Create install directory if it doesn't exist and move binary
-    if [ -n "$sudo_cmd" ]; then
-        $sudo_cmd mkdir -p "$install_dir"
-        print_status "Using sudo to install to ${install_dir}"
-        $sudo_cmd mv "$temp_file" "$final_path"
-    else
-        mkdir -p "$install_dir"
-        mv "$temp_file" "$final_path"
-    fi
-
+    
+    # Create install directory if it doesn't exist
+    mkdir -p "$install_dir"
+    
+    # Move binary to install directory
+    mv "$temp_file" "$final_path"
+    
+    # Make executable (not needed on Windows, but doesn't hurt)
+    chmod +x "$final_path"
+    
     print_status "newt installed to ${final_path}"
-
+    
     # Check if install directory is in PATH
     if ! echo "$PATH" | grep -q "$install_dir"; then
         print_warning "Install directory ${install_dir} is not in your PATH."
-        print_warning "Add it with:"
+        print_warning "Add it to your PATH by adding this line to your shell profile:"
         print_warning "  export PATH=\"${install_dir}:\$PATH\""
     fi
 }
 
 # Verify installation
 verify_installation() {
-    install_dir="$1"
-    exe_suffix=""
-
-    case "$PLATFORM" in
-        *windows*) exe_suffix=".exe" ;;
-    esac
-
-    newt_path="${install_dir}/newt${exe_suffix}"
-
-    if [ -x "$newt_path" ]; then
+    local install_dir="$1"
+    local exe_suffix=""
+    
+    if [[ "$PLATFORM" == *"windows"* ]]; then
+        exe_suffix=".exe"
+    fi
+    
+    local newt_path="${install_dir}/newt${exe_suffix}"
+    
+    if [ -f "$newt_path" ] && [ -x "$newt_path" ]; then
         print_status "Installation successful!"
-        print_status "newt version: $("$newt_path" --version 2>/dev/null || printf 'unknown')"
+        print_status "newt version: $("$newt_path" --version 2>/dev/null || echo "unknown")"
         return 0
     else
         print_error "Installation failed. Binary not found or not executable."
@@ -269,62 +197,35 @@ verify_installation() {
 
 # Main installation process
 main() {
-    # --path explicitly overrides everything
-    CUSTOM_PATH=$(parse_path_arg "$@")
-
-    if [ -n "$CUSTOM_PATH" ]; then
-        print_status "Installing latest version of newt to ${CUSTOM_PATH} (--path override)..."
-    else
-        print_status "Installing latest version of newt..."
-    fi
-
-    print_status "Fetching latest version..."
+    print_status "Installing latest version of newt..."
+    
+    # Get latest version
+    print_status "Fetching latest version from GitHub..."
     VERSION=$(get_latest_version)
     print_status "Latest version: v${VERSION}"
-
+    
+    # Set base URL with the fetched version
     BASE_URL="https://github.com/${REPO}/releases/download/${VERSION}"
-
+    
+    # Detect platform
     PLATFORM=$(detect_platform)
     print_status "Detected platform: ${PLATFORM}"
-
-    if [ -n "$CUSTOM_PATH" ]; then
-        # --path wins; derive INSTALL_DIR from it
-        INSTALL_DIR=$(dirname "$CUSTOM_PATH")
-    else
-        # Try to find an existing installation so we update the right place
-        EXISTING_BINARY=$(detect_existing_binary)
-        if [ -n "$EXISTING_BINARY" ]; then
-            print_status "Found existing newt binary at ${EXISTING_BINARY}"
-            CUSTOM_PATH="$EXISTING_BINARY"
-            INSTALL_DIR=$(dirname "$EXISTING_BINARY")
-            print_status "Will update existing installation at ${INSTALL_DIR}"
-        else
-            INSTALL_DIR=$(get_install_dir)
-        fi
-    fi
-
+    
+    # Get install directory
+    INSTALL_DIR=$(get_install_dir)
     print_status "Install directory: ${INSTALL_DIR}"
-
-    # Check if we need sudo
-    SUDO_CMD=$(get_sudo_cmd "$INSTALL_DIR")
-    if [ -n "$SUDO_CMD" ]; then
-        print_status "Root privileges required for installation to ${INSTALL_DIR}"
-    fi
-
-    install_newt "$PLATFORM" "$INSTALL_DIR" "$SUDO_CMD" "$CUSTOM_PATH"
-
-    if [ -n "$CUSTOM_PATH" ]; then
-        if [ -x "$CUSTOM_PATH" ]; then
-            print_status "Installation successful!"
-            print_status "newt version: $("$CUSTOM_PATH" --version 2>/dev/null || printf 'unknown')"
-            print_status "newt is ready to use!"
-        else
-            print_error "Installation failed. Binary not found or not executable at ${CUSTOM_PATH}."
-            exit 1
-        fi
-    elif verify_installation "$INSTALL_DIR"; then
+    
+    # Install newt
+    install_newt "$PLATFORM" "$INSTALL_DIR"
+    
+    # Verify installation
+    if verify_installation "$INSTALL_DIR"; then
         print_status "newt is ready to use!"
-        print_status "Run 'newt --help' to get started."
+        if [[ "$PLATFORM" == *"windows"* ]]; then
+            print_status "Run 'newt --help' to get started"
+        else
+            print_status "Run 'newt --help' to get started"
+        fi
     else
         exit 1
     fi

go.mod

@@ -1,33 +1,32 @@
 module github.com/fosrl/newt
 
-go 1.25.0
+go 1.25
 
 require (
 	github.com/docker/docker v28.5.2+incompatible
-	github.com/gaissmai/bart v0.26.1
 	github.com/gorilla/websocket v1.5.3
 	github.com/prometheus/client_golang v1.23.2
 	github.com/vishvananda/netlink v1.3.1
-	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0
-	go.opentelemetry.io/contrib/instrumentation/runtime v0.68.0
-	go.opentelemetry.io/otel v1.43.0
-	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0
-	go.opentelemetry.io/otel/exporters/prometheus v0.65.0
-	go.opentelemetry.io/otel/metric v1.43.0
-	go.opentelemetry.io/otel/sdk v1.43.0
-	go.opentelemetry.io/otel/sdk/metric v1.43.0
-	golang.org/x/crypto v0.49.0
+	go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0
+	go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0
+	go.opentelemetry.io/otel v1.38.0
+	go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0
+	go.opentelemetry.io/otel/exporters/prometheus v0.60.0
+	go.opentelemetry.io/otel/metric v1.38.0
+	go.opentelemetry.io/otel/sdk v1.38.0
+	go.opentelemetry.io/otel/sdk/metric v1.38.0
+	golang.org/x/crypto v0.45.0
 	golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6
-	golang.org/x/net v0.52.0
-	golang.org/x/sys v0.42.0
+	golang.org/x/net v0.47.0
+	golang.org/x/sys v0.38.0
 	golang.zx2c4.com/wireguard v0.0.0-20250521234502-f333402bd9cb
 	golang.zx2c4.com/wireguard/wgctrl v0.0.0-20241231184526-a9ab2273dd10
 	golang.zx2c4.com/wireguard/windows v0.5.3
-	google.golang.org/grpc v1.80.0
+	google.golang.org/grpc v1.76.0
 	gopkg.in/yaml.v3 v3.0.1
 	gvisor.dev/gvisor v0.0.0-20250503011706-39ed1f5ac29c
-	software.sslmate.com/src/go-pkcs12 v0.7.0
+	software.sslmate.com/src/go-pkcs12 v0.6.0
 )
 
 require (
@@ -45,7 +44,8 @@ require (
 	github.com/go-logr/stdr v1.2.2 // indirect
 	github.com/google/btree v1.1.3 // indirect
 	github.com/google/uuid v1.6.0 // indirect
-	github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 // indirect
+	github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc // indirect
+	github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 // indirect
 	github.com/moby/docker-image-spec v1.3.1 // indirect
 	github.com/moby/sys/atomicwriter v0.1.0 // indirect
 	github.com/moby/term v0.5.2 // indirect
@@ -55,23 +55,23 @@ require (
 	github.com/opencontainers/image-spec v1.1.0 // indirect
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/prometheus/client_model v0.6.2 // indirect
-	github.com/prometheus/common v0.67.5 // indirect
-	github.com/prometheus/otlptranslator v1.0.0 // indirect
-	github.com/prometheus/procfs v0.20.1 // indirect
+	github.com/prometheus/common v0.66.1 // indirect
+	github.com/prometheus/otlptranslator v0.0.2 // indirect
+	github.com/prometheus/procfs v0.17.0 // indirect
 	github.com/vishvananda/netns v0.0.5 // indirect
-	go.opentelemetry.io/auto/sdk v1.2.1 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 // indirect
-	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 // indirect
-	go.opentelemetry.io/otel/trace v1.43.0 // indirect
-	go.opentelemetry.io/proto/otlp v1.10.0 // indirect
-	go.yaml.in/yaml/v2 v2.4.4 // indirect
-	golang.org/x/mod v0.33.0 // indirect
-	golang.org/x/sync v0.20.0 // indirect
-	golang.org/x/text v0.35.0 // indirect
+	go.opentelemetry.io/auto/sdk v1.1.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 // indirect
+	go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 // indirect
+	go.opentelemetry.io/otel/trace v1.38.0 // indirect
+	go.opentelemetry.io/proto/otlp v1.7.1 // indirect
+	go.yaml.in/yaml/v2 v2.4.2 // indirect
+	golang.org/x/mod v0.30.0 // indirect
+	golang.org/x/sync v0.18.0 // indirect
+	golang.org/x/text v0.31.0 // indirect
 	golang.org/x/time v0.12.0 // indirect
-	golang.org/x/tools v0.42.0 // indirect
+	golang.org/x/tools v0.39.0 // indirect
 	golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 // indirect
-	google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 // indirect
-	google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 // indirect
-	google.golang.org/protobuf v1.36.11 // indirect
+	google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 // indirect
+	google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 // indirect
+	google.golang.org/protobuf v1.36.8 // indirect
 )

go.sum

@@ -26,8 +26,6 @@ github.com/docker/go-units v0.4.0 h1:3uh0PgVws3nIA0Q+MwDC8yjEPf9zjRfZZWXZYDct3Tw
 github.com/docker/go-units v0.4.0/go.mod h1:fgPhTUdO+D/Jk86RDLlptpiXQzgHJF7gydDDbaIK4Dk=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
-github.com/gaissmai/bart v0.26.1 h1:+w4rnLGNlA2GDVn382Tfe3jOsK5vOr5n4KmigJ9lbTo=
-github.com/gaissmai/bart v0.26.1/go.mod h1:GREWQfTLRWz/c5FTOsIw+KkscuFkIV5t8Rp7Nd1Td5c=
 github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A=
 github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI=
 github.com/go-logr/logr v1.4.3/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY=
@@ -43,8 +41,10 @@ github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
 github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
 github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0 h1:HWRh5R2+9EifMyIHV7ZV+MIZqgz+PMpZ14Jynv3O2Zs=
-github.com/grpc-ecosystem/grpc-gateway/v2 v2.28.0/go.mod h1:JfhWUomR1baixubs02l85lZYYOm7LV6om4ceouMv45c=
+github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc h1:GN2Lv3MGO7AS6PrRoT6yV5+wkrOpcszoIsO4+4ds248=
+github.com/grafana/regexp v0.0.0-20240518133315-a468a5bfb3bc/go.mod h1:+JKpmjMGhpgPL+rXZ5nsZieVzvarn86asRlBg4uNGnk=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2 h1:8Tjv8EJ+pM1xP8mK6egEbD1OgnVTyacbefKhmbLhIhU=
+github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.2/go.mod h1:pkJQ2tZHJ0aFOVEEot6oZmaVEZcRme73eIFmhiVuRWs=
 github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
 github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=
 github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -77,14 +77,14 @@ github.com/prometheus/client_golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h
 github.com/prometheus/client_golang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=
 github.com/prometheus/client_model v0.6.2 h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=
 github.com/prometheus/client_model v0.6.2/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE=
-github.com/prometheus/common v0.67.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGI4=
-github.com/prometheus/common v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw=
-github.com/prometheus/otlptranslator v1.0.0 h1:s0LJW/iN9dkIH+EnhiD3BlkkP5QVIUVEoIwkU+A6qos=
-github.com/prometheus/otlptranslator v1.0.0/go.mod h1:vRYWnXvI6aWGpsdY/mOT/cbeVRBlPWtBNDb7kGR3uKM=
-github.com/prometheus/procfs v0.20.1 h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc=
-github.com/prometheus/procfs v0.20.1/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo=
-github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
-github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
+github.com/prometheus/common v0.66.1 h1:h5E0h5/Y8niHc5DlaLlWLArTQI7tMrsfQjHV+d9ZoGs=
+github.com/prometheus/common v0.66.1/go.mod h1:gcaUsgf3KfRSwHY4dIMXLPV0K/Wg1oZ8+SbZk/HH/dA=
+github.com/prometheus/otlptranslator v0.0.2 h1:+1CdeLVrRQ6Psmhnobldo0kTp96Rj80DRXRd5OSnMEQ=
+github.com/prometheus/otlptranslator v0.0.2/go.mod h1:P8AwMgdD7XEr6QRUJ2QWLpiAZTgTE2UYgjlu3svompI=
+github.com/prometheus/procfs v0.17.0 h1:FuLQ+05u4ZI+SS/w9+BWEM2TXiHKsUQ9TADiRH7DuK0=
+github.com/prometheus/procfs v0.17.0/go.mod h1:oPQLaDAMRbA+u8H5Pbfq+dl3VDAvHxMUOVhe0wYB2zw=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
 github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
@@ -93,58 +93,58 @@ github.com/vishvananda/netlink v1.3.1 h1:3AEMt62VKqz90r0tmNhog0r/PpWKmrEShJU0wJW
 github.com/vishvananda/netlink v1.3.1/go.mod h1:ARtKouGSTGchR8aMwmkzC0qiNPrrWO5JS/XMVl45+b4=
 github.com/vishvananda/netns v0.0.5 h1:DfiHV+j8bA32MFM7bfEunvT8IAqQ/NzSJHtcmW5zdEY=
 github.com/vishvananda/netns v0.0.5/go.mod h1:SpkAiCQRtJ6TvvxPnOSyH3BMl6unz3xZlaprSwhNNJM=
-go.opentelemetry.io/auto/sdk v1.2.1 h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64=
-go.opentelemetry.io/auto/sdk v1.2.1/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0 h1:CqXxU8VOmDefoh0+ztfGaymYbhdB/tT3zs79QaZTNGY=
-go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.68.0/go.mod h1:BuhAPThV8PBHBvg8ZzZ/Ok3idOdhWIodywz2xEcRbJo=
-go.opentelemetry.io/contrib/instrumentation/runtime v0.68.0 h1:jhVIQEprwUTV+KfzzliLidclhoTOoHTgdz96kAyR8mU=
-go.opentelemetry.io/contrib/instrumentation/runtime v0.68.0/go.mod h1:4HsdbLUbernaTnA8CNaNE+1g026SciXb3juRYe3l8EY=
-go.opentelemetry.io/otel v1.43.0 h1:mYIM03dnh5zfN7HautFE4ieIig9amkNANT+xcVxAj9I=
-go.opentelemetry.io/otel v1.43.0/go.mod h1:JuG+u74mvjvcm8vj8pI5XiHy1zDeoCS2LB1spIq7Ay0=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0 h1:8UQVDcZxOJLtX6gxtDt3vY2WTgvZqMQRzjsqiIHQdkc=
-go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.43.0/go.mod h1:2lmweYCiHYpEjQ/lSJBYhj9jP1zvCvQW4BqL9dnT7FQ=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0 h1:88Y4s2C8oTui1LGM6bTWkw0ICGcOLCAI5l6zsD1j20k=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.43.0/go.mod h1:Vl1/iaggsuRlrHf/hfPJPvVag77kKyvrLeD10kpMl+A=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0 h1:RAE+JPfvEmvy+0LzyUA25/SGawPwIUbZ6u0Wug54sLc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.43.0/go.mod h1:AGmbycVGEsRx9mXMZ75CsOyhSP6MFIcj/6dnG+vhVjk=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0 h1:3iZJKlCZufyRzPzlQhUIWVmfltrXuGyfjREgGP3UUjc=
-go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.43.0/go.mod h1:/G+nUPfhq2e+qiXMGxMwumDrP5jtzU+mWN7/sjT2rak=
-go.opentelemetry.io/otel/exporters/prometheus v0.65.0 h1:jOveH/b4lU9HT7y+Gfamf18BqlOuz2PWEvs8yM7Q6XE=
-go.opentelemetry.io/otel/exporters/prometheus v0.65.0/go.mod h1:i1P8pcumauPtUI4YNopea1dhzEMuEqWP1xoUZDylLHo=
-go.opentelemetry.io/otel/metric v1.43.0 h1:d7638QeInOnuwOONPp4JAOGfbCEpYb+K6DVWvdxGzgM=
-go.opentelemetry.io/otel/metric v1.43.0/go.mod h1:RDnPtIxvqlgO8GRW18W6Z/4P462ldprJtfxHxyKd2PY=
-go.opentelemetry.io/otel/sdk v1.43.0 h1:pi5mE86i5rTeLXqoF/hhiBtUNcrAGHLKQdhg4h4V9Dg=
-go.opentelemetry.io/otel/sdk v1.43.0/go.mod h1:P+IkVU3iWukmiit/Yf9AWvpyRDlUeBaRg6Y+C58QHzg=
-go.opentelemetry.io/otel/sdk/metric v1.43.0 h1:S88dyqXjJkuBNLeMcVPRFXpRw2fuwdvfCGLEo89fDkw=
-go.opentelemetry.io/otel/sdk/metric v1.43.0/go.mod h1:C/RJtwSEJ5hzTiUz5pXF1kILHStzb9zFlIEe85bhj6A=
-go.opentelemetry.io/otel/trace v1.43.0 h1:BkNrHpup+4k4w+ZZ86CZoHHEkohws8AY+WTX09nk+3A=
-go.opentelemetry.io/otel/trace v1.43.0/go.mod h1:/QJhyVBUUswCphDVxq+8mld+AvhXZLhe+8WVFxiFff0=
-go.opentelemetry.io/proto/otlp v1.10.0 h1:IQRWgT5srOCYfiWnpqUYz9CVmbO8bFmKcwYxpuCSL2g=
-go.opentelemetry.io/proto/otlp v1.10.0/go.mod h1:/CV4QoCR/S9yaPj8utp3lvQPoqMtxXdzn7ozvvozVqk=
+go.opentelemetry.io/auto/sdk v1.1.0 h1:cH53jehLUN6UFLY71z+NDOiNJqDdPRaXzTel0sJySYA=
+go.opentelemetry.io/auto/sdk v1.1.0/go.mod h1:3wSPjt5PWp2RhlCcmmOial7AvC4DQqZb7a7wCow3W8A=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0 h1:RbKq8BG0FI8OiXhBfcRtqqHcZcka+gU3cskNuf05R18=
+go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.63.0/go.mod h1:h06DGIukJOevXaj/xrNjhi/2098RZzcLTbc0jDAUbsg=
+go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0 h1:PeBoRj6af6xMI7qCupwFvTbbnd49V7n5YpG6pg8iDYQ=
+go.opentelemetry.io/contrib/instrumentation/runtime v0.63.0/go.mod h1:ingqBCtMCe8I4vpz/UVzCW6sxoqgZB37nao91mLQ3Bw=
+go.opentelemetry.io/otel v1.38.0 h1:RkfdswUDRimDg0m2Az18RKOsnI8UDzppJAtj01/Ymk8=
+go.opentelemetry.io/otel v1.38.0/go.mod h1:zcmtmQ1+YmQM9wrNsTGV/q/uyusom3P8RxwExxkZhjM=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0 h1:vl9obrcoWVKp/lwl8tRE33853I8Xru9HFbw/skNeLs8=
+go.opentelemetry.io/otel/exporters/otlp/otlpmetric/otlpmetricgrpc v1.38.0/go.mod h1:GAXRxmLJcVM3u22IjTg74zWBrRCKq8BnOqUVLodpcpw=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0 h1:GqRJVj7UmLjCVyVJ3ZFLdPRmhDUp2zFmQe3RHIOsw24=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace v1.38.0/go.mod h1:ri3aaHSmCTVYu2AWv44YMauwAQc0aqI9gHKIcSbI1pU=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0 h1:lwI4Dc5leUqENgGuQImwLo4WnuXFPetmPpkLi2IrX54=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc v1.38.0/go.mod h1:Kz/oCE7z5wuyhPxsXDuaPteSWqjSBD5YaSdbxZYGbGk=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0 h1:aTL7F04bJHUlztTsNGJ2l+6he8c+y/b//eR0jjjemT4=
+go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracehttp v1.38.0/go.mod h1:kldtb7jDTeol0l3ewcmd8SDvx3EmIE7lyvqbasU3QC4=
+go.opentelemetry.io/otel/exporters/prometheus v0.60.0 h1:cGtQxGvZbnrWdC2GyjZi0PDKVSLWP/Jocix3QWfXtbo=
+go.opentelemetry.io/otel/exporters/prometheus v0.60.0/go.mod h1:hkd1EekxNo69PTV4OWFGZcKQiIqg0RfuWExcPKFvepk=
+go.opentelemetry.io/otel/metric v1.38.0 h1:Kl6lzIYGAh5M159u9NgiRkmoMKjvbsKtYRwgfrA6WpA=
+go.opentelemetry.io/otel/metric v1.38.0/go.mod h1:kB5n/QoRM8YwmUahxvI3bO34eVtQf2i4utNVLr9gEmI=
+go.opentelemetry.io/otel/sdk v1.38.0 h1:l48sr5YbNf2hpCUj/FoGhW9yDkl+Ma+LrVl8qaM5b+E=
+go.opentelemetry.io/otel/sdk v1.38.0/go.mod h1:ghmNdGlVemJI3+ZB5iDEuk4bWA3GkTpW+DOoZMYBVVg=
+go.opentelemetry.io/otel/sdk/metric v1.38.0 h1:aSH66iL0aZqo//xXzQLYozmWrXxyFkBJ6qT5wthqPoM=
+go.opentelemetry.io/otel/sdk/metric v1.38.0/go.mod h1:dg9PBnW9XdQ1Hd6ZnRz689CbtrUp0wMMs9iPcgT9EZA=
+go.opentelemetry.io/otel/trace v1.38.0 h1:Fxk5bKrDZJUH+AMyyIXGcFAPah0oRcT+LuNtJrmcNLE=
+go.opentelemetry.io/otel/trace v1.38.0/go.mod h1:j1P9ivuFsTceSWe1oY+EeW3sc+Pp42sO++GHkg4wwhs=
+go.opentelemetry.io/proto/otlp v1.7.1 h1:gTOMpGDb0WTBOP8JaO72iL3auEZhVmAQg4ipjOVAtj4=
+go.opentelemetry.io/proto/otlp v1.7.1/go.mod h1:b2rVh6rfI/s2pHWNlB7ILJcRALpcNDzKhACevjI+ZnE=
 go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto=
 go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE=
-go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ=
-go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ=
-golang.org/x/crypto v0.49.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4=
-golang.org/x/crypto v0.49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCA=
+go.yaml.in/yaml/v2 v2.4.2 h1:DzmwEr2rDGHl7lsFgAHxmNz/1NlQ7xLIrlN2h5d1eGI=
+go.yaml.in/yaml/v2 v2.4.2/go.mod h1:081UH+NErpNdqlCXm3TtEran0rJZGxAYx9hb/ELlsPU=
+golang.org/x/crypto v0.45.0 h1:jMBrvKuj23MTlT0bQEOBcAE0mjg8mK9RXFhRH6nyF3Q=
+golang.org/x/crypto v0.45.0/go.mod h1:XTGrrkGJve7CYK7J8PEww4aY7gM3qMCElcJQ8n8JdX4=
 golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6 h1:zfMcR1Cs4KNuomFFgGefv5N0czO2XZpUbxGUy8i8ug0=
 golang.org/x/exp v0.0.0-20251113190631-e25ba8c21ef6/go.mod h1:46edojNIoXTNOhySWIWdix628clX9ODXwPsQuG6hsK0=
-golang.org/x/mod v0.33.0 h1:tHFzIWbBifEmbwtGz65eaWyGiGZatSrT9prnU8DbVL8=
-golang.org/x/mod v0.33.0/go.mod h1:swjeQEj+6r7fODbD2cqrnje9PnziFuw4bmLbBZFrQ5w=
-golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0=
-golang.org/x/net v0.52.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36Sw=
-golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4=
-golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0=
+golang.org/x/mod v0.30.0 h1:fDEXFVZ/fmCKProc/yAXXUijritrDzahmwwefnjoPFk=
+golang.org/x/mod v0.30.0/go.mod h1:lAsf5O2EvJeSFMiBxXDki7sCgAxEUcZHXoXMKT4GJKc=
+golang.org/x/net v0.47.0 h1:Mx+4dIFzqraBXUugkia1OOvlD6LemFo1ALMHjrXDOhY=
+golang.org/x/net v0.47.0/go.mod h1:/jNxtkgq5yWUGYkaZGqo27cfGZ1c5Nen03aYrrKpVRU=
+golang.org/x/sync v0.18.0 h1:kr88TuHDroi+UVf+0hZnirlk8o8T+4MrK6mr60WkH/I=
+golang.org/x/sync v0.18.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
 golang.org/x/sys v0.2.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.10.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.42.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeo=
-golang.org/x/sys v0.42.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
-golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8=
-golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA=
+golang.org/x/sys v0.38.0 h1:3yZWxaJjBmCWXqhN1qh02AkOnCQ1poK6oF+a7xWL6Gc=
+golang.org/x/sys v0.38.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
+golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
+golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=
 golang.org/x/time v0.12.0 h1:ScB/8o8olJvc+CQPWrK3fPZNfh7qgwCrY0zJmoEQLSE=
 golang.org/x/time v0.12.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
-golang.org/x/tools v0.42.0 h1:uNgphsn75Tdz5Ji2q36v/nsFSfR/9BRFvqhGBaJGd5k=
-golang.org/x/tools v0.42.0/go.mod h1:Ma6lCIwGZvHK6XtgbswSoWroEkhugApmsXyrUmBhfr0=
+golang.org/x/tools v0.39.0 h1:ik4ho21kwuQln40uelmciQPp9SipgNDdrafrYA4TmQQ=
+golang.org/x/tools v0.39.0/go.mod h1:JnefbkDPyD8UU2kI5fuf8ZX4/yUeh9W877ZeBONxUqQ=
 golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2 h1:B82qJJgjvYKsXS9jeunTOisW56dUokqW/FOteYJJ/yg=
 golang.zx2c4.com/wintun v0.0.0-20230126152724-0fa3db229ce2/go.mod h1:deeaetjYA+DHMHg+sMSMI58GrEteJUUzzw7en6TJQcI=
 golang.zx2c4.com/wireguard v0.0.0-20250521234502-f333402bd9cb h1:whnFRlWMcXI9d+ZbWg+4sHnLp52d5yiIPUxMBSt4X9A=
@@ -153,16 +153,16 @@ golang.zx2c4.com/wireguard/wgctrl v0.0.0-20241231184526-a9ab2273dd10 h1:3GDAcqdI
 golang.zx2c4.com/wireguard/wgctrl v0.0.0-20241231184526-a9ab2273dd10/go.mod h1:T97yPqesLiNrOYxkwmhMI0ZIlJDm+p0PMR8eRVeR5tQ=
 golang.zx2c4.com/wireguard/windows v0.5.3 h1:On6j2Rpn3OEMXqBq00QEDC7bWSZrPIHKIus8eIuExIE=
 golang.zx2c4.com/wireguard/windows v0.5.3/go.mod h1:9TEe8TJmtwyQebdFwAkEWOPr3prrtqm+REGFifP60hI=
-gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4=
-gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E=
-google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 h1:VPWxll4HlMw1Vs/qXtN7BvhZqsS9cdAittCNvVENElA=
-google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:7QBABkRtR8z+TEnmXTqIqwJLlzrZKVfAUm7tY3yGv0M=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg=
-google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8=
-google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM=
-google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4=
-google.golang.org/protobuf v1.36.11 h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE=
-google.golang.org/protobuf v1.36.11/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=
+gonum.org/v1/gonum v0.16.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfk=
+gonum.org/v1/gonum v0.16.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5 h1:BIRfGDEjiHRrk0QKZe3Xv2ieMhtgRGeLcZQ0mIVn4EY=
+google.golang.org/genproto/googleapis/api v0.0.0-20250825161204-c5933d9347a5/go.mod h1:j3QtIyytwqGr1JUDtYXwtMXWPKsEa5LtzIFN1Wn5WvE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5 h1:eaY8u2EuxbRv7c3NiGK0/NedzVsCcV6hDuU5qPX5EGE=
+google.golang.org/genproto/googleapis/rpc v0.0.0-20250825161204-c5933d9347a5/go.mod h1:M4/wBTSeyLxupu3W3tJtOgB14jILAS/XWPSSa3TAlJc=
+google.golang.org/grpc v1.76.0 h1:UnVkv1+uMLYXoIz6o7chp59WfQUYA2ex/BXQ9rHZu7A=
+google.golang.org/grpc v1.76.0/go.mod h1:Ju12QI8M6iQJtbcsV+awF5a4hfJMLi4X0JLo94ULZ6c=
+google.golang.org/protobuf v1.36.8 h1:xHScyCOEuuwZEc6UtSOvPbAT4zRh0xcNRYekJwfqyMc=
+google.golang.org/protobuf v1.36.8/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
 gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
@@ -172,5 +172,5 @@ gotest.tools/v3 v3.4.0 h1:ZazjZUfuVeZGLAmlKKuyv3IKP5orXcwtOwDQH6YVr6o=
 gotest.tools/v3 v3.4.0/go.mod h1:CtbdzLSsqVhDgMtKsx03ird5YTGB3ar27v0u/yKBW5g=
 gvisor.dev/gvisor v0.0.0-20250503011706-39ed1f5ac29c h1:m/r7OM+Y2Ty1sgBQ7Qb27VgIMBW8ZZhT4gLnUyDIhzI=
 gvisor.dev/gvisor v0.0.0-20250503011706-39ed1f5ac29c/go.mod h1:3r5CMtNQMKIvBlrmM9xWUNamjKBYPOWyXOjmg5Kts3g=
-software.sslmate.com/src/go-pkcs12 v0.7.0 h1:Db8W44cB54TWD7stUFFSWxdfpdn6fZVcDl0w3R4RVM0=
-software.sslmate.com/src/go-pkcs12 v0.7.0/go.mod h1:Qiz0EyvDRJjjxGyUQa2cCNZn/wMyzrRJ/qcDXOQazLI=
+software.sslmate.com/src/go-pkcs12 v0.6.0 h1:f3sQittAeF+pao32Vb+mkli+ZyT+VwKaD014qFGq6oU=
+software.sslmate.com/src/go-pkcs12 v0.6.0/go.mod h1:Qiz0EyvDRJjjxGyUQa2cCNZn/wMyzrRJ/qcDXOQazLI=

healthcheck/healthcheck.go

@@ -5,9 +5,7 @@ import (
 	"crypto/tls"
 	"encoding/json"
 	"fmt"
-	"net"
 	"net/http"
-	"strconv"
 	"strings"
 	"sync"
 	"time"
@@ -37,38 +35,32 @@ func (s Health) String() string {
 
 // Config holds the health check configuration for a target
 type Config struct {
-	ID                 int               `json:"id"`
-	Enabled            bool              `json:"hcEnabled"`
-	Path               string            `json:"hcPath"`
-	Scheme             string            `json:"hcScheme"`
-	Mode               string            `json:"hcMode"`
-	Hostname           string            `json:"hcHostname"`
-	Port               int               `json:"hcPort"`
-	Interval           int               `json:"hcInterval"`          // in seconds
-	UnhealthyInterval  int               `json:"hcUnhealthyInterval"` // in seconds
-	Timeout            int               `json:"hcTimeout"`           // in seconds
-	FollowRedirects    *bool             `json:"hcFollowRedirects"`
-	Headers            map[string]string `json:"hcHeaders"`
-	Method             string            `json:"hcMethod"`
-	Status             int               `json:"hcStatus"` // HTTP status code
-	TLSServerName      string            `json:"hcTlsServerName"`
-	HealthyThreshold   int               `json:"hcHealthyThreshold"`   // consecutive successes required to become healthy
-	UnhealthyThreshold int               `json:"hcUnhealthyThreshold"` // consecutive failures required to become unhealthy
+	ID                int               `json:"id"`
+	Enabled           bool              `json:"hcEnabled"`
+	Path              string            `json:"hcPath"`
+	Scheme            string            `json:"hcScheme"`
+	Mode              string            `json:"hcMode"`
+	Hostname          string            `json:"hcHostname"`
+	Port              int               `json:"hcPort"`
+	Interval          int               `json:"hcInterval"`          // in seconds
+	UnhealthyInterval int               `json:"hcUnhealthyInterval"` // in seconds
+	Timeout           int               `json:"hcTimeout"`           // in seconds
+	Headers           map[string]string `json:"hcHeaders"`
+	Method            string            `json:"hcMethod"`
+	Status            int               `json:"hcStatus"` // HTTP status code
+	TLSServerName     string            `json:"hcTlsServerName"`
 }
 
 // Target represents a health check target with its current status
 type Target struct {
-	Config               Config    `json:"config"`
-	Status               Health    `json:"status"`
-	LastCheck            time.Time `json:"lastCheck"`
-	LastError            string    `json:"lastError,omitempty"`
-	CheckCount           int       `json:"checkCount"`
-	timer                *time.Timer
-	ctx                  context.Context
-	cancel               context.CancelFunc
-	client               *http.Client
-	consecutiveSuccesses int
-	consecutiveFailures  int
+	Config     Config    `json:"config"`
+	Status     Health    `json:"status"`
+	LastCheck  time.Time `json:"lastCheck"`
+	LastError  string    `json:"lastError,omitempty"`
+	CheckCount int       `json:"checkCount"`
+	timer      *time.Timer
+	ctx        context.Context
+	cancel     context.CancelFunc
 }
 
 // StatusChangeCallback is called when any target's status changes
@@ -170,16 +162,9 @@ func (m *Monitor) addTargetUnsafe(config Config) error {
 	if config.Timeout == 0 {
 		config.Timeout = 5
 	}
-	if config.HealthyThreshold == 0 {
-		config.HealthyThreshold = 1
-	}
-	if config.UnhealthyThreshold == 0 {
-		config.UnhealthyThreshold = 1
-	}
 
-	logger.Debug("Target %d configuration: mode=%s, scheme=%s, method=%s, interval=%ds, timeout=%ds, healthyThreshold=%d, unhealthyThreshold=%d",
-		config.ID, config.Mode, config.Scheme, config.Method, config.Interval, config.Timeout,
-		config.HealthyThreshold, config.UnhealthyThreshold)
+	logger.Debug("Target %d configuration: scheme=%s, method=%s, interval=%ds, timeout=%ds",
+		config.ID, config.Scheme, config.Method, config.Interval, config.Timeout)
 
 	// Parse headers if provided as string
 	if len(config.Headers) == 0 && config.Path != "" {
@@ -200,26 +185,6 @@ func (m *Monitor) addTargetUnsafe(config Config) error {
 		Status: StatusUnknown,
 		ctx:    ctx,
 		cancel: cancel,
-		client: &http.Client{
-			CheckRedirect: func() func(*http.Request, []*http.Request) error {
-				// Default to following redirects if not explicitly configured
-				followRedirects := config.FollowRedirects == nil || *config.FollowRedirects
-				if !followRedirects {
-					return func(req *http.Request, via []*http.Request) error {
-						return http.ErrUseLastResponse
-					}
-				}
-				return nil
-			}(),
-			Transport: &http.Transport{
-				TLSClientConfig: &tls.Config{
-					// Configure TLS settings based on certificate enforcement
-					InsecureSkipVerify: !m.enforceCert,
-					// Use SNI TLS header if present
-					ServerName: config.TLSServerName,
-				},
-			},
-		},
 	}
 
 	m.targets[config.ID] = target
@@ -252,7 +217,7 @@ func (m *Monitor) RemoveTarget(id int) error {
 
 	// Notify callback of status change
 	if m.callback != nil {
-		go m.callback(m.getAllTargetsUnsafe())
+		go m.callback(m.GetTargets())
 	}
 
 	logger.Info("Successfully removed target %d", id)
@@ -285,7 +250,7 @@ func (m *Monitor) RemoveTargets(ids []int) error {
 
 	// Notify callback of status change if any targets were removed
 	if len(notFound) != len(ids) && m.callback != nil {
-		go m.callback(m.getAllTargetsUnsafe())
+		go m.callback(m.GetTargets())
 	}
 
 	if len(notFound) > 0 {
@@ -383,75 +348,17 @@ func (m *Monitor) monitorTarget(target *Target) {
 	}
 }
 
-// performHealthCheck performs a health check on a target and applies threshold logic
+// performHealthCheck performs a health check on a target
 func (m *Monitor) performHealthCheck(target *Target) {
 	target.CheckCount++
 	target.LastCheck = time.Now()
+	target.LastError = ""
 
-	var passed bool
-	var checkErr string
-
-	switch strings.ToLower(target.Config.Mode) {
-	case "tcp":
-		passed, checkErr = m.performTCPCheck(target)
-	default:
-		// "http", "https", or anything else falls through to HTTP
-		passed, checkErr = m.performHTTPCheck(target)
-	}
-
-	if passed {
-		target.consecutiveFailures = 0
-		target.consecutiveSuccesses++
-
-		logger.Debug("Target %d: check passed (consecutive successes: %d / threshold: %d)",
-			target.Config.ID, target.consecutiveSuccesses, target.Config.HealthyThreshold)
-
-		if target.consecutiveSuccesses >= target.Config.HealthyThreshold {
-			target.Status = StatusHealthy
-			target.LastError = ""
-		}
-	} else {
-		target.consecutiveSuccesses = 0
-		target.consecutiveFailures++
-		target.LastError = checkErr
-
-		logger.Debug("Target %d: check failed (consecutive failures: %d / threshold: %d): %s",
-			target.Config.ID, target.consecutiveFailures, target.Config.UnhealthyThreshold, checkErr)
-
-		if target.consecutiveFailures >= target.Config.UnhealthyThreshold {
-			target.Status = StatusUnhealthy
-		}
-	}
-}
-
-// performTCPCheck dials the target's host:port over TCP and returns whether it succeeded
-func (m *Monitor) performTCPCheck(target *Target) (bool, string) {
-	address := net.JoinHostPort(target.Config.Hostname, strconv.Itoa(target.Config.Port))
-	timeout := time.Duration(target.Config.Timeout) * time.Second
-
-	logger.Debug("Target %d: performing TCP health check to %s (timeout: %v)",
-		target.Config.ID, address, timeout)
-
-	conn, err := net.DialTimeout("tcp", address, timeout)
-	if err != nil {
-		msg := fmt.Sprintf("TCP dial failed: %v", err)
-		logger.Warn("Target %d: %s", target.Config.ID, msg)
-		return false, msg
-	}
-	conn.Close()
-
-	logger.Debug("Target %d: TCP health check passed", target.Config.ID)
-	return true, ""
-}
-
-// performHTTPCheck performs an HTTP/HTTPS health check and returns whether it succeeded
-func (m *Monitor) performHTTPCheck(target *Target) (bool, string) {
-	// Build URL (use net.JoinHostPort to properly handle IPv6 addresses with ports)
-	host := target.Config.Hostname
+	// Build URL
+	url := fmt.Sprintf("%s://%s", target.Config.Scheme, target.Config.Hostname)
 	if target.Config.Port > 0 {
-		host = net.JoinHostPort(target.Config.Hostname, strconv.Itoa(target.Config.Port))
+		url = fmt.Sprintf("%s:%d", url, target.Config.Port)
 	}
-	url := fmt.Sprintf("%s://%s", target.Config.Scheme, host)
 	if target.Config.Path != "" {
 		if !strings.HasPrefix(target.Config.Path, "/") {
 			url += "/"
@@ -459,7 +366,7 @@ func (m *Monitor) performHTTPCheck(target *Target) (bool, string) {
 		url += target.Config.Path
 	}
 
-	logger.Debug("Target %d: performing HTTP health check %d to %s",
+	logger.Debug("Target %d: performing health check %d to %s",
 		target.Config.ID, target.CheckCount, url)
 
 	if target.Config.Scheme == "https" {
@@ -467,15 +374,27 @@ func (m *Monitor) performHTTPCheck(target *Target) (bool, string) {
 			target.Config.ID, m.enforceCert)
 	}
 
-	// Create request with timeout context
+	// Create request
 	ctx, cancel := context.WithTimeout(context.Background(), time.Duration(target.Config.Timeout)*time.Second)
 	defer cancel()
 
+	client := &http.Client{
+		Transport: &http.Transport{
+			TLSClientConfig: &tls.Config{
+				// Configure TLS settings based on certificate enforcement
+				InsecureSkipVerify: !m.enforceCert,
+				// Use SNI TLS header if present
+				ServerName: target.Config.TLSServerName,
+			},
+		},
+	}
+
 	req, err := http.NewRequestWithContext(ctx, target.Config.Method, url, nil)
 	if err != nil {
-		msg := fmt.Sprintf("failed to create request: %v", err)
-		logger.Warn("Target %d: %s", target.Config.ID, msg)
-		return false, msg
+		target.Status = StatusUnhealthy
+		target.LastError = fmt.Sprintf("failed to create request: %v", err)
+		logger.Warn("Target %d: failed to create request: %v", target.Config.ID, err)
+		return
 	}
 
 	// Add headers
@@ -489,36 +408,45 @@ func (m *Monitor) performHTTPCheck(target *Target) (bool, string) {
 	}
 
 	// Perform request
-	resp, err := target.client.Do(req)
+	resp, err := client.Do(req)
 	if err != nil {
-		msg := fmt.Sprintf("request failed: %v", err)
+		target.Status = StatusUnhealthy
+		target.LastError = fmt.Sprintf("request failed: %v", err)
 		logger.Warn("Target %d: health check failed: %v", target.Config.ID, err)
-		return false, msg
+		return
 	}
 	defer resp.Body.Close()
 
 	// Check response status
+	var expectedStatus int
 	if target.Config.Status > 0 {
+		expectedStatus = target.Config.Status
+	} else {
+		expectedStatus = 0 // Use range check for 200-299
+	}
+
+	if expectedStatus > 0 {
+		logger.Debug("Target %d: checking health status against expected code %d", target.Config.ID, expectedStatus)
 		// Check for specific status code
-		logger.Debug("Target %d: checking status against expected code %d", target.Config.ID, target.Config.Status)
-		if resp.StatusCode == target.Config.Status {
-			logger.Debug("Target %d: health check passed (status: %d)", target.Config.ID, resp.StatusCode)
-			return true, ""
+		if resp.StatusCode == expectedStatus {
+			target.Status = StatusHealthy
+			logger.Debug("Target %d: health check passed (status: %d, expected: %d)", target.Config.ID, resp.StatusCode, expectedStatus)
+		} else {
+			target.Status = StatusUnhealthy
+			target.LastError = fmt.Sprintf("unexpected status code: %d (expected: %d)", resp.StatusCode, expectedStatus)
+			logger.Warn("Target %d: health check failed with status code %d (expected: %d)", target.Config.ID, resp.StatusCode, expectedStatus)
+		}
+	} else {
+		// Check for 2xx range
+		if resp.StatusCode >= 200 && resp.StatusCode < 300 {
+			target.Status = StatusHealthy
+			logger.Debug("Target %d: health check passed (status: %d)", target.Config.ID, resp.StatusCode)
+		} else {
+			target.Status = StatusUnhealthy
+			target.LastError = fmt.Sprintf("unhealthy status code: %d", resp.StatusCode)
+			logger.Warn("Target %d: health check failed with status code %d", target.Config.ID, resp.StatusCode)
 		}
-		msg := fmt.Sprintf("unexpected status code: %d (expected: %d)", resp.StatusCode, target.Config.Status)
-		logger.Warn("Target %d: %s", target.Config.ID, msg)
-		return false, msg
 	}
-
-	// Default: check for 2xx range
-	if resp.StatusCode >= 200 && resp.StatusCode < 300 {
-		logger.Debug("Target %d: health check passed (status: %d)", target.Config.ID, resp.StatusCode)
-		return true, ""
-	}
-
-	msg := fmt.Sprintf("unhealthy status code: %d", resp.StatusCode)
-	logger.Warn("Target %d: health check failed with status code %d", target.Config.ID, resp.StatusCode)
-	return false, msg
 }
 
 // Stop stops monitoring all targets
@@ -585,7 +513,7 @@ func (m *Monitor) DisableTarget(id int) error {
 
 		// Notify callback of status change
 		if m.callback != nil {
-			go m.callback(m.getAllTargetsUnsafe())
+			go m.callback(m.GetTargets())
 		}
 	} else {
 		logger.Debug("Target %d is already disabled", id)
@@ -593,82 +521,3 @@ func (m *Monitor) DisableTarget(id int) error {
 
 	return nil
 }
-
-// GetTargetIDs returns a slice of all current target IDs
-func (m *Monitor) GetTargetIDs() []int {
-	m.mutex.RLock()
-	defer m.mutex.RUnlock()
-
-	ids := make([]int, 0, len(m.targets))
-	for id := range m.targets {
-		ids = append(ids, id)
-	}
-	return ids
-}
-
-// SyncTargets synchronizes the current targets to match the desired set.
-// It removes targets not in the desired set and adds targets that are missing.
-func (m *Monitor) SyncTargets(desiredConfigs []Config) error {
-	m.mutex.Lock()
-	defer m.mutex.Unlock()
-
-	logger.Info("Syncing health check targets: %d desired targets", len(desiredConfigs))
-
-	// Build a set of desired target IDs
-	desiredIDs := make(map[int]Config)
-	for _, config := range desiredConfigs {
-		desiredIDs[config.ID] = config
-	}
-
-	// Find targets to remove (exist but not in desired set)
-	var toRemove []int
-	for id := range m.targets {
-		if _, exists := desiredIDs[id]; !exists {
-			toRemove = append(toRemove, id)
-		}
-	}
-
-	// Remove targets that are not in the desired set
-	for _, id := range toRemove {
-		logger.Info("Sync: removing health check target %d", id)
-		if target, exists := m.targets[id]; exists {
-			target.cancel()
-			delete(m.targets, id)
-		}
-	}
-
-	// Add or update targets from the desired set
-	var addedCount, updatedCount int
-	for id, config := range desiredIDs {
-		if existing, exists := m.targets[id]; exists {
-			// Target exists - check if config changed and update if needed
-			// For now, we'll replace it to ensure config is up to date
-			logger.Debug("Sync: updating health check target %d", id)
-			existing.cancel()
-			delete(m.targets, id)
-			if err := m.addTargetUnsafe(config); err != nil {
-				logger.Error("Sync: failed to update target %d: %v", id, err)
-				return fmt.Errorf("failed to update target %d: %v", id, err)
-			}
-			updatedCount++
-		} else {
-			// Target doesn't exist - add it
-			logger.Debug("Sync: adding health check target %d", id)
-			if err := m.addTargetUnsafe(config); err != nil {
-				logger.Error("Sync: failed to add target %d: %v", id, err)
-				return fmt.Errorf("failed to add target %d: %v", id, err)
-			}
-			addedCount++
-		}
-	}
-
-	logger.Info("Sync complete: removed %d, added %d, updated %d targets",
-		len(toRemove), addedCount, updatedCount)
-
-	// Notify callback if any changes were made
-	if (len(toRemove) > 0 || addedCount > 0 || updatedCount > 0) && m.callback != nil {
-		go m.callback(m.getAllTargetsUnsafe())
-	}
-
-	return nil
-}

holepunch/holepunch.go

@@ -27,42 +27,32 @@ type ExitNode struct {
 
 // Manager handles UDP hole punching operations
 type Manager struct {
-	mu          sync.Mutex
-	running     bool
-	stopChan    chan struct{}
-	sharedBind  *bind.SharedBind
-	ID          string
-	token       string
-	publicKey   string
-	clientType  string
-	exitNodes   map[string]ExitNode // key is endpoint
-	updateChan  chan struct{}        // signals the goroutine to refresh exit nodes
-	publicDNS []string
+	mu         sync.Mutex
+	running    bool
+	stopChan   chan struct{}
+	sharedBind *bind.SharedBind
+	ID         string
+	token      string
+	publicKey  string
+	clientType string
+	exitNodes  map[string]ExitNode // key is endpoint
+	updateChan chan struct{}       // signals the goroutine to refresh exit nodes
 
-	sendHolepunchInterval    time.Duration
-	sendHolepunchIntervalMin time.Duration
-	sendHolepunchIntervalMax time.Duration
-	defaultIntervalMin       time.Duration
-	defaultIntervalMax       time.Duration
+	sendHolepunchInterval time.Duration
 }
 
-const defaultSendHolepunchIntervalMax = 60 * time.Second
-const defaultSendHolepunchIntervalMin = 1 * time.Second
+const sendHolepunchIntervalMax = 60 * time.Second
+const sendHolepunchIntervalMin = 1 * time.Second
 
 // NewManager creates a new hole punch manager
-func NewManager(sharedBind *bind.SharedBind, ID string, clientType string, publicKey string, publicDNS []string) *Manager {
+func NewManager(sharedBind *bind.SharedBind, ID string, clientType string, publicKey string) *Manager {
 	return &Manager{
-		sharedBind:               sharedBind,
-		ID:                       ID,
-		clientType:               clientType,
-		publicKey:                publicKey,
-		publicDNS:              publicDNS,
-		exitNodes:                make(map[string]ExitNode),
-		sendHolepunchInterval:    defaultSendHolepunchIntervalMin,
-		sendHolepunchIntervalMin: defaultSendHolepunchIntervalMin,
-		sendHolepunchIntervalMax: defaultSendHolepunchIntervalMax,
-		defaultIntervalMin:       defaultSendHolepunchIntervalMin,
-		defaultIntervalMax:       defaultSendHolepunchIntervalMax,
+		sharedBind:            sharedBind,
+		ID:                    ID,
+		clientType:            clientType,
+		publicKey:             publicKey,
+		exitNodes:             make(map[string]ExitNode),
+		sendHolepunchInterval: sendHolepunchIntervalMin,
 	}
 }
 
@@ -210,46 +200,17 @@ func (m *Manager) GetExitNodes() []ExitNode {
 	return nodes
 }
 
-// SetServerHolepunchInterval sets custom min and max intervals for hole punching.
-// This is useful for low power mode where longer intervals are desired.
-func (m *Manager) SetServerHolepunchInterval(min, max time.Duration) {
+// ResetInterval resets the hole punch interval back to the minimum value,
+// allowing it to climb back up through exponential backoff.
+// This is useful when network conditions change or connectivity is restored.
+func (m *Manager) ResetInterval() {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
-	m.sendHolepunchIntervalMin = min
-	m.sendHolepunchIntervalMax = max
-	m.sendHolepunchInterval = min
-
-	logger.Info("Set hole punch intervals: min=%v, max=%v", min, max)
-
-	// Signal the goroutine to apply the new interval if running
-	if m.running && m.updateChan != nil {
-		select {
-		case m.updateChan <- struct{}{}:
-		default:
-			// Channel full or closed, skip
-		}
+	if m.sendHolepunchInterval != sendHolepunchIntervalMin {
+		m.sendHolepunchInterval = sendHolepunchIntervalMin
+		logger.Info("Reset hole punch interval to minimum (%v)", sendHolepunchIntervalMin)
 	}
-}
-
-// GetInterval returns the current min and max intervals
-func (m *Manager) GetServerHolepunchInterval() (min, max time.Duration) {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-	return m.sendHolepunchIntervalMin, m.sendHolepunchIntervalMax
-}
-
-// ResetServerHolepunchInterval resets the hole punch interval back to the default values.
-// This restores normal operation after low power mode or other custom settings.
-func (m *Manager) ResetServerHolepunchInterval() {
-	m.mu.Lock()
-	defer m.mu.Unlock()
-
-	m.sendHolepunchIntervalMin = m.defaultIntervalMin
-	m.sendHolepunchIntervalMax = m.defaultIntervalMax
-	m.sendHolepunchInterval = m.defaultIntervalMin
-
-	logger.Info("Reset hole punch intervals to defaults: min=%v, max=%v", m.defaultIntervalMin, m.defaultIntervalMax)
 
 	// Signal the goroutine to apply the new interval if running
 	if m.running && m.updateChan != nil {
@@ -283,13 +244,7 @@ func (m *Manager) TriggerHolePunch() error {
 	// Send hole punch to all exit nodes
 	successCount := 0
 	for _, exitNode := range currentExitNodes {
-		var host string
-		var err error
-		if len(m.publicDNS) > 0 {
-			host, err = util.ResolveDomainUpstream(exitNode.Endpoint, m.publicDNS)
-		} else {
-			host, err = util.ResolveDomain(exitNode.Endpoint)
-		}
+		host, err := util.ResolveDomain(exitNode.Endpoint)
 		if err != nil {
 			logger.Warn("Failed to resolve endpoint %s: %v", exitNode.Endpoint, err)
 			continue
@@ -340,7 +295,7 @@ func (m *Manager) StartMultipleExitNodes(exitNodes []ExitNode) error {
 	m.updateChan = make(chan struct{}, 1)
 	m.mu.Unlock()
 
-	logger.Debug("Starting UDP hole punch to %d exit nodes with shared bind", len(exitNodes))
+	logger.Info("Starting UDP hole punch to %d exit nodes with shared bind", len(exitNodes))
 
 	go m.runMultipleExitNodes()
 
@@ -400,13 +355,7 @@ func (m *Manager) runMultipleExitNodes() {
 
 		var resolvedNodes []resolvedExitNode
 		for _, exitNode := range currentExitNodes {
-			var host string
-			var err error
-			if len(m.publicDNS) > 0 {
-				host, err = util.ResolveDomainUpstream(exitNode.Endpoint, m.publicDNS)
-			} else {
-				host, err = util.ResolveDomain(exitNode.Endpoint)
-			}
+			host, err := util.ResolveDomain(exitNode.Endpoint)
 			if err != nil {
 				logger.Warn("Failed to resolve endpoint %s: %v", exitNode.Endpoint, err)
 				continue
@@ -424,7 +373,7 @@ func (m *Manager) runMultipleExitNodes() {
 				publicKey:    exitNode.PublicKey,
 				endpointName: exitNode.Endpoint,
 			})
-			logger.Debug("Resolved exit node: %s -> %s", exitNode.Endpoint, remoteAddr.String())
+			logger.Info("Resolved exit node: %s -> %s", exitNode.Endpoint, remoteAddr.String())
 		}
 		return resolvedNodes
 	}
@@ -444,7 +393,7 @@ func (m *Manager) runMultipleExitNodes() {
 
 	// Start with minimum interval
 	m.mu.Lock()
-	m.sendHolepunchInterval = m.sendHolepunchIntervalMin
+	m.sendHolepunchInterval = sendHolepunchIntervalMin
 	m.mu.Unlock()
 
 	ticker := time.NewTicker(m.sendHolepunchInterval)
@@ -466,7 +415,7 @@ func (m *Manager) runMultipleExitNodes() {
 			}
 			// Reset interval to minimum on update
 			m.mu.Lock()
-			m.sendHolepunchInterval = m.sendHolepunchIntervalMin
+			m.sendHolepunchInterval = sendHolepunchIntervalMin
 			m.mu.Unlock()
 			ticker.Reset(m.sendHolepunchInterval)
 			// Send immediate hole punch to newly resolved nodes
@@ -486,8 +435,8 @@ func (m *Manager) runMultipleExitNodes() {
 				// Exponential backoff: double the interval up to max
 				m.mu.Lock()
 				newInterval := m.sendHolepunchInterval * 2
-				if newInterval > m.sendHolepunchIntervalMax {
-					newInterval = m.sendHolepunchIntervalMax
+				if newInterval > sendHolepunchIntervalMax {
+					newInterval = sendHolepunchIntervalMax
 				}
 				if newInterval != m.sendHolepunchInterval {
 					m.sendHolepunchInterval = newInterval

holepunch/tester.go

@@ -41,30 +41,18 @@ func DefaultTestOptions() TestConnectionOptions {
 	}
 }
 
-// cachedAddr holds a cached resolved UDP address
-type cachedAddr struct {
-	addr      *net.UDPAddr
-	resolvedAt time.Time
-}
-
 // HolepunchTester monitors holepunch connectivity using magic packets
 type HolepunchTester struct {
-	sharedBind  *bind.SharedBind
-	publicDNS []string
-	mu          sync.RWMutex
-	running     bool
-	stopChan    chan struct{}
+	sharedBind *bind.SharedBind
+	mu         sync.RWMutex
+	running    bool
+	stopChan   chan struct{}
 
 	// Pending requests waiting for responses (key: echo data as string)
 	pendingRequests sync.Map // map[string]*pendingRequest
 
 	// Callback when connection status changes
 	callback HolepunchStatusCallback
-
-	// Address cache to avoid repeated DNS/UDP resolution
-	addrCache    map[string]*cachedAddr
-	addrCacheMu  sync.RWMutex
-	addrCacheTTL time.Duration // How long cached addresses are valid
 }
 
 // HolepunchStatus represents the status of a holepunch connection
@@ -85,12 +73,9 @@ type pendingRequest struct {
 }
 
 // NewHolepunchTester creates a new holepunch tester using the given SharedBind
-func NewHolepunchTester(sharedBind *bind.SharedBind, publicDNS []string) *HolepunchTester {
+func NewHolepunchTester(sharedBind *bind.SharedBind) *HolepunchTester {
 	return &HolepunchTester{
-		sharedBind:   sharedBind,
-		publicDNS:  publicDNS,
-		addrCache:    make(map[string]*cachedAddr),
-		addrCacheTTL: 5 * time.Minute, // Cache addresses for 5 minutes
+		sharedBind: sharedBind,
 	}
 }
 
@@ -150,76 +135,12 @@ func (t *HolepunchTester) Stop() {
 		return true
 	})
 
-	// Clear address cache
-	t.addrCacheMu.Lock()
-	t.addrCache = make(map[string]*cachedAddr)
-	t.addrCacheMu.Unlock()
-
 	logger.Debug("HolepunchTester stopped")
 }
 
-// resolveEndpoint resolves an endpoint to a UDP address, using cache when possible
-func (t *HolepunchTester) resolveEndpoint(endpoint string) (*net.UDPAddr, error) {
-	// Check cache first
-	t.addrCacheMu.RLock()
-	cached, ok := t.addrCache[endpoint]
-	ttl := t.addrCacheTTL
-	t.addrCacheMu.RUnlock()
-
-	if ok && time.Since(cached.resolvedAt) < ttl {
-		return cached.addr, nil
-	}
-
-	// Resolve the endpoint
-	var host string
-	var err error
-	if len(t.publicDNS) > 0 {
-		host, err = util.ResolveDomainUpstream(endpoint, t.publicDNS)
-	} else {
-		host, err = util.ResolveDomain(endpoint)
-	}
-	if err != nil {
-		host = endpoint
-	}
-
-	_, _, err = net.SplitHostPort(host)
-	if err != nil {
-		host = net.JoinHostPort(host, "21820")
-	}
-
-	remoteAddr, err := net.ResolveUDPAddr("udp", host)
-	if err != nil {
-		return nil, fmt.Errorf("failed to resolve UDP address %s: %w", host, err)
-	}
-
-	// Cache the result
-	t.addrCacheMu.Lock()
-	t.addrCache[endpoint] = &cachedAddr{
-		addr:       remoteAddr,
-		resolvedAt: time.Now(),
-	}
-	t.addrCacheMu.Unlock()
-
-	return remoteAddr, nil
-}
-
-// InvalidateCache removes a specific endpoint from the address cache
-func (t *HolepunchTester) InvalidateCache(endpoint string) {
-	t.addrCacheMu.Lock()
-	delete(t.addrCache, endpoint)
-	t.addrCacheMu.Unlock()
-}
-
-// ClearCache clears all cached addresses
-func (t *HolepunchTester) ClearCache() {
-	t.addrCacheMu.Lock()
-	t.addrCache = make(map[string]*cachedAddr)
-	t.addrCacheMu.Unlock()
-}
-
 // handleResponse is called by SharedBind when a magic response is received
 func (t *HolepunchTester) handleResponse(addr netip.AddrPort, echoData []byte) {
-	// logger.Debug("Received magic response from %s", addr.String())
+	logger.Debug("Received magic response from %s", addr.String())
 	key := string(echoData)
 
 	value, ok := t.pendingRequests.LoadAndDelete(key)
@@ -231,7 +152,7 @@ func (t *HolepunchTester) handleResponse(addr netip.AddrPort, echoData []byte) {
 
 	req := value.(*pendingRequest)
 	rtt := time.Since(req.sentAt)
-	// logger.Debug("Magic response matched pending request for %s (RTT: %v)", req.endpoint, rtt)
+	logger.Debug("Magic response matched pending request for %s (RTT: %v)", req.endpoint, rtt)
 
 	// Send RTT to the waiting goroutine (non-blocking)
 	select {
@@ -262,10 +183,20 @@ func (t *HolepunchTester) TestEndpoint(endpoint string, timeout time.Duration) T
 		return result
 	}
 
-	// Resolve the endpoint (using cache)
-	remoteAddr, err := t.resolveEndpoint(endpoint)
+	// Resolve the endpoint
+	host, err := util.ResolveDomain(endpoint)
 	if err != nil {
-		result.Error = err
+		host = endpoint
+	}
+
+	_, _, err = net.SplitHostPort(host)
+	if err != nil {
+		host = net.JoinHostPort(host, "21820")
+	}
+
+	remoteAddr, err := net.ResolveUDPAddr("udp", host)
+	if err != nil {
+		result.Error = fmt.Errorf("failed to resolve UDP address %s: %w", host, err)
 		return result
 	}
 

main.go

@@ -1,27 +1,22 @@
 package main
 
 import (
-	"bytes"
 	"context"
-	"crypto/rand"
-	"crypto/tls"
-	"encoding/hex"
 	"encoding/json"
 	"errors"
 	"flag"
 	"fmt"
 	"net"
 	"net/http"
-	"net/http/pprof"
 	"net/netip"
 	"os"
 	"os/signal"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"syscall"
 	"time"
 
-	"github.com/fosrl/newt/authdaemon"
 	"github.com/fosrl/newt/docker"
 	"github.com/fosrl/newt/healthcheck"
 	"github.com/fosrl/newt/logger"
@@ -48,7 +43,6 @@ type WgData struct {
 	TunnelIP           string               `json:"tunnelIP"`
 	Targets            TargetsByType        `json:"targets"`
 	HealthCheckTargets []healthcheck.Config `json:"healthCheckTargets"`
-	ChainId            string               `json:"chainId"`
 }
 
 type TargetsByType struct {
@@ -62,7 +56,10 @@ type TargetData struct {
 
 type ExitNodeData struct {
 	ExitNodes []ExitNode `json:"exitNodes"`
-	ChainId   string     `json:"chainId"`
+}
+
+type SSHPublicKeyData struct {
+	PublicKey string `json:"publicKey"`
 }
 
 // ExitNode represents an exit node with an ID, endpoint, and weight.
@@ -121,7 +118,6 @@ var (
 	logLevel                           string
 	interfaceName                      string
 	port                               uint16
-	portStr                            string
 	disableClients                     bool
 	updownScript                       string
 	dockerSocket                       string
@@ -129,23 +125,15 @@ var (
 	dockerEnforceNetworkValidationBool bool
 	pingInterval                       time.Duration
 	pingTimeout                        time.Duration
-	udpProxyIdleTimeout                time.Duration
 	publicKey                          wgtypes.Key
 	pingStopChan                       chan struct{}
 	stopFunc                           func()
-	pendingRegisterChainId             string
-	pendingPingChainId                 string
 	healthFile                         string
 	useNativeInterface                 bool
 	authorizedKeysFile                 string
 	preferEndpoint                     string
 	healthMonitor                      *healthcheck.Monitor
 	enforceHealthcheckCert             bool
-	authDaemonKey                      string
-	authDaemonPrincipalsFile           string
-	authDaemonCACertPath               string
-	authDaemonEnabled                  bool
-	authDaemonGenerateRandomPassword   bool
 	// Build/version (can be overridden via -ldflags "-X main.newtVersion=...")
 	newtVersion = "version_replaceme"
 
@@ -155,10 +143,8 @@ var (
 	adminAddr         string
 	region            string
 	metricsAsyncBytes bool
-	pprofEnabled      bool
-	blueprintFile              string
-	provisioningBlueprintFile  string
-	noCloud                    bool
+	blueprintFile     string
+	noCloud           bool
 
 	// New mTLS configuration variables
 	tlsClientCert string
@@ -167,47 +153,9 @@ var (
 
 	// Legacy PKCS12 support (deprecated)
 	tlsPrivateKey string
-
-	// Provisioning key – exchanged once for a permanent newt ID + secret
-	provisioningKey string
-
-	// Optional name for the site created during provisioning
-	newtName string
-
-	// Path to config file (overrides CONFIG_FILE env var and default location)
-	configFile string
 )
 
-// generateChainId generates a random chain ID for deduplicating round-trip messages.
-func generateChainId() string {
-	b := make([]byte, 8)
-	_, _ = rand.Read(b)
-	return hex.EncodeToString(b)
-}
-
 func main() {
-	// Check for subcommands first (only principals exits early)
-	if len(os.Args) > 1 {
-		switch os.Args[1] {
-		case "auth-daemon":
-			// Run principals subcommand only if the next argument is "principals"
-			if len(os.Args) > 2 && os.Args[2] == "principals" {
-				runPrincipalsCmd(os.Args[3:])
-				return
-			}
-
-			// auth-daemon subcommand without "principals" - show help
-			fmt.Println("Error: auth-daemon subcommand requires 'principals' argument")
-			fmt.Println()
-			fmt.Println("Usage:")
-			fmt.Println("  newt auth-daemon principals [options]")
-			fmt.Println()
-
-			// If not "principals", exit the switch to continue with normal execution
-			return
-		}
-	}
-
 	// Check if we're running as a Windows service
 	if isWindowsService() {
 		runService("NewtWireguardService", false, os.Args[1:])
@@ -238,12 +186,7 @@ func runNewtMain(ctx context.Context) {
 	logLevel = os.Getenv("LOG_LEVEL")
 	updownScript = os.Getenv("UPDOWN_SCRIPT")
 	interfaceName = os.Getenv("INTERFACE")
-	portStr = os.Getenv("PORT")
-	authDaemonKey = os.Getenv("AD_KEY")
-	authDaemonPrincipalsFile = os.Getenv("AD_PRINCIPALS_FILE")
-	authDaemonCACertPath = os.Getenv("AD_CA_CERT_PATH")
-	authDaemonEnabledEnv := os.Getenv("AUTH_DAEMON_ENABLED")
-	authDaemonGenerateRandomPasswordEnv := os.Getenv("AD_GENERATE_RANDOM_PASSWORD")
+	portStr := os.Getenv("PORT")
 
 	// Metrics/observability env mirrors
 	metricsEnabledEnv := os.Getenv("NEWT_METRICS_PROMETHEUS_ENABLED")
@@ -251,7 +194,6 @@ func runNewtMain(ctx context.Context) {
 	adminAddrEnv := os.Getenv("NEWT_ADMIN_ADDR")
 	regionEnv := os.Getenv("NEWT_REGION")
 	asyncBytesEnv := os.Getenv("NEWT_METRICS_ASYNC_BYTES")
-	pprofEnabledEnv := os.Getenv("NEWT_PPROF_ENABLED")
 
 	disableClientsEnv := os.Getenv("DISABLE_CLIENTS")
 	disableClients = disableClientsEnv == "true"
@@ -262,7 +204,6 @@ func runNewtMain(ctx context.Context) {
 	dockerSocket = os.Getenv("DOCKER_SOCKET")
 	pingIntervalStr := os.Getenv("PING_INTERVAL")
 	pingTimeoutStr := os.Getenv("PING_TIMEOUT")
-	udpProxyIdleTimeoutStr := os.Getenv("NEWT_UDP_PROXY_IDLE_TIMEOUT")
 	dockerEnforceNetworkValidation = os.Getenv("DOCKER_ENFORCE_NETWORK_VALIDATION")
 	healthFile = os.Getenv("HEALTH_FILE")
 	// authorizedKeysFile = os.Getenv("AUTHORIZED_KEYS_FILE")
@@ -287,12 +228,8 @@ func runNewtMain(ctx context.Context) {
 		tlsPrivateKey = os.Getenv("TLS_CLIENT_CERT")
 	}
 	blueprintFile = os.Getenv("BLUEPRINT_FILE")
-	provisioningBlueprintFile = os.Getenv("PROVISIONING_BLUEPRINT_FILE")
 	noCloudEnv := os.Getenv("NO_CLOUD")
 	noCloud = noCloudEnv == "true"
-	provisioningKey = os.Getenv("NEWT_PROVISIONING_KEY")
-	newtName = os.Getenv("NEWT_NAME")
-	configFile = os.Getenv("CONFIG_FILE")
 
 	if endpoint == "" {
 		flag.StringVar(&endpoint, "endpoint", "", "Endpoint of your pangolin server")
@@ -334,25 +271,17 @@ func runNewtMain(ctx context.Context) {
 		flag.StringVar(&dockerSocket, "docker-socket", "", "Path or address to Docker socket (typically unix:///var/run/docker.sock)")
 	}
 	if pingIntervalStr == "" {
-		flag.StringVar(&pingIntervalStr, "ping-interval", "15s", "Interval for pinging the server (default 15s)")
+		flag.StringVar(&pingIntervalStr, "ping-interval", "3s", "Interval for pinging the server (default 3s)")
 	}
 	if pingTimeoutStr == "" {
-		flag.StringVar(&pingTimeoutStr, "ping-timeout", "7s", "	Timeout for each ping (default 7s)")
-	}
-	if udpProxyIdleTimeoutStr == "" {
-		flag.StringVar(&udpProxyIdleTimeoutStr, "udp-proxy-idle-timeout", "90s", "Idle timeout for UDP proxied client flows before cleanup")
+		flag.StringVar(&pingTimeoutStr, "ping-timeout", "5s", "	Timeout for each ping (default 5s)")
 	}
 	// load the prefer endpoint just as a flag
 	flag.StringVar(&preferEndpoint, "prefer-endpoint", "", "Prefer this endpoint for the connection (if set, will override the endpoint from the server)")
-	if provisioningKey == "" {
-		flag.StringVar(&provisioningKey, "provisioning-key", "", "One-time provisioning key used to obtain a newt ID and secret from the server")
-	}
-	if newtName == "" {
-		flag.StringVar(&newtName, "name", "", "Name for the site created during provisioning (supports {{env.VAR}} interpolation)")
-	}
-	if configFile == "" {
-		flag.StringVar(&configFile, "config-file", "", "Path to config file (overrides CONFIG_FILE env var and default location)")
-	}
+
+	// if authorizedKeysFile == "" {
+	// 	flag.StringVar(&authorizedKeysFile, "authorized-keys-file", "~/.ssh/authorized_keys", "Path to authorized keys file (if unset, no keys will be authorized)")
+	// }
 
 	// Add new mTLS flags
 	if tlsClientCert == "" {
@@ -374,31 +303,30 @@ func runNewtMain(ctx context.Context) {
 	if pingIntervalStr != "" {
 		pingInterval, err = time.ParseDuration(pingIntervalStr)
 		if err != nil {
-			fmt.Printf("Invalid PING_INTERVAL value: %s, using default 15 seconds\n", pingIntervalStr)
-			pingInterval = 15 * time.Second
+			fmt.Printf("Invalid PING_INTERVAL value: %s, using default 3 seconds\n", pingIntervalStr)
+			pingInterval = 3 * time.Second
 		}
 	} else {
-		pingInterval = 15 * time.Second
+		pingInterval = 3 * time.Second
 	}
 
 	if pingTimeoutStr != "" {
 		pingTimeout, err = time.ParseDuration(pingTimeoutStr)
 		if err != nil {
-			fmt.Printf("Invalid PING_TIMEOUT value: %s, using default 7 seconds\n", pingTimeoutStr)
-			pingTimeout = 7 * time.Second
+			fmt.Printf("Invalid PING_TIMEOUT value: %s, using default 5 seconds\n", pingTimeoutStr)
+			pingTimeout = 5 * time.Second
 		}
 	} else {
-		pingTimeout = 7 * time.Second
+		pingTimeout = 5 * time.Second
 	}
 
-	if udpProxyIdleTimeoutStr != "" {
-		udpProxyIdleTimeout, err = time.ParseDuration(udpProxyIdleTimeoutStr)
-		if err != nil || udpProxyIdleTimeout <= 0 {
-			fmt.Printf("Invalid NEWT_UDP_PROXY_IDLE_TIMEOUT/--udp-proxy-idle-timeout value: %s, using default 90 seconds\n", udpProxyIdleTimeoutStr)
-			udpProxyIdleTimeout = 90 * time.Second
+	if portStr != "" {
+		portInt, err := strconv.Atoi(portStr)
+		if err != nil {
+			logger.Warn("Failed to parse PORT, choosing a random port")
+		} else {
+			port = uint16(portInt)
 		}
-	} else {
-		udpProxyIdleTimeout = 90 * time.Second
 	}
 
 	if dockerEnforceNetworkValidation == "" {
@@ -410,16 +338,13 @@ func runNewtMain(ctx context.Context) {
 	if blueprintFile == "" {
 		flag.StringVar(&blueprintFile, "blueprint-file", "", "Path to blueprint file (if unset, no blueprint will be applied)")
 	}
-	if provisioningBlueprintFile == "" {
-		flag.StringVar(&provisioningBlueprintFile, "provisioning-blueprint-file", "", "Path to blueprint file applied once after a provisioning credential exchange (if unset, no provisioning blueprint will be applied)")
-	}
 	if noCloudEnv == "" {
 		flag.BoolVar(&noCloud, "no-cloud", false, "Disable cloud failover")
 	}
 
 	// Metrics/observability flags (mirror ENV if unset)
 	if metricsEnabledEnv == "" {
-		flag.BoolVar(&metricsEnabled, "metrics", false, "Enable Prometheus metrics exporter")
+		flag.BoolVar(&metricsEnabled, "metrics", true, "Enable Prometheus /metrics exporter")
 	} else {
 		if v, err := strconv.ParseBool(metricsEnabledEnv); err == nil {
 			metricsEnabled = v
@@ -447,14 +372,6 @@ func runNewtMain(ctx context.Context) {
 			metricsAsyncBytes = v
 		}
 	}
-	// pprof debug endpoint toggle
-	if pprofEnabledEnv == "" {
-		flag.BoolVar(&pprofEnabled, "pprof", false, "Enable pprof debug endpoints on admin server")
-	} else {
-		if v, err := strconv.ParseBool(pprofEnabledEnv); err == nil {
-			pprofEnabled = v
-		}
-	}
 	// Optional region flag (resource attribute)
 	if regionEnv == "" {
 		flag.StringVar(&region, "region", "", "Optional region resource attribute (also NEWT_REGION)")
@@ -462,31 +379,6 @@ func runNewtMain(ctx context.Context) {
 		region = regionEnv
 	}
 
-	// Auth daemon flags
-	if authDaemonKey == "" {
-		flag.StringVar(&authDaemonKey, "ad-pre-shared-key", "", "Pre-shared key for auth daemon authentication")
-	}
-	if authDaemonPrincipalsFile == "" {
-		flag.StringVar(&authDaemonPrincipalsFile, "ad-principals-file", "/var/run/auth-daemon/principals", "Path to the principals file for auth daemon")
-	}
-	if authDaemonCACertPath == "" {
-		flag.StringVar(&authDaemonCACertPath, "ad-ca-cert-path", "/etc/ssh/ca.pem", "Path to the CA certificate file for auth daemon")
-	}
-	if authDaemonEnabledEnv == "" {
-		flag.BoolVar(&authDaemonEnabled, "auth-daemon", false, "Enable auth daemon mode (runs alongside normal newt operation)")
-	} else {
-		if v, err := strconv.ParseBool(authDaemonEnabledEnv); err == nil {
-			authDaemonEnabled = v
-		}
-	}
-	if authDaemonGenerateRandomPasswordEnv == "" {
-		flag.BoolVar(&authDaemonGenerateRandomPassword, "ad-generate-random-password", false, "Generate a random password for authenticated users")
-	} else {
-		if v, err := strconv.ParseBool(authDaemonGenerateRandomPasswordEnv); err == nil {
-			authDaemonGenerateRandomPassword = v
-		}
-	}
-
 	// do a --version check
 	version := flag.Bool("version", false, "Print the version")
 
@@ -497,15 +389,6 @@ func runNewtMain(ctx context.Context) {
 		tlsClientCAs = append(tlsClientCAs, tlsClientCAsFlag...)
 	}
 
-	if portStr != "" {
-		portInt, err := strconv.Atoi(portStr)
-		if err != nil {
-			logger.Warn("Failed to parse PORT, choosing a random port")
-		} else {
-			port = uint16(portInt)
-		}
-	}
-
 	if *version {
 		fmt.Println("Newt version " + newtVersion)
 		os.Exit(0)
@@ -515,13 +398,6 @@ func runNewtMain(ctx context.Context) {
 
 	logger.Init(nil)
 	loggerLevel := util.ParseLogLevel(logLevel)
-
-	// Start auth daemon if enabled
-	if authDaemonEnabled {
-		if err := startAuthDaemon(ctx); err != nil {
-			logger.Fatal("Failed to start auth daemon: %v", err)
-		}
-	}
 	logger.GetLogger().SetLevel(loggerLevel)
 
 	// Initialize telemetry after flags are parsed (so flags override env)
@@ -542,22 +418,14 @@ func runNewtMain(ctx context.Context) {
 	if telErr != nil {
 		logger.Warn("Telemetry init failed: %v", telErr)
 	}
-	if tel != nil && (metricsEnabled || pprofEnabled) {
+	if tel != nil {
 		// Admin HTTP server (exposes /metrics when Prometheus exporter is enabled)
-		logger.Debug("Starting metrics server on %s", tcfg.AdminAddr)
+		logger.Info("Starting metrics server on %s", tcfg.AdminAddr)
 		mux := http.NewServeMux()
 		mux.HandleFunc("/healthz", func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(200) })
 		if tel.PrometheusHandler != nil {
 			mux.Handle("/metrics", tel.PrometheusHandler)
 		}
-		if pprofEnabled {
-			mux.HandleFunc("/debug/pprof/", pprof.Index)
-			mux.HandleFunc("/debug/pprof/cmdline", pprof.Cmdline)
-			mux.HandleFunc("/debug/pprof/profile", pprof.Profile)
-			mux.HandleFunc("/debug/pprof/symbol", pprof.Symbol)
-			mux.HandleFunc("/debug/pprof/trace", pprof.Trace)
-			logger.Info("pprof debugging enabled on %s/debug/pprof/", tcfg.AdminAddr)
-		}
 		admin := &http.Server{
 			Addr:              tcfg.AdminAddr,
 			Handler:           otelhttp.NewHandler(mux, "newt-admin"),
@@ -638,22 +506,13 @@ func runNewtMain(ctx context.Context) {
 		id,     // CLI arg takes precedence
 		secret, // CLI arg takes precedence
 		endpoint,
-		30*time.Second,
+		pingInterval,
+		pingTimeout,
 		opt,
-		websocket.WithConfigFile(configFile),
 	)
 	if err != nil {
 		logger.Fatal("Failed to create client: %v", err)
 	}
-	// If a provisioning key was supplied via CLI / env and the config file did
-	// not already carry one, inject it now so provisionIfNeeded() can use it.
-	if provisioningKey != "" && client.GetConfig().ProvisioningKey == "" {
-		client.GetConfig().ProvisioningKey = provisioningKey
-	}
-	if newtName != "" && client.GetConfig().Name == "" {
-		client.GetConfig().Name = newtName
-	}
-
 	endpoint = client.GetConfig().Endpoint // Update endpoint from config
 	id = client.GetConfig().ID             // Update ID from config
 	// Update site labels for metrics with the resolved ID
@@ -770,24 +629,6 @@ func runNewtMain(ctx context.Context) {
 		defer func() {
 			telemetry.IncSiteRegistration(ctx, regResult)
 		}()
-
-		// Deduplicate using chainId: if the server echoes back a chainId we have
-		// already consumed (or one that doesn't match our current pending request),
-		// throw the message away to avoid setting up the tunnel twice.
-		var chainData struct {
-			ChainId string `json:"chainId"`
-		}
-		if jsonBytes, err := json.Marshal(msg.Data); err == nil {
-			_ = json.Unmarshal(jsonBytes, &chainData)
-		}
-		if chainData.ChainId != "" {
-			if chainData.ChainId != pendingRegisterChainId {
-				logger.Debug("Discarding duplicate/stale newt/wg/connect (chainId=%s, expected=%s)", chainData.ChainId, pendingRegisterChainId)
-				return
-			}
-			pendingRegisterChainId = "" // consume – further duplicates with this id are rejected
-		}
-
 		if stopFunc != nil {
 			stopFunc()     // stop the ws from sending more requests
 			stopFunc = nil // reset stopFunc to nil to avoid double stopping
@@ -853,8 +694,8 @@ func runNewtMain(ctx context.Context) {
 
 		relayPort := wgData.RelayPort
 		if relayPort == 0 {
-			relayPort = 21820
-		}
+            relayPort = 21820
+        }
 
 		clientsHandleNewtConnection(wgData.PublicKey, endpoint, relayPort)
 
@@ -911,7 +752,6 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		// Create proxy manager
 		pm = proxy.NewProxyManager(tnet)
 		pm.SetAsyncBytes(metricsAsyncBytes)
-		pm.SetUDPIdleTimeout(udpProxyIdleTimeout)
 		// Set tunnel_id for metrics (WireGuard peer public key)
 		pm.SetTunnelID(wgData.PublicKey)
 
@@ -973,11 +813,8 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		}
 
 		// Request exit nodes from the server
-		pingChainId := generateChainId()
-		pendingPingChainId = pingChainId
 		stopFunc = client.SendMessageInterval("newt/ping/request", map[string]interface{}{
 			"noCloud": noCloud,
-			"chainId": pingChainId,
 		}, 3*time.Second)
 
 		logger.Info("Tunnel destroyed, ready for reconnection")
@@ -1006,7 +843,6 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 
 	client.RegisterHandler("newt/ping/exitNodes", func(msg websocket.WSMessage) {
 		logger.Debug("Received ping message")
-
 		if stopFunc != nil {
 			stopFunc()     // stop the ws from sending more requests
 			stopFunc = nil // reset stopFunc to nil to avoid double stopping
@@ -1026,14 +862,6 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		}
 		exitNodes := exitNodeData.ExitNodes
 
-		if exitNodeData.ChainId != "" {
-			if exitNodeData.ChainId != pendingPingChainId {
-				logger.Debug("Discarding duplicate/stale newt/ping/exitNodes (chainId=%s, expected=%s)", exitNodeData.ChainId, pendingPingChainId)
-				return
-			}
-			pendingPingChainId = "" // consume – further duplicates with this id are rejected
-		}
-
 		if len(exitNodes) == 0 {
 			logger.Info("No exit nodes provided")
 			return
@@ -1066,14 +894,11 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 				},
 			}
 
-			chainId := generateChainId()
-			pendingRegisterChainId = chainId
 			stopFunc = client.SendMessageInterval(topicWGRegister, map[string]interface{}{
 				"publicKey":   publicKey.String(),
 				"pingResults": pingResults,
 				"newtVersion": newtVersion,
-				"chainId":     chainId,
-			}, 2*time.Second)
+			}, 1*time.Second)
 
 			return
 		}
@@ -1172,14 +997,11 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		}
 
 		// Send the ping results to the cloud for selection
-		chainId := generateChainId()
-		pendingRegisterChainId = chainId
 		stopFunc = client.SendMessageInterval(topicWGRegister, map[string]interface{}{
 			"publicKey":   publicKey.String(),
 			"pingResults": pingResults,
 			"newtVersion": newtVersion,
-			"chainId":     chainId,
-		}, 2*time.Second)
+		}, 1*time.Second)
 
 		logger.Debug("Sent exit node ping results to cloud for selection: pingResults=%+v", pingResults)
 	})
@@ -1284,153 +1106,6 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		}
 	})
 
-	// Register handler for syncing targets (TCP, UDP, and health checks)
-	client.RegisterHandler("newt/sync", func(msg websocket.WSMessage) {
-		logger.Info("Received sync message")
-
-		// if there is no wgData or pm, we can't sync targets
-		if wgData.TunnelIP == "" || pm == nil {
-			logger.Info(msgNoTunnelOrProxy)
-			return
-		}
-
-		// Define the sync data structure
-		type SyncData struct {
-			Targets            TargetsByType        `json:"targets"`
-			HealthCheckTargets []healthcheck.Config `json:"healthCheckTargets"`
-		}
-
-		var syncData SyncData
-		jsonData, err := json.Marshal(msg.Data)
-		if err != nil {
-			logger.Error("Error marshaling sync data: %v", err)
-			return
-		}
-
-		if err := json.Unmarshal(jsonData, &syncData); err != nil {
-			logger.Error("Error unmarshaling sync data: %v", err)
-			return
-		}
-
-		logger.Debug("Sync data received: TCP targets=%d, UDP targets=%d, health check targets=%d",
-			len(syncData.Targets.TCP), len(syncData.Targets.UDP), len(syncData.HealthCheckTargets))
-
-		//TODO: TEST AND IMPLEMENT THIS
-
-		// // Build sets of desired targets (port -> target string)
-		// desiredTCP := make(map[int]string)
-		// for _, t := range syncData.Targets.TCP {
-		// 	parts := strings.Split(t, ":")
-		// 	if len(parts) != 3 {
-		// 		logger.Warn("Invalid TCP target format: %s", t)
-		// 		continue
-		// 	}
-		// 	port := 0
-		// 	if _, err := fmt.Sscanf(parts[0], "%d", &port); err != nil {
-		// 		logger.Warn("Invalid port in TCP target: %s", parts[0])
-		// 		continue
-		// 	}
-		// 	desiredTCP[port] = parts[1] + ":" + parts[2]
-		// }
-
-		// desiredUDP := make(map[int]string)
-		// for _, t := range syncData.Targets.UDP {
-		// 	parts := strings.Split(t, ":")
-		// 	if len(parts) != 3 {
-		// 		logger.Warn("Invalid UDP target format: %s", t)
-		// 		continue
-		// 	}
-		// 	port := 0
-		// 	if _, err := fmt.Sscanf(parts[0], "%d", &port); err != nil {
-		// 		logger.Warn("Invalid port in UDP target: %s", parts[0])
-		// 		continue
-		// 	}
-		// 	desiredUDP[port] = parts[1] + ":" + parts[2]
-		// }
-
-		// // Get current targets from proxy manager
-		// currentTCP, currentUDP := pm.GetTargets()
-
-		// // Sync TCP targets
-		// // Remove TCP targets not in desired set
-		// if tcpForIP, ok := currentTCP[wgData.TunnelIP]; ok {
-		// 	for port := range tcpForIP {
-		// 		if _, exists := desiredTCP[port]; !exists {
-		// 			logger.Info("Sync: removing TCP target on port %d", port)
-		// 			targetStr := fmt.Sprintf("%d:%s", port, tcpForIP[port])
-		// 			updateTargets(pm, "remove", wgData.TunnelIP, "tcp", TargetData{Targets: []string{targetStr}})
-		// 		}
-		// 	}
-		// }
-
-		// // Add TCP targets that are missing
-		// for port, target := range desiredTCP {
-		// 	needsAdd := true
-		// 	if tcpForIP, ok := currentTCP[wgData.TunnelIP]; ok {
-		// 		if currentTarget, exists := tcpForIP[port]; exists {
-		// 			// Check if target address changed
-		// 			if currentTarget == target {
-		// 				needsAdd = false
-		// 			} else {
-		// 				// Target changed, remove old one first
-		// 				logger.Info("Sync: updating TCP target on port %d", port)
-		// 				targetStr := fmt.Sprintf("%d:%s", port, currentTarget)
-		// 				updateTargets(pm, "remove", wgData.TunnelIP, "tcp", TargetData{Targets: []string{targetStr}})
-		// 			}
-		// 		}
-		// 	}
-		// 	if needsAdd {
-		// 		logger.Info("Sync: adding TCP target on port %d -> %s", port, target)
-		// 		targetStr := fmt.Sprintf("%d:%s", port, target)
-		// 		updateTargets(pm, "add", wgData.TunnelIP, "tcp", TargetData{Targets: []string{targetStr}})
-		// 	}
-		// }
-
-		// // Sync UDP targets
-		// // Remove UDP targets not in desired set
-		// if udpForIP, ok := currentUDP[wgData.TunnelIP]; ok {
-		// 	for port := range udpForIP {
-		// 		if _, exists := desiredUDP[port]; !exists {
-		// 			logger.Info("Sync: removing UDP target on port %d", port)
-		// 			targetStr := fmt.Sprintf("%d:%s", port, udpForIP[port])
-		// 			updateTargets(pm, "remove", wgData.TunnelIP, "udp", TargetData{Targets: []string{targetStr}})
-		// 		}
-		// 	}
-		// }
-
-		// // Add UDP targets that are missing
-		// for port, target := range desiredUDP {
-		// 	needsAdd := true
-		// 	if udpForIP, ok := currentUDP[wgData.TunnelIP]; ok {
-		// 		if currentTarget, exists := udpForIP[port]; exists {
-		// 			// Check if target address changed
-		// 			if currentTarget == target {
-		// 				needsAdd = false
-		// 			} else {
-		// 				// Target changed, remove old one first
-		// 				logger.Info("Sync: updating UDP target on port %d", port)
-		// 				targetStr := fmt.Sprintf("%d:%s", port, currentTarget)
-		// 				updateTargets(pm, "remove", wgData.TunnelIP, "udp", TargetData{Targets: []string{targetStr}})
-		// 			}
-		// 		}
-		// 	}
-		// 	if needsAdd {
-		// 		logger.Info("Sync: adding UDP target on port %d -> %s", port, target)
-		// 		targetStr := fmt.Sprintf("%d:%s", port, target)
-		// 		updateTargets(pm, "add", wgData.TunnelIP, "udp", TargetData{Targets: []string{targetStr}})
-		// 	}
-		// }
-
-		// // Sync health check targets
-		// if err := healthMonitor.SyncTargets(syncData.HealthCheckTargets); err != nil {
-		// 	logger.Error("Failed to sync health check targets: %v", err)
-		// } else {
-		// 	logger.Info("Successfully synced health check targets")
-		// }
-
-		logger.Info("Sync complete")
-	})
-
 	// Register handler for Docker socket check
 	client.RegisterHandler("newt/socket/check", func(msg websocket.WSMessage) {
 		logger.Debug("Received Docker socket check request")
@@ -1493,6 +1168,94 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		}
 	})
 
+	// EXPERIMENTAL: WHAT SHOULD WE DO ABOUT SECURITY?
+	client.RegisterHandler("newt/send/ssh/publicKey", func(msg websocket.WSMessage) {
+		logger.Debug("Received SSH public key request")
+
+		var sshPublicKeyData SSHPublicKeyData
+
+		jsonData, err := json.Marshal(msg.Data)
+		if err != nil {
+			logger.Info(fmtErrMarshaling, err)
+			return
+		}
+		if err := json.Unmarshal(jsonData, &sshPublicKeyData); err != nil {
+			logger.Info("Error unmarshaling SSH public key data: %v", err)
+			return
+		}
+
+		sshPublicKey := sshPublicKeyData.PublicKey
+
+		if authorizedKeysFile == "" {
+			logger.Debug("No authorized keys file set, skipping public key response")
+			return
+		}
+
+		// Expand tilde to home directory if present
+		expandedPath := authorizedKeysFile
+		if strings.HasPrefix(authorizedKeysFile, "~/") {
+			homeDir, err := os.UserHomeDir()
+			if err != nil {
+				logger.Error("Failed to get user home directory: %v", err)
+				return
+			}
+			expandedPath = filepath.Join(homeDir, authorizedKeysFile[2:])
+		}
+
+		// if it is set but the file does not exist, create it
+		if _, err := os.Stat(expandedPath); os.IsNotExist(err) {
+			logger.Debug("Authorized keys file does not exist, creating it: %s", expandedPath)
+			if err := os.MkdirAll(filepath.Dir(expandedPath), 0755); err != nil {
+				logger.Error("Failed to create directory for authorized keys file: %v", err)
+				return
+			}
+			if _, err := os.Create(expandedPath); err != nil {
+				logger.Error("Failed to create authorized keys file: %v", err)
+				return
+			}
+		}
+
+		// Check if the public key already exists in the file
+		fileContent, err := os.ReadFile(expandedPath)
+		if err != nil {
+			logger.Error("Failed to read authorized keys file: %v", err)
+			return
+		}
+
+		// Check if the key already exists (trim whitespace for comparison)
+		existingKeys := strings.Split(string(fileContent), "\n")
+		keyAlreadyExists := false
+		trimmedNewKey := strings.TrimSpace(sshPublicKey)
+
+		for _, existingKey := range existingKeys {
+			if strings.TrimSpace(existingKey) == trimmedNewKey && trimmedNewKey != "" {
+				keyAlreadyExists = true
+				break
+			}
+		}
+
+		if keyAlreadyExists {
+			logger.Info("SSH public key already exists in authorized keys file, skipping")
+			return
+		}
+
+		// append the public key to the authorized keys file
+		logger.Debug("Appending public key to authorized keys file: %s", sshPublicKey)
+		file, err := os.OpenFile(expandedPath, os.O_APPEND|os.O_WRONLY, 0644)
+		if err != nil {
+			logger.Error("Failed to open authorized keys file: %v", err)
+			return
+		}
+		defer file.Close()
+
+		if _, err := file.WriteString(sshPublicKey + "\n"); err != nil {
+			logger.Error("Failed to write public key to authorized keys file: %v", err)
+			return
+		}
+
+		logger.Info("SSH public key appended to authorized keys file")
+	})
+
 	// Register handler for adding health check targets
 	client.RegisterHandler("newt/healthcheck/add", func(msg websocket.WSMessage) {
 		logger.Debug("Received health check add request: %+v", msg)
@@ -1648,175 +1411,6 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		}
 	})
 
-	// Register handler for SSH certificate issued events
-	client.RegisterHandler("newt/pam/connection", func(msg websocket.WSMessage) {
-		logger.Debug("Received SSH certificate issued message")
-
-		// Define the structure of the incoming message
-		type SSHCertData struct {
-			MessageId          int    `json:"messageId"`
-			AgentPort          int    `json:"agentPort"`
-			AgentHost          string `json:"agentHost"`
-			ExternalAuthDaemon bool   `json:"externalAuthDaemon"`
-			CACert             string `json:"caCert"`
-			Username           string `json:"username"`
-			NiceID             string `json:"niceId"`
-			Metadata           struct {
-				SudoMode     string   `json:"sudoMode"`
-				SudoCommands []string `json:"sudoCommands"`
-				Homedir      bool     `json:"homedir"`
-				Groups       []string `json:"groups"`
-			} `json:"metadata"`
-		}
-
-		var certData SSHCertData
-		jsonData, err := json.Marshal(msg.Data)
-		if err != nil {
-			logger.Error("Error marshaling SSH cert data: %v", err)
-			return
-		}
-
-		// print the received data for debugging
-		logger.Debug("Received SSH cert data: %s", string(jsonData))
-
-		if err := json.Unmarshal(jsonData, &certData); err != nil {
-			logger.Error("Error unmarshaling SSH cert data: %v", err)
-			return
-		}
-
-		// Check if we're running the auth daemon internally
-		if authDaemonServer != nil && !certData.ExternalAuthDaemon { // if the auth daemon is running internally and the external auth daemon is not enabled
-			// Call ProcessConnection directly when running internally
-			logger.Debug("Calling internal auth daemon ProcessConnection for user %s", certData.Username)
-
-			authDaemonServer.ProcessConnection(authdaemon.ConnectionRequest{
-				CaCert:   certData.CACert,
-				NiceId:   certData.NiceID,
-				Username: certData.Username,
-				Metadata: authdaemon.ConnectionMetadata{
-					SudoMode:     certData.Metadata.SudoMode,
-					SudoCommands: certData.Metadata.SudoCommands,
-					Homedir:      certData.Metadata.Homedir,
-					Groups:       certData.Metadata.Groups,
-				},
-			})
-
-			// Send success response back to cloud
-			err = client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-				"messageId": certData.MessageId,
-				"complete":  true,
-			})
-
-			logger.Info("Successfully processed connection via internal auth daemon for user %s", certData.Username)
-		} else {
-			// External auth daemon mode - make HTTP request
-			// Check if auth daemon key is configured
-			if authDaemonKey == "" {
-				logger.Error("Auth daemon key not configured, cannot communicate with daemon")
-				// Send failure response back to cloud
-				err := client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-					"messageId": certData.MessageId,
-					"complete":  true,
-					"error":     "auth daemon key not configured",
-				})
-				if err != nil {
-					logger.Error("Failed to send SSH cert failure response: %v", err)
-				}
-				return
-			}
-
-			// Prepare the request body for the auth daemon
-			requestBody := map[string]interface{}{
-				"caCert":   certData.CACert,
-				"niceId":   certData.NiceID,
-				"username": certData.Username,
-				"metadata": map[string]interface{}{
-					"sudoMode":     certData.Metadata.SudoMode,
-					"sudoCommands": certData.Metadata.SudoCommands,
-					"homedir":      certData.Metadata.Homedir,
-					"groups":       certData.Metadata.Groups,
-				},
-			}
-
-			requestJSON, err := json.Marshal(requestBody)
-			if err != nil {
-				logger.Error("Failed to marshal auth daemon request: %v", err)
-				// Send failure response
-				client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-					"messageId": certData.MessageId,
-					"complete":  true,
-					"error":     fmt.Sprintf("failed to marshal request: %v", err),
-				})
-				return
-			}
-
-			// Create HTTPS client that skips certificate verification
-			// (auth daemon uses self-signed cert)
-			httpClient := &http.Client{
-				Transport: &http.Transport{
-					TLSClientConfig: &tls.Config{
-						InsecureSkipVerify: true,
-					},
-				},
-				Timeout: 10 * time.Second,
-			}
-
-			// Make the request to the auth daemon
-			url := fmt.Sprintf("https://%s:%d/connection", certData.AgentHost, certData.AgentPort)
-			req, err := http.NewRequest("POST", url, bytes.NewBuffer(requestJSON))
-			if err != nil {
-				logger.Error("Failed to create auth daemon request: %v", err)
-				client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-					"messageId": certData.MessageId,
-					"complete":  true,
-					"error":     fmt.Sprintf("failed to create request: %v", err),
-				})
-				return
-			}
-
-			// Set headers
-			req.Header.Set("Content-Type", "application/json")
-			req.Header.Set("Authorization", "Bearer "+authDaemonKey)
-
-			logger.Debug("Sending SSH cert to auth daemon at %s", url)
-
-			// Send the request
-			resp, err := httpClient.Do(req)
-			if err != nil {
-				logger.Error("Failed to connect to auth daemon: %v", err)
-				client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-					"messageId": certData.MessageId,
-					"complete":  true,
-					"error":     fmt.Sprintf("failed to connect to auth daemon: %v", err),
-				})
-				return
-			}
-			defer resp.Body.Close()
-
-			// Check response status
-			if resp.StatusCode != http.StatusOK {
-				logger.Error("Auth daemon returned non-OK status: %d", resp.StatusCode)
-				client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-					"messageId": certData.MessageId,
-					"complete":  true,
-					"error":     fmt.Sprintf("auth daemon returned status %d", resp.StatusCode),
-				})
-				return
-			}
-
-			logger.Info("Successfully registered SSH certificate with external auth daemon for user %s", certData.Username)
-		}
-
-		// Send success response back to cloud
-		err = client.SendMessage("ws/round-trip/complete", map[string]interface{}{
-			"messageId": certData.MessageId,
-			"complete":  true,
-		})
-		if err != nil {
-			logger.Error("Failed to send SSH cert success response: %v", err)
-		}
-	})
-
 	client.OnConnect(func() error {
 		publicKey = privateKey.PublicKey()
 		logger.Debug("Public key: %s", publicKey)
@@ -1828,11 +1422,8 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 				stopFunc()
 			}
 			// request from the server the list of nodes to ping
-			pingChainId := generateChainId()
-			pendingPingChainId = pingChainId
 			stopFunc = client.SendMessageInterval("newt/ping/request", map[string]interface{}{
 				"noCloud": noCloud,
-				"chainId": pingChainId,
 			}, 3*time.Second)
 			logger.Debug("Requesting exit nodes from server")
 
@@ -1841,46 +1432,17 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 			} else {
 				logger.Warn("CLIENTS WILL NOT WORK ON THIS VERSION OF NEWT WITH THIS VERSION OF PANGOLIN, PLEASE UPDATE THE SERVER TO 1.13 OR HIGHER OR DOWNGRADE NEWT")
 			}
-			
-			sendBlueprint(client, blueprintFile)
-			if client.WasJustProvisioned() {
-				logger.Info("Provisioning detected – sending provisioning blueprint")
-				sendBlueprint(client, provisioningBlueprintFile)
-			}
-		} else {
-			// Resend current health check status for all targets in case the server
-			// missed updates while newt was disconnected.
-			targets := healthMonitor.GetTargets()
-			if len(targets) > 0 {
-				healthStatuses := make(map[int]interface{})
-				for id, target := range targets {
-					healthStatuses[id] = map[string]interface{}{
-						"status":     target.Status.String(),
-						"lastCheck":  target.LastCheck.Format(time.RFC3339),
-						"checkCount": target.CheckCount,
-						"lastError":  target.LastError,
-						"config":     target.Config,
-					}
-				}
-				logger.Debug("Reconnected: resending health check status for %d targets", len(healthStatuses))
-				if err := client.SendMessage("newt/healthcheck/status", map[string]interface{}{
-					"targets": healthStatuses,
-				}); err != nil {
-					logger.Error("Failed to resend health check status on reconnect: %v", err)
-				}
-			}
 		}
 
 		// Send registration message to the server for backward compatibility
-		bcChainId := generateChainId()
-		pendingRegisterChainId = bcChainId
 		err := client.SendMessage(topicWGRegister, map[string]interface{}{
 			"publicKey":           publicKey.String(),
 			"newtVersion":         newtVersion,
 			"backwardsCompatible": true,
-			"chainId":             bcChainId,
 		})
 
+		sendBlueprint(client)
+
 		if err != nil {
 			logger.Error("Failed to send registration message: %v", err)
 			return err
@@ -1945,8 +1507,6 @@ persistent_keepalive_interval=5`, util.FixKey(privateKey.String()), util.FixKey(
 		pm.Stop()
 	}
 
-	client.SendMessage("newt/disconnecting", map[string]any{})
-
 	if client != nil {
 		client.Close()
 	}

netstack2/access_log.go

@@ -1,514 +0,0 @@
-package netstack2
-
-import (
-	"bytes"
-	"compress/zlib"
-	"crypto/rand"
-	"encoding/base64"
-	"encoding/hex"
-	"encoding/json"
-	"net"
-	"sort"
-	"sync"
-	"time"
-
-	"github.com/fosrl/newt/logger"
-)
-
-const (
-	// flushInterval is how often the access logger flushes completed sessions to the server
-	flushInterval = 60 * time.Second
-
-	// maxBufferedSessions is the max number of completed sessions to buffer before forcing a flush
-	maxBufferedSessions = 100
-
-	// sessionGapThreshold is the maximum gap between the end of one connection
-	// and the start of the next for them to be considered part of the same session.
-	// If the gap exceeds this, a new consolidated session is created.
-	sessionGapThreshold = 5 * time.Second
-
-	// minConnectionsToConsolidate is the minimum number of connections in a group
-	// before we bother consolidating. Groups smaller than this are sent as-is.
-	minConnectionsToConsolidate = 2
-)
-
-// SendFunc is a callback that sends compressed access log data to the server.
-// The data is a base64-encoded zlib-compressed JSON array of AccessSession objects.
-type SendFunc func(data string) error
-
-// AccessSession represents a tracked access session through the proxy
-type AccessSession struct {
-	SessionID       string    `json:"sessionId"`
-	ResourceID      int       `json:"resourceId"`
-	SourceAddr      string    `json:"sourceAddr"`
-	DestAddr        string    `json:"destAddr"`
-	Protocol        string    `json:"protocol"`
-	StartedAt       time.Time `json:"startedAt"`
-	EndedAt         time.Time `json:"endedAt,omitempty"`
-	BytesTx         int64     `json:"bytesTx"`
-	BytesRx         int64     `json:"bytesRx"`
-	ConnectionCount int       `json:"connectionCount,omitempty"` // number of raw connections merged into this session (0 or 1 = single)
-}
-
-// udpSessionKey identifies a unique UDP "session" by src -> dst
-type udpSessionKey struct {
-	srcAddr  string
-	dstAddr  string
-	protocol string
-}
-
-// consolidationKey groups connections that may be part of the same logical session.
-// Source port is intentionally excluded so that many ephemeral-port connections
-// from the same source IP to the same destination are grouped together.
-type consolidationKey struct {
-	sourceIP   string // IP only, no port
-	destAddr   string // full host:port of the destination
-	protocol   string
-	resourceID int
-}
-
-// AccessLogger tracks access sessions for resources and periodically
-// flushes completed sessions to the server via a configurable SendFunc.
-type AccessLogger struct {
-	mu                sync.Mutex
-	sessions          map[string]*AccessSession       // active sessions: sessionID -> session
-	udpSessions       map[udpSessionKey]*AccessSession // active UDP sessions for dedup
-	completedSessions []*AccessSession                 // completed sessions waiting to be flushed
-	udpTimeout        time.Duration
-	sendFn            SendFunc
-	stopCh            chan struct{}
-	flushDone         chan struct{} // closed after the flush goroutine exits
-}
-
-// NewAccessLogger creates a new access logger.
-// udpTimeout controls how long a UDP session is kept alive without traffic before being ended.
-func NewAccessLogger(udpTimeout time.Duration) *AccessLogger {
-	al := &AccessLogger{
-		sessions:          make(map[string]*AccessSession),
-		udpSessions:       make(map[udpSessionKey]*AccessSession),
-		completedSessions: make([]*AccessSession, 0),
-		udpTimeout:        udpTimeout,
-		stopCh:            make(chan struct{}),
-		flushDone:         make(chan struct{}),
-	}
-	go al.backgroundLoop()
-	return al
-}
-
-// SetSendFunc sets the callback used to send compressed access log batches
-// to the server. This can be called after construction once the websocket
-// client is available.
-func (al *AccessLogger) SetSendFunc(fn SendFunc) {
-	al.mu.Lock()
-	defer al.mu.Unlock()
-	al.sendFn = fn
-}
-
-// generateSessionID creates a random session identifier
-func generateSessionID() string {
-	b := make([]byte, 8)
-	rand.Read(b)
-	return hex.EncodeToString(b)
-}
-
-// StartTCPSession logs the start of a TCP session and returns a session ID.
-func (al *AccessLogger) StartTCPSession(resourceID int, srcAddr, dstAddr string) string {
-	sessionID := generateSessionID()
-	now := time.Now()
-
-	session := &AccessSession{
-		SessionID:  sessionID,
-		ResourceID: resourceID,
-		SourceAddr: srcAddr,
-		DestAddr:   dstAddr,
-		Protocol:   "tcp",
-		StartedAt:  now,
-	}
-
-	al.mu.Lock()
-	al.sessions[sessionID] = session
-	al.mu.Unlock()
-
-	logger.Info("ACCESS START session=%s resource=%d proto=tcp src=%s dst=%s time=%s",
-		sessionID, resourceID, srcAddr, dstAddr, now.Format(time.RFC3339))
-
-	return sessionID
-}
-
-// EndTCPSession logs the end of a TCP session and queues it for sending.
-func (al *AccessLogger) EndTCPSession(sessionID string) {
-	now := time.Now()
-
-	al.mu.Lock()
-	session, ok := al.sessions[sessionID]
-	if ok {
-		session.EndedAt = now
-		delete(al.sessions, sessionID)
-		al.completedSessions = append(al.completedSessions, session)
-	}
-	shouldFlush := len(al.completedSessions) >= maxBufferedSessions
-	al.mu.Unlock()
-
-	if ok {
-		duration := now.Sub(session.StartedAt)
-		logger.Info("ACCESS END session=%s resource=%d proto=tcp src=%s dst=%s started=%s ended=%s duration=%s",
-			sessionID, session.ResourceID, session.SourceAddr, session.DestAddr,
-			session.StartedAt.Format(time.RFC3339), now.Format(time.RFC3339), duration)
-	}
-
-	if shouldFlush {
-		al.flush()
-	}
-}
-
-// TrackUDPSession starts or returns an existing UDP session. Returns the session ID.
-func (al *AccessLogger) TrackUDPSession(resourceID int, srcAddr, dstAddr string) string {
-	key := udpSessionKey{
-		srcAddr:  srcAddr,
-		dstAddr:  dstAddr,
-		protocol: "udp",
-	}
-
-	al.mu.Lock()
-	defer al.mu.Unlock()
-
-	if existing, ok := al.udpSessions[key]; ok {
-		return existing.SessionID
-	}
-
-	sessionID := generateSessionID()
-	now := time.Now()
-
-	session := &AccessSession{
-		SessionID:  sessionID,
-		ResourceID: resourceID,
-		SourceAddr: srcAddr,
-		DestAddr:   dstAddr,
-		Protocol:   "udp",
-		StartedAt:  now,
-	}
-
-	al.sessions[sessionID] = session
-	al.udpSessions[key] = session
-
-	logger.Info("ACCESS START session=%s resource=%d proto=udp src=%s dst=%s time=%s",
-		sessionID, resourceID, srcAddr, dstAddr, now.Format(time.RFC3339))
-
-	return sessionID
-}
-
-// EndUDPSession ends a UDP session and queues it for sending.
-func (al *AccessLogger) EndUDPSession(sessionID string) {
-	now := time.Now()
-
-	al.mu.Lock()
-	session, ok := al.sessions[sessionID]
-	if ok {
-		session.EndedAt = now
-		delete(al.sessions, sessionID)
-		key := udpSessionKey{
-			srcAddr:  session.SourceAddr,
-			dstAddr:  session.DestAddr,
-			protocol: "udp",
-		}
-		delete(al.udpSessions, key)
-		al.completedSessions = append(al.completedSessions, session)
-	}
-	shouldFlush := len(al.completedSessions) >= maxBufferedSessions
-	al.mu.Unlock()
-
-	if ok {
-		duration := now.Sub(session.StartedAt)
-		logger.Info("ACCESS END session=%s resource=%d proto=udp src=%s dst=%s started=%s ended=%s duration=%s",
-			sessionID, session.ResourceID, session.SourceAddr, session.DestAddr,
-			session.StartedAt.Format(time.RFC3339), now.Format(time.RFC3339), duration)
-	}
-
-	if shouldFlush {
-		al.flush()
-	}
-}
-
-// backgroundLoop handles periodic flushing and stale session reaping.
-func (al *AccessLogger) backgroundLoop() {
-	defer close(al.flushDone)
-
-	flushTicker := time.NewTicker(flushInterval)
-	defer flushTicker.Stop()
-
-	reapTicker := time.NewTicker(30 * time.Second)
-	defer reapTicker.Stop()
-
-	for {
-		select {
-		case <-al.stopCh:
-			return
-		case <-flushTicker.C:
-			al.flush()
-		case <-reapTicker.C:
-			al.reapStaleSessions()
-		}
-	}
-}
-
-// reapStaleSessions cleans up UDP sessions that were not properly ended.
-func (al *AccessLogger) reapStaleSessions() {
-	al.mu.Lock()
-	defer al.mu.Unlock()
-
-	staleThreshold := time.Now().Add(-5 * time.Minute)
-
-	for key, session := range al.udpSessions {
-		if session.StartedAt.Before(staleThreshold) && session.EndedAt.IsZero() {
-			now := time.Now()
-			session.EndedAt = now
-			duration := now.Sub(session.StartedAt)
-			logger.Info("ACCESS END (reaped) session=%s resource=%d proto=udp src=%s dst=%s started=%s ended=%s duration=%s",
-				session.SessionID, session.ResourceID, session.SourceAddr, session.DestAddr,
-				session.StartedAt.Format(time.RFC3339), now.Format(time.RFC3339), duration)
-			al.completedSessions = append(al.completedSessions, session)
-			delete(al.sessions, session.SessionID)
-			delete(al.udpSessions, key)
-		}
-	}
-}
-
-// extractIP strips the port from an address string and returns just the IP.
-// If the address has no port component it is returned as-is.
-func extractIP(addr string) string {
-	host, _, err := net.SplitHostPort(addr)
-	if err != nil {
-		// Might already be a bare IP
-		return addr
-	}
-	return host
-}
-
-// consolidateSessions takes a slice of completed sessions and merges bursts of
-// short-lived connections from the same source IP to the same destination into
-// single higher-level session entries.
-//
-// The algorithm:
-//  1. Group sessions by (sourceIP, destAddr, protocol, resourceID).
-//  2. Within each group, sort by StartedAt.
-//  3. Walk through the sorted list and merge consecutive sessions whose gap
-//     (previous EndedAt → next StartedAt) is ≤ sessionGapThreshold.
-//  4. For merged sessions the earliest StartedAt and latest EndedAt are kept,
-//     bytes are summed, and ConnectionCount records how many raw connections
-//     were folded in. If the merged connections used more than one source port,
-//     SourceAddr is set to just the IP (port omitted).
-//  5. Groups with fewer than minConnectionsToConsolidate members are passed
-//     through unmodified.
-func consolidateSessions(sessions []*AccessSession) []*AccessSession {
-	if len(sessions) <= 1 {
-		return sessions
-	}
-
-	// Group sessions by consolidation key
-	groups := make(map[consolidationKey][]*AccessSession)
-	for _, s := range sessions {
-		key := consolidationKey{
-			sourceIP:   extractIP(s.SourceAddr),
-			destAddr:   s.DestAddr,
-			protocol:   s.Protocol,
-			resourceID: s.ResourceID,
-		}
-		groups[key] = append(groups[key], s)
-	}
-
-	result := make([]*AccessSession, 0, len(sessions))
-
-	for key, group := range groups {
-		// Small groups don't need consolidation
-		if len(group) < minConnectionsToConsolidate {
-			result = append(result, group...)
-			continue
-		}
-
-		// Sort the group by start time so we can detect gaps
-		sort.Slice(group, func(i, j int) bool {
-			return group[i].StartedAt.Before(group[j].StartedAt)
-		})
-
-		// Walk through and merge runs that are within the gap threshold
-		var merged []*AccessSession
-		cur := cloneSession(group[0])
-		cur.ConnectionCount = 1
-		sourcePorts := make(map[string]struct{})
-		sourcePorts[cur.SourceAddr] = struct{}{}
-
-		for i := 1; i < len(group); i++ {
-			s := group[i]
-
-			// Determine the gap: from the latest end time we've seen so far to the
-			// start of the next connection.
-			gapRef := cur.EndedAt
-			if gapRef.IsZero() {
-				gapRef = cur.StartedAt
-			}
-			gap := s.StartedAt.Sub(gapRef)
-
-			if gap <= sessionGapThreshold {
-				// Merge into the current consolidated session
-				cur.ConnectionCount++
-				cur.BytesTx += s.BytesTx
-				cur.BytesRx += s.BytesRx
-				sourcePorts[s.SourceAddr] = struct{}{}
-
-				// Extend EndedAt to the latest time
-				endTime := s.EndedAt
-				if endTime.IsZero() {
-					endTime = s.StartedAt
-				}
-				if endTime.After(cur.EndedAt) {
-					cur.EndedAt = endTime
-				}
-			} else {
-				// Gap exceeded — finalize the current session and start a new one
-				finalizeMergedSourceAddr(cur, key.sourceIP, sourcePorts)
-				merged = append(merged, cur)
-
-				cur = cloneSession(s)
-				cur.ConnectionCount = 1
-				sourcePorts = make(map[string]struct{})
-				sourcePorts[s.SourceAddr] = struct{}{}
-			}
-		}
-
-		// Finalize the last accumulated session
-		finalizeMergedSourceAddr(cur, key.sourceIP, sourcePorts)
-		merged = append(merged, cur)
-
-		result = append(result, merged...)
-	}
-
-	return result
-}
-
-// cloneSession creates a shallow copy of an AccessSession.
-func cloneSession(s *AccessSession) *AccessSession {
-	cp := *s
-	return &cp
-}
-
-// finalizeMergedSourceAddr sets the SourceAddr on a consolidated session.
-// If multiple distinct source addresses (ports) were seen, the port is
-// stripped and only the IP is kept so the log isn't misleading.
-func finalizeMergedSourceAddr(s *AccessSession, sourceIP string, ports map[string]struct{}) {
-	if len(ports) > 1 {
-		// Multiple source ports — just report the IP
-		s.SourceAddr = sourceIP
-	}
-	// Otherwise keep the original SourceAddr which already has ip:port
-}
-
-// flush drains the completed sessions buffer, consolidates bursts of
-// short-lived connections, compresses with zlib, and sends via the SendFunc.
-func (al *AccessLogger) flush() {
-	al.mu.Lock()
-	if len(al.completedSessions) == 0 {
-		al.mu.Unlock()
-		return
-	}
-	batch := al.completedSessions
-	al.completedSessions = make([]*AccessSession, 0)
-	sendFn := al.sendFn
-	al.mu.Unlock()
-
-	if sendFn == nil {
-		logger.Debug("Access logger: no send function configured, discarding %d sessions", len(batch))
-		return
-	}
-
-	// Consolidate bursts of short-lived connections into higher-level sessions
-	originalCount := len(batch)
-	batch = consolidateSessions(batch)
-	if len(batch) != originalCount {
-		logger.Info("Access logger: consolidated %d raw connections into %d sessions", originalCount, len(batch))
-	}
-
-	compressed, err := compressSessions(batch)
-	if err != nil {
-		logger.Error("Access logger: failed to compress %d sessions: %v", len(batch), err)
-		return
-	}
-
-	if err := sendFn(compressed); err != nil {
-		logger.Error("Access logger: failed to send %d sessions: %v", len(batch), err)
-		// Re-queue the batch so we don't lose data
-		al.mu.Lock()
-		al.completedSessions = append(batch, al.completedSessions...)
-		// Cap re-queued data to prevent unbounded growth if server is unreachable
-		if len(al.completedSessions) > maxBufferedSessions*5 {
-			dropped := len(al.completedSessions) - maxBufferedSessions*5
-			al.completedSessions = al.completedSessions[:maxBufferedSessions*5]
-			logger.Warn("Access logger: buffer overflow, dropped %d oldest sessions", dropped)
-		}
-		al.mu.Unlock()
-		return
-	}
-
-	logger.Info("Access logger: sent %d sessions to server", len(batch))
-}
-
-// compressSessions JSON-encodes the sessions, compresses with zlib, and returns
-// a base64-encoded string suitable for embedding in a JSON message.
-func compressSessions(sessions []*AccessSession) (string, error) {
-	jsonData, err := json.Marshal(sessions)
-	if err != nil {
-		return "", err
-	}
-
-	var buf bytes.Buffer
-	w, err := zlib.NewWriterLevel(&buf, zlib.BestCompression)
-	if err != nil {
-		return "", err
-	}
-	if _, err := w.Write(jsonData); err != nil {
-		w.Close()
-		return "", err
-	}
-	if err := w.Close(); err != nil {
-		return "", err
-	}
-
-	return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
-}
-
-// Close shuts down the background loop, ends all active sessions,
-// and performs one final flush to send everything to the server.
-func (al *AccessLogger) Close() {
-	// Signal the background loop to stop
-	select {
-	case <-al.stopCh:
-		// Already closed
-		return
-	default:
-		close(al.stopCh)
-	}
-
-	// Wait for the background loop to exit so we don't race on flush
-	<-al.flushDone
-
-	al.mu.Lock()
-	now := time.Now()
-
-	// End all active sessions and move them to the completed buffer
-	for _, session := range al.sessions {
-		if session.EndedAt.IsZero() {
-			session.EndedAt = now
-			duration := now.Sub(session.StartedAt)
-			logger.Info("ACCESS END (shutdown) session=%s resource=%d proto=%s src=%s dst=%s started=%s ended=%s duration=%s",
-				session.SessionID, session.ResourceID, session.Protocol, session.SourceAddr, session.DestAddr,
-				session.StartedAt.Format(time.RFC3339), now.Format(time.RFC3339), duration)
-			al.completedSessions = append(al.completedSessions, session)
-		}
-	}
-
-	al.sessions = make(map[string]*AccessSession)
-	al.udpSessions = make(map[udpSessionKey]*AccessSession)
-	al.mu.Unlock()
-
-	// Final flush to send all remaining sessions to the server
-	al.flush()
-}

netstack2/access_log_test.go

@@ -1,811 +0,0 @@
-package netstack2
-
-import (
-	"testing"
-	"time"
-)
-
-func TestExtractIP(t *testing.T) {
-	tests := []struct {
-		name     string
-		addr     string
-		expected string
-	}{
-		{"ipv4 with port", "192.168.1.1:12345", "192.168.1.1"},
-		{"ipv4 without port", "192.168.1.1", "192.168.1.1"},
-		{"ipv6 with port", "[::1]:12345", "::1"},
-		{"ipv6 without port", "::1", "::1"},
-		{"empty string", "", ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			result := extractIP(tt.addr)
-			if result != tt.expected {
-				t.Errorf("extractIP(%q) = %q, want %q", tt.addr, result, tt.expected)
-			}
-		})
-	}
-}
-
-func TestConsolidateSessions_Empty(t *testing.T) {
-	result := consolidateSessions(nil)
-	if result != nil {
-		t.Errorf("expected nil, got %v", result)
-	}
-
-	result = consolidateSessions([]*AccessSession{})
-	if len(result) != 0 {
-		t.Errorf("expected empty slice, got %d items", len(result))
-	}
-}
-
-func TestConsolidateSessions_SingleSession(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "abc123",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(1 * time.Second),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 session, got %d", len(result))
-	}
-	if result[0].SourceAddr != "10.0.0.1:5000" {
-		t.Errorf("expected source addr preserved, got %q", result[0].SourceAddr)
-	}
-}
-
-func TestConsolidateSessions_MergesBurstFromSameSourceIP(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-			BytesTx:    100,
-			BytesRx:    200,
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-			BytesTx:    150,
-			BytesRx:    250,
-		},
-		{
-			SessionID:  "s3",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5002",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(400 * time.Millisecond),
-			EndedAt:    now.Add(500 * time.Millisecond),
-			BytesTx:    50,
-			BytesRx:    75,
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 consolidated session, got %d", len(result))
-	}
-
-	s := result[0]
-	if s.ConnectionCount != 3 {
-		t.Errorf("expected ConnectionCount=3, got %d", s.ConnectionCount)
-	}
-	if s.SourceAddr != "10.0.0.1" {
-		t.Errorf("expected source addr to be IP only (multiple ports), got %q", s.SourceAddr)
-	}
-	if s.DestAddr != "192.168.1.100:443" {
-		t.Errorf("expected dest addr preserved, got %q", s.DestAddr)
-	}
-	if s.StartedAt != now {
-		t.Errorf("expected StartedAt to be earliest time")
-	}
-	if s.EndedAt != now.Add(500*time.Millisecond) {
-		t.Errorf("expected EndedAt to be latest time")
-	}
-	expectedTx := int64(300)
-	expectedRx := int64(525)
-	if s.BytesTx != expectedTx {
-		t.Errorf("expected BytesTx=%d, got %d", expectedTx, s.BytesTx)
-	}
-	if s.BytesRx != expectedRx {
-		t.Errorf("expected BytesRx=%d, got %d", expectedRx, s.BytesRx)
-	}
-}
-
-func TestConsolidateSessions_SameSourcePortPreserved(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 session, got %d", len(result))
-	}
-	if result[0].SourceAddr != "10.0.0.1:5000" {
-		t.Errorf("expected source addr with port preserved when all ports are the same, got %q", result[0].SourceAddr)
-	}
-	if result[0].ConnectionCount != 2 {
-		t.Errorf("expected ConnectionCount=2, got %d", result[0].ConnectionCount)
-	}
-}
-
-func TestConsolidateSessions_GapSplitsSessions(t *testing.T) {
-	now := time.Now()
-
-	// First burst
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-		// Big gap here (10 seconds)
-		{
-			SessionID:  "s3",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5002",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(10 * time.Second),
-			EndedAt:    now.Add(10*time.Second + 100*time.Millisecond),
-		},
-		{
-			SessionID:  "s4",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5003",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(10*time.Second + 200*time.Millisecond),
-			EndedAt:    now.Add(10*time.Second + 300*time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 2 {
-		t.Fatalf("expected 2 consolidated sessions (gap split), got %d", len(result))
-	}
-
-	// Find the sessions by their start time
-	var first, second *AccessSession
-	for _, s := range result {
-		if s.StartedAt.Equal(now) {
-			first = s
-		} else {
-			second = s
-		}
-	}
-
-	if first == nil || second == nil {
-		t.Fatal("could not find both consolidated sessions")
-	}
-
-	if first.ConnectionCount != 2 {
-		t.Errorf("first burst: expected ConnectionCount=2, got %d", first.ConnectionCount)
-	}
-	if second.ConnectionCount != 2 {
-		t.Errorf("second burst: expected ConnectionCount=2, got %d", second.ConnectionCount)
-	}
-}
-
-func TestConsolidateSessions_DifferentDestinationsNotMerged(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:8080",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	// Each goes to a different dest port so they should not be merged
-	if len(result) != 2 {
-		t.Fatalf("expected 2 sessions (different destinations), got %d", len(result))
-	}
-}
-
-func TestConsolidateSessions_DifferentProtocolsNotMerged(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "udp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 2 {
-		t.Fatalf("expected 2 sessions (different protocols), got %d", len(result))
-	}
-}
-
-func TestConsolidateSessions_DifferentResourceIDsNotMerged(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 2,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 2 {
-		t.Fatalf("expected 2 sessions (different resource IDs), got %d", len(result))
-	}
-}
-
-func TestConsolidateSessions_DifferentSourceIPsNotMerged(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.2:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 2 {
-		t.Fatalf("expected 2 sessions (different source IPs), got %d", len(result))
-	}
-}
-
-func TestConsolidateSessions_OutOfOrderInput(t *testing.T) {
-	now := time.Now()
-	// Provide sessions out of chronological order to verify sorting
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s3",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5002",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(400 * time.Millisecond),
-			EndedAt:    now.Add(500 * time.Millisecond),
-			BytesTx:    30,
-		},
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-			BytesTx:    10,
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-			BytesTx:    20,
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 consolidated session, got %d", len(result))
-	}
-
-	s := result[0]
-	if s.ConnectionCount != 3 {
-		t.Errorf("expected ConnectionCount=3, got %d", s.ConnectionCount)
-	}
-	if s.StartedAt != now {
-		t.Errorf("expected StartedAt to be earliest time")
-	}
-	if s.EndedAt != now.Add(500*time.Millisecond) {
-		t.Errorf("expected EndedAt to be latest time")
-	}
-	if s.BytesTx != 60 {
-		t.Errorf("expected BytesTx=60, got %d", s.BytesTx)
-	}
-}
-
-func TestConsolidateSessions_ExactlyAtGapThreshold(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			// Starts exactly sessionGapThreshold after s1 ends — should still merge
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(100*time.Millisecond + sessionGapThreshold),
-			EndedAt:    now.Add(100*time.Millisecond + sessionGapThreshold + 50*time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 session (gap exactly at threshold merges), got %d", len(result))
-	}
-	if result[0].ConnectionCount != 2 {
-		t.Errorf("expected ConnectionCount=2, got %d", result[0].ConnectionCount)
-	}
-}
-
-func TestConsolidateSessions_JustOverGapThreshold(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			// Starts 1ms over the gap threshold after s1 ends — should split
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(100*time.Millisecond + sessionGapThreshold + 1*time.Millisecond),
-			EndedAt:    now.Add(100*time.Millisecond + sessionGapThreshold + 50*time.Millisecond),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 2 {
-		t.Fatalf("expected 2 sessions (gap just over threshold splits), got %d", len(result))
-	}
-}
-
-func TestConsolidateSessions_UDPSessions(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		{
-			SessionID:  "u1",
-			ResourceID: 5,
-			SourceAddr: "10.0.0.1:6000",
-			DestAddr:   "192.168.1.100:53",
-			Protocol:   "udp",
-			StartedAt:  now,
-			EndedAt:    now.Add(50 * time.Millisecond),
-			BytesTx:    64,
-			BytesRx:    512,
-		},
-		{
-			SessionID:  "u2",
-			ResourceID: 5,
-			SourceAddr: "10.0.0.1:6001",
-			DestAddr:   "192.168.1.100:53",
-			Protocol:   "udp",
-			StartedAt:  now.Add(100 * time.Millisecond),
-			EndedAt:    now.Add(150 * time.Millisecond),
-			BytesTx:    64,
-			BytesRx:    256,
-		},
-		{
-			SessionID:  "u3",
-			ResourceID: 5,
-			SourceAddr: "10.0.0.1:6002",
-			DestAddr:   "192.168.1.100:53",
-			Protocol:   "udp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(250 * time.Millisecond),
-			BytesTx:    64,
-			BytesRx:    128,
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 consolidated UDP session, got %d", len(result))
-	}
-
-	s := result[0]
-	if s.Protocol != "udp" {
-		t.Errorf("expected protocol=udp, got %q", s.Protocol)
-	}
-	if s.ConnectionCount != 3 {
-		t.Errorf("expected ConnectionCount=3, got %d", s.ConnectionCount)
-	}
-	if s.SourceAddr != "10.0.0.1" {
-		t.Errorf("expected source addr to be IP only, got %q", s.SourceAddr)
-	}
-	if s.BytesTx != 192 {
-		t.Errorf("expected BytesTx=192, got %d", s.BytesTx)
-	}
-	if s.BytesRx != 896 {
-		t.Errorf("expected BytesRx=896, got %d", s.BytesRx)
-	}
-}
-
-func TestConsolidateSessions_MixedGroupsSomeConsolidatedSomeNot(t *testing.T) {
-	now := time.Now()
-	sessions := []*AccessSession{
-		// Group 1: 3 connections to :443 from same IP — should consolidate
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(100 * time.Millisecond),
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(200 * time.Millisecond),
-			EndedAt:    now.Add(300 * time.Millisecond),
-		},
-		{
-			SessionID:  "s3",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5002",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(400 * time.Millisecond),
-			EndedAt:    now.Add(500 * time.Millisecond),
-		},
-		// Group 2: 1 connection to :8080 from different IP — should pass through
-		{
-			SessionID:  "s4",
-			ResourceID: 2,
-			SourceAddr: "10.0.0.2:6000",
-			DestAddr:   "192.168.1.200:8080",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(1 * time.Second),
-			EndedAt:    now.Add(2 * time.Second),
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 2 {
-		t.Fatalf("expected 2 sessions total, got %d", len(result))
-	}
-
-	var consolidated, passthrough *AccessSession
-	for _, s := range result {
-		if s.ConnectionCount > 1 {
-			consolidated = s
-		} else {
-			passthrough = s
-		}
-	}
-
-	if consolidated == nil {
-		t.Fatal("expected a consolidated session")
-	}
-	if consolidated.ConnectionCount != 3 {
-		t.Errorf("consolidated: expected ConnectionCount=3, got %d", consolidated.ConnectionCount)
-	}
-
-	if passthrough == nil {
-		t.Fatal("expected a passthrough session")
-	}
-	if passthrough.SessionID != "s4" {
-		t.Errorf("passthrough: expected session s4, got %s", passthrough.SessionID)
-	}
-}
-
-func TestConsolidateSessions_OverlappingConnections(t *testing.T) {
-	now := time.Now()
-	// Connections that overlap in time (not sequential)
-	sessions := []*AccessSession{
-		{
-			SessionID:  "s1",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5000",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now,
-			EndedAt:    now.Add(5 * time.Second),
-			BytesTx:    100,
-		},
-		{
-			SessionID:  "s2",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5001",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(1 * time.Second),
-			EndedAt:    now.Add(3 * time.Second),
-			BytesTx:    200,
-		},
-		{
-			SessionID:  "s3",
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:5002",
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(2 * time.Second),
-			EndedAt:    now.Add(6 * time.Second),
-			BytesTx:    300,
-		},
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 1 {
-		t.Fatalf("expected 1 consolidated session, got %d", len(result))
-	}
-
-	s := result[0]
-	if s.ConnectionCount != 3 {
-		t.Errorf("expected ConnectionCount=3, got %d", s.ConnectionCount)
-	}
-	if s.StartedAt != now {
-		t.Error("expected StartedAt to be earliest")
-	}
-	if s.EndedAt != now.Add(6*time.Second) {
-		t.Error("expected EndedAt to be the latest end time")
-	}
-	if s.BytesTx != 600 {
-		t.Errorf("expected BytesTx=600, got %d", s.BytesTx)
-	}
-}
-
-func TestConsolidateSessions_DoesNotMutateOriginals(t *testing.T) {
-	now := time.Now()
-	s1 := &AccessSession{
-		SessionID:  "s1",
-		ResourceID: 1,
-		SourceAddr: "10.0.0.1:5000",
-		DestAddr:   "192.168.1.100:443",
-		Protocol:   "tcp",
-		StartedAt:  now,
-		EndedAt:    now.Add(100 * time.Millisecond),
-		BytesTx:    100,
-	}
-	s2 := &AccessSession{
-		SessionID:  "s2",
-		ResourceID: 1,
-		SourceAddr: "10.0.0.1:5001",
-		DestAddr:   "192.168.1.100:443",
-		Protocol:   "tcp",
-		StartedAt:  now.Add(200 * time.Millisecond),
-		EndedAt:    now.Add(300 * time.Millisecond),
-		BytesTx:    200,
-	}
-
-	// Save original values
-	origS1Addr := s1.SourceAddr
-	origS1Bytes := s1.BytesTx
-	origS2Addr := s2.SourceAddr
-	origS2Bytes := s2.BytesTx
-
-	_ = consolidateSessions([]*AccessSession{s1, s2})
-
-	if s1.SourceAddr != origS1Addr {
-		t.Errorf("s1.SourceAddr was mutated: %q -> %q", origS1Addr, s1.SourceAddr)
-	}
-	if s1.BytesTx != origS1Bytes {
-		t.Errorf("s1.BytesTx was mutated: %d -> %d", origS1Bytes, s1.BytesTx)
-	}
-	if s2.SourceAddr != origS2Addr {
-		t.Errorf("s2.SourceAddr was mutated: %q -> %q", origS2Addr, s2.SourceAddr)
-	}
-	if s2.BytesTx != origS2Bytes {
-		t.Errorf("s2.BytesTx was mutated: %d -> %d", origS2Bytes, s2.BytesTx)
-	}
-}
-
-func TestConsolidateSessions_ThreeBurstsWithGaps(t *testing.T) {
-	now := time.Now()
-
-	sessions := make([]*AccessSession, 0, 9)
-
-	// Burst 1: 3 connections at t=0
-	for i := 0; i < 3; i++ {
-		sessions = append(sessions, &AccessSession{
-			SessionID:  generateSessionID(),
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:" + string(rune('A'+i)),
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(time.Duration(i*100) * time.Millisecond),
-			EndedAt:    now.Add(time.Duration(i*100+50) * time.Millisecond),
-		})
-	}
-
-	// Burst 2: 3 connections at t=20s (well past the 5s gap)
-	for i := 0; i < 3; i++ {
-		sessions = append(sessions, &AccessSession{
-			SessionID:  generateSessionID(),
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:" + string(rune('D'+i)),
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(20*time.Second + time.Duration(i*100)*time.Millisecond),
-			EndedAt:    now.Add(20*time.Second + time.Duration(i*100+50)*time.Millisecond),
-		})
-	}
-
-	// Burst 3: 3 connections at t=40s
-	for i := 0; i < 3; i++ {
-		sessions = append(sessions, &AccessSession{
-			SessionID:  generateSessionID(),
-			ResourceID: 1,
-			SourceAddr: "10.0.0.1:" + string(rune('G'+i)),
-			DestAddr:   "192.168.1.100:443",
-			Protocol:   "tcp",
-			StartedAt:  now.Add(40*time.Second + time.Duration(i*100)*time.Millisecond),
-			EndedAt:    now.Add(40*time.Second + time.Duration(i*100+50)*time.Millisecond),
-		})
-	}
-
-	result := consolidateSessions(sessions)
-	if len(result) != 3 {
-		t.Fatalf("expected 3 consolidated sessions (3 bursts), got %d", len(result))
-	}
-
-	for _, s := range result {
-		if s.ConnectionCount != 3 {
-			t.Errorf("expected each burst to have ConnectionCount=3, got %d (started=%v)", s.ConnectionCount, s.StartedAt)
-		}
-	}
-}
-
-func TestFinalizeMergedSourceAddr(t *testing.T) {
-	s := &AccessSession{SourceAddr: "10.0.0.1:5000"}
-	ports := map[string]struct{}{"10.0.0.1:5000": {}}
-	finalizeMergedSourceAddr(s, "10.0.0.1", ports)
-	if s.SourceAddr != "10.0.0.1:5000" {
-		t.Errorf("single port: expected addr preserved, got %q", s.SourceAddr)
-	}
-
-	s2 := &AccessSession{SourceAddr: "10.0.0.1:5000"}
-	ports2 := map[string]struct{}{"10.0.0.1:5000": {}, "10.0.0.1:5001": {}}
-	finalizeMergedSourceAddr(s2, "10.0.0.1", ports2)
-	if s2.SourceAddr != "10.0.0.1" {
-		t.Errorf("multiple ports: expected IP only, got %q", s2.SourceAddr)
-	}
-}
-
-func TestCloneSession(t *testing.T) {
-	original := &AccessSession{
-		SessionID:  "test",
-		ResourceID: 42,
-		SourceAddr: "1.2.3.4:100",
-		DestAddr:   "5.6.7.8:443",
-		Protocol:   "tcp",
-		BytesTx:    999,
-	}
-
-	clone := cloneSession(original)
-
-	if clone == original {
-		t.Error("clone should be a different pointer")
-	}
-	if clone.SessionID != original.SessionID {
-		t.Error("clone should have same SessionID")
-	}
-
-	// Mutating clone should not affect original
-	clone.BytesTx = 0
-	clone.SourceAddr = "changed"
-	if original.BytesTx != 999 {
-		t.Error("mutating clone affected original BytesTx")
-	}
-	if original.SourceAddr != "1.2.3.4:100" {
-		t.Error("mutating clone affected original SourceAddr")
-	}
-}

netstack2/handlers.go

@@ -137,33 +137,14 @@ func (h *TCPHandler) InstallTCPHandler() error {
 
 // handleTCPConn handles a TCP connection by proxying it to the actual target
 func (h *TCPHandler) handleTCPConn(netstackConn *gonet.TCPConn, id stack.TransportEndpointID) {
-	// Extract source and target address from the connection ID first so they
-	// are available for HTTP routing before any defer is set up.
+	defer netstackConn.Close()
+
+	// Extract source and target address from the connection ID
 	srcIP := id.RemoteAddress.String()
 	srcPort := id.RemotePort
 	dstIP := id.LocalAddress.String()
 	dstPort := id.LocalPort
 
-	// For HTTP/HTTPS ports, look up the matching subnet rule. If the rule has
-	// Protocol configured, hand the connection off to the HTTP handler which
-	// takes full ownership of the lifecycle (the defer close must not be
-	// installed before this point).
-	if (dstPort == 80 || dstPort == 443) && h.proxyHandler != nil && h.proxyHandler.httpHandler != nil {
-		srcAddr, _ := netip.ParseAddr(srcIP)
-		dstAddr, _ := netip.ParseAddr(dstIP)
-		rule := h.proxyHandler.subnetLookup.Match(srcAddr, dstAddr, dstPort, tcp.ProtocolNumber)
-		if rule != nil && rule.Protocol != "" && len(rule.HTTPTargets) > 0 {
-			logger.Info("TCP Forwarder: Routing %s:%d -> %s:%d to HTTP handler (%s)",
-				srcIP, srcPort, dstIP, dstPort, rule.Protocol)
-			h.proxyHandler.httpHandler.HandleConn(netstackConn, rule)
-			return
-		}
-		// Otherwise fall through to raw TCP forwarding (e.g. CIDR resources
-		// that happen to use port 80/443 without HTTP configuration).
-	}
-
-	defer netstackConn.Close()
-
 	logger.Info("TCP Forwarder: Handling connection %s:%d -> %s:%d", srcIP, srcPort, dstIP, dstPort)
 
 	// Check if there's a destination rewrite for this connection (e.g., localhost targets)
@@ -177,18 +158,6 @@ func (h *TCPHandler) handleTCPConn(netstackConn *gonet.TCPConn, id stack.Transpo
 
 	targetAddr := fmt.Sprintf("%s:%d", actualDstIP, dstPort)
 
-	// Look up resource ID and start access session if applicable
-	var accessSessionID string
-	if h.proxyHandler != nil {
-		resourceId := h.proxyHandler.LookupResourceId(srcIP, dstIP, dstPort, uint8(tcp.ProtocolNumber))
-		if resourceId != 0 {
-			if al := h.proxyHandler.GetAccessLogger(); al != nil {
-				srcAddr := fmt.Sprintf("%s:%d", srcIP, srcPort)
-				accessSessionID = al.StartTCPSession(resourceId, srcAddr, targetAddr)
-			}
-		}
-	}
-
 	// Create context with timeout for connection establishment
 	ctx, cancel := context.WithTimeout(context.Background(), tcpConnectTimeout)
 	defer cancel()
@@ -198,26 +167,11 @@ func (h *TCPHandler) handleTCPConn(netstackConn *gonet.TCPConn, id stack.Transpo
 	targetConn, err := d.DialContext(ctx, "tcp", targetAddr)
 	if err != nil {
 		logger.Info("TCP Forwarder: Failed to connect to %s: %v", targetAddr, err)
-		// End access session on connection failure
-		if accessSessionID != "" {
-			if al := h.proxyHandler.GetAccessLogger(); al != nil {
-				al.EndTCPSession(accessSessionID)
-			}
-		}
 		// Connection failed, netstack will handle RST
 		return
 	}
 	defer targetConn.Close()
 
-	// End access session when connection closes
-	if accessSessionID != "" {
-		defer func() {
-			if al := h.proxyHandler.GetAccessLogger(); al != nil {
-				al.EndTCPSession(accessSessionID)
-			}
-		}()
-	}
-
 	logger.Info("TCP Forwarder: Successfully connected to %s, starting bidirectional copy", targetAddr)
 
 	// Bidirectional copy between netstack and target
@@ -326,27 +280,6 @@ func (h *UDPHandler) handleUDPConn(netstackConn *gonet.UDPConn, id stack.Transpo
 
 	targetAddr := fmt.Sprintf("%s:%d", actualDstIP, dstPort)
 
-	// Look up resource ID and start access session if applicable
-	var accessSessionID string
-	if h.proxyHandler != nil {
-		resourceId := h.proxyHandler.LookupResourceId(srcIP, dstIP, dstPort, uint8(udp.ProtocolNumber))
-		if resourceId != 0 {
-			if al := h.proxyHandler.GetAccessLogger(); al != nil {
-				srcAddr := fmt.Sprintf("%s:%d", srcIP, srcPort)
-				accessSessionID = al.TrackUDPSession(resourceId, srcAddr, targetAddr)
-			}
-		}
-	}
-
-	// End access session when UDP handler returns (timeout or error)
-	if accessSessionID != "" {
-		defer func() {
-			if al := h.proxyHandler.GetAccessLogger(); al != nil {
-				al.EndUDPSession(accessSessionID)
-			}
-		}()
-	}
-
 	// Resolve target address
 	remoteUDPAddr, err := net.ResolveUDPAddr("udp", targetAddr)
 	if err != nil {
@@ -439,7 +372,7 @@ func copyPacketData(dst, src net.PacketConn, to net.Addr, timeout time.Duration)
 // InstallICMPHandler installs the ICMP handler on the stack
 func (h *ICMPHandler) InstallICMPHandler() error {
 	h.stack.SetTransportProtocolHandler(header.ICMPv4ProtocolNumber, h.handleICMPPacket)
-	logger.Debug("ICMP Handler: Installed ICMP protocol handler")
+	logger.Info("ICMP Handler: Installed ICMP protocol handler")
 	return nil
 }
 
@@ -667,7 +600,7 @@ func (h *ICMPHandler) sendAndReceiveICMP(conn *icmp.PacketConn, actualDstIP stri
 			logger.Debug("ICMP Handler: Reply seq mismatch: got seq=%d, want seq=%d", reply.Seq, seq)
 			continue
 		}
-
+		
 		if !ignoreIdent && reply.ID != int(ident) {
 			logger.Debug("ICMP Handler: Reply ident mismatch: got ident=%d, want ident=%d", reply.ID, ident)
 			continue

netstack2/http_handler.go

@@ -1,396 +0,0 @@
-/* SPDX-License-Identifier: MIT
- *
- * Copyright (C) 2017-2025 WireGuard LLC. All Rights Reserved.
- */
-
-package netstack2
-
-import (
-	"bufio"
-	"context"
-	"crypto/tls"
-	"errors"
-	"fmt"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/url"
-	"sync"
-	"time"
-
-	"github.com/fosrl/newt/logger"
-	"gvisor.dev/gvisor/pkg/tcpip/stack"
-)
-
-// ---------------------------------------------------------------------------
-// HTTPTarget
-// ---------------------------------------------------------------------------
-
-// HTTPTarget describes a single downstream HTTP or HTTPS service that the
-// proxy should forward requests to.
-type HTTPTarget struct {
-	DestAddr string `json:"destAddr"` // IP address or hostname of the downstream service
-	DestPort uint16 `json:"destPort"` // TCP port of the downstream service
-	Scheme   string `json:"scheme"`   // When true the outbound leg uses HTTPS
-}
-
-// ---------------------------------------------------------------------------
-// HTTPHandler
-// ---------------------------------------------------------------------------
-
-// HTTPHandler intercepts TCP connections from the netstack forwarder on ports
-// 80 and 443 and services them as HTTP or HTTPS, reverse-proxying each request
-// to downstream targets specified by the matching SubnetRule.
-//
-// HTTP and raw TCP are fully separate: a connection is only routed here when
-// its SubnetRule has Protocol set ("http" or "https"). All other connections
-// on those ports fall through to the normal raw-TCP path.
-//
-// Incoming TLS termination (Protocol == "https") is performed per-connection
-// using the certificate and key stored in the rule, so different subnet rules
-// can present different certificates without sharing any state.
-//
-// Outbound connections to downstream targets honour HTTPTarget.UseHTTPS
-// independently of the incoming protocol.
-type HTTPHandler struct {
-	stack         *stack.Stack
-	proxyHandler  *ProxyHandler
-	requestLogger *HTTPRequestLogger
-
-	listener *chanListener
-	server   *http.Server
-
-	// proxyCache holds pre-built *httputil.ReverseProxy values keyed by the
-	// canonical target URL string ("scheme://host:port"). Building a proxy is
-	// cheap, but reusing one preserves the underlying http.Transport connection
-	// pool, which matters for throughput.
-	proxyCache sync.Map // map[string]*httputil.ReverseProxy
-
-	// tlsCache holds pre-parsed *tls.Config values keyed by the concatenation
-	// of the PEM certificate and key. Parsing a keypair is relatively expensive
-	// and the same cert is likely reused across many connections.
-	tlsCache sync.Map // map[string]*tls.Config
-}
-
-// ---------------------------------------------------------------------------
-// chanListener – net.Listener backed by a channel
-// ---------------------------------------------------------------------------
-
-// chanListener implements net.Listener by receiving net.Conn values over a
-// buffered channel. This lets the netstack TCP forwarder hand off connections
-// directly to a running http.Server without any real OS socket.
-type chanListener struct {
-	connCh chan net.Conn
-	closed chan struct{}
-	once   sync.Once
-}
-
-func newChanListener() *chanListener {
-	return &chanListener{
-		connCh: make(chan net.Conn, 128),
-		closed: make(chan struct{}),
-	}
-}
-
-// Accept blocks until a connection is available or the listener is closed.
-func (l *chanListener) Accept() (net.Conn, error) {
-	select {
-	case conn, ok := <-l.connCh:
-		if !ok {
-			return nil, net.ErrClosed
-		}
-		return conn, nil
-	case <-l.closed:
-		return nil, net.ErrClosed
-	}
-}
-
-// Close shuts down the listener; subsequent Accept calls return net.ErrClosed.
-func (l *chanListener) Close() error {
-	l.once.Do(func() { close(l.closed) })
-	return nil
-}
-
-// Addr returns a placeholder address (the listener has no real OS socket).
-func (l *chanListener) Addr() net.Addr {
-	return &net.TCPAddr{}
-}
-
-// send delivers conn to the listener. Returns false if the listener is already
-// closed, in which case the caller is responsible for closing conn.
-func (l *chanListener) send(conn net.Conn) bool {
-	select {
-	case l.connCh <- conn:
-		return true
-	case <-l.closed:
-		return false
-	}
-}
-
-// ---------------------------------------------------------------------------
-// httpConnCtx – conn wrapper that carries a SubnetRule through the listener
-// ---------------------------------------------------------------------------
-
-// httpConnCtx wraps a net.Conn so the matching SubnetRule can be passed
-// through the chanListener into the http.Server's ConnContext callback,
-// making it available to request handlers via the request context.
-type httpConnCtx struct {
-	net.Conn
-	rule *SubnetRule
-}
-
-// connCtxKey is the unexported context key used to store a *SubnetRule on the
-// per-connection context created by http.Server.ConnContext.
-type connCtxKey struct{}
-
-// ---------------------------------------------------------------------------
-// Constructor and lifecycle
-// ---------------------------------------------------------------------------
-
-// NewHTTPHandler creates an HTTPHandler attached to the given stack and
-// ProxyHandler. Call Start to begin serving connections.
-func NewHTTPHandler(s *stack.Stack, ph *ProxyHandler) *HTTPHandler {
-	return &HTTPHandler{
-		stack:        s,
-		proxyHandler: ph,
-	}
-}
-
-// SetRequestLogger attaches an HTTPRequestLogger so that every proxied request
-// is recorded and periodically shipped to the server.
-func (h *HTTPHandler) SetRequestLogger(rl *HTTPRequestLogger) {
-	h.requestLogger = rl
-}
-
-// Start launches the internal http.Server that services connections delivered
-// via HandleConn. The server runs for the lifetime of the HTTPHandler; call
-// Close to stop it.
-func (h *HTTPHandler) Start() error {
-	h.listener = newChanListener()
-
-	h.server = &http.Server{
-		Handler: http.HandlerFunc(h.handleRequest),
-		// ConnContext runs once per accepted connection and attaches the
-		// SubnetRule carried by httpConnCtx to the connection's context so
-		// that handleRequest can retrieve it without any global state.
-		ConnContext: func(ctx context.Context, c net.Conn) context.Context {
-			if cc, ok := c.(*httpConnCtx); ok {
-				return context.WithValue(ctx, connCtxKey{}, cc.rule)
-			}
-			return ctx
-		},
-	}
-
-	go func() {
-		if err := h.server.Serve(h.listener); err != nil && err != http.ErrServerClosed {
-			logger.Error("HTTP handler: server exited unexpectedly: %v", err)
-		}
-	}()
-
-	logger.Debug("HTTP handler: ready — routing determined per SubnetRule on ports 80/443")
-	return nil
-}
-
-// HandleConn accepts a TCP connection from the netstack forwarder together
-// with the SubnetRule that matched it. The HTTP handler takes full ownership
-// of the connection's lifecycle; the caller must NOT close conn after this call.
-//
-// When rule.Protocol is "https", TLS termination is performed on conn using
-// the certificate and key stored in rule.TLSCert and rule.TLSKey before the
-// connection is passed to the HTTP server. The HTTP server itself is always
-// plain-HTTP; TLS is fully unwrapped at this layer.
-func (h *HTTPHandler) HandleConn(conn net.Conn, rule *SubnetRule) {
-	var effectiveConn net.Conn = conn
-
-	if rule.Protocol == "https" {
-		tlsCfg, err := h.getTLSConfig(rule)
-		if err != nil {
-			logger.Error("HTTP handler: cannot build TLS config for connection from %s: %v",
-				conn.RemoteAddr(), err)
-			conn.Close()
-			return
-		}
-		// tls.Server wraps the raw conn; the TLS handshake is deferred until
-		// the first Read, which the http.Server will trigger naturally.
-		effectiveConn = tls.Server(conn, tlsCfg)
-	}
-
-	wrapped := &httpConnCtx{Conn: effectiveConn, rule: rule}
-	if !h.listener.send(wrapped) {
-		// Listener is already closed — clean up the orphaned connection.
-		effectiveConn.Close()
-	}
-}
-
-// Close gracefully shuts down the HTTP server and the underlying channel
-// listener, causing the goroutine started in Start to exit.
-func (h *HTTPHandler) Close() error {
-	if h.server != nil {
-		if err := h.server.Close(); err != nil {
-			return err
-		}
-	}
-	if h.listener != nil {
-		h.listener.Close()
-	}
-	return nil
-}
-
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-
-// getTLSConfig returns a *tls.Config for the cert/key pair in rule, using a
-// cache to avoid re-parsing the same keypair on every connection.
-// The cache key is the concatenation of the PEM cert and key strings, so
-// different rules that happen to share the same material hit the same entry.
-func (h *HTTPHandler) getTLSConfig(rule *SubnetRule) (*tls.Config, error) {
-	cacheKey := rule.TLSCert + "|" + rule.TLSKey
-	if v, ok := h.tlsCache.Load(cacheKey); ok {
-		return v.(*tls.Config), nil
-	}
-
-	cert, err := tls.X509KeyPair([]byte(rule.TLSCert), []byte(rule.TLSKey))
-	if err != nil {
-		return nil, fmt.Errorf("failed to parse TLS keypair: %w", err)
-	}
-	cfg := &tls.Config{
-		Certificates: []tls.Certificate{cert},
-	}
-	// LoadOrStore is safe under concurrent calls: if two goroutines race here
-	// both will produce a valid config; the loser's work is discarded.
-	actual, _ := h.tlsCache.LoadOrStore(cacheKey, cfg)
-	return actual.(*tls.Config), nil
-}
-
-// getProxy returns a cached *httputil.ReverseProxy for the given target,
-// creating one on first use. Reusing the proxy preserves its http.Transport
-// connection pool, avoiding repeated TCP/TLS handshakes to the downstream.
-func (h *HTTPHandler) getProxy(target HTTPTarget) *httputil.ReverseProxy {
-	scheme := target.Scheme
-	cacheKey := fmt.Sprintf("%s://%s:%d", scheme, target.DestAddr, target.DestPort)
-
-	if v, ok := h.proxyCache.Load(cacheKey); ok {
-		return v.(*httputil.ReverseProxy)
-	}
-
-	targetURL := &url.URL{
-		Scheme: scheme,
-		Host:   fmt.Sprintf("%s:%d", target.DestAddr, target.DestPort),
-	}
-	var transport http.RoundTripper = http.DefaultTransport
-	if target.Scheme == "https" {
-		// Allow self-signed certificates on downstream HTTPS targets.
-		transport = &http.Transport{
-			TLSClientConfig: &tls.Config{
-				InsecureSkipVerify: true, //nolint:gosec // downstream self-signed certs are a supported configuration
-			},
-		}
-	}
-
-	proxy := &httputil.ReverseProxy{
-		Rewrite: func(pr *httputil.ProxyRequest) {
-			pr.SetURL(targetURL)
-			// SetXForwarded sets X-Forwarded-For from the inbound request's
-			// RemoteAddr (the WireGuard/netstack client address), along with
-			// X-Forwarded-Host and X-Forwarded-Proto. Using Rewrite instead of
-			// Director means the proxy does not append its own automatic
-			// X-Forwarded-For entry, so the header is set exactly once.
-			pr.SetXForwarded()
-		},
-		Transport: transport,
-	}
-
-	proxy.ErrorHandler = func(w http.ResponseWriter, r *http.Request, err error) {
-		logger.Error("HTTP handler: upstream error (%s %s -> %s): %v",
-			r.Method, r.URL.RequestURI(), cacheKey, err)
-		http.Error(w, "Bad Gateway", http.StatusBadGateway)
-	}
-
-	actual, _ := h.proxyCache.LoadOrStore(cacheKey, proxy)
-	return actual.(*httputil.ReverseProxy)
-}
-
-// statusCapture wraps an http.ResponseWriter and records the HTTP status code
-// written by the upstream handler. If WriteHeader is never called the status
-// defaults to 200 (http.StatusOK), matching net/http semantics.
-type statusCapture struct {
-	http.ResponseWriter
-	status int
-}
-
-func (sc *statusCapture) WriteHeader(code int) {
-	sc.status = code
-	sc.ResponseWriter.WriteHeader(code)
-}
-
-func (sc *statusCapture) Unwrap() http.ResponseWriter {
-	return sc.ResponseWriter
-}
-
-func (sc *statusCapture) Flush() {
-	if flusher, ok := sc.ResponseWriter.(http.Flusher); ok {
-		flusher.Flush()
-	}
-}
-
-func (sc *statusCapture) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	hijacker, ok := sc.ResponseWriter.(http.Hijacker)
-	if !ok {
-		return nil, nil, errors.New("underlying response writer does not support hijacking")
-	}
-	return hijacker.Hijack()
-}
-
-// handleRequest is the http.Handler entry point. It retrieves the SubnetRule
-// attached to the connection by ConnContext, selects the first configured
-// downstream target, and forwards the request via the cached ReverseProxy.
-//
-// TODO: add host/path-based routing across multiple HTTPTargets once the
-// configuration model evolves beyond a single target per rule.
-func (h *HTTPHandler) handleRequest(w http.ResponseWriter, r *http.Request) {
-	rule, _ := r.Context().Value(connCtxKey{}).(*SubnetRule)
-	if rule == nil || len(rule.HTTPTargets) == 0 {
-		logger.Error("HTTP handler: no downstream targets for request %s %s", r.Method, r.URL.RequestURI())
-		http.Error(w, "no targets configured", http.StatusBadGateway)
-		return
-	}
-
-	// If the rule is plain HTTP but has a TLS certificate configured, redirect
-	// the client to the HTTPS equivalent of the requested URL.
-	if rule.Protocol == "http" && rule.TLSCert != "" && rule.TLSKey != "" {
-		host := r.Host
-		if host == "" {
-			host = r.URL.Host
-		}
-		httpsURL := "https://" + host + r.RequestURI
-		logger.Info("HTTP handler: redirecting %s %s -> %s (TLS cert present)", r.Method, r.URL.RequestURI(), httpsURL)
-		http.Redirect(w, r, httpsURL, http.StatusMovedPermanently)
-		return
-	}
-
-	target := rule.HTTPTargets[0]
-	scheme := target.Scheme
-	logger.Info("HTTP handler: %s %s -> %s://%s:%d",
-		r.Method, r.URL.RequestURI(), scheme, target.DestAddr, target.DestPort)
-
-	timestamp := time.Now()
-	sc := &statusCapture{ResponseWriter: w, status: http.StatusOK}
-
-	h.getProxy(target).ServeHTTP(sc, r)
-
-	if h.requestLogger != nil && rule.ResourceId != 0 {
-		h.requestLogger.LogRequest(HTTPRequestLog{
-			ResourceID: rule.ResourceId,
-			Timestamp:  timestamp,
-			Method:     r.Method,
-			Scheme:     rule.Protocol,
-			Host:       r.Host,
-			Path:       r.URL.Path,
-			RawQuery:   r.URL.RawQuery,
-			UserAgent:  r.UserAgent(),
-			SourceAddr: r.RemoteAddr,
-			TLS:        rule.Protocol == "https",
-		})
-	}
-}

netstack2/http_handler_test.go

@@ -1,97 +0,0 @@
-package netstack2
-
-import (
-	"context"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"testing"
-
-	"github.com/gorilla/websocket"
-)
-
-func TestHTTPHandlerProxiesWebSocketUpgrade(t *testing.T) {
-	upgrader := websocket.Upgrader{}
-	backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		conn, err := upgrader.Upgrade(w, r, nil)
-		if err != nil {
-			t.Errorf("upgrade failed: %v", err)
-			return
-		}
-		defer conn.Close()
-
-		messageType, payload, err := conn.ReadMessage()
-		if err != nil {
-			t.Errorf("read failed: %v", err)
-			return
-		}
-		if err := conn.WriteMessage(messageType, append([]byte("echo:"), payload...)); err != nil {
-			t.Errorf("write failed: %v", err)
-		}
-	}))
-	defer backend.Close()
-
-	backendURL, err := url.Parse(backend.URL)
-	if err != nil {
-		t.Fatalf("parse backend URL: %v", err)
-	}
-	backendHost, backendPort, err := net.SplitHostPort(backendURL.Host)
-	if err != nil {
-		t.Fatalf("split backend host: %v", err)
-	}
-	port, err := net.LookupPort("tcp", backendPort)
-	if err != nil {
-		t.Fatalf("parse backend port: %v", err)
-	}
-
-	handler := NewHTTPHandler(nil, nil)
-	rule := &SubnetRule{
-		Protocol: "http",
-		HTTPTargets: []HTTPTarget{
-			{
-				DestAddr: backendHost,
-				DestPort: uint16(port),
-				Scheme:   backendURL.Scheme,
-			},
-		},
-	}
-
-	frontend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		ctx := context.WithValue(r.Context(), connCtxKey{}, rule)
-		handler.handleRequest(w, r.WithContext(ctx))
-	}))
-	defer frontend.Close()
-
-	frontendURL, err := url.Parse(frontend.URL)
-	if err != nil {
-		t.Fatalf("parse frontend URL: %v", err)
-	}
-	wsURL := url.URL{
-		Scheme:   "ws",
-		Host:     frontendURL.Host,
-		Path:     "/socket",
-		RawQuery: "token=test",
-	}
-
-	conn, _, err := websocket.DefaultDialer.Dial(wsURL.String(), nil)
-	if err != nil {
-		t.Fatalf("dial websocket through proxy: %v", err)
-	}
-	defer conn.Close()
-
-	if err := conn.WriteMessage(websocket.TextMessage, []byte("hello")); err != nil {
-		t.Fatalf("write websocket message: %v", err)
-	}
-
-	messageType, payload, err := conn.ReadMessage()
-	if err != nil {
-		t.Fatalf("read websocket message: %v", err)
-	}
-	if messageType != websocket.TextMessage {
-		t.Fatalf("message type = %d, want %d", messageType, websocket.TextMessage)
-	}
-	if got, want := string(payload), "echo:hello"; got != want {
-		t.Fatalf("payload = %q, want %q", got, want)
-	}
-}

netstack2/http_request_log.go

@@ -1,175 +0,0 @@
-package netstack2
-
-import (
-	"bytes"
-	"compress/zlib"
-	"encoding/base64"
-	"encoding/json"
-	"sync"
-	"time"
-
-	"github.com/fosrl/newt/logger"
-)
-
-// HTTPRequestLog represents a single HTTP/HTTPS request proxied through the handler.
-type HTTPRequestLog struct {
-	RequestID  string    `json:"requestId"`
-	ResourceID int       `json:"resourceId"`
-	Timestamp  time.Time `json:"timestamp"`
-	Method     string    `json:"method"`
-	Scheme     string    `json:"scheme"`
-	Host       string    `json:"host"`
-	Path       string    `json:"path"`
-	RawQuery   string    `json:"rawQuery,omitempty"`
-	UserAgent  string    `json:"userAgent,omitempty"`
-	SourceAddr string    `json:"sourceAddr"`
-	TLS        bool      `json:"tls"`
-}
-
-// HTTPRequestLogger buffers HTTP request logs and periodically flushes them
-// to the server via a configurable SendFunc.
-type HTTPRequestLogger struct {
-	mu        sync.Mutex
-	pending   []HTTPRequestLog
-	sendFn    SendFunc
-	stopCh    chan struct{}
-	flushDone chan struct{}
-}
-
-// NewHTTPRequestLogger creates a new HTTPRequestLogger and starts its background flush loop.
-func NewHTTPRequestLogger() *HTTPRequestLogger {
-	rl := &HTTPRequestLogger{
-		pending:   make([]HTTPRequestLog, 0),
-		stopCh:    make(chan struct{}),
-		flushDone: make(chan struct{}),
-	}
-	go rl.backgroundLoop()
-	return rl
-}
-
-// SetSendFunc sets the callback used to send compressed HTTP request log batches
-// to the server. This can be called after construction once the websocket
-// client is available.
-func (rl *HTTPRequestLogger) SetSendFunc(fn SendFunc) {
-	rl.mu.Lock()
-	defer rl.mu.Unlock()
-	rl.sendFn = fn
-}
-
-// LogRequest adds an HTTP request log entry to the buffer. If the buffer
-// reaches maxBufferedSessions entries a flush is triggered immediately.
-func (rl *HTTPRequestLogger) LogRequest(log HTTPRequestLog) {
-	if log.RequestID == "" {
-		log.RequestID = generateSessionID()
-	}
-
-	rl.mu.Lock()
-	rl.pending = append(rl.pending, log)
-	shouldFlush := len(rl.pending) >= maxBufferedSessions
-	rl.mu.Unlock()
-
-	if shouldFlush {
-		rl.flush()
-	}
-}
-
-// backgroundLoop handles periodic flushing of buffered request logs.
-func (rl *HTTPRequestLogger) backgroundLoop() {
-	defer close(rl.flushDone)
-
-	ticker := time.NewTicker(flushInterval)
-	defer ticker.Stop()
-
-	for {
-		select {
-		case <-rl.stopCh:
-			return
-		case <-ticker.C:
-			rl.flush()
-		}
-	}
-}
-
-// flush drains the pending buffer, compresses with zlib, and sends via the SendFunc.
-// On send failure the batch is re-queued, capped at maxBufferedSessions*5 entries
-// to prevent unbounded memory growth when the server is unreachable.
-func (rl *HTTPRequestLogger) flush() {
-	rl.mu.Lock()
-	if len(rl.pending) == 0 {
-		rl.mu.Unlock()
-		return
-	}
-	batch := rl.pending
-	rl.pending = make([]HTTPRequestLog, 0)
-	sendFn := rl.sendFn
-	rl.mu.Unlock()
-
-	if sendFn == nil {
-		logger.Debug("HTTP request logger: no send function configured, discarding %d requests", len(batch))
-		return
-	}
-
-	compressed, err := compressRequestLogs(batch)
-	if err != nil {
-		logger.Error("HTTP request logger: failed to compress %d requests: %v", len(batch), err)
-		return
-	}
-
-	if err := sendFn(compressed); err != nil {
-		logger.Error("HTTP request logger: failed to send %d requests: %v", len(batch), err)
-		// Re-queue the batch so we don't lose data
-		rl.mu.Lock()
-		rl.pending = append(batch, rl.pending...)
-		// Cap re-queued data to prevent unbounded growth if server is unreachable
-		if len(rl.pending) > maxBufferedSessions*5 {
-			dropped := len(rl.pending) - maxBufferedSessions*5
-			rl.pending = rl.pending[:maxBufferedSessions*5]
-			logger.Warn("HTTP request logger: buffer overflow, dropped %d oldest requests", dropped)
-		}
-		rl.mu.Unlock()
-		return
-	}
-
-	logger.Info("HTTP request logger: sent %d requests to server", len(batch))
-}
-
-// compressRequestLogs JSON-encodes the request logs, compresses with zlib, and
-// returns a base64-encoded string suitable for embedding in a JSON message.
-func compressRequestLogs(logs []HTTPRequestLog) (string, error) {
-	jsonData, err := json.Marshal(logs)
-	if err != nil {
-		return "", err
-	}
-
-	var buf bytes.Buffer
-	w, err := zlib.NewWriterLevel(&buf, zlib.BestCompression)
-	if err != nil {
-		return "", err
-	}
-	if _, err := w.Write(jsonData); err != nil {
-		w.Close()
-		return "", err
-	}
-	if err := w.Close(); err != nil {
-		return "", err
-	}
-
-	return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
-}
-
-// Close shuts down the background loop and performs one final flush to send
-// any remaining buffered requests to the server.
-func (rl *HTTPRequestLogger) Close() {
-	select {
-	case <-rl.stopCh:
-		// Already closed
-		return
-	default:
-		close(rl.stopCh)
-	}
-
-	// Wait for the background loop to exit so we don't race on flush
-	<-rl.flushDone
-
-	rl.flush()
-}

netstack2/proxy.go

@@ -22,12 +22,6 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/transport/udp"
 )
 
-const (
-	// udpAccessSessionTimeout is how long a UDP access session stays alive without traffic
-	// before being considered ended by the access logger
-	udpAccessSessionTimeout = 120 * time.Second
-)
-
 // PortRange represents an allowed range of ports (inclusive) with optional protocol filtering
 // Protocol can be "tcp", "udp", or "" (empty string means both protocols)
 type PortRange struct {
@@ -52,32 +46,115 @@ type SubnetRule struct {
 	DisableIcmp  bool         // If true, ICMP traffic is blocked for this subnet
 	RewriteTo    string       // Optional rewrite address for DNAT - can be IP/CIDR or domain name
 	PortRanges   []PortRange  // empty slice means all ports allowed
-	ResourceId   int          // Optional resource ID from the server for access logging
-
-	// HTTP proxy configuration (optional).
-	// When Protocol is non-empty the TCP connection is handled by HTTPHandler
-	// instead of the raw TCP forwarder.
-	Protocol    string       // "", "http", or "https" — controls the incoming (client-facing) protocol
-	HTTPTargets []HTTPTarget // downstream services to proxy requests to
-	TLSCert     string       // PEM-encoded certificate for incoming HTTPS termination
-	TLSKey      string       // PEM-encoded private key for incoming HTTPS termination
 }
 
-// GetAllRules returns a copy of all subnet rules
-func (sl *SubnetLookup) GetAllRules() []SubnetRule {
+// ruleKey is used as a map key for fast O(1) lookups
+type ruleKey struct {
+	sourcePrefix string
+	destPrefix   string
+}
+
+// SubnetLookup provides fast IP subnet and port matching with O(1) lookup performance
+type SubnetLookup struct {
+	mu    sync.RWMutex
+	rules map[ruleKey]*SubnetRule // Map for O(1) lookups by prefix combination
+}
+
+// NewSubnetLookup creates a new subnet lookup table
+func NewSubnetLookup() *SubnetLookup {
+	return &SubnetLookup{
+		rules: make(map[ruleKey]*SubnetRule),
+	}
+}
+
+// AddSubnet adds a subnet rule with source and destination prefixes and optional port restrictions
+// If portRanges is nil or empty, all ports are allowed for this subnet
+// rewriteTo can be either an IP/CIDR (e.g., "192.168.1.1/32") or a domain name (e.g., "example.com")
+func (sl *SubnetLookup) AddSubnet(sourcePrefix, destPrefix netip.Prefix, rewriteTo string, portRanges []PortRange, disableIcmp bool) {
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
+	key := ruleKey{
+		sourcePrefix: sourcePrefix.String(),
+		destPrefix:   destPrefix.String(),
+	}
+
+	sl.rules[key] = &SubnetRule{
+		SourcePrefix: sourcePrefix,
+		DestPrefix:   destPrefix,
+		DisableIcmp:  disableIcmp,
+		RewriteTo:    rewriteTo,
+		PortRanges:   portRanges,
+	}
+}
+
+// RemoveSubnet removes a subnet rule from the lookup table
+func (sl *SubnetLookup) RemoveSubnet(sourcePrefix, destPrefix netip.Prefix) {
+	sl.mu.Lock()
+	defer sl.mu.Unlock()
+
+	key := ruleKey{
+		sourcePrefix: sourcePrefix.String(),
+		destPrefix:   destPrefix.String(),
+	}
+
+	delete(sl.rules, key)
+}
+
+// Match checks if a source IP, destination IP, port, and protocol match any subnet rule
+// Returns the matched rule if ALL of these conditions are met:
+//   - The source IP is in the rule's source prefix
+//   - The destination IP is in the rule's destination prefix
+//   - The port is in an allowed range (or no port restrictions exist)
+//   - The protocol matches (or the port range allows both protocols)
+//
+// proto should be header.TCPProtocolNumber or header.UDPProtocolNumber
+// Returns nil if no rule matches
+func (sl *SubnetLookup) Match(srcIP, dstIP netip.Addr, port uint16, proto tcpip.TransportProtocolNumber) *SubnetRule {
 	sl.mu.RLock()
 	defer sl.mu.RUnlock()
 
-	var rules []SubnetRule
-	for _, destTriePtr := range sl.sourceTrie.All() {
-		if destTriePtr == nil {
+	// Iterate through all rules to find matching source and destination prefixes
+	// This is O(n) but necessary since we need to check prefix containment, not exact match
+	for _, rule := range sl.rules {
+		// Check if source and destination IPs match their respective prefixes
+		if !rule.SourcePrefix.Contains(srcIP) {
 			continue
 		}
-		for _, rule := range destTriePtr.rules {
-			rules = append(rules, *rule)
+		if !rule.DestPrefix.Contains(dstIP) {
+			continue
+		}
+
+		if rule.DisableIcmp && (proto == header.ICMPv4ProtocolNumber || proto == header.ICMPv6ProtocolNumber) {
+		    // ICMP is disabled for this subnet
+			return nil
+		}
+
+		// Both IPs match - now check port restrictions
+		// If no port ranges specified, all ports are allowed
+		if len(rule.PortRanges) == 0 {
+			return rule
+		}
+
+		// Check if port and protocol are in any of the allowed ranges
+		for _, pr := range rule.PortRanges {
+			if port >= pr.Min && port <= pr.Max {
+				// Check protocol compatibility
+				if pr.Protocol == "" {
+					// Empty protocol means allow both TCP and UDP
+					return rule
+				}
+				// Check if the packet protocol matches the port range protocol
+				if (pr.Protocol == "tcp" && proto == header.TCPProtocolNumber) ||
+					(pr.Protocol == "udp" && proto == header.UDPProtocolNumber) {
+					return rule
+				}
+				// Port matches but protocol doesn't - continue checking other ranges
+			}
 		}
 	}
-	return rules
+
+	return nil
 }
 
 // connKey uniquely identifies a connection for NAT tracking
@@ -89,17 +166,6 @@ type connKey struct {
 	proto   uint8
 }
 
-// reverseConnKey uniquely identifies a connection for reverse NAT lookup (reply direction)
-// Key structure: (rewrittenTo, originalSrcIP, originalSrcPort, originalDstPort, proto)
-// This allows O(1) lookup of NAT entries for reply packets
-type reverseConnKey struct {
-	rewrittenTo     string // The address we rewrote to (becomes src in replies)
-	originalSrcIP   string // Original source IP (becomes dst in replies)
-	originalSrcPort uint16 // Original source port (becomes dst port in replies)
-	originalDstPort uint16 // Original destination port (becomes src port in replies)
-	proto           uint8
-}
-
 // destKey identifies a destination for handler lookups (without source port since it may change)
 type destKey struct {
 	srcIP   string
@@ -122,18 +188,13 @@ type ProxyHandler struct {
 	tcpHandler        *TCPHandler
 	udpHandler        *UDPHandler
 	icmpHandler       *ICMPHandler
-	httpHandler       *HTTPHandler
 	subnetLookup      *SubnetLookup
 	natTable          map[connKey]*natState
-	reverseNatTable   map[reverseConnKey]*natState // Reverse lookup map for O(1) reply packet NAT
-	destRewriteTable  map[destKey]netip.Addr       // Maps original dest to rewritten dest for handler lookups
-	resourceTable     map[destKey]int              // Maps connection key to resource ID for access logging
+	destRewriteTable  map[destKey]netip.Addr // Maps original dest to rewritten dest for handler lookups
 	natMu             sync.RWMutex
 	enabled           bool
 	icmpReplies       chan []byte          // Channel for ICMP reply packets to be sent back through the tunnel
 	notifiable        channel.Notification // Notification handler for triggering reads
-	accessLogger      *AccessLogger        // Access logger for tracking sessions
-	httpRequestLogger *HTTPRequestLogger   // HTTP request logger for proxied HTTP/HTTPS requests
 }
 
 // ProxyHandlerOptions configures the proxy handler
@@ -154,11 +215,8 @@ func NewProxyHandler(options ProxyHandlerOptions) (*ProxyHandler, error) {
 		enabled:          true,
 		subnetLookup:     NewSubnetLookup(),
 		natTable:         make(map[connKey]*natState),
-		reverseNatTable:  make(map[reverseConnKey]*natState),
 		destRewriteTable: make(map[destKey]netip.Addr),
-		resourceTable:    make(map[destKey]int),
 		icmpReplies:      make(chan []byte, 256), // Buffer for ICMP reply packets
-		accessLogger:     NewAccessLogger(udpAccessSessionTimeout),
 		proxyEp:          channel.New(1024, uint32(options.MTU), ""),
 		proxyStack: stack.New(stack.Options{
 			NetworkProtocols: []stack.NetworkProtocolFactory{
@@ -174,24 +232,12 @@ func NewProxyHandler(options ProxyHandlerOptions) (*ProxyHandler, error) {
 		}),
 	}
 
-	// Initialize TCP handler if enabled. The HTTP handler piggybacks on the
-	// TCP forwarder — TCPHandler.handleTCPConn checks the subnet rule for
-	// ports 80/443 and routes matching connections to the HTTP handler, so
-	// the HTTP handler is always initialised alongside TCP.
+	// Initialize TCP handler if enabled
 	if options.EnableTCP {
 		handler.tcpHandler = NewTCPHandler(handler.proxyStack, handler)
 		if err := handler.tcpHandler.InstallTCPHandler(); err != nil {
 			return nil, fmt.Errorf("failed to install TCP handler: %v", err)
 		}
-
-		handler.httpHandler = NewHTTPHandler(handler.proxyStack, handler)
-		if err := handler.httpHandler.Start(); err != nil {
-			return nil, fmt.Errorf("failed to start HTTP handler: %v", err)
-		}
-
-		handler.httpRequestLogger = NewHTTPRequestLogger()
-		handler.httpHandler.SetRequestLogger(handler.httpRequestLogger)
-		logger.Debug("ProxyHandler: HTTP handler enabled")
 	}
 
 	// Initialize UDP handler if enabled
@@ -208,7 +254,7 @@ func NewProxyHandler(options ProxyHandlerOptions) (*ProxyHandler, error) {
 		if err := handler.icmpHandler.InstallICMPHandler(); err != nil {
 			return nil, fmt.Errorf("failed to install ICMP handler: %v", err)
 		}
-		logger.Debug("ProxyHandler: ICMP handler enabled")
+		logger.Info("ProxyHandler: ICMP handler enabled")
 	}
 
 	// // Example 1: Add a rule with no port restrictions (all ports allowed)
@@ -230,14 +276,16 @@ func NewProxyHandler(options ProxyHandlerOptions) (*ProxyHandler, error) {
 	return handler, nil
 }
 
-// AddSubnetRule adds a subnet rule to the proxy handler.
-// HTTP proxy behaviour is configured via rule.Protocol, rule.HTTPTargets,
-// rule.TLSCert, and rule.TLSKey; leave Protocol empty for raw TCP/UDP.
-func (p *ProxyHandler) AddSubnetRule(rule SubnetRule) {
+// AddSubnetRule adds a subnet with optional port restrictions to the proxy handler
+// sourcePrefix: The IP prefix of the peer sending the data
+// destPrefix: The IP prefix of the destination
+// rewriteTo: Optional address to rewrite destination to - can be IP/CIDR or domain name
+// If portRanges is nil or empty, all ports are allowed for this subnet
+func (p *ProxyHandler) AddSubnetRule(sourcePrefix, destPrefix netip.Prefix, rewriteTo string, portRanges []PortRange, disableIcmp bool) {
 	if p == nil || !p.enabled {
 		return
 	}
-	p.subnetLookup.AddSubnet(rule)
+	p.subnetLookup.AddSubnet(sourcePrefix, destPrefix, rewriteTo, portRanges, disableIcmp)
 }
 
 // RemoveSubnetRule removes a subnet from the proxy handler
@@ -248,69 +296,6 @@ func (p *ProxyHandler) RemoveSubnetRule(sourcePrefix, destPrefix netip.Prefix) {
 	p.subnetLookup.RemoveSubnet(sourcePrefix, destPrefix)
 }
 
-// GetAllRules returns all subnet rules from the proxy handler
-func (p *ProxyHandler) GetAllRules() []SubnetRule {
-	if p == nil || !p.enabled {
-		return nil
-	}
-	return p.subnetLookup.GetAllRules()
-}
-
-// LookupResourceId looks up the resource ID for a connection
-// Returns 0 if no resource ID is associated with this connection
-func (p *ProxyHandler) LookupResourceId(srcIP, dstIP string, dstPort uint16, proto uint8) int {
-	if p == nil || !p.enabled {
-		return 0
-	}
-
-	key := destKey{
-		srcIP:   srcIP,
-		dstIP:   dstIP,
-		dstPort: dstPort,
-		proto:   proto,
-	}
-
-	p.natMu.RLock()
-	defer p.natMu.RUnlock()
-
-	return p.resourceTable[key]
-}
-
-// GetAccessLogger returns the access logger for session tracking
-func (p *ProxyHandler) GetAccessLogger() *AccessLogger {
-	if p == nil {
-		return nil
-	}
-	return p.accessLogger
-}
-
-// SetAccessLogSender configures the function used to send compressed access log
-// batches to the server. This should be called once the websocket client is available.
-func (p *ProxyHandler) SetAccessLogSender(fn SendFunc) {
-	if p == nil || !p.enabled || p.accessLogger == nil {
-		return
-	}
-	p.accessLogger.SetSendFunc(fn)
-}
-
-// GetHTTPRequestLogger returns the HTTP request logger.
-func (p *ProxyHandler) GetHTTPRequestLogger() *HTTPRequestLogger {
-	if p == nil {
-		return nil
-	}
-	return p.httpRequestLogger
-}
-
-// SetHTTPRequestLogSender configures the function used to send compressed HTTP
-// request log batches to the server. This should be called once the websocket
-// client is available.
-func (p *ProxyHandler) SetHTTPRequestLogSender(fn SendFunc) {
-	if p == nil || !p.enabled || p.httpRequestLogger == nil {
-		return
-	}
-	p.httpRequestLogger.SetSendFunc(fn)
-}
-
 // LookupDestinationRewrite looks up the rewritten destination for a connection
 // This is used by TCP/UDP handlers to find the actual target address
 func (p *ProxyHandler) LookupDestinationRewrite(srcIP, dstIP string, dstPort uint16, proto uint8) (netip.Addr, bool) {
@@ -473,22 +458,8 @@ func (p *ProxyHandler) HandleIncomingPacket(packet []byte) bool {
 	// Check if the source IP, destination IP, port, and protocol match any subnet rule
 	matchedRule := p.subnetLookup.Match(srcAddr, dstAddr, dstPort, protocol)
 	if matchedRule != nil {
-		logger.Debug("HandleIncomingPacket: Matched rule for %s -> %s (proto=%d, port=%d, resourceId=%d)",
-			srcAddr, dstAddr, protocol, dstPort, matchedRule.ResourceId)
-
-		// Store resource ID for connections without DNAT as well
-		if matchedRule.ResourceId != 0 && matchedRule.RewriteTo == "" {
-			dKey := destKey{
-				srcIP:   srcAddr.String(),
-				dstIP:   dstAddr.String(),
-				dstPort: dstPort,
-				proto:   uint8(protocol),
-			}
-			p.natMu.Lock()
-			p.resourceTable[dKey] = matchedRule.ResourceId
-			p.natMu.Unlock()
-		}
-
+		logger.Debug("HandleIncomingPacket: Matched rule for %s -> %s (proto=%d, port=%d)",
+			srcAddr, dstAddr, protocol, dstPort)
 		// Check if we need to perform DNAT
 		if matchedRule.RewriteTo != "" {
 			// Create connection tracking key using original destination
@@ -520,13 +491,6 @@ func (p *ProxyHandler) HandleIncomingPacket(packet []byte) bool {
 				proto:   uint8(protocol),
 			}
 
-			// Store resource ID for access logging if present
-			if matchedRule.ResourceId != 0 {
-				p.natMu.Lock()
-				p.resourceTable[dKey] = matchedRule.ResourceId
-				p.natMu.Unlock()
-			}
-
 			// Check if we already have a NAT entry for this connection
 			p.natMu.RLock()
 			existingEntry, exists := p.natTable[key]
@@ -553,23 +517,10 @@ func (p *ProxyHandler) HandleIncomingPacket(packet []byte) bool {
 
 				// Store NAT state for this connection
 				p.natMu.Lock()
-				natEntry := &natState{
+				p.natTable[key] = &natState{
 					originalDst: dstAddr,
 					rewrittenTo: newDst,
 				}
-				p.natTable[key] = natEntry
-
-				// Create reverse lookup key for O(1) reply packet lookups
-				// Key: (rewrittenTo, originalSrcIP, originalSrcPort, originalDstPort, proto)
-				reverseKey := reverseConnKey{
-					rewrittenTo:     newDst.String(),
-					originalSrcIP:   srcAddr.String(),
-					originalSrcPort: srcPort,
-					originalDstPort: dstPort,
-					proto:           uint8(protocol),
-				}
-				p.reverseNatTable[reverseKey] = natEntry
-
 				// Store destination rewrite for handler lookups
 				p.destRewriteTable[dKey] = newDst
 				p.natMu.Unlock()
@@ -599,8 +550,8 @@ func (p *ProxyHandler) HandleIncomingPacket(packet []byte) bool {
 		return true
 	}
 
-	// logger.Debug("HandleIncomingPacket: No matching rule for %s -> %s (proto=%d, port=%d)",
-		// srcAddr, dstAddr, protocol, dstPort)
+	logger.Debug("HandleIncomingPacket: No matching rule for %s -> %s (proto=%d, port=%d)",
+		srcAddr, dstAddr, protocol, dstPort)
 	return false
 }
 
@@ -768,22 +719,20 @@ func (p *ProxyHandler) ReadOutgoingPacket() *buffer.View {
 				return view
 			}
 
-			// Look up NAT state for reverse translation using O(1) reverse lookup map
-			// Key: (rewrittenTo, originalSrcIP, originalSrcPort, originalDstPort, proto)
-			// For reply packets:
-			// - reply's srcIP = rewrittenTo (the address we rewrote to)
-			// - reply's dstIP = originalSrcIP (original source IP)
-			// - reply's srcPort = originalDstPort (original destination port)
-			// - reply's dstPort = originalSrcPort (original source port)
+			// Look up NAT state for reverse translation
+			// The key uses the original dst (before rewrite), so for replies we need to
+			// find the entry where the rewritten address matches the current source
 			p.natMu.RLock()
-			reverseKey := reverseConnKey{
-				rewrittenTo:     srcIP.String(), // Reply's source is the rewritten address
-				originalSrcIP:   dstIP.String(), // Reply's destination is the original source
-				originalSrcPort: dstPort,        // Reply's destination port is the original source port
-				originalDstPort: srcPort,        // Reply's source port is the original destination port
-				proto:           uint8(protocol),
+			var natEntry *natState
+			for k, entry := range p.natTable {
+				// Match: reply's dst should be original src, reply's src should be rewritten dst
+				if k.srcIP == dstIP.String() && k.srcPort == dstPort &&
+					entry.rewrittenTo.String() == srcIP.String() && k.dstPort == srcPort &&
+					k.proto == uint8(protocol) {
+					natEntry = entry
+					break
+				}
 			}
-			natEntry := p.reverseNatTable[reverseKey]
 			p.natMu.RUnlock()
 
 			if natEntry != nil {
@@ -827,21 +776,6 @@ func (p *ProxyHandler) Close() error {
 		return nil
 	}
 
-	// Shut down access logger
-	if p.accessLogger != nil {
-		p.accessLogger.Close()
-	}
-
-	// Shut down HTTP request logger
-	if p.httpRequestLogger != nil {
-		p.httpRequestLogger.Close()
-	}
-
-	// Shut down HTTP handler
-	if p.httpHandler != nil {
-		p.httpHandler.Close()
-	}
-
 	// Close ICMP replies channel
 	if p.icmpReplies != nil {
 		close(p.icmpReplies)

netstack2/subnet_lookup.go

@@ -1,201 +0,0 @@
-package netstack2
-
-import (
-	"net/netip"
-	"sync"
-
-	"github.com/gaissmai/bart"
-	"gvisor.dev/gvisor/pkg/tcpip"
-	"gvisor.dev/gvisor/pkg/tcpip/header"
-)
-
-// SubnetLookup provides fast IP subnet and port matching using BART (Binary Aggregated Range Tree)
-// This uses BART Table for O(log n) prefix matching with Supernets() for efficient lookups
-//
-// Architecture:
-// - Two-level BART structure for matching both source AND destination prefixes
-// - Level 1: Source prefix -> Level 2 (destination prefix -> rules)
-// - This reduces search space: only check destination prefixes for matching source prefixes
-type SubnetLookup struct {
-	mu sync.RWMutex
-	// Two-level BART structure:
-	// Level 1: Source prefix -> Level 2 (destination prefix -> rules)
-	// This allows us to first match source prefix, then only check destination prefixes
-	// for matching source prefixes, reducing the search space significantly
-	sourceTrie *bart.Table[*destTrie]
-}
-
-// destTrie is a BART for destination prefixes, containing the actual rules
-type destTrie struct {
-	trie  *bart.Table[[]*SubnetRule]
-	rules []*SubnetRule // All rules for this source prefix (for iteration if needed)
-}
-
-// NewSubnetLookup creates a new subnet lookup table using BART
-func NewSubnetLookup() *SubnetLookup {
-	return &SubnetLookup{
-		sourceTrie: &bart.Table[*destTrie]{},
-	}
-}
-
-// prefixEqual compares two prefixes after masking to handle host bits correctly.
-// For example, 10.0.0.5/24 and 10.0.0.0/24 are treated as equal.
-func prefixEqual(a, b netip.Prefix) bool {
-	return a.Masked() == b.Masked()
-}
-
-// AddSubnet adds a subnet rule to the lookup table.
-// If rule.PortRanges is nil or empty, all ports are allowed.
-// rule.RewriteTo can be either an IP/CIDR (e.g., "192.168.1.1/32") or a domain name (e.g., "example.com").
-// HTTP proxy behaviour is driven by rule.Protocol, rule.HTTPTargets, rule.TLSCert, and rule.TLSKey.
-func (sl *SubnetLookup) AddSubnet(rule SubnetRule) {
-	sl.mu.Lock()
-	defer sl.mu.Unlock()
-
-	rulePtr := &rule
-
-	// Canonicalize source prefix to handle host bits correctly
-	canonicalSourcePrefix := rule.SourcePrefix.Masked()
-
-	// Get or create destination trie for this source prefix
-	destTriePtr, exists := sl.sourceTrie.Get(canonicalSourcePrefix)
-	if !exists {
-		// Create new destination trie for this source prefix
-		destTriePtr = &destTrie{
-			trie:  &bart.Table[[]*SubnetRule]{},
-			rules: make([]*SubnetRule, 0),
-		}
-		sl.sourceTrie.Insert(canonicalSourcePrefix, destTriePtr)
-	}
-
-	// Canonicalize destination prefix to handle host bits correctly
-	// BART masks prefixes internally, so we need to match that behavior in our bookkeeping
-	canonicalDestPrefix := rule.DestPrefix.Masked()
-
-	// Add rule to destination trie
-	// Original behavior: overwrite if same (sourcePrefix, destPrefix) exists
-	// Store as single-element slice to match original overwrite behavior
-	destTriePtr.trie.Insert(canonicalDestPrefix, []*SubnetRule{rulePtr})
-
-	// Update destTriePtr.rules - remove old rule with same canonical prefix if exists, then add new one
-	// Use canonical comparison to handle cases like 10.0.0.5/24 vs 10.0.0.0/24
-	newRules := make([]*SubnetRule, 0, len(destTriePtr.rules)+1)
-	for _, r := range destTriePtr.rules {
-		if !prefixEqual(r.DestPrefix, canonicalDestPrefix) || !prefixEqual(r.SourcePrefix, canonicalSourcePrefix) {
-			newRules = append(newRules, r)
-		}
-	}
-	newRules = append(newRules, rulePtr)
-	destTriePtr.rules = newRules
-}
-
-// RemoveSubnet removes a subnet rule from the lookup table
-func (sl *SubnetLookup) RemoveSubnet(sourcePrefix, destPrefix netip.Prefix) {
-	sl.mu.Lock()
-	defer sl.mu.Unlock()
-
-	// Canonicalize prefixes to handle host bits correctly
-	canonicalSourcePrefix := sourcePrefix.Masked()
-	canonicalDestPrefix := destPrefix.Masked()
-
-	destTriePtr, exists := sl.sourceTrie.Get(canonicalSourcePrefix)
-	if !exists {
-		return
-	}
-
-	// Remove the rule - original behavior: delete exact (sourcePrefix, destPrefix) combination
-	// BART masks prefixes internally, so Delete works with canonical form
-	destTriePtr.trie.Delete(canonicalDestPrefix)
-
-	// Also remove from destTriePtr.rules using canonical comparison
-	// This ensures we remove rules even if they were added with host bits set
-	newDestRules := make([]*SubnetRule, 0, len(destTriePtr.rules))
-	for _, r := range destTriePtr.rules {
-		if !prefixEqual(r.DestPrefix, canonicalDestPrefix) || !prefixEqual(r.SourcePrefix, canonicalSourcePrefix) {
-			newDestRules = append(newDestRules, r)
-		}
-	}
-	destTriePtr.rules = newDestRules
-
-	// Check if the trie is actually empty using BART's Size() method
-	// This is more efficient than iterating and ensures we clean up empty tries
-	// even if there were stale entries in the rules slice (which shouldn't happen
-	// with proper canonicalization, but this provides a definitive check)
-	if destTriePtr.trie.Size() == 0 {
-		sl.sourceTrie.Delete(canonicalSourcePrefix)
-	}
-}
-
-// Match checks if a source IP, destination IP, port, and protocol match any subnet rule
-// Returns the matched rule if ALL of these conditions are met:
-//   - The source IP is in the rule's source prefix
-//   - The destination IP is in the rule's destination prefix
-//   - The port is in an allowed range (or no port restrictions exist)
-//   - The protocol matches (or the port range allows both protocols)
-//
-// proto should be header.TCPProtocolNumber, header.UDPProtocolNumber, or header.ICMPv4ProtocolNumber
-// Returns nil if no rule matches
-// This uses BART's Supernets() for O(log n) prefix matching instead of O(n) iteration
-func (sl *SubnetLookup) Match(srcIP, dstIP netip.Addr, port uint16, proto tcpip.TransportProtocolNumber) *SubnetRule {
-	sl.mu.RLock()
-	defer sl.mu.RUnlock()
-
-	// Convert IP addresses to /32 (IPv4) or /128 (IPv6) prefixes
-	// Supernets() finds all prefixes that contain this IP (i.e., are supernets of /32 or /128)
-	srcPrefix := netip.PrefixFrom(srcIP, srcIP.BitLen())
-	dstPrefix := netip.PrefixFrom(dstIP, dstIP.BitLen())
-
-	// Step 1: Find all source prefixes that contain srcIP using BART's Supernets
-	// This is O(log n) instead of O(n) iteration
-	// Supernets returns all prefixes that are supernets (contain) the given prefix
-	for _, destTriePtr := range sl.sourceTrie.Supernets(srcPrefix) {
-		if destTriePtr == nil {
-			continue
-		}
-
-		// Step 2: Find all destination prefixes that contain dstIP
-		// This is also O(log n) for each matching source prefix
-		for _, rules := range destTriePtr.trie.Supernets(dstPrefix) {
-			if rules == nil {
-				continue
-			}
-
-			// Step 3: Check each rule for ICMP and port restrictions
-			for _, rule := range rules {
-				// Handle ICMP before port range check — ICMP has no ports
-				if proto == header.ICMPv4ProtocolNumber || proto == header.ICMPv6ProtocolNumber {
-					if rule.DisableIcmp {
-						return nil
-					}
-					// ICMP is allowed; port ranges don't apply to ICMP
-					return rule
-				}
-
-				// Check port restrictions
-				if len(rule.PortRanges) == 0 {
-					// No port restrictions, match!
-					return rule
-				}
-
-				// Check if port and protocol are in any of the allowed ranges
-				for _, pr := range rule.PortRanges {
-					if port >= pr.Min && port <= pr.Max {
-						// Check protocol compatibility
-						if pr.Protocol == "" {
-							// Empty protocol means allow both TCP and UDP
-							return rule
-						}
-						// Check if the packet protocol matches the port range protocol
-						if (pr.Protocol == "tcp" && proto == header.TCPProtocolNumber) ||
-							(pr.Protocol == "udp" && proto == header.UDPProtocolNumber) {
-							return rule
-						}
-						// Port matches but protocol doesn't - continue checking other ranges
-					}
-				}
-			}
-		}
-	}
-
-	return nil
-}

netstack2/tun.go

@@ -351,13 +351,13 @@ func (net *Net) ListenUDP(laddr *net.UDPAddr) (*gonet.UDPConn, error) {
 	return net.DialUDP(laddr, nil)
 }
 
-// AddProxySubnetRule adds a subnet rule to the proxy handler.
-// HTTP proxy behaviour is configured via rule.Protocol, rule.HTTPTargets,
-// rule.TLSCert, and rule.TLSKey; leave Protocol empty for raw TCP/UDP.
-func (net *Net) AddProxySubnetRule(rule SubnetRule) {
+// AddProxySubnetRule adds a subnet rule to the proxy handler
+// If portRanges is nil or empty, all ports are allowed for this subnet
+// rewriteTo can be either an IP/CIDR (e.g., "192.168.1.1/32") or a domain name (e.g., "example.com")
+func (net *Net) AddProxySubnetRule(sourcePrefix, destPrefix netip.Prefix, rewriteTo string, portRanges []PortRange, disableIcmp bool) {
 	tun := (*netTun)(net)
 	if tun.proxyHandler != nil {
-		tun.proxyHandler.AddSubnetRule(rule)
+		tun.proxyHandler.AddSubnetRule(sourcePrefix, destPrefix, rewriteTo, portRanges, disableIcmp)
 	}
 }
 
@@ -369,15 +369,6 @@ func (net *Net) RemoveProxySubnetRule(sourcePrefix, destPrefix netip.Prefix) {
 	}
 }
 
-// GetProxySubnetRules returns all subnet rules from the proxy handler
-func (net *Net) GetProxySubnetRules() []SubnetRule {
-	tun := (*netTun)(net)
-	if tun.proxyHandler != nil {
-		return tun.proxyHandler.GetAllRules()
-	}
-	return nil
-}
-
 // GetProxyHandler returns the proxy handler (for advanced use cases)
 // Returns nil if proxy is not enabled
 func (net *Net) GetProxyHandler() *ProxyHandler {
@@ -385,25 +376,6 @@ func (net *Net) GetProxyHandler() *ProxyHandler {
 	return tun.proxyHandler
 }
 
-// SetAccessLogSender configures the function used to send compressed access log
-// batches to the server. This should be called once the websocket client is available.
-func (net *Net) SetAccessLogSender(fn SendFunc) {
-	tun := (*netTun)(net)
-	if tun.proxyHandler != nil {
-		tun.proxyHandler.SetAccessLogSender(fn)
-	}
-}
-
-// SetHTTPRequestLogSender configures the function used to send compressed HTTP
-// request log batches to the server. This should be called once the websocket
-// client is available.
-func (net *Net) SetHTTPRequestLogSender(fn SendFunc) {
-	tun := (*netTun)(net)
-	if tun.proxyHandler != nil {
-		tun.proxyHandler.SetHTTPRequestLogSender(fn)
-	}
-}
-
 type PingConn struct {
 	laddr    PingAddr
 	raddr    PingAddr

network/interface.go

@@ -44,13 +44,9 @@ func ConfigureInterface(interfaceName string, tunnelIp string, mtu int) error {
 		return configureDarwin(interfaceName, ip, ipNet)
 	case "windows":
 		return configureWindows(interfaceName, ip, ipNet)
-	case "android":
-		return nil
-	case "ios":
-		return nil
+	default:
+		return fmt.Errorf("unsupported operating system: %s", runtime.GOOS)
 	}
-
-	return nil
 }
 
 // waitForInterfaceUp polls the network interface until it's up or times out
@@ -120,7 +116,7 @@ func configureDarwin(interfaceName string, ip net.IP, ipNet *net.IPNet) error {
 	prefix, _ := ipNet.Mask.Size()
 	ipStr := fmt.Sprintf("%s/%d", ip.String(), prefix)
 
-	cmd := exec.Command("/sbin/ifconfig", interfaceName, "inet", ipStr, ip.String(), "alias")
+	cmd := exec.Command("ifconfig", interfaceName, "inet", ipStr, ip.String(), "alias")
 	logger.Info("Running command: %v", cmd)
 
 	out, err := cmd.CombinedOutput()
@@ -129,7 +125,7 @@ func configureDarwin(interfaceName string, ip net.IP, ipNet *net.IPNet) error {
 	}
 
 	// Bring up the interface
-	cmd = exec.Command("/sbin/ifconfig", interfaceName, "up")
+	cmd = exec.Command("ifconfig", interfaceName, "up")
 	logger.Info("Running command: %v", cmd)
 
 	out, err = cmd.CombinedOutput()

network/route.go

@@ -126,14 +126,13 @@ func LinuxRemoveRoute(destination string) error {
 
 // addRouteForServerIP adds an OS-specific route for the server IP
 func AddRouteForServerIP(serverIP, interfaceName string) error {
+	if err := AddRouteForNetworkConfig(serverIP); err != nil {
+		return err
+	}
 	if interfaceName == "" {
 		return nil
 	}
-	// TODO: does this also need to be ios?
-	if runtime.GOOS == "darwin" { // macos requires routes for each peer to be added but this messes with other platforms
-		if err := AddRouteForNetworkConfig(serverIP); err != nil {
-			return err
-		}
+	if runtime.GOOS == "darwin" {
 		return DarwinAddRoute(serverIP, "", interfaceName)
 	}
 	// else if runtime.GOOS == "windows" {
@@ -146,14 +145,13 @@ func AddRouteForServerIP(serverIP, interfaceName string) error {
 
 // removeRouteForServerIP removes an OS-specific route for the server IP
 func RemoveRouteForServerIP(serverIP string, interfaceName string) error {
+	if err := RemoveRouteForNetworkConfig(serverIP); err != nil {
+		return err
+	}
 	if interfaceName == "" {
 		return nil
 	}
-	// TODO: does this also need to be ios?
-	if runtime.GOOS == "darwin" { // macos requires routes for each peer to be added but this messes with other platforms
-		if err := RemoveRouteForNetworkConfig(serverIP); err != nil {
-			return err
-		}
+	if runtime.GOOS == "darwin" {
 		return DarwinRemoveRoute(serverIP)
 	}
 	// else if runtime.GOOS == "windows" {
@@ -219,22 +217,21 @@ func AddRoutes(remoteSubnets []string, interfaceName string) error {
 			continue
 		}
 
-		switch runtime.GOOS {
-		case "darwin":
+		if runtime.GOOS == "darwin" {
 			if err := DarwinAddRoute(subnet, "", interfaceName); err != nil {
 				logger.Error("Failed to add Darwin route for subnet %s: %v", subnet, err)
+				return err
 			}
-		case "windows":
+		} else if runtime.GOOS == "windows" {
 			if err := WindowsAddRoute(subnet, "", interfaceName); err != nil {
 				logger.Error("Failed to add Windows route for subnet %s: %v", subnet, err)
+				return err
 			}
-		case "linux":
+		} else if runtime.GOOS == "linux" {
 			if err := LinuxAddRoute(subnet, "", interfaceName); err != nil {
 				logger.Error("Failed to add Linux route for subnet %s: %v", subnet, err)
+				return err
 			}
-		case "android", "ios":
-			// Routes handled by the OS/VPN service
-			continue
 		}
 
 		logger.Info("Added route for remote subnet: %s", subnet)
@@ -261,22 +258,21 @@ func RemoveRoutes(remoteSubnets []string) error {
 		}
 
 		// Remove route based on operating system
-		switch runtime.GOOS {
-		case "darwin":
+		if runtime.GOOS == "darwin" {
 			if err := DarwinRemoveRoute(subnet); err != nil {
 				logger.Error("Failed to remove Darwin route for subnet %s: %v", subnet, err)
+				return err
 			}
-		case "windows":
+		} else if runtime.GOOS == "windows" {
 			if err := WindowsRemoveRoute(subnet); err != nil {
 				logger.Error("Failed to remove Windows route for subnet %s: %v", subnet, err)
+				return err
 			}
-		case "linux":
+		} else if runtime.GOOS == "linux" {
 			if err := LinuxRemoveRoute(subnet); err != nil {
 				logger.Error("Failed to remove Linux route for subnet %s: %v", subnet, err)
+				return err
 			}
-		case "android", "ios":
-			// Routes handled by the OS/VPN service
-			continue
 		}
 
 		logger.Info("Removed route for remote subnet: %s", subnet)

network/settings.go

@@ -115,7 +115,7 @@ func RemoveIPv4IncludedRoute(route IPv4Route) {
 		if r == route {
 			networkSettings.IPv4IncludedRoutes = append(routes[:i], routes[i+1:]...)
 			logger.Info("Removed IPv4 included route: %+v", route)
-			break
+			return
 		}
 	}
 	incrementor++

newt.iss

@@ -32,7 +32,7 @@ DefaultGroupName={#MyAppName}
 DisableProgramGroupPage=yes
 ; Uncomment the following line to run in non administrative install mode (install for current user only).
 ;PrivilegesRequired=lowest
-OutputBaseFilename=newt_windows_installer
+OutputBaseFilename=mysetup
 SolidCompression=yes
 WizardStyle=modern
 ; Add this to ensure PATH changes are applied and the system is prompted for a restart if needed

proxy/manager.go

@@ -21,32 +21,7 @@ import (
 	"gvisor.dev/gvisor/pkg/tcpip/adapters/gonet"
 )
 
-const (
-	errUnsupportedProtoFmt = "unsupported protocol: %s"
-	maxUDPPacketSize       = 65507 // Maximum UDP packet size
-	defaultUDPIdleTimeout  = 90 * time.Second
-)
-
-// udpBufferPool provides reusable buffers for UDP packet handling.
-// This reduces GC pressure from frequent large allocations.
-var udpBufferPool = sync.Pool{
-	New: func() any {
-		buf := make([]byte, maxUDPPacketSize)
-		return &buf
-	},
-}
-
-// getUDPBuffer retrieves a buffer from the pool.
-func getUDPBuffer() *[]byte {
-	return udpBufferPool.Get().(*[]byte)
-}
-
-// putUDPBuffer clears and returns a buffer to the pool.
-func putUDPBuffer(buf *[]byte) {
-	// Clear the buffer to prevent data leakage
-	clear(*buf)
-	udpBufferPool.Put(buf)
-}
+const errUnsupportedProtoFmt = "unsupported protocol: %s"
 
 // Target represents a proxy target with its address and port
 type Target struct {
@@ -69,7 +44,6 @@ type ProxyManager struct {
 	tunnels         map[string]*tunnelEntry
 	asyncBytes      bool
 	flushStop       chan struct{}
-	udpIdleTimeout  time.Duration
 }
 
 // tunnelEntry holds per-tunnel attributes and (optional) async counters.
@@ -131,9 +105,13 @@ func classifyProxyError(err error) string {
 	if errors.Is(err, net.ErrClosed) {
 		return "closed"
 	}
-	var ne net.Error
-	if errors.As(err, &ne) && ne.Timeout() {
-		return "timeout"
+	if ne, ok := err.(net.Error); ok {
+		if ne.Timeout() {
+			return "timeout"
+		}
+		if ne.Temporary() {
+			return "temporary"
+		}
 	}
 	msg := strings.ToLower(err.Error())
 	switch {
@@ -155,7 +133,6 @@ func NewProxyManager(tnet *netstack.Net) *ProxyManager {
 		listeners:  make([]*gonet.TCPListener, 0),
 		udpConns:   make([]*gonet.UDPConn, 0),
 		tunnels:    make(map[string]*tunnelEntry),
-		udpIdleTimeout: defaultUDPIdleTimeout,
 	}
 }
 
@@ -233,7 +210,6 @@ func NewProxyManagerWithoutTNet() *ProxyManager {
 		udpTargets: make(map[string]map[int]string),
 		listeners:  make([]*gonet.TCPListener, 0),
 		udpConns:   make([]*gonet.UDPConn, 0),
-		udpIdleTimeout: defaultUDPIdleTimeout,
 	}
 }
 
@@ -370,17 +346,6 @@ func (pm *ProxyManager) SetAsyncBytes(b bool) {
 		go pm.flushLoop()
 	}
 }
-
-// SetUDPIdleTimeout configures when idle UDP client flows are reclaimed.
-func (pm *ProxyManager) SetUDPIdleTimeout(d time.Duration) {
-	pm.mutex.Lock()
-	defer pm.mutex.Unlock()
-	if d <= 0 {
-		pm.udpIdleTimeout = defaultUDPIdleTimeout
-		return
-	}
-	pm.udpIdleTimeout = d
-}
 func (pm *ProxyManager) flushLoop() {
 	flushInterval := 2 * time.Second
 	if v := os.Getenv("OTEL_METRIC_EXPORT_INTERVAL"); v != "" {
@@ -472,6 +437,14 @@ func (pm *ProxyManager) Stop() error {
 		pm.udpConns = append(pm.udpConns[:i], pm.udpConns[i+1:]...)
 	}
 
+	// // Clear the target maps
+	// for k := range pm.tcpTargets {
+	// 	delete(pm.tcpTargets, k)
+	// }
+	// for k := range pm.udpTargets {
+	// 	delete(pm.udpTargets, k)
+	// }
+
 	// Give active connections a chance to close gracefully
 	time.Sleep(100 * time.Millisecond)
 
@@ -525,7 +498,7 @@ func (pm *ProxyManager) handleTCPProxy(listener net.Listener, targetAddr string)
 			if !pm.running {
 				return
 			}
-			if errors.Is(err, net.ErrClosed) {
+			if ne, ok := err.(net.Error); ok && !ne.Temporary() {
 				logger.Info("TCP listener closed, stopping proxy handler for %v", listener.Addr())
 				return
 			}
@@ -591,9 +564,7 @@ func (pm *ProxyManager) handleTCPProxy(listener net.Listener, targetAddr string)
 }
 
 func (pm *ProxyManager) handleUDPProxy(conn *gonet.UDPConn, targetAddr string) {
-	bufPtr := getUDPBuffer()
-	defer putUDPBuffer(bufPtr)
-	buffer := *bufPtr
+	buffer := make([]byte, 65507) // Max UDP packet size
 	clientConns := make(map[string]*net.UDPConn)
 	var clientsMutex sync.RWMutex
 
@@ -612,7 +583,7 @@ func (pm *ProxyManager) handleUDPProxy(conn *gonet.UDPConn, targetAddr string) {
 			}
 
 			// Check for connection closed conditions
-			if errors.Is(err, io.EOF) || errors.Is(err, net.ErrClosed) {
+			if err == io.EOF || strings.Contains(err.Error(), "use of closed network connection") {
 				logger.Info("UDP connection closed, stopping proxy handler")
 
 				// Clean up existing client connections
@@ -661,9 +632,6 @@ func (pm *ProxyManager) handleUDPProxy(conn *gonet.UDPConn, targetAddr string) {
 				telemetry.IncProxyAccept(context.Background(), pm.currentTunnelID, "udp", "failure", classifyProxyError(err))
 				continue
 			}
-			// Prevent idle UDP client goroutines from living forever and
-			// retaining large per-connection buffers.
-			_ = targetConn.SetReadDeadline(time.Now().Add(pm.udpIdleTimeout))
 			tunnelID := pm.currentTunnelID
 			telemetry.IncProxyAccept(context.Background(), tunnelID, "udp", "success", "")
 			telemetry.IncProxyConnectionEvent(context.Background(), tunnelID, "udp", telemetry.ProxyConnectionOpened)
@@ -679,10 +647,7 @@ func (pm *ProxyManager) handleUDPProxy(conn *gonet.UDPConn, targetAddr string) {
 			go func(clientKey string, targetConn *net.UDPConn, remoteAddr net.Addr, tunnelID string) {
 				start := time.Now()
 				result := "success"
-				bufPtr := getUDPBuffer()
 				defer func() {
-					// Return buffer to pool first
-					putUDPBuffer(bufPtr)
 					// Always clean up when this goroutine exits
 					clientsMutex.Lock()
 					if storedConn, exists := clientConns[clientKey]; exists && storedConn == targetConn {
@@ -697,18 +662,10 @@ func (pm *ProxyManager) handleUDPProxy(conn *gonet.UDPConn, targetAddr string) {
 					telemetry.IncProxyConnectionEvent(context.Background(), tunnelID, "udp", telemetry.ProxyConnectionClosed)
 				}()
 
-				buffer := *bufPtr
+				buffer := make([]byte, 65507)
 				for {
 					n, _, err := targetConn.ReadFromUDP(buffer)
 					if err != nil {
-						var netErr net.Error
-						if errors.As(err, &netErr) && netErr.Timeout() {
-							return
-						}
-						// Connection closed is normal during cleanup
-						if errors.Is(err, net.ErrClosed) || errors.Is(err, io.EOF) {
-							return // defer will handle cleanup, result stays "success"
-						}
 						logger.Error("Error reading from target: %v", err)
 						result = "failure"
 						return // defer will handle cleanup
@@ -747,8 +704,6 @@ func (pm *ProxyManager) handleUDPProxy(conn *gonet.UDPConn, targetAddr string) {
 			delete(clientConns, clientKey)
 			clientsMutex.Unlock()
 		} else if pm.currentTunnelID != "" && written > 0 {
-			// Extend idle timeout whenever client traffic is observed.
-			_ = targetConn.SetReadDeadline(time.Now().Add(pm.udpIdleTimeout))
 			if pm.asyncBytes {
 				if e := pm.getEntry(pm.currentTunnelID); e != nil {
 					e.bytesInUDP.Add(uint64(written))
@@ -781,28 +736,3 @@ func (pm *ProxyManager) PrintTargets() {
 		}
 	}
 }
-
-// GetTargets returns a copy of the current TCP and UDP targets
-// Returns map[listenIP]map[port]targetAddress for both TCP and UDP
-func (pm *ProxyManager) GetTargets() (tcpTargets map[string]map[int]string, udpTargets map[string]map[int]string) {
-	pm.mutex.RLock()
-	defer pm.mutex.RUnlock()
-
-	tcpTargets = make(map[string]map[int]string)
-	for listenIP, targets := range pm.tcpTargets {
-		tcpTargets[listenIP] = make(map[int]string)
-		for port, targetAddr := range targets {
-			tcpTargets[listenIP][port] = targetAddr
-		}
-	}
-
-	udpTargets = make(map[string]map[int]string)
-	for listenIP, targets := range pm.udpTargets {
-		udpTargets[listenIP] = make(map[int]string)
-		for port, targetAddr := range targets {
-			udpTargets[listenIP][port] = targetAddr
-		}
-	}
-
-	return tcpTargets, udpTargets
-}

testing/ws_client.py

@@ -1,60 +0,0 @@
-import asyncio
-import sys
-import websockets
-
-# Argument parsing: Check if HOST and PORT are provided
-if len(sys.argv) < 3 or len(sys.argv) > 4:
-    print("Usage: python ws_client.py <HOST_IP> <HOST_PORT> [ws|wss]")
-    # Example: python ws_client.py 127.0.0.1 8765
-    # Example: python ws_client.py 127.0.0.1 8765 wss
-    sys.exit(1)
-
-HOST = sys.argv[1]
-try:
-    PORT = int(sys.argv[2])
-except ValueError:
-    print("Error: HOST_PORT must be an integer.")
-    sys.exit(1)
-
-if len(sys.argv) == 4:
-    SCHEME = sys.argv[3].lower()
-    if SCHEME not in ("ws", "wss"):
-        print("Error: scheme must be 'ws' or 'wss'.")
-        sys.exit(1)
-else:
-    SCHEME = "ws"
-
-URI = f"{SCHEME}://{HOST}:{PORT}"
-
-# The message to send to the server
-MESSAGE = "Hello WebSocket Server! How are you?"
-
-
-async def main():
-    print(f"Connecting to {URI}...")
-
-    try:
-        async with websockets.connect(URI) as websocket:
-            print(f"Connected to server.")
-            print(f"Sending message: '{MESSAGE}'")
-
-            await websocket.send(MESSAGE)
-
-            response = await websocket.recv()
-
-            print("-" * 30)
-            print(f"Received response from server:")
-            print(f"-> Data: '{response}'")
-
-    except ConnectionRefusedError:
-        print(f"Error: Connection to {URI} was refused. Is the server running?")
-    except websockets.exceptions.InvalidMessage as e:
-        print(f"Error: Server did not respond with a valid WebSocket handshake: {e}")
-    except Exception as e:
-        print(f"Error during communication: {e}")
-
-    print("-" * 30)
-    print("Client finished.")
-
-
-asyncio.run(main())

testing/ws_server.py

@@ -1,49 +0,0 @@
-import asyncio
-import sys
-import websockets
-
-# Optionally take in a positional arg for the port
-if len(sys.argv) > 1:
-    try:
-        PORT = int(sys.argv[1])
-    except ValueError:
-        print("Invalid port number. Using default port 8765.")
-        PORT = 8765
-else:
-    PORT = 8765
-
-# Define the server host
-HOST = "0.0.0.0"
-
-
-async def handle_client(websocket):
-    client_address = websocket.remote_address
-    print(f"Client connected: {client_address[0]}:{client_address[1]}")
-
-    try:
-        async for message in websocket:
-            print("-" * 30)
-            print(f"Received message from {client_address[0]}:{client_address[1]}:")
-            print(f"-> Data: '{message}'")
-
-            response = f"Hello client! Server received: '{message.upper()}'"
-
-            await websocket.send(response)
-            print(f"Sent response back to client.")
-
-    except websockets.exceptions.ConnectionClosedOK:
-        print(f"Client {client_address[0]}:{client_address[1]} disconnected cleanly.")
-    except websockets.exceptions.ConnectionClosedError as e:
-        print(f"Client {client_address[0]}:{client_address[1]} disconnected with error: {e}")
-
-
-async def main():
-    print(f"WebSocket Server listening on {HOST}:{PORT}")
-    async with websockets.serve(handle_client, HOST, PORT):
-        await asyncio.Future()  # Run forever
-
-
-try:
-    asyncio.run(main())
-except KeyboardInterrupt:
-    print("\nServer stopped.")

updates/updates.go

@@ -119,7 +119,7 @@ func CheckForUpdate(owner, repo, currentVersion string) error {
 
 	// Check if update is available
 	if currentVer.isNewer(latestVer) {
-		printUpdateBanner(currentVer.String(), latestVer.String(), "curl -fsSL https://static.pangolin.net/get-newt.sh | bash")
+		printUpdateBanner(currentVer.String(), latestVer.String(), release.HTMLURL)
 	}
 
 	return nil
@@ -145,7 +145,7 @@ func printUpdateBanner(currentVersion, latestVersion, releaseURL string) {
 		"║  A newer version is available! Please update to get the" + padRight("", contentWidth-56) + "║",
 		"║  latest features, bug fixes, and security improvements." + padRight("", contentWidth-56) + "║",
 		emptyLine,
-		"║  Update: " + padRight(releaseURL, contentWidth-10) + "║",
+		"║  Release URL: " + padRight(releaseURL, contentWidth-15) + "║",
 		emptyLine,
 		borderBot,
 	}

util/util.go

@@ -1,7 +1,6 @@
 package util
 
 import (
-	"context"
 	"encoding/base64"
 	"encoding/binary"
 	"encoding/hex"
@@ -15,99 +14,6 @@ import (
 	"golang.zx2c4.com/wireguard/device"
 )
 
-func ResolveDomainUpstream(domain string, publicDNS []string) (string, error) {
-	// trim whitespace
-	domain = strings.TrimSpace(domain)
-
-	// Remove any protocol prefix if present (do this first, before splitting host/port)
-	domain = strings.TrimPrefix(domain, "http://")
-	domain = strings.TrimPrefix(domain, "https://")
-
-	// if there are any trailing slashes, remove them
-	domain = strings.TrimSuffix(domain, "/")
-
-	// Check if there's a port in the domain
-	host, port, err := net.SplitHostPort(domain)
-	if err != nil {
-		// No port found, use the domain as is
-		host = domain
-		port = ""
-	}
-
-	// Check if host is already an IP address (IPv4 or IPv6)
-	// For IPv6, the host from SplitHostPort will already have brackets stripped
-	// but if there was no port, we need to handle bracketed IPv6 addresses
-	cleanHost := strings.TrimPrefix(strings.TrimSuffix(host, "]"), "[")
-	if ip := net.ParseIP(cleanHost); ip != nil {
-		// It's already an IP address, no need to resolve
-		ipAddr := ip.String()
-		if port != "" {
-			return net.JoinHostPort(ipAddr, port), nil
-		}
-		return ipAddr, nil
-	}
-
-	// Lookup IP addresses using the upstream DNS servers if provided
-	var ips []net.IP
-	if len(publicDNS) > 0 {
-		var lastErr error
-		for _, server := range publicDNS {
-			// Ensure the upstream DNS address has a port
-			dnsAddr := server
-			if _, _, err := net.SplitHostPort(dnsAddr); err != nil {
-				// No port specified, default to 53
-				dnsAddr = net.JoinHostPort(server, "53")
-			}
-
-			resolver := &net.Resolver{
-				PreferGo: true,
-				Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
-					d := net.Dialer{}
-					return d.DialContext(ctx, "udp", dnsAddr)
-				},
-			}
-			ips, lastErr = resolver.LookupIP(context.Background(), "ip", host)
-			if lastErr == nil {
-				break
-			}
-		}
-		if lastErr != nil {
-			return "", fmt.Errorf("DNS lookup failed using all upstream servers: %v", lastErr)
-		}
-	} else {
-		ips, err = net.LookupIP(host)
-		if err != nil {
-			return "", fmt.Errorf("DNS lookup failed: %v", err)
-		}
-	}
-
-	if len(ips) == 0 {
-		return "", fmt.Errorf("no IP addresses found for domain %s", host)
-	}
-
-	// Get the first IPv4 address if available
-	var ipAddr string
-	for _, ip := range ips {
-		if ipv4 := ip.To4(); ipv4 != nil {
-			ipAddr = ipv4.String()
-			break
-		}
-	}
-
-	// If no IPv4 found, use the first IP (might be IPv6)
-	if ipAddr == "" {
-		ipAddr = ips[0].String()
-	}
-
-	// Add port back if it existed
-	if port != "" {
-		ipAddr = net.JoinHostPort(ipAddr, port)
-	}
-
-	return ipAddr, nil
-}
-
-
 func ResolveDomain(domain string) (string, error) {
 	// trim whitespace
 	domain = strings.TrimSpace(domain)

websocket/client.go

@@ -2,7 +2,6 @@ package websocket
 
 import (
 	"bytes"
-	"compress/gzip"
 	"crypto/tls"
 	"crypto/x509"
 	"encoding/json"
@@ -38,22 +37,16 @@ type Client struct {
 	isConnected       bool
 	reconnectMux      sync.RWMutex
 	pingInterval      time.Duration
+	pingTimeout       time.Duration
 	onConnect         func() error
 	onTokenUpdate     func(token string)
 	writeMux          sync.Mutex
 	clientType        string // Type of client (e.g., "newt", "olm")
-	configFilePath    string // Optional override for the config file path
 	tlsConfig         TLSConfig
 	metricsCtxMu      sync.RWMutex
 	metricsCtx        context.Context
 	configNeedsSave   bool // Flag to track if config needs to be saved
 	serverVersion     string
-	configVersion     int64        // Latest config version received from server
-	configVersionMux  sync.RWMutex
-	processingMessage bool           // Flag to track if a message is currently being processed
-	processingMux     sync.RWMutex   // Protects processingMessage
-	processingWg      sync.WaitGroup // WaitGroup to wait for message processing to complete
-	justProvisioned   bool           // Set to true when provisionIfNeeded exchanges a key for permanent credentials
 }
 
 type ClientOption func(*Client)
@@ -79,12 +72,6 @@ func WithBaseURL(url string) ClientOption {
 }
 
 // WithTLSConfig sets the TLS configuration for the client
-func WithConfigFile(path string) ClientOption {
-	return func(c *Client) {
-		c.configFilePath = path
-	}
-}
-
 func WithTLSConfig(config TLSConfig) ClientOption {
 	return func(c *Client) {
 		c.tlsConfig = config
@@ -103,16 +90,6 @@ func (c *Client) OnTokenUpdate(callback func(token string)) {
 	c.onTokenUpdate = callback
 }
 
-// WasJustProvisioned reports whether the client exchanged a provisioning key
-// for permanent credentials during the most recent connection attempt. It
-// consumes the flag – subsequent calls return false until provisioning occurs
-// again (which, in practice, never happens once credentials are persisted).
-func (c *Client) WasJustProvisioned() bool {
-	v := c.justProvisioned
-	c.justProvisioned = false
-	return v
-}
-
 func (c *Client) metricsContext() context.Context {
 	c.metricsCtxMu.RLock()
 	defer c.metricsCtxMu.RUnlock()
@@ -134,7 +111,7 @@ func (c *Client) MetricsContext() context.Context {
 }
 
 // NewClient creates a new websocket client
-func NewClient(clientType string, ID, secret string, endpoint string, pingInterval time.Duration, opts ...ClientOption) (*Client, error) {
+func NewClient(clientType string, ID, secret string, endpoint string, pingInterval time.Duration, pingTimeout time.Duration, opts ...ClientOption) (*Client, error) {
 	config := &Config{
 		ID:       ID,
 		Secret:   secret,
@@ -149,6 +126,7 @@ func NewClient(clientType string, ID, secret string, endpoint string, pingInterv
 		reconnectInterval: 3 * time.Second,
 		isConnected:       false,
 		pingInterval:      pingInterval,
+		pingTimeout:       pingTimeout,
 		clientType:        clientType,
 	}
 
@@ -176,20 +154,6 @@ func (c *Client) GetServerVersion() string {
 	return c.serverVersion
 }
 
-// GetConfigVersion returns the latest config version received from server
-func (c *Client) GetConfigVersion() int64 {
-	c.configVersionMux.RLock()
-	defer c.configVersionMux.RUnlock()
-	return c.configVersion
-}
-
-// setConfigVersion updates the config version
-func (c *Client) setConfigVersion(version int64) {
-	c.configVersionMux.Lock()
-	defer c.configVersionMux.Unlock()
-	c.configVersion = version
-}
-
 // Connect establishes the WebSocket connection
 func (c *Client) Connect() error {
 	go c.connectWithRetry()
@@ -499,11 +463,6 @@ func (c *Client) connectWithRetry() {
 func (c *Client) establishConnection() error {
 	ctx := context.Background()
 
-	// Exchange provisioning key for permanent credentials if needed.
-	if err := c.provisionIfNeeded(); err != nil {
-		return fmt.Errorf("failed to provision newt credentials: %w", err)
-	}
-
 	// Get token for authentication
 	token, err := c.getToken()
 	if err != nil {
@@ -682,61 +641,7 @@ func (c *Client) setupPKCS12TLS() (*tls.Config, error) {
 }
 
 // pingMonitor sends pings at a short interval and triggers reconnect on failure
-func (c *Client) sendPing() {
-	if c.conn == nil {
-		return
-	}
-
-	// Skip ping if a message is currently being processed
-	c.processingMux.RLock()
-	isProcessing := c.processingMessage
-	c.processingMux.RUnlock()
-	if isProcessing {
-		logger.Debug("Skipping ping, message is being processed")
-		return
-	}
-
-	c.configVersionMux.RLock()
-	configVersion := c.configVersion
-	c.configVersionMux.RUnlock()
-
-	pingMsg := WSMessage{
-		Type:          "newt/ping",
-		Data:          map[string]interface{}{},
-		ConfigVersion: configVersion,
-	}
-
-	c.writeMux.Lock()
-	if c.conn == nil {
-		c.writeMux.Unlock()
-		return
-	}
-	err := c.conn.WriteJSON(pingMsg)
-	if err == nil {
-		telemetry.IncWSMessage(c.metricsContext(), "out", "ping")
-	}
-	c.writeMux.Unlock()
-
-	if err != nil {
-		// Check if we're shutting down before logging error and reconnecting
-		select {
-		case <-c.done:
-			// Expected during shutdown
-			return
-		default:
-			logger.Error("Ping failed: %v", err)
-			telemetry.IncWSKeepaliveFailure(c.metricsContext(), "ping_write")
-			telemetry.IncWSReconnect(c.metricsContext(), "ping_write")
-			c.reconnect()
-			return
-		}
-	}
-}
-
 func (c *Client) pingMonitor() {
-	// Send an immediate ping as soon as we connect
-	c.sendPing()
-
 	ticker := time.NewTicker(c.pingInterval)
 	defer ticker.Stop()
 
@@ -745,7 +650,29 @@ func (c *Client) pingMonitor() {
 		case <-c.done:
 			return
 		case <-ticker.C:
-			c.sendPing()
+			if c.conn == nil {
+				return
+			}
+			c.writeMux.Lock()
+			err := c.conn.WriteControl(websocket.PingMessage, []byte{}, time.Now().Add(c.pingTimeout))
+			if err == nil {
+				telemetry.IncWSMessage(c.metricsContext(), "out", "ping")
+			}
+			c.writeMux.Unlock()
+			if err != nil {
+				// Check if we're shutting down before logging error and reconnecting
+				select {
+				case <-c.done:
+					// Expected during shutdown
+					return
+				default:
+					logger.Error("Ping failed: %v", err)
+					telemetry.IncWSKeepaliveFailure(c.metricsContext(), "ping_write")
+					telemetry.IncWSReconnect(c.metricsContext(), "ping_write")
+					c.reconnect()
+					return
+				}
+			}
 		}
 	}
 }
@@ -782,13 +709,10 @@ func (c *Client) readPumpWithDisconnectDetection(started time.Time) {
 			disconnectResult = "success"
 			return
 		default:
-			msgType, p, err := c.conn.ReadMessage()
+			var msg WSMessage
+			err := c.conn.ReadJSON(&msg)
 			if err == nil {
-				if msgType == websocket.BinaryMessage {
-					telemetry.IncWSMessage(c.metricsContext(), "in", "binary")
-				} else {
-					telemetry.IncWSMessage(c.metricsContext(), "in", "text")
-				}
+				telemetry.IncWSMessage(c.metricsContext(), "in", "text")
 			}
 			if err != nil {
 				// Check if we're shutting down before logging error
@@ -813,47 +737,9 @@ func (c *Client) readPumpWithDisconnectDetection(started time.Time) {
 				}
 			}
 
-			// Update config version from incoming message
-			var data []byte
-			if msgType == websocket.BinaryMessage {
-				gr, err := gzip.NewReader(bytes.NewReader(p))
-				if err != nil {
-					logger.Error("WebSocket failed to create gzip reader: %v", err)
-					continue
-				}
-				data, err = io.ReadAll(gr)
-				gr.Close()
-				if err != nil {
-					logger.Error("WebSocket failed to decompress message: %v", err)
-					continue
-				}
-			} else {
-				data = p
-			}
-
-			var msg WSMessage
-			if err = json.Unmarshal(data, &msg); err != nil {
-				logger.Error("WebSocket failed to parse message: %v", err)
-				continue
-			}
-			
-			c.setConfigVersion(msg.ConfigVersion)
-
 			c.handlersMux.RLock()
 			if handler, ok := c.handlers[msg.Type]; ok {
-				// Mark that we're processing a message
-				c.processingMux.Lock()
-				c.processingMessage = true
-				c.processingMux.Unlock()
-				c.processingWg.Add(1)
-
 				handler(msg)
-
-				// Mark that we're done processing
-				c.processingWg.Done()
-				c.processingMux.Lock()
-				c.processingMessage = false
-				c.processingMux.Unlock()
 			}
 			c.handlersMux.RUnlock()
 		}
@@ -863,12 +749,10 @@ func (c *Client) readPumpWithDisconnectDetection(started time.Time) {
 func (c *Client) reconnect() {
 	c.setConnected(false)
 	telemetry.SetWSConnectionState(false)
-	c.writeMux.Lock()
 	if c.conn != nil {
 		c.conn.Close()
 		c.conn = nil
 	}
-	c.writeMux.Unlock()
 
 	// Only reconnect if we're not shutting down
 	select {

websocket/config.go

@@ -1,29 +1,16 @@
 package websocket
 
 import (
-	"bytes"
-	"context"
-	"crypto/tls"
 	"encoding/json"
-	"fmt"
-	"io"
 	"log"
-	"net/http"
-	"net/url"
 	"os"
 	"path/filepath"
-	"regexp"
 	"runtime"
-	"strings"
-	"time"
 
 	"github.com/fosrl/newt/logger"
 )
 
-func getConfigPath(clientType string, overridePath string) string {
-	if overridePath != "" {
-		return overridePath
-	}
+func getConfigPath(clientType string) string {
 	configFile := os.Getenv("CONFIG_FILE")
 	if configFile == "" {
 		var configDir string
@@ -49,7 +36,7 @@ func getConfigPath(clientType string, overridePath string) string {
 
 func (c *Client) loadConfig() error {
 	originalConfig := *c.config // Store original config to detect changes
-	configPath := getConfigPath(c.clientType, c.configFilePath)
+	configPath := getConfigPath(c.clientType)
 
 	if c.config.ID != "" && c.config.Secret != "" && c.config.Endpoint != "" {
 		logger.Debug("Config already provided, skipping loading from file")
@@ -71,11 +58,6 @@ func (c *Client) loadConfig() error {
 		}
 		return err
 	}
-	if len(bytes.TrimSpace(data)) == 0 {
-		logger.Info("Config file at %s is empty, will initialize it with provided values", configPath)
-		c.configNeedsSave = true
-		return nil
-	}
 
 	var config Config
 	if err := json.Unmarshal(data, &config); err != nil {
@@ -101,14 +83,6 @@ func (c *Client) loadConfig() error {
 		c.config.Endpoint = config.Endpoint
 		c.baseURL = config.Endpoint
 	}
-	// Always load the provisioning key from the file if not already set
-	if c.config.ProvisioningKey == "" {
-		c.config.ProvisioningKey = config.ProvisioningKey
-	}
-	// Always load the name from the file if not already set
-	if c.config.Name == "" {
-		c.config.Name = config.Name
-	}
 
 	// Check if CLI args provided values that override file values
 	if (!fileHadID && originalConfig.ID != "") ||
@@ -131,7 +105,7 @@ func (c *Client) saveConfig() error {
 		return nil
 	}
 
-	configPath := getConfigPath(c.clientType, c.configFilePath)
+	configPath := getConfigPath(c.clientType)
 	data, err := json.MarshalIndent(c.config, "", "  ")
 	if err != nil {
 		return err
@@ -144,139 +118,3 @@ func (c *Client) saveConfig() error {
 	}
 	return err
 }
-
-// interpolateString replaces {{env.VAR}} tokens in s with the corresponding
-// environment variable values. Tokens that do not match a supported scheme are
-// left unchanged, mirroring the blueprint interpolation logic.
-func interpolateString(s string) string {
-	re := regexp.MustCompile(`\{\{([^}]+)\}\}`)
-	return re.ReplaceAllStringFunc(s, func(match string) string {
-		inner := strings.TrimSpace(match[2 : len(match)-2])
-		if strings.HasPrefix(inner, "env.") {
-			varName := strings.TrimPrefix(inner, "env.")
-			return os.Getenv(varName)
-		}
-		return match
-	})
-}
-
-// provisionIfNeeded checks whether a provisioning key is present and, if so,
-// exchanges it for a newt ID and secret by calling the registration endpoint.
-// On success the config is updated in-place and flagged for saving so that
-// subsequent runs use the permanent credentials directly.
-func (c *Client) provisionIfNeeded() error {
-	if c.config.ProvisioningKey == "" {
-		return nil
-	}
-
-	// If we already have both credentials there is nothing to provision.
-	if c.config.ID != "" && c.config.Secret != "" {
-		logger.Debug("Credentials already present, skipping provisioning")
-		return nil
-	}
-
-	logger.Info("Provisioning key found – exchanging for newt credentials...")
-
-	baseURL, err := url.Parse(c.baseURL)
-	if err != nil {
-		return fmt.Errorf("failed to parse base URL for provisioning: %w", err)
-	}
-	baseEndpoint := strings.TrimRight(baseURL.String(), "/")
-
-	// Interpolate any {{env.VAR}} tokens in the name before sending.
-	name := interpolateString(c.config.Name)
-
-	reqBody := map[string]interface{}{
-		"provisioningKey": c.config.ProvisioningKey,
-	}
-	if name != "" {
-		reqBody["name"] = name
-	}
-	jsonData, err := json.Marshal(reqBody)
-	if err != nil {
-		return fmt.Errorf("failed to marshal provisioning request: %w", err)
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(
-		ctx,
-		"POST",
-		baseEndpoint+"/api/v1/auth/newt/register",
-		bytes.NewBuffer(jsonData),
-	)
-	if err != nil {
-		return fmt.Errorf("failed to create provisioning request: %w", err)
-	}
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("X-CSRF-Token", "x-csrf-protection")
-
-	// Mirror the TLS setup used by getToken so mTLS / self-signed CAs work.
-	var tlsCfg *tls.Config
-	if c.tlsConfig.ClientCertFile != "" || c.tlsConfig.ClientKeyFile != "" ||
-		len(c.tlsConfig.CAFiles) > 0 || c.tlsConfig.PKCS12File != "" {
-		tlsCfg, err = c.setupTLS()
-		if err != nil {
-			return fmt.Errorf("failed to setup TLS for provisioning: %w", err)
-		}
-	}
-	if os.Getenv("SKIP_TLS_VERIFY") == "true" {
-		if tlsCfg == nil {
-			tlsCfg = &tls.Config{}
-		}
-		tlsCfg.InsecureSkipVerify = true
-		logger.Debug("TLS certificate verification disabled for provisioning via SKIP_TLS_VERIFY")
-	}
-
-	httpClient := &http.Client{}
-	if tlsCfg != nil {
-		httpClient.Transport = &http.Transport{TLSClientConfig: tlsCfg}
-	}
-
-	resp, err := httpClient.Do(req)
-	if err != nil {
-		return fmt.Errorf("provisioning request failed: %w", err)
-	}
-	defer resp.Body.Close()
-
-	body, _ := io.ReadAll(resp.Body)
-	logger.Debug("Provisioning response body: %s", string(body))
-
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return fmt.Errorf("provisioning endpoint returned status %d: %s", resp.StatusCode, string(body))
-	}
-
-	var provResp ProvisioningResponse
-	if err := json.Unmarshal(body, &provResp); err != nil {
-		return fmt.Errorf("failed to decode provisioning response: %w", err)
-	}
-
-	if !provResp.Success {
-		return fmt.Errorf("provisioning failed: %s", provResp.Message)
-	}
-
-	if provResp.Data.NewtID == "" || provResp.Data.Secret == "" {
-		return fmt.Errorf("provisioning response is missing newt ID or secret")
-	}
-
-	logger.Info("Successfully provisioned – newt ID: %s", provResp.Data.NewtID)
-
-	// Persist the returned credentials and clear the one-time provisioning key
-	// so subsequent runs authenticate normally.
-	c.config.ID = provResp.Data.NewtID
-	c.config.Secret = provResp.Data.Secret
-	c.config.ProvisioningKey = ""
-	c.config.Name = ""
-	c.configNeedsSave = true
-	c.justProvisioned = true
-
-	// Save immediately so that if the subsequent connection attempt fails the
-	// provisioning key is already gone from disk and the next retry uses the
-	// permanent credentials instead of trying to provision again.
-	if err := c.saveConfig(); err != nil {
-		logger.Error("Failed to save config after provisioning: %v", err)
-	}
-
-	return nil
-}

websocket/config_test.go

@@ -1,35 +0,0 @@
-package websocket
-
-import (
-	"os"
-	"path/filepath"
-	"testing"
-)
-
-func TestLoadConfig_EmptyFileMarksConfigForSave(t *testing.T) {
-	t.Setenv("CONFIG_FILE", "")
-
-	tmpDir := t.TempDir()
-	configPath := filepath.Join(tmpDir, "config.json")
-	if err := os.WriteFile(configPath, []byte(""), 0o644); err != nil {
-		t.Fatalf("failed to create empty config file: %v", err)
-	}
-
-	client := &Client{
-		config: &Config{
-			Endpoint:        "https://example.com",
-			ProvisioningKey: "spk-test",
-		},
-		clientType:     "newt",
-		configFilePath: configPath,
-	}
-
-	if err := client.loadConfig(); err != nil {
-		t.Fatalf("loadConfig returned error for empty file: %v", err)
-	}
-
-	if !client.configNeedsSave {
-		t.Fatal("expected empty config file to mark configNeedsSave")
-	}
-}
-

websocket/types.go

@@ -1,12 +1,10 @@
 package websocket
 
 type Config struct {
-	ID              string `json:"id"`
-	Secret          string `json:"secret"`
-	Endpoint        string `json:"endpoint"`
-	TlsClientCert   string `json:"tlsClientCert"`
-	ProvisioningKey string `json:"provisioningKey,omitempty"`
-	Name            string `json:"name,omitempty"`
+	ID            string `json:"id"`
+	Secret        string `json:"secret"`
+	Endpoint      string `json:"endpoint"`
+	TlsClientCert string `json:"tlsClientCert"`
 }
 
 type TokenResponse struct {
@@ -18,17 +16,7 @@ type TokenResponse struct {
 	Message string `json:"message"`
 }
 
-type ProvisioningResponse struct {
-	Data struct {
-		NewtID string `json:"newtId"`
-		Secret string `json:"secret"`
-	} `json:"data"`
-	Success bool   `json:"success"`
-	Message string `json:"message"`
-}
-
 type WSMessage struct {
-	Type          string      `json:"type"`
-	Data          interface{} `json:"data"`
-	ConfigVersion int64       `json:"configVersion,omitempty"`
-}
+	Type string      `json:"type"`
+	Data interface{} `json:"data"`
+}

wgtester/wgtester.go

@@ -38,6 +38,7 @@ type Server struct {
 	isRunning    bool
 	runningLock  sync.Mutex
 	newtID       string
+	outputPrefix string
 	useNetstack  bool
 	tnet         interface{} // Will be *netstack2.Net when using netstack
 }
@@ -49,6 +50,7 @@ func NewServer(serverAddr string, serverPort uint16, newtID string) *Server {
 		serverPort:   serverPort + 1, // use the next port for the server
 		shutdownCh:   make(chan struct{}),
 		newtID:       newtID,
+		outputPrefix: "[WGTester] ",
 		useNetstack:  false,
 		tnet:         nil,
 	}
@@ -61,6 +63,7 @@ func NewServerWithNetstack(serverAddr string, serverPort uint16, newtID string,
 		serverPort:   serverPort + 1, // use the next port for the server
 		shutdownCh:   make(chan struct{}),
 		newtID:       newtID,
+		outputPrefix: "[WGTester] ",
 		useNetstack:  true,
 		tnet:         tnet,
 	}
@@ -106,7 +109,7 @@ func (s *Server) Start() error {
 	s.isRunning = true
 	go s.handleConnections()
 
-	logger.Debug("WGTester Server started on %s:%d", s.serverAddr, s.serverPort)
+	logger.Info("%sServer started on %s:%d", s.outputPrefix, s.serverAddr, s.serverPort)
 	return nil
 }
 
@@ -124,7 +127,7 @@ func (s *Server) Stop() {
 		s.conn.Close()
 	}
 	s.isRunning = false
-	logger.Info("WGTester Server stopped")
+	logger.Info("%sServer stopped", s.outputPrefix)
 }
 
 // RestartWithNetstack stops the current server and restarts it with netstack
@@ -159,7 +162,7 @@ func (s *Server) handleConnections() {
 			// Set read deadline to avoid blocking forever
 			err := s.conn.SetReadDeadline(time.Now().Add(1 * time.Second))
 			if err != nil {
-				logger.Error("Error setting read deadline: %v", err)
+				logger.Error("%sError setting read deadline: %v", s.outputPrefix, err)
 				continue
 			}
 
@@ -189,7 +192,7 @@ func (s *Server) handleConnections() {
 					if err == io.EOF {
 						return
 					}
-					logger.Error("Error reading from UDP: %v", err)
+					logger.Error("%sError reading from UDP: %v", s.outputPrefix, err)
 				}
 				continue
 			}
@@ -221,7 +224,7 @@ func (s *Server) handleConnections() {
 			copy(responsePacket[5:13], buffer[5:13])
 
 			// Log response being sent for debugging
-			// logger.Debug("Sending response to %s", addr.String())
+			// logger.Debug("%sSending response to %s", s.outputPrefix, addr.String())
 
 			// Send the response packet - handle both regular UDP and netstack UDP
 			if s.useNetstack {
@@ -235,9 +238,9 @@ func (s *Server) handleConnections() {
 			}
 
 			if err != nil {
-				logger.Error("Error sending response: %v", err)
+				logger.Error("%sError sending response: %v", s.outputPrefix, err)
 			} else {
-				// logger.Debug("Response sent successfully")
+				// logger.Debug("%sResponse sent successfully", s.outputPrefix)
 			}
 		}
 	}