blob: 276eead70ece4f2c594702b742ae83e9b5d6d56e [file] [log] [blame]
Ryan Hamilton56b10c5d2018-05-11 13:40:161// Copyright (c) 2013 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
Ryan Hamilton7582d2652018-08-01 22:35:325#include "net/quic/mock_crypto_client_stream.h"
Ryan Hamilton56b10c5d2018-05-11 13:40:166
Ryan Hamilton7582d2652018-08-01 22:35:327#include "net/quic/mock_decrypter.h"
8#include "net/quic/mock_encrypter.h"
Ryan Hamilton56b10c5d2018-05-11 13:40:169#include "net/third_party/quic/core/crypto/null_decrypter.h"
10#include "net/third_party/quic/core/crypto/null_encrypter.h"
11#include "net/third_party/quic/core/crypto/quic_decrypter.h"
12#include "net/third_party/quic/core/crypto/quic_encrypter.h"
Victor Vasilievc5b409c22018-07-24 12:23:4613#include "net/third_party/quic/core/http/quic_spdy_client_session_base.h"
Ryan Hamilton56b10c5d2018-05-11 13:40:1614#include "net/third_party/quic/platform/api/quic_ptr_util.h"
Ryan Hamilton56b10c5d2018-05-11 13:40:1615#include "net/third_party/quic/test_tools/quic_config_peer.h"
16#include "testing/gtest/include/gtest/gtest.h"
17
Ryan Hamilton8d9ee76e2018-05-29 23:52:5218namespace quic {
Ryan Hamilton56b10c5d2018-05-11 13:40:1619
20MockCryptoClientStream::MockCryptoClientStream(
21 const QuicServerId& server_id,
22 QuicSpdyClientSessionBase* session,
Ryan Hamiltonf044c1b2018-07-24 00:00:1423 std::unique_ptr<ProofVerifyContext> verify_context,
Ryan Hamilton56b10c5d2018-05-11 13:40:1624 const QuicConfig& config,
25 QuicCryptoClientConfig* crypto_config,
26 HandshakeMode handshake_mode,
Ryan Hamilton8d9ee76e2018-05-29 23:52:5227 const net::ProofVerifyDetailsChromium* proof_verify_details,
Ryan Hamilton56b10c5d2018-05-11 13:40:1628 bool use_mock_crypter)
29 : QuicCryptoClientStream(server_id,
30 session,
Ryan Hamiltonf044c1b2018-07-24 00:00:1431 std::move(verify_context),
Ryan Hamilton56b10c5d2018-05-11 13:40:1632 crypto_config,
33 session),
34 QuicCryptoHandshaker(this, session),
35 handshake_mode_(handshake_mode),
36 encryption_established_(false),
37 handshake_confirmed_(false),
38 crypto_negotiated_params_(new QuicCryptoNegotiatedParameters),
39 use_mock_crypter_(use_mock_crypter),
40 server_id_(server_id),
41 proof_verify_details_(proof_verify_details),
42 config_(config) {
43 crypto_framer_.set_visitor(this);
44}
45
46MockCryptoClientStream::~MockCryptoClientStream() {}
47
48void MockCryptoClientStream::OnHandshakeMessage(
49 const CryptoHandshakeMessage& message) {
50 CloseConnectionWithDetails(QUIC_CRYPTO_MESSAGE_AFTER_HANDSHAKE_COMPLETE,
51 "Forced mock failure");
52}
53
54bool MockCryptoClientStream::CryptoConnect() {
55 if (proof_verify_details_) {
56 if (!proof_verify_details_->cert_verify_result.verified_cert
57 ->VerifyNameMatch(server_id_.host())) {
58 handshake_confirmed_ = false;
59 encryption_established_ = false;
60 session()->connection()->CloseConnection(
61 QUIC_PROOF_INVALID, "proof invalid",
62 ConnectionCloseBehavior::SILENT_CLOSE);
63 return false;
64 }
65 }
66
67 switch (handshake_mode_) {
68 case ZERO_RTT: {
69 encryption_established_ = true;
70 handshake_confirmed_ = false;
71 crypto_negotiated_params_->key_exchange = kC255;
72 crypto_negotiated_params_->aead = kAESG;
73 if (proof_verify_details_) {
74 reinterpret_cast<QuicSpdyClientSessionBase*>(session())
75 ->OnProofVerifyDetailsAvailable(*proof_verify_details_);
76 }
77 if (use_mock_crypter_) {
78 session()->connection()->SetDecrypter(
79 ENCRYPTION_INITIAL,
80 QuicMakeUnique<MockDecrypter>(Perspective::IS_CLIENT));
81 session()->connection()->SetEncrypter(
82 ENCRYPTION_INITIAL,
83 QuicMakeUnique<MockEncrypter>(Perspective::IS_CLIENT));
84 } else {
85 session()->connection()->SetDecrypter(
86 ENCRYPTION_INITIAL,
87 QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
88 session()->connection()->SetEncrypter(
89 ENCRYPTION_INITIAL,
90 QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT));
91 }
92 session()->connection()->SetDefaultEncryptionLevel(ENCRYPTION_INITIAL);
93 session()->OnCryptoHandshakeEvent(
94 QuicSession::ENCRYPTION_FIRST_ESTABLISHED);
95 break;
96 }
97
98 case CONFIRM_HANDSHAKE: {
99 encryption_established_ = true;
100 handshake_confirmed_ = true;
101 crypto_negotiated_params_->key_exchange = kC255;
102 crypto_negotiated_params_->aead = kAESG;
103 if (proof_verify_details_) {
104 reinterpret_cast<QuicSpdyClientSessionBase*>(session())
105 ->OnProofVerifyDetailsAvailable(*proof_verify_details_);
106 }
107 SetConfigNegotiated();
108 if (use_mock_crypter_) {
109 session()->connection()->SetDecrypter(
110 ENCRYPTION_FORWARD_SECURE,
111 QuicMakeUnique<MockDecrypter>(Perspective::IS_CLIENT));
112 session()->connection()->SetEncrypter(
113 ENCRYPTION_FORWARD_SECURE,
114 QuicMakeUnique<MockEncrypter>(Perspective::IS_CLIENT));
115 } else {
116 session()->connection()->SetDecrypter(
117 ENCRYPTION_FORWARD_SECURE,
118 QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
119 session()->connection()->SetEncrypter(
120 ENCRYPTION_FORWARD_SECURE,
121 QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT));
122 }
123 session()->connection()->SetDefaultEncryptionLevel(
124 ENCRYPTION_FORWARD_SECURE);
125 session()->OnCryptoHandshakeEvent(QuicSession::HANDSHAKE_CONFIRMED);
126 break;
127 }
128
129 case COLD_START: {
130 handshake_confirmed_ = false;
131 encryption_established_ = false;
132 break;
133 }
134
135 case USE_DEFAULT_CRYPTO_STREAM: {
136 NOTREACHED();
137 break;
138 }
139 }
140
141 return session()->connection()->connected();
142}
143
144bool MockCryptoClientStream::encryption_established() const {
145 return encryption_established_;
146}
147
148bool MockCryptoClientStream::handshake_confirmed() const {
149 return handshake_confirmed_;
150}
151
152const QuicCryptoNegotiatedParameters&
153MockCryptoClientStream::crypto_negotiated_params() const {
154 return *crypto_negotiated_params_;
155}
156
157CryptoMessageParser* MockCryptoClientStream::crypto_message_parser() {
158 return &crypto_framer_;
159}
160
161void MockCryptoClientStream::SendOnCryptoHandshakeEvent(
162 QuicSession::CryptoHandshakeEvent event) {
163 encryption_established_ = true;
164 if (event == QuicSession::HANDSHAKE_CONFIRMED) {
165 handshake_confirmed_ = true;
166 SetConfigNegotiated();
167 if (use_mock_crypter_) {
168 session()->connection()->SetDecrypter(
169 ENCRYPTION_FORWARD_SECURE,
170 QuicMakeUnique<MockDecrypter>(Perspective::IS_CLIENT));
171 session()->connection()->SetEncrypter(
172 ENCRYPTION_FORWARD_SECURE,
173 QuicMakeUnique<MockEncrypter>(Perspective::IS_CLIENT));
174 } else {
175 session()->connection()->SetDecrypter(
176 ENCRYPTION_FORWARD_SECURE,
177 QuicMakeUnique<NullDecrypter>(Perspective::IS_CLIENT));
178 session()->connection()->SetEncrypter(
179 ENCRYPTION_FORWARD_SECURE,
180 QuicMakeUnique<NullEncrypter>(Perspective::IS_CLIENT));
181 }
182 session()->connection()->SetDefaultEncryptionLevel(
183 ENCRYPTION_FORWARD_SECURE);
184 }
185 session()->OnCryptoHandshakeEvent(event);
186}
187
188void MockCryptoClientStream::SetConfigNegotiated() {
189 ASSERT_FALSE(session()->config()->negotiated());
190 QuicTagVector cgst;
191// TODO(rtenneti): Enable the following code after BBR code is checked in.
192#if 0
193 cgst.push_back(kTBBR);
194#endif
195 cgst.push_back(kQBIC);
196 QuicConfig config(config_);
197 config.SetIdleNetworkTimeout(
198 QuicTime::Delta::FromSeconds(2 * kMaximumIdleTimeoutSecs),
199 QuicTime::Delta::FromSeconds(kMaximumIdleTimeoutSecs));
Ryan Hamilton56b10c5d2018-05-11 13:40:16200 config.SetBytesForConnectionIdToSend(PACKET_8BYTE_CONNECTION_ID);
201 config.SetMaxIncomingDynamicStreamsToSend(kDefaultMaxStreamsPerConnection /
202 2);
203
204 CryptoHandshakeMessage msg;
205 config.ToHandshakeMessage(&msg);
Ryan Hamiltonccfa84a2018-07-24 00:38:08206 QuicString error_details;
Ryan Hamilton56b10c5d2018-05-11 13:40:16207 const QuicErrorCode error =
208 session()->config()->ProcessPeerHello(msg, CLIENT, &error_details);
209 ASSERT_EQ(QUIC_NO_ERROR, error);
210 ASSERT_TRUE(session()->config()->negotiated());
211 session()->OnConfigNegotiated();
212}
213
Ryan Hamilton8d9ee76e2018-05-29 23:52:52214} // namespace quic