net/quic/test_tools/crypto_test_utils.h

   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 #ifndef NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
   6 #define NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_
   7
   8 #include <stdarg.h>
   9
  10 #include <utility>
  11 #include <vector>
  12
  13 #include "base/basictypes.h"
  14 #include "base/logging.h"
  15 #include "base/strings/string_piece.h"
  16 #include "net/quic/crypto/crypto_framer.h"
  17 #include "net/quic/quic_framer.h"
  18 #include "net/quic/quic_protocol.h"
  19
  20 namespace net {
  21
  22 class ChannelIDSource;
  23 class CommonCertSets;
  24 class ProofSource;
  25 class ProofVerifier;
  26 class ProofVerifyContext;
  27 class QuicClock;
  28 class QuicConfig;
  29 class QuicCryptoClientStream;
  30 class QuicCryptoServerConfig;
  31 class QuicCryptoServerStream;
  32 class QuicCryptoStream;
  33 class QuicRandom;
  34
  35 namespace test {
  36
  37 class PacketSavingConnection;
  38
  39 class CryptoTestUtils {
  40  public:
  41   // An interface for a source of callbacks. This is used for invoking
  42   // callbacks asynchronously.
  43   //
  44   // Call the RunPendingCallbacks method regularly to run the callbacks from
  45   // this source.
  46   class CallbackSource {
  47    public:
  48     virtual ~CallbackSource() {}
  49
  50     // Runs pending callbacks from this source. If there is no pending
  51     // callback, does nothing.
  52     virtual void RunPendingCallbacks() = 0;
  53   };
  54
  55   // FakeClientOptions bundles together a number of options for configuring
  56   // HandshakeWithFakeClient.
  57   struct FakeClientOptions {
  58     FakeClientOptions();
  59
  60     // If dont_verify_certs is true then no ProofVerifier is set on the client.
  61     // Thus no certificates will be requested or checked.
  62     bool dont_verify_certs;
  63
  64     // If channel_id_enabled is true then the client will attempt to send a
  65     // ChannelID.
  66     bool channel_id_enabled;
  67
  68     // If channel_id_source_async is true then the client will use an async
  69     // ChannelIDSource for testing. Ignored if channel_id_enabled is false.
  70     bool channel_id_source_async;
  71   };
  72
  73   // returns: the number of client hellos that the client sent.
  74   static int HandshakeWithFakeServer(PacketSavingConnection* client_conn,
  75                                      QuicCryptoClientStream* client);
  76
  77   // returns: the number of client hellos that the client sent.
  78   static int HandshakeWithFakeClient(PacketSavingConnection* server_conn,
  79                                      QuicCryptoServerStream* server,
  80                                      const FakeClientOptions& options);
  81
  82   // SetupCryptoServerConfigForTest configures |config| and |crypto_config|
  83   // with sensible defaults for testing.
  84   static void SetupCryptoServerConfigForTest(
  85       const QuicClock* clock,
  86       QuicRandom* rand,
  87       QuicConfig* config,
  88       QuicCryptoServerConfig* crypto_config);
  89
  90   // CommunicateHandshakeMessages moves messages from |a| to |b| and back until
  91   // |a|'s handshake has completed.
  92   static void CommunicateHandshakeMessages(PacketSavingConnection* a_conn,
  93                                            QuicCryptoStream* a,
  94                                            PacketSavingConnection* b_conn,
  95                                            QuicCryptoStream* b);
  96
  97   // CommunicateHandshakeMessagesAndRunCallbacks moves messages from |a| to |b|
  98   // and back until |a|'s handshake has completed. If |callback_source| is not
  99   // NULL, CommunicateHandshakeMessagesAndRunCallbacks also runs callbacks from
 100   // |callback_source| between processing messages.
 101   static void CommunicateHandshakeMessagesAndRunCallbacks(
 102       PacketSavingConnection* a_conn,
 103       QuicCryptoStream* a,
 104       PacketSavingConnection* b_conn,
 105       QuicCryptoStream* b,
 106       CallbackSource* callback_source);
 107
 108   // AdvanceHandshake attempts to moves messages from |a| to |b| and |b| to |a|.
 109   // Returns the number of messages moved.
 110   static std::pair<size_t, size_t> AdvanceHandshake(
 111       PacketSavingConnection* a_conn,
 112       QuicCryptoStream* a,
 113       size_t a_i,
 114       PacketSavingConnection* b_conn,
 115       QuicCryptoStream* b,
 116       size_t b_i);
 117
 118   // Returns the value for the tag |tag| in the tag value map of |message|.
 119   static std::string GetValueForTag(const CryptoHandshakeMessage& message,
 120                                     QuicTag tag);
 121
 122   // Returns a |ProofSource| that serves up test certificates.
 123   static ProofSource* ProofSourceForTesting();
 124
 125   // Returns a |ProofVerifier| that uses the QUIC testing root CA.
 126   static ProofVerifier* ProofVerifierForTesting();
 127
 128   // Returns a |ProofVerifyContext| that must be used with the verifier
 129   // returned by |ProofVerifierForTesting|.
 130   static ProofVerifyContext* ProofVerifyContextForTesting();
 131
 132   // These functions return a fake |ProofSource|, |ProofVerifier|, or
 133   // |ProofVerifyContext| that works with each other. These are suitable for
 134   // unit tests that aren't concerned with |ProofSource| and |ProofVerifier|.
 135   // TODO(wtc): delete these when Chromium has a working
 136   // ProofSourceForTesting().
 137   static ProofSource* FakeProofSourceForTesting();
 138   static ProofVerifier* FakeProofVerifierForTesting();
 139   static ProofVerifyContext* FakeProofVerifyContextForTesting();
 140
 141   // MockCommonCertSets returns a CommonCertSets that contains a single set with
 142   // hash |hash|, consisting of the certificate |cert| at index |index|.
 143   static CommonCertSets* MockCommonCertSets(base::StringPiece cert,
 144                                             uint64 hash,
 145                                             uint32 index);
 146
 147   // ParseTag returns a QuicTag from parsing |tagstr|. |tagstr| may either be
 148   // in the format "EXMP" (i.e. ASCII format), or "#11223344" (an explicit hex
 149   // format). It CHECK fails if there's a parse error.
 150   static QuicTag ParseTag(const char* tagstr);
 151
 152   // Message constructs a handshake message from a variable number of
 153   // arguments. |message_tag| is passed to |ParseTag| and used as the tag of
 154   // the resulting message. The arguments are taken in pairs and NULL
 155   // terminated. The first of each pair is the tag of a tag/value and is given
 156   // as an argument to |ParseTag|. The second is the value of the tag/value
 157   // pair and is either a hex dump, preceeded by a '#', or a raw value.
 158   //
 159   //   Message(
 160   //       "CHLO",
 161   //       "NOCE", "#11223344",
 162   //       "SNI", "www.example.com",
 163   //       NULL);
 164   static CryptoHandshakeMessage Message(const char* message_tag, ...);
 165
 166   // BuildMessage is the same as |Message|, but takes the variable arguments
 167   // explicitly. TODO(rtenneti): Investigate whether it'd be better for
 168   // Message() and BuildMessage() to return a CryptoHandshakeMessage* pointer
 169   // instead, to avoid copying the return value.
 170   static CryptoHandshakeMessage BuildMessage(const char* message_tag,
 171                                              va_list ap);
 172
 173   // ChannelIDSourceForTesting returns a ChannelIDSource that generates keys
 174   // deterministically based on the hostname given in the GetChannelIDKey call.
 175   // This ChannelIDSource works in synchronous mode, i.e., its GetChannelIDKey
 176   // method never returns QUIC_PENDING.
 177   static ChannelIDSource* ChannelIDSourceForTesting();
 178
 179  private:
 180   static void CompareClientAndServerKeys(QuicCryptoClientStream* client,
 181                                          QuicCryptoServerStream* server);
 182
 183   DISALLOW_COPY_AND_ASSIGN(CryptoTestUtils);
 184 };
 185
 186 }  // namespace test
 187
 188 }  // namespace net
 189
 190 #endif  // NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_