1 // Copyright 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
5 #include "net/websockets/websocket_test_util.h"
6
7 #include <stddef.h>
8 #include <algorithm>
9 #include <utility>
10
11 #include "base/strings/strcat.h"
12 #include "base/strings/string_util.h"
13 #include "base/strings/stringprintf.h"
14 #include "net/base/ip_endpoint.h"
15 #include "net/http/http_network_session.h"
16 #include "net/proxy_resolution/configured_proxy_resolution_service.h"
17 #include "net/socket/socket_test_util.h"
18 #include "net/third_party/quiche/src/spdy/core/spdy_protocol.h"
19 #include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
20 #include "net/websockets/websocket_basic_handshake_stream.h"
21 #include "url/origin.h"
22
23 namespace net {
24
25 namespace {
26
27 const uint64_t kA = (static_cast<uint64_t>(0x5851f42d) << 32) +
28 static_cast<uint64_t>(0x4c957f2d);
29 const uint64_t kC = 12345;
30 const uint64_t kM = static_cast<uint64_t>(1) << 48;
31
32 } // namespace
33
LinearCongruentialGenerator(uint32_t seed)34 LinearCongruentialGenerator::LinearCongruentialGenerator(uint32_t seed)
35 : current_(seed) {}
36
Generate()37 uint32_t LinearCongruentialGenerator::Generate() {
38 uint64_t result = current_;
39 current_ = (current_ * kA + kC) % kM;
40 return static_cast<uint32_t>(result >> 16);
41 }
42
WebSocketExtraHeadersToString(const WebSocketExtraHeaders & headers)43 std::string WebSocketExtraHeadersToString(
44 const WebSocketExtraHeaders& headers) {
45 std::string answer;
46 for (const auto& header : headers) {
47 base::StrAppend(&answer, {header.first, ": ", header.second, "\r\n"});
48 }
49 return answer;
50 }
51
WebSocketExtraHeadersToHttpRequestHeaders(const WebSocketExtraHeaders & headers)52 HttpRequestHeaders WebSocketExtraHeadersToHttpRequestHeaders(
53 const WebSocketExtraHeaders& headers) {
54 HttpRequestHeaders headers_to_return;
55 for (const auto& header : headers)
56 headers_to_return.SetHeader(header.first, header.second);
57 return headers_to_return;
58 }
59
WebSocketStandardRequest(const std::string & path,const std::string & host,const url::Origin & origin,const std::string & send_additional_request_headers,const std::string & extra_headers)60 std::string WebSocketStandardRequest(
61 const std::string& path,
62 const std::string& host,
63 const url::Origin& origin,
64 const std::string& send_additional_request_headers,
65 const std::string& extra_headers) {
66 return WebSocketStandardRequestWithCookies(path, host, origin, std::string(),
67 send_additional_request_headers,
68 extra_headers);
69 }
70
WebSocketStandardRequestWithCookies(const std::string & path,const std::string & host,const url::Origin & origin,const std::string & cookies,const std::string & send_additional_request_headers,const std::string & extra_headers)71 std::string WebSocketStandardRequestWithCookies(
72 const std::string& path,
73 const std::string& host,
74 const url::Origin& origin,
75 const std::string& cookies,
76 const std::string& send_additional_request_headers,
77 const std::string& extra_headers) {
78 // Unrelated changes in net/http may change the order and default-values of
79 // HTTP headers, causing WebSocket tests to fail. It is safe to update this
80 // in that case.
81 HttpRequestHeaders headers;
82 std::stringstream request_headers;
83
84 request_headers << base::StringPrintf("GET %s HTTP/1.1\r\n", path.c_str());
85 headers.SetHeader("Host", host);
86 headers.SetHeader("Connection", "Upgrade");
87 headers.SetHeader("Pragma", "no-cache");
88 headers.SetHeader("Cache-Control", "no-cache");
89 headers.AddHeadersFromString(send_additional_request_headers);
90 headers.SetHeader("Upgrade", "websocket");
91 headers.SetHeader("Origin", origin.Serialize());
92 headers.SetHeader("Sec-WebSocket-Version", "13");
93 if (!headers.HasHeader("User-Agent"))
94 headers.SetHeader("User-Agent", "");
95 headers.SetHeader("Accept-Encoding", "gzip, deflate");
96 headers.SetHeader("Accept-Language", "en-us,fr");
97 headers.AddHeadersFromString(cookies);
98 headers.SetHeader("Sec-WebSocket-Key", "dGhlIHNhbXBsZSBub25jZQ==");
99 headers.SetHeader("Sec-WebSocket-Extensions",
100 "permessage-deflate; client_max_window_bits");
101 headers.AddHeadersFromString(extra_headers);
102
103 request_headers << headers.ToString();
104 return request_headers.str();
105 }
106
WebSocketStandardResponse(const std::string & extra_headers)107 std::string WebSocketStandardResponse(const std::string& extra_headers) {
108 return base::StringPrintf(
109 "HTTP/1.1 101 Switching Protocols\r\n"
110 "Upgrade: websocket\r\n"
111 "Connection: Upgrade\r\n"
112 "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
113 "%s\r\n",
114 extra_headers.c_str());
115 }
116
WebSocketCommonTestHeaders()117 HttpRequestHeaders WebSocketCommonTestHeaders() {
118 HttpRequestHeaders request_headers;
119 request_headers.SetHeader("Host", "www.example.org");
120 request_headers.SetHeader("Connection", "Upgrade");
121 request_headers.SetHeader("Pragma", "no-cache");
122 request_headers.SetHeader("Cache-Control", "no-cache");
123 request_headers.SetHeader("Upgrade", "websocket");
124 request_headers.SetHeader("Origin", "http://origin.example.org");
125 request_headers.SetHeader("Sec-WebSocket-Version", "13");
126 request_headers.SetHeader("User-Agent", "");
127 request_headers.SetHeader("Accept-Encoding", "gzip, deflate");
128 request_headers.SetHeader("Accept-Language", "en-us,fr");
129 return request_headers;
130 }
131
WebSocketHttp2Request(const std::string & path,const std::string & authority,const std::string & origin,const WebSocketExtraHeaders & extra_headers)132 spdy::SpdyHeaderBlock WebSocketHttp2Request(
133 const std::string& path,
134 const std::string& authority,
135 const std::string& origin,
136 const WebSocketExtraHeaders& extra_headers) {
137 spdy::SpdyHeaderBlock request_headers;
138 request_headers[spdy::kHttp2MethodHeader] = "CONNECT";
139 request_headers[spdy::kHttp2AuthorityHeader] = authority;
140 request_headers[spdy::kHttp2SchemeHeader] = "https";
141 request_headers[spdy::kHttp2PathHeader] = path;
142 request_headers[spdy::kHttp2ProtocolHeader] = "websocket";
143 request_headers["pragma"] = "no-cache";
144 request_headers["cache-control"] = "no-cache";
145 request_headers["origin"] = origin;
146 request_headers["sec-websocket-version"] = "13";
147 request_headers["user-agent"] = "";
148 request_headers["accept-encoding"] = "gzip, deflate";
149 request_headers["accept-language"] = "en-us,fr";
150 request_headers["sec-websocket-extensions"] =
151 "permessage-deflate; client_max_window_bits";
152 for (const auto& header : extra_headers) {
153 request_headers[base::ToLowerASCII(header.first)] = header.second;
154 }
155 return request_headers;
156 }
157
WebSocketHttp2Response(const WebSocketExtraHeaders & extra_headers)158 spdy::SpdyHeaderBlock WebSocketHttp2Response(
159 const WebSocketExtraHeaders& extra_headers) {
160 spdy::SpdyHeaderBlock response_headers;
161 response_headers[spdy::kHttp2StatusHeader] = "200";
162 for (const auto& header : extra_headers) {
163 response_headers[base::ToLowerASCII(header.first)] = header.second;
164 }
165 return response_headers;
166 }
167
168 struct WebSocketMockClientSocketFactoryMaker::Detail {
169 std::string expect_written;
170 std::string return_to_read;
171 std::vector<MockRead> reads;
172 MockWrite write;
173 std::vector<std::unique_ptr<SequencedSocketData>> socket_data_vector;
174 std::vector<std::unique_ptr<SSLSocketDataProvider>> ssl_socket_data_vector;
175 MockClientSocketFactory factory;
176 };
177
WebSocketMockClientSocketFactoryMaker()178 WebSocketMockClientSocketFactoryMaker::WebSocketMockClientSocketFactoryMaker()
179 : detail_(std::make_unique<Detail>()) {}
180
181 WebSocketMockClientSocketFactoryMaker::
182 ~WebSocketMockClientSocketFactoryMaker() = default;
183
factory()184 MockClientSocketFactory* WebSocketMockClientSocketFactoryMaker::factory() {
185 return &detail_->factory;
186 }
187
SetExpectations(const std::string & expect_written,const std::string & return_to_read)188 void WebSocketMockClientSocketFactoryMaker::SetExpectations(
189 const std::string& expect_written,
190 const std::string& return_to_read) {
191 const size_t kHttpStreamParserBufferSize = 4096;
192 // We need to extend the lifetime of these strings.
193 detail_->expect_written = expect_written;
194 detail_->return_to_read = return_to_read;
195 int sequence = 0;
196 detail_->write = MockWrite(SYNCHRONOUS,
197 detail_->expect_written.data(),
198 detail_->expect_written.size(),
199 sequence++);
200 // HttpStreamParser reads 4KB at a time. We need to take this implementation
201 // detail into account if |return_to_read| is big enough.
202 for (size_t place = 0; place < detail_->return_to_read.size();
203 place += kHttpStreamParserBufferSize) {
204 detail_->reads.push_back(
205 MockRead(SYNCHRONOUS, detail_->return_to_read.data() + place,
206 std::min(detail_->return_to_read.size() - place,
207 kHttpStreamParserBufferSize),
208 sequence++));
209 }
210 auto socket_data = std::make_unique<SequencedSocketData>(
211 detail_->reads, base::make_span(&detail_->write, 1));
212 socket_data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
213 AddRawExpectations(std::move(socket_data));
214 }
215
AddRawExpectations(std::unique_ptr<SequencedSocketData> socket_data)216 void WebSocketMockClientSocketFactoryMaker::AddRawExpectations(
217 std::unique_ptr<SequencedSocketData> socket_data) {
218 detail_->factory.AddSocketDataProvider(socket_data.get());
219 detail_->socket_data_vector.push_back(std::move(socket_data));
220 }
221
AddSSLSocketDataProvider(std::unique_ptr<SSLSocketDataProvider> ssl_socket_data)222 void WebSocketMockClientSocketFactoryMaker::AddSSLSocketDataProvider(
223 std::unique_ptr<SSLSocketDataProvider> ssl_socket_data) {
224 detail_->factory.AddSSLSocketDataProvider(ssl_socket_data.get());
225 detail_->ssl_socket_data_vector.push_back(std::move(ssl_socket_data));
226 }
227
WebSocketTestURLRequestContextHost()228 WebSocketTestURLRequestContextHost::WebSocketTestURLRequestContextHost()
229 : url_request_context_(true), url_request_context_initialized_(false) {
230 url_request_context_.set_client_socket_factory(maker_.factory());
231 auto params = std::make_unique<HttpNetworkSession::Params>();
232 params->enable_spdy_ping_based_connection_checking = false;
233 params->enable_quic = false;
234 params->enable_websocket_over_http2 = true;
235 params->disable_idle_sockets_close_on_memory_pressure = false;
236 url_request_context_.set_http_network_session_params(std::move(params));
237 }
238
239 WebSocketTestURLRequestContextHost::~WebSocketTestURLRequestContextHost() =
240 default;
241
AddRawExpectations(std::unique_ptr<SequencedSocketData> socket_data)242 void WebSocketTestURLRequestContextHost::AddRawExpectations(
243 std::unique_ptr<SequencedSocketData> socket_data) {
244 maker_.AddRawExpectations(std::move(socket_data));
245 }
246
AddSSLSocketDataProvider(std::unique_ptr<SSLSocketDataProvider> ssl_socket_data)247 void WebSocketTestURLRequestContextHost::AddSSLSocketDataProvider(
248 std::unique_ptr<SSLSocketDataProvider> ssl_socket_data) {
249 maker_.AddSSLSocketDataProvider(std::move(ssl_socket_data));
250 }
251
SetProxyConfig(const std::string & proxy_rules)252 void WebSocketTestURLRequestContextHost::SetProxyConfig(
253 const std::string& proxy_rules) {
254 DCHECK(!url_request_context_initialized_);
255 proxy_resolution_service_ = ConfiguredProxyResolutionService::CreateFixed(
256 proxy_rules, TRAFFIC_ANNOTATION_FOR_TESTS);
257 url_request_context_.set_proxy_resolution_service(
258 proxy_resolution_service_.get());
259 }
260
OnAuthRequired(const AuthChallengeInfo & auth_info,scoped_refptr<HttpResponseHeaders> response_headers,const IPEndPoint & host_port_pair,base::OnceCallback<void (const AuthCredentials *)> callback,base::Optional<AuthCredentials> * credentials)261 int DummyConnectDelegate::OnAuthRequired(
262 const AuthChallengeInfo& auth_info,
263 scoped_refptr<HttpResponseHeaders> response_headers,
264 const IPEndPoint& host_port_pair,
265 base::OnceCallback<void(const AuthCredentials*)> callback,
266 base::Optional<AuthCredentials>* credentials) {
267 return OK;
268 }
269
270 TestURLRequestContext*
GetURLRequestContext()271 WebSocketTestURLRequestContextHost::GetURLRequestContext() {
272 if (!url_request_context_initialized_) {
273 url_request_context_.Init();
274 // A Network Delegate is required to make the URLRequest::Delegate work.
275 url_request_context_.set_network_delegate(&network_delegate_);
276 url_request_context_initialized_ = true;
277 }
278 return &url_request_context_;
279 }
280
OnBasicHandshakeStreamCreated(WebSocketBasicHandshakeStream * handshake_stream)281 void TestWebSocketStreamRequestAPI::OnBasicHandshakeStreamCreated(
282 WebSocketBasicHandshakeStream* handshake_stream) {
283 handshake_stream->SetWebSocketKeyForTesting("dGhlIHNhbXBsZSBub25jZQ==");
284 }
285
OnHttp2HandshakeStreamCreated(WebSocketHttp2HandshakeStream * handshake_stream)286 void TestWebSocketStreamRequestAPI::OnHttp2HandshakeStreamCreated(
287 WebSocketHttp2HandshakeStream* handshake_stream) {}
288
289 } // namespace net
290