relnote: remove insecure QUIC support

net/quic/crypto/quic_crypto_server_config_test.cc

 // Copyright 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/crypto/quic_crypto_server_config.h"
 
 #include <stdarg.h>
 
 #include "base/stl_util.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/crypto_handshake_message.h"
 #include "net/quic/crypto/crypto_secret_boxer.h"
 #include "net/quic/crypto/crypto_server_config_protobuf.h"
 #include "net/quic/crypto/quic_random.h"
 #include "net/quic/crypto/strike_register_client.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_time.h"
+#include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::map;
 using std::pair;
 using std::string;
 using std::vector;
@@ skipping 183 matching lines @@
 
   bool is_known_orbit_called() { return is_known_orbit_called_; }
 
  private:
   QuicCryptoServerConfig* config_;
   mutable bool is_known_orbit_called_;
 };
 
 TEST(QuicCryptoServerConfigTest, ServerConfig) {
   QuicRandom* rand = QuicRandom::GetInstance();
-  QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
+  QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
+                                CryptoTestUtils::ProofSourceForTesting());
   MockClock clock;
 
   scoped_ptr<CryptoHandshakeMessage>(
       server.AddDefaultConfig(rand, &clock,
                               QuicCryptoServerConfig::ConfigOptions()));
 }
 
 TEST(QuicCryptoServerConfigTest, GetOrbitIsCalledWithoutTheStrikeRegisterLock) {
   QuicRandom* rand = QuicRandom::GetInstance();
-  QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
+  QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
+                                CryptoTestUtils::ProofSourceForTesting());
   MockClock clock;
 
   TestStrikeRegisterClient* strike_register =
       new TestStrikeRegisterClient(&server);
   server.SetStrikeRegisterClient(strike_register);
 
   QuicCryptoServerConfig::ConfigOptions options;
   scoped_ptr<CryptoHandshakeMessage> message(
       server.AddDefaultConfig(rand, &clock, options));
   EXPECT_TRUE(strike_register->is_known_orbit_called());
 }
 
 class SourceAddressTokenTest : public ::testing::Test {
  public:
   SourceAddressTokenTest()
       : ip4_(Loopback4()),
         ip4_dual_(ConvertIPv4NumberToIPv6Number(ip4_)),
         ip6_(Loopback6()),
         original_time_(QuicWallTime::Zero()),
         rand_(QuicRandom::GetInstance()),
-        server_(QuicCryptoServerConfig::TESTING, rand_),
+        server_(QuicCryptoServerConfig::TESTING,
+                rand_,
+                CryptoTestUtils::ProofSourceForTesting()),
         peer_(&server_) {
     // Advance the clock to some non-zero time.
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1000000));
     original_time_ = clock_.WallNow();
 
     primary_config_.reset(server_.AddDefaultConfig(
         rand_, &clock_, QuicCryptoServerConfig::ConfigOptions()));
 
     // Add a config that overrides the default boxer.
     QuicCryptoServerConfig::ConfigOptions options;
@@ skipping 152 matching lines @@
       NewSourceAddressToken(kPrimary, ip4_, previous_tokens);
 
   EXPECT_EQ(HANDSHAKE_OK,
             ValidateSourceAddressTokens(kPrimary, token4or6, ip4_));
   ASSERT_EQ(HANDSHAKE_OK,
             ValidateSourceAddressTokens(kPrimary, token4or6, ip6_));
 }
 
 TEST(QuicCryptoServerConfigTest, ValidateServerNonce) {
   QuicRandom* rand = QuicRandom::GetInstance();
-  QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand);
+  QuicCryptoServerConfig server(QuicCryptoServerConfig::TESTING, rand,
+                                CryptoTestUtils::ProofSourceForTesting());
   QuicCryptoServerConfigPeer peer(&server);
 
   StringPiece message("hello world");
   const size_t key_size = CryptoSecretBoxer::GetKeySize();
   scoped_ptr<uint8[]> key(new uint8[key_size]);
   memset(key.get(), 0x11, key_size);
 
   CryptoSecretBoxer boxer;
   boxer.SetKey(StringPiece(reinterpret_cast<char*>(key.get()), key_size));
   const string box = boxer.Box(rand, message);
@@ skipping 10 matching lines @@
 
   now = original_time.Add(QuicTime::Delta::FromSeconds(1000 * 7));
   server_nonce = peer.NewServerNonce(rand, now);
   EXPECT_EQ(HANDSHAKE_OK, peer.ValidateServerNonce(server_nonce, now));
 }
 
 class CryptoServerConfigsTest : public ::testing::Test {
  public:
   CryptoServerConfigsTest()
       : rand_(QuicRandom::GetInstance()),
-        config_(QuicCryptoServerConfig::TESTING, rand_),
+        config_(QuicCryptoServerConfig::TESTING,
+                rand_,
+                CryptoTestUtils::ProofSourceForTesting()),
         test_peer_(&config_) {}
 
   void SetUp() override {
     clock_.AdvanceTime(QuicTime::Delta::FromSeconds(1000));
   }
 
   // SetConfigs constructs suitable config protobufs and calls SetConfigs on
   // |config_|. The arguments are given as nullptr-terminated pairs. The first
   // of each pair is the server config ID of a Config. The second is the
   // |primary_time| of that Config, given in epoch seconds. (Although note that,
@@ skipping 282 matching lines @@
              nullptr);
   test_peer_.CheckConfigs(
       "a", false,
       "b", true,
       "c", false,
       nullptr);
 }
 
 }  // namespace test
 }  // namespace net