"github.com/chon219/water"
)
+var (
+ remoteAddr = flag.String("remote", "", "Remote server address")
+ bindAddr = flag.String("bind", "", "Bind to address")
+ ifaceName = flag.String("iface", "tap0", "TAP network interface")
+ keyHex = flag.String("key", "", "Authentication key")
+ mtu = flag.Int("mtu", 1500, "MTU")
+ timeout = flag.Int("timeout", 60, "Timeout seconds")
+ verbose = flag.Bool("v", false, "Increase verbosity")
+)
+
const (
- NonceSize = 8
- AliveTimeout = time.Second * 90
+ NonceSize = 8
+ KeySize = 32
// S20BS is Salsa20's internal blocksize in bytes
S20BS = 64
)
type Peer struct {
addr *net.UDPAddr
- lastPing time.Time
- key *[32]byte // encryption key
- nonceOur uint64 // nonce for our messages
- nonceRecv uint64 // latest received nonce from remote peer
-}
-
-func (p *Peer) IsAlive() bool {
- if (p == nil) || (p.lastPing.Add(AliveTimeout).Before(time.Now())) {
- return false
- }
- return true
-}
-
-func (p *Peer) SetAlive() {
- p.lastPing = time.Now()
+ key *[KeySize]byte // encryption key
+ nonceOur uint64 // nonce for our messages
+ nonceRecv uint64 // latest received nonce from remote peer
}
type UDPPkt struct {
addr *net.UDPAddr
- data []byte
+ size int
}
-var (
- remoteAddr = flag.String("remote", "", "Remote server address")
- bindAddr = flag.String("bind", "", "Bind to address")
- ifaceName = flag.String("iface", "tap0", "TAP network interface")
- keyHex = flag.String("key", "", "Authentication key")
- mtu = flag.Int("mtu", 1500, "MTU")
- verbose = flag.Bool("v", false, "Increase verbosity")
-)
-
func main() {
flag.Parse()
log.SetFlags(log.Ldate | log.Lmicroseconds | log.Lshortfile)
if err != nil {
panic(err)
}
- key := new([32]byte)
+ key := new([KeySize]byte)
copy(key[:], keyDecoded)
// Interface listening
if err != nil {
panic(err)
}
- ethSink := make(chan []byte)
+ ethBuf := make([]byte, maxIfacePktSize)
+ ethSink := make(chan int)
+ ethSinkReady := make(chan bool)
go func() {
for {
- buf := make([]byte, maxIfacePktSize)
- n, err := iface.Read(buf)
+ <-ethSinkReady
+ n, err := iface.Read(ethBuf)
if err != nil {
panic(err)
}
- ethSink <- buf[:n]
+ ethSink <- n
}
}()
+ ethSinkReady <- true
// Network address parsing
- if (len(*bindAddr) > 1 && len(*remoteAddr) > 1) || (len(*bindAddr) == 0 && len(*remoteAddr) == 0) {
+ if (len(*bindAddr) > 1 && len(*remoteAddr) > 1) ||
+ (len(*bindAddr) == 0 && len(*remoteAddr) == 0) {
panic("Either -bind or -remote must be specified only")
}
-
var conn *net.UDPConn
var remote *net.UDPAddr
-
serverMode := false
bindTo := "0.0.0.0:0"
}
}
- udpSink := make(chan UDPPkt)
- go func(conn *net.UDPConn, sink chan<- UDPPkt) {
+ udpBuf := make([]byte, *mtu)
+ udpSink := make(chan *UDPPkt)
+ udpSinkReady := make(chan bool)
+ go func(conn *net.UDPConn) {
for {
- data := make([]byte, *mtu)
- n, addr, err := conn.ReadFromUDP(data)
+ <-udpSinkReady
+ conn.SetReadDeadline(time.Now().Add(time.Second))
+ n, addr, err := conn.ReadFromUDP(udpBuf)
if err != nil {
- fmt.Print("B")
+ if *verbose {
+ fmt.Print("B")
+ }
+ udpSink <- nil
+ } else {
+ udpSink <- &UDPPkt{addr, n}
}
- sink <- UDPPkt{addr, data[:n]}
}
- }(conn, udpSink)
+ }(conn)
+ udpSinkReady <- true
// Process packets
- var udpPkt UDPPkt
- var ethPkt []byte
+ var udpPkt *UDPPkt
+ var udpPktData []byte
+ var ethPktSize int
var addr string
- var peer Peer
+ var peer *Peer
var p *Peer
- var buf []byte
+ timeouts := 0
states := make(map[string]*Handshake)
nonce := make([]byte, NonceSize)
- keyAuth := new([32]byte)
+ keyAuth := new([KeySize]byte)
tag := new([poly1305.TagSize]byte)
+ buf := make([]byte, *mtu+S20BS)
+ emptyKey := make([]byte, KeySize)
+ ethPkt := make([]byte, maxIfacePktSize)
+ udpPktDataBuf := make([]byte, *mtu)
if !serverMode {
- log.Println("starting handshake with", *remoteAddr)
states[remote.String()] = HandshakeStart(conn, remote, key)
}
+ finished := false
for {
- buf = make([]byte, *mtu+S20BS)
+ if finished {
+ break
+ }
select {
case udpPkt = <-udpSink:
- if isValidHandshakePkt(udpPkt.data) {
+ timeouts++
+ if !serverMode && timeouts >= *timeout {
+ finished = true
+ }
+ if udpPkt == nil {
+ udpSinkReady <- true
+ continue
+ }
+ copy(udpPktDataBuf, udpBuf[:udpPkt.size])
+ udpSinkReady <- true
+ udpPktData = udpPktDataBuf[:udpPkt.size]
+ if isValidHandshakePkt(udpPktData) {
addr = udpPkt.addr.String()
state, exists := states[addr]
if serverMode {
state = &Handshake{addr: udpPkt.addr}
states[addr] = state
}
- p = state.Server(conn, key, udpPkt.data)
+ p = state.Server(conn, key, udpPktData)
} else {
if !exists {
fmt.Print("[HS?]")
continue
}
- p = state.Client(conn, key, udpPkt.data)
+ p = state.Client(conn, key, udpPktData)
}
if p != nil {
fmt.Print("[HS-OK]")
- peer = *p
+ peer = p
delete(states, addr)
}
continue
}
- if !peer.IsAlive() {
+ if peer == nil {
continue
}
- nonceRecv, _ := binary.Uvarint(udpPkt.data[:8])
+ nonceRecv, _ := binary.Uvarint(udpPktData[:8])
if peer.nonceRecv >= nonceRecv {
fmt.Print("R")
continue
}
- copy(tag[:], udpPkt.data[len(udpPkt.data)-poly1305.TagSize:])
- copy(buf[S20BS:], udpPkt.data[NonceSize:len(udpPkt.data)-poly1305.TagSize])
+ copy(buf[:KeySize], emptyKey)
+ copy(tag[:], udpPktData[udpPkt.size-poly1305.TagSize:])
+ copy(buf[S20BS:], udpPktData[NonceSize:udpPkt.size-poly1305.TagSize])
salsa20.XORKeyStream(
- buf[:S20BS+len(udpPkt.data)-poly1305.TagSize],
- buf[:S20BS+len(udpPkt.data)-poly1305.TagSize],
- udpPkt.data[:NonceSize],
+ buf[:S20BS+udpPkt.size-poly1305.TagSize],
+ buf[:S20BS+udpPkt.size-poly1305.TagSize],
+ udpPktData[:NonceSize],
peer.key,
)
- copy(keyAuth[:], buf[:32])
- if !poly1305.Verify(tag, udpPkt.data[:len(udpPkt.data)-poly1305.TagSize], keyAuth) {
+ copy(keyAuth[:], buf[:KeySize])
+ if !poly1305.Verify(tag, udpPktData[:udpPkt.size-poly1305.TagSize], keyAuth) {
fmt.Print("T")
continue
}
peer.nonceRecv = nonceRecv
- peer.SetAlive()
- if _, err := iface.Write(buf[S20BS : S20BS+len(udpPkt.data)-NonceSize-poly1305.TagSize]); err != nil {
+ timeouts = 0
+ if _, err := iface.Write(buf[S20BS : S20BS+udpPkt.size-NonceSize-poly1305.TagSize]); err != nil {
log.Println("Error writing to iface")
}
if *verbose {
fmt.Print("r")
}
- case ethPkt = <-ethSink:
- if len(ethPkt) > maxIfacePktSize {
+ case ethPktSize = <-ethSink:
+ if ethPktSize > maxIfacePktSize {
panic("Too large packet on interface")
}
- if !peer.IsAlive() {
+ if peer == nil {
+ ethSinkReady <- true
continue
}
+ copy(ethPkt, ethBuf[:ethPktSize])
+ ethSinkReady <- true
peer.nonceOur = peer.nonceOur + 2
binary.PutUvarint(nonce, peer.nonceOur)
- copy(buf[S20BS:], ethPkt)
+ copy(buf[:KeySize], emptyKey)
+ copy(buf[S20BS:], ethPkt[:ethPktSize])
salsa20.XORKeyStream(buf, buf, nonce, peer.key)
copy(buf[S20BS-NonceSize:S20BS], nonce)
- copy(keyAuth[:], buf[:32])
- dataToSend := buf[S20BS-NonceSize : S20BS+len(ethPkt)]
+ copy(keyAuth[:], buf[:KeySize])
+ dataToSend := buf[S20BS-NonceSize : S20BS+ethPktSize]
poly1305.Sum(tag, dataToSend, keyAuth)
- _, err := conn.WriteTo(append(dataToSend, tag[:]...), peer.addr)
- if err != nil {
+ if _, err := conn.WriteTo(append(dataToSend, tag[:]...), peer.addr); err != nil {
log.Println("Error sending UDP", err)
}
if *verbose {