Zero handshake and peer states after their usage

Signed-off-by: Sergey Matveev <stargrave@stargrave.org>

diff --git a/cmd/govpn-client/main.go b/cmd/govpn-client/main.go
index f4a29eb82d2aea2a23d3fdb5eaad906cf41e677d..82a89a69115a7b4edebf863ee06d5d9331ae09dc 100644 (file)
--- a/cmd/govpn-client/main.go
+++ b/cmd/govpn-client/main.go
@@ -93,6 +93,7 @@ func main() {
 MainCycle:
        for {
                if peer != nil && peer.Bytes > govpn.MaxBytesPerKey {
+                       peer.Zero()
                        peer = nil
                        handshake = govpn.HandshakeStart(conn, remote, id, key)
                        log.Println("Rehandshaking")
@@ -132,6 +133,7 @@ MainCycle:
                                                firstUpCall = false
                                        }
                                        peer = p
+                                       handshake.Zero()
                                        handshake = nil
                                }
                                udpReady <- struct{}{}

diff --git a/cmd/govpn-server/main.go b/cmd/govpn-server/main.go
index 4fa5c96f8baa184c350e4362178b196dc14f1009..1ce5a3748cd02d391f311f64adb6c090c0eaee84 100644 (file)
--- a/cmd/govpn-server/main.go
+++ b/cmd/govpn-server/main.go
@@ -129,6 +129,7 @@ MainCycle:
                        for addr, hs := range states {
                                if hs.LastPing.Add(timeout).Before(now) {
                                        log.Println("Deleting handshake state", addr)
+                                       hs.Zero()
                                        delete(states, addr)
                                }
                        }
@@ -143,6 +144,7 @@ MainCycle:
                                        )
                                        go govpn.ScriptCall(downPath, state.tap.Name)
                                        state.terminate <- struct{}{}
+                                       state.peer.Zero()
                                }
                        }
                case peerReady = <-peerReadySink:
@@ -152,6 +154,7 @@ MainCycle:
                                }
                                delete(peers, addr)
                                state.terminate <- struct{}{}
+                               state.peer.Zero()
                                break
                        }
                        addr = peerReady.peer.Addr.String()
@@ -160,6 +163,7 @@ MainCycle:
                                continue
                        }
                        peers[addr] = state
+                       states[addr].Zero()
                        delete(states, addr)
                        log.Println("Registered interface", peerReady.iface, "with peer", peer)
                        go func(state *PeerState) {

diff --git a/common.go b/common.go
index b42673c98925f32be3b63948f7eaf30eccb186e9..545274fb4c3f92c5c5f7da402375280ff872411f 100644 (file)
--- a/common.go
+++ b/common.go
@@ -74,3 +74,10 @@ func KeyRead(path string) *[KeySize]byte {
        copy(key[:], keyDecoded)
        return key
 }
+
+// Zero each byte
+func sliceZero(data []byte) {
+       for i := 0; i < len(data); i++ {
+               data[i] = '\x00'
+       }
+}

diff --git a/handshake.go b/handshake.go
index c458f5d41e90d25b6961d9d043b2d1ece7dbde87..44f9a2968c980ace0ef292ad9d1cd29395685e96 100644 (file)
--- a/handshake.go
+++ b/handshake.go
@@ -69,6 +69,25 @@ func IsValidHandshakePkt(pkt []byte) bool {
        return true
 }
 
+// Zero handshake's memory state
+func (h *Handshake) Zero() {
+       sliceZero(h.rNonce[:])
+       sliceZero(h.dhPriv[:])
+       sliceZero(h.key[:])
+       if h.rServer != nil {
+               sliceZero(h.rServer[:])
+       }
+       if h.rClient != nil {
+               sliceZero(h.rClient[:])
+       }
+       if h.sServer != nil {
+               sliceZero(h.sServer[:])
+       }
+       if h.sClient != nil {
+               sliceZero(h.sClient[:])
+       }
+}
+
 func (h *Handshake) rNonceNext() []byte {
        nonce := make([]byte, 8)
        nonceCurrent, _ := binary.Uvarint(h.rNonce[:])

diff --git a/transport.go b/transport.go
index d72fcc15ea140c74584514dd380fbc3fe6dea607..31bfe7f6a403f64bad9d8b613b7f24affd1a0b86 100644 (file)
--- a/transport.go
+++ b/transport.go
@@ -67,6 +67,16 @@ func (p *Peer) String() string {
        return p.Id.String() + ":" + p.Addr.String()
 }
 
+// Zero peer's memory state
+func (p *Peer) Zero() {
+       sliceZero(p.Key[:])
+       sliceZero(p.tag[:])
+       sliceZero(p.keyAuth[:])
+       sliceZero(p.buf)
+       sliceZero(p.frame)
+       sliceZero(p.nonce)
+}
+
 var (
        HeartbeatMark   = []byte("\x00\x00\x00HEARTBEAT")
        Emptiness       = make([]byte, KeySize)