Cleanup dependencies

Co-authored-by: jdl <jdl@desktop>
Co-authored-by: jdl <jdl@crumpington.com>
Reviewed-on: #3

README.md

@@ -1,41 +1,4 @@
-# vppn: Virtual Pretty Private Network
-
-## Roadmap
-
-* Use probe and relayed-probe packets vs ping/pong.
-* Rename Mediator -> Relay
-* Use default port 456
-* Remove signing key from hub
-* Peer: UDP hole-punching
-* Peer: local peer discovery - part of RoutingProcessor
-* Peer: update hub w/ latest port on startup
-
-## Learnings
-
-* Encryption / decryption is 20x faster than signing/opening.
-* Allowing out-of order packets is massively important for throughput with TCP
-
-## Principles
-
-* Creates an IPv4/24 network with a maximum of 254 peers. (1-254)
-* Simple setup: via setup link from the hub.
-* Each peer has full network state replicated from the hub.
-
-## Routing
-
-* Routing is different for public vs non-public peers
-  * Public: routes are initialized via incoming ping requests
-  * NonPub: routes are initialized via incoming ping responses
-
-A non-public peer needs to maintain connections with every public peer.
-
-* Sending:
-  * Public: send to address
-  * Non-public: send to a mediator
-
-* Pings:
-  * Servers don't need to ping
-  * Clients need to ping all public and local peers to keep connections open
+# vppn: Virtual Potentially Private Network
 
 ## Hub Server Configuration
 
@@ -58,18 +21,14 @@ scp hub user@<remote>:~/
 Create systemd file in `/etc/systemd/system/hub.service
 
 ```
-Description=hub
-Requires=network.target
-
 [Service]
 AmbientCapabilities=CAP_NET_BIND_SERVICE
 Type=simple
 User=user
 WorkingDirectory=/home/user/
-ExecStart=/home/user/hub -listen <addr>:https -secure=true -root-dir=/home/user
+ExecStart=/home/user/hub -listen <addr>:https -root-dir=/home/user
 Restart=always
 RestartSec=8
-TimeoutStopSec=24
 
 [Install]
 WantedBy=default.target
@@ -98,18 +57,14 @@ Create systemd file in `/etc/systemd/system/vppn.service`.
 
 
 ```
-Description=vppn
-Requires=network.target
-
 [Service]
 AmbientCapabilities=CAP_NET_BIND_SERVICE CAP_NET_ADMIN
 Type=simple
 User=user
 WorkingDirectory=/home/user/
-ExecStart=/home/user/vppn -name vppn
+ExecStart=/home/user/vppn -name vppn -hub-address https://my.hub -api-key 1234567890
 Restart=always
 RestartSec=8
-TimeoutStopSec=24
 
 [Install]
 WantedBy=default.target

aestests/aes_test.go

@@ -1,79 +0,0 @@
-package aestests
-
-import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/rand"
-	"log"
-	"testing"
-)
-
-func must(err error) {
-	if err != nil {
-		panic(err)
-	}
-}
-
-func TestAES(t *testing.T) {
-	key := make([]byte, 32)
-	rand.Read(key)
-
-	block, err := aes.NewCipher(key)
-	must(err)
-
-	aesgcm, err := cipher.NewGCM(block)
-	must(err)
-
-	log.Print(aesgcm.NonceSize())
-	log.Print(aesgcm.Overhead())
-}
-
-func BenchmarkSeal(b *testing.B) {
-	key := make([]byte, 32)
-	rand.Read(key)
-
-	block, err := aes.NewCipher(key)
-	must(err)
-
-	cryptor, err := cipher.NewGCM(block)
-	must(err)
-
-	nonce := make([]byte, 12)
-	rand.Read(nonce)
-
-	data := make([]byte, 1400)
-	rand.Read(data)
-
-	out := make([]byte, 1500)
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		out = cryptor.Seal(out[:0], nonce, data, nil)
-	}
-}
-
-func BenchmarkOpen(b *testing.B) {
-	key := make([]byte, 32)
-	rand.Read(key)
-
-	block, err := aes.NewCipher(key)
-	must(err)
-
-	cryptor, err := cipher.NewGCM(block)
-	must(err)
-
-	nonce := make([]byte, 12)
-	rand.Read(nonce)
-
-	data := make([]byte, 1400)
-	rand.Read(data)
-
-	sealed := make([]byte, 1500)
-	sealed = cryptor.Seal(sealed[:0], nonce, data, nil)
-
-	dec := make([]byte, 1500)
-
-	b.ResetTimer()
-	for i := 0; i < b.N; i++ {
-		dec, err = cryptor.Open(dec[:0], nonce, sealed, nil)
-	}
-}

cmd/vppn/build.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-go build
-sudo setcap cap_net_admin+iep vppn
-sudo setcap cap_net_bind_service+iep vppn

cmd/vppn/main.go

@@ -2,10 +2,10 @@ package main
 
 import (
 	"log"
-	"vppn/node"
+	"vppn/peer"
 )
 
 func main() {
 	log.SetFlags(0)
-	node.Main()
+	peer.Main()
 }

go.mod

@@ -1,17 +1,15 @@
 module vppn
 
-go 1.23.2
+go 1.24.1
 
 require (
 	git.crumpington.com/lib/go v0.8.1
-	git.crumpington.com/lib/webutil v0.0.7
-	github.com/songgao/water v0.0.0-20200317203138-2b4b6d7c09d8
 	golang.org/x/crypto v0.29.0
+	golang.org/x/sys v0.27.0
 )
 
 require (
 	github.com/mattn/go-sqlite3 v1.14.24 // indirect
 	golang.org/x/net v0.31.0 // indirect
-	golang.org/x/sys v0.27.0 // indirect
 	golang.org/x/text v0.20.0 // indirect
 )

go.sum

@@ -1,11 +1,7 @@
 git.crumpington.com/lib/go v0.8.1 h1:rWjddllSxQ4yReraqDaGZAod4NpRD9LtGx1yV71ytcU=
 git.crumpington.com/lib/go v0.8.1/go.mod h1:XjQaf2NFlje9BJ1EevZL8NNioPrAe7WwHpKUhcDw2Lk=
-git.crumpington.com/lib/webutil v0.0.7 h1:1RG9CpuXYalT0NPj8fvxjOLV566LqL37APvAdASFzgA=
-git.crumpington.com/lib/webutil v0.0.7/go.mod h1:efIEiuK1uqFIhI/dlsWUHMsC5bXcEbJEjmdluRoFPPQ=
 github.com/mattn/go-sqlite3 v1.14.24 h1:tpSp2G2KyMnnQu99ngJ47EIkWVmliIizyZBfPrBWDRM=
 github.com/mattn/go-sqlite3 v1.14.24/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
-github.com/songgao/water v0.0.0-20200317203138-2b4b6d7c09d8 h1:TG/diQgUe0pntT/2D9tmUCz4VNwm9MfrtPr0SU2qSX8=
-github.com/songgao/water v0.0.0-20200317203138-2b4b6d7c09d8/go.mod h1:P5HUIBuIWKbyjl083/loAegFkfbFNx5i2qEP4CNbm7E=
 golang.org/x/crypto v0.29.0 h1:L5SG1JTTXupVV3n6sUqMTeWbjAyfPwoda2DLX8J8FrQ=
 golang.org/x/crypto v0.29.0/go.mod h1:+F4F4N5hv6v38hfeYwTdx20oUvLLc+QfrE9Ax9HtgRg=
 golang.org/x/net v0.31.0 h1:68CPQngjLL0r2AlUKiSxtQFKvzRVbnzLwMUn5SzcLHo=

hub/api/api.go

@@ -1,7 +1,6 @@
 package api
 
 import (
-	"crypto/rand"
 	"database/sql"
 	"embed"
 	"errors"
@@ -14,7 +13,6 @@ import (
 	"git.crumpington.com/lib/go/idgen"
 	"git.crumpington.com/lib/go/sqliteutil"
 	"golang.org/x/crypto/bcrypt"
-	"golang.org/x/crypto/nacl/box"
 )
 
 //go:embed migrations
@@ -23,7 +21,6 @@ var migrations embed.FS
 type API struct {
 	db   *sql.DB
 	lock sync.Mutex
-	peerIntents map[string]PeerCreateArgs
 }
 
 func New(dbPath string) (*API, error) {
@@ -38,7 +35,6 @@ func New(dbPath string) (*API, error) {
 
 	a := &API{
 		db: sqlDB,
-		peerIntents: map[string]PeerCreateArgs{},
 	}
 
 	return a, a.ensurePassword()
@@ -141,78 +137,24 @@ func (a *API) Session_SignIn(s *Session, pwd string) error {
 	return db.Session_SetSignedIn(a.db, s.SessionID)
 }
 
-type PeerCreateArgs struct {
-	Name     string
-	PublicIP []byte
-	Port     uint16
-	Relay    bool
+func (a *API) Peer_CreateNew(p *Peer) error {
+	p.Version = idgen.NextID(0)
+	p.PubKey = []byte{}
+	p.PubSignKey = []byte{}
+	p.APIKey = idgen.NewToken()
+
+	return db.Peer_Insert(a.db, p)
 }
 
-// Create the intention to add a peer. The returned code is used to complete
-// the peer creation. The code is valid for 5 minutes.
-func (a *API) Peer_CreateIntent(args PeerCreateArgs) string {
+func (a *API) Peer_Init(peer *Peer, args m.PeerInitArgs) (*m.PeerConfig, error) {
 	a.lock.Lock()
 	defer a.lock.Unlock()
 
-	code := idgen.NewToken()
-	a.peerIntents[code] = args
+	peer.Version = idgen.NextID(0)
+	peer.PubKey = args.EncPubKey
+	peer.PubSignKey = args.PubSignKey
 
-	go func() {
-		time.Sleep(5 * time.Minute)
-		a.lock.Lock()
-		defer a.lock.Unlock()
-		delete(a.peerIntents, code)
-	}()
-
-	return code
-}
-
-func (a *API) Peer_Create(creationCode string) (*m.PeerConfig, error) {
-	a.lock.Lock()
-	defer a.lock.Unlock()
-
-	args, ok := a.peerIntents[creationCode]
-	if !ok {
-		return nil, ErrNotAuthorized
-	}
-
-	delete(a.peerIntents, creationCode)
-
-	encPubKey, encPrivKey, err := box.GenerateKey(rand.Reader)
-	if err != nil {
-		return nil, err
-	}
-
-	// Get peer IP.
-	peerIP := byte(0)
-
-	for i := byte(1); i < 255; i++ {
-		exists, err := db.Peer_Exists(a.db, i)
-		if err != nil {
-			return nil, err
-		}
-		if !exists {
-			peerIP = i
-			break
-		}
-	}
-
-	if peerIP == 0 {
-		return nil, ErrNoIPAvailable
-	}
-
-	peer := &Peer{
-		PeerIP:   peerIP,
-		Version:  idgen.NextID(0),
-		APIKey:   idgen.NewToken(),
-		Name:     args.Name,
-		PublicIP: args.PublicIP,
-		Port:     args.Port,
-		Relay:    args.Relay,
-		PubKey:   encPubKey[:],
-	}
-
-	if err := db.Peer_Insert(a.db, peer); err != nil {
+	if err := db.Peer_UpdateFull(a.db, peer); err != nil {
 		return nil, err
 	}
 
@@ -220,14 +162,10 @@ func (a *API) Peer_Create(creationCode string) (*m.PeerConfig, error) {
 
 	return &m.PeerConfig{
 		PeerIP:   peer.PeerIP,
-		HubAddress: conf.HubAddress,
-		APIKey:     peer.APIKey,
 		Network:  conf.VPNNetwork,
 		PublicIP: peer.PublicIP,
 		Port:     peer.Port,
 		Relay:    peer.Relay,
-		PubKey:     encPubKey[:],
-		PrivKey:    encPrivKey[:],
 	}, nil
 }
 

hub/api/db/generated.go

@@ -315,9 +315,10 @@ type Peer struct {
 	Port       uint16
 	Relay      bool
 	PubKey     []byte
+	PubSignKey []byte
 }
 
-const Peer_SelectQuery = "SELECT PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey FROM peers"
+const Peer_SelectQuery = "SELECT PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey FROM peers"
 
 func Peer_Insert(
 	tx TX,
@@ -328,7 +329,7 @@ func Peer_Insert(
 		return err
 	}
 
-	_, err = tx.Exec("INSERT INTO peers(PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey) VALUES(?,?,?,?,?,?,?,?)", row.PeerIP, row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey)
+	_, err = tx.Exec("INSERT INTO peers(PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey) VALUES(?,?,?,?,?,?,?,?,?)", row.PeerIP, row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PubSignKey)
 	return err
 }
 
@@ -369,7 +370,7 @@ func Peer_UpdateFull(
 		return err
 	}
 
-	result, err := tx.Exec("UPDATE peers SET Version=?,APIKey=?,Name=?,PublicIP=?,Port=?,Relay=?,PubKey=? WHERE PeerIP=?", row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PeerIP)
+	result, err := tx.Exec("UPDATE peers SET Version=?,APIKey=?,Name=?,PublicIP=?,Port=?,Relay=?,PubKey=?,PubSignKey=? WHERE PeerIP=?", row.Version, row.APIKey, row.Name, row.PublicIP, row.Port, row.Relay, row.PubKey, row.PubSignKey, row.PeerIP)
 	if err != nil {
 		return err
 	}
@@ -419,8 +420,8 @@ func Peer_Get(
 	err error,
 ) {
 	row = &Peer{}
-	r := tx.QueryRow("SELECT PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey FROM peers WHERE PeerIP=?", PeerIP)
-	err = r.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey)
+	r := tx.QueryRow("SELECT PeerIP,Version,APIKey,Name,PublicIP,Port,Relay,PubKey,PubSignKey FROM peers WHERE PeerIP=?", PeerIP)
+	err = r.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
 	return
 }
 
@@ -434,7 +435,7 @@ func Peer_GetWhere(
 ) {
 	row = &Peer{}
 	r := tx.QueryRow(query, args...)
-	err = r.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey)
+	err = r.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
 	return
 }
 
@@ -454,7 +455,7 @@ func Peer_Iterate(
 		defer rows.Close()
 		for rows.Next() {
 			row := &Peer{}
-			err := rows.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey)
+			err := rows.Scan(&row.PeerIP, &row.Version, &row.APIKey, &row.Name, &row.PublicIP, &row.Port, &row.Relay, &row.PubKey, &row.PubSignKey)
 			if !yield(row, err) {
 				return
 			}

hub/api/db/tables.defs

@@ -21,5 +21,6 @@ TABLE peers OF Peer (
   PublicIP   []byte,
   Port       uint16,
   Relay      bool,
-  PubKey     []byte NoUpdate
+  PubKey     []byte NoUpdate,
+  PubSignKey []byte NoUpdate
 );

hub/api/migrations/2024-12-27-signing-keys.sql

@@ -0,0 +1 @@
+ALTER TABLE peers ADD COLUMN PubSignKey BLOB NOT NULL DEFAULT '';

hub/api/session.go

@@ -1 +0,0 @@
-package api

hub/app.go

@@ -7,7 +7,7 @@ import (
 	"path/filepath"
 	"vppn/hub/api"
 
-	"git.crumpington.com/lib/webutil"
+	"git.crumpington.com/lib/go/webutil"
 )
 
 //go:embed static
@@ -19,14 +19,14 @@ var templateFS embed.FS
 type Config struct {
 	RootDir    string
 	ListenAddr string
-	Secure     bool
+	Insecure   bool
 }
 
 type App struct {
 	api      *api.API
 	mux      *http.ServeMux
 	tmpl     map[string]*template.Template
-	secure bool
+	insecure bool
 }
 
 func NewApp(conf Config) (*App, error) {
@@ -39,7 +39,7 @@ func NewApp(conf Config) (*App, error) {
 		api:      api,
 		mux:      http.NewServeMux(),
 		tmpl:     webutil.ParseTemplateSet(templateFuncs, templateFS),
-		secure: conf.Secure,
+		insecure: conf.Insecure,
 	}
 
 	app.registerRoutes()

hub/cookie.go

@@ -17,8 +17,9 @@ func (a *App) setCookie(w http.ResponseWriter, name, value string) {
 		Name:     name,
 		Value:    value,
 		Path:     "/",
-		Secure:   a.secure,
+		Secure:   !a.insecure,
 		SameSite: http.SameSiteStrictMode,
+		HttpOnly: true,
 		MaxAge:   86400 * 365 * 10,
 	})
 }

hub/handler.go

@@ -5,7 +5,7 @@ import (
 	"net/http"
 	"vppn/hub/api"
 
-	"git.crumpington.com/lib/webutil"
+	"git.crumpington.com/lib/go/webutil"
 )
 
 type handlerFunc func(s *api.Session, w http.ResponseWriter, r *http.Request) error
@@ -65,13 +65,26 @@ func (app *App) handleSignedIn(pattern string, fn handlerFunc) {
 	})
 }
 
-type peerHandlerFunc func(w http.ResponseWriter, r *http.Request) error
+type peerHandlerFunc func(p *api.Peer, w http.ResponseWriter, r *http.Request) error
 
 func (app *App) handlePeer(pattern string, fn peerHandlerFunc) {
 	wrapped := func(w http.ResponseWriter, r *http.Request) {
+		_, apiKey, ok := r.BasicAuth()
+		if !ok {
+			http.Error(w, "Not authorized", http.StatusUnauthorized)
+			return
+		}
+
+		peer, err := app.api.Peer_GetByAPIKey(apiKey)
+		if err != nil {
+			http.Error(w, "Not authorized", http.StatusUnauthorized)
+			return
+		}
+
 		r.ParseForm()
-		if err := fn(w, r); err != nil {
+		if err := fn(peer, w, r); err != nil {
 			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
 		}
 	}
 

hub/handlers.go

@@ -1,6 +1,7 @@
 package hub
 
 import (
+	"encoding/json"
 	"errors"
 	"log"
 	"net/http"
@@ -54,11 +55,18 @@ func (a *App) _adminSignOutSubmit(s *api.Session, w http.ResponseWriter, r *http
 }
 
 func (a *App) _adminConfig(s *api.Session, w http.ResponseWriter, r *http.Request) error {
+	peers, err := a.api.Peer_List()
+	if err != nil {
+		return err
+	}
+
 	return a.render("/admin-config.html", w, struct {
 		Session *api.Session
+		Peers   []*api.Peer
 		Config  *api.Config
 	}{
 		s,
+		peers,
 		a.api.Config_Get(),
 	})
 }
@@ -142,21 +150,6 @@ func (a *App) _adminPasswordSubmit(s *api.Session, w http.ResponseWriter, r *htt
 	return a.redirect(w, r, "/admin/config/")
 }
 
-func (a *App) _adminPeerList(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	peers, err := a.api.Peer_List()
-	if err != nil {
-		return err
-	}
-
-	return a.render("/admin-peer-list.html", w, struct {
-		Session *api.Session
-		Peers   []*api.Peer
-	}{
-		s,
-		peers,
-	})
-}
-
 func (a *App) _adminHosts(s *api.Session, w http.ResponseWriter, r *http.Request) error {
 	conf := a.api.Config_Get()
 
@@ -187,36 +180,26 @@ func (a *App) _adminPeerCreate(s *api.Session, w http.ResponseWriter, r *http.Re
 func (a *App) _adminPeerCreateSubmit(s *api.Session, w http.ResponseWriter, r *http.Request) error {
 	var ipStr string
 
-	args := api.PeerCreateArgs{}
+	p := &api.Peer{}
 	err := webutil.NewFormScanner(r.Form).
-		Scan("Name", &args.Name).
+		Scan("IP", &p.PeerIP).
+		Scan("Name", &p.Name).
 		Scan("PublicIP", &ipStr).
-		Scan("Port", &args.Port).
-		Scan("Relay", &args.Relay).
+		Scan("Port", &p.Port).
+		Scan("Relay", &p.Relay).
 		Error()
 	if err != nil {
 		return err
 	}
 
-	if args.PublicIP, err = stringToIP(ipStr); err != nil {
+	if p.PublicIP, err = stringToIP(ipStr); err != nil {
 		return err
 	}
 
-	code := a.api.Peer_CreateIntent(args)
-	return a.redirect(w, r, "/admin/peer/intent-created/?Code=%s", code)
-}
-
-func (a *App) _adminPeerIntentCreated(s *api.Session, w http.ResponseWriter, r *http.Request) error {
-	code := r.FormValue("Code")
-	if code == "" {
-		return errors.New("missing Code")
+	if err := a.api.Peer_CreateNew(p); err != nil {
+		return err
 	}
-
-	return a.render("/admin-peer-intent.html", w, struct {
-		Session    *api.Session
-		HubAddress string
-		Code       string
-	}{s, a.api.Config_Get().HubAddress, code})
+	return a.redirect(w, r, "/admin/peer/view/?PeerIP=%d", p.PeerIP)
 }
 
 func (a *App) _adminPeerView(s *api.Session, w http.ResponseWriter, r *http.Request) error {
@@ -323,9 +306,13 @@ func (a *App) _adminPeerDeleteSubmit(s *api.Session, w http.ResponseWriter, r *h
 	return a.redirect(w, r, "/admin/peer/list/")
 }
 
-func (a *App) _peerCreate(w http.ResponseWriter, r *http.Request) error {
-	code := r.FormValue("Code")
-	conf, err := a.api.Peer_Create(code)
+func (a *App) _peerInit(peer *api.Peer, w http.ResponseWriter, r *http.Request) error {
+	args := m.PeerInitArgs{}
+	if err := json.NewDecoder(r.Body).Decode(&args); err != nil {
+		return err
+	}
+
+	conf, err := a.api.Peer_Init(peer, args)
 	if err != nil {
 		return err
 	}
@@ -333,33 +320,16 @@ func (a *App) _peerCreate(w http.ResponseWriter, r *http.Request) error {
 	return a.sendJSON(w, conf)
 }
 
-func (a *App) _peerFetchState(w http.ResponseWriter, r *http.Request) error {
-	_, apiKey, ok := r.BasicAuth()
-	if !ok {
-		return api.ErrNotAuthorized
-	}
-
-	peer, err := a.api.Peer_GetByAPIKey(apiKey)
-	if err != nil {
-		return err
-	}
-
+func (a *App) _peerFetchState(peer *api.Peer, w http.ResponseWriter, r *http.Request) error {
 	peers, err := a.api.Peer_List()
 	if err != nil {
 		return err
 	}
 
-	conf := a.api.Config_Get()
-
-	state := m.NetworkState{
-		HubAddress: conf.HubAddress,
-		Network:    conf.VPNNetwork,
-		PeerIP:     peer.PeerIP,
-		PublicIP:   peer.PublicIP,
-		Port:       peer.Port,
-	}
+	state := m.NetworkState{}
 
 	for _, p := range peers {
+		if len(p.PubKey) != 0 {
 			state.Peers[p.PeerIP] = &m.Peer{
 				PeerIP:     p.PeerIP,
 				Version:    p.Version,
@@ -368,6 +338,8 @@ func (a *App) _peerFetchState(w http.ResponseWriter, r *http.Request) error {
 				Port:       p.Port,
 				Relay:      p.Relay,
 				PubKey:     p.PubKey,
+				PubSignKey: p.PubSignKey,
+			}
 		}
 	}
 

hub/main.go

@@ -6,7 +6,7 @@ import (
 	"net/http"
 	"os"
 
-	"git.crumpington.com/lib/webutil"
+	"git.crumpington.com/lib/go/webutil"
 )
 
 func Main() {
@@ -15,7 +15,7 @@ func Main() {
 	conf := Config{}
 	flag.StringVar(&conf.RootDir, "root-dir", "", "[REQUIRED] Root directory.")
 	flag.StringVar(&conf.ListenAddr, "listen", "", "[REQUIRED] Listen address.")
-	flag.BoolVar(&conf.Secure, "secure", false, "Use secure cookies.")
+	flag.BoolVar(&conf.Insecure, "insecure", false, "Don't use secure cookies.")
 
 	flag.Parse()
 

hub/routes.go

@@ -16,17 +16,15 @@ func (a *App) registerRoutes() {
 	a.handleSignedIn("POST /admin/sign-out/", a._adminSignOutSubmit)
 	a.handleSignedIn("GET  /admin/password/edit/", a._adminPasswordEdit)
 	a.handleSignedIn("POST /admin/password/edit/", a._adminPasswordSubmit)
-	a.handleSignedIn("GET  /admin/peer/list/", a._adminPeerList)
 	a.handleSignedIn("GET  /admin/peer/hosts/", a._adminHosts)
 	a.handleSignedIn("GET  /admin/peer/create/", a._adminPeerCreate)
 	a.handleSignedIn("POST /admin/peer/create/", a._adminPeerCreateSubmit)
-	a.handleSignedIn("GET  /admin/peer/intent-created/", a._adminPeerIntentCreated)
 	a.handleSignedIn("GET  /admin/peer/view/", a._adminPeerView)
 	a.handleSignedIn("GET  /admin/peer/edit/", a._adminPeerEdit)
 	a.handleSignedIn("POST /admin/peer/edit/", a._adminPeerEditSubmit)
 	a.handleSignedIn("GET  /admin/peer/delete/", a._adminPeerDelete)
 	a.handleSignedIn("POST /admin/peer/delete/", a._adminPeerDeleteSubmit)
 
-	a.handlePeer("GET /peer/create/", a._peerCreate)
+	a.handlePeer("POST /peer/init/", a._peerInit)
 	a.handlePeer("GET /peer/fetch-state/", a._peerFetchState)
 }

hub/static/custom.css

@@ -1,7 +1,3 @@
-body {
-    max-width: 1920px;
-}
-
 .def-list tr td:first-child {
     text-align:right;
     width:1%;

hub/templates/admin-config.html

@@ -16,4 +16,42 @@
     <td>{{ipToString .Config.VPNNetwork}}</td>
   </tr>
 </table>
+
+<h2>Peers</h2>
+
+<p>
+  <a href="/admin/peer/create/">Add Peer</a> /
+  <a href="/admin/peer/hosts/">Hosts</a>
+</p>
+
+{{if .Peers -}}
+<table>
+  <thead>
+    <tr>
+      <th>PeerIP</th>
+      <th>Name</th>
+      <th>Public IP</th>
+      <th>Port</th>
+      <th>Relay</th>
+    </tr>
+  </thead>
+  <tbody>
+  {{range .Peers -}}
+  <tr>
+    <td>
+      <a href="/admin/peer/view/?PeerIP={{.PeerIP}}">
+        {{.PeerIP}}
+      </a>
+    </td>
+    <td>{{.Name}}</td>
+    <td>{{ipToString .PublicIP}}</td>
+    <td>{{.Port}}</td>
+    <td>{{if .Relay}}T{{else}}F{{end}}</td>
+  </tr>
+  </tbody>
+  {{- end}}
+</table>
+{{- else}}
+<p>No peers.</p>
+{{- end}}
 {{- end}}

hub/templates/admin-peer-create.html

@@ -3,6 +3,10 @@
 
 <form method="POST">
   <input type="hidden" name="CSRF" value="{{.Session.CSRF}}">
+  <p>
+    <label>IP</label><br>
+    <input type="number" name="IP" min="1" max="255" value="0">
+  </p>
   <p>
     <label>Name</label><br>
     <input type="text" name="Name">

hub/templates/admin-peer-init.html

@@ -0,0 +1,13 @@
+{{define "body" -}}
+<h2>Initialize Peer</h2>
+
+<p>
+  Configure the peer with the following URL:
+</p>
+<pre>
+  {{.HubAddress}}/peer/init/?Code={{.Code}}
+</pre>
+<p>
+  <a href="/admin/config/">Done</a>
+</p>
+{{- end}}

hub/templates/admin-peer-intent.html

@@ -8,6 +8,6 @@
   {{.HubAddress}}/peer/create/?Code={{.Code}}
 </pre>
 <p>
-  <a href="/admin/peer/list/">Done</a>
+  <a href="/admin/config/">Done</a>
 </p>
 {{- end}}

hub/templates/admin-peer-list.html

@@ -1,40 +0,0 @@
-{{define "body" -}}
-<h2>Peers</h2>
-
-<p>
-  <a href="/admin/peer/create/">Add Peer</a> /
-  <a href="/admin/peer/hosts/">Hosts</a>
-</p>
-
-{{if .Peers -}}
-<table>
-  <thead>
-    <tr>
-      <th>PeerIP</th>
-      <th>Name</th>
-      <th>Public IP</th>
-      <th>Port</th>
-      <th>Relay</th>
-    </tr>
-  </thead>
-  <tbody>
-  {{range .Peers -}}
-  <tr>
-    <td>
-      <a href="/admin/peer/view/?PeerIP={{.PeerIP}}">
-        {{.PeerIP}}
-      </a>
-    </td>
-    <td>{{.Name}}</td>
-    <td>{{ipToString .PublicIP}}</td>
-    <td>{{.Port}}</td>
-    <td>{{if .Relay}}T{{else}}F{{end}}</td>
-  </tr>
-  </tbody>
-  {{- end}}
-</table>
-{{- else}}
-<p>No peers.</p>
-{{- end}}
-
-{{- end}}

hub/templates/base.html

@@ -10,8 +10,7 @@
     <h1>VPPN</h1>
     <nav>
       {{if .Session.SignedIn -}}
-      <a href="/admin/config/">Config</a> /
-      <a href="/admin/peer/list/">Peers</a> /
+      <a href="/admin/config/">Home</a> /
       <a href="/admin/sign-out/">Sign out</a>
       {{- end}}
     </nav>

hub/time.go

@@ -1 +0,0 @@
-package hub

m/models.go

@@ -1,16 +1,17 @@
 // The package `m` contains models shared between the hub and peer programs.
 package m
 
+type PeerInitArgs struct {
+	EncPubKey  []byte
+	PubSignKey []byte
+}
+
 type PeerConfig struct {
 	PeerIP   byte
-	HubAddress string
 	Network  []byte
-	APIKey     string
 	PublicIP []byte
 	Port     uint16
 	Relay    bool
-	PubKey     []byte
-	PrivKey    []byte
 }
 
 type Peer struct {
@@ -21,17 +22,9 @@ type Peer struct {
 	Port       uint16
 	Relay      bool
 	PubKey     []byte
+	PubSignKey []byte
 }
 
 type NetworkState struct {
-	HubAddress string
-
-	// The requester's data:
-	Network  []byte
-	PeerIP   byte
-	PublicIP []byte
-	Port     uint16
-
-	// All peer data.
 	Peers [256]*Peer
 }

node/addrdiscovery.go

@@ -1,71 +0,0 @@
-package node
-
-import (
-	"log"
-	"net/netip"
-	"time"
-)
-
-func addrDiscoveryServer() {
-	var (
-		buf1 = make([]byte, bufferSize)
-		buf2 = make([]byte, bufferSize)
-	)
-
-	for {
-		pkt := <-discoveryPackets
-
-		p, ok := pkt.Payload.(addrDiscoveryPacket)
-		if !ok {
-			continue
-		}
-
-		route := routingTable[pkt.SrcIP].Load()
-		if route == nil || !route.RemoteAddr.IsValid() {
-			continue
-		}
-
-		_sendControlPacket(addrDiscoveryPacket{
-			TraceID: p.TraceID,
-			ToAddr:  pkt.SrcAddr,
-		}, *route, buf1, buf2)
-	}
-}
-
-func addrDiscoveryClient() {
-	var (
-		checkInterval = 8 * time.Second
-		timer         = time.NewTimer(4 * time.Second)
-
-		buf1 = make([]byte, bufferSize)
-		buf2 = make([]byte, bufferSize)
-
-		addrPacket addrDiscoveryPacket
-		lAddr      netip.AddrPort
-	)
-
-	for {
-		select {
-		case pkt := <-discoveryPackets:
-			p, ok := pkt.Payload.(addrDiscoveryPacket)
-			if !ok || p.TraceID != addrPacket.TraceID || !p.ToAddr.IsValid() || p.ToAddr == lAddr {
-				continue
-			}
-
-			log.Printf("Discovered local address: %v", p.ToAddr)
-			lAddr = p.ToAddr
-			localAddr.Store(&p.ToAddr)
-
-		case <-timer.C:
-			timer.Reset(checkInterval)
-
-			route := getRelayRoute()
-			if route == nil {
-				continue
-			}
-
-			addrPacket.TraceID = newTraceID()
-			_sendControlPacket(addrPacket, *route, buf1, buf2)
-		}
-	}
-}

node/cmd/client/build.sh

@@ -1,5 +0,0 @@
-#!/bin/bash
-
-go build
-sudo setcap cap_net_admin+iep ./client
-./client 144.76.78.93

node/cmd/client/main.go

@@ -1,15 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-	"vppn/node"
-)
-
-func main() {
-	if len(os.Args) != 2 {
-		log.Fatalf("Usage: %s <addr:port>", os.Args[0])
-	}
-	n := node.NewTmpNodeClient(os.Args[1])
-	n.RunClient()
-}

node/cmd/server/build.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-go build
-ssh kevin "killall server"
-scp server kevin:/home/jdl/tmp/
-ssh root@kevin "sudo setcap cap_net_admin+iep /home/jdl/tmp/server"
-ssh kevin "/home/jdl/tmp/server"

node/cmd/server/main.go

@@ -1,8 +0,0 @@
-package main
-
-import "vppn/node"
-
-func main() {
-	n := node.NewTmpNodeServer()
-	n.RunServer()
-}

node/conn.go

@@ -1,49 +0,0 @@
-package node
-
-import (
-	"io"
-	"log"
-	"net"
-	"net/netip"
-	"runtime/debug"
-	"sync"
-)
-
-// ----------------------------------------------------------------------------
-
-type connWriter struct {
-	lock sync.Mutex
-	conn *net.UDPConn
-}
-
-func newConnWriter(conn *net.UDPConn) *connWriter {
-	return &connWriter{conn: conn}
-}
-
-func (w *connWriter) WriteTo(packet []byte, addr netip.AddrPort) {
-	w.lock.Lock()
-	if _, err := w.conn.WriteToUDPAddrPort(packet, addr); err != nil {
-		debug.PrintStack()
-		log.Fatalf("Failed to write to UDP port: %v", err)
-	}
-	w.lock.Unlock()
-}
-
-// ----------------------------------------------------------------------------
-
-type ifWriter struct {
-	lock  sync.Mutex
-	iface io.ReadWriteCloser
-}
-
-func newIFWriter(iface io.ReadWriteCloser) *ifWriter {
-	return &ifWriter{iface: iface}
-}
-
-func (w *ifWriter) Write(packet []byte) {
-	w.lock.Lock()
-	if _, err := w.iface.Write(packet); err != nil {
-		log.Fatalf("Failed to write to interface: %v", err)
-	}
-	w.lock.Unlock()
-}

node/globalfuncs.go

@@ -1,73 +0,0 @@
-package node
-
-import (
-	"net/netip"
-	"sync/atomic"
-)
-
-func getRelayRoute() *peerRoute {
-	if ip := relayIP.Load(); ip != nil {
-		return routingTable[*ip].Load()
-	}
-	return nil
-}
-
-func getLocalAddr() netip.AddrPort {
-	if a := localAddr.Load(); a != nil {
-		return *a
-	}
-	return netip.AddrPort{}
-}
-
-func _sendControlPacket(pkt interface{ Marshal([]byte) []byte }, route peerRoute, buf1, buf2 []byte) {
-	buf := pkt.Marshal(buf2)
-	h := header{
-		StreamID: controlStreamID,
-		Counter:  atomic.AddUint64(&sendCounters[route.IP], 1),
-		SourceIP: localIP,
-		DestIP:   route.IP,
-	}
-	buf = route.ControlCipher.Encrypt(h, buf, buf1)
-
-	if route.Direct {
-		_conn.WriteTo(buf, route.RemoteAddr)
-		return
-	}
-
-	_relayPacket(route.IP, buf, buf2)
-}
-
-func _sendDataPacket(route *peerRoute, pkt, buf1, buf2 []byte) {
-	h := header{
-		StreamID: dataStreamID,
-		Counter:  atomic.AddUint64(&sendCounters[route.IP], 1),
-		SourceIP: localIP,
-		DestIP:   route.IP,
-	}
-
-	enc := route.DataCipher.Encrypt(h, pkt, buf1)
-
-	if route.Direct {
-		_conn.WriteTo(enc, route.RemoteAddr)
-		return
-	}
-
-	_relayPacket(route.IP, enc, buf2)
-}
-
-func _relayPacket(destIP byte, data, buf []byte) {
-	relayRoute := getRelayRoute()
-	if relayRoute == nil || !relayRoute.Up || !relayRoute.Relay {
-		return
-	}
-
-	h := header{
-		StreamID: dataStreamID,
-		Counter:  atomic.AddUint64(&sendCounters[relayRoute.IP], 1),
-		SourceIP: localIP,
-		DestIP:   destIP,
-	}
-
-	enc := relayRoute.DataCipher.Encrypt(h, data, buf)
-	_conn.WriteTo(enc, relayRoute.RemoteAddr)
-}

node/globals.go

@@ -1,86 +0,0 @@
-package node
-
-import (
-	"net/netip"
-	"sync/atomic"
-	"time"
-	"vppn/m"
-)
-
-const (
-	bufferSize            = 1536
-	if_mtu                = 1200
-	if_queue_len          = 2048
-	controlCipherOverhead = 16
-	dataCipherOverhead    = 16
-)
-
-type peerRoute struct {
-	IP            byte
-	Up            bool // True if data can be sent on the route.
-	Relay         bool // True if the peer is a relay.
-	Direct        bool // True if this is a direct connection.
-	ControlCipher *controlCipher
-	DataCipher    *dataCipher
-	RemoteAddr    netip.AddrPort // Remote address if directly connected.
-}
-
-var (
-	// Configuration for this peer.
-	netName    string
-	localIP    byte
-	localPub   bool
-	privateKey []byte
-
-	// Shared interface for writing.
-	_iface *ifWriter
-
-	// Shared connection for writing.
-	_conn *connWriter
-
-	// Counters for sending to each peer.
-	sendCounters [256]uint64 = func() (out [256]uint64) {
-		for i := range out {
-			out[i] = uint64(time.Now().Unix()<<30 + 1)
-		}
-		return
-	}()
-
-	// Duplicate checkers for incoming packets.
-	dupChecks [256]*dupCheck = func() (out [256]*dupCheck) {
-		for i := range out {
-			out[i] = newDupCheck(0)
-		}
-		return
-	}()
-
-	// Channels for incoming control packets.
-	controlPackets [256]chan controlPacket = func() (out [256]chan controlPacket) {
-		for i := range out {
-			out[i] = make(chan controlPacket, 256)
-		}
-		return
-	}()
-
-	// Channels for incoming peer updates from the hub.
-	peerUpdates [256]chan *m.Peer = func() (out [256]chan *m.Peer) {
-		for i := range out {
-			out[i] = make(chan *m.Peer)
-		}
-		return
-	}()
-
-	// Global routing table.
-	routingTable [256]*atomic.Pointer[peerRoute] = func() (out [256]*atomic.Pointer[peerRoute]) {
-		for i := range out {
-			out[i] = &atomic.Pointer[peerRoute]{}
-			out[i].Store(&peerRoute{})
-		}
-		return
-	}()
-
-	// Managed by the relayManager.
-	discoveryPackets chan controlPacket
-	localAddr        *atomic.Pointer[netip.AddrPort] // May be nil.
-	relayIP          *atomic.Pointer[byte]           // May be nil.
-)

node/header.go

@@ -1,35 +0,0 @@
-package node
-
-import "unsafe"
-
-// ----------------------------------------------------------------------------
-
-const (
-	headerSize        = 12
-	controlStreamID   = 2
-	controlHeaderSize = 24
-	dataStreamID      = 1
-	dataHeaderSize    = 12
-)
-
-type header struct {
-	StreamID byte
-	Counter  uint64 // Init with time.Now().Unix << 30 to ensure monotonic.
-	SourceIP byte
-	DestIP   byte
-}
-
-func (h *header) Parse(b []byte) {
-	h.StreamID = b[0]
-	h.Counter = *(*uint64)(unsafe.Pointer(&b[1]))
-	h.SourceIP = b[9]
-	h.DestIP = b[10]
-}
-
-func (h *header) Marshal(buf []byte) {
-	buf[0] = h.StreamID
-	*(*uint64)(unsafe.Pointer(&buf[1])) = h.Counter
-	buf[9] = h.SourceIP
-	buf[10] = h.DestIP
-	buf[11] = 0
-}

node/hubpoller.go

@@ -1,94 +0,0 @@
-package node
-
-import (
-	"encoding/json"
-	"io"
-	"log"
-	"net/http"
-	"net/url"
-	"time"
-	"vppn/m"
-)
-
-type hubPoller struct {
-	client   *http.Client
-	req      *http.Request
-	versions [256]int64
-}
-
-func newHubPoller(conf m.PeerConfig) *hubPoller {
-	u, err := url.Parse(conf.HubAddress)
-	if err != nil {
-		log.Fatalf("Failed to parse hub address %s: %v", conf.HubAddress, err)
-	}
-	u.Path = "/peer/fetch-state/"
-
-	client := &http.Client{Timeout: 8 * time.Second}
-
-	req := &http.Request{
-		Method: http.MethodGet,
-		URL:    u,
-		Header: http.Header{},
-	}
-	req.SetBasicAuth("", conf.APIKey)
-
-	return &hubPoller{
-		client: client,
-		req:    req,
-	}
-}
-
-func (hp *hubPoller) Run() {
-	defer panicHandler()
-
-	state, err := loadNetworkState(netName)
-	if err != nil {
-		log.Printf("Failed to load network state: %v", err)
-		log.Printf("Polling hub...")
-		hp.pollHub()
-	} else {
-		hp.applyNetworkState(state)
-	}
-
-	for range time.Tick(64 * time.Second) {
-		hp.pollHub()
-	}
-}
-
-func (hp *hubPoller) pollHub() {
-	var state m.NetworkState
-
-	resp, err := hp.client.Do(hp.req)
-	if err != nil {
-		log.Printf("Failed to fetch peer state: %v", err)
-		return
-	}
-	body, err := io.ReadAll(resp.Body)
-	_ = resp.Body.Close()
-	if err != nil {
-		log.Printf("Failed to read body from hub: %v", err)
-		return
-	}
-
-	if err := json.Unmarshal(body, &state); err != nil {
-		log.Printf("Failed to unmarshal response from hub: %v", err)
-		return
-	}
-
-	hp.applyNetworkState(state)
-
-	if err := storeNetworkState(netName, state); err != nil {
-		log.Printf("Failed to store network state: %v", err)
-	}
-}
-
-func (hp *hubPoller) applyNetworkState(state m.NetworkState) {
-	for i, peer := range state.Peers {
-		if i != int(localIP) {
-			if peer != nil && peer.Version != hp.versions[i] {
-				peerUpdates[i] <- state.Peers[i]
-				hp.versions[i] = peer.Version
-			}
-		}
-	}
-}

node/interface.go

@@ -1,177 +0,0 @@
-package node
-
-import (
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"os"
-	"syscall"
-
-	"golang.org/x/sys/unix"
-)
-
-// Get next packet, returning packet, ip, and possible error.
-func readNextPacket(iface io.ReadWriteCloser, buf []byte) ([]byte, byte, error) {
-	var (
-		version byte
-		ip      byte
-	)
-	for {
-		n, err := iface.Read(buf[:cap(buf)])
-		if err != nil {
-			return nil, ip, err
-		}
-
-		buf = buf[:n]
-		version = buf[0] >> 4
-
-		switch version {
-		case 4:
-			if n < 20 {
-				log.Printf("Short IPv4 packet: %d", len(buf))
-				continue
-			}
-			ip = buf[19]
-
-		case 6:
-			if len(buf) < 40 {
-				log.Printf("Short IPv6 packet: %d", len(buf))
-				continue
-			}
-			ip = buf[39]
-
-		default:
-			log.Printf("Invalid IP packet version: %v", version)
-			continue
-		}
-
-		return buf, ip, nil
-	}
-}
-
-func openInterface(network []byte, localIP byte, name string) (io.ReadWriteCloser, error) {
-	if len(network) != 4 {
-		return nil, fmt.Errorf("expected network to be 4 bytes, got %d", len(network))
-	}
-	ip := net.IPv4(network[0], network[1], network[2], localIP)
-
-	//////////////////////////
-	// Create TUN Interface //
-	//////////////////////////
-
-	tunFD, err := syscall.Open("/dev/net/tun", syscall.O_RDWR|unix.O_CLOEXEC, 0600)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open TUN device: %w", err)
-	}
-
-	// New interface request.
-	req, err := unix.NewIfreq(name)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create new TUN interface request: %w", err)
-	}
-
-	// Flags:
-	//
-	// IFF_NO_PI => don't add packet info data to packets sent to the interface.
-	// IFF_TUN   => create a TUN device handling IP packets.
-	req.SetUint16(unix.IFF_NO_PI | unix.IFF_TUN)
-
-	err = unix.IoctlIfreq(tunFD, unix.TUNSETIFF, req)
-	if err != nil {
-		return nil, fmt.Errorf("failed to set TUN device settings: %w", err)
-	}
-
-	// Name may not be exactly the same?
-	name = req.Name()
-
-	/////////////
-	// Set MTU //
-	/////////////
-
-	// We need a socket file descriptor to set other options for some reason.
-	sockFD, err := unix.Socket(unix.AF_INET, unix.SOCK_DGRAM, unix.IPPROTO_IP)
-	if err != nil {
-		return nil, fmt.Errorf("failed to open socket: %w", err)
-	}
-	defer unix.Close(sockFD)
-
-	req, err = unix.NewIfreq(name)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create MTU interface request: %w", err)
-	}
-
-	req.SetUint32(if_mtu)
-	if err = unix.IoctlIfreq(sockFD, unix.SIOCSIFMTU, req); err != nil {
-		return nil, fmt.Errorf("failed to set interface MTU: %w", err)
-	}
-
-	//////////////////////
-	// Set Queue Length //
-	//////////////////////
-
-	req, err = unix.NewIfreq(name)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create IP interface request: %w", err)
-	}
-
-	req.SetUint16(if_queue_len)
-	if err = unix.IoctlIfreq(sockFD, unix.SIOCSIFTXQLEN, req); err != nil {
-		return nil, fmt.Errorf("failed to set interface queue length: %w", err)
-	}
-
-	/////////////////////
-	// Set IP and Mask //
-	/////////////////////
-
-	req, err = unix.NewIfreq(name)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create IP interface request: %w", err)
-	}
-
-	if err := req.SetInet4Addr(ip.To4()); err != nil {
-		return nil, fmt.Errorf("failed to set interface request IP: %w", err)
-	}
-
-	if err = unix.IoctlIfreq(sockFD, unix.SIOCSIFADDR, req); err != nil {
-		return nil, fmt.Errorf("failed to set interface IP: %w", err)
-	}
-
-	// SET MASK - must happen after setting address.
-	req, err = unix.NewIfreq(name)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create mask interface request: %w", err)
-	}
-
-	if err := req.SetInet4Addr(net.IPv4(255, 255, 255, 0).To4()); err != nil {
-		return nil, fmt.Errorf("failed to set interface request mask: %w", err)
-	}
-
-	if err := unix.IoctlIfreq(sockFD, unix.SIOCSIFNETMASK, req); err != nil {
-		return nil, fmt.Errorf("failed to set interface mask: %w", err)
-	}
-
-	////////////////////////
-	// Bring Interface Up //
-	////////////////////////
-
-	req, err = unix.NewIfreq(name)
-	if err != nil {
-		return nil, fmt.Errorf("failed to create up interface request: %w", err)
-	}
-
-	// Get current flags.
-	if err = unix.IoctlIfreq(sockFD, unix.SIOCGIFFLAGS, req); err != nil {
-		return nil, fmt.Errorf("failed to get interface flags: %w", err)
-	}
-
-	flags := req.Uint16() | unix.IFF_UP | unix.IFF_RUNNING
-
-	// Set UP flag / broadcast flags.
-	req.SetUint16(flags)
-	if err = unix.IoctlIfreq(sockFD, unix.SIOCSIFFLAGS, req); err != nil {
-		return nil, fmt.Errorf("failed to set interface up: %w", err)
-	}
-
-	return os.NewFile(uintptr(tunFD), "tun"), nil
-}

node/main.go

@@ -1,309 +0,0 @@
-package node
-
-import (
-	"encoding/json"
-	"flag"
-	"fmt"
-	"io"
-	"log"
-	"net"
-	"net/http"
-	"net/netip"
-	"os"
-	"runtime/debug"
-	"sync/atomic"
-	"vppn/m"
-)
-
-func panicHandler() {
-	if r := recover(); r != nil {
-		log.Fatalf("\n %v\n\nstacktrace from panic: %s\n", r, string(debug.Stack()))
-	}
-}
-
-func Main() {
-	defer panicHandler()
-
-	var (
-		initURL  string
-		listenIP string
-		port     int
-	)
-
-	flag.StringVar(&netName, "name", "", "[REQUIRED] The network name.")
-	flag.StringVar(&initURL, "init-url", "", "Initializes peer from the hub URL.")
-	flag.StringVar(&listenIP, "listen-ip", "", "IP address to listen on.")
-	flag.IntVar(&port, "port", 0, "Port to listen on.")
-	flag.Parse()
-
-	if netName == "" {
-		flag.Usage()
-		os.Exit(1)
-	}
-
-	if initURL != "" {
-		mainInit(initURL)
-		return
-	}
-
-	main(listenIP, uint16(port))
-}
-
-func mainInit(initURL string) {
-	if _, err := loadPeerConfig(netName); err == nil {
-		log.Fatalf("Network is already initialized.")
-	}
-
-	resp, err := http.Get(initURL)
-	if err != nil {
-		log.Fatalf("Failed to fetch data from hub: %v", err)
-	}
-	defer resp.Body.Close()
-
-	data, err := io.ReadAll(resp.Body)
-	if err != nil {
-		log.Fatalf("Failed to read response body: %v", err)
-	}
-
-	peerConfig := m.PeerConfig{}
-	if err := json.Unmarshal(data, &peerConfig); err != nil {
-		log.Fatalf("Failed to parse configuration: %v", err)
-	}
-
-	if err := storePeerConfig(netName, peerConfig); err != nil {
-		log.Fatalf("Failed to store configuration: %v", err)
-	}
-
-	log.Print("Initialization successful.")
-}
-
-// ----------------------------------------------------------------------------
-
-func main(listenIP string, port uint16) {
-	config, err := loadPeerConfig(netName)
-	if err != nil {
-		log.Fatalf("Failed to load configuration: %v", err)
-	}
-
-	port = determinePort(config.Port, port)
-
-	iface, err := openInterface(config.Network, config.PeerIP, netName)
-	if err != nil {
-		log.Fatalf("Failed to open interface: %v", err)
-	}
-
-	myAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", listenIP, port))
-	if err != nil {
-		log.Fatalf("Failed to resolve UDP address: %v", err)
-	}
-
-	conn, err := net.ListenUDP("udp", myAddr)
-	if err != nil {
-		log.Fatalf("Failed to open UDP port: %v", err)
-	}
-
-	// Intialize globals.
-	_iface = newIFWriter(iface)
-	_conn = newConnWriter(conn)
-
-	localIP = config.PeerIP
-	discoveryPackets = make(chan controlPacket, 256)
-	localAddr = &atomic.Pointer[netip.AddrPort]{}
-	relayIP = &atomic.Pointer[byte]{}
-
-	ip, ok := netip.AddrFromSlice(config.PublicIP)
-	if ok {
-		localPub = true
-		addr := netip.AddrPortFrom(ip, config.Port)
-		localAddr.Store(&addr)
-	}
-
-	privateKey = config.PrivKey
-
-	// Start supervisors.
-	for i := range 256 {
-		go newPeerSupervisor(i).Run()
-	}
-
-	if localPub {
-		go addrDiscoveryServer()
-	} else {
-		go addrDiscoveryClient()
-		go relayManager()
-	}
-	go newHubPoller(config).Run()
-	go readFromConn(conn)
-	readFromIFace(iface)
-}
-
-// ----------------------------------------------------------------------------
-
-func determinePort(confPort, portFromCommandLine uint16) uint16 {
-	if portFromCommandLine != 0 {
-		return portFromCommandLine
-	}
-	if confPort != 0 {
-		return confPort
-	}
-	return 456
-}
-
-// ----------------------------------------------------------------------------
-
-func readFromConn(conn *net.UDPConn) {
-
-	defer panicHandler()
-
-	var (
-		remoteAddr netip.AddrPort
-		n          int
-		err        error
-		buf        = make([]byte, bufferSize)
-		decBuf     = make([]byte, bufferSize)
-		data       []byte
-		h          header
-	)
-
-	for {
-		n, remoteAddr, err = conn.ReadFromUDPAddrPort(buf[:bufferSize])
-		if err != nil {
-			log.Fatalf("Failed to read from UDP port: %v", err)
-		}
-
-		remoteAddr = netip.AddrPortFrom(remoteAddr.Addr().Unmap(), remoteAddr.Port())
-
-		data = buf[:n]
-
-		if n < headerSize {
-			continue // Packet it soo short.
-		}
-
-		h.Parse(data)
-		switch h.StreamID {
-		case controlStreamID:
-			handleControlPacket(remoteAddr, h, data, decBuf)
-
-		case dataStreamID:
-			handleDataPacket(h, data, decBuf)
-
-		default:
-			log.Printf("Unknown stream ID: %d", h.StreamID)
-		}
-	}
-}
-
-func handleControlPacket(addr netip.AddrPort, h header, data, decBuf []byte) {
-	route := routingTable[h.SourceIP].Load()
-	if route.ControlCipher == nil {
-		//log.Printf("Not connected (control).")
-		return
-	}
-
-	if h.DestIP != localIP {
-		log.Printf("Incorrect destination IP on control packet: %d != %d", h.DestIP, localIP)
-		return
-	}
-
-	out, ok := route.ControlCipher.Decrypt(data, decBuf)
-	if !ok {
-		//log.Printf("Failed to decrypt control packet.")
-		return
-	}
-
-	if len(out) == 0 {
-		//log.Printf("Empty control packet from: %d", h.SourceIP)
-		return
-	}
-
-	if dupChecks[h.SourceIP].IsDup(h.Counter) {
-		//log.Printf("[%03d] Duplicate control packet: %d", h.SourceIP, h.Counter)
-		return
-	}
-
-	pkt := controlPacket{
-		SrcIP:   h.SourceIP,
-		SrcAddr: addr,
-	}
-
-	if err := pkt.ParsePayload(out); err != nil {
-		log.Printf("Failed to parse control packet: %v", err)
-		return
-	}
-
-	switch pkt.Payload.(type) {
-
-	case addrDiscoveryPacket:
-		select {
-		case discoveryPackets <- pkt:
-		default:
-			log.Printf("Dropping discovery packet.")
-		}
-
-	default:
-		select {
-		case controlPackets[h.SourceIP] <- pkt:
-		default:
-			log.Printf("Dropping control packet.")
-		}
-	}
-
-}
-
-func handleDataPacket(h header, data []byte, decBuf []byte) {
-	route := routingTable[h.SourceIP].Load()
-	if !route.Up {
-		//log.Printf("Not connected (recv).")
-		return
-	}
-
-	dec, ok := route.DataCipher.Decrypt(data, decBuf)
-	if !ok {
-		log.Printf("Failed to decrypt data packet.")
-		return
-	}
-
-	if dupChecks[h.SourceIP].IsDup(h.Counter) {
-		//log.Printf("[%03d] Duplicate data packet: %d", h.SourceIP, h.Counter)
-		return
-	}
-
-	if h.DestIP == localIP {
-		_iface.Write(dec)
-		return
-	}
-
-	destRoute := routingTable[h.DestIP].Load()
-	if !destRoute.Up {
-		log.Printf("Not connected (relay): %v", destRoute)
-		return
-	}
-
-	_conn.WriteTo(dec, destRoute.RemoteAddr)
-}
-
-// ----------------------------------------------------------------------------
-
-func readFromIFace(iface io.ReadWriteCloser) {
-	var (
-		packet   = make([]byte, bufferSize)
-		buf1     = make([]byte, bufferSize)
-		buf2     = make([]byte, bufferSize)
-		remoteIP byte
-		err      error
-	)
-
-	for {
-		packet, remoteIP, err = readNextPacket(iface, packet)
-		if err != nil {
-			log.Fatalf("Failed to read from interface: %v", err)
-		}
-
-		route := routingTable[remoteIP].Load()
-		if !route.Up {
-			log.Printf("Route not connected: %d", remoteIP)
-			continue
-		}
-
-		_sendDataPacket(route, packet, buf1, buf2)
-	}
-}

node/packets-util_test.go

@@ -1,40 +0,0 @@
-package node
-
-import (
-	"net/netip"
-	"reflect"
-	"testing"
-)
-
-func TestBinWriteRead(t *testing.T) {
-	buf := make([]byte, 1024)
-
-	type Item struct {
-		Type     byte
-		TraceID  uint64
-		DestAddr netip.AddrPort
-	}
-
-	in := Item{1, 2, netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 22)}
-
-	buf = newBinWriter(buf).
-		Byte(in.Type).
-		Uint64(in.TraceID).
-		AddrPort(in.DestAddr).
-		Build()
-
-	out := Item{}
-
-	err := newBinReader(buf).
-		Byte(&out.Type).
-		Uint64(&out.TraceID).
-		AddrPort(&out.DestAddr).
-		Error()
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(in, out) {
-		t.Fatal(in, out)
-	}
-}

node/packets.go

@@ -1,140 +0,0 @@
-package node
-
-import (
-	"errors"
-	"net/netip"
-)
-
-var (
-	errMalformedPacket   = errors.New("malformed packet")
-	errUnknownPacketType = errors.New("unknown packet type")
-)
-
-const (
-	packetTypeSyn = iota + 1
-	packetTypeSynAck
-	packetTypeAck
-	packetTypeProbe
-	packetTypeAddrDiscovery
-)
-
-// ----------------------------------------------------------------------------
-
-type controlPacket struct {
-	SrcIP   byte
-	SrcAddr netip.AddrPort
-	Payload any
-}
-
-func (p *controlPacket) ParsePayload(buf []byte) (err error) {
-	switch buf[0] {
-	case packetTypeSyn:
-		p.Payload, err = parseSynPacket(buf)
-	case packetTypeSynAck:
-		p.Payload, err = parseSynAckPacket(buf)
-	case packetTypeProbe:
-		p.Payload, err = parseProbePacket(buf)
-	case packetTypeAddrDiscovery:
-		p.Payload, err = parseAddrDiscoveryPacket(buf)
-	default:
-		return errUnknownPacketType
-	}
-	return err
-}
-
-// ----------------------------------------------------------------------------
-
-type synPacket struct {
-	TraceID   uint64   // TraceID to match response w/ request.
-	SharedKey [32]byte // Our shared key.
-	Direct    bool
-	FromAddr  netip.AddrPort // The client's sending address.
-}
-
-func (p synPacket) Marshal(buf []byte) []byte {
-	return newBinWriter(buf).
-		Byte(packetTypeSyn).
-		Uint64(p.TraceID).
-		SharedKey(p.SharedKey).
-		Bool(p.Direct).
-		AddrPort(p.FromAddr).
-		Build()
-}
-
-func parseSynPacket(buf []byte) (p synPacket, err error) {
-	err = newBinReader(buf[1:]).
-		Uint64(&p.TraceID).
-		SharedKey(&p.SharedKey).
-		Bool(&p.Direct).
-		AddrPort(&p.FromAddr).
-		Error()
-	return
-}
-
-// ----------------------------------------------------------------------------
-
-type synAckPacket struct {
-	TraceID  uint64
-	FromAddr netip.AddrPort
-}
-
-func (p synAckPacket) Marshal(buf []byte) []byte {
-	return newBinWriter(buf).
-		Byte(packetTypeSynAck).
-		Uint64(p.TraceID).
-		AddrPort(p.FromAddr).
-		Build()
-}
-
-func parseSynAckPacket(buf []byte) (p synAckPacket, err error) {
-	err = newBinReader(buf[1:]).
-		Uint64(&p.TraceID).
-		AddrPort(&p.FromAddr).
-		Error()
-	return
-}
-
-// ----------------------------------------------------------------------------
-
-type addrDiscoveryPacket struct {
-	TraceID uint64
-	ToAddr  netip.AddrPort
-}
-
-func (p addrDiscoveryPacket) Marshal(buf []byte) []byte {
-	return newBinWriter(buf).
-		Byte(packetTypeAddrDiscovery).
-		Uint64(p.TraceID).
-		AddrPort(p.ToAddr).
-		Build()
-}
-
-func parseAddrDiscoveryPacket(buf []byte) (p addrDiscoveryPacket, err error) {
-	err = newBinReader(buf[1:]).
-		Uint64(&p.TraceID).
-		AddrPort(&p.ToAddr).
-		Error()
-	return
-}
-
-// ----------------------------------------------------------------------------
-
-// A probeReqPacket is sent from a client to a server to determine if direct
-// UDP communication can be used.
-type probePacket struct {
-	TraceID uint64
-}
-
-func (p probePacket) Marshal(buf []byte) []byte {
-	return newBinWriter(buf).
-		Byte(packetTypeProbe).
-		Uint64(p.TraceID).
-		Build()
-}
-
-func parseProbePacket(buf []byte) (p probePacket, err error) {
-	err = newBinReader(buf[1:]).
-		Uint64(&p.TraceID).
-		Error()
-	return
-}

node/packets_test.go

@@ -1,42 +0,0 @@
-package node
-
-import (
-	"crypto/rand"
-	"net/netip"
-	"reflect"
-	"testing"
-)
-
-func TestPacketSyn(t *testing.T) {
-	in := synPacket{
-		TraceID:  newTraceID(),
-		RelayIP:  4,
-		FromAddr: netip.AddrPortFrom(netip.AddrFrom4([4]byte{4, 5, 6, 7}), 22),
-	}
-	rand.Read(in.SharedKey[:])
-
-	out, err := parseSynPacket(in.Marshal(make([]byte, bufferSize)))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(in, out) {
-		t.Fatal("\n", in, "\n", out)
-	}
-}
-
-func TestPacketSynAck(t *testing.T) {
-	in := synAckPacket{
-		TraceID:  newTraceID(),
-		FromAddr: netip.AddrPortFrom(netip.AddrFrom4([4]byte{4, 5, 6, 7}), 22),
-	}
-
-	out, err := parseSynAckPacket(in.Marshal(make([]byte, bufferSize)))
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if !reflect.DeepEqual(in, out) {
-		t.Fatal("\n", in, "\n", out)
-	}
-}

node/peer-supervisor.go

@@ -1,331 +0,0 @@
-package node
-
-import (
-	"fmt"
-	"log"
-	"net/netip"
-	"sync/atomic"
-	"time"
-	"vppn/m"
-)
-
-const (
-	pingInterval    = 8 * time.Second
-	timeoutInterval = 25 * time.Second
-)
-
-// ----------------------------------------------------------------------------
-
-type peerSupervisor struct {
-	// The purpose of this state machine is to manage this published data.
-	published *atomic.Pointer[peerRoute]
-	staged    peerRoute // Local copy of shared data. See publish().
-
-	// Immutable data.
-	remoteIP byte // Remote VPN IP.
-
-	// Mutable peer data.
-	peer      *m.Peer
-	remotePub bool
-
-	// Incoming events.
-	peerUpdates    chan *m.Peer
-	controlPackets chan controlPacket
-
-	// Buffers for sending control packets.
-	buf1 []byte
-	buf2 []byte
-}
-
-func newPeerSupervisor(i int) *peerSupervisor {
-	return &peerSupervisor{
-		published:      routingTable[i],
-		remoteIP:       byte(i),
-		peerUpdates:    peerUpdates[i],
-		controlPackets: controlPackets[i],
-		buf1:           make([]byte, bufferSize),
-		buf2:           make([]byte, bufferSize),
-	}
-}
-
-type stateFunc func() stateFunc
-
-func (s *peerSupervisor) Run() {
-	state := s.noPeer
-	for {
-		state = state()
-	}
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) sendControlPacket(pkt interface{ Marshal([]byte) []byte }) {
-	_sendControlPacket(pkt, s.staged, s.buf1, s.buf2)
-	time.Sleep(500 * time.Millisecond) // Rate limit packets.
-}
-
-func (s *peerSupervisor) sendControlPacketTo(
-	pkt interface{ Marshal([]byte) []byte },
-	addr netip.AddrPort,
-) {
-	if !addr.IsValid() {
-		s.logf("ERROR: Attepted to send packet to invalid address: %v", addr)
-		return
-	}
-	route := s.staged
-	route.Direct = true
-	route.RemoteAddr = addr
-	_sendControlPacket(pkt, route, s.buf1, s.buf2)
-	time.Sleep(500 * time.Millisecond) // Rate limit packets.
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) logf(msg string, args ...any) {
-	log.Printf(fmt.Sprintf("[%03d] ", s.remoteIP)+msg, args...)
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) publish() {
-	data := s.staged
-	s.published.Store(&data)
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) noPeer() stateFunc {
-	return s.peerUpdate(<-s.peerUpdates)
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) peerUpdate(peer *m.Peer) stateFunc {
-	return func() stateFunc { return s._peerUpdate(peer) }
-}
-
-func (s *peerSupervisor) _peerUpdate(peer *m.Peer) stateFunc {
-	defer s.publish()
-
-	s.peer = peer
-	s.staged = peerRoute{}
-
-	if s.peer == nil {
-		return s.noPeer
-	}
-
-	s.staged.IP = s.remoteIP
-	s.staged.ControlCipher = newControlCipher(privateKey, peer.PubKey)
-	s.staged.DataCipher = newDataCipher()
-
-	if ip, isValid := netip.AddrFromSlice(peer.PublicIP); isValid {
-		s.remotePub = true
-		s.staged.Relay = peer.Relay
-		s.staged.Direct = true
-		s.staged.RemoteAddr = netip.AddrPortFrom(ip, peer.Port)
-	} else if localPub {
-		s.staged.Direct = true
-	}
-
-	if s.remotePub == localPub {
-		if localIP < s.remoteIP {
-			return s.server
-		}
-		return s.client
-	}
-
-	if s.remotePub {
-		return s.client
-	}
-	return s.server
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) server() stateFunc {
-	logf := func(format string, args ...any) { s.logf("SERVER "+format, args...) }
-
-	logf("DOWN")
-
-	var (
-		syn          synPacket
-		timeoutTimer = time.NewTimer(timeoutInterval)
-	)
-
-	for {
-		select {
-		case peer := <-s.peerUpdates:
-			return s.peerUpdate(peer)
-
-		case pkt := <-s.controlPackets:
-			switch p := pkt.Payload.(type) {
-
-			case synPacket:
-				// Before we can respond to this packet, we need to make sure the
-				// route is setup properly.
-				//
-				// The client will update the syn's TraceID whenever there's a change.
-				// The server will follow the client's request.
-				if p.TraceID != syn.TraceID || !s.staged.Up {
-					if p.Direct {
-						logf("UP - Direct")
-					} else {
-						logf("UP - Relayed")
-					}
-
-					syn = p
-					s.staged.Up = true
-					s.staged.Direct = syn.Direct
-					s.staged.DataCipher = newDataCipherFromKey(syn.SharedKey)
-					s.staged.RemoteAddr = pkt.SrcAddr
-
-					s.publish()
-				}
-
-				// We should always respond.
-				ack := synAckPacket{
-					TraceID:  syn.TraceID,
-					FromAddr: getLocalAddr(),
-				}
-				s.sendControlPacket(ack)
-
-				if s.staged.Direct {
-					continue
-				}
-
-				if !syn.FromAddr.IsValid() {
-					continue
-				}
-
-				probe := probePacket{TraceID: newTraceID()}
-				s.sendControlPacketTo(probe, syn.FromAddr)
-
-			case probePacket:
-				if pkt.SrcAddr.IsValid() {
-					s.sendControlPacketTo(probePacket{TraceID: p.TraceID}, pkt.SrcAddr)
-				} else {
-					logf("Invalid probe address")
-				}
-			}
-
-		case <-timeoutTimer.C:
-			logf("Connection timeout")
-			s.staged.Up = false
-			s.publish()
-		}
-	}
-}
-
-// ----------------------------------------------------------------------------
-
-func (s *peerSupervisor) client() stateFunc {
-	logf := func(format string, args ...any) { s.logf("CLIENT "+format, args...) }
-
-	logf("DOWN")
-
-	var (
-		syn = synPacket{
-			TraceID:   newTraceID(),
-			SharedKey: s.staged.DataCipher.Key(),
-			Direct:    s.staged.Direct,
-			FromAddr:  getLocalAddr(),
-		}
-
-		ack synAckPacket
-
-		probe     probePacket
-		probeAddr netip.AddrPort
-
-		lAddr netip.AddrPort
-
-		timeoutTimer = time.NewTimer(timeoutInterval)
-		pingTimer    = time.NewTimer(pingInterval)
-	)
-
-	defer timeoutTimer.Stop()
-	defer pingTimer.Stop()
-
-	s.sendControlPacket(syn)
-
-	for {
-		select {
-
-		case peer := <-s.peerUpdates:
-			return s.peerUpdate(peer)
-
-		case pkt := <-s.controlPackets:
-			switch p := pkt.Payload.(type) {
-
-			case synAckPacket:
-				if p.TraceID != syn.TraceID {
-					continue // Hmm...
-				}
-
-				ack = p
-				timeoutTimer.Reset(timeoutInterval)
-
-				if !s.staged.Up {
-					if s.staged.Direct {
-						logf("UP - Direct")
-					} else {
-						logf("UP - Relayed")
-					}
-
-					s.staged.Up = true
-					s.publish()
-				}
-
-			case probePacket:
-				if s.staged.Direct {
-					continue
-				}
-
-				if p.TraceID != probe.TraceID {
-					continue
-				}
-
-				// Upgrade connection.
-
-				logf("UP - Direct")
-				s.staged.Direct = true
-				s.staged.RemoteAddr = probeAddr
-				s.publish()
-
-				syn.TraceID = newTraceID()
-				syn.Direct = true
-				syn.FromAddr = getLocalAddr()
-				s.sendControlPacket(syn)
-			}
-
-		case <-pingTimer.C:
-			// Send syn.
-
-			syn.FromAddr = getLocalAddr()
-			if syn.FromAddr != lAddr {
-				syn.TraceID = newTraceID()
-				lAddr = syn.FromAddr
-			}
-
-			s.sendControlPacket(syn)
-
-			pingTimer.Reset(pingInterval)
-
-			if s.staged.Direct {
-				continue
-			}
-
-			if !ack.FromAddr.IsValid() {
-				continue
-			}
-
-			probe = probePacket{TraceID: newTraceID()}
-			probeAddr = ack.FromAddr
-
-			s.sendControlPacketTo(probe, ack.FromAddr)
-
-		case <-timeoutTimer.C:
-			logf("Connection timeout")
-			return s.peerUpdate(s.peer)
-		}
-	}
-}

node/relaymanager.go

@@ -1,40 +0,0 @@
-package node
-
-import (
-	"log"
-	"math/rand"
-	"time"
-)
-
-func relayManager() {
-	time.Sleep(2 * time.Second)
-	updateRelayRoute()
-
-	for range time.Tick(8 * time.Second) {
-		relay := getRelayRoute()
-		if relay == nil || !relay.Up || !relay.Relay {
-			updateRelayRoute()
-		}
-	}
-}
-
-func updateRelayRoute() {
-	possible := make([]*peerRoute, 0, 8)
-	for i := range routingTable {
-		route := routingTable[i].Load()
-		if !route.Up || !route.Relay {
-			continue
-		}
-		possible = append(possible, route)
-	}
-
-	if len(possible) == 0 {
-		log.Printf("No relay available.")
-		relayIP.Store(nil)
-		return
-	}
-
-	ip := possible[rand.Intn(len(possible))].IP
-	log.Printf("New relay IP: %d", ip)
-	relayIP.Store(&ip)
-}

peer/bitset.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 const bitSetSize = 512 // Multiple of 64.
 

peer/bitset_test.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import (
 	"math/rand"

peer/cipher-control.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import "golang.org/x/crypto/nacl/box"
 

peer/cipher-control_test.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import (
 	"bytes"

peer/cipher-data.go

@@ -1,12 +1,12 @@
-package node
+package peer
 
 import (
 	"crypto/aes"
 	"crypto/cipher"
 	"crypto/rand"
+	"log"
 )
 
-// TODO: Use [32]byte for simplicity everywhere.
 type dataCipher struct {
 	key  [32]byte
 	aead cipher.AEAD
@@ -15,21 +15,20 @@ type dataCipher struct {
 func newDataCipher() *dataCipher {
 	key := [32]byte{}
 	if _, err := rand.Read(key[:]); err != nil {
-		panic(err)
+		log.Fatalf("Failed to read random data: %v", err)
 	}
 	return newDataCipherFromKey(key)
 }
 
-// key must be 32 bytes.
 func newDataCipherFromKey(key [32]byte) *dataCipher {
 	block, err := aes.NewCipher(key[:])
 	if err != nil {
-		panic(err)
+		log.Fatalf("Failed to create new cipher: %v", err)
 	}
 
 	aead, err := cipher.NewGCM(block)
 	if err != nil {
-		panic(err)
+		log.Fatalf("Failed to create new GCM: %v", err)
 	}
 
 	return &dataCipher{key: key, aead: aead}

peer/cipher-data_test.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import (
 	"bytes"

peer/cipher-discovery.go

@@ -0,0 +1,13 @@
+package peer
+
+/*
+func signData(privKey *[64]byte, h header, data, out []byte) []byte {
+	out = out[:headerSize]
+	h.Marshal(out)
+	return sign.Sign(out, data, privKey)
+}
+
+func openData(pubKey *[32]byte, signed, out []byte) (data []byte, ok bool) {
+	return sign.Open(out[:0], signed[headerSize:], pubKey)
+}
+*/

peer/connreader.go

@@ -0,0 +1,140 @@
+package peer
+
+import (
+	"io"
+	"log"
+	"net/netip"
+	"sync/atomic"
+)
+
+type connReader struct {
+	// Input
+	readFromUDPAddrPort func([]byte) (int, netip.AddrPort, error)
+
+	// Output
+	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error)
+	iface              io.Writer
+	handleControlMsg   func(fromIP byte, pkt any)
+
+	localIP byte
+	rt      *atomic.Pointer[routingTable]
+
+	buf    []byte
+	decBuf []byte
+}
+
+func newConnReader(
+	readFromUDPAddrPort func([]byte) (int, netip.AddrPort, error),
+	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error),
+	iface io.Writer,
+	handleControlMsg func(fromIP byte, pkt any),
+	rt *atomic.Pointer[routingTable],
+) *connReader {
+	return &connReader{
+		readFromUDPAddrPort: readFromUDPAddrPort,
+		writeToUDPAddrPort:  writeToUDPAddrPort,
+		iface:               iface,
+		handleControlMsg:    handleControlMsg,
+		localIP:             rt.Load().LocalIP,
+		rt:                  rt,
+		buf:                 newBuf(),
+		decBuf:              newBuf(),
+	}
+}
+
+func (r *connReader) Run() {
+	for {
+		r.handleNextPacket()
+	}
+}
+
+func (r *connReader) handleNextPacket() {
+	buf := r.buf[:bufferSize]
+	n, remoteAddr, err := r.readFromUDPAddrPort(buf)
+	if err != nil {
+		log.Fatalf("Failed to read from UDP port: %v", err)
+	}
+
+	if n < headerSize {
+		return
+	}
+
+	remoteAddr = netip.AddrPortFrom(remoteAddr.Addr().Unmap(), remoteAddr.Port())
+
+	buf = buf[:n]
+	h := parseHeader(buf)
+
+	rt := r.rt.Load()
+	peer := rt.Peers[h.SourceIP]
+
+	switch h.StreamID {
+	case controlStreamID:
+		r.handleControlPacket(remoteAddr, peer, h, buf)
+	case dataStreamID:
+		r.handleDataPacket(rt, peer, h, buf)
+	default:
+		r.logf("Unknown stream ID: %d", h.StreamID)
+	}
+}
+
+func (r *connReader) handleControlPacket(
+	remoteAddr netip.AddrPort,
+	peer remotePeer,
+	h header,
+	enc []byte,
+) {
+	if peer.ControlCipher == nil {
+		r.logf("No control cipher for peer: %d", h.SourceIP)
+		return
+	}
+
+	if h.DestIP != r.localIP {
+		r.logf("Incorrect destination IP on control packet: %d", h.DestIP)
+		return
+	}
+
+	msg, err := peer.DecryptControlPacket(remoteAddr, h, enc, r.decBuf)
+	if err != nil {
+		r.logf("Failed to decrypt control packet: %v", err)
+		return
+	}
+
+	r.handleControlMsg(h.SourceIP, msg)
+}
+
+func (r *connReader) handleDataPacket(
+	rt *routingTable,
+	peer remotePeer,
+	h header,
+	enc []byte,
+) {
+	if !peer.Up {
+		r.logf("Not connected (recv).")
+		return
+	}
+
+	data, err := peer.DecryptDataPacket(h, enc, r.decBuf)
+	if err != nil {
+		r.logf("Failed to decrypt data packet: %v", err)
+		return
+	}
+
+	if h.DestIP == r.localIP {
+		if _, err := r.iface.Write(data); err != nil {
+			log.Fatalf("Failed to write to interface: %v", err)
+		}
+		return
+	}
+
+	remote := rt.Peers[h.DestIP]
+	if !remote.Direct {
+		r.logf("Unable to relay data to %d.", h.DestIP)
+		return
+	}
+
+	r.writeToUDPAddrPort(data, remote.DirectAddr)
+}
+
+func (r *connReader) logf(format string, args ...any) {
+	log.Printf("[ConnReader] "+format, args...)
+}

peer/controlmessage.go

@@ -0,0 +1,64 @@
+package peer
+
+import (
+	"net/netip"
+	"vppn/m"
+)
+
+// ----------------------------------------------------------------------------
+
+type controlMsg[T any] struct {
+	SrcIP   byte
+	SrcAddr netip.AddrPort
+	Packet  T
+}
+
+func parseControlMsg(srcIP byte, srcAddr netip.AddrPort, buf []byte) (any, error) {
+	switch buf[0] {
+
+	case packetTypeInit:
+		packet, err := parsePacketInit(buf)
+		return controlMsg[packetInit]{
+			SrcIP:   srcIP,
+			SrcAddr: srcAddr,
+			Packet:  packet,
+		}, err
+
+	case packetTypeSyn:
+		packet, err := parsePacketSyn(buf)
+		return controlMsg[packetSyn]{
+			SrcIP:   srcIP,
+			SrcAddr: srcAddr,
+			Packet:  packet,
+		}, err
+
+	case packetTypeAck:
+		packet, err := parsePacketAck(buf)
+		return controlMsg[packetAck]{
+			SrcIP:   srcIP,
+			SrcAddr: srcAddr,
+			Packet:  packet,
+		}, err
+
+	case packetTypeProbe:
+		packet, err := parsePacketProbe(buf)
+		return controlMsg[packetProbe]{
+			SrcIP:   srcIP,
+			SrcAddr: srcAddr,
+			Packet:  packet,
+		}, err
+
+	default:
+		return nil, errUnknownPacketType
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+type peerUpdateMsg struct {
+	Peer *m.Peer
+}
+
+// ----------------------------------------------------------------------------
+
+type pingTimerMsg struct{}

peer/crypto.go

@@ -0,0 +1,30 @@
+package peer
+
+import (
+	"crypto/rand"
+	"log"
+
+	"golang.org/x/crypto/nacl/box"
+	"golang.org/x/crypto/nacl/sign"
+)
+
+type cryptoKeys struct {
+	PubKey      []byte
+	PrivKey     []byte
+	PubSignKey  []byte
+	PrivSignKey []byte
+}
+
+func generateKeys() cryptoKeys {
+	pubKey, privKey, err := box.GenerateKey(rand.Reader)
+	if err != nil {
+		log.Fatalf("Failed to generate encryption keys: %v", err)
+	}
+
+	pubSignKey, privSignKey, err := sign.GenerateKey(rand.Reader)
+	if err != nil {
+		log.Fatalf("Failed to generate signing keys: %v", err)
+	}
+
+	return cryptoKeys{pubKey[:], privKey[:], pubSignKey[:], privSignKey[:]}
+}

peer/crypto_test.go

@@ -0,0 +1,191 @@
+package peer
+
+import (
+	"net/netip"
+	"reflect"
+	"testing"
+)
+
+func newRoutePairForTesting() (*remotePeer, *remotePeer) {
+	keys1 := generateKeys()
+	keys2 := generateKeys()
+
+	r1 := newRemotePeer(1)
+	r1.PubSignKey = keys1.PubSignKey
+	r1.ControlCipher = newControlCipher(keys1.PrivKey, keys2.PubKey)
+	r1.DataCipher = newDataCipher()
+
+	r2 := newRemotePeer(2)
+	r2.PubSignKey = keys2.PubSignKey
+	r2.ControlCipher = newControlCipher(keys2.PrivKey, keys1.PubKey)
+	r2.DataCipher = r1.DataCipher
+
+	return r1, r2
+}
+
+func TestDecryptControlPacket(t *testing.T) {
+	var (
+		r1, r2 = newRoutePairForTesting()
+		tmp    = make([]byte, bufferSize)
+		out    = make([]byte, bufferSize)
+	)
+
+	in := packetSyn{
+		TraceID:   newTraceID(),
+		SharedKey: r1.DataCipher.Key(),
+		Direct:    true,
+	}
+
+	enc := r1.EncryptControlPacket(in, tmp, out)
+	h := parseHeader(enc)
+
+	iMsg, err := r2.DecryptControlPacket(netip.AddrPort{}, h, enc, tmp)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	msg, ok := iMsg.(controlMsg[packetSyn])
+	if !ok {
+		t.Fatal(ok)
+	}
+
+	if !reflect.DeepEqual(msg.Packet, in) {
+		t.Fatal(msg)
+	}
+}
+
+/*
+	func TestDecryptControlPacket_decryptionFailed(t *testing.T) {
+		var (
+			r1, r2 = newRoutePairForTesting()
+			tmp    = make([]byte, bufferSize)
+			out    = make([]byte, bufferSize)
+		)
+
+		in := packetSyn{
+			TraceID:   newTraceID(),
+			SharedKey: r1.DataCipher.Key(),
+			Direct:    true,
+		}
+
+		enc := encryptControlPacket(r1.IP, r2, in, tmp, out)
+		h := parseHeader(enc)
+
+		for i := range enc {
+			x := bytes.Clone(enc)
+			x[i]++
+			_, err := decryptControlPacket(r2, netip.AddrPort{}, h, x, tmp)
+			if !errors.Is(err, errDecryptionFailed) {
+				t.Fatal(i, err)
+			}
+		}
+	}
+
+	func TestDecryptControlPacket_duplicate(t *testing.T) {
+		var (
+			r1, r2 = newRoutePairForTesting()
+			tmp    = make([]byte, bufferSize)
+			out    = make([]byte, bufferSize)
+		)
+
+		in := packetSyn{
+			TraceID:   newTraceID(),
+			SharedKey: r1.DataCipher.Key(),
+			Direct:    true,
+		}
+
+		enc := encryptControlPacket(r1.IP, r2, in, tmp, out)
+		h := parseHeader(enc)
+
+		if _, err := decryptControlPacket(r2, netip.AddrPort{}, h, enc, tmp); err != nil {
+			t.Fatal(err)
+		}
+
+		_, err := decryptControlPacket(r2, netip.AddrPort{}, h, enc, tmp)
+		if !errors.Is(err, errDuplicateSeqNum) {
+			t.Fatal(err)
+		}
+	}
+
+	func TestDecryptControlPacket_invalidPacket(t *testing.T) {
+		var (
+			r1, r2 = newRoutePairForTesting()
+			tmp    = make([]byte, bufferSize)
+			out    = make([]byte, bufferSize)
+		)
+
+		in := testPacket("hello!")
+
+		enc := encryptControlPacket(r1.IP, r2, in, tmp, out)
+		h := parseHeader(enc)
+
+		_, err := decryptControlPacket(r2, netip.AddrPort{}, h, enc, tmp)
+		if !errors.Is(err, errUnknownPacketType) {
+			t.Fatal(err)
+		}
+	}
+
+func TestDecryptDataPacket(t *testing.T) {
+	var (
+		r1, r2 = newRoutePairForTesting()
+		out    = make([]byte, bufferSize)
+		data   = make([]byte, 1024)
+	)
+
+	rand.Read(data)
+
+	enc := encryptDataPacket(r1.IP, r2.IP, r2, data, out)
+	h := parseHeader(enc)
+
+	out, err := decryptDataPacket(r1, h, bytes.Clone(enc), out)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !bytes.Equal(data, out) {
+		t.Fatal(data, out)
+	}
+}
+
+func TestDecryptDataPacket_incorrectCipher(t *testing.T) {
+	var (
+		r1, r2 = newRoutePairForTesting()
+		out    = make([]byte, bufferSize)
+		data   = make([]byte, 1024)
+	)
+
+	rand.Read(data)
+
+	enc := encryptDataPacket(r1.IP, r2.IP, r2, data, bytes.Clone(out))
+	h := parseHeader(enc)
+
+	r1.DataCipher = newDataCipher()
+	_, err := decryptDataPacket(r1, h, enc, bytes.Clone(out))
+	if !errors.Is(err, errDecryptionFailed) {
+		t.Fatal(err)
+	}
+}
+
+func TestDecryptDataPacket_duplicate(t *testing.T) {
+	var (
+		r1, r2 = newRoutePairForTesting()
+		out    = make([]byte, bufferSize)
+		data   = make([]byte, 1024)
+	)
+
+	rand.Read(data)
+
+	enc := encryptDataPacket(r1.IP, r2.IP, r2, data, bytes.Clone(out))
+	h := parseHeader(enc)
+
+	_, err := decryptDataPacket(r1, h, enc, bytes.Clone(out))
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	_, err = decryptDataPacket(r1, h, enc, bytes.Clone(out))
+	if !errors.Is(err, errDuplicateSeqNum) {
+		t.Fatal(err)
+	}
+}
+*/

peer/data-flow.dot

@@ -0,0 +1,14 @@
+digraph d {
+    ifReader   -> connWriter;
+    connReader -> ifWriter;
+    connReader -> connWriter;
+    connReader -> supervisor;
+    mcReader   -> supervisor;
+    supervisor -> connWriter;
+    supervisor -> mcWriter;
+    hubPoller  -> supervisor;
+
+    connWriter [shape="box"];
+    mcWriter [shape="box"];
+    ifWriter [shape="box"];
+}

peer/dupcheck.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 type dupCheck struct {
 	bitSet
@@ -38,14 +38,14 @@ func (dc *dupCheck) IsDup(counter uint64) bool {
 	delta := counter - dc.tailCounter
 
 	// Full clear.
-	if delta >= bitSetSize {
+	if delta >= bitSetSize-1 {
 		dc.ClearAll()
 		dc.Set(0)
 
 		dc.tail = 1
 		dc.head = 2
 		dc.tailCounter = counter + 1
-		dc.headCounter = dc.tailCounter - bitSetSize
+		dc.headCounter = dc.tailCounter - bitSetSize + 1
 
 		return false
 	}

peer/dupcheck_test.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import (
 	"testing"
@@ -19,6 +19,7 @@ func TestDupCheck(t *testing.T) {
 	}
 
 	testCases := []TestCase{
+		{511, true},
 		{0, true},
 		{1, true},
 		{2, true},
@@ -39,11 +40,13 @@ func TestDupCheck(t *testing.T) {
 		{516, false},
 		{517, true},
 		{2512, false},
-		{2000, true},
-		{2001, false},
+		{2512, true},
+		{2001, true},
+		{2002, false},
+		{2002, true},
 		{4000, false},
-		{4000 - 512, true},  // Too old.
-		{4000 - 511, false}, // Just in the window.
+		{4000 - 511, true},  // Too old.
+		{4000 - 510, false}, // Just in the window.
 	}
 
 	for i, tc := range testCases {

peer/errors.go

@@ -0,0 +1,10 @@
+package peer
+
+import "errors"
+
+var (
+	errDecryptionFailed  = errors.New("decryption failed")
+	errDuplicateSeqNum   = errors.New("duplicate sequence number")
+	errMalformedPacket   = errors.New("malformed packet")
+	errUnknownPacketType = errors.New("unknown packet type")
+)

peer/files.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import (
 	"encoding/json"
@@ -8,6 +8,14 @@ import (
 	"vppn/m"
 )
 
+type localConfig struct {
+	m.PeerConfig
+	PubKey      []byte
+	PrivKey     []byte
+	PubSignKey  []byte
+	PrivSignKey []byte
+}
+
 func configDir(netName string) string {
 	d, err := os.UserHomeDir()
 	if err != nil {
@@ -56,7 +64,7 @@ func storeJson(x any, outPath string) error {
 	return os.Rename(tmpPath, outPath)
 }
 
-func storePeerConfig(netName string, pc m.PeerConfig) error {
+func storePeerConfig(netName string, pc localConfig) error {
 	return storeJson(pc, peerConfigPath(netName))
 }
 
@@ -73,7 +81,7 @@ func loadJson(dataPath string, ptr any) error {
 	return json.Unmarshal(data, ptr)
 }
 
-func loadPeerConfig(netName string) (pc m.PeerConfig, err error) {
+func loadPeerConfig(netName string) (pc localConfig, err error) {
 	return pc, loadJson(peerConfigPath(netName), &pc)
 }
 

peer/files_test.go

@@ -0,0 +1,57 @@
+package peer
+
+import (
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestFilePaths(t *testing.T) {
+	confDir := configDir("netName")
+	if filepath.Base(confDir) != "netName" {
+		t.Fatal(confDir)
+	}
+	if filepath.Base(filepath.Dir(confDir)) != ".vppn" {
+		t.Fatal(confDir)
+	}
+
+	path := peerConfigPath("netName")
+	if path != filepath.Join(confDir, "peer-config.json") {
+		t.Fatal(path)
+	}
+
+	path = peerStatePath("netName")
+	if path != filepath.Join(confDir, "peer-state.json") {
+		t.Fatal(path)
+	}
+}
+
+func TestStoreLoadJson(t *testing.T) {
+	type Object struct {
+		Name  string
+		Age   int
+		Price float64
+	}
+
+	tmpDir := t.TempDir()
+	outPath := filepath.Join(tmpDir, "object.json")
+
+	obj := Object{
+		Name:  "Jason",
+		Age:   22,
+		Price: 123.534,
+	}
+
+	if err := storeJson(obj, outPath); err != nil {
+		t.Fatal(err)
+	}
+
+	obj2 := Object{}
+	if err := loadJson(outPath, &obj2); err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(obj, obj2) {
+		t.Fatal(obj, obj2)
+	}
+}

peer/globals.go

@@ -0,0 +1,37 @@
+package peer
+
+import (
+	"net"
+	"net/netip"
+	"time"
+)
+
+const (
+	version = 1
+
+	bufferSize = 1536
+
+	if_mtu       = 1200
+	if_queue_len = 2048
+
+	controlCipherOverhead = 16
+	dataCipherOverhead    = 16
+	signOverhead          = 64
+
+	pingInterval                  = 8 * time.Second
+	timeoutInterval               = 30 * time.Second
+	broadcastInterval             = 16 * time.Second
+	broadcastErrorTimeoutInterval = 8 * time.Second
+)
+
+var multicastAddr = net.UDPAddrFromAddrPort(netip.AddrPortFrom(
+	netip.AddrFrom4([4]byte{224, 0, 0, 157}),
+	4560))
+
+func newBuf() []byte {
+	return make([]byte, bufferSize)
+}
+
+type marshaller interface {
+	Marshal([]byte) []byte
+}

peer/header.go

@@ -0,0 +1,46 @@
+package peer
+
+import "unsafe"
+
+// ----------------------------------------------------------------------------
+
+const (
+	headerSize        = 12
+	controlStreamID   = 2
+	controlHeaderSize = 24
+	dataStreamID      = 1
+	dataHeaderSize    = 12
+)
+
+type header struct {
+	Version  byte
+	StreamID byte
+	SourceIP byte
+	DestIP   byte
+	Counter  uint64 // Init with time.Now().Unix << 30 to ensure monotonic.
+}
+
+func parseHeader(b []byte) (h header) {
+	h.Version = b[0]
+	h.StreamID = b[1]
+	h.SourceIP = b[2]
+	h.DestIP = b[3]
+	h.Counter = *(*uint64)(unsafe.Pointer(&b[4]))
+	return h
+}
+
+func (h *header) Parse(b []byte) {
+	h.Version = b[0]
+	h.StreamID = b[1]
+	h.SourceIP = b[2]
+	h.DestIP = b[3]
+	h.Counter = *(*uint64)(unsafe.Pointer(&b[4]))
+}
+
+func (h *header) Marshal(buf []byte) {
+	buf[0] = h.Version
+	buf[1] = h.StreamID
+	buf[2] = h.SourceIP
+	buf[3] = h.DestIP
+	*(*uint64)(unsafe.Pointer(&buf[4])) = h.Counter
+}

peer/header_test.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import "testing"
 

peer/hubpoller.go

@@ -0,0 +1,110 @@
+package peer
+
+import (
+	"encoding/json"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"time"
+	"vppn/m"
+)
+
+type hubPoller struct {
+	client           *http.Client
+	req              *http.Request
+	versions         [256]int64
+	localIP          byte
+	netName          string
+	handleControlMsg func(fromIP byte, msg any)
+}
+
+func newHubPoller(
+	localIP byte,
+	netName,
+	hubURL,
+	apiKey string,
+	handleControlMsg func(byte, any),
+) (*hubPoller, error) {
+	u, err := url.Parse(hubURL)
+	if err != nil {
+		return nil, err
+	}
+	u.Path = "/peer/fetch-state/"
+
+	client := &http.Client{Timeout: 8 * time.Second}
+
+	req := &http.Request{
+		Method: http.MethodGet,
+		URL:    u,
+		Header: http.Header{},
+	}
+	req.SetBasicAuth("", apiKey)
+
+	return &hubPoller{
+		client:           client,
+		req:              req,
+		localIP:          localIP,
+		netName:          netName,
+		handleControlMsg: handleControlMsg,
+	}, nil
+}
+
+func (hp *hubPoller) logf(s string, args ...any) {
+	log.Printf("[HubPoller] "+s, args...)
+}
+
+func (hp *hubPoller) Run() {
+	state, err := loadNetworkState(hp.netName)
+	if err != nil {
+		hp.logf("Failed to load network state: %v", err)
+		hp.logf("Polling hub...")
+		hp.pollHub()
+	} else {
+		hp.applyNetworkState(state)
+	}
+
+	for range time.Tick(64 * time.Second) {
+		hp.pollHub()
+	}
+}
+
+func (hp *hubPoller) pollHub() {
+	var state m.NetworkState
+
+	resp, err := hp.client.Do(hp.req)
+	if err != nil {
+		hp.logf("Failed to fetch peer state: %v", err)
+		return
+	}
+	body, err := io.ReadAll(resp.Body)
+	_ = resp.Body.Close()
+	if err != nil {
+		hp.logf("Failed to read body from hub: %v", err)
+		return
+	}
+
+	if err := json.Unmarshal(body, &state); err != nil {
+		hp.logf("Failed to unmarshal response from hub: %v\n%s", err, body)
+		return
+	}
+
+	hp.applyNetworkState(state)
+
+	if err := storeNetworkState(hp.netName, state); err != nil {
+		hp.logf("Failed to store network state: %v", err)
+	}
+}
+
+func (hp *hubPoller) applyNetworkState(state m.NetworkState) {
+	for i, peer := range state.Peers {
+		if i != int(hp.localIP) {
+			if peer == nil || peer.Version != hp.versions[i] {
+				hp.handleControlMsg(byte(i), peerUpdateMsg{Peer: state.Peers[i]})
+				if peer != nil {
+					hp.versions[i] = peer.Version
+				}
+			}
+		}
+	}
+}

peer/ifreader.go

@@ -0,0 +1,103 @@
+package peer
+
+import (
+	"io"
+	"log"
+	"net/netip"
+	"sync/atomic"
+)
+
+type ifReader struct {
+	iface              io.Reader
+	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error)
+	rt                 *atomic.Pointer[routingTable]
+	buf1               []byte
+	buf2               []byte
+}
+
+func newIFReader(
+	iface io.Reader,
+	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error),
+	rt *atomic.Pointer[routingTable],
+) *ifReader {
+	return &ifReader{iface, writeToUDPAddrPort, rt, newBuf(), newBuf()}
+}
+
+func (r *ifReader) Run() {
+	packet := newBuf()
+	for {
+		r.handleNextPacket(packet)
+	}
+}
+
+func (r *ifReader) handleNextPacket(packet []byte) {
+	packet = r.readNextPacket(packet)
+	remoteIP, ok := r.parsePacket(packet)
+	if !ok {
+		return
+	}
+
+	rt := r.rt.Load()
+	peer := rt.Peers[remoteIP]
+	if !peer.Up {
+		r.logf("Peer %d not up.", peer.IP)
+		return
+	}
+
+	enc := peer.EncryptDataPacket(peer.IP, packet, r.buf1)
+	if peer.Direct {
+		r.writeToUDPAddrPort(enc, peer.DirectAddr)
+		return
+	}
+
+	relay, ok := rt.GetRelay()
+	if !ok {
+		r.logf("Relay not available for peer %d.", peer.IP)
+		return
+	}
+
+	enc = relay.EncryptDataPacket(peer.IP, enc, r.buf2)
+	r.writeToUDPAddrPort(enc, relay.DirectAddr)
+}
+
+func (r *ifReader) readNextPacket(buf []byte) []byte {
+	n, err := r.iface.Read(buf[:cap(buf)])
+	if err != nil {
+		log.Fatalf("Failed to read from interface: %v", err)
+	}
+
+	return buf[:n]
+}
+
+func (r *ifReader) parsePacket(buf []byte) (byte, bool) {
+	n := len(buf)
+	if n == 0 {
+		return 0, false
+	}
+
+	version := buf[0] >> 4
+
+	switch version {
+	case 4:
+		if n < 20 {
+			r.logf("Short IPv4 packet: %d", len(buf))
+			return 0, false
+		}
+		return buf[19], true
+
+	case 6:
+		if len(buf) < 40 {
+			r.logf("Short IPv6 packet: %d", len(buf))
+			return 0, false
+		}
+		return buf[39], true
+
+	default:
+		r.logf("Invalid IP packet version: %v", version)
+		return 0, false
+	}
+}
+
+func (*ifReader) logf(s string, args ...any) {
+	log.Printf("[IFReader] "+s, args...)
+}

peer/ifreader_test.go

@@ -0,0 +1,81 @@
+package peer
+
+/*
+func TestIFReader_IPv4(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+
+	pkt := make([]byte, 1234)
+	pkt[0] = 4 << 4
+	pkt[19] = 2 // IP.
+
+	p1.IFace.UserWrite(pkt)
+	p1.IFReader.handleNextPacket(newBuf())
+
+	packets := p2.Conn.Packets()
+	if len(packets) != 1 {
+		t.Fatal(packets)
+	}
+}
+
+func TestIFReader_IPv6(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+
+	pkt := make([]byte, 1234)
+	pkt[0] = 6 << 4
+	pkt[39] = 2 // IP.
+
+	p1.IFace.UserWrite(pkt)
+	p1.IFReader.handleNextPacket(newBuf())
+
+	packets := p2.Conn.Packets()
+	if len(packets) != 1 {
+		t.Fatal(packets)
+	}
+}
+
+func TestIFReader_parsePacket_emptyPacket(t *testing.T) {
+	r := NewIFReader(nil, nil)
+	pkt := make([]byte, 0)
+	if ip, ok := r.parsePacket(pkt); ok {
+		t.Fatal(ip, ok)
+	}
+}
+
+func TestIFReader_parsePacket_invalidIPVersion(t *testing.T) {
+	r := NewIFReader(nil, nil)
+
+	for i := byte(1); i < 16; i++ {
+		if i == 4 || i == 6 {
+			continue
+		}
+		pkt := make([]byte, 1234)
+		pkt[0] = i << 4
+
+		if ip, ok := r.parsePacket(pkt); ok {
+			t.Fatal(i, ip, ok)
+		}
+	}
+}
+
+func TestIFReader_parsePacket_shortIPv4(t *testing.T) {
+	r := NewIFReader(nil, nil)
+
+	pkt := make([]byte, 19)
+	pkt[0] = 4 << 4
+
+	if ip, ok := r.parsePacket(pkt); ok {
+		t.Fatal(ip, ok)
+	}
+}
+
+func TestIFReader_parsePacket_shortIPv6(t *testing.T) {
+	r := NewIFReader(nil, nil)
+
+	pkt := make([]byte, 39)
+	pkt[0] = 6 << 4
+
+	if ip, ok := r.parsePacket(pkt); ok {
+		t.Fatal(ip, ok)
+	}
+}
+*/

peer/interface.go

@@ -1,4 +1,4 @@
-package stage2
+package peer
 
 import (
 	"fmt"
@@ -10,11 +10,6 @@ import (
 	"golang.org/x/sys/unix"
 )
 
-const (
-	if_mtu       = 1200
-	if_queue_len = 1000
-)
-
 func openInterface(network []byte, localIP byte, name string) (io.ReadWriteCloser, error) {
 	if len(network) != 4 {
 		return nil, fmt.Errorf("expected network to be 4 bytes, got %d", len(network))

peer/main.go

@@ -0,0 +1,23 @@
+package peer
+
+import (
+	"flag"
+	"os"
+)
+
+func Main() {
+	conf := peerConfig{}
+
+	flag.StringVar(&conf.NetName, "name", "", "[REQUIRED] The network name.")
+	flag.StringVar(&conf.HubAddress, "hub-address", "", "[REQUIRED] The hub address.")
+	flag.StringVar(&conf.APIKey, "api-key", "", "[REQUIRED] The node's API key.")
+	flag.Parse()
+
+	if conf.NetName == "" || conf.HubAddress == "" || conf.APIKey == "" {
+		flag.Usage()
+		os.Exit(1)
+	}
+
+	peer := newPeerMain(conf)
+	peer.Run()
+}

peer/mcreader.go

@@ -0,0 +1,70 @@
+package peer
+
+import (
+	"log"
+	"net"
+	"sync/atomic"
+	"time"
+)
+
+func runMCReader(
+	rt *atomic.Pointer[routingTable],
+	handleControlMsg func(destIP byte, msg any),
+) {
+	for {
+		runMCReaderInner(rt, handleControlMsg)
+		time.Sleep(broadcastErrorTimeoutInterval)
+	}
+}
+
+func runMCReaderInner(
+	rt *atomic.Pointer[routingTable],
+	handleControlMsg func(destIP byte, msg any),
+) {
+	var (
+		raw  = newBuf()
+		buf  = newBuf()
+		logf = func(s string, args ...any) {
+			log.Printf("[MCReader] "+s, args...)
+		}
+	)
+
+	conn, err := net.ListenMulticastUDP("udp", nil, multicastAddr)
+	if err != nil {
+		logf("Failed to bind to multicast address: %v", err)
+		return
+	}
+
+	for {
+		conn.SetReadDeadline(time.Now().Add(32 * time.Second))
+		n, remoteAddr, err := conn.ReadFromUDPAddrPort(raw[:bufferSize])
+		if err != nil {
+			logf("Failed to read from UDP port): %v", err)
+			return
+		}
+
+		raw = raw[:n]
+		h, ok := headerFromLocalDiscoveryPacket(raw)
+		if !ok {
+			logf("Failed to open discovery packet?")
+			continue
+		}
+
+		peer := rt.Load().Peers[h.SourceIP]
+		if peer.PubSignKey == nil {
+			logf("No signing key for peer %d.", h.SourceIP)
+			continue
+		}
+
+		if !verifyLocalDiscoveryPacket(raw, buf, peer.PubSignKey) {
+			logf("Invalid signature from peer: %d", h.SourceIP)
+			continue
+		}
+
+		msg := controlMsg[packetLocalDiscovery]{
+			SrcIP:   h.SourceIP,
+			SrcAddr: remoteAddr,
+		}
+		handleControlMsg(h.SourceIP, msg)
+	}
+}

peer/mcreader_test.go

@@ -0,0 +1,132 @@
+package peer
+
+/*
+type mcMockConn struct {
+	packets chan []byte
+}
+
+func newMCMockConn() *mcMockConn {
+	return &mcMockConn{make(chan []byte, 32)}
+}
+
+func (c *mcMockConn) WriteToUDP(in []byte, addr *net.UDPAddr) (int, error) {
+	c.packets <- bytes.Clone(in)
+	return len(in), nil
+}
+
+func (c *mcMockConn) ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err error) {
+	buf := <-c.packets
+	b = b[:len(buf)]
+	copy(b, buf)
+	return len(b), netip.AddrPort{}, nil
+}
+
+func TestMCReader(t *testing.T) {
+	keys := generateKeys()
+	super := &mockControlMsgHandler{}
+	conn := newMCMockConn()
+
+	peers := [256]*atomic.Pointer[RemotePeer]{}
+	peer := &RemotePeer{
+		IP:         1,
+		Up:         true,
+		PubSignKey: keys.PubSignKey,
+	}
+	peers[1] = &atomic.Pointer[RemotePeer]{}
+	peers[1].Store(peer)
+
+	w := newMCWriter(conn, 1, keys.PrivSignKey)
+	r := newMCReader(conn, super, peers)
+
+	w.SendLocalDiscovery()
+	r.handleNextPacket()
+
+	if len(super.Messages) != 1 {
+		t.Fatal(super.Messages)
+	}
+	msg, ok := super.Messages[0].(controlMsg[PacketLocalDiscovery])
+	if !ok || msg.SrcIP != 1 {
+		t.Fatal(ok, msg)
+	}
+}
+
+func TestMCReader_noHeader(t *testing.T) {
+	keys := generateKeys()
+	super := &mockControlMsgHandler{}
+	conn := newMCMockConn()
+
+	peers := [256]*atomic.Pointer[RemotePeer]{}
+	peer := &RemotePeer{
+		IP:         1,
+		Up:         true,
+		PubSignKey: keys.PubSignKey,
+	}
+	peers[1] = &atomic.Pointer[RemotePeer]{}
+	peers[1].Store(peer)
+
+	r := newMCReader(conn, super, peers)
+	conn.WriteToUDP([]byte("0123546789"), nil)
+	r.handleNextPacket()
+
+	if len(super.Messages) != 0 {
+		t.Fatal(super.Messages)
+	}
+}
+
+func TestMCReader_noPeer(t *testing.T) {
+	keys := generateKeys()
+	super := &mockControlMsgHandler{}
+	conn := newMCMockConn()
+
+	peers := [256]*atomic.Pointer[RemotePeer]{}
+	peer := &RemotePeer{
+		IP:         1,
+		Up:         true,
+		PubSignKey: keys.PubSignKey,
+	}
+	peers[1] = &atomic.Pointer[RemotePeer]{}
+	peers[2] = &atomic.Pointer[RemotePeer]{}
+	peers[1].Store(peer)
+
+	w := newMCWriter(conn, 2, keys.PrivSignKey)
+	r := newMCReader(conn, super, peers)
+
+	w.SendLocalDiscovery()
+	r.handleNextPacket()
+
+	if len(super.Messages) != 0 {
+		t.Fatal(super.Messages)
+	}
+}
+
+func TestMCReader_badSignature(t *testing.T) {
+	keys := generateKeys()
+	super := &mockControlMsgHandler{}
+	conn := newMCMockConn()
+
+	peers := [256]*atomic.Pointer[RemotePeer]{}
+	peer := &RemotePeer{
+		IP:         1,
+		Up:         true,
+		PubSignKey: keys.PubSignKey,
+	}
+	peers[1] = &atomic.Pointer[RemotePeer]{}
+	peers[1].Store(peer)
+
+	w := newMCWriter(conn, 1, keys.PrivSignKey)
+	w.SendLocalDiscovery()
+
+	// Break signing.
+	packet := <-conn.packets
+	packet[0]++
+	conn.packets <- packet
+
+	r := newMCReader(conn, super, peers)
+
+	r.handleNextPacket()
+
+	if len(super.Messages) != 0 {
+		t.Fatal(super.Messages)
+	}
+}
+*/

peer/mcwriter.go

@@ -0,0 +1,53 @@
+package peer
+
+import (
+	"log"
+	"net"
+	"time"
+
+	"golang.org/x/crypto/nacl/sign"
+)
+
+func createLocalDiscoveryPacket(localIP byte, signingKey []byte) []byte {
+	h := header{
+		SourceIP: localIP,
+		DestIP:   255,
+	}
+	buf := make([]byte, headerSize)
+	h.Marshal(buf)
+	out := make([]byte, headerSize+signOverhead)
+	return sign.Sign(out[:0], buf, (*[64]byte)(signingKey))
+}
+
+func headerFromLocalDiscoveryPacket(pkt []byte) (h header, ok bool) {
+	if len(pkt) != headerSize+signOverhead {
+		return
+	}
+
+	h.Parse(pkt[signOverhead:])
+	ok = true
+	return
+}
+
+func verifyLocalDiscoveryPacket(pkt, buf []byte, pubSignKey []byte) bool {
+	_, ok := sign.Open(buf[:0], pkt, (*[32]byte)(pubSignKey))
+	return ok
+}
+
+// ----------------------------------------------------------------------------
+
+func runMCWriter(localIP byte, signingKey []byte) {
+	discoveryPacket := createLocalDiscoveryPacket(localIP, signingKey)
+
+	conn, err := net.ListenMulticastUDP("udp", nil, multicastAddr)
+	if err != nil {
+		log.Fatalf("[MCWriter] Failed to bind to multicast address: %v", err)
+	}
+
+	for range time.Tick(broadcastInterval) {
+		_, err := conn.WriteToUDP(discoveryPacket, multicastAddr)
+		if err != nil {
+			log.Printf("[MCWriter] Failed to write multicast: %v", err)
+		}
+	}
+}

peer/mcwriter_test.go

@@ -0,0 +1,98 @@
+package peer
+
+/*
+// ----------------------------------------------------------------------------
+
+// Testing that we can create and verify a local discovery packet.
+func TestVerifyLocalDiscoveryPacket_valid(t *testing.T) {
+	keys := generateKeys()
+
+	created := createLocalDiscoveryPacket(55, keys.PrivSignKey)
+
+	header, ok := headerFromLocalDiscoveryPacket(created)
+	if !ok {
+		t.Fatal(ok)
+	}
+	if header.SourceIP != 55 || header.DestIP != 255 {
+		t.Fatal(header)
+	}
+
+	if !verifyLocalDiscoveryPacket(created, make([]byte, 1024), keys.PubSignKey) {
+		t.Fatal("Not valid")
+	}
+}
+
+// Testing that we don't try to parse short packets.
+func TestVerifyLocalDiscoveryPacket_tooShort(t *testing.T) {
+	keys := generateKeys()
+
+	created := createLocalDiscoveryPacket(55, keys.PrivSignKey)
+
+	_, ok := headerFromLocalDiscoveryPacket(created[:len(created)-1])
+	if ok {
+		t.Fatal(ok)
+	}
+}
+
+// Testing that modifying a packet makes it invalid.
+func TestVerifyLocalDiscoveryPacket_invalid(t *testing.T) {
+	keys := generateKeys()
+
+	created := createLocalDiscoveryPacket(55, keys.PrivSignKey)
+	buf := make([]byte, 1024)
+	for i := range created {
+		modified := bytes.Clone(created)
+		modified[i]++
+		if verifyLocalDiscoveryPacket(modified, buf, keys.PubSignKey) {
+			t.Fatal("Verification should have failed.")
+		}
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+type testUDPWriter struct {
+	written [][]byte
+}
+
+func (w *testUDPWriter) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) {
+	w.written = append(w.written, bytes.Clone(b))
+	return len(b), nil
+}
+
+func (w *testUDPWriter) Written() [][]byte {
+	out := w.written
+	w.written = [][]byte{}
+	return out
+}
+
+// ----------------------------------------------------------------------------
+
+// Testing that the mcWriter sends local discovery packets as expected.
+func TestMCWriter_SendLocalDiscovery(t *testing.T) {
+	keys := generateKeys()
+	writer := &testUDPWriter{}
+
+	mcw := newMCWriter(writer, 42, keys.PrivSignKey)
+	mcw.SendLocalDiscovery()
+
+	out := writer.Written()
+	if len(out) != 1 {
+		t.Fatal(out)
+	}
+
+	pkt := out[0]
+
+	header, ok := headerFromLocalDiscoveryPacket(pkt)
+	if !ok {
+		t.Fatal(ok)
+	}
+	if header.SourceIP != 42 || header.DestIP != 255 {
+		t.Fatal(header)
+	}
+
+	if !verifyLocalDiscoveryPacket(pkt, make([]byte, 1024), keys.PubSignKey) {
+		t.Fatal("Verification should succeed.")
+	}
+}
+*/

peer/mock-iface_test.go

@@ -0,0 +1,31 @@
+package peer
+
+import "bytes"
+
+type TestIFace struct {
+	out *bytes.Buffer // Toward the network.
+	in  *bytes.Buffer // From the network
+}
+
+func NewTestIFace() *TestIFace {
+	return &TestIFace{
+		out: &bytes.Buffer{},
+		in:  &bytes.Buffer{},
+	}
+}
+
+func (iface *TestIFace) Write(b []byte) (int, error) {
+	return iface.in.Write(b)
+}
+
+func (iface *TestIFace) Read(b []byte) (int, error) {
+	return iface.out.Read(b)
+}
+
+func (iface *TestIFace) UserWrite(b []byte) (int, error) {
+	return iface.out.Write(b)
+}
+
+func (iface *TestIFace) UserRead(b []byte) (int, error) {
+	return iface.in.Read(b)
+}

peer/mock-network_test.go

@@ -0,0 +1,80 @@
+package peer
+
+import (
+	"bytes"
+	"net"
+	"net/netip"
+	"sync"
+)
+
+type TestPacket struct {
+	Addr netip.AddrPort
+	Data []byte
+}
+
+type TestNetwork struct {
+	lock    sync.Mutex
+	packets map[netip.AddrPort]chan TestPacket
+}
+
+func NewTestNetwork() *TestNetwork {
+	return &TestNetwork{packets: map[netip.AddrPort]chan TestPacket{}}
+}
+
+func (n *TestNetwork) NewUDPConn(localAddr netip.AddrPort) *TestUDPConn {
+	n.lock.Lock()
+	defer n.lock.Unlock()
+	if _, ok := n.packets[localAddr]; !ok {
+		n.packets[localAddr] = make(chan TestPacket, 1024)
+	}
+	return &TestUDPConn{
+		addr:    localAddr,
+		n:       n,
+		packets: n.packets[localAddr],
+	}
+}
+
+func (n *TestNetwork) write(b []byte, from, to netip.AddrPort) {
+	n.lock.Lock()
+	defer n.lock.Unlock()
+	if _, ok := n.packets[to]; !ok {
+		n.packets[to] = make(chan TestPacket, 1024)
+	}
+	n.packets[to] <- TestPacket{
+		Addr: from,
+		Data: bytes.Clone(b),
+	}
+}
+
+type TestUDPConn struct {
+	addr    netip.AddrPort
+	n       *TestNetwork
+	packets chan TestPacket
+}
+
+func (c *TestUDPConn) WriteToUDPAddrPort(b []byte, addr netip.AddrPort) (int, error) {
+	c.n.write(b, c.addr, addr)
+	return len(b), nil
+}
+
+func (c *TestUDPConn) WriteToUDP(b []byte, addr *net.UDPAddr) (int, error) {
+	return c.WriteToUDPAddrPort(b, addr.AddrPort())
+}
+
+func (c *TestUDPConn) ReadFromUDPAddrPort(b []byte) (n int, addr netip.AddrPort, err error) {
+	pkt := <-c.packets
+	b = b[:len(pkt.Data)]
+	copy(b, pkt.Data)
+	return len(b), pkt.Addr, nil
+}
+
+func (c *TestUDPConn) Packets() (out []TestPacket) {
+	for {
+		select {
+		case pkt := <-c.packets:
+			out = append(out, pkt)
+		default:
+			return
+		}
+	}
+}

peer/packets-util.go

@@ -1,4 +1,4 @@
-package node
+package peer
 
 import (
 	"net/netip"
@@ -63,12 +63,20 @@ func (w *binWriter) Int64(x int64) *binWriter {
 }
 
 func (w *binWriter) AddrPort(addrPort netip.AddrPort) *binWriter {
+	w.Bool(addrPort.IsValid())
 	addr := addrPort.Addr().As16()
 	copy(w.b[w.i:w.i+16], addr[:])
 	w.i += 16
 	return w.Uint16(addrPort.Port())
 }
 
+func (w *binWriter) AddrPort8(l [8]netip.AddrPort) *binWriter {
+	for _, addrPort := range l {
+		w.AddrPort(addrPort)
+	}
+	return w
+}
+
 func (w *binWriter) Build() []byte {
 	return w.b[:w.i]
 }
@@ -146,15 +154,34 @@ func (r *binReader) Int64(x *int64) *binReader {
 }
 
 func (r *binReader) AddrPort(x *netip.AddrPort) *binReader {
-	if !r.hasBytes(18) {
+	if !r.hasBytes(19) {
 		return r
 	}
+
+	var (
+		valid bool
+		port  uint16
+	)
+
+	r.Bool(&valid)
 	addr := netip.AddrFrom16(([16]byte)(r.b[r.i : r.i+16])).Unmap()
 	r.i += 16
 
-	var port uint16
 	r.Uint16(&port)
+
+	if valid {
 		*x = netip.AddrPortFrom(addr, port)
+	} else {
+		*x = netip.AddrPort{}
+	}
+
+	return r
+}
+
+func (r *binReader) AddrPort8(x *[8]netip.AddrPort) *binReader {
+	for i := range x {
+		r.AddrPort(&x[i])
+	}
 	return r
 }
 

peer/packets-util_test.go

@@ -0,0 +1,76 @@
+package peer
+
+import (
+	"net/netip"
+	"reflect"
+	"testing"
+)
+
+func TestBinWriteRead_invalidAddrPort(t *testing.T) {
+	addr := netip.AddrPort{}
+	buf := make([]byte, 1024)
+	buf = newBinWriter(buf).
+		AddrPort(addr).
+		Build()
+
+	var addr2 netip.AddrPort
+	err := newBinReader(buf).
+		AddrPort(&addr2).
+		Error()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if addr2.IsValid() {
+		t.Fatal(addr, addr2)
+	}
+}
+
+func TestBinWriteRead(t *testing.T) {
+	buf := make([]byte, 1024)
+
+	type Item struct {
+		Type     byte
+		TraceID  uint64
+		Addrs    [8]netip.AddrPort
+		DestAddr netip.AddrPort
+	}
+
+	in := Item{
+		1,
+		2,
+		[8]netip.AddrPort{},
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 22),
+	}
+
+	in.Addrs[0] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{0, 1, 2, 3}), 20)
+	in.Addrs[2] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 3, 4, 5}), 22)
+	in.Addrs[3] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 3, 4, 3}), 23)
+	in.Addrs[4] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 3, 4, 4}), 24)
+	in.Addrs[5] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 3, 4, 5}), 25)
+	in.Addrs[6] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 3, 4, 6}), 26)
+	in.Addrs[7] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{7, 8, 9, 7}), 27)
+
+	buf = newBinWriter(buf).
+		Byte(in.Type).
+		Uint64(in.TraceID).
+		AddrPort(in.DestAddr).
+		AddrPort8(in.Addrs).
+		Build()
+
+	out := Item{}
+
+	err := newBinReader(buf).
+		Byte(&out.Type).
+		Uint64(&out.TraceID).
+		AddrPort(&out.DestAddr).
+		AddrPort8(&out.Addrs).
+		Error()
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !reflect.DeepEqual(in, out) {
+		t.Fatal(in, out)
+	}
+}

peer/packets.go

@@ -0,0 +1,120 @@
+package peer
+
+import (
+	"net/netip"
+)
+
+const (
+	packetTypeSyn           = 1
+	packetTypeInit          = 2
+	packetTypeAck           = 3
+	packetTypeProbe         = 4
+	packetTypeAddrDiscovery = 5
+)
+
+// ----------------------------------------------------------------------------
+
+type packetInit struct {
+	TraceID uint64
+	Direct  bool
+	Version uint64
+}
+
+func (p packetInit) Marshal(buf []byte) []byte {
+	return newBinWriter(buf).
+		Byte(packetTypeInit).
+		Uint64(p.TraceID).
+		Bool(p.Direct).
+		Uint64(p.Version).
+		Build()
+}
+
+func parsePacketInit(buf []byte) (p packetInit, err error) {
+	err = newBinReader(buf[1:]).
+		Uint64(&p.TraceID).
+		Bool(&p.Direct).
+		Uint64(&p.Version).
+		Error()
+	return
+}
+
+// ----------------------------------------------------------------------------
+
+type packetSyn struct {
+	TraceID       uint64   // TraceID to match response w/ request.
+	SharedKey     [32]byte // Our shared key.
+	Direct        bool
+	PossibleAddrs [8]netip.AddrPort // Possible public addresses of the sender.
+}
+
+func (p packetSyn) Marshal(buf []byte) []byte {
+	return newBinWriter(buf).
+		Byte(packetTypeSyn).
+		Uint64(p.TraceID).
+		SharedKey(p.SharedKey).
+		Bool(p.Direct).
+		AddrPort8(p.PossibleAddrs).
+		Build()
+}
+
+func parsePacketSyn(buf []byte) (p packetSyn, err error) {
+	err = newBinReader(buf[1:]).
+		Uint64(&p.TraceID).
+		SharedKey(&p.SharedKey).
+		Bool(&p.Direct).
+		AddrPort8(&p.PossibleAddrs).
+		Error()
+	return
+}
+
+// ----------------------------------------------------------------------------
+
+type packetAck struct {
+	TraceID       uint64
+	ToAddr        netip.AddrPort
+	PossibleAddrs [8]netip.AddrPort // Possible public addresses of the sender.
+}
+
+func (p packetAck) Marshal(buf []byte) []byte {
+	return newBinWriter(buf).
+		Byte(packetTypeAck).
+		Uint64(p.TraceID).
+		AddrPort(p.ToAddr).
+		AddrPort8(p.PossibleAddrs).
+		Build()
+}
+
+func parsePacketAck(buf []byte) (p packetAck, err error) {
+	err = newBinReader(buf[1:]).
+		Uint64(&p.TraceID).
+		AddrPort(&p.ToAddr).
+		AddrPort8(&p.PossibleAddrs).
+		Error()
+	return
+}
+
+// ----------------------------------------------------------------------------
+
+// A probeReqPacket is sent from a client to a server to determine if direct
+// UDP communication can be used.
+type packetProbe struct {
+	TraceID uint64
+}
+
+func (p packetProbe) Marshal(buf []byte) []byte {
+	return newBinWriter(buf).
+		Byte(packetTypeProbe).
+		Uint64(p.TraceID).
+		Build()
+}
+
+func parsePacketProbe(buf []byte) (p packetProbe, err error) {
+	err = newBinReader(buf[1:]).
+		Uint64(&p.TraceID).
+		Error()
+	return
+}
+
+// ----------------------------------------------------------------------------
+
+type packetLocalDiscovery struct{}

peer/packets_test.go

@@ -0,0 +1,66 @@
+package peer
+
+import (
+	"crypto/rand"
+	"net/netip"
+	"reflect"
+	"testing"
+)
+
+func TestSynPacket(t *testing.T) {
+	p := packetSyn{
+		TraceID: newTraceID(),
+		//SentAt:        time.Now().UnixMilli(),
+		//SharedKeyType: 1,
+		Direct: true,
+	}
+	rand.Read(p.SharedKey[:])
+
+	p.PossibleAddrs[0] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 234)
+	p.PossibleAddrs[1] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 2, 3, 4}), 12399)
+	p.PossibleAddrs[2] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{3, 2, 3, 4}), 60000)
+
+	buf := p.Marshal(newBuf())
+	p2, err := parsePacketSyn(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(p, p2) {
+		t.Fatal(p2)
+	}
+}
+
+func TestAckPacket(t *testing.T) {
+	p := packetAck{
+		TraceID: newTraceID(),
+		ToAddr:  netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 2, 3, 4}), 234),
+	}
+
+	p.PossibleAddrs[0] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{8, 2, 3, 4}), 100)
+	p.PossibleAddrs[1] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 2, 3, 4}), 12399)
+	p.PossibleAddrs[2] = netip.AddrPortFrom(netip.AddrFrom4([4]byte{3, 2, 3, 4}), 60000)
+
+	buf := p.Marshal(newBuf())
+	p2, err := parsePacketAck(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(p, p2) {
+		t.Fatal(p2)
+	}
+}
+
+func TestProbePacket(t *testing.T) {
+	p := packetProbe{
+		TraceID: newTraceID(),
+	}
+
+	buf := p.Marshal(newBuf())
+	p2, err := parsePacketProbe(buf)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if !reflect.DeepEqual(p, p2) {
+		t.Fatal(p2)
+	}
+}

peer/peer.go

@@ -0,0 +1,177 @@
+package peer
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"net/http"
+	"net/netip"
+	"net/url"
+	"sync"
+	"sync/atomic"
+	"vppn/m"
+)
+
+type peerMain struct {
+	conf       localConfig
+	rt         *atomic.Pointer[routingTable]
+	ifReader   *ifReader
+	connReader *connReader
+	iface      io.Writer
+	hubPoller  *hubPoller
+	super      *supervisor
+}
+
+type peerConfig struct {
+	NetName    string
+	HubAddress string
+	APIKey     string
+}
+
+func newPeerMain(conf peerConfig) *peerMain {
+	logf := func(s string, args ...any) {
+		log.Printf("[Main] "+s, args...)
+	}
+
+	config, err := loadPeerConfig(conf.NetName)
+	if err != nil {
+		logf("Failed to load configuration: %v", err)
+		logf("Initializing...")
+		initPeerWithHub(conf)
+
+		config, err = loadPeerConfig(conf.NetName)
+		if err != nil {
+			log.Fatalf("Failed to load configuration: %v", err)
+		}
+	}
+
+	iface, err := openInterface(config.Network, config.PeerIP, conf.NetName)
+	if err != nil {
+		log.Fatalf("Failed to open interface: %v", err)
+	}
+
+	myAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", config.Port))
+	if err != nil {
+		log.Fatalf("Failed to resolve UDP address: %v", err)
+	}
+
+	logf("Listening on %v...", myAddr)
+	conn, err := net.ListenUDP("udp", myAddr)
+	if err != nil {
+		log.Fatalf("Failed to open UDP port: %v", err)
+	}
+
+	conn.SetReadBuffer(1024 * 1024 * 8)
+	conn.SetWriteBuffer(1024 * 1024 * 8)
+
+	// Wrap write function - this is necessary to avoid starvation.
+	writeLock := sync.Mutex{}
+	writeToUDPAddrPort := func(b []byte, addr netip.AddrPort) (n int, err error) {
+		writeLock.Lock()
+		n, err = conn.WriteToUDPAddrPort(b, addr)
+		if err != nil {
+			logf("Failed to write packet: %v", err)
+		}
+		writeLock.Unlock()
+		return n, err
+	}
+
+	var localAddr netip.AddrPort
+	ip, localAddrValid := netip.AddrFromSlice(config.PublicIP)
+	if localAddrValid {
+		localAddr = netip.AddrPortFrom(ip, config.Port)
+	}
+
+	rt := newRoutingTable(config.PeerIP, localAddr)
+	rtPtr := &atomic.Pointer[routingTable]{}
+	rtPtr.Store(&rt)
+
+	ifReader := newIFReader(iface, writeToUDPAddrPort, rtPtr)
+	super := newSupervisor(writeToUDPAddrPort, rtPtr, config.PrivKey)
+	connReader := newConnReader(conn.ReadFromUDPAddrPort, writeToUDPAddrPort, iface, super.HandleControlMsg, rtPtr)
+	hubPoller, err := newHubPoller(config.PeerIP, conf.NetName, conf.HubAddress, conf.APIKey, super.HandleControlMsg)
+	if err != nil {
+		log.Fatalf("Failed to create hub poller: %v", err)
+	}
+
+	return &peerMain{
+		conf:       config,
+		rt:         rtPtr,
+		iface:      iface,
+		ifReader:   ifReader,
+		connReader: connReader,
+		hubPoller:  hubPoller,
+		super:      super,
+	}
+}
+
+func (p *peerMain) Run() {
+
+	go p.ifReader.Run()
+	go p.connReader.Run()
+	p.super.Start()
+
+	if !p.rt.Load().LocalAddr.IsValid() {
+		go runMCWriter(p.conf.PeerIP, p.conf.PrivSignKey)
+		go runMCReader(p.rt, p.super.HandleControlMsg)
+	}
+
+	go p.hubPoller.Run()
+	select {}
+}
+
+func initPeerWithHub(conf peerConfig) {
+	keys := generateKeys()
+
+	initURL, err := url.Parse(conf.HubAddress)
+	if err != nil {
+		log.Fatalf("Failed to parse hub URL: %v", err)
+	}
+	initURL.Path = "/peer/init/"
+
+	args := m.PeerInitArgs{
+		EncPubKey:  keys.PubKey,
+		PubSignKey: keys.PubSignKey,
+	}
+
+	buf := &bytes.Buffer{}
+	if err := json.NewEncoder(buf).Encode(args); err != nil {
+		log.Fatalf("Failed to encode init args: %v", err)
+	}
+
+	req, err := http.NewRequest(http.MethodPost, initURL.String(), buf)
+	if err != nil {
+		log.Fatalf("Failed to construct request: %v", err)
+	}
+	req.SetBasicAuth("", conf.APIKey)
+
+	resp, err := http.DefaultClient.Do(req)
+	if err != nil {
+		log.Fatalf("Failed to init with hub: %v", err)
+	}
+	defer resp.Body.Close()
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		log.Fatalf("Failed to read response body: %v", err)
+	}
+
+	peerConfig := localConfig{}
+	if err := json.Unmarshal(data, &peerConfig.PeerConfig); err != nil {
+		log.Fatalf("Failed to parse configuration: %v\n%s", err, data)
+	}
+
+	peerConfig.PubKey = keys.PubKey
+	peerConfig.PrivKey = keys.PrivKey
+	peerConfig.PubSignKey = keys.PubSignKey
+	peerConfig.PrivSignKey = keys.PrivSignKey
+
+	if err := storePeerConfig(conf.NetName, peerConfig); err != nil {
+		log.Fatalf("Failed to store configuration: %v", err)
+	}
+
+	log.Print("Initialization successful.")
+}

peer/peer_test.go

@@ -0,0 +1,114 @@
+package peer
+
+import (
+	"bytes"
+	"crypto/rand"
+	mrand "math/rand"
+	"net/netip"
+	"sync/atomic"
+)
+
+// A test peer.
+type P struct {
+	cryptoKeys
+	RT         *atomic.Pointer[routingTable]
+	Conn       *TestUDPConn
+	IFace      *TestIFace
+	ConnReader *connReader
+	IFReader   *ifReader
+}
+
+func NewPeerForTesting(n *TestNetwork, ip byte, addr netip.AddrPort) P {
+	p := P{
+		cryptoKeys: generateKeys(),
+		RT:         &atomic.Pointer[routingTable]{},
+		IFace:      NewTestIFace(),
+	}
+
+	rt := newRoutingTable(ip, addr)
+	p.RT.Store(&rt)
+	p.Conn = n.NewUDPConn(addr)
+	//p.ConnWriter = NewConnWriter(p.Conn.WriteToUDPAddrPort, p.RT)
+
+	return p
+}
+
+func ConnectPeers(p1, p2 *P) {
+	rt1 := p1.RT.Load()
+	rt2 := p2.RT.Load()
+
+	ip1 := rt1.LocalIP
+	ip2 := rt2.LocalIP
+
+	rt1.Peers[ip2].Up = true
+	rt1.Peers[ip2].Direct = true
+	rt1.Peers[ip2].Relay = true
+	rt1.Peers[ip2].DirectAddr = rt2.LocalAddr
+	rt1.Peers[ip2].PubSignKey = p2.PubSignKey
+	rt1.Peers[ip2].ControlCipher = newControlCipher(p1.PrivKey, p2.PubKey)
+	rt1.Peers[ip2].DataCipher = newDataCipher()
+
+	rt2.Peers[ip1].Up = true
+	rt2.Peers[ip1].Direct = true
+	rt2.Peers[ip1].Relay = true
+	rt2.Peers[ip1].DirectAddr = rt1.LocalAddr
+	rt2.Peers[ip1].PubSignKey = p1.PubSignKey
+	rt2.Peers[ip1].ControlCipher = newControlCipher(p2.PrivKey, p1.PubKey)
+	rt2.Peers[ip1].DataCipher = rt1.Peers[ip2].DataCipher
+}
+
+func NewPeersForTesting() (p1, p2, p3 P) {
+	n := NewTestNetwork()
+
+	p1 = NewPeerForTesting(
+		n,
+		1,
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 1}), 100))
+
+	p2 = NewPeerForTesting(
+		n,
+		2,
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 2}), 200))
+
+	p3 = NewPeerForTesting(
+		n,
+		3,
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 1, 3}), 300))
+
+	ConnectPeers(&p1, &p2)
+	ConnectPeers(&p1, &p3)
+	ConnectPeers(&p2, &p3)
+
+	return
+}
+
+func RandPacket() []byte {
+	n := mrand.Intn(1200)
+	b := make([]byte, n)
+	rand.Read(b)
+	return b
+}
+
+func ModifyPacket(in []byte) []byte {
+	x := make([]byte, 1)
+
+	for {
+		rand.Read(x)
+		out := bytes.Clone(in)
+		idx := mrand.Intn(len(out))
+		if out[idx] != x[0] {
+			out[idx] = x[0]
+			return out
+		}
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+type UnknownControlPacket struct {
+	TraceID uint64
+}
+
+func (p UnknownControlPacket) Marshal(buf []byte) []byte {
+	return newBinWriter(buf).Byte(255).Uint64(p.TraceID).Build()
+}

peer/peerstates_test.go

@@ -0,0 +1,371 @@
+package peer
+
+import (
+	"testing"
+	"vppn/m"
+)
+
+// ----------------------------------------------------------------------------
+
+func TestPeerState_OnPeerUpdate_nilPeer(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.PeerUpdate(nil)
+	assertType[*stateDisconnected](t, h.State)
+}
+
+func TestPeerState_OnPeerUpdate_publicLocalIsServer(t *testing.T) {
+	keys := generateKeys()
+	h := NewPeerStateTestHarness()
+
+	state := h.State.(*stateDisconnected)
+	state.localAddr = addrPort4(1, 1, 1, 2, 200)
+
+	peer := &m.Peer{
+		PeerIP:     3,
+		Port:       456,
+		PubKey:     keys.PubKey,
+		PubSignKey: keys.PubSignKey,
+	}
+
+	h.PeerUpdate(peer)
+	assertEqual(t, h.Published.Up, false)
+	assertType[*stateServer](t, h.State)
+}
+
+/*
+
+func TestPeerState_OnPeerUpdate_clientDirect(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+}
+
+/*
+func TestPeerState_OnPeerUpdate_clientRelayed(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+}
+
+/*
+func TestStateServer_directSyn(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	synMsg := controlMsg[packetSyn]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 1, 1, 3, 300),
+		Packet: packetSyn{
+			TraceID: newTraceID(),
+			//SentAt:        time.Now().UnixMilli(),
+			//SharedKeyType: 1,
+			Direct: true,
+		},
+	}
+
+	h.State = h.State.OnMsg(synMsg)
+
+	assertEqual(t, len(h.Sent), 1)
+	ack := assertType[packetAck](t, h.Sent[0].Packet)
+	assertEqual(t, ack.TraceID, synMsg.Packet.TraceID)
+	assertEqual(t, h.Sent[0].Peer.IP, 3)
+	assertEqual(t, ack.PossibleAddrs[0].IsValid(), false)
+	assertEqual(t, h.Published.Up, true)
+}
+
+func TestStateServer_relayedSyn(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	state := h.ConfigServer_Relayed(t)
+
+	state.pubAddrs.Store(addrPort4(4, 5, 6, 7, 1234))
+
+	assertEqual(t, h.Published.Up, false)
+
+	synMsg := controlMsg[packetSyn]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 1, 1, 3, 300),
+		Packet: packetSyn{
+			TraceID: newTraceID(),
+			//SentAt:        time.Now().UnixMilli(),
+			//SharedKeyType: 1,
+			Direct: false,
+		},
+	}
+	synMsg.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 3, 300)
+	synMsg.Packet.PossibleAddrs[1] = addrPort4(2, 2, 2, 3, 300)
+
+	h.State = h.State.OnMsg(synMsg)
+
+	assertEqual(t, len(h.Sent), 3)
+
+	ack := assertType[packetAck](t, h.Sent[0].Packet)
+	assertEqual(t, ack.TraceID, synMsg.Packet.TraceID)
+	assertEqual(t, h.Sent[0].Peer.IP, 3)
+	assertEqual(t, ack.PossibleAddrs[0], addrPort4(4, 5, 6, 7, 1234))
+	assertEqual(t, ack.PossibleAddrs[1].IsValid(), false)
+	assertEqual(t, h.Published.Up, true)
+
+	assertType[packetProbe](t, h.Sent[1].Packet)
+	assertType[packetProbe](t, h.Sent[2].Packet)
+	assertEqual(t, h.Sent[1].Peer.DirectAddr, addrPort4(1, 1, 1, 3, 300))
+	assertEqual(t, h.Sent[2].Peer.DirectAddr, addrPort4(2, 2, 2, 3, 300))
+}
+
+func TestStateServer_onProbe(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+	assertEqual(t, h.Published.Up, false)
+
+	probeMsg := controlMsg[packetProbe]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 1, 1, 3, 300),
+		Packet:  packetProbe{TraceID: newTraceID()},
+	}
+
+	h.State = h.State.OnMsg(probeMsg)
+
+	assertEqual(t, len(h.Sent), 1)
+
+	probe := assertType[packetProbe](t, h.Sent[0].Packet)
+	assertEqual(t, probe.TraceID, probeMsg.Packet.TraceID)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, addrPort4(1, 1, 1, 3, 300))
+}
+
+func TestStateServer_OnPingTimer_timeout(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	synMsg := controlMsg[packetSyn]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 1, 1, 3, 300),
+		Packet: packetSyn{
+			TraceID: newTraceID(),
+			//SentAt:        time.Now().UnixMilli(),
+			//SharedKeyType: 1,
+			Direct: true,
+		},
+	}
+
+	h.State = h.State.OnMsg(synMsg)
+	assertEqual(t, len(h.Sent), 1)
+	assertEqual(t, h.Published.Up, true)
+
+	// Ping shouldn't timeout.
+	h.OnPingTimer()
+	assertEqual(t, h.Published.Up, true)
+
+	// Advance the time, then ping.
+	state := assertType[*stateServer](t, h.State)
+	state.lastSeen = time.Now().Add(-timeoutInterval - time.Second)
+
+	h.OnPingTimer()
+	assertEqual(t, h.Published.Up, false)
+}
+
+func TestStateClientDirect_OnAck(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID},
+	}
+	h.State = h.State.OnMsg(ack)
+	assertEqual(t, h.Published.Up, true)
+}
+
+func TestStateClientDirect_OnAck_incorrectTraceID(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID + 1},
+	}
+	h.State = h.State.OnMsg(ack)
+	assertEqual(t, h.Published.Up, false)
+}
+
+func TestStateClientDirect_OnPingTimer(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+	assertType[packetSyn](t, h.Sent[0].Packet)
+
+	h.OnPingTimer()
+
+	// On ping timer, another syn should be sent. Additionally, we should remain
+	// in the same state.
+	assertEqual(t, len(h.Sent), 2)
+	assertType[packetSyn](t, h.Sent[1].Packet)
+	assertType[*stateClientDirect](t, h.State)
+	assertEqual(t, h.Published.Up, false)
+}
+
+func TestStateClientDirect_OnPingTimer_timeout(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID},
+	}
+	h.State = h.State.OnMsg(ack)
+	assertEqual(t, h.Published.Up, true)
+
+	state := assertType[*stateClientDirect](t, h.State)
+	state.lastSeen = time.Now().Add(-(timeoutInterval + time.Second))
+
+	h.OnPingTimer()
+
+	// On ping timer, we should timeout, causing the client to reset. Another SYN
+	// will be sent when re-entering the state, but the connection should be down.
+	assertEqual(t, len(h.Sent), 2)
+	assertType[packetSyn](t, h.Sent[1].Packet)
+	assertType[*stateClientDirect](t, h.State)
+	assertEqual(t, h.Published.Up, false)
+}
+
+func TestStateClientRelayed_OnAck(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID},
+	}
+	h.State = h.State.OnMsg(ack)
+	assertEqual(t, h.Published.Up, true)
+}
+
+func TestStateClientRelayed_OnPingTimer_noAddrs(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+
+	// If we haven't had an ack yet, we won't have addresses to probe. Therefore
+	// we'll have just one more syn packet sent.
+	h.OnPingTimer()
+	assertEqual(t, len(h.Sent), 2)
+}
+
+func TestStateClientRelayed_OnPingTimer_withAddrs(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	assertEqual(t, h.Published.Up, false)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{Packet: packetAck{TraceID: syn.TraceID}}
+	ack.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 300)
+	ack.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 300)
+
+	h.State = h.State.OnMsg(ack)
+
+	// Add a local discovery address. Note that the port will be configured port
+	// and no the one provided here.
+	h.State = h.State.OnMsg(controlMsg[packetLocalDiscovery]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(2, 2, 2, 3, 300),
+	})
+
+	// We should see one SYN and three probe packets.
+	h.OnPingTimer()
+	assertEqual(t, len(h.Sent), 5)
+	assertType[packetSyn](t, h.Sent[1].Packet)
+	assertType[packetProbe](t, h.Sent[2].Packet)
+	assertType[packetProbe](t, h.Sent[3].Packet)
+	assertType[packetProbe](t, h.Sent[4].Packet)
+
+	assertEqual(t, h.Sent[2].Peer.DirectAddr, addrPort4(1, 1, 1, 1, 300))
+	assertEqual(t, h.Sent[3].Peer.DirectAddr, addrPort4(1, 1, 1, 2, 300))
+	assertEqual(t, h.Sent[4].Peer.DirectAddr, addrPort4(2, 2, 2, 3, 456))
+}
+
+func TestStateClientRelayed_OnPingTimer_timeout(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	// On entering the state, a SYN should have been sent.
+	assertEqual(t, len(h.Sent), 1)
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID},
+	}
+	h.State = h.State.OnMsg(ack)
+	assertEqual(t, h.Published.Up, true)
+
+	state := assertType[*stateClientRelayed](t, h.State)
+	state.lastSeen = time.Now().Add(-(timeoutInterval + time.Second))
+
+	h.OnPingTimer()
+
+	// On ping timer, we should timeout, causing the client to reset. Another SYN
+	// will be sent when re-entering the state, but the connection should be down.
+	assertEqual(t, len(h.Sent), 2)
+	assertType[packetSyn](t, h.Sent[1].Packet)
+	assertType[*stateClientRelayed](t, h.State)
+	assertEqual(t, h.Published.Up, false)
+}
+
+func TestStateClientRelayed_OnProbe_unknownAddr(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	h.OnProbe(controlMsg[packetProbe]{
+		Packet: packetProbe{TraceID: newTraceID()},
+	})
+
+	assertType[*stateClientRelayed](t, h.State)
+}
+
+func TestStateClientRelayed_OnProbe_upgradeDirect(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	syn := assertType[packetSyn](t, h.Sent[0].Packet)
+
+	ack := controlMsg[packetAck]{Packet: packetAck{TraceID: syn.TraceID}}
+	ack.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 300)
+	ack.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 300)
+
+	h.State = h.State.OnMsg(ack)
+	h.OnPingTimer()
+
+	probe := assertType[packetProbe](t, h.Sent[2].Packet)
+	h.OnProbe(controlMsg[packetProbe]{Packet: probe})
+
+	assertType[*stateClientDirect](t, h.State)
+}
+*/

peer/peersuper.go

@@ -0,0 +1,148 @@
+package peer
+
+import (
+	"net/netip"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"git.crumpington.com/lib/go/ratelimiter"
+)
+
+type supervisor struct {
+	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error)
+	staged             routingTable
+	shared             *atomic.Pointer[routingTable]
+	peers              [256]*peerSuper
+	lock               sync.Mutex
+
+	buf1 []byte
+	buf2 []byte
+}
+
+func newSupervisor(
+	writeToUDPAddrPort func([]byte, netip.AddrPort) (int, error),
+	rt *atomic.Pointer[routingTable],
+	privKey []byte,
+) *supervisor {
+
+	routes := rt.Load()
+
+	s := &supervisor{
+		writeToUDPAddrPort: writeToUDPAddrPort,
+		staged:             *routes,
+		shared:             rt,
+		buf1:               newBuf(),
+		buf2:               newBuf(),
+	}
+
+	pubAddrs := newPubAddrStore(routes.LocalAddr)
+
+	for i := range s.peers {
+		state := &peerData{
+			publish:           s.publish,
+			sendControlPacket: s.send,
+			pingTimer:         time.NewTicker(timeoutInterval),
+			localIP:           routes.LocalIP,
+			remoteIP:          byte(i),
+			privKey:           privKey,
+			localAddr:         routes.LocalAddr,
+			pubAddrs:          pubAddrs,
+			staged:            routes.Peers[i],
+			limiter: ratelimiter.New(ratelimiter.Config{
+				FillPeriod:   20 * time.Millisecond,
+				MaxWaitCount: 1,
+			}),
+		}
+		s.peers[i] = newPeerSuper(state, state.pingTimer)
+	}
+
+	return s
+}
+
+func (s *supervisor) Start() {
+	for i := range s.peers {
+		go s.peers[i].Run()
+	}
+}
+
+func (s *supervisor) HandleControlMsg(destIP byte, msg any) {
+	s.peers[destIP].HandleControlMsg(msg)
+}
+
+func (s *supervisor) send(peer remotePeer, pkt marshaller) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	enc := peer.EncryptControlPacket(pkt, s.buf1, s.buf2)
+	if peer.Direct {
+		s.writeToUDPAddrPort(enc, peer.DirectAddr)
+		return
+	}
+
+	relay, ok := s.staged.GetRelay()
+	if !ok {
+		return
+	}
+
+	enc = relay.EncryptDataPacket(peer.IP, enc, s.buf1)
+	s.writeToUDPAddrPort(enc, relay.DirectAddr)
+}
+
+func (s *supervisor) publish(rp remotePeer) {
+	s.lock.Lock()
+	defer s.lock.Unlock()
+
+	s.staged.Peers[rp.IP] = rp
+	s.ensureRelay()
+	copy := s.staged
+	s.shared.Store(&copy)
+}
+
+func (s *supervisor) ensureRelay() {
+	if _, ok := s.staged.GetRelay(); ok {
+		return
+	}
+
+	// TODO: Random selection? Something else?
+	for _, peer := range s.staged.Peers {
+		if peer.Up && peer.Direct && peer.Relay {
+			s.staged.RelayIP = peer.IP
+			return
+		}
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+type peerSuper struct {
+	messages  chan any
+	state     peerState
+	pingTimer *time.Ticker
+}
+
+func newPeerSuper(state *peerData, pingTimer *time.Ticker) *peerSuper {
+	return &peerSuper{
+		messages:  make(chan any, 8),
+		state:     initPeerState(state, nil),
+		pingTimer: pingTimer,
+	}
+}
+
+func (s *peerSuper) HandleControlMsg(msg any) {
+	select {
+	case s.messages <- msg:
+	default:
+	}
+}
+
+func (s *peerSuper) Run() {
+	for {
+		select {
+		case <-s.pingTimer.C:
+			s.state = s.state.OnMsg(pingTimerMsg{})
+		case raw := <-s.messages:
+			s.state = s.state.OnMsg(raw)
+		}
+	}
+}

peer/pubaddrs.go

@@ -0,0 +1,86 @@
+package peer
+
+import (
+	"net/netip"
+	"sort"
+	"sync"
+	"time"
+)
+
+type pubAddrStore struct {
+	lock      sync.Mutex
+	localPub  bool
+	localAddr netip.AddrPort
+	lastSeen  map[netip.AddrPort]time.Time
+	addrList  []netip.AddrPort
+}
+
+func newPubAddrStore(localAddr netip.AddrPort) *pubAddrStore {
+	return &pubAddrStore{
+		localPub:  localAddr.IsValid(),
+		localAddr: localAddr,
+		lastSeen:  map[netip.AddrPort]time.Time{},
+		addrList:  make([]netip.AddrPort, 0, 32),
+	}
+}
+
+func (store *pubAddrStore) Store(addr netip.AddrPort) {
+	if store.localPub {
+		return
+	}
+
+	if !addr.IsValid() {
+		return
+	}
+
+	if addr.Addr().IsPrivate() {
+		return
+	}
+
+	store.lock.Lock()
+	defer store.lock.Unlock()
+
+	if _, exists := store.lastSeen[addr]; !exists {
+		store.addrList = append(store.addrList, addr)
+	}
+	store.lastSeen[addr] = time.Now()
+	store.sort()
+}
+
+func (store *pubAddrStore) Get() (addrs [8]netip.AddrPort) {
+	store.lock.Lock()
+	defer store.lock.Unlock()
+
+	store.clean()
+
+	if store.localPub {
+		addrs[0] = store.localAddr
+		return
+	}
+
+	copy(addrs[:], store.addrList)
+	return
+}
+
+func (store *pubAddrStore) clean() {
+	if store.localPub {
+		return
+	}
+
+	for ip, lastSeen := range store.lastSeen {
+		if time.Since(lastSeen) > timeoutInterval {
+			delete(store.lastSeen, ip)
+		}
+	}
+	store.addrList = store.addrList[:0]
+	for ip := range store.lastSeen {
+		store.addrList = append(store.addrList, ip)
+	}
+	store.sort()
+}
+
+func (store *pubAddrStore) sort() {
+	sort.Slice(store.addrList, func(i, j int) bool {
+		return store.lastSeen[store.addrList[j]].Before(store.lastSeen[store.addrList[i]])
+	})
+}

peer/pubaddrs_test.go

@@ -0,0 +1,29 @@
+package peer
+
+import (
+	"net/netip"
+	"testing"
+	"time"
+)
+
+func TestPubAddrStore(t *testing.T) {
+	s := newPubAddrStore(netip.AddrPort{})
+
+	l := []netip.AddrPort{
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{0, 1, 2, 3}), 20),
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{1, 1, 2, 3}), 21),
+		netip.AddrPortFrom(netip.AddrFrom4([4]byte{2, 1, 2, 3}), 22),
+	}
+
+	for i := range l {
+		s.Store(l[i])
+		time.Sleep(time.Millisecond)
+	}
+
+	s.clean()
+
+	l2 := s.Get()
+	if l2[0] != l[2] || l2[1] != l[1] || l2[2] != l[0] {
+		t.Fatal(l, l2)
+	}
+}

peer/routingtable.go

@@ -0,0 +1,138 @@
+package peer
+
+import (
+	"net/netip"
+	"sync/atomic"
+	"time"
+)
+
+// TODO: Remove
+func newRemotePeer(ip byte) *remotePeer {
+	counter := uint64(time.Now().Unix()<<30 + 1)
+	return &remotePeer{
+		IP:       ip,
+		counter:  &counter,
+		dupCheck: newDupCheck(0),
+	}
+}
+
+// ----------------------------------------------------------------------------
+
+type remotePeer struct {
+	localIP       byte
+	IP            byte           // VPN IP of peer (last byte).
+	Up            bool           // True if data can be sent on the peer.
+	Relay         bool           // True if the peer is a relay.
+	Direct        bool           // True if this is a direct connection.
+	DirectAddr    netip.AddrPort // Remote address if directly connected.
+	PubSignKey    []byte
+	ControlCipher *controlCipher
+	DataCipher    *dataCipher
+
+	counter  *uint64   // For sending to. Atomic access only.
+	dupCheck *dupCheck // For receiving from. Not safe for concurrent use.
+}
+
+func (p remotePeer) EncryptDataPacket(destIP byte, data, out []byte) []byte {
+	h := header{
+		StreamID: dataStreamID,
+		Counter:  atomic.AddUint64(p.counter, 1),
+		SourceIP: p.localIP,
+		DestIP:   destIP,
+	}
+	return p.DataCipher.Encrypt(h, data, out)
+}
+
+// Decrypts and de-dups incoming data packets.
+func (p remotePeer) DecryptDataPacket(h header, enc, out []byte) ([]byte, error) {
+	dec, ok := p.DataCipher.Decrypt(enc, out)
+	if !ok {
+		return nil, errDecryptionFailed
+	}
+
+	if p.dupCheck.IsDup(h.Counter) {
+		return nil, errDuplicateSeqNum
+	}
+
+	return dec, nil
+}
+
+// Peer must have a ControlCipher.
+func (p remotePeer) EncryptControlPacket(pkt marshaller, tmp, out []byte) []byte {
+	tmp = pkt.Marshal(tmp)
+	h := header{
+		StreamID: controlStreamID,
+		Counter:  atomic.AddUint64(p.counter, 1),
+		SourceIP: p.localIP,
+		DestIP:   p.IP,
+	}
+
+	return p.ControlCipher.Encrypt(h, tmp, out)
+}
+
+// Returns a controlMsg[PacketType]. Peer must have a non-nil ControlCipher.
+//
+// This function also drops packets with duplicate sequence numbers.
+func (p remotePeer) DecryptControlPacket(fromAddr netip.AddrPort, h header, enc, tmp []byte) (any, error) {
+	out, ok := p.ControlCipher.Decrypt(enc, tmp)
+	if !ok {
+		return nil, errDecryptionFailed
+	}
+
+	if p.dupCheck.IsDup(h.Counter) {
+		return nil, errDuplicateSeqNum
+	}
+
+	msg, err := parseControlMsg(h.SourceIP, fromAddr, out)
+	if err != nil {
+		return nil, err
+	}
+
+	return msg, nil
+}
+
+// ----------------------------------------------------------------------------
+
+type routingTable struct {
+	// The LocalIP is the configured IP address of the local peer on the VPN.
+	//
+	// This value is constant.
+	LocalIP byte
+
+	// The LocalAddr is the configured local public address of the peer on the
+	// internet. If LocalAddr.IsValid(), then the local peer has a public
+	// address.
+	//
+	// This value is constant.
+	LocalAddr netip.AddrPort
+
+	// The remote peer configurations. These are updated by
+	Peers [256]remotePeer
+
+	// The current relay's VPN IP address, or zero if no relay is available.
+	RelayIP byte
+}
+
+func newRoutingTable(localIP byte, localAddr netip.AddrPort) routingTable {
+	rt := routingTable{
+		LocalIP:   localIP,
+		LocalAddr: localAddr,
+	}
+
+	for i := range rt.Peers {
+		counter := uint64(time.Now().Unix()<<30 + 1)
+		rt.Peers[i] = remotePeer{
+			localIP:  localIP,
+			IP:       byte(i),
+			counter:  &counter,
+			dupCheck: newDupCheck(0),
+		}
+	}
+
+	return rt
+}
+
+func (rt *routingTable) GetRelay() (remotePeer, bool) {
+	relay := rt.Peers[rt.RelayIP]
+	return relay, relay.Up && relay.Direct
+}

peer/routingtable_test.go

@@ -0,0 +1,169 @@
+package peer
+
+import (
+	"bytes"
+	"reflect"
+	"testing"
+)
+
+func TestRemotePeer_DecryptDataPacket(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+	orig := RandPacket()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	enc := peer2.EncryptDataPacket(2, orig, newBuf())
+
+	h := parseHeader(enc)
+	if h.DestIP != 2 || h.SourceIP != 1 {
+		t.Fatal(h)
+	}
+
+	dec, err := peer1.DecryptDataPacket(h, enc, newBuf())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if !bytes.Equal(orig, dec) {
+		t.Fatal(dec)
+	}
+}
+
+func TestRemotePeer_DecryptDataPacket_packetAltered(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+	orig := RandPacket()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	enc := peer2.EncryptDataPacket(2, orig, newBuf())
+
+	h := parseHeader(enc)
+
+	for range 2048 {
+		_, err := peer1.DecryptDataPacket(h, ModifyPacket(enc), newBuf())
+		if err == nil {
+			t.Fatal(enc)
+		}
+	}
+}
+
+func TestRemotePeer_DecryptDataPacket_duplicateSequenceNumber(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+	orig := RandPacket()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	enc := peer2.EncryptDataPacket(2, orig, newBuf())
+	h := parseHeader(enc)
+
+	if _, err := peer1.DecryptDataPacket(h, enc, newBuf()); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := peer1.DecryptDataPacket(h, enc, newBuf()); err == nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRemotePeer_DecryptControlPacket(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	orig := packetProbe{TraceID: newTraceID()}
+
+	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
+
+	h := parseHeader(enc)
+	if h.DestIP != 2 || h.SourceIP != 1 {
+		t.Fatal(h)
+	}
+
+	ctrlMsg, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf())
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	dec, ok := ctrlMsg.(controlMsg[packetProbe])
+	if !ok {
+		t.Fatal(ctrlMsg)
+	}
+
+	if dec.SrcIP != 1 || dec.SrcAddr != p1.RT.Load().LocalAddr {
+		t.Fatal(dec)
+	}
+
+	if !reflect.DeepEqual(dec.Packet, orig) {
+		t.Fatal(dec)
+	}
+}
+
+func TestRemotePeer_DecryptControlPacket_packetAltered(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	orig := packetProbe{TraceID: newTraceID()}
+
+	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
+
+	h := parseHeader(enc)
+	if h.DestIP != 2 || h.SourceIP != 1 {
+		t.Fatal(h)
+	}
+
+	for range 2048 {
+		ctrlMsg, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, ModifyPacket(enc), newBuf())
+		if err == nil {
+			t.Fatal(ctrlMsg)
+		}
+	}
+}
+
+func TestRemotePeer_DecryptControlPacket_duplicateSequenceNumber(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	orig := packetProbe{TraceID: newTraceID()}
+
+	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
+
+	h := parseHeader(enc)
+	if h.DestIP != 2 || h.SourceIP != 1 {
+		t.Fatal(h)
+	}
+
+	if _, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf()); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf()); err == nil {
+		t.Fatal(err)
+	}
+}
+
+func TestRemotePeer_DecryptControlPacket_unknownPacketType(t *testing.T) {
+	p1, p2, _ := NewPeersForTesting()
+
+	peer2 := p1.RT.Load().Peers[2]
+	peer1 := p2.RT.Load().Peers[1]
+
+	orig := UnknownControlPacket{TraceID: newTraceID()}
+
+	enc := peer2.EncryptControlPacket(orig, newBuf(), newBuf())
+
+	h := parseHeader(enc)
+	if h.DestIP != 2 || h.SourceIP != 1 {
+		t.Fatal(h)
+	}
+
+	if _, err := peer1.DecryptControlPacket(p1.RT.Load().LocalAddr, h, enc, newBuf()); err == nil {
+		t.Fatal(err)
+	}
+}

peer/state-client.go

@@ -0,0 +1,162 @@
+package peer
+
+import (
+	"net/netip"
+	"time"
+)
+
+type sentProbe struct {
+	SentAt time.Time
+	Addr   netip.AddrPort
+}
+
+type stateClient struct {
+	*peerData
+	lastSeen time.Time
+	syn      packetSyn
+	probes   map[uint64]sentProbe
+}
+
+func enterStateClient(data *peerData) peerState {
+	ip, ipValid := netip.AddrFromSlice(data.peer.PublicIP)
+
+	data.staged.Relay = data.peer.Relay && ipValid
+	data.staged.Direct = ipValid
+	data.staged.DirectAddr = netip.AddrPortFrom(ip, data.peer.Port)
+	data.publish(data.staged)
+
+	state := &stateClient{
+		peerData: data,
+		lastSeen: time.Now(),
+		syn: packetSyn{
+			TraceID:       newTraceID(),
+			SharedKey:     data.staged.DataCipher.Key(),
+			Direct:        data.staged.Direct,
+			PossibleAddrs: data.pubAddrs.Get(),
+		},
+		probes: map[uint64]sentProbe{},
+	}
+
+	state.Send(state.staged, state.syn)
+
+	data.pingTimer.Reset(pingInterval)
+
+	state.logf("==> Client")
+	return state
+}
+
+func (s *stateClient) logf(str string, args ...any) {
+	s.peerData.logf("CLNT | "+str, args...)
+}
+
+func (s *stateClient) OnMsg(raw any) peerState {
+	switch msg := raw.(type) {
+	case peerUpdateMsg:
+		return initPeerState(s.peerData, msg.Peer)
+	case controlMsg[packetAck]:
+		s.onAck(msg)
+	case controlMsg[packetProbe]:
+		return s.onProbe(msg)
+	case controlMsg[packetLocalDiscovery]:
+		s.onLocalDiscovery(msg)
+	case pingTimerMsg:
+		return s.onPingTimer()
+	default:
+		s.logf("Ignoring message: %v", raw)
+	}
+	return s
+}
+
+func (s *stateClient) onAck(msg controlMsg[packetAck]) {
+	if msg.Packet.TraceID != s.syn.TraceID {
+		return
+	}
+
+	s.lastSeen = time.Now()
+
+	if !s.staged.Up {
+		s.staged.Up = true
+		s.publish(s.staged)
+		s.logf("Got ACK.")
+	}
+
+	if s.staged.Direct {
+		s.pubAddrs.Store(msg.Packet.ToAddr)
+		return
+	}
+
+	// Relayed below.
+
+	s.cleanProbes()
+
+	for _, addr := range msg.Packet.PossibleAddrs {
+		if !addr.IsValid() {
+			break
+		}
+		s.sendProbeTo(addr)
+	}
+}
+
+func (s *stateClient) onPingTimer() peerState {
+	if time.Since(s.lastSeen) > timeoutInterval {
+		if s.staged.Up {
+			s.logf("Timeout.")
+		}
+		return initPeerState(s.peerData, s.peer)
+	}
+
+	s.Send(s.staged, s.syn)
+	return s
+}
+
+func (s *stateClient) onProbe(msg controlMsg[packetProbe]) peerState {
+	if s.staged.Direct {
+		return s
+	}
+
+	s.cleanProbes()
+
+	sent, ok := s.probes[msg.Packet.TraceID]
+	if !ok {
+		return s
+	}
+
+	s.staged.Direct = true
+	s.staged.DirectAddr = sent.Addr
+	s.publish(s.staged)
+
+	s.syn.TraceID = newTraceID()
+	s.syn.Direct = true
+	s.Send(s.staged, s.syn)
+	s.logf("Successful probe to %v.", sent.Addr)
+	return s
+}
+
+func (s *stateClient) onLocalDiscovery(msg controlMsg[packetLocalDiscovery]) {
+	if s.staged.Direct {
+		return
+	}
+
+	// The source port will be the multicast port, so we'll have to
+	// construct the correct address using the peer's listed port.
+	addr := netip.AddrPortFrom(msg.SrcAddr.Addr(), s.peer.Port)
+	s.sendProbeTo(addr)
+}
+
+func (s *stateClient) cleanProbes() {
+	for key, sent := range s.probes {
+		if time.Since(sent.SentAt) > pingInterval {
+			delete(s.probes, key)
+		}
+	}
+}
+
+func (s *stateClient) sendProbeTo(addr netip.AddrPort) {
+	probe := packetProbe{TraceID: newTraceID()}
+	s.probes[probe.TraceID] = sentProbe{
+		SentAt: time.Now(),
+		Addr:   addr,
+	}
+	s.logf("Probing %v...", addr)
+	s.SendTo(probe, addr)
+}

peer/state-client_test.go

@@ -0,0 +1,193 @@
+package peer
+
+import (
+	"testing"
+	"time"
+)
+
+func TestStateClient_peerUpdate(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+	h.PeerUpdate(nil)
+	assertType[*stateDisconnected](t, h.State)
+}
+
+func TestStateClient_initialPackets(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	assertEqual(t, len(h.Sent), 2)
+	assertType[packetInit](t, h.Sent[0].Packet)
+	assertType[packetSyn](t, h.Sent[1].Packet)
+}
+
+func TestStateClient_onAck_incorrectTraceID(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+	h.Sent = h.Sent[:0]
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: newTraceID()},
+	}
+	h.OnAck(ack)
+
+	// Nothing should have happened.
+	assertType[*stateClient](t, h.State)
+	assertEqual(t, len(h.Sent), 0)
+}
+
+func TestStateClient_onAck_direct_downToUp(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	assertEqual(t, len(h.Sent), 2)
+	syn := assertType[packetSyn](t, h.Sent[1].Packet)
+	h.Sent = h.Sent[:0]
+
+	assertEqual(t, h.Published.Up, false)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID},
+	}
+
+	h.OnAck(ack)
+
+	assertEqual(t, len(h.Sent), 0)
+}
+
+func TestStateClient_onAck_relayed_sendsProbes(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	assertEqual(t, len(h.Sent), 2)
+	syn := assertType[packetSyn](t, h.Sent[1].Packet)
+	h.Sent = h.Sent[:0]
+
+	assertEqual(t, h.Published.Up, false)
+
+	ack := controlMsg[packetAck]{
+		Packet: packetAck{TraceID: syn.TraceID},
+	}
+	ack.Packet.PossibleAddrs[0] = addrPort4(1, 2, 3, 4, 100)
+	ack.Packet.PossibleAddrs[1] = addrPort4(2, 3, 4, 5, 200)
+
+	h.OnAck(ack)
+
+	assertEqual(t, len(h.Sent), 2)
+	assertType[packetProbe](t, h.Sent[0].Packet)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, ack.Packet.PossibleAddrs[0])
+	assertType[packetProbe](t, h.Sent[1].Packet)
+	assertEqual(t, h.Sent[1].Peer.DirectAddr, ack.Packet.PossibleAddrs[1])
+}
+
+func TestStateClient_onPing(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+	h.Sent = h.Sent[:0]
+	h.OnPingTimer()
+	assertEqual(t, len(h.Sent), 1)
+	assertType[*stateClient](t, h.State)
+	assertType[packetSyn](t, h.Sent[0].Packet)
+}
+
+func TestStateClient_onPing_timeout(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+	h.Sent = h.Sent[:0]
+	state := assertType[*stateClient](t, h.State)
+	state.lastSeen = time.Now().Add(-2 * timeoutInterval)
+	state.staged.Up = true
+	h.OnPingTimer()
+
+	newState := assertType[*stateClientInit](t, h.State)
+	assertEqual(t, newState.staged.Up, false)
+	assertEqual(t, len(h.Sent), 1)
+	assertType[packetInit](t, h.Sent[0].Packet)
+}
+
+func TestStateClient_onProbe_direct(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	h.Sent = h.Sent[:0]
+	probe := controlMsg[packetProbe]{
+		Packet: packetProbe{
+			TraceID: newTraceID(),
+		},
+	}
+
+	h.OnProbe(probe)
+	assertType[*stateClient](t, h.State)
+	assertEqual(t, len(h.Sent), 0)
+}
+
+func TestStateClient_onProbe_noMatch(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	h.Sent = h.Sent[:0]
+	probe := controlMsg[packetProbe]{
+		Packet: packetProbe{
+			TraceID: newTraceID(),
+		},
+	}
+
+	h.OnProbe(probe)
+	assertType[*stateClient](t, h.State)
+	assertEqual(t, len(h.Sent), 0)
+}
+
+func TestStateClient_onProbe_directUpgrade(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	state := assertType[*stateClient](t, h.State)
+	traceID := newTraceID()
+	state.probes[traceID] = sentProbe{
+		SentAt: time.Now(),
+		Addr:   addrPort4(1, 2, 3, 4, 500),
+	}
+
+	probe := controlMsg[packetProbe]{
+		Packet: packetProbe{TraceID: traceID},
+	}
+
+	assertEqual(t, h.Published.Direct, false)
+	h.Sent = h.Sent[:0]
+	h.OnProbe(probe)
+	assertEqual(t, h.Published.Direct, true)
+
+	assertEqual(t, len(h.Sent), 1)
+	assertType[packetSyn](t, h.Sent[0].Packet)
+}
+
+func TestStateClient_onLocalDiscovery_direct(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientDirect(t)
+
+	h.Sent = h.Sent[:0]
+	pkt := controlMsg[packetLocalDiscovery]{
+		Packet: packetLocalDiscovery{},
+	}
+
+	h.OnLocalDiscovery(pkt)
+	assertType[*stateClient](t, h.State)
+	assertEqual(t, len(h.Sent), 0)
+}
+
+func TestStateClient_onLocalDiscovery_relayed(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientRelayed(t)
+
+	h.Sent = h.Sent[:0]
+	pkt := controlMsg[packetLocalDiscovery]{
+		SrcAddr: addrPort4(1, 2, 3, 4, 500),
+		Packet:  packetLocalDiscovery{},
+	}
+
+	h.OnLocalDiscovery(pkt)
+	assertType[*stateClient](t, h.State)
+	assertEqual(t, len(h.Sent), 1)
+	assertType[packetProbe](t, h.Sent[0].Packet)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, addrPort4(1, 2, 3, 4, 456))
+}

peer/state-clientinit.go

@@ -0,0 +1,104 @@
+package peer
+
+import (
+	"net/netip"
+	"time"
+)
+
+type stateClientInit struct {
+	*peerData
+	startedAt time.Time
+	traceID   uint64
+}
+
+func enterStateClientInit(data *peerData) peerState {
+	ip, ipValid := netip.AddrFromSlice(data.peer.PublicIP)
+
+	data.staged.Up = false
+	data.staged.Relay = false
+	data.staged.Direct = ipValid
+	data.staged.DirectAddr = netip.AddrPortFrom(ip, data.peer.Port)
+	data.staged.PubSignKey = data.peer.PubSignKey
+	data.staged.ControlCipher = newControlCipher(data.privKey, data.peer.PubKey)
+	data.staged.DataCipher = newDataCipher()
+
+	data.publish(data.staged)
+
+	state := &stateClientInit{
+		peerData:  data,
+		startedAt: time.Now(),
+		traceID:   newTraceID(),
+	}
+	state.sendInit()
+
+	data.pingTimer.Reset(pingInterval)
+
+	state.logf("==> ClientInit")
+	return state
+}
+
+func (s *stateClientInit) logf(str string, args ...any) {
+	s.peerData.logf("INIT | "+str, args...)
+}
+
+func (s *stateClientInit) OnMsg(raw any) peerState {
+	switch msg := raw.(type) {
+	case peerUpdateMsg:
+		return initPeerState(s.peerData, msg.Peer)
+	case controlMsg[packetInit]:
+		return s.onInit(msg)
+	case controlMsg[packetSyn]:
+		s.logf("Unexpected SYN")
+		return s
+	case controlMsg[packetAck]:
+		s.logf("Unexpected ACK")
+		return s
+	case controlMsg[packetProbe]:
+		return s
+	case controlMsg[packetLocalDiscovery]:
+		return s
+	case pingTimerMsg:
+		return s.onPing()
+	default:
+		s.logf("Ignoring message: %#v", raw)
+		return s
+	}
+}
+
+func (s *stateClientInit) onInit(msg controlMsg[packetInit]) peerState {
+	if msg.Packet.TraceID != s.traceID {
+		s.logf("Invalid trace ID on INIT.")
+		return s
+	}
+	s.logf("Got INIT version %d.", msg.Packet.Version)
+	return enterStateClient(s.peerData)
+}
+
+func (s *stateClientInit) onPing() peerState {
+	if time.Since(s.startedAt) < timeoutInterval {
+		s.sendInit()
+		return s
+	}
+
+	if s.staged.Direct {
+		s.staged.Direct = false
+		s.publish(s.staged)
+		s.startedAt = time.Now()
+		s.sendInit()
+		s.logf("Direct connection failed. Attempting indirect connection.")
+		return s
+	}
+
+	s.logf("Timeout.")
+	return initPeerState(s.peerData, s.peer)
+}
+
+func (s *stateClientInit) sendInit() {
+	s.traceID = newTraceID()
+	init := packetInit{
+		TraceID: s.traceID,
+		Direct:  s.staged.Direct,
+		Version: version,
+	}
+	s.Send(s.staged, init)
+}

peer/state-clientinit_test.go

@@ -0,0 +1,92 @@
+package peer
+
+import (
+	"testing"
+	"time"
+)
+
+func TestPeerState_ClientInit_initWithIncorrectTraceID(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientInit(t)
+
+	// Should have sent the first init packet.
+	assertEqual(t, len(h.Sent), 1)
+	init := assertType[packetInit](t, h.Sent[0].Packet)
+
+	init.TraceID = newTraceID()
+	h.OnInit(controlMsg[packetInit]{Packet: init})
+
+	assertType[*stateClientInit](t, h.State)
+}
+
+func TestPeerState_ClientInit_init(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientInit(t)
+
+	// Should have sent the first init packet.
+	assertEqual(t, len(h.Sent), 1)
+	init := assertType[packetInit](t, h.Sent[0].Packet)
+	h.OnInit(controlMsg[packetInit]{Packet: init})
+
+	assertType[*stateClient](t, h.State)
+}
+
+func TestPeerState_ClientInit_onPing(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientInit(t)
+
+	// Should have sent the first init packet.
+	assertEqual(t, len(h.Sent), 1)
+	h.Sent = h.Sent[:0]
+
+	for range 3 {
+		h.OnPingTimer()
+	}
+
+	assertEqual(t, len(h.Sent), 3)
+
+	for i := range h.Sent {
+		assertType[packetInit](t, h.Sent[i].Packet)
+	}
+}
+
+func TestPeerState_ClientInit_onPingTimeout(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientInit(t)
+
+	state := assertType[*stateClientInit](t, h.State)
+	state.startedAt = time.Now().Add(-2 * timeoutInterval)
+	assertEqual(t, state.staged.Direct, true)
+
+	h.OnPingTimer()
+
+	// Should now try indirect connection.
+	state = assertType[*stateClientInit](t, h.State)
+	assertEqual(t, state.staged.Direct, false)
+
+	// Should re-initialize the peer after another timeout, so should be direct
+	// again.
+	state.startedAt = time.Now().Add(-2 * timeoutInterval)
+	h.OnPingTimer()
+
+	assertEqual(t, state.staged.Direct, true)
+}
+
+func TestPeerState_ClientInit_onPeerUpdate(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientInit(t)
+
+	h.PeerUpdate(nil)
+
+	// Should have moved into the client state due to timeout.
+	assertType[*stateDisconnected](t, h.State)
+}
+
+func TestPeerState_ClientInit_ignoreMessage(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigClientInit(t)
+	h.OnProbe(controlMsg[packetProbe]{})
+
+	// Shouldn't do anything.
+	assertType[*stateClientInit](t, h.State)
+}

peer/state-disconnected.go

@@ -0,0 +1,50 @@
+package peer
+
+import "net/netip"
+
+type stateDisconnected struct {
+	*peerData
+}
+
+func enterStateDisconnected(data *peerData) peerState {
+	data.staged.Up = false
+	data.staged.Relay = false
+	data.staged.Direct = false
+	data.staged.DirectAddr = netip.AddrPort{}
+	data.staged.PubSignKey = nil
+	data.staged.ControlCipher = nil
+	data.staged.DataCipher = nil
+
+	data.publish(data.staged)
+
+	data.pingTimer.Stop()
+
+	return &stateDisconnected{data}
+}
+
+func (s *stateDisconnected) OnMsg(raw any) peerState {
+	switch msg := raw.(type) {
+	case peerUpdateMsg:
+		return initPeerState(s.peerData, msg.Peer)
+	case controlMsg[packetInit]:
+		s.logf("Unexpected INIT")
+		return s
+	case controlMsg[packetSyn]:
+		s.logf("Unexpected SYN")
+		return s
+	case controlMsg[packetAck]:
+		s.logf("Unexpected ACK")
+		return s
+	case controlMsg[packetProbe]:
+		s.logf("Unexpected probe")
+		return s
+	case controlMsg[packetLocalDiscovery]:
+		return s
+	case pingTimerMsg:
+		s.logf("Unexpected ping")
+		return s
+	default:
+		s.logf("Ignoring message: %#v", raw)
+		return s
+	}
+}

peer/state-server.go

@@ -0,0 +1,136 @@
+package peer
+
+import (
+	"net/netip"
+	"time"
+)
+
+type stateServer struct {
+	*peerData
+	lastSeen   time.Time
+	synTraceID uint64 // Last syn trace ID.
+}
+
+func enterStateServer(data *peerData) peerState {
+	data.staged.Up = false
+	data.staged.Relay = false
+	data.staged.Direct = false
+	data.staged.DirectAddr = netip.AddrPort{}
+	data.staged.PubSignKey = data.peer.PubSignKey
+	data.staged.ControlCipher = newControlCipher(data.privKey, data.peer.PubKey)
+	data.staged.DataCipher = nil
+
+	data.publish(data.staged)
+
+	data.pingTimer.Reset(pingInterval)
+
+	state := &stateServer{
+		peerData: data,
+		lastSeen: time.Now(),
+	}
+	state.logf("==> Server")
+	return state
+}
+
+func (s *stateServer) logf(str string, args ...any) {
+	s.peerData.logf("SRVR | "+str, args...)
+}
+
+func (s *stateServer) OnMsg(raw any) peerState {
+	switch msg := raw.(type) {
+	case peerUpdateMsg:
+		return initPeerState(s.peerData, msg.Peer)
+	case controlMsg[packetInit]:
+		return s.onInit(msg)
+	case controlMsg[packetSyn]:
+		return s.onSyn(msg)
+	case controlMsg[packetAck]:
+		s.logf("Unexpected ACK")
+		return s
+	case controlMsg[packetProbe]:
+		return s.onProbe(msg)
+	case controlMsg[packetLocalDiscovery]:
+		return s
+	case pingTimerMsg:
+		return s.onPingTimer()
+	default:
+		s.logf("Unexpected message: %#v", raw)
+		return s
+	}
+}
+
+func (s *stateServer) onInit(msg controlMsg[packetInit]) peerState {
+	s.staged.Up = false
+	s.staged.Direct = msg.Packet.Direct
+	s.staged.DirectAddr = msg.SrcAddr
+	s.publish(s.staged)
+
+	init := packetInit{
+		TraceID: msg.Packet.TraceID,
+		Direct:  s.staged.Direct,
+		Version: version,
+	}
+
+	s.Send(s.staged, init)
+
+	return s
+}
+
+func (s *stateServer) onSyn(msg controlMsg[packetSyn]) peerState {
+	s.lastSeen = time.Now()
+	p := msg.Packet
+
+	// Before we can respond to this packet, we need to make sure the
+	// route is setup properly.
+	//
+	// The client will update the syn's TraceID whenever there's a change.
+	// The server will follow the client's request.
+	if p.TraceID != s.synTraceID || !s.staged.Up {
+		s.synTraceID = p.TraceID
+		s.staged.Up = true
+		s.staged.Direct = p.Direct
+		s.staged.DataCipher = newDataCipherFromKey(p.SharedKey)
+		s.staged.DirectAddr = msg.SrcAddr
+		s.publish(s.staged)
+		s.logf("Got SYN.")
+	}
+
+	// Always respond.
+	s.Send(s.staged, packetAck{
+		TraceID:       p.TraceID,
+		ToAddr:        s.staged.DirectAddr,
+		PossibleAddrs: s.pubAddrs.Get(),
+	})
+
+	if p.Direct {
+		return s
+	}
+
+	// Send probes if not a direct connection.
+	for _, addr := range msg.Packet.PossibleAddrs {
+		if !addr.IsValid() {
+			break
+		}
+		s.logf("Probing %v...", addr)
+		s.SendTo(packetProbe{TraceID: newTraceID()}, addr)
+	}
+
+	return s
+}
+
+func (s *stateServer) onProbe(msg controlMsg[packetProbe]) peerState {
+	if msg.SrcAddr.IsValid() {
+		s.logf("Probe response %v...", msg.SrcAddr)
+		s.SendTo(packetProbe{TraceID: msg.Packet.TraceID}, msg.SrcAddr)
+	}
+	return s
+}
+
+func (s *stateServer) onPingTimer() peerState {
+	if time.Since(s.lastSeen) > timeoutInterval && s.staged.Up {
+		s.staged.Up = false
+		s.publish(s.staged)
+		s.logf("Timeout.")
+	}
+	return s
+}

peer/state-server_test.go

@@ -0,0 +1,164 @@
+package peer
+
+import (
+	"testing"
+	"time"
+)
+
+func TestStateServer_peerUpdate(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Public(t)
+	h.PeerUpdate(nil)
+	assertType[*stateDisconnected](t, h.State)
+}
+
+func TestStateServer_onInit(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Public(t)
+
+	msg := controlMsg[packetInit]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 2, 3, 4, 1000),
+		Packet: packetInit{
+			TraceID: newTraceID(),
+			Direct:  true,
+			Version: 4,
+		},
+	}
+
+	h.OnInit(msg)
+	assertEqual(t, len(h.Sent), 1)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
+	resp := assertType[packetInit](t, h.Sent[0].Packet)
+	assertEqual(t, msg.Packet.TraceID, resp.TraceID)
+	assertEqual(t, resp.Version, version)
+}
+
+func TestStateServer_onSynDirect(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Public(t)
+
+	msg := controlMsg[packetSyn]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 2, 3, 4, 1000),
+		Packet: packetSyn{
+			TraceID: newTraceID(),
+			Direct:  true,
+		},
+	}
+
+	msg.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 1000)
+	msg.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 2000)
+
+	h.OnSyn(msg)
+	assertEqual(t, len(h.Sent), 1)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
+	resp := assertType[packetAck](t, h.Sent[0].Packet)
+	assertEqual(t, msg.Packet.TraceID, resp.TraceID)
+}
+
+func TestStateServer_onSynRelayed(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	msg := controlMsg[packetSyn]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 2, 3, 4, 1000),
+		Packet: packetSyn{
+			TraceID: newTraceID(),
+		},
+	}
+
+	msg.Packet.PossibleAddrs[0] = addrPort4(1, 1, 1, 1, 1000)
+	msg.Packet.PossibleAddrs[1] = addrPort4(1, 1, 1, 2, 2000)
+
+	h.OnSyn(msg)
+	assertEqual(t, len(h.Sent), 3)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
+	resp := assertType[packetAck](t, h.Sent[0].Packet)
+	assertEqual(t, msg.Packet.TraceID, resp.TraceID)
+
+	for i, pkt := range h.Sent[1:] {
+		assertEqual(t, pkt.Peer.DirectAddr, msg.Packet.PossibleAddrs[i])
+		assertType[packetProbe](t, pkt.Packet)
+	}
+}
+
+func TestStateServer_onProbe(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	msg := controlMsg[packetProbe]{
+		SrcIP: 3,
+		Packet: packetProbe{
+			TraceID: newTraceID(),
+		},
+	}
+	h.Sent = h.Sent[:0]
+
+	h.OnProbe(msg)
+	assertEqual(t, len(h.Sent), 0)
+}
+
+func TestStateServer_onProbe_valid(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	msg := controlMsg[packetProbe]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 2, 3, 4, 100),
+		Packet: packetProbe{
+			TraceID: newTraceID(),
+		},
+	}
+	h.Sent = h.Sent[:0]
+
+	h.OnProbe(msg)
+	assertEqual(t, len(h.Sent), 1)
+	assertType[packetProbe](t, h.Sent[0].Packet)
+	assertEqual(t, h.Sent[0].Peer.DirectAddr, msg.SrcAddr)
+}
+
+func TestStateServer_onPing(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+	h.Sent = h.Sent[:0]
+	h.OnPingTimer()
+	assertEqual(t, len(h.Sent), 0)
+	assertType[*stateServer](t, h.State)
+}
+
+func TestStateServer_onPing_timeout(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	h.Sent = h.Sent[:0]
+	state := assertType[*stateServer](t, h.State)
+	state.staged.Up = true
+	state.lastSeen = time.Now().Add(-2 * timeoutInterval)
+
+	h.OnPingTimer()
+	state = assertType[*stateServer](t, h.State)
+	assertEqual(t, len(h.Sent), 0)
+	assertEqual(t, state.staged.Up, false)
+}
+
+func TestStateServer_onLocalDiscovery(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+
+	msg := controlMsg[packetLocalDiscovery]{
+		SrcIP:   3,
+		SrcAddr: addrPort4(1, 2, 3, 4, 100),
+	}
+	h.OnLocalDiscovery(msg)
+	assertType[*stateServer](t, h.State)
+}
+
+func TestStateServer_onAck(t *testing.T) {
+	h := NewPeerStateTestHarness()
+	h.ConfigServer_Relayed(t)
+	msg := controlMsg[packetAck]{}
+	h.OnAck(msg)
+	assertType[*stateServer](t, h.State)
+}

peer/state-util_test.go

@@ -0,0 +1,151 @@
+package peer
+
+import (
+	"net/netip"
+	"testing"
+	"time"
+	"vppn/m"
+
+	"git.crumpington.com/lib/go/ratelimiter"
+)
+
+type PeerStateControlMsg struct {
+	Peer   remotePeer
+	Packet any
+}
+
+type PeerStateTestHarness struct {
+	data      *peerData
+	State     peerState
+	Published remotePeer
+	Sent      []PeerStateControlMsg
+}
+
+func NewPeerStateTestHarness() *PeerStateTestHarness {
+	h := &PeerStateTestHarness{}
+
+	keys := generateKeys()
+
+	state := &peerData{
+		publish: func(rp remotePeer) {
+			h.Published = rp
+		},
+		sendControlPacket: func(rp remotePeer, pkt marshaller) {
+			h.Sent = append(h.Sent, PeerStateControlMsg{rp, pkt})
+		},
+		pingTimer: time.NewTicker(pingInterval),
+		localIP:   2,
+		remoteIP:  3,
+		privKey:   keys.PrivKey,
+		pubAddrs:  newPubAddrStore(netip.AddrPort{}),
+		limiter: ratelimiter.New(ratelimiter.Config{
+			FillPeriod:   20 * time.Millisecond,
+			MaxWaitCount: 1,
+		}),
+	}
+	h.data = state
+
+	h.State = enterStateDisconnected(state)
+	return h
+}
+
+func (h *PeerStateTestHarness) PeerUpdate(p *m.Peer) {
+	h.State = h.State.OnMsg(peerUpdateMsg{p})
+}
+
+func (h *PeerStateTestHarness) OnInit(msg controlMsg[packetInit]) {
+	h.State = h.State.OnMsg(msg)
+}
+
+func (h *PeerStateTestHarness) OnSyn(msg controlMsg[packetSyn]) {
+	h.State = h.State.OnMsg(msg)
+}
+
+func (h *PeerStateTestHarness) OnAck(msg controlMsg[packetAck]) {
+	h.State = h.State.OnMsg(msg)
+}
+
+func (h *PeerStateTestHarness) OnProbe(msg controlMsg[packetProbe]) {
+	h.State = h.State.OnMsg(msg)
+}
+
+func (h *PeerStateTestHarness) OnLocalDiscovery(msg controlMsg[packetLocalDiscovery]) {
+	h.State = h.State.OnMsg(msg)
+}
+
+func (h *PeerStateTestHarness) OnPingTimer() {
+	h.State = h.State.OnMsg(pingTimerMsg{})
+}
+
+func (h *PeerStateTestHarness) ConfigServer_Public(t *testing.T) *stateServer {
+	keys := generateKeys()
+
+	state := h.State.(*stateDisconnected)
+	state.localAddr = addrPort4(1, 1, 1, 2, 200)
+
+	peer := &m.Peer{
+		PeerIP:     3,
+		PublicIP:   []byte{1, 1, 1, 3},
+		Port:       456,
+		PubKey:     keys.PubKey,
+		PubSignKey: keys.PubSignKey,
+	}
+
+	h.PeerUpdate(peer)
+	assertEqual(t, h.Published.Up, false)
+	return assertType[*stateServer](t, h.State)
+}
+
+func (h *PeerStateTestHarness) ConfigServer_Relayed(t *testing.T) *stateServer {
+	keys := generateKeys()
+	peer := &m.Peer{
+		PeerIP:     3,
+		Port:       456,
+		PubKey:     keys.PubKey,
+		PubSignKey: keys.PubSignKey,
+	}
+
+	h.PeerUpdate(peer)
+	assertEqual(t, h.Published.Up, false)
+	return assertType[*stateServer](t, h.State)
+}
+
+func (h *PeerStateTestHarness) ConfigClientInit(t *testing.T) *stateClientInit {
+	// Remote IP should be less than local IP.
+	h.data.localIP = 4
+	keys := generateKeys()
+	peer := &m.Peer{
+		PeerIP:     3,
+		PublicIP:   []byte{1, 2, 3, 4},
+		Port:       456,
+		PubKey:     keys.PubKey,
+		PubSignKey: keys.PubSignKey,
+	}
+
+	h.PeerUpdate(peer)
+	assertEqual(t, h.Published.Up, false)
+	return assertType[*stateClientInit](t, h.State)
+}
+
+func (h *PeerStateTestHarness) ConfigClientDirect(t *testing.T) *stateClient {
+	h.ConfigClientInit(t)
+	init := assertType[packetInit](t, h.Sent[0].Packet)
+	h.OnInit(controlMsg[packetInit]{
+		Packet: init,
+	})
+
+	return assertType[*stateClient](t, h.State)
+}
+
+func (h *PeerStateTestHarness) ConfigClientRelayed(t *testing.T) *stateClient {
+	h.ConfigClientInit(t)
+	state := assertType[*stateClientInit](t, h.State)
+	state.peer.PublicIP = nil // Force relay.
+
+	init := assertType[packetInit](t, h.Sent[0].Packet)
+	h.OnInit(controlMsg[packetInit]{
+		Packet: init,
+	})
+
+	return assertType[*stateClient](t, h.State)
+}

peer/statedata.go

@@ -0,0 +1,109 @@
+package peer
+
+import (
+	"fmt"
+	"log"
+	"net/netip"
+	"strings"
+	"time"
+	"vppn/m"
+
+	"git.crumpington.com/lib/go/ratelimiter"
+)
+
+type peerState interface {
+	OnMsg(raw any) peerState
+}
+
+// ----------------------------------------------------------------------------
+
+type peerData struct {
+	// Output.
+	publish           func(remotePeer)
+	sendControlPacket func(remotePeer, marshaller)
+	pingTimer         *time.Ticker
+
+	// Immutable data.
+	localIP   byte
+	remoteIP  byte
+	privKey   []byte
+	localAddr netip.AddrPort // If valid, then local peer is publicly accessible.
+
+	pubAddrs *pubAddrStore
+
+	// The purpose of this state machine is to manage the RemotePeer object,
+	// publishing it as necessary.
+	staged remotePeer // Local copy of shared data. See publish().
+
+	// Mutable peer data.
+	peer *m.Peer
+
+	// We rate limit per remote endpoint because if we don't we tend to lose
+	// packets.
+	limiter *ratelimiter.Limiter
+}
+
+func (s *peerData) logf(format string, args ...any) {
+	b := strings.Builder{}
+	name := ""
+	if s.peer != nil {
+		name = s.peer.Name
+	}
+	b.WriteString(fmt.Sprintf("%03d", s.remoteIP))
+
+	b.WriteString(fmt.Sprintf("%30s: ", name))
+
+	if s.staged.Direct {
+		b.WriteString("DIRECT  | ")
+	} else {
+		b.WriteString("RELAYED | ")
+	}
+
+	if s.staged.Up {
+		b.WriteString("UP   | ")
+	} else {
+		b.WriteString("DOWN | ")
+	}
+
+	log.Printf(b.String()+format, args...)
+}
+
+// ----------------------------------------------------------------------------
+
+func (s *peerData) SendTo(pkt marshaller, addr netip.AddrPort) {
+	if !addr.IsValid() {
+		return
+	}
+	route := s.staged
+	route.Direct = true
+	route.DirectAddr = addr
+	s.Send(route, pkt)
+}
+
+func (s *peerData) Send(peer remotePeer, pkt marshaller) {
+	if err := s.limiter.Limit(); err != nil {
+		s.logf("Rate limited.")
+		return
+	}
+	s.sendControlPacket(peer, pkt)
+}
+
+func initPeerState(data *peerData, peer *m.Peer) peerState {
+	data.peer = peer
+
+	if peer == nil {
+		return enterStateDisconnected(data)
+	}
+
+	if _, isValid := netip.AddrFromSlice(peer.PublicIP); isValid {
+		if data.localAddr.IsValid() && data.localIP < data.remoteIP {
+			return enterStateServer(data)
+		}
+		return enterStateClientInit(data)
+	}
+
+	if data.localAddr.IsValid() || data.localIP < data.remoteIP {
+		return enterStateServer(data)
+	}
+	return enterStateClientInit(data)
+}

peer/util_test.go

@@ -0,0 +1,26 @@
+package peer
+
+import (
+	"net/netip"
+	"testing"
+)
+
+func addrPort4(a, b, c, d byte, port uint16) netip.AddrPort {
+	return netip.AddrPortFrom(netip.AddrFrom4([4]byte{a, b, c, d}), port)
+}
+
+func assertType[T any](t *testing.T, obj any) T {
+	t.Helper()
+	x, ok := obj.(T)
+	if !ok {
+		t.Fatalf("invalid type: %#v", obj)
+	}
+	return x
+}
+
+func assertEqual[T comparable](t *testing.T, a, b T) {
+	t.Helper()
+	if a != b {
+		t.Fatal(a, " != ", b)
+	}
+}

stage1/README.md

@@ -1 +0,0 @@
-## Stage1: Point-to-point Tunnel w/ no Encryption

stage1/client.go

@@ -1,32 +0,0 @@
-package stage1
-
-import (
-	"fmt"
-	"net"
-	"net/netip"
-	"runtime/debug"
-)
-
-func RunClient(serverAddrStr string) {
-	defer func() {
-		if r := recover(); r != nil {
-			fmt.Printf("%v", r)
-			debug.PrintStack()
-		}
-	}()
-
-	iface, err := openInterface(network, clientIP, netName)
-	must(err)
-
-	myAddr, err := net.ResolveUDPAddr("udp", fmt.Sprintf(":%d", port))
-	must(err)
-
-	conn, err := net.ListenUDP("udp", myAddr)
-	must(err)
-
-	serverAddr, err := netip.ParseAddrPort(fmt.Sprintf("%s:%d", serverAddrStr, port))
-	must(err)
-
-	go readFromIFace(iface, conn, serverIP, serverAddr)
-	readFromConn(iface, conn)
-}

stage1/cmd/client/build.sh

@@ -1,7 +0,0 @@
-#!/bin/bash
-
-go build
-
-scp client kevin:/home/jdl/tmp
-ssh root@home "setcap cap_net_admin+iep /home/jdl/tmp/client"
-ssh home "/home/jdl/tmp/client 192.168.1.21"

stage1/cmd/client/main.go

@@ -1,14 +0,0 @@
-package main
-
-import (
-	"log"
-	"os"
-	"vppn/stage1"
-)
-
-func main() {
-	if len(os.Args) != 2 {
-		log.Fatalf("Usage: %s <addr:port>", os.Args[0])
-	}
-	stage1.RunClient(os.Args[1])
-}