net/websockets/websocket_handshake_handler_unittest.cc

   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 #include "net/websockets/websocket_handshake_handler.h"
   6
   7 #include <string>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/string_util.h"
  12 #include "googleurl/src/gurl.h"
  13 #include "net/http/http_response_headers.h"
  14 #include "net/http/http_util.h"
  15
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 namespace {
  19
  20 const char* const kCookieHeaders[] = {
  21   "cookie", "cookie2"
  22 };
  23
  24 const char* const kSetCookieHeaders[] = {
  25   "set-cookie", "set-cookie2"
  26 };
  27
  28 }
  29
  30 namespace net {
  31
  32 TEST(WebSocketHandshakeRequestHandlerTest, SimpleRequest) {
  33   WebSocketHandshakeRequestHandler handler;
  34
  35   static const char kHandshakeRequestMessage[] =
  36       "GET /demo HTTP/1.1\r\n"
  37       "Host: example.com\r\n"
  38       "Connection: Upgrade\r\n"
  39       "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
  40       "Sec-WebSocket-Protocol: sample\r\n"
  41       "Upgrade: WebSocket\r\n"
  42       "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
  43       "Origin: http://example.com\r\n"
  44       "\r\n"
  45       "^n:ds[4U";
  46
  47   EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
  48                                    strlen(kHandshakeRequestMessage)));
  49   EXPECT_EQ(0, handler.protocol_version());
  50
  51   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
  52
  53   EXPECT_EQ(kHandshakeRequestMessage, handler.GetRawRequest());
  54 }
  55
  56 TEST(WebSocketHandshakeRequestHandlerTest, SimpleRequestHybi06Handshake) {
  57   WebSocketHandshakeRequestHandler handler;
  58
  59   static const char kHandshakeRequestMessage[] =
  60       "GET /demo HTTP/1.1\r\n"
  61       "Host: example.com\r\n"
  62       "Upgrade: websocket\r\n"
  63       "Connection: Upgrade\r\n"
  64       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
  65       "Sec-WebSocket-Origin: http://example.com\r\n"
  66       "Sec-WebSocket-Protocol: sample\r\n"
  67       "Sec-WebSocket-Version: 6\r\n"
  68       "\r\n";
  69
  70   EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
  71                                    strlen(kHandshakeRequestMessage)));
  72   EXPECT_EQ(6, handler.protocol_version());
  73
  74   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
  75
  76   EXPECT_EQ(kHandshakeRequestMessage, handler.GetRawRequest());
  77 }
  78
  79 TEST(WebSocketHandshakeRequestHandlerTest, ReplaceRequestCookies) {
  80   WebSocketHandshakeRequestHandler handler;
  81
  82   static const char kHandshakeRequestMessage[] =
  83       "GET /demo HTTP/1.1\r\n"
  84       "Host: example.com\r\n"
  85       "Connection: Upgrade\r\n"
  86       "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
  87       "Sec-WebSocket-Protocol: sample\r\n"
  88       "Upgrade: WebSocket\r\n"
  89       "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
  90       "Origin: http://example.com\r\n"
  91       "Cookie: WK-websocket-test=1\r\n"
  92       "\r\n"
  93       "^n:ds[4U";
  94
  95   EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
  96                                    strlen(kHandshakeRequestMessage)));
  97   EXPECT_EQ(0, handler.protocol_version());
  98
  99   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
 100
 101   handler.AppendHeaderIfMissing("Cookie",
 102                                 "WK-websocket-test=1; "
 103                                 "WK-websocket-test-httponly=1");
 104
 105   static const char kHandshakeRequestExpectedMessage[] =
 106       "GET /demo HTTP/1.1\r\n"
 107       "Host: example.com\r\n"
 108       "Connection: Upgrade\r\n"
 109       "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
 110       "Sec-WebSocket-Protocol: sample\r\n"
 111       "Upgrade: WebSocket\r\n"
 112       "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
 113       "Origin: http://example.com\r\n"
 114       "Cookie: WK-websocket-test=1; WK-websocket-test-httponly=1\r\n"
 115       "\r\n"
 116       "^n:ds[4U";
 117
 118   EXPECT_EQ(kHandshakeRequestExpectedMessage, handler.GetRawRequest());
 119 }
 120
 121 TEST(WebSocketHandshakeRequestHandlerTest,
 122      ReplaceRequestCookiesHybi06Handshake) {
 123   WebSocketHandshakeRequestHandler handler;
 124
 125   static const char kHandshakeRequestMessage[] =
 126       "GET /demo HTTP/1.1\r\n"
 127       "Host: example.com\r\n"
 128       "Upgrade: websocket\r\n"
 129       "Connection: Upgrade\r\n"
 130       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
 131       "Sec-WebSocket-Origin: http://example.com\r\n"
 132       "Sec-WebSocket-Protocol: sample\r\n"
 133       "Sec-WebSocket-Version: 6\r\n"
 134       "Cookie: WK-websocket-test=1\r\n"
 135       "\r\n";
 136
 137   EXPECT_TRUE(handler.ParseRequest(kHandshakeRequestMessage,
 138                                    strlen(kHandshakeRequestMessage)));
 139   EXPECT_EQ(6, handler.protocol_version());
 140
 141   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
 142
 143   handler.AppendHeaderIfMissing("Cookie",
 144                                 "WK-websocket-test=1; "
 145                                 "WK-websocket-test-httponly=1");
 146
 147   static const char kHandshakeRequestExpectedMessage[] =
 148       "GET /demo HTTP/1.1\r\n"
 149       "Host: example.com\r\n"
 150       "Upgrade: websocket\r\n"
 151       "Connection: Upgrade\r\n"
 152       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
 153       "Sec-WebSocket-Origin: http://example.com\r\n"
 154       "Sec-WebSocket-Protocol: sample\r\n"
 155       "Sec-WebSocket-Version: 6\r\n"
 156       "Cookie: WK-websocket-test=1; WK-websocket-test-httponly=1\r\n"
 157       "\r\n";
 158
 159   EXPECT_EQ(kHandshakeRequestExpectedMessage, handler.GetRawRequest());
 160 }
 161
 162 TEST(WebSocketHandshakeResponseHandlerTest, SimpleResponse) {
 163   WebSocketHandshakeResponseHandler handler;
 164   EXPECT_EQ(0, handler.protocol_version());
 165
 166   static const char kHandshakeResponseMessage[] =
 167       "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 168       "Upgrade: WebSocket\r\n"
 169       "Connection: Upgrade\r\n"
 170       "Sec-WebSocket-Origin: http://example.com\r\n"
 171       "Sec-WebSocket-Location: ws://example.com/demo\r\n"
 172       "Sec-WebSocket-Protocol: sample\r\n"
 173       "\r\n"
 174       "8jKS'y:G*Co,Wxa-";
 175
 176   EXPECT_EQ(strlen(kHandshakeResponseMessage),
 177             handler.ParseRawResponse(kHandshakeResponseMessage,
 178                                      strlen(kHandshakeResponseMessage)));
 179   EXPECT_TRUE(handler.HasResponse());
 180
 181   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
 182
 183   EXPECT_EQ(kHandshakeResponseMessage, handler.GetResponse());
 184 }
 185
 186 TEST(WebSocketHandshakeResponseHandlerTest, SimpleResponseHybi06Handshake) {
 187   WebSocketHandshakeResponseHandler handler;
 188   handler.set_protocol_version(6);
 189   EXPECT_EQ(6, handler.protocol_version());
 190
 191   static const char kHandshakeResponseMessage[] =
 192       "HTTP/1.1 101 Switching Protocols\r\n"
 193       "Upgrade: websocket\r\n"
 194       "Connection: Upgrade\r\n"
 195       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
 196       "Sec-WebSocket-Protocol: sample\r\n"
 197       "\r\n";
 198
 199   EXPECT_EQ(strlen(kHandshakeResponseMessage),
 200             handler.ParseRawResponse(kHandshakeResponseMessage,
 201                                      strlen(kHandshakeResponseMessage)));
 202   EXPECT_TRUE(handler.HasResponse());
 203
 204   handler.RemoveHeaders(kCookieHeaders, arraysize(kCookieHeaders));
 205
 206   EXPECT_EQ(kHandshakeResponseMessage, handler.GetResponse());
 207 }
 208
 209 TEST(WebSocketHandshakeResponseHandlerTest, ReplaceResponseCookies) {
 210   WebSocketHandshakeResponseHandler handler;
 211   EXPECT_EQ(0, handler.protocol_version());
 212
 213   static const char kHandshakeResponseMessage[] =
 214       "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 215       "Upgrade: WebSocket\r\n"
 216       "Connection: Upgrade\r\n"
 217       "Sec-WebSocket-Origin: http://example.com\r\n"
 218       "Sec-WebSocket-Location: ws://example.com/demo\r\n"
 219       "Sec-WebSocket-Protocol: sample\r\n"
 220       "Set-Cookie: WK-websocket-test-1\r\n"
 221       "Set-Cookie: WK-websocket-test-httponly=1; HttpOnly\r\n"
 222       "\r\n"
 223       "8jKS'y:G*Co,Wxa-";
 224
 225   EXPECT_EQ(strlen(kHandshakeResponseMessage),
 226             handler.ParseRawResponse(kHandshakeResponseMessage,
 227                                      strlen(kHandshakeResponseMessage)));
 228   EXPECT_TRUE(handler.HasResponse());
 229   std::vector<std::string> cookies;
 230   handler.GetHeaders(kSetCookieHeaders, arraysize(kSetCookieHeaders), &cookies);
 231   ASSERT_EQ(2U, cookies.size());
 232   EXPECT_EQ("WK-websocket-test-1", cookies[0]);
 233   EXPECT_EQ("WK-websocket-test-httponly=1; HttpOnly", cookies[1]);
 234   handler.RemoveHeaders(kSetCookieHeaders, arraysize(kSetCookieHeaders));
 235
 236   static const char kHandshakeResponseExpectedMessage[] =
 237       "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 238       "Upgrade: WebSocket\r\n"
 239       "Connection: Upgrade\r\n"
 240       "Sec-WebSocket-Origin: http://example.com\r\n"
 241       "Sec-WebSocket-Location: ws://example.com/demo\r\n"
 242       "Sec-WebSocket-Protocol: sample\r\n"
 243       "\r\n"
 244       "8jKS'y:G*Co,Wxa-";
 245
 246   EXPECT_EQ(kHandshakeResponseExpectedMessage, handler.GetResponse());
 247 }
 248
 249 TEST(WebSocketHandshakeResponseHandlerTest,
 250      ReplaceResponseCookiesHybi06Handshake) {
 251   WebSocketHandshakeResponseHandler handler;
 252   handler.set_protocol_version(6);
 253   EXPECT_EQ(6, handler.protocol_version());
 254
 255   static const char kHandshakeResponseMessage[] =
 256       "HTTP/1.1 101 Switching Protocols\r\n"
 257       "Upgrade: websocket\r\n"
 258       "Connection: Upgrade\r\n"
 259       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
 260       "Sec-WebSocket-Protocol: sample\r\n"
 261       "Set-Cookie: WK-websocket-test-1\r\n"
 262       "Set-Cookie: WK-websocket-test-httponly=1; HttpOnly\r\n"
 263       "\r\n";
 264
 265   EXPECT_EQ(strlen(kHandshakeResponseMessage),
 266             handler.ParseRawResponse(kHandshakeResponseMessage,
 267                                      strlen(kHandshakeResponseMessage)));
 268   EXPECT_TRUE(handler.HasResponse());
 269   std::vector<std::string> cookies;
 270   handler.GetHeaders(kSetCookieHeaders, arraysize(kSetCookieHeaders), &cookies);
 271   ASSERT_EQ(2U, cookies.size());
 272   EXPECT_EQ("WK-websocket-test-1", cookies[0]);
 273   EXPECT_EQ("WK-websocket-test-httponly=1; HttpOnly", cookies[1]);
 274   handler.RemoveHeaders(kSetCookieHeaders, arraysize(kSetCookieHeaders));
 275
 276   static const char kHandshakeResponseExpectedMessage[] =
 277       "HTTP/1.1 101 Switching Protocols\r\n"
 278       "Upgrade: websocket\r\n"
 279       "Connection: Upgrade\r\n"
 280       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
 281       "Sec-WebSocket-Protocol: sample\r\n"
 282       "\r\n";
 283
 284   EXPECT_EQ(kHandshakeResponseExpectedMessage, handler.GetResponse());
 285 }
 286
 287 TEST(WebSocketHandshakeResponseHandlerTest, BadResponse) {
 288   WebSocketHandshakeResponseHandler handler;
 289
 290   static const char kBadMessage[] = "\n\n\r\net-Location: w";
 291   EXPECT_EQ(strlen(kBadMessage),
 292             handler.ParseRawResponse(kBadMessage, strlen(kBadMessage)));
 293   EXPECT_TRUE(handler.HasResponse());
 294   EXPECT_EQ(kBadMessage, handler.GetResponse());
 295 }
 296
 297 TEST(WebSocketHandshakeResponseHandlerTest, BadResponse2) {
 298   WebSocketHandshakeResponseHandler handler;
 299
 300   static const char kBadMessage[] = "\n\r\n\r\net-Location: w";
 301   EXPECT_EQ(strlen(kBadMessage),
 302             handler.ParseRawResponse(kBadMessage, strlen(kBadMessage)));
 303   EXPECT_TRUE(handler.HasResponse());
 304   EXPECT_EQ(kBadMessage, handler.GetResponse());
 305 }
 306
 307 TEST(WebSocketHandshakeHandlerTest, HttpRequestResponse) {
 308   WebSocketHandshakeRequestHandler request_handler;
 309
 310   static const char kHandshakeRequestMessage[] =
 311       "GET /demo HTTP/1.1\r\n"
 312       "Host: example.com\r\n"
 313       "Connection: Upgrade\r\n"
 314       "Sec-WebSocket-Key2: 12998 5 Y3 1  .P00\r\n"
 315       "Sec-WebSocket-Protocol: sample\r\n"
 316       "Upgrade: WebSocket\r\n"
 317       "Sec-WebSocket-Key1: 4 @1  46546xW%0l 1 5\r\n"
 318       "Origin: http://example.com\r\n"
 319       "\r\n"
 320       "^n:ds[4U";
 321
 322   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
 323                                            strlen(kHandshakeRequestMessage)));
 324   EXPECT_EQ(0, request_handler.protocol_version());
 325
 326   GURL url("ws://example.com/demo");
 327   std::string challenge;
 328   const HttpRequestInfo& request_info =
 329       request_handler.GetRequestInfo(url, &challenge);
 330
 331   EXPECT_EQ(url, request_info.url);
 332   EXPECT_EQ("GET", request_info.method);
 333   EXPECT_FALSE(request_info.extra_headers.HasHeader("Upgrade"));
 334   EXPECT_FALSE(request_info.extra_headers.HasHeader("Connection"));
 335   EXPECT_FALSE(request_info.extra_headers.HasHeader("Sec-WebSocket-Key1"));
 336   EXPECT_FALSE(request_info.extra_headers.HasHeader("Sec-WebSocket-Key2"));
 337   std::string value;
 338   EXPECT_TRUE(request_info.extra_headers.GetHeader("Host", &value));
 339   EXPECT_EQ("example.com", value);
 340   EXPECT_TRUE(request_info.extra_headers.GetHeader("Origin", &value));
 341   EXPECT_EQ("http://example.com", value);
 342   EXPECT_TRUE(request_info.extra_headers.GetHeader("Sec-WebSocket-Protocol",
 343                                                    &value));
 344   EXPECT_EQ("sample", value);
 345
 346   const char expected_challenge[] = "\x31\x6e\x41\x13\x0f\x7e\xd6\x3c^n:ds[4U";
 347
 348   EXPECT_EQ(expected_challenge, challenge);
 349
 350   static const char kHandshakeResponseHeader[] =
 351       "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 352       "Sec-WebSocket-Origin: http://example.com\r\n"
 353       "Sec-WebSocket-Location: ws://example.com/demo\r\n"
 354       "Sec-WebSocket-Protocol: sample\r\n";
 355
 356   std::string raw_headers =
 357       HttpUtil::AssembleRawHeaders(kHandshakeResponseHeader,
 358                                    strlen(kHandshakeResponseHeader));
 359   HttpResponseInfo response_info;
 360   response_info.headers = new HttpResponseHeaders(raw_headers);
 361
 362   EXPECT_TRUE(StartsWithASCII(response_info.headers->GetStatusLine(),
 363                               "HTTP/1.1 101 ", false));
 364   EXPECT_FALSE(response_info.headers->HasHeader("Upgrade"));
 365   EXPECT_FALSE(response_info.headers->HasHeader("Connection"));
 366   EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Origin",
 367                                                     "http://example.com"));
 368   EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Location",
 369                                                     "ws://example.com/demo"));
 370   EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Protocol",
 371                                                     "sample"));
 372
 373   WebSocketHandshakeResponseHandler response_handler;
 374   EXPECT_EQ(0, response_handler.protocol_version());
 375   EXPECT_TRUE(response_handler.ParseResponseInfo(response_info, challenge));
 376   EXPECT_TRUE(response_handler.HasResponse());
 377
 378   static const char kHandshakeResponseExpectedMessage[] =
 379       "HTTP/1.1 101 WebSocket Protocol Handshake\r\n"
 380       "Upgrade: WebSocket\r\n"
 381       "Connection: Upgrade\r\n"
 382       "Sec-WebSocket-Origin: http://example.com\r\n"
 383       "Sec-WebSocket-Location: ws://example.com/demo\r\n"
 384       "Sec-WebSocket-Protocol: sample\r\n"
 385       "\r\n"
 386       "8jKS'y:G*Co,Wxa-";
 387
 388   EXPECT_EQ(kHandshakeResponseExpectedMessage, response_handler.GetResponse());
 389 }
 390
 391 TEST(WebSocketHandshakeHandlerTest, HttpRequestResponseHybi06Handshake) {
 392   WebSocketHandshakeRequestHandler request_handler;
 393
 394   static const char kHandshakeRequestMessage[] =
 395       "GET /demo HTTP/1.1\r\n"
 396       "Host: example.com\r\n"
 397       "Upgrade: websocket\r\n"
 398       "Connection: Upgrade\r\n"
 399       "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
 400       "Sec-WebSocket-Origin: http://example.com\r\n"
 401       "Sec-WebSocket-Protocol: sample\r\n"
 402       "Sec-WebSocket-Version: 6\r\n"
 403       "\r\n";
 404
 405   EXPECT_TRUE(request_handler.ParseRequest(kHandshakeRequestMessage,
 406                                            strlen(kHandshakeRequestMessage)));
 407   EXPECT_EQ(6, request_handler.protocol_version());
 408
 409   GURL url("ws://example.com/demo");
 410   std::string challenge;
 411   const HttpRequestInfo& request_info =
 412       request_handler.GetRequestInfo(url, &challenge);
 413
 414   EXPECT_EQ(url, request_info.url);
 415   EXPECT_EQ("GET", request_info.method);
 416   EXPECT_FALSE(request_info.extra_headers.HasHeader("Upgrade"));
 417   EXPECT_FALSE(request_info.extra_headers.HasHeader("Connection"));
 418   EXPECT_FALSE(request_info.extra_headers.HasHeader("Sec-WebSocket-Key"));
 419   std::string value;
 420   EXPECT_TRUE(request_info.extra_headers.GetHeader("Host", &value));
 421   EXPECT_EQ("example.com", value);
 422   EXPECT_TRUE(request_info.extra_headers.GetHeader("Sec-WebSocket-Origin",
 423                                                    &value));
 424   EXPECT_EQ("http://example.com", value);
 425   EXPECT_TRUE(request_info.extra_headers.GetHeader("Sec-WebSocket-Protocol",
 426                                                    &value));
 427   EXPECT_EQ("sample", value);
 428
 429   EXPECT_EQ("dGhlIHNhbXBsZSBub25jZQ==", challenge);
 430
 431   static const char kHandshakeResponseHeader[] =
 432       "HTTP/1.1 101 Switching Protocols\r\n"
 433       "Sec-WebSocket-Protocol: sample\r\n";
 434
 435   std::string raw_headers =
 436       HttpUtil::AssembleRawHeaders(kHandshakeResponseHeader,
 437                                    strlen(kHandshakeResponseHeader));
 438   HttpResponseInfo response_info;
 439   response_info.headers = new HttpResponseHeaders(raw_headers);
 440
 441   EXPECT_TRUE(StartsWithASCII(response_info.headers->GetStatusLine(),
 442                               "HTTP/1.1 101 ", false));
 443   EXPECT_FALSE(response_info.headers->HasHeader("Upgrade"));
 444   EXPECT_FALSE(response_info.headers->HasHeader("Connection"));
 445   EXPECT_FALSE(response_info.headers->HasHeader("Sec-WebSocket-Accept"));
 446   EXPECT_TRUE(response_info.headers->HasHeaderValue("Sec-WebSocket-Protocol",
 447                                                     "sample"));
 448
 449   WebSocketHandshakeResponseHandler response_handler;
 450   response_handler.set_protocol_version(request_handler.protocol_version());
 451   EXPECT_EQ(6, response_handler.protocol_version());
 452
 453   EXPECT_TRUE(response_handler.ParseResponseInfo(response_info, challenge));
 454   EXPECT_TRUE(response_handler.HasResponse());
 455
 456   static const char kHandshakeResponseExpectedMessage[] =
 457       "HTTP/1.1 101 Switching Protocols\r\n"
 458       "Upgrade: websocket\r\n"
 459       "Connection: Upgrade\r\n"
 460       "Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\r\n"
 461       "Sec-WebSocket-Protocol: sample\r\n"
 462       "\r\n";
 463
 464   EXPECT_EQ(kHandshakeResponseExpectedMessage, response_handler.GetResponse());
 465 }
 466
 467 }  // namespace net