wireguard-go/peer.go

291 lines
6.4 KiB
Go
Raw Normal View History

/* SPDX-License-Identifier: GPL-2.0
*
* Copyright (C) 2017-2018 Jason A. Donenfeld <Jason@zx2c4.com>. All Rights Reserved.
*/
package main
import (
"encoding/base64"
2017-06-26 11:14:02 +00:00
"errors"
"fmt"
"sync"
"time"
)
const (
PeerRoutineNumber = 4
2018-05-05 02:15:07 +00:00
EventInterval = 10 * time.Millisecond
)
type Peer struct {
isRunning AtomicBool
2018-02-04 15:46:24 +00:00
mutex sync.RWMutex
2017-06-26 11:14:02 +00:00
keyPairs KeyPairs
2017-06-24 13:34:17 +00:00
handshake Handshake
device *Device
endpoint Endpoint
persistentKeepaliveInterval uint16
_ uint32 // padding for alignment
stats struct {
txBytes uint64 // bytes send to peer (endpoint)
rxBytes uint64 // bytes received from peer
lastHandshakeNano int64 // nano seconds since epoch
}
time struct {
2018-02-04 15:46:24 +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
}
event struct {
dataSent *Event
dataReceived *Event
anyAuthenticatedPacketReceived *Event
anyAuthenticatedPacketTraversal *Event
2018-05-05 02:15:07 +00:00
handshakeCompleted *Event
handshakePushDeadline *Event
2018-05-05 02:15:07 +00:00
handshakeBegin *Event
ephemeralKeyCreated *Event
2018-05-05 02:15:07 +00:00
newKeyPair *Event
}
signal struct {
flushNonceQueue chan struct{} // size 0, empty queued packets
}
timer struct {
sendLastMinuteHandshake AtomicBool
needAnotherKeepalive AtomicBool
}
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
}
routines struct {
2018-02-04 15:46:24 +00:00
mutex sync.Mutex // held when stopping / starting routines
starting sync.WaitGroup // routines pending start
stopping sync.WaitGroup // routines pending stop
stop Signal // size 0, stop all go-routines in peer
}
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) {
if device.isClosed.Get() {
return nil, errors.New("Device closed")
}
// lock resources
device.state.mutex.Lock()
defer device.state.mutex.Unlock()
device.noise.mutex.RLock()
defer device.noise.mutex.RUnlock()
device.peers.mutex.Lock()
defer device.peers.mutex.Unlock()
// check if over limit
if len(device.peers.keyMap) >= MaxPeers {
return nil, errors.New("Too many peers")
}
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
peer.isRunning.Set(false)
2017-07-08 21:51:26 +00:00
2018-05-05 02:15:07 +00:00
// events
peer.event.dataSent = newEvent(EventInterval)
peer.event.dataReceived = newEvent(EventInterval)
peer.event.anyAuthenticatedPacketReceived = newEvent(EventInterval)
peer.event.anyAuthenticatedPacketTraversal = newEvent(EventInterval)
peer.event.handshakeCompleted = newEvent(EventInterval)
peer.event.handshakePushDeadline = newEvent(EventInterval)
peer.event.handshakeBegin = newEvent(EventInterval)
peer.event.ephemeralKeyCreated = newEvent(EventInterval)
peer.event.newKeyPair = newEvent(EventInterval)
// map public key
_, ok := device.peers.keyMap[pk]
2017-06-26 11:14:02 +00:00
if ok {
return nil, errors.New("Adding existing peer")
2017-06-26 11:14:02 +00:00
}
device.peers.keyMap[pk] = peer
2017-06-24 13:34:17 +00:00
// pre-compute 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.noise.privateKey.sharedSecret(pk)
2017-06-26 11:14:02 +00:00
handshake.mutex.Unlock()
2017-06-24 13:34:17 +00:00
// reset endpoint
peer.endpoint = nil
2017-07-08 21:51:26 +00:00
// prepare signaling & routines
peer.routines.mutex.Lock()
peer.routines.stop = NewSignal()
peer.routines.mutex.Unlock()
// start peer
if peer.device.isUp.Get() {
peer.Start()
}
return peer, nil
}
func (peer *Peer) SendBuffer(buffer []byte) error {
peer.device.net.mutex.RLock()
defer peer.device.net.mutex.RUnlock()
2017-12-29 16:42:09 +00:00
2018-02-02 19:45:25 +00:00
if peer.device.net.bind == nil {
return errors.New("No bind")
}
peer.mutex.RLock()
defer peer.mutex.RUnlock()
2017-12-29 16:42:09 +00:00
if peer.endpoint == nil {
return errors.New("No known endpoint for peer")
}
2017-12-29 16:42:09 +00:00
return peer.device.net.bind.Send(buffer, peer.endpoint)
}
2017-12-29 16:42:09 +00:00
/* Returns a short string identifier for logging
*/
func (peer *Peer) String() string {
return fmt.Sprintf(
"peer(%s)",
base64.StdEncoding.EncodeToString(peer.handshake.remoteStatic[:]),
)
}
func (peer *Peer) Start() {
// should never start a peer on a closed device
if peer.device.isClosed.Get() {
return
}
// prevent simultaneous start/stop operations
peer.routines.mutex.Lock()
defer peer.routines.mutex.Unlock()
2018-02-02 19:45:25 +00:00
if peer.isRunning.Get() {
return
}
2018-02-04 18:18:44 +00:00
device := peer.device
device.log.Debug.Println(peer, ": Starting...")
2018-02-02 19:45:25 +00:00
// sanity check : these should be 0
peer.routines.starting.Wait()
peer.routines.stopping.Wait()
2017-12-29 16:42:09 +00:00
2018-02-02 19:45:25 +00:00
// prepare queues and signals
peer.signal.flushNonceQueue = make(chan struct{})
peer.queue.nonce = make(chan *QueueOutboundElement, QueueOutboundSize)
peer.queue.outbound = make(chan *QueueOutboundElement, QueueOutboundSize)
peer.queue.inbound = make(chan *QueueInboundElement, QueueInboundSize)
peer.routines.stop = NewSignal()
2018-02-02 19:45:25 +00:00
peer.isRunning.Set(true)
// wait for routines to start
peer.routines.starting.Add(PeerRoutineNumber)
peer.routines.stopping.Add(PeerRoutineNumber)
2017-12-29 16:42:09 +00:00
go peer.RoutineNonce()
go peer.RoutineTimerHandler()
2017-12-29 16:42:09 +00:00
go peer.RoutineSequentialSender()
go peer.RoutineSequentialReceiver()
peer.routines.starting.Wait()
peer.isRunning.Set(true)
2017-12-29 16:42:09 +00:00
}
func (peer *Peer) Stop() {
// prevent simultaneous start/stop operations
peer.routines.mutex.Lock()
defer peer.routines.mutex.Unlock()
2018-02-02 19:45:25 +00:00
if !peer.isRunning.Swap(false) {
return
}
device := peer.device
device.log.Debug.Println(peer, ": Stopping...")
2018-02-02 19:45:25 +00:00
// stop & wait for ongoing peer routines
peer.routines.starting.Wait()
peer.routines.stop.Broadcast()
peer.routines.stopping.Wait()
// close queues
close(peer.queue.nonce)
close(peer.queue.outbound)
close(peer.queue.inbound)
2018-02-04 18:18:44 +00:00
// close signals
close(peer.signal.flushNonceQueue)
peer.signal.flushNonceQueue = nil
2018-02-04 18:18:44 +00:00
// clear key pairs
kp := &peer.keyPairs
kp.mutex.Lock()
device.DeleteKeyPair(kp.previous)
device.DeleteKeyPair(kp.current)
device.DeleteKeyPair(kp.next)
kp.previous = nil
kp.current = nil
kp.next = nil
kp.mutex.Unlock()
// clear handshake state
hs := &peer.handshake
hs.mutex.Lock()
device.indices.Delete(hs.localIndex)
hs.Clear()
hs.mutex.Unlock()
}