Replace many panic() with Fatalln less verbose and scary printing

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

diff --git a/src/govpn/handshake.go b/src/govpn/handshake.go
index a0bd79bd8820238dc64a8d6a8efbce63b7921ee2..7019148e899949f754435bdbad61c2042963350c 100644 (file)
--- a/src/govpn/handshake.go
+++ b/src/govpn/handshake.go
@@ -108,7 +108,7 @@ func dhKeypairGen() (*[32]byte, *[32]byte) {
        reprFound := false
        for !reprFound {
                if _, err := rand.Read(priv[:]); err != nil {
-                       panic("Can not read random for DH private key")
+                       log.Fatalln("Error reading random for DH private key:", err)
                }
                reprFound = extra25519.ScalarBaseMult(pub, repr, priv)
        }
@@ -158,7 +158,7 @@ func HandshakeStart(conf *PeerConf, conn *net.UDPConn, addr *net.UDPAddr) *Hands
 
        state.rNonce = new([RSize]byte)
        if _, err := rand.Read(state.rNonce[:]); err != nil {
-               panic("Can not read random for handshake nonce")
+               log.Fatalln("Error reading random for nonce:", err)
        }
        enc := make([]byte, 32)
        salsa20.XORKeyStream(enc, dhPubRepr[:], state.rNonce[:], state.dsaPubH)
@@ -202,11 +202,11 @@ func (h *Handshake) Server(conn *net.UDPConn, data []byte) *Peer {
                // Generate R* and encrypt them
                h.rServer = new([RSize]byte)
                if _, err := rand.Read(h.rServer[:]); err != nil {
-                       panic("Can not read random for handshake random key")
+                       log.Fatalln("Error reading random for R:", err)
                }
                h.sServer = new([SSize]byte)
                if _, err := rand.Read(h.sServer[:]); err != nil {
-                       panic("Can not read random for handshake shared key")
+                       log.Fatalln("Error reading random for S:", err)
                }
                encRs := make([]byte, RSize+SSize)
                salsa20.XORKeyStream(encRs, append(h.rServer[:], h.sServer[:]...), h.rNonce[:], h.key)
@@ -288,11 +288,11 @@ func (h *Handshake) Client(conn *net.UDPConn, data []byte) *Peer {
                // Generate R* and signature and encrypt them
                h.rClient = new([RSize]byte)
                if _, err := rand.Read(h.rClient[:]); err != nil {
-                       panic("Can not read random for handshake random key")
+                       log.Fatalln("Error reading random for R:", err)
                }
                h.sClient = new([SSize]byte)
                if _, err := rand.Read(h.sClient[:]); err != nil {
-                       panic("Can not read random for handshake shared key")
+                       log.Fatalln("Error reading random for S:", err)
                }
                sign := ed25519.Sign(h.Conf.DSAPriv, h.key[:])