Landing Recent QUIC changes until 5:55 PM, Aug 25, 2016 UTC-4

net/quic/core/quic_crypto_client_stream_test.cc

 // Copyright (c) 2012 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/quic_crypto_client_stream.h"
 
 #include <memory>
 
 #include "net/quic/core/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/core/crypto/quic_decrypter.h"
@@ skipping 22 matching lines @@
 
 class QuicCryptoClientStreamTest : public ::testing::Test {
  public:
   QuicCryptoClientStreamTest()
       : server_id_(kServerHostname, kServerPort, PRIVACY_MODE_DISABLED),
         crypto_config_(CryptoTestUtils::ProofVerifierForTesting()) {
     CreateConnection();
   }
 
   void CreateConnection() {
-    connection_ = new PacketSavingConnection(&helper_, &alarm_factory_,
+    connection_ = new PacketSavingConnection(&client_helper_, &alarm_factory_,
                                              Perspective::IS_CLIENT);
     // Advance the time, because timers do not like uninitialized times.
     connection_->AdvanceTime(QuicTime::Delta::FromSeconds(1));
 
     session_.reset(new TestQuicSpdyClientSession(
         connection_, DefaultQuicConfig(), server_id_, &crypto_config_));
   }
 
   void CompleteCryptoHandshake() {
     stream()->CryptoConnect();
     QuicConfig config;
-    CryptoTestUtils::HandshakeWithFakeServer(&config, &helper_, &alarm_factory_,
-                                             connection_, stream(),
-                                             server_options_);
+    CryptoTestUtils::HandshakeWithFakeServer(&config, &server_helper_,
+                                             &alarm_factory_, connection_,
+                                             stream(), server_options_);
   }
 
   void ConstructHandshakeMessage() {
     CryptoFramer framer;
     message_data_.reset(framer.ConstructHandshakeMessage(message_));
   }
 
   QuicCryptoClientStream* stream() { return session_->GetCryptoStream(); }
 
-  MockQuicConnectionHelper helper_;
+  MockQuicConnectionHelper server_helper_;
+  MockQuicConnectionHelper client_helper_;
   MockAlarmFactory alarm_factory_;
   PacketSavingConnection* connection_;
   std::unique_ptr<TestQuicSpdyClientSession> session_;
   QuicServerId server_id_;
   CryptoHandshakeMessage message_;
   std::unique_ptr<QuicData> message_data_;
   QuicCryptoClientConfig crypto_config_;
   CryptoTestUtils::FakeServerOptions server_options_;
 };
 
@@ skipping 56 matching lines @@
   CreateConnection();
 
   // Advance time 5 years to ensure that we pass the expiry time of the cached
   // server config.
   connection_->AdvanceTime(
       QuicTime::Delta::FromSeconds(60 * 60 * 24 * 365 * 5));
 
   stream()->CryptoConnect();
   // Check that a client hello was sent.
   ASSERT_EQ(1u, connection_->encrypted_packets_.size());
+  EXPECT_EQ(ENCRYPTION_NONE, connection_->encryption_level());
+}
+
+TEST_F(QuicCryptoClientStreamTest, ClockSkew) {
+  FLAGS_quic_send_scfg_ttl = true;
+  // Test that if the client's clock is skewed with respect to the server,
+  // the handshake succeeds. In the past, the client would get the server
+  // config, notice that it had already expired and then close the connection.
+
+  // Advance time 5 years to ensure that we pass the expiry time in the server
+  // config, but the TTL is used instead.
+  connection_->AdvanceTime(
+      QuicTime::Delta::FromSeconds(60 * 60 * 24 * 365 * 5));
+
+  // The handshakes completes!
+  CompleteCryptoHandshake();
 }
 
 TEST_F(QuicCryptoClientStreamTest, InvalidCachedServerConfig) {
   // Seed the config with a cached server config.
   CompleteCryptoHandshake();
 
   // Recreate connection with the new config.
   CreateConnection();
 
   QuicCryptoClientConfig::CachedState* state =
@@ skipping 36 matching lines @@
                           0x45, 0x58, 0x50, 0x59,
                           // EXPY end offset
                           0x08, 0x00, 0x00, 0x00,
                           // Value
                           '1', '2', '3', '4', '5', '6', '7', '8'};
 
   CryptoHandshakeMessage server_config_update;
   server_config_update.set_tag(kSCUP);
   server_config_update.SetValue(kSourceAddressTokenTag, stk);
   server_config_update.SetValue(kSCFG, scfg);
+  const uint64_t expiry_seconds = 60 * 60 * 24 * 2;
+  server_config_update.SetValue(kSTTL, expiry_seconds);
 
   std::unique_ptr<QuicData> data(
       CryptoFramer::ConstructHandshakeMessage(server_config_update));
   stream()->OnStreamFrame(QuicStreamFrame(kCryptoStreamId, /*fin=*/false,
                                           /*offset=*/0, data->AsStringPiece()));
 
   // Make sure that the STK and SCFG are cached correctly.
   EXPECT_EQ("xstk", state->source_address_token());
 
   string cached_scfg = state->server_config();
@@ skipping 145 matching lines @@
       client_state->GetNextServerDesignatedConnectionId();
   QuicConnectionId expected_id =
       server_session_->connection()->random_generator()->RandUint64();
   EXPECT_EQ(expected_id, server_designated_id);
   EXPECT_FALSE(client_state->has_server_designated_connection_id());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net