From 8a45d91e8d78ed3e0ed7c5c982743478679feab0 Mon Sep 17 00:00:00 2001 From: Toni Date: Tue, 21 Jul 2026 20:58:05 +0200 Subject: [PATCH] Hello, World! --- .gitignore | 1 + client/main.go | 87 +++++++++++++++++++++++++++++ go.mod | 10 ++++ go.sum | 6 ++ server/main.go | 144 ++++++++++++++++++++++++++++++++++++++++++++++++ shared/proto.go | 25 +++++++++ 6 files changed, 273 insertions(+) create mode 100644 .gitignore create mode 100644 client/main.go create mode 100644 go.mod create mode 100644 go.sum create mode 100644 server/main.go create mode 100644 shared/proto.go diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8c3970a --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +Justfile diff --git a/client/main.go b/client/main.go new file mode 100644 index 0000000..ef4cf47 --- /dev/null +++ b/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") + } +} diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..aa01da9 --- /dev/null +++ b/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 diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..e213a41 --- /dev/null +++ b/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= diff --git a/server/main.go b/server/main.go new file mode 100644 index 0000000..d6fe41b --- /dev/null +++ b/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") + } +} diff --git a/shared/proto.go b/shared/proto.go new file mode 100644 index 0000000..a7d7276 --- /dev/null +++ b/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 +}