net/quic/test_tools/crypto_test_utils.cc

   1 // Copyright (c) 2012 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/test_tools/crypto_test_utils.h"
   6
   7 #include "net/quic/crypto/channel_id.h"
   8 #include "net/quic/crypto/common_cert_set.h"
   9 #include "net/quic/crypto/crypto_handshake.h"
  10 #include "net/quic/crypto/quic_crypto_server_config.h"
  11 #include "net/quic/crypto/quic_decrypter.h"
  12 #include "net/quic/crypto/quic_encrypter.h"
  13 #include "net/quic/crypto/quic_random.h"
  14 #include "net/quic/quic_clock.h"
  15 #include "net/quic/quic_crypto_client_stream.h"
  16 #include "net/quic/quic_crypto_server_stream.h"
  17 #include "net/quic/quic_crypto_stream.h"
  18 #include "net/quic/quic_server_id.h"
  19 #include "net/quic/test_tools/quic_connection_peer.h"
  20 #include "net/quic/test_tools/quic_test_utils.h"
  21 #include "net/quic/test_tools/simple_quic_framer.h"
  22
  23 using base::StringPiece;
  24 using std::make_pair;
  25 using std::pair;
  26 using std::string;
  27 using std::vector;
  28
  29 namespace net {
  30 namespace test {
  31
  32 namespace {
  33
  34 const char kServerHostname[] = "test.example.com";
  35 const uint16 kServerPort = 80;
  36
  37 // CryptoFramerVisitor is a framer visitor that records handshake messages.
  38 class CryptoFramerVisitor : public CryptoFramerVisitorInterface {
  39  public:
  40   CryptoFramerVisitor()
  41       : error_(false) {
  42   }
  43
  44   virtual void OnError(CryptoFramer* framer) OVERRIDE { error_ = true; }
  45
  46   virtual void OnHandshakeMessage(
  47       const CryptoHandshakeMessage& message) OVERRIDE {
  48     messages_.push_back(message);
  49   }
  50
  51   bool error() const {
  52     return error_;
  53   }
  54
  55   const vector<CryptoHandshakeMessage>& messages() const {
  56     return messages_;
  57   }
  58
  59  private:
  60   bool error_;
  61   vector<CryptoHandshakeMessage> messages_;
  62 };
  63
  64 // MovePackets parses crypto handshake messages from packet number
  65 // |*inout_packet_index| through to the last packet (or until a packet fails to
  66 // decrypt) and has |dest_stream| process them. |*inout_packet_index| is updated
  67 // with an index one greater than the last packet processed.
  68 void MovePackets(PacketSavingConnection* source_conn,
  69                  size_t *inout_packet_index,
  70                  QuicCryptoStream* dest_stream,
  71                  PacketSavingConnection* dest_conn) {
  72   SimpleQuicFramer framer(source_conn->supported_versions());
  73   CryptoFramer crypto_framer;
  74   CryptoFramerVisitor crypto_visitor;
  75
  76   // In order to properly test the code we need to perform encryption and
  77   // decryption so that the crypters latch when expected. The crypters are in
  78   // |dest_conn|, but we don't want to try and use them there. Instead we swap
  79   // them into |framer|, perform the decryption with them, and then swap them
  80   // back.
  81   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
  82
  83   crypto_framer.set_visitor(&crypto_visitor);
  84
  85   size_t index = *inout_packet_index;
  86   for (; index < source_conn->encrypted_packets_.size(); index++) {
  87     if (!framer.ProcessPacket(*source_conn->encrypted_packets_[index])) {
  88       // The framer will be unable to decrypt forward-secure packets sent after
  89       // the handshake is complete. Don't treat them as handshake packets.
  90       break;
  91     }
  92
  93     for (vector<QuicStreamFrame>::const_iterator
  94          i =  framer.stream_frames().begin();
  95          i != framer.stream_frames().end(); ++i) {
  96       scoped_ptr<string> frame_data(i->GetDataAsString());
  97       ASSERT_TRUE(crypto_framer.ProcessInput(*frame_data));
  98       ASSERT_FALSE(crypto_visitor.error());
  99     }
 100   }
 101   *inout_packet_index = index;
 102
 103   QuicConnectionPeer::SwapCrypters(dest_conn, framer.framer());
 104
 105   ASSERT_EQ(0u, crypto_framer.InputBytesRemaining());
 106
 107   for (vector<CryptoHandshakeMessage>::const_iterator
 108        i = crypto_visitor.messages().begin();
 109        i != crypto_visitor.messages().end(); ++i) {
 110     dest_stream->OnHandshakeMessage(*i);
 111   }
 112 }
 113
 114 // HexChar parses |c| as a hex character. If valid, it sets |*value| to the
 115 // value of the hex character and returns true. Otherwise it returns false.
 116 bool HexChar(char c, uint8* value) {
 117   if (c >= '0' && c <= '9') {
 118     *value = c - '0';
 119     return true;
 120   }
 121   if (c >= 'a' && c <= 'f') {
 122     *value = c - 'a' + 10;
 123     return true;
 124   }
 125   if (c >= 'A' && c <= 'F') {
 126     *value = c - 'A' + 10;
 127     return true;
 128   }
 129   return false;
 130 }
 131
 132 // A ChannelIDSource that works in asynchronous mode unless the |callback|
 133 // argument to GetChannelIDKey is NULL.
 134 class AsyncTestChannelIDSource : public ChannelIDSource,
 135                                  public CryptoTestUtils::CallbackSource {
 136  public:
 137   // Takes ownership of |sync_source|, a synchronous ChannelIDSource.
 138   explicit AsyncTestChannelIDSource(ChannelIDSource* sync_source)
 139       : sync_source_(sync_source) {}
 140   virtual ~AsyncTestChannelIDSource() {}
 141
 142   // ChannelIDSource implementation.
 143   virtual QuicAsyncStatus GetChannelIDKey(
 144       const string& hostname,
 145       scoped_ptr<ChannelIDKey>* channel_id_key,
 146       ChannelIDSourceCallback* callback) OVERRIDE {
 147     // Synchronous mode.
 148     if (!callback) {
 149       return sync_source_->GetChannelIDKey(hostname, channel_id_key, NULL);
 150     }
 151
 152     // Asynchronous mode.
 153     QuicAsyncStatus status =
 154         sync_source_->GetChannelIDKey(hostname, &channel_id_key_, NULL);
 155     if (status != QUIC_SUCCESS) {
 156       return QUIC_FAILURE;
 157     }
 158     callback_.reset(callback);
 159     return QUIC_PENDING;
 160   }
 161
 162   // CallbackSource implementation.
 163   virtual void RunPendingCallbacks() OVERRIDE {
 164     if (callback_.get()) {
 165       callback_->Run(&channel_id_key_);
 166       callback_.reset();
 167     }
 168   }
 169
 170  private:
 171   scoped_ptr<ChannelIDSource> sync_source_;
 172   scoped_ptr<ChannelIDSourceCallback> callback_;
 173   scoped_ptr<ChannelIDKey> channel_id_key_;
 174 };
 175
 176 }  // anonymous namespace
 177
 178 CryptoTestUtils::FakeClientOptions::FakeClientOptions()
 179     : dont_verify_certs(false),
 180       channel_id_enabled(false),
 181       channel_id_source_async(false) {
 182 }
 183
 184 // static
 185 int CryptoTestUtils::HandshakeWithFakeServer(
 186     PacketSavingConnection* client_conn,
 187     QuicCryptoClientStream* client) {
 188   PacketSavingConnection* server_conn =
 189       new PacketSavingConnection(true, client_conn->supported_versions());
 190   TestSession server_session(server_conn, DefaultQuicConfig());
 191   server_session.InitializeSession();
 192   QuicCryptoServerConfig crypto_config(QuicCryptoServerConfig::TESTING,
 193                                        QuicRandom::GetInstance());
 194
 195   SetupCryptoServerConfigForTest(
 196       server_session.connection()->clock(),
 197       server_session.connection()->random_generator(),
 198       server_session.config(), &crypto_config);
 199
 200   QuicCryptoServerStream server(crypto_config, &server_session);
 201   server_session.SetCryptoStream(&server);
 202
 203   // The client's handshake must have been started already.
 204   CHECK_NE(0u, client_conn->packets_.size());
 205
 206   CommunicateHandshakeMessages(client_conn, client, server_conn, &server);
 207
 208   CompareClientAndServerKeys(client, &server);
 209
 210   return client->num_sent_client_hellos();
 211 }
 212
 213 // static
 214 int CryptoTestUtils::HandshakeWithFakeClient(
 215     PacketSavingConnection* server_conn,
 216     QuicCryptoServerStream* server,
 217     const FakeClientOptions& options) {
 218   PacketSavingConnection* client_conn = new PacketSavingConnection(false);
 219   TestClientSession client_session(client_conn, DefaultQuicConfig());
 220   QuicCryptoClientConfig crypto_config;
 221
 222   client_session.config()->SetDefaults();
 223   crypto_config.SetDefaults();
 224   if (!options.dont_verify_certs) {
 225     // TODO(wtc): replace this with ProofVerifierForTesting() when we have
 226     // a working ProofSourceForTesting().
 227     crypto_config.SetProofVerifier(FakeProofVerifierForTesting());
 228   }
 229   bool is_https = false;
 230   AsyncTestChannelIDSource* async_channel_id_source = NULL;
 231   if (options.channel_id_enabled) {
 232     is_https = true;
 233
 234     ChannelIDSource* source = ChannelIDSourceForTesting();
 235     if (options.channel_id_source_async) {
 236       async_channel_id_source = new AsyncTestChannelIDSource(source);
 237       source = async_channel_id_source;
 238     }
 239     crypto_config.SetChannelIDSource(source);
 240   }
 241   QuicServerId server_id(kServerHostname, kServerPort, is_https,
 242                          PRIVACY_MODE_DISABLED);
 243   QuicCryptoClientStream client(server_id, &client_session,
 244                                 ProofVerifyContextForTesting(),
 245                                 &crypto_config);
 246   client_session.SetCryptoStream(&client);
 247
 248   CHECK(client.CryptoConnect());
 249   CHECK_EQ(1u, client_conn->packets_.size());
 250
 251   CommunicateHandshakeMessagesAndRunCallbacks(
 252       client_conn, &client, server_conn, server, async_channel_id_source);
 253
 254   CompareClientAndServerKeys(&client, server);
 255
 256   if (options.channel_id_enabled) {
 257     scoped_ptr<ChannelIDKey> channel_id_key;
 258     QuicAsyncStatus status =
 259         crypto_config.channel_id_source()->GetChannelIDKey(kServerHostname,
 260                                                            &channel_id_key,
 261                                                            NULL);
 262     EXPECT_EQ(QUIC_SUCCESS, status);
 263     EXPECT_EQ(channel_id_key->SerializeKey(),
 264               server->crypto_negotiated_params().channel_id);
 265     EXPECT_EQ(options.channel_id_source_async,
 266               client.WasChannelIDSourceCallbackRun());
 267   }
 268
 269   return client.num_sent_client_hellos();
 270 }
 271
 272 // static
 273 void CryptoTestUtils::SetupCryptoServerConfigForTest(
 274     const QuicClock* clock,
 275     QuicRandom* rand,
 276     QuicConfig* config,
 277     QuicCryptoServerConfig* crypto_config) {
 278   config->SetDefaults();
 279   QuicCryptoServerConfig::ConfigOptions options;
 280   options.channel_id_enabled = true;
 281   scoped_ptr<CryptoHandshakeMessage> scfg(
 282       crypto_config->AddDefaultConfig(rand, clock, options));
 283 }
 284
 285 // static
 286 void CryptoTestUtils::CommunicateHandshakeMessages(
 287     PacketSavingConnection* a_conn,
 288     QuicCryptoStream* a,
 289     PacketSavingConnection* b_conn,
 290     QuicCryptoStream* b) {
 291   CommunicateHandshakeMessagesAndRunCallbacks(a_conn, a, b_conn, b, NULL);
 292 }
 293
 294 // static
 295 void CryptoTestUtils::CommunicateHandshakeMessagesAndRunCallbacks(
 296     PacketSavingConnection* a_conn,
 297     QuicCryptoStream* a,
 298     PacketSavingConnection* b_conn,
 299     QuicCryptoStream* b,
 300     CallbackSource* callback_source) {
 301   size_t a_i = 0, b_i = 0;
 302   while (!a->handshake_confirmed()) {
 303     ASSERT_GT(a_conn->packets_.size(), a_i);
 304     LOG(INFO) << "Processing " << a_conn->packets_.size() - a_i
 305               << " packets a->b";
 306     MovePackets(a_conn, &a_i, b, b_conn);
 307     if (callback_source) {
 308       callback_source->RunPendingCallbacks();
 309     }
 310
 311     ASSERT_GT(b_conn->packets_.size(), b_i);
 312     LOG(INFO) << "Processing " << b_conn->packets_.size() - b_i
 313               << " packets b->a";
 314     MovePackets(b_conn, &b_i, a, a_conn);
 315     if (callback_source) {
 316       callback_source->RunPendingCallbacks();
 317     }
 318   }
 319 }
 320
 321 // static
 322 pair<size_t, size_t> CryptoTestUtils::AdvanceHandshake(
 323     PacketSavingConnection* a_conn,
 324     QuicCryptoStream* a,
 325     size_t a_i,
 326     PacketSavingConnection* b_conn,
 327     QuicCryptoStream* b,
 328     size_t b_i) {
 329   LOG(INFO) << "Processing " << a_conn->packets_.size() - a_i
 330             << " packets a->b";
 331   MovePackets(a_conn, &a_i, b, b_conn);
 332
 333   LOG(INFO) << "Processing " << b_conn->packets_.size() - b_i
 334             << " packets b->a";
 335   if (b_conn->packets_.size() - b_i == 2) {
 336     LOG(INFO) << "here";
 337   }
 338   MovePackets(b_conn, &b_i, a, a_conn);
 339
 340   return make_pair(a_i, b_i);
 341 }
 342
 343 // static
 344 string CryptoTestUtils::GetValueForTag(const CryptoHandshakeMessage& message,
 345                                        QuicTag tag) {
 346   QuicTagValueMap::const_iterator it = message.tag_value_map().find(tag);
 347   if (it == message.tag_value_map().end()) {
 348     return string();
 349   }
 350   return it->second;
 351 }
 352
 353 class MockCommonCertSets : public CommonCertSets {
 354  public:
 355   MockCommonCertSets(StringPiece cert, uint64 hash, uint32 index)
 356       : cert_(cert.as_string()),
 357         hash_(hash),
 358         index_(index) {
 359   }
 360
 361   virtual StringPiece GetCommonHashes() const OVERRIDE {
 362     CHECK(false) << "not implemented";
 363     return StringPiece();
 364   }
 365
 366   virtual StringPiece GetCert(uint64 hash, uint32 index) const OVERRIDE {
 367     if (hash == hash_ && index == index_) {
 368       return cert_;
 369     }
 370     return StringPiece();
 371   }
 372
 373   virtual bool MatchCert(StringPiece cert,
 374                          StringPiece common_set_hashes,
 375                          uint64* out_hash,
 376                          uint32* out_index) const OVERRIDE {
 377     if (cert != cert_) {
 378       return false;
 379     }
 380
 381     if (common_set_hashes.size() % sizeof(uint64) != 0) {
 382       return false;
 383     }
 384     bool client_has_set = false;
 385     for (size_t i = 0; i < common_set_hashes.size(); i += sizeof(uint64)) {
 386       uint64 hash;
 387       memcpy(&hash, common_set_hashes.data() + i, sizeof(hash));
 388       if (hash == hash_) {
 389         client_has_set = true;
 390         break;
 391       }
 392     }
 393
 394     if (!client_has_set) {
 395       return false;
 396     }
 397
 398     *out_hash = hash_;
 399     *out_index = index_;
 400     return true;
 401   }
 402
 403  private:
 404   const string cert_;
 405   const uint64 hash_;
 406   const uint32 index_;
 407 };
 408
 409 CommonCertSets* CryptoTestUtils::MockCommonCertSets(StringPiece cert,
 410                                                     uint64 hash,
 411                                                     uint32 index) {
 412   return new class MockCommonCertSets(cert, hash, index);
 413 }
 414
 415 void CryptoTestUtils::CompareClientAndServerKeys(
 416     QuicCryptoClientStream* client,
 417     QuicCryptoServerStream* server) {
 418   const QuicEncrypter* client_encrypter(
 419       client->session()->connection()->encrypter(ENCRYPTION_INITIAL));
 420   const QuicDecrypter* client_decrypter(
 421       client->session()->connection()->decrypter());
 422   const QuicEncrypter* client_forward_secure_encrypter(
 423       client->session()->connection()->encrypter(ENCRYPTION_FORWARD_SECURE));
 424   const QuicDecrypter* client_forward_secure_decrypter(
 425       client->session()->connection()->alternative_decrypter());
 426   const QuicEncrypter* server_encrypter(
 427       server->session()->connection()->encrypter(ENCRYPTION_INITIAL));
 428   const QuicDecrypter* server_decrypter(
 429       server->session()->connection()->decrypter());
 430   const QuicEncrypter* server_forward_secure_encrypter(
 431       server->session()->connection()->encrypter(ENCRYPTION_FORWARD_SECURE));
 432   const QuicDecrypter* server_forward_secure_decrypter(
 433       server->session()->connection()->alternative_decrypter());
 434
 435   StringPiece client_encrypter_key = client_encrypter->GetKey();
 436   StringPiece client_encrypter_iv = client_encrypter->GetNoncePrefix();
 437   StringPiece client_decrypter_key = client_decrypter->GetKey();
 438   StringPiece client_decrypter_iv = client_decrypter->GetNoncePrefix();
 439   StringPiece client_forward_secure_encrypter_key =
 440       client_forward_secure_encrypter->GetKey();
 441   StringPiece client_forward_secure_encrypter_iv =
 442       client_forward_secure_encrypter->GetNoncePrefix();
 443   StringPiece client_forward_secure_decrypter_key =
 444       client_forward_secure_decrypter->GetKey();
 445   StringPiece client_forward_secure_decrypter_iv =
 446       client_forward_secure_decrypter->GetNoncePrefix();
 447   StringPiece server_encrypter_key = server_encrypter->GetKey();
 448   StringPiece server_encrypter_iv = server_encrypter->GetNoncePrefix();
 449   StringPiece server_decrypter_key = server_decrypter->GetKey();
 450   StringPiece server_decrypter_iv = server_decrypter->GetNoncePrefix();
 451   StringPiece server_forward_secure_encrypter_key =
 452       server_forward_secure_encrypter->GetKey();
 453   StringPiece server_forward_secure_encrypter_iv =
 454       server_forward_secure_encrypter->GetNoncePrefix();
 455   StringPiece server_forward_secure_decrypter_key =
 456       server_forward_secure_decrypter->GetKey();
 457   StringPiece server_forward_secure_decrypter_iv =
 458       server_forward_secure_decrypter->GetNoncePrefix();
 459
 460   StringPiece client_subkey_secret =
 461       client->crypto_negotiated_params().subkey_secret;
 462   StringPiece server_subkey_secret =
 463       server->crypto_negotiated_params().subkey_secret;
 464
 465
 466   const char kSampleLabel[] = "label";
 467   const char kSampleContext[] = "context";
 468   const size_t kSampleOutputLength = 32;
 469   string client_key_extraction;
 470   string server_key_extraction;
 471   EXPECT_TRUE(client->ExportKeyingMaterial(kSampleLabel,
 472                                            kSampleContext,
 473                                            kSampleOutputLength,
 474                                            &client_key_extraction));
 475   EXPECT_TRUE(server->ExportKeyingMaterial(kSampleLabel,
 476                                            kSampleContext,
 477                                            kSampleOutputLength,
 478                                            &server_key_extraction));
 479
 480   CompareCharArraysWithHexError("client write key",
 481                                 client_encrypter_key.data(),
 482                                 client_encrypter_key.length(),
 483                                 server_decrypter_key.data(),
 484                                 server_decrypter_key.length());
 485   CompareCharArraysWithHexError("client write IV",
 486                                 client_encrypter_iv.data(),
 487                                 client_encrypter_iv.length(),
 488                                 server_decrypter_iv.data(),
 489                                 server_decrypter_iv.length());
 490   CompareCharArraysWithHexError("server write key",
 491                                 server_encrypter_key.data(),
 492                                 server_encrypter_key.length(),
 493                                 client_decrypter_key.data(),
 494                                 client_decrypter_key.length());
 495   CompareCharArraysWithHexError("server write IV",
 496                                 server_encrypter_iv.data(),
 497                                 server_encrypter_iv.length(),
 498                                 client_decrypter_iv.data(),
 499                                 client_decrypter_iv.length());
 500   CompareCharArraysWithHexError("client forward secure write key",
 501                                 client_forward_secure_encrypter_key.data(),
 502                                 client_forward_secure_encrypter_key.length(),
 503                                 server_forward_secure_decrypter_key.data(),
 504                                 server_forward_secure_decrypter_key.length());
 505   CompareCharArraysWithHexError("client forward secure write IV",
 506                                 client_forward_secure_encrypter_iv.data(),
 507                                 client_forward_secure_encrypter_iv.length(),
 508                                 server_forward_secure_decrypter_iv.data(),
 509                                 server_forward_secure_decrypter_iv.length());
 510   CompareCharArraysWithHexError("server forward secure write key",
 511                                 server_forward_secure_encrypter_key.data(),
 512                                 server_forward_secure_encrypter_key.length(),
 513                                 client_forward_secure_decrypter_key.data(),
 514                                 client_forward_secure_decrypter_key.length());
 515   CompareCharArraysWithHexError("server forward secure write IV",
 516                                 server_forward_secure_encrypter_iv.data(),
 517                                 server_forward_secure_encrypter_iv.length(),
 518                                 client_forward_secure_decrypter_iv.data(),
 519                                 client_forward_secure_decrypter_iv.length());
 520   CompareCharArraysWithHexError("subkey secret",
 521                                 client_subkey_secret.data(),
 522                                 client_subkey_secret.length(),
 523                                 server_subkey_secret.data(),
 524                                 server_subkey_secret.length());
 525   CompareCharArraysWithHexError("sample key extraction",
 526                                 client_key_extraction.data(),
 527                                 client_key_extraction.length(),
 528                                 server_key_extraction.data(),
 529                                 server_key_extraction.length());
 530 }
 531
 532 // static
 533 QuicTag CryptoTestUtils::ParseTag(const char* tagstr) {
 534   const size_t len = strlen(tagstr);
 535   CHECK_NE(0u, len);
 536
 537   QuicTag tag = 0;
 538
 539   if (tagstr[0] == '#') {
 540     CHECK_EQ(static_cast<size_t>(1 + 2*4), len);
 541     tagstr++;
 542
 543     for (size_t i = 0; i < 8; i++) {
 544       tag <<= 4;
 545
 546       uint8 v = 0;
 547       CHECK(HexChar(tagstr[i], &v));
 548       tag |= v;
 549     }
 550
 551     return tag;
 552   }
 553
 554   CHECK_LE(len, 4u);
 555   for (size_t i = 0; i < 4; i++) {
 556     tag >>= 8;
 557     if (i < len) {
 558       tag |= static_cast<uint32>(tagstr[i]) << 24;
 559     }
 560   }
 561
 562   return tag;
 563 }
 564
 565 // static
 566 CryptoHandshakeMessage CryptoTestUtils::Message(const char* message_tag, ...) {
 567   va_list ap;
 568   va_start(ap, message_tag);
 569
 570   CryptoHandshakeMessage message = BuildMessage(message_tag, ap);
 571   va_end(ap);
 572   return message;
 573 }
 574
 575 // static
 576 CryptoHandshakeMessage CryptoTestUtils::BuildMessage(const char* message_tag,
 577                                                      va_list ap) {
 578   CryptoHandshakeMessage msg;
 579   msg.set_tag(ParseTag(message_tag));
 580
 581   for (;;) {
 582     const char* tagstr = va_arg(ap, const char*);
 583     if (tagstr == NULL) {
 584       break;
 585     }
 586
 587     if (tagstr[0] == '$') {
 588       // Special value.
 589       const char* const special = tagstr + 1;
 590       if (strcmp(special, "padding") == 0) {
 591         const int min_bytes = va_arg(ap, int);
 592         msg.set_minimum_size(min_bytes);
 593       } else {
 594         CHECK(false) << "Unknown special value: " << special;
 595       }
 596
 597       continue;
 598     }
 599
 600     const QuicTag tag = ParseTag(tagstr);
 601     const char* valuestr = va_arg(ap, const char*);
 602
 603     size_t len = strlen(valuestr);
 604     if (len > 0 && valuestr[0] == '#') {
 605       valuestr++;
 606       len--;
 607
 608       CHECK_EQ(0u, len % 2);
 609       scoped_ptr<uint8[]> buf(new uint8[len/2]);
 610
 611       for (size_t i = 0; i < len/2; i++) {
 612         uint8 v = 0;
 613         CHECK(HexChar(valuestr[i*2], &v));
 614         buf[i] = v << 4;
 615         CHECK(HexChar(valuestr[i*2 + 1], &v));
 616         buf[i] |= v;
 617       }
 618
 619       msg.SetStringPiece(
 620           tag, StringPiece(reinterpret_cast<char*>(buf.get()), len/2));
 621       continue;
 622     }
 623
 624     msg.SetStringPiece(tag, valuestr);
 625   }
 626
 627   // The CryptoHandshakeMessage needs to be serialized and parsed to ensure
 628   // that any padding is included.
 629   scoped_ptr<QuicData> bytes(CryptoFramer::ConstructHandshakeMessage(msg));
 630   scoped_ptr<CryptoHandshakeMessage> parsed(
 631       CryptoFramer::ParseMessage(bytes->AsStringPiece()));
 632   CHECK(parsed.get());
 633
 634   return *parsed;
 635 }
 636
 637 }  // namespace test
 638 }  // namespace net