Hello, World!

.gitignore

@@ -0,0 +1 @@
+Justfile

client/main.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"encoding/binary"
+	"log"
+	"net"
+	"os"
+
+	"baalvpn/shared"
+)
+
+const SERVER_IP = "172.20.12.47"
+
+var (
+	internalIP net.IP = nil
+)
+
+func main() {
+	if os.Geteuid() != 0 {
+		panic("root permissions needed")
+	}
+
+	listenAddr, err := net.ResolveUDPAddr("udp", ":38001")
+	if err != nil {
+		panic(err)
+	}
+	listener, err := net.ListenUDP("udp", listenAddr)
+	if err != nil {
+		panic(err)
+	}
+	defer listener.Close()
+
+	go receivePackets(listener)
+	register(listener)
+
+	<-make(chan int) // block forever
+}
+
+func register(c *net.UDPConn) {
+	serverAddr, err := net.ResolveUDPAddr("udp", SERVER_IP+":38000")
+	if err != nil {
+		panic(err)
+	}
+
+	req := shared.BuildPkt(shared.REQ_REGISTER, []byte{})
+	if _, err := c.WriteToUDP(req, serverAddr); err != nil {
+		panic(err)
+	}
+}
+
+func receivePackets(listener *net.UDPConn) {
+	for {
+		buffer := make([]byte, 50000)
+		n, addr, err := listener.ReadFromUDP(buffer)
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		if n == 0 {
+			continue
+		}
+
+		go receivePacket(listener, buffer[:n], addr)
+	}
+}
+
+func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
+	if len(pkt) < 4 {
+		log.Println("packet too short")
+		return
+	}
+	version := binary.LittleEndian.Uint16(pkt[0:])
+	if version != shared.PROTO_VERSION {
+		log.Println("mismatched packet version")
+		return
+	}
+
+	pktType := binary.LittleEndian.Uint16(pkt[2:])
+
+	switch pktType {
+	case shared.RESP_REGISTER:
+		internalIP = net.IP(pkt[4:])
+		log.Println("Received IP from the server:", internalIP.String())
+	default:
+		log.Println("unknown packet type")
+	}
+}

go.mod

@@ -0,0 +1,10 @@
+module baalvpn
+
+go 1.26.3
+
+require (
+	github.com/songgao/packets v0.0.0-20160404182456-549a10cd4091
+	github.com/songgao/water v0.0.0-20200317203138-2b4b6d7c09d8
+)
+
+require golang.org/x/sys v0.47.0 // indirect

go.sum

@@ -0,0 +1,6 @@
+github.com/songgao/packets v0.0.0-20160404182456-549a10cd4091 h1:1zN6ImoqhSJhN8hGXFaJlSC8msLmIbX8bFqOfWLKw0w=
+github.com/songgao/packets v0.0.0-20160404182456-549a10cd4091/go.mod h1:N20Z5Y8oye9a7HmytmZ+tr8Q2vlP0tAHP13kTHzwvQY=
+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/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs=
+golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=

server/main.go

@@ -0,0 +1,144 @@
+package main
+
+import (
+	"encoding/binary"
+	"fmt"
+	"log"
+	"net"
+	"os"
+	"os/exec"
+	"sync"
+
+	"baalvpn/shared"
+
+	"github.com/songgao/packets/ethernet"
+	"github.com/songgao/water"
+)
+
+const IFACE_NAME = "baalvpn"
+
+type Peer struct {
+	RealIP     string
+	InternalIP string
+}
+
+var (
+	peers      = map[string]*Peer{}
+	peersMutex sync.Mutex
+	nextIP     = 3
+)
+
+func main() {
+	if os.Geteuid() != 0 {
+		panic("root permissions needed")
+	}
+
+	config := water.Config{DeviceType: water.TAP}
+	config.Name = IFACE_NAME
+
+	iface, err := water.New(config)
+	if err != nil {
+		panic(err)
+	}
+
+	if err := exec.Command("ip", "addr", "add", "10.1.0.10/24", "dev", IFACE_NAME).Run(); err != nil {
+		panic(err)
+	}
+	if err := exec.Command("ip", "link", "set", "dev", IFACE_NAME, "up").Run(); err != nil {
+		panic(err)
+	}
+
+	log.Println("Listening...")
+
+	go receivePackets()
+	sendPackets(iface)
+}
+
+func sendPackets(iface *water.Interface) {
+	var frame ethernet.Frame
+	for {
+		frame.Resize(1500)
+		n, err := iface.Read([]byte(frame))
+		if err != nil {
+			panic(err)
+		}
+		frame = frame[:n]
+
+		if frame.Destination()[0]&0x01 == 0x01 {
+			log.Println("multicast")
+			continue
+		}
+
+		log.Printf("Dst: %s\n", frame.Destination())
+		log.Printf("Src: %s\n", frame.Source())
+		log.Printf("Ethertype: % x\n", frame.Ethertype())
+		log.Printf("Payload: % x\n", frame.Payload())
+	}
+}
+
+func receivePackets() {
+	listenAddr, err := net.ResolveUDPAddr("udp", ":38000")
+	if err != nil {
+		panic(err)
+	}
+	listener, err := net.ListenUDP("udp", listenAddr)
+	if err != nil {
+		panic(err)
+	}
+	defer listener.Close()
+
+	for {
+		buffer := make([]byte, 50000)
+		n, addr, err := listener.ReadFromUDP(buffer)
+		if err != nil {
+			log.Println(err)
+			continue
+		}
+		if n == 0 {
+			continue
+		}
+
+		go receivePacket(listener, buffer[:n], addr)
+	}
+}
+
+func receivePacket(c *net.UDPConn, pkt []byte, addr *net.UDPAddr) {
+	if len(pkt) < 4 {
+		log.Println("packet too short")
+		return
+	}
+	version := binary.LittleEndian.Uint16(pkt[0:])
+	if version != shared.PROTO_VERSION {
+		log.Println("mismatched packet version")
+		return
+	}
+
+	pktType := binary.LittleEndian.Uint16(pkt[2:])
+
+	peerIP := addr.IP.String()
+
+	switch pktType {
+	case shared.REQ_REGISTER:
+		peersMutex.Lock()
+		defer peersMutex.Unlock()
+
+		internalIP := fmt.Sprintf("10.1.0.%d", nextIP)
+
+		if peer, ok := peers[addr.IP.String()]; ok {
+			internalIP = peer.InternalIP
+		} else {
+			peers[addr.IP.String()] = &Peer{
+				RealIP:     peerIP,
+				InternalIP: internalIP,
+			}
+			nextIP++
+		}
+
+		resp := shared.BuildPkt(shared.RESP_REGISTER, net.ParseIP(internalIP).To4())
+		if _, err := c.WriteToUDP(resp, addr); err != nil {
+			log.Printf("register WriteToUDP: %v\n", err)
+		}
+	default:
+		log.Println("unknown packet type")
+	}
+}

shared/proto.go

@@ -0,0 +1,25 @@
+package shared
+
+import "encoding/binary"
+
+const PROTO_VERSION uint16 = 1
+
+const (
+	unused uint16 = iota
+	REQ_REGISTER
+	RESP_REGISTER
+)
+
+func Uint16(v uint16) []byte {
+	out := make([]byte, 2)
+	binary.LittleEndian.PutUint16(out, v)
+	return out
+}
+
+func BuildPkt(pktType uint16, data []byte) []byte {
+	out := make([]byte, 4+len(data))
+	binary.LittleEndian.PutUint16(out[0:], PROTO_VERSION)
+	binary.LittleEndian.PutUint16(out[2:], pktType)
+	copy(out[4:], data)
+	return out
+}