src/cypherpunks.ru/govpn/handshake.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         "crypto/subtle"
  23         "encoding/binary"
  24         "io"
  25         "time"
  26
  27         "chacha20"
  28         "github.com/Sirupsen/logrus"
  29         "github.com/agl/ed25519"
  30         "github.com/agl/ed25519/extra25519"
  31         "github.com/pkg/errors"
  32         "golang.org/x/crypto/blake2b"
  33         "golang.org/x/crypto/curve25519"
  34 )
  35
  36 const (
  37         // RSize is size in bytes of channel binding random value
  38         RSize = 8
  39         // SSize is size in bytes of shared secret half
  40         SSize = 32
  41
  42         wrapIDTag = "idTag id:%q timeSync:%d"
  43 )
  44
  45 // Handshake is state of a handshake/negotiation between client and server
  46 type Handshake struct {
  47         addr     string
  48         conn     io.Writer
  49         LastPing time.Time
  50         Conf     *PeerConf
  51         dsaPubH  *[ed25519.PublicKeySize]byte
  52         key      *[32]byte
  53         rNonce   *[16]byte
  54         dhPriv   *[32]byte    // own private DH key
  55         rServer  *[RSize]byte // random string for authentication
  56         rClient  *[RSize]byte
  57         sServer  *[SSize]byte // secret string for main key calculation
  58         sClient  *[SSize]byte
  59 }
  60
  61 // LogFields return a logrus compatible logging context
  62 func (h *Handshake) LogFields() logrus.Fields {
  63         const prefix = "hs_"
  64         return logrus.Fields{
  65                 prefix + "remote":    h.addr,
  66                 prefix + "last_ping": h.LastPing.String(),
  67                 prefix + "id":        h.Conf.ID.String(),
  68         }
  69 }
  70
  71 func keyFromSecrets(server, client []byte) *[SSize]byte {
  72         k := new([SSize]byte)
  73         for i := 0; i < SSize; i++ {
  74                 k[i] = server[i] ^ client[i]
  75         }
  76         return k
  77 }
  78
  79 // Zero handshake's memory state
  80 func (h *Handshake) Zero() {
  81         if h.rNonce != nil {
  82                 SliceZero(h.rNonce[:])
  83         }
  84         if h.dhPriv != nil {
  85                 SliceZero(h.dhPriv[:])
  86         }
  87         if h.key != nil {
  88                 SliceZero(h.key[:])
  89         }
  90         if h.dsaPubH != nil {
  91                 SliceZero(h.dsaPubH[:])
  92         }
  93         if h.rServer != nil {
  94                 SliceZero(h.rServer[:])
  95         }
  96         if h.rClient != nil {
  97                 SliceZero(h.rClient[:])
  98         }
  99         if h.sServer != nil {
 100                 SliceZero(h.sServer[:])
 101         }
 102         if h.sClient != nil {
 103                 SliceZero(h.sClient[:])
 104         }
 105 }
 106
 107 func (h *Handshake) rNonceNext(count uint64) *[16]byte {
 108         nonce := new([16]byte)
 109         nonceCurrent, _ := binary.Uvarint(h.rNonce[8:])
 110         binary.PutUvarint(nonce[8:], nonceCurrent+count)
 111         return nonce
 112 }
 113
 114 func dhKeypairGen() (*[32]byte, *[32]byte, error) {
 115         priv := new([32]byte)
 116         pub := new([32]byte)
 117         repr := new([32]byte)
 118         reprFound := false
 119         for !reprFound {
 120                 if _, err := io.ReadFull(Rand, priv[:]); err != nil {
 121                         return nil, nil, errors.Wrapf(err, wrapIoReadFull, "Rand")
 122                 }
 123                 reprFound = extra25519.ScalarBaseMult(pub, repr, priv)
 124         }
 125         return priv, repr, nil
 126 }
 127
 128 func dhKeyGen(priv, pub *[32]byte) *[32]byte {
 129         key := new([32]byte)
 130         curve25519.ScalarMult(key, priv, pub)
 131         hashed := blake2b.Sum256(key[:])
 132         return &hashed
 133 }
 134
 135 // NewHandshake creates new handshake state.
 136 func NewHandshake(addr string, conn io.Writer, conf *PeerConf) *Handshake {
 137         state := Handshake{
 138                 addr:     addr,
 139                 conn:     conn,
 140                 LastPing: time.Now(),
 141                 Conf:     conf,
 142         }
 143         state.dsaPubH = new([ed25519.PublicKeySize]byte)
 144         copy(state.dsaPubH[:], state.Conf.Verifier.Pub[:])
 145         hashed := blake2b.Sum256(state.dsaPubH[:])
 146         state.dsaPubH = &hashed
 147         return &state
 148 }
 149
 150 // Generate ID tag from client identification and data.
 151 func idTag(id *PeerID, timeSync int, data []byte) ([]byte, error) {
 152         enc := make([]byte, 8)
 153         copy(enc, data)
 154         AddTimeSync(timeSync, enc)
 155         mac, err := blake2b.New256(id[:])
 156         if err != nil {
 157                 return nil, errors.Wrap(err, wrapBlake2bNew256)
 158         }
 159         if _, err = mac.Write(enc); err != nil {
 160                 return nil, errors.Wrap(err, "mac.Write")
 161         }
 162         sum := mac.Sum(nil)
 163         return sum[len(sum)-8:], nil
 164 }
 165
 166 // HandshakeStarts start handshake's procedure from the client.
 167 // It is the entry point for starting the handshake procedure.
 168 // First handshake packet will be sent immediately.
 169 func HandshakeStart(addr string, conn io.Writer, conf *PeerConf) (*Handshake, error) {
 170         state := NewHandshake(addr, conn, conf)
 171         var (
 172                 dhPubRepr *[32]byte
 173                 err       error
 174         )
 175         if state.dhPriv, dhPubRepr, err = dhKeypairGen(); err != nil {
 176                 return nil, errors.Wrap(err, "dhKeypairGen")
 177         }
 178
 179         state.rNonce = new([16]byte)
 180         if _, err := io.ReadFull(Rand, state.rNonce[8:]); err != nil {
 181                 return nil, errors.Wrapf(err, wrapIoReadFull, "Rand")
 182         }
 183         var enc []byte
 184         if conf.Noise {
 185                 enc = make([]byte, conf.MTU-8-RSize)
 186         } else {
 187                 enc = make([]byte, 32)
 188         }
 189         copy(enc, dhPubRepr[:])
 190         if conf.Encless {
 191                 enc, err = EnclessEncode(state.dsaPubH, state.rNonce, enc)
 192                 if err != err {
 193                         return nil, errors.Wrap(err, wrapEnclessDecode)
 194                 }
 195         } else {
 196                 chacha20.XORKeyStream(enc, enc, state.rNonce, state.dsaPubH)
 197         }
 198         tag, err := idTag(state.Conf.ID, state.Conf.TimeSync, state.rNonce[8:])
 199         if err != nil {
 200                 return nil, errors.Wrapf(err, wrapIDTag, state.Conf.ID.String(), state.Conf.TimeSync)
 201         }
 202         data := append(state.rNonce[8:], enc...)
 203         data = append(data, tag...)
 204         if _, err = state.conn.Write(data); err != nil {
 205                 return nil, errors.Wrap(err, "state.conn.Write")
 206         }
 207         return state, nil
 208 }
 209
 210 // Server processes handshake message on the server side.
 211 // This function is intended to be called on server's side.
 212 // If this is the final handshake message, then new Peer object
 213 // will be created and used as a transport.
 214 func (h *Handshake) Server(data []byte) (*Peer, error) {
 215         // R + ENC(H(DSAPub), R, El(CDHPub)) + IDtag
 216         if h.rNonce == nil && ((!h.Conf.Encless && len(data) >= 48) ||
 217                 (h.Conf.Encless && len(data) == EnclessEnlargeSize+h.Conf.MTU)) {
 218                 h.rNonce = new([16]byte)
 219                 copy(h.rNonce[8:], data[:RSize])
 220
 221                 // Decrypt remote public key
 222                 cDHRepr := new([32]byte)
 223                 if h.Conf.Encless {
 224                         out, err := EnclessDecode(
 225                                 h.dsaPubH,
 226                                 h.rNonce,
 227                                 data[RSize:len(data)-8],
 228                         )
 229                         if err != nil {
 230                                 return nil, errors.Wrap(err, wrapEnclessDecode)
 231                         }
 232                         copy(cDHRepr[:], out)
 233                 } else {
 234                         chacha20.XORKeyStream(cDHRepr[:], data[RSize:RSize+32], h.rNonce, h.dsaPubH)
 235                 }
 236
 237                 // Generate DH keypair
 238                 var dhPubRepr *[32]byte
 239                 var err error
 240                 if h.dhPriv, dhPubRepr, err = dhKeypairGen(); err != nil {
 241                         return nil, errors.Wrap(err, "dhKeypairGen")
 242                 }
 243
 244                 // Compute shared key
 245                 cDH := new([32]byte)
 246                 extra25519.RepresentativeToPublicKey(cDH, cDHRepr)
 247                 h.key = dhKeyGen(h.dhPriv, cDH)
 248
 249                 var encPub []byte
 250                 if h.Conf.Encless {
 251                         encPub = make([]byte, h.Conf.MTU)
 252                         copy(encPub, dhPubRepr[:])
 253                         encPub, err = EnclessEncode(h.dsaPubH, h.rNonceNext(1), encPub)
 254                         if err != nil {
 255                                 return nil, errors.Wrap(err, wrapEnclessEncode)
 256                         }
 257                 } else {
 258                         encPub = make([]byte, 32)
 259                         chacha20.XORKeyStream(encPub, dhPubRepr[:], h.rNonceNext(1), h.dsaPubH)
 260                 }
 261
 262                 // Generate R* and encrypt them
 263                 h.rServer = new([RSize]byte)
 264                 if _, err = io.ReadFull(Rand, h.rServer[:]); err != nil {
 265                         return nil, errors.Wrapf(err, wrapIoReadFull, "Rand")
 266                 }
 267                 h.sServer = new([SSize]byte)
 268                 if _, err = io.ReadFull(Rand, h.sServer[:]); err != nil {
 269                         return nil, errors.Wrapf(err, wrapIoReadFull, "Rand")
 270                 }
 271                 var encRs []byte
 272                 if h.Conf.Noise && !h.Conf.Encless {
 273                         encRs = make([]byte, h.Conf.MTU-len(encPub)-8)
 274                 } else if h.Conf.Encless {
 275                         encRs = make([]byte, h.Conf.MTU-8)
 276                 } else {
 277                         encRs = make([]byte, RSize+SSize)
 278                 }
 279                 copy(encRs, append(h.rServer[:], h.sServer[:]...))
 280                 if h.Conf.Encless {
 281                         encRs, err = EnclessEncode(h.key, h.rNonce, encRs)
 282                         if err != nil {
 283                                 return nil, errors.Wrap(err, wrapEnclessEncode)
 284                         }
 285                 } else {
 286                         chacha20.XORKeyStream(encRs, encRs, h.rNonce, h.key)
 287                 }
 288
 289                 tag, err := idTag(h.Conf.ID, h.Conf.TimeSync, encPub)
 290                 if err != nil {
 291                         return nil, errors.Wrapf(err, wrapIDTag, h.Conf.ID.String(), h.Conf.TimeSync)
 292                 }
 293
 294                 // Send that to client
 295                 _, err = h.conn.Write(append(encPub, append(
 296                         encRs, tag...,
 297                 )...))
 298                 if err != nil {
 299                         return nil, errors.Wrap(err, "conn.Write")
 300                 }
 301                 h.LastPing = time.Now()
 302         } else
 303         // ENC(K, R+1, RS + RC + SC + Sign(DSAPriv, K)) + IDtag
 304         if h.rClient == nil && ((!h.Conf.Encless && len(data) >= 120) ||
 305                 (h.Conf.Encless && len(data) == EnclessEnlargeSize+h.Conf.MTU)) {
 306                 var dec []byte
 307                 var err error
 308                 if h.Conf.Encless {
 309                         dec, err = EnclessDecode(
 310                                 h.key,
 311                                 h.rNonceNext(1),
 312                                 data[:len(data)-8],
 313                         )
 314                         if err != nil {
 315                                 return nil, errors.Wrap(err, wrapEnclessDecode)
 316                         }
 317                         dec = dec[:RSize+RSize+SSize+ed25519.SignatureSize]
 318                 } else {
 319                         dec = make([]byte, RSize+RSize+SSize+ed25519.SignatureSize)
 320                         chacha20.XORKeyStream(
 321                                 dec,
 322                                 data[:RSize+RSize+SSize+ed25519.SignatureSize],
 323                                 h.rNonceNext(1),
 324                                 h.key,
 325                         )
 326                 }
 327                 if subtle.ConstantTimeCompare(dec[:RSize], h.rServer[:]) != 1 {
 328                         return nil, errors.New("Invalid server's random number")
 329                 }
 330                 sign := new([ed25519.SignatureSize]byte)
 331                 copy(sign[:], dec[RSize+RSize+SSize:])
 332                 if !ed25519.Verify(h.Conf.Verifier.Pub, h.key[:], sign) {
 333                         return nil, errors.New("Invalid signature")
 334                 }
 335
 336                 // Send final answer to client
 337                 var enc []byte
 338                 if h.Conf.Noise {
 339                         enc = make([]byte, h.Conf.MTU-8)
 340                 } else {
 341                         enc = make([]byte, RSize)
 342                 }
 343                 copy(enc, dec[RSize:RSize+RSize])
 344                 if h.Conf.Encless {
 345                         enc, err = EnclessEncode(h.key, h.rNonceNext(2), enc)
 346                         if err != nil {
 347                                 return nil, errors.Wrap(err, wrapEnclessEncode)
 348                         }
 349                 } else {
 350                         chacha20.XORKeyStream(enc, enc, h.rNonceNext(2), h.key)
 351                 }
 352                 tag, err := idTag(h.Conf.ID, h.Conf.TimeSync, enc)
 353                 if err != nil {
 354                         return nil, errors.Wrapf(err, wrapIDTag, h.Conf.ID.String(), h.Conf.TimeSync)
 355                 }
 356                 if _, err = h.conn.Write(append(enc, tag...)); err != nil {
 357                         return nil, errors.Wrap(err, "conn.Write")
 358                 }
 359
 360                 // Switch peer
 361                 peer, err := newPeer(
 362                         false,
 363                         h.addr,
 364                         h.conn,
 365                         h.Conf,
 366                         keyFromSecrets(h.sServer[:], dec[RSize+RSize:RSize+RSize+SSize]))
 367                 if err != nil {
 368                         return nil, errors.Wrap(err, "newPeer")
 369                 }
 370                 h.LastPing = time.Now()
 371                 return peer, nil
 372         }
 373         return nil, nil
 374 }
 375
 376 // Client processes handshake message on the client side.
 377 // This function is intended to be called on client's side.
 378 // If this is the final handshake message, then new Peer object
 379 // will be created and used as a transport. If no mutually
 380 // authenticated Peer is ready, then return nil.
 381 func (h *Handshake) Client(data []byte) (*Peer, error) {
 382         // ENC(H(DSAPub), R+1, El(SDHPub)) + ENC(K, R, RS + SS) + IDtag
 383         if h.rServer == nil && h.key == nil &&
 384                 ((!h.Conf.Encless && len(data) >= 80) ||
 385                         (h.Conf.Encless && len(data) == 2*(EnclessEnlargeSize+h.Conf.MTU))) {
 386                 // Decrypt remote public key
 387                 sDHRepr := new([32]byte)
 388                 var tmp []byte
 389                 var err error
 390                 if h.Conf.Encless {
 391                         tmp, err = EnclessDecode(
 392                                 h.dsaPubH,
 393                                 h.rNonceNext(1),
 394                                 data[:len(data)/2],
 395                         )
 396                         if err != nil {
 397                                 return nil, errors.Wrap(err, wrapEnclessDecode)
 398                         }
 399                         copy(sDHRepr[:], tmp[:32])
 400                 } else {
 401                         chacha20.XORKeyStream(sDHRepr[:], data[:32], h.rNonceNext(1), h.dsaPubH)
 402                 }
 403
 404                 // Compute shared key
 405                 sDH := new([32]byte)
 406                 extra25519.RepresentativeToPublicKey(sDH, sDHRepr)
 407                 h.key = dhKeyGen(h.dhPriv, sDH)
 408
 409                 // Decrypt Rs
 410                 h.rServer = new([RSize]byte)
 411                 h.sServer = new([SSize]byte)
 412                 if h.Conf.Encless {
 413                         tmp, err = EnclessDecode(h.key, h.rNonce, data[len(data)/2:len(data)-8])
 414                         if err != nil {
 415                                 return nil, errors.Wrap(err, wrapEnclessDecode)
 416                         }
 417                         copy(h.rServer[:], tmp[:RSize])
 418                         copy(h.sServer[:], tmp[RSize:RSize+SSize])
 419                 } else {
 420                         decRs := make([]byte, RSize+SSize)
 421                         chacha20.XORKeyStream(decRs, data[SSize:SSize+RSize+SSize], h.rNonce, h.key)
 422                         copy(h.rServer[:], decRs[:RSize])
 423                         copy(h.sServer[:], decRs[RSize:])
 424                 }
 425
 426                 // Generate R* and signature and encrypt them
 427                 h.rClient = new([RSize]byte)
 428                 if _, err = io.ReadFull(Rand, h.rClient[:]); err != nil {
 429                         return nil, errors.Wrapf(err, wrapIoReadFull, "Rand")
 430                 }
 431                 h.sClient = new([SSize]byte)
 432                 if _, err = io.ReadFull(Rand, h.sClient[:]); err != nil {
 433                         return nil, errors.Wrapf(err, wrapIoReadFull, "Rand")
 434                 }
 435                 sign := ed25519.Sign(h.Conf.DSAPriv, h.key[:])
 436
 437                 var enc []byte
 438                 if h.Conf.Noise {
 439                         enc = make([]byte, h.Conf.MTU-8)
 440                 } else {
 441                         enc = make([]byte, RSize+RSize+SSize+ed25519.SignatureSize)
 442                 }
 443                 copy(enc, h.rServer[:])
 444                 copy(enc[RSize:], h.rClient[:])
 445                 copy(enc[RSize+RSize:], h.sClient[:])
 446                 copy(enc[RSize+RSize+SSize:], sign[:])
 447                 if h.Conf.Encless {
 448                         enc, err = EnclessEncode(h.key, h.rNonceNext(1), enc)
 449                         if err != nil {
 450                                 return nil, errors.Wrap(err, wrapEnclessEncode)
 451                         }
 452                 } else {
 453                         chacha20.XORKeyStream(enc, enc, h.rNonceNext(1), h.key)
 454                 }
 455
 456                 tag, err := idTag(h.Conf.ID, h.Conf.TimeSync, enc)
 457                 if err != nil {
 458                         return nil, errors.Wrapf(err, wrapIDTag, h.Conf.ID.String(), h.Conf.TimeSync)
 459                 }
 460
 461                 // Send that to server
 462                 if _, err = h.conn.Write(append(enc, tag...)); err != nil {
 463                         return nil, errors.Wrap(err, "conn.Write")
 464                 }
 465                 h.LastPing = time.Now()
 466         } else
 467         // ENC(K, R+2, RC) + IDtag
 468         if h.key != nil && ((!h.Conf.Encless && len(data) >= 16) ||
 469                 (h.Conf.Encless && len(data) == EnclessEnlargeSize+h.Conf.MTU)) {
 470                 var err error
 471                 // Decrypt rClient
 472                 var dec []byte
 473                 if h.Conf.Encless {
 474                         dec, err = EnclessDecode(h.key, h.rNonceNext(2), data[:len(data)-8])
 475                         if err != nil {
 476                                 return nil, errors.Wrap(err, wrapEnclessDecode)
 477                         }
 478                         dec = dec[:RSize]
 479                 } else {
 480                         dec = make([]byte, RSize)
 481                         chacha20.XORKeyStream(dec, data[:RSize], h.rNonceNext(2), h.key)
 482                 }
 483                 if subtle.ConstantTimeCompare(dec, h.rClient[:]) != 1 {
 484                         return nil, errors.New("Invalid client's random number")
 485                 }
 486
 487                 // Switch peer
 488                 peer, err := newPeer(
 489                         true,
 490                         h.addr,
 491                         h.conn,
 492                         h.Conf,
 493                         keyFromSecrets(h.sServer[:], h.sClient[:]),
 494                 )
 495                 if err != nil {
 496                         return nil, errors.Wrap(err, "newPeer")
 497                 }
 498                 h.LastPing = time.Now()
 499                 return peer, nil
 500         }
 501
 502         // no peer yet, no error
 503         return nil, nil
 504 }