package govpn
import (
+ "bytes"
"encoding/binary"
"io"
+ "log"
"sync"
"sync/atomic"
"time"
S20BS = 64
// Maximal amount of bytes transfered with single key (4 GiB)
MaxBytesPerKey int64 = 1 << 32
- // Size of packet's size mark in bytes
- PktSizeSize = 2
// Heartbeat rate, relative to Timeout
TimeoutHeartbeat = 4
// Minimal valid packet length
- MinPktLength = 2 + 16 + 8
+ MinPktLength = 1 + 16 + 8
+ // Padding byte
+ PadByte = byte(0x80)
)
func newNonceCipher(key *[32]byte) *xtea.Cipher {
CPR int
CPRCycle time.Duration `json:"-"`
EncLess bool
+ MTU int
// Cryptography related
Key *[SSize]byte `json:"-"`
bufR []byte
tagR *[TagSize]byte
keyAuthR *[SSize]byte
- pktSizeR uint16
+ pktSizeR int
// Transmitter
BusyT sync.Mutex `json:"-"`
p.NonceCipher.Encrypt(buf, buf)
}
+func cprCycleCalculate(rate int) time.Duration {
+ if rate == 0 {
+ return time.Duration(0)
+ }
+ return time.Second / time.Duration(rate*(1<<10)/MTUMax)
+}
+
func newPeer(isClient bool, addr string, conn io.Writer, conf *PeerConf, key *[SSize]byte) *Peer {
now := time.Now()
timeout := conf.Timeout
timeout = timeout / TimeoutHeartbeat
}
- bufSize := S20BS + MTU + NonceSize
+ bufSize := S20BS + 2*conf.MTU
if conf.EncLess {
bufSize += EncLessEnlargeSize
noiseEnable = true
CPR: conf.CPR,
CPRCycle: cprCycle,
EncLess: conf.EncLess,
+ MTU: conf.MTU,
Key: key,
NonceCipher: newNonceCipher(key),
// that he is free to receive new packets. Encrypted and authenticated
// packets will be sent to remote Peer side immediately.
func (p *Peer) EthProcess(data []byte) {
+ if len(data) > p.MTU-1 { // 1 is for padding byte
+ log.Println("Padded data packet size", len(data)+1, "is bigger than MTU", p.MTU, p)
+ return
+ }
p.now = time.Now()
p.BusyT.Lock()
// Zero size is a heartbeat packet
+ SliceZero(p.bufT)
if len(data) == 0 {
// If this heartbeat is necessary
if !p.LastSent.Add(p.Timeout).Before(p.now) {
p.BusyT.Unlock()
return
}
- p.bufT[S20BS+0] = 0
- p.bufT[S20BS+1] = 0
+ p.bufT[S20BS+0] = PadByte
p.HeartbeatSent++
} else {
// Copy payload to our internal buffer and we are ready to
// accept the next one
- binary.BigEndian.PutUint16(
- p.bufT[S20BS:S20BS+PktSizeSize],
- uint16(len(data)),
- )
- copy(p.bufT[S20BS+PktSizeSize:], data)
+ copy(p.bufT[S20BS:], data)
+ p.bufT[S20BS+len(data)] = PadByte
p.BytesPayloadOut += int64(len(data))
}
if p.NoiseEnable && !p.EncLess {
- p.frameT = p.bufT[S20BS : S20BS+MTU-TagSize]
+ p.frameT = p.bufT[S20BS : S20BS+p.MTU-TagSize]
} else if p.EncLess {
- p.frameT = p.bufT[S20BS : S20BS+MTU]
+ p.frameT = p.bufT[S20BS : S20BS+p.MTU]
} else {
- p.frameT = p.bufT[S20BS : S20BS+PktSizeSize+len(data)+NonceSize]
+ p.frameT = p.bufT[S20BS : S20BS+len(data)+1+NonceSize]
}
p.nonceOur += 2
binary.BigEndian.PutUint64(p.frameT[len(p.frameT)-NonceSize:], p.nonceOur)
}
out = append(out, p.frameT[len(p.frameT)-NonceSize:]...)
} else {
- for i := 0; i < SSize; i++ {
- p.bufT[i] = 0
- }
salsa20.XORKeyStream(
p.bufT[:S20BS+len(p.frameT)-NonceSize],
p.bufT[:S20BS+len(p.frameT)-NonceSize],
p.BusyR.Unlock()
return false
}
- out = p.bufR[S20BS:]
+ out = p.bufR[S20BS : S20BS+len(data)-TagSize-NonceSize]
}
// Check if received nonce is known to us in either of two buckets.
p.FramesIn++
atomic.AddInt64(&p.BytesIn, int64(len(data)))
p.LastPing = time.Now()
- p.pktSizeR = binary.BigEndian.Uint16(out[:PktSizeSize])
+ p.pktSizeR = bytes.LastIndexByte(out, PadByte)
+ if p.pktSizeR == -1 {
+ p.BusyR.Unlock()
+ return false
+ }
+ // Validate the pad
+ for i := p.pktSizeR + 1; i < len(out); i++ {
+ if out[i] != 0 {
+ p.BusyR.Unlock()
+ return false
+ }
+ }
if p.pktSizeR == 0 {
p.HeartbeatRecv++
p.BusyR.Unlock()
return true
}
- if int(p.pktSizeR) > len(data)-MinPktLength {
- return false
- }
p.BytesPayloadIn += int64(p.pktSizeR)
- tap.Write(out[PktSizeSize : PktSizeSize+p.pktSizeR])
+ tap.Write(out[:p.pktSizeR])
p.BusyR.Unlock()
return true
}