168 lines
3.2 KiB
Go
168 lines
3.2 KiB
Go
// TODO: slice bounds checking
|
|
// TODO: authentication
|
|
// TODO: encryption
|
|
// TODO: somehow persist IPs
|
|
// TODO: handle multiple peers behind one NAT
|
|
package main
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/binary"
|
|
"log"
|
|
"net"
|
|
"os"
|
|
"sync"
|
|
|
|
"baalvpn/shared"
|
|
)
|
|
|
|
type Peer struct {
|
|
RealAddr *net.UDPAddr
|
|
InternalIP string
|
|
}
|
|
|
|
var (
|
|
peers = map[string]*Peer{}
|
|
peersMutex sync.Mutex
|
|
conn *net.UDPConn
|
|
)
|
|
|
|
func main() {
|
|
if os.Geteuid() != 0 {
|
|
panic("root permissions needed")
|
|
}
|
|
|
|
receivePackets()
|
|
}
|
|
|
|
func receivePackets() {
|
|
log.Println("Listening for packets...")
|
|
|
|
listenAddr, err := net.ResolveUDPAddr("udp", ":38000")
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
conn, err = net.ListenUDP("udp", listenAddr)
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
defer conn.Close()
|
|
|
|
for {
|
|
buffer := make([]byte, 50000)
|
|
n, addr, err := conn.ReadFromUDP(buffer)
|
|
if err != nil {
|
|
log.Println(err)
|
|
continue
|
|
}
|
|
if n == 0 {
|
|
continue
|
|
}
|
|
|
|
go receivePacket(buffer[:n], addr)
|
|
}
|
|
}
|
|
|
|
func receivePacket(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:])
|
|
|
|
// idk if it needs to lock the mutex
|
|
peer := peers[addr.IP.String()]
|
|
|
|
switch pktType {
|
|
case shared.REQ_REGISTER:
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
|
|
internalIP := randomIP().String()
|
|
|
|
if destPeer, ok := peers[addr.IP.String()]; ok {
|
|
internalIP = destPeer.InternalIP
|
|
} else {
|
|
peers[addr.IP.String()] = &Peer{
|
|
RealAddr: addr,
|
|
InternalIP: internalIP,
|
|
}
|
|
}
|
|
|
|
resp := shared.BuildPkt(shared.RESP_REGISTER, net.ParseIP(internalIP))
|
|
sendTo(addr, resp)
|
|
case shared.REQ_DATA:
|
|
frame := pkt[4:]
|
|
etherType := binary.BigEndian.Uint16(frame[12:14])
|
|
payload := frame[14:]
|
|
|
|
switch etherType {
|
|
case 0x86dd: // IPv6
|
|
rawDestIP := payload[24:40]
|
|
destIP := net.IP(rawDestIP).String()
|
|
resp := shared.BuildPkt(shared.RESP_DATA, frame)
|
|
|
|
if rawDestIP[0] == 0xff { // multicast
|
|
log.Println(peer.InternalIP + " -> " + destIP + " (*)")
|
|
broadcast(resp, peer.InternalIP)
|
|
} else if destPeer := getPeerByInternalIP(destIP); destPeer != nil {
|
|
log.Println(peer.InternalIP + " -> " + destIP)
|
|
sendTo(destPeer.RealAddr, resp)
|
|
} else {
|
|
log.Println(peer.InternalIP + " -/> " + destIP + " (unrecognized IP)")
|
|
}
|
|
default:
|
|
log.Printf("unhandled EtherType: 0x%x\n", etherType)
|
|
}
|
|
default:
|
|
log.Println("unknown packet type")
|
|
}
|
|
}
|
|
|
|
func broadcast(pkt []byte, except string) {
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
for _, p := range peers {
|
|
if p.InternalIP == except {
|
|
continue
|
|
}
|
|
sendTo(p.RealAddr, pkt)
|
|
}
|
|
}
|
|
|
|
func sendTo(addr *net.UDPAddr, pkt []byte) {
|
|
if _, err := conn.WriteToUDP(pkt, addr); err != nil {
|
|
log.Println(err)
|
|
}
|
|
}
|
|
|
|
func getPeerByInternalIP(internalIP string) *Peer {
|
|
peersMutex.Lock()
|
|
defer peersMutex.Unlock()
|
|
for _, p := range peers {
|
|
if p.InternalIP == internalIP {
|
|
return p
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// fd00:baa1::/32
|
|
func randomIP() net.IP {
|
|
ip := make(net.IP, 16)
|
|
ip[0] = 0xfd
|
|
ip[1] = 0x00
|
|
ip[2] = 0xba
|
|
ip[3] = 0xa1
|
|
if _, err := rand.Read(ip[4:]); err != nil {
|
|
panic(err)
|
|
}
|
|
return ip
|
|
}
|