Remove crypto/curve25519.h in favor of BoringSSL's.

net/quic/core/crypto/curve25519_key_exchange.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/core/crypto/curve25519_key_exchange.h"
 
 #include "base/logging.h"
-#include "crypto/curve25519.h"
 #include "net/quic/core/crypto/quic_random.h"
+#include "third_party/boringssl/src/include/openssl/curve25519.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 
 Curve25519KeyExchange::Curve25519KeyExchange() {}
 
 Curve25519KeyExchange::~Curve25519KeyExchange() {}
 
 // static
 Curve25519KeyExchange* Curve25519KeyExchange::New(StringPiece private_key) {
-  Curve25519KeyExchange* ka;
-  // We don't want to #include the NaCl headers in the public header file, so
-  // we use literals for the sizes of private_key_ and public_key_. Here we
-  // assert that those values are equal to the values from the NaCl header.
-  static_assert(sizeof(ka->private_key_) == crypto::curve25519::kScalarBytes,
-                "header out of sync");
-  static_assert(sizeof(ka->public_key_) == crypto::curve25519::kBytes,
-                "header out of sync");
-
-  if (private_key.size() != crypto::curve25519::kScalarBytes) {
+  if (private_key.size() != 32) {

[Ryan Hamilton, 2016/10/31 18:31:11]

This file is key in sync with the internal repository. Could these changes be
made there as well?

[davidben, 2016/10/31 18:36:19]

Sure. Though probably after the latter comment is resolved, which means I'll
park this for a week for it to roll into the internal repo. (That's fine. Not in
any hurry here or anything.)

[Ryan Hamilton, 2016/10/31 18:46:07]

Great, thanks! Let me know if I can help...

     return nullptr;
   }
 
-  ka = new Curve25519KeyExchange();
-  memcpy(ka->private_key_, private_key.data(),
-         crypto::curve25519::kScalarBytes);
-  crypto::curve25519::ScalarBaseMult(ka->private_key_, ka->public_key_);
+  Curve25519KeyExchange* ka = new Curve25519KeyExchange();
+  memcpy(ka->private_key_, private_key.data(), 32);

[Ryan Hamilton, 2016/10/31 18:31:11]

instead of 32 in several places, can we make this a kSomething?

[davidben, 2016/10/31 18:36:19]

They're just 32 in the header. I can add some constants though. Looks like we
have them for Ed25519, but not X25519.

https://commondatastorage.googleapis.com/chromium-boringssl-docs/curve25519.h...

[Ryan Hamilton, 2016/10/31 18:46:07]

Fee free to make the constant local to this file.

[davidben, 2016/10/31 18:49:56]

Eh, it's a fair comment and one that I think should be provided by BoringSSL's
header. I've uploaded:
https://boringssl-review.googlesource.com/c/11941/

(No big deal. This was just idle cleanup. If I cared, I'd cherry-pick it into
the internal repo, but I don't actually care enough. :-) )

+  X25519_public_from_private(ka->public_key_, ka->private_key_);
   return ka;
 }
 
 // static
 string Curve25519KeyExchange::NewPrivateKey(QuicRandom* rand) {
-  uint8_t private_key[crypto::curve25519::kScalarBytes];
+  uint8_t private_key[32];
   rand->RandBytes(private_key, sizeof(private_key));
 
   // This makes |private_key| a valid scalar, as specified on
   // http://cr.yp.to/ecdh.html
   private_key[0] &= 248;
   private_key[31] &= 127;
   private_key[31] |= 64;
   return string(reinterpret_cast<char*>(private_key), sizeof(private_key));
 }
 
 KeyExchange* Curve25519KeyExchange::NewKeyPair(QuicRandom* rand) const {
   const string private_value = NewPrivateKey(rand);
   return Curve25519KeyExchange::New(private_value);
 }
 
 bool Curve25519KeyExchange::CalculateSharedKey(StringPiece peer_public_value,
                                                string* out_result) const {
-  if (peer_public_value.size() != crypto::curve25519::kBytes) {
+  if (peer_public_value.size() != 32) {
     return false;
   }
 
-  uint8_t result[crypto::curve25519::kBytes];
-  if (!crypto::curve25519::ScalarMult(
-          private_key_,
-          reinterpret_cast<const uint8_t*>(peer_public_value.data()), result)) {
+  uint8_t result[32];
+  if (!X25519(result, private_key_,
+              reinterpret_cast<const uint8_t*>(peer_public_value.data()))) {
     return false;
   }
   out_result->assign(reinterpret_cast<char*>(result), sizeof(result));
 
   return true;
 }
 
 StringPiece Curve25519KeyExchange::public_value() const {
   return StringPiece(reinterpret_cast<const char*>(public_key_),
                      sizeof(public_key_));
 }
 
 QuicTag Curve25519KeyExchange::tag() const {
   return kC255;
 }
 
 }  // namespace net