diff options
Diffstat (limited to 'chromium/net/quic/test_tools/crypto_test_utils.h')
-rw-r--r-- | chromium/net/quic/test_tools/crypto_test_utils.h | 132 |
1 files changed, 132 insertions, 0 deletions
diff --git a/chromium/net/quic/test_tools/crypto_test_utils.h b/chromium/net/quic/test_tools/crypto_test_utils.h new file mode 100644 index 00000000000..7b0c95274d5 --- /dev/null +++ b/chromium/net/quic/test_tools/crypto_test_utils.h @@ -0,0 +1,132 @@ +// 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. + +#ifndef NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_ +#define NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_ + +#include <stdarg.h> + +#include <vector> + +#include "base/logging.h" +#include "base/strings/string_piece.h" +#include "net/quic/crypto/crypto_framer.h" +#include "net/quic/quic_framer.h" +#include "net/quic/quic_protocol.h" + +namespace net { + +class ChannelIDSigner; +class CommonCertSets; +class ProofSource; +class ProofVerifier; +class QuicClock; +class QuicConfig; +class QuicCryptoClientStream; +class QuicCryptoServerConfig; +class QuicCryptoServerStream; +class QuicCryptoStream; +class QuicRandom; + +namespace test { + +class PacketSavingConnection; + +class CryptoTestUtils { + public: + // FakeClientOptions bundles together a number of options for configuring + // HandshakeWithFakeClient. + struct FakeClientOptions { + FakeClientOptions(); + + // If dont_verify_certs is true then no ProofVerifier is set on the client. + // Thus no certificates will be requested or checked. + bool dont_verify_certs; + + // If channel_id_enabled is true then the client will attempt to send a + // ChannelID. The key will be the same as is returned by + // ChannelIDSigner's |GetKeyForHostname|. + bool channel_id_enabled; + }; + + // returns: the number of client hellos that the client sent. + static int HandshakeWithFakeServer(PacketSavingConnection* client_conn, + QuicCryptoClientStream* client); + + // returns: the number of client hellos that the client sent. + static int HandshakeWithFakeClient(PacketSavingConnection* server_conn, + QuicCryptoServerStream* server, + const FakeClientOptions& options); + + // SetupCryptoServerConfigForTest configures |config| and |crypto_config| + // with sensible defaults for testing. + static void SetupCryptoServerConfigForTest( + const QuicClock* clock, + QuicRandom* rand, + QuicConfig* config, + QuicCryptoServerConfig* crypto_config); + + // CommunicateHandshakeMessages moves messages from |a| to |b| and back until + // |a|'s handshake has completed. + static void CommunicateHandshakeMessages(PacketSavingConnection* a_conn, + QuicCryptoStream* a, + PacketSavingConnection* b_conn, + QuicCryptoStream* b); + + // Returns the value for the tag |tag| in the tag value map of |message|. + static std::string GetValueForTag(const CryptoHandshakeMessage& message, + QuicTag tag); + + // Returns a |ProofSource| that serves up test certificates. + static ProofSource* ProofSourceForTesting(); + + // Returns a |ProofVerifier| that uses the QUIC testing root CA. + static ProofVerifier* ProofVerifierForTesting(); + + // MockCommonCertSets returns a CommonCertSets that contains a single set with + // hash |hash|, consisting of the certificate |cert| at index |index|. + static CommonCertSets* MockCommonCertSets(base::StringPiece cert, + uint64 hash, + uint32 index); + + // ParseTag returns a QuicTag from parsing |tagstr|. |tagstr| may either be + // in the format "EXMP" (i.e. ASCII format), or "#11223344" (an explicit hex + // format). It CHECK fails if there's a parse error. + static QuicTag ParseTag(const char* tagstr); + + // Message constructs a handshake message from a variable number of + // arguments. |message_tag| is passed to |ParseTag| and used as the tag of + // the resulting message. The arguments are taken in pairs and NULL + // terminated. The first of each pair is the tag of a tag/value and is given + // as an argument to |ParseTag|. The second is the value of the tag/value + // pair and is either a hex dump, preceeded by a '#', or a raw value. + // + // Message( + // "CHLO", + // "NOCE", "#11223344", + // "SNI", "www.example.com", + // NULL); + static CryptoHandshakeMessage Message(const char* message_tag, ...); + + // BuildMessage is the same as |Message|, but takes the variable arguments + // explicitly. TODO(rtenneti): Investigate whether it'd be better for + // Message() and BuildMessage() to return a CryptoHandshakeMessage* pointer + // instead, to avoid copying the return value. + static CryptoHandshakeMessage BuildMessage(const char* message_tag, + va_list ap); + + // ChannelIDSignerForTesting returns a ChannelIDSigner that generates keys + // deterministically based on the hostname given in the Sign call. + static ChannelIDSigner* ChannelIDSignerForTesting(); + + private: + static void CompareClientAndServerKeys(QuicCryptoClientStream* client, + QuicCryptoServerStream* server); +}; + +} // namespace test + +} // namespace net + +#endif // NET_QUIC_TEST_TOOLS_CRYPTO_TEST_UTILS_H_ |