Implement QUIC key extraction.

net/quic/test_tools/crypto_test_utils.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/test_tools/crypto_test_utils.h"
 
 #include "net/quic/crypto/channel_id.h"
 #include "net/quic/crypto/common_cert_set.h"
 #include "net/quic/crypto/crypto_handshake.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
@@ skipping 434 matching lines @@
   StringPiece server_decrypter_iv = server_decrypter->GetNoncePrefix();
   StringPiece server_forward_secure_encrypter_key =
       server_forward_secure_encrypter->GetKey();
   StringPiece server_forward_secure_encrypter_iv =
       server_forward_secure_encrypter->GetNoncePrefix();
   StringPiece server_forward_secure_decrypter_key =
       server_forward_secure_decrypter->GetKey();
   StringPiece server_forward_secure_decrypter_iv =
       server_forward_secure_decrypter->GetNoncePrefix();
 
+  StringPiece client_subkey_secret =
+      client->crypto_negotiated_params().subkey_secret;
+  StringPiece server_subkey_secret =
+      server->crypto_negotiated_params().subkey_secret;
+
+
+  const char kSampleLabel[] = "label";
+  const char kSampleContext[] = "context";
+  const int kSampleOutputLength = 32;

[dmz, 2014/07/30 17:58:26]

Do you want to use size_t here like you suggested for me?

[wtc, 2014/07/30 18:09:35]

Done. Originally I wanted to see if it caused a compiler warning on any
platform. (The answer seems to be No based on the try bot results.)

+  string client_key_extraction;
+  string server_key_extraction;
+  EXPECT_TRUE(client->ExportKeyingMaterial(kSampleLabel,
+                                           kSampleContext,
+                                           kSampleOutputLength,
+                                           &client_key_extraction));
+  EXPECT_TRUE(server->ExportKeyingMaterial(kSampleLabel,
+                                           kSampleContext,
+                                           kSampleOutputLength,
+                                           &server_key_extraction));
+
   CompareCharArraysWithHexError("client write key",
                                 client_encrypter_key.data(),
                                 client_encrypter_key.length(),
                                 server_decrypter_key.data(),
                                 server_decrypter_key.length());
   CompareCharArraysWithHexError("client write IV",
                                 client_encrypter_iv.data(),
                                 client_encrypter_iv.length(),
                                 server_decrypter_iv.data(),
                                 server_decrypter_iv.length());
@@ skipping 20 matching lines @@
   CompareCharArraysWithHexError("server forward secure write key",
                                 server_forward_secure_encrypter_key.data(),
                                 server_forward_secure_encrypter_key.length(),
                                 client_forward_secure_decrypter_key.data(),
                                 client_forward_secure_decrypter_key.length());
   CompareCharArraysWithHexError("server forward secure write IV",
                                 server_forward_secure_encrypter_iv.data(),
                                 server_forward_secure_encrypter_iv.length(),
                                 client_forward_secure_decrypter_iv.data(),
                                 client_forward_secure_decrypter_iv.length());
+  CompareCharArraysWithHexError("subkey secret",
+                                client_subkey_secret.data(),
+                                client_subkey_secret.length(),
+                                server_subkey_secret.data(),
+                                server_subkey_secret.length());
+  CompareCharArraysWithHexError("sample key extraction",
+                                client_key_extraction.data(),
+                                client_key_extraction.length(),
+                                server_key_extraction.data(),
+                                server_key_extraction.length());
 }
 
 // static
 QuicTag CryptoTestUtils::ParseTag(const char* tagstr) {
   const size_t len = strlen(tagstr);
   CHECK_NE(0u, len);
 
   QuicTag tag = 0;
 
   if (tagstr[0] == '#') {
@@ skipping 89 matching lines @@
   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
   scoped_ptr<CryptoHandshakeMessage> parsed(
       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
   CHECK(parsed.get());
 
   return *parsed;
 }
 
 }  // namespace test
 }  // namespace net