wireguard-go/src/peer.go

168 lines
4.7 KiB
Go
Raw Normal View History

package main
import (
"encoding/base64"
2017-06-26 11:14:02 +00:00
"errors"
"fmt"
"sync"
"time"
)
type Peer struct {
id uint
mutex sync.RWMutex
persistentKeepaliveInterval uint64
2017-06-26 11:14:02 +00:00
keyPairs KeyPairs
2017-06-24 13:34:17 +00:00
handshake Handshake
device *Device
endpoint Endpoint
stats struct {
txBytes uint64 // bytes send to peer (endpoint)
rxBytes uint64 // bytes received from peer
lastHandshakeNano int64 // nano seconds since epoch
}
time struct {
2017-07-08 21:51:26 +00:00
mutex sync.RWMutex
lastSend time.Time // last send message
lastHandshake time.Time // last completed handshake
2017-07-08 21:51:26 +00:00
nextKeepalive time.Time
}
signal struct {
newKeyPair chan struct{} // (size 1) : a new key pair was generated
handshakeBegin chan struct{} // (size 1) : request that a new handshake be started ("queue handshake")
handshakeCompleted chan struct{} // (size 1) : handshake completed
handshakeReset chan struct{} // (size 1) : reset handshake negotiation state
flushNonceQueue chan struct{} // (size 1) : empty queued packets
2017-07-08 21:51:26 +00:00
messageSend chan struct{} // (size 1) : a message was send to the peer
messageReceived chan struct{} // (size 1) : an authenticated message was received
stop chan struct{} // (size 0) : close to stop all goroutines for peer
}
timer struct {
// state related to WireGuard timers
keepalivePersistent *time.Timer // set for persistent keepalives
keepalivePassive *time.Timer // set upon recieving messages
2017-07-27 21:45:37 +00:00
newHandshake *time.Timer // begin a new handshake (after Keepalive + RekeyTimeout)
zeroAllKeys *time.Timer // zero all key material (after RejectAfterTime*3)
handshakeDeadline *time.Timer // Current handshake must be completed
2017-07-27 21:45:37 +00:00
pendingKeepalivePassive bool
pendingNewHandshake bool
pendingZeroAllKeys bool
needAnotherKeepalive bool
sendLastMinuteHandshake bool
}
queue struct {
nonce chan *QueueOutboundElement // nonce / pre-handshake queue
outbound chan *QueueOutboundElement // sequential ordering of work
2017-07-01 21:29:22 +00:00
inbound chan *QueueInboundElement // sequential ordering of work
}
2017-08-14 15:09:25 +00:00
mac CookieGenerator
2017-06-24 13:34:17 +00:00
}
func (device *Device) NewPeer(pk NoisePublicKey) (*Peer, error) {
2017-06-26 11:14:02 +00:00
// create peer
peer := new(Peer)
2017-06-26 11:14:02 +00:00
peer.mutex.Lock()
defer peer.mutex.Unlock()
2017-07-01 21:29:22 +00:00
2017-06-27 15:33:06 +00:00
peer.mac.Init(pk)
2017-07-01 21:29:22 +00:00
peer.device = device
2017-07-08 21:51:26 +00:00
peer.timer.keepalivePersistent = NewStoppedTimer()
2017-07-27 21:45:37 +00:00
peer.timer.keepalivePassive = NewStoppedTimer()
peer.timer.newHandshake = NewStoppedTimer()
2017-07-08 21:51:26 +00:00
peer.timer.zeroAllKeys = NewStoppedTimer()
// assign id for debugging
2017-06-24 13:34:17 +00:00
device.mutex.Lock()
peer.id = device.idCounter
device.idCounter += 1
// check if over limit
if len(device.peers) >= MaxPeers {
return nil, errors.New("Too many peers")
}
// map public key
2017-06-26 11:14:02 +00:00
_, ok := device.peers[pk]
if ok {
return nil, errors.New("Adding existing peer")
2017-06-26 11:14:02 +00:00
}
device.peers[pk] = peer
2017-06-24 13:34:17 +00:00
device.mutex.Unlock()
2017-06-26 11:14:02 +00:00
// precompute DH
2017-06-24 13:34:17 +00:00
2017-06-26 11:14:02 +00:00
handshake := &peer.handshake
handshake.mutex.Lock()
handshake.remoteStatic = pk
handshake.precomputedStaticStatic = device.privateKey.sharedSecret(handshake.remoteStatic)
handshake.mutex.Unlock()
2017-06-24 13:34:17 +00:00
// reset endpoint
peer.endpoint = nil
2017-07-01 21:29:22 +00:00
// prepare queuing
peer.queue.nonce = make(chan *QueueOutboundElement, QueueOutboundSize)
2017-07-01 21:29:22 +00:00
peer.queue.outbound = make(chan *QueueOutboundElement, QueueOutboundSize)
peer.queue.inbound = make(chan *QueueInboundElement, QueueInboundSize)
2017-07-01 21:29:22 +00:00
2017-07-08 21:51:26 +00:00
// prepare signaling & routines
peer.signal.stop = make(chan struct{})
peer.signal.newKeyPair = make(chan struct{}, 1)
peer.signal.handshakeBegin = make(chan struct{}, 1)
peer.signal.handshakeReset = make(chan struct{}, 1)
peer.signal.handshakeCompleted = make(chan struct{}, 1)
peer.signal.flushNonceQueue = make(chan struct{}, 1)
go peer.RoutineNonce()
2017-07-08 21:51:26 +00:00
go peer.RoutineTimerHandler()
go peer.RoutineHandshakeInitiator()
go peer.RoutineSequentialSender()
2017-07-01 21:29:22 +00:00
go peer.RoutineSequentialReceiver()
return peer, nil
}
func (peer *Peer) SendBuffer(buffer []byte) error {
peer.device.net.mutex.RLock()
defer peer.device.net.mutex.RUnlock()
peer.mutex.RLock()
defer peer.mutex.RUnlock()
if peer.endpoint == nil {
return errors.New("No known endpoint for peer")
}
return peer.device.net.bind.Send(buffer, peer.endpoint)
}
/* Returns a short string identification for logging
*/
func (peer *Peer) String() string {
if peer.endpoint == nil {
return fmt.Sprintf(
"peer(%d unknown %s)",
peer.id,
base64.StdEncoding.EncodeToString(peer.handshake.remoteStatic[:]),
)
}
return fmt.Sprintf(
"peer(%d %s %s)",
peer.id,
peer.endpoint.DstToString(),
base64.StdEncoding.EncodeToString(peer.handshake.remoteStatic[:]),
)
}
func (peer *Peer) Close() {
close(peer.signal.stop)
}