src/cypherpunks.ru/govpn/peer_test.go

   1 /*
   2 GoVPN -- simple secure free software virtual private network daemon
   3 Copyright (C) 2014-2017 Sergey Matveev <stargrave@stargrave.org>
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 package govpn
  20
  21 import (
  22         "testing"
  23         "testing/quick"
  24 )
  25
  26 var (
  27         testPeer   *Peer
  28         testPt     []byte
  29         testCt     []byte
  30         testPeerID PeerID
  31         testConf   *PeerConf
  32 )
  33
  34 type Dummy struct {
  35         dst *[]byte
  36 }
  37
  38 func (d Dummy) Write(b []byte) (int, error) {
  39         if d.dst != nil {
  40                 *d.dst = b
  41         }
  42         return len(b), nil
  43 }
  44
  45 func init() {
  46         id := new([IDSize]byte)
  47         testPeerID = PeerID(*id)
  48         testConf = &PeerConf{
  49                 ID:      &testPeerID,
  50                 MTU:     MTUDefault,
  51                 Timeout: TimeoutDefault,
  52         }
  53         testPt = make([]byte, 789)
  54 }
  55
  56 func testPeerNew(t *testing.T) {
  57         var err error
  58         testPeer, err = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte))
  59         if err != nil {
  60                 t.Error(err)
  61         }
  62 }
  63
  64 func TestTransportSymmetric(t *testing.T) {
  65         testPeerNew(t)
  66         peerd, err := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte))
  67         if err != nil {
  68                 t.Error(err)
  69         }
  70         f := func(payload []byte) bool {
  71                 if len(payload) == 0 {
  72                         return true
  73                 }
  74                 if err := testPeer.EthProcess(payload); err != nil {
  75                         t.Error(err)
  76                 }
  77                 return peerd.PktProcess(testCt, Dummy{nil}, true)
  78         }
  79         if err := quick.Check(f, nil); err != nil {
  80                 t.Error(err)
  81         }
  82 }
  83
  84 func TestTransportSymmetricNoise(t *testing.T) {
  85         testPeerNew(t)
  86         peerd, err := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte))
  87         if err != nil {
  88                 t.Error(err)
  89         }
  90         testPeer.NoiseEnable = true
  91         peerd.NoiseEnable = true
  92         f := func(payload []byte) bool {
  93                 if len(payload) == 0 {
  94                         return true
  95                 }
  96                 if err := testPeer.EthProcess(payload); err != nil {
  97                         t.Error(err)
  98                 }
  99                 return peerd.PktProcess(testCt, Dummy{nil}, true)
 100         }
 101         if err := quick.Check(f, nil); err != nil {
 102                 t.Error(err)
 103         }
 104         testPeer.NoiseEnable = true
 105 }
 106
 107 func TestTransportSymmetricEncless(t *testing.T) {
 108         testPeerNew(t)
 109         peerd, err := newPeer(false, "foo", Dummy{nil}, testConf, new([SSize]byte))
 110         if err != nil {
 111                 t.Error(err)
 112         }
 113         testPeer.Encless = true
 114         testPeer.NoiseEnable = true
 115         peerd.Encless = true
 116         peerd.NoiseEnable = true
 117         f := func(payload []byte) bool {
 118                 if len(payload) == 0 {
 119                         return true
 120                 }
 121                 if err := testPeer.EthProcess(payload); err != nil {
 122                         t.Error(err)
 123                 }
 124                 return peerd.PktProcess(testCt, Dummy{nil}, true)
 125         }
 126         if err := quick.Check(f, nil); err != nil {
 127                 t.Error(err)
 128         }
 129         testPeer.NoiseEnable = false
 130         testPeer.Encless = false
 131 }
 132
 133 func BenchmarkEnc(b *testing.B) {
 134         var err error
 135         for i := 0; i < b.N; i++ {
 136                 if err = testPeer.EthProcess(testPt); err != nil {
 137                         b.Error(err)
 138                 }
 139         }
 140 }
 141
 142 func BenchmarkDec(b *testing.B) {
 143         var err error
 144         testPeer, err = newPeer(true, "foo", Dummy{&testCt}, testConf, new([SSize]byte))
 145         if err != nil {
 146                 b.Error(err)
 147         }
 148         if err := testPeer.EthProcess(testPt); err != nil {
 149                 b.Error(err)
 150         }
 151         testPeer, err = newPeer(true, "foo", Dummy{nil}, testConf, new([SSize]byte))
 152         if err != nil {
 153                 b.Error(err)
 154         }
 155         orig := make([]byte, len(testCt))
 156         copy(orig, testCt)
 157         nonce := new([NonceSize]byte)
 158         copy(nonce[:], testCt[len(testCt)-NonceSize:])
 159         b.ResetTimer()
 160         for i := 0; i < b.N; i++ {
 161                 testPeer.nonceBucketL = make(map[[NonceSize]byte]struct{}, 1)
 162                 testPeer.nonceBucketM = make(map[[NonceSize]byte]struct{}, 1)
 163                 testPeer.nonceBucketH = make(map[[NonceSize]byte]struct{}, 1)
 164                 testPeer.nonceBucketL[*nonce] = struct{}{}
 165                 copy(testCt, orig)
 166                 if !testPeer.PktProcess(testCt, Dummy{nil}, true) {
 167                         b.Fail()
 168                 }
 169         }
 170 }
 171
 172 func TestTransportBigger(t *testing.T) {
 173         tmp := make([]byte, MTUMax*4)
 174         Rand.Read(tmp)
 175         testPeer.PktProcess(tmp, Dummy{nil}, true)
 176 }