1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
// 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 <utility>
#include <vector>
#include "base/basictypes.h"
#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);
// AdvanceHandshake attempts to moves messages from |a| to |b| and |b| to |a|.
// Returns the number of messages moved.
static std::pair<size_t, size_t> AdvanceHandshake(
PacketSavingConnection* a_conn,
QuicCryptoStream* a,
size_t a_i,
PacketSavingConnection* b_conn,
QuicCryptoStream* b,
size_t b_i);
// 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_
|
