net/quic/crypto/curve25519_key_exchange.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "net/quic/crypto/curve25519_key_exchange.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/logging.h"
   9 #include "crypto/curve25519.h"
  10 #include "net/quic/crypto/quic_random.h"
  11
  12 using base::StringPiece;
  13 using std::string;
  14
  15 namespace net {
  16
  17 Curve25519KeyExchange::Curve25519KeyExchange() {}
  18
  19 Curve25519KeyExchange::~Curve25519KeyExchange() {}
  20
  21 // static
  22 Curve25519KeyExchange* Curve25519KeyExchange::New(
  23     const StringPiece& private_key) {
  24   Curve25519KeyExchange* ka;
  25   // We don't want to #include the NaCl headers in the public header file, so
  26   // we use literals for the sizes of private_key_ and public_key_. Here we
  27   // assert that those values are equal to the values from the NaCl header.
  28   COMPILE_ASSERT(
  29       sizeof(ka->private_key_) == crypto::curve25519::kScalarBytes,
  30       header_out_of_sync);
  31   COMPILE_ASSERT(sizeof(ka->public_key_) == crypto::curve25519::kBytes,
  32                  header_out_of_sync);
  33
  34   if (private_key.size() != crypto::curve25519::kScalarBytes) {
  35     return NULL;
  36   }
  37
  38   ka = new Curve25519KeyExchange();
  39   memcpy(ka->private_key_, private_key.data(),
  40          crypto::curve25519::kScalarBytes);
  41   crypto::curve25519::ScalarBaseMult(ka->private_key_, ka->public_key_);
  42   return ka;
  43 }
  44
  45 // static
  46 string Curve25519KeyExchange::NewPrivateKey(QuicRandom* rand) {
  47   uint8 private_key[crypto::curve25519::kScalarBytes];
  48   rand->RandBytes(private_key, sizeof(private_key));
  49
  50   // This makes |private_key| a valid scalar, as specified on
  51   // http://cr.yp.to/ecdh.html
  52   private_key[0] &= 248;
  53   private_key[31] &= 127;
  54   private_key[31] |= 64;
  55   return string(reinterpret_cast<char*>(private_key), sizeof(private_key));
  56 }
  57
  58 KeyExchange* Curve25519KeyExchange::NewKeyPair(QuicRandom* rand) const {
  59   const string private_value = NewPrivateKey(rand);
  60   return Curve25519KeyExchange::New(private_value);
  61 }
  62
  63 bool Curve25519KeyExchange::CalculateSharedKey(
  64     const StringPiece& peer_public_value,
  65     string* out_result) const {
  66   if (peer_public_value.size() != crypto::curve25519::kBytes) {
  67     return false;
  68   }
  69
  70   uint8 result[crypto::curve25519::kBytes];
  71   crypto::curve25519::ScalarMult(
  72       private_key_,
  73       reinterpret_cast<const uint8*>(peer_public_value.data()),
  74       result);
  75   out_result->assign(reinterpret_cast<char*>(result), sizeof(result));
  76
  77   return true;
  78 }
  79
  80 StringPiece Curve25519KeyExchange::public_value() const {
  81   return StringPiece(reinterpret_cast<const char*>(public_key_),
  82                      sizeof(public_key_));
  83 }
  84
  85 QuicTag Curve25519KeyExchange::tag() const { return kC255; }
  86
  87 }  // namespace net