Home | History | Annotate | Download | only in test_tools 
      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_
    191