Make SliceZero function public

[govpn.git] / src / govpn / handshake.go

diff --git a/src/govpn/handshake.go b/src/govpn/handshake.go
index 1c7c43d6fd83dac0de0f7483fca7840b868adeee..13f1a6cdace24d268f63d08ac6fc91039b7372b7 100644 (file)
--- a/src/govpn/handshake.go
+++ b/src/govpn/handshake.go
@@ -1,6 +1,6 @@
 /*
 GoVPN -- simple secure free software virtual private network daemon
-Copyright (C) 2014-2015 Sergey Matveev <stargrave@stargrave.org>
+Copyright (C) 2014-2016 Sergey Matveev <stargrave@stargrave.org>
 
 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -19,7 +19,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 package govpn
 
 import (
-       "crypto/rand"
        "crypto/subtle"
        "encoding/binary"
        "io"
@@ -70,28 +69,28 @@ func HApply(data *[32]byte) {
 // Zero handshake's memory state
 func (h *Handshake) Zero() {
        if h.rNonce != nil {
-               sliceZero(h.rNonce[:])
+               SliceZero(h.rNonce[:])
        }
        if h.dhPriv != nil {
-               sliceZero(h.dhPriv[:])
+               SliceZero(h.dhPriv[:])
        }
        if h.key != nil {
-               sliceZero(h.key[:])
+               SliceZero(h.key[:])
        }
        if h.dsaPubH != nil {
-               sliceZero(h.dsaPubH[:])
+               SliceZero(h.dsaPubH[:])
        }
        if h.rServer != nil {
-               sliceZero(h.rServer[:])
+               SliceZero(h.rServer[:])
        }
        if h.rClient != nil {
-               sliceZero(h.rClient[:])
+               SliceZero(h.rClient[:])
        }
        if h.sServer != nil {
-               sliceZero(h.sServer[:])
+               SliceZero(h.sServer[:])
        }
        if h.sClient != nil {
-               sliceZero(h.sClient[:])
+               SliceZero(h.sClient[:])
        }
 }
 
@@ -102,23 +101,13 @@ func (h *Handshake) rNonceNext(count uint64) []byte {
        return nonce
 }
 
-func randRead(b []byte) error {
-       var err error
-       if egdPath == "" {
-               _, err = rand.Read(b)
-       } else {
-               err = EGDRead(b)
-       }
-       return err
-}
-
 func dhKeypairGen() (*[32]byte, *[32]byte) {
        priv := new([32]byte)
        pub := new([32]byte)
        repr := new([32]byte)
        reprFound := false
        for !reprFound {
-               if err := randRead(priv[:]); err != nil {
+               if _, err := Rand.Read(priv[:]); err != nil {
                        log.Fatalln("Error reading random for DH private key:", err)
                }
                reprFound = extra25519.ScalarBaseMult(pub, repr, priv)
@@ -142,7 +131,7 @@ func NewHandshake(addr string, conn io.Writer, conf *PeerConf) *Handshake {
                Conf:     conf,
        }
        state.dsaPubH = new([ed25519.PublicKeySize]byte)
-       copy(state.dsaPubH[:], state.Conf.DSAPub[:])
+       copy(state.dsaPubH[:], state.Conf.Verifier.Pub[:])
        HApply(state.dsaPubH)
        return &state
 }
@@ -167,11 +156,11 @@ func HandshakeStart(addr string, conn io.Writer, conf *PeerConf) *Handshake {
        state.dhPriv, dhPubRepr = dhKeypairGen()
 
        state.rNonce = new([RSize]byte)
-       if err := randRead(state.rNonce[:]); err != nil {
+       if _, err := Rand.Read(state.rNonce[:]); err != nil {
                log.Fatalln("Error reading random for nonce:", err)
        }
        var enc []byte
-       if conf.NoiseEnable {
+       if conf.Noise {
                enc = make([]byte, MTU-xtea.BlockSize-RSize)
        } else {
                enc = make([]byte, 32)
@@ -191,7 +180,7 @@ func HandshakeStart(addr string, conn io.Writer, conf *PeerConf) *Handshake {
 // authenticated Peer is ready, then return nil.
 func (h *Handshake) Server(data []byte) *Peer {
        // R + ENC(H(DSAPub), R, El(CDHPub)) + IDtag
-       if h.rNonce == nil {
+       if h.rNonce == nil && len(data) >= 48 {
                // Generate DH keypair
                var dhPubRepr *[32]byte
                h.dhPriv, dhPubRepr = dhKeypairGen()
@@ -216,15 +205,16 @@ func (h *Handshake) Server(data []byte) *Peer {
 
                // Generate R* and encrypt them
                h.rServer = new([RSize]byte)
-               if err := randRead(h.rServer[:]); err != nil {
+               var err error
+               if _, err = Rand.Read(h.rServer[:]); err != nil {
                        log.Fatalln("Error reading random for R:", err)
                }
                h.sServer = new([SSize]byte)
-               if err := randRead(h.sServer[:]); err != nil {
+               if _, err = Rand.Read(h.sServer[:]); err != nil {
                        log.Fatalln("Error reading random for S:", err)
                }
                var encRs []byte
-               if h.Conf.NoiseEnable {
+               if h.Conf.Noise {
                        encRs = make([]byte, MTU-len(encPub)-xtea.BlockSize)
                } else {
                        encRs = make([]byte, RSize+SSize)
@@ -237,7 +227,7 @@ func (h *Handshake) Server(data []byte) *Peer {
                h.LastPing = time.Now()
        } else
        // ENC(K, R+1, RS + RC + SC + Sign(DSAPriv, K)) + IDtag
-       if h.rClient == nil {
+       if h.rClient == nil && len(data) >= 120 {
                // Decrypted Rs compare rServer
                dec := make([]byte, RSize+RSize+SSize+ed25519.SignatureSize)
                salsa20.XORKeyStream(
@@ -252,14 +242,14 @@ func (h *Handshake) Server(data []byte) *Peer {
                }
                sign := new([ed25519.SignatureSize]byte)
                copy(sign[:], dec[RSize+RSize+SSize:])
-               if !ed25519.Verify(h.Conf.DSAPub, h.key[:], sign) {
+               if !ed25519.Verify(h.Conf.Verifier.Pub, h.key[:], sign) {
                        log.Println("Invalid signature from", h.addr)
                        return nil
                }
 
                // Send final answer to client
                var enc []byte
-               if h.Conf.NoiseEnable {
+               if h.Conf.Noise {
                        enc = make([]byte, MTU-xtea.BlockSize)
                } else {
                        enc = make([]byte, RSize)
@@ -290,7 +280,7 @@ func (h *Handshake) Server(data []byte) *Peer {
 // authenticated Peer is ready, then return nil.
 func (h *Handshake) Client(data []byte) *Peer {
        // ENC(H(DSAPub), R+1, El(SDHPub)) + ENC(K, R, RS + SS) + IDtag
-       if h.rServer == nil && h.key == nil {
+       if h.rServer == nil && h.key == nil && len(data) >= 80 {
                // Decrypt remote public key and compute shared key
                sDHRepr := new([32]byte)
                salsa20.XORKeyStream(sDHRepr[:], data[:32], h.rNonceNext(1), h.dsaPubH)
@@ -308,17 +298,18 @@ func (h *Handshake) Client(data []byte) *Peer {
 
                // Generate R* and signature and encrypt them
                h.rClient = new([RSize]byte)
-               if err := randRead(h.rClient[:]); err != nil {
+               var err error
+               if _, err = Rand.Read(h.rClient[:]); err != nil {
                        log.Fatalln("Error reading random for R:", err)
                }
                h.sClient = new([SSize]byte)
-               if err := randRead(h.sClient[:]); err != nil {
+               if _, err = Rand.Read(h.sClient[:]); err != nil {
                        log.Fatalln("Error reading random for S:", err)
                }
                sign := ed25519.Sign(h.Conf.DSAPriv, h.key[:])
 
                var enc []byte
-               if h.Conf.NoiseEnable {
+               if h.Conf.Noise {
                        enc = make([]byte, MTU-xtea.BlockSize)
                } else {
                        enc = make([]byte, RSize+RSize+SSize+ed25519.SignatureSize)
@@ -334,7 +325,7 @@ func (h *Handshake) Client(data []byte) *Peer {
                h.LastPing = time.Now()
        } else
        // ENC(K, R+2, RC) + IDtag
-       if h.key != nil {
+       if h.key != nil && len(data) >= 16 {
                // Decrypt rClient
                dec := make([]byte, RSize)
                salsa20.XORKeyStream(dec, data[:RSize], h.rNonceNext(2), h.key)