net/websockets/websocket_frame_test.cc

   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_frame.h"
   6
   7 #include <algorithm>
   8 #include <vector>
   9
  10 #include "base/basictypes.h"
  11 #include "base/memory/aligned_memory.h"
  12 #include "net/base/net_errors.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 namespace net {
  16
  17 namespace {
  18
  19 TEST(WebSocketFrameHeaderTest, FrameLengths) {
  20   struct TestCase {
  21     const char* frame_header;
  22     size_t frame_header_length;
  23     uint64 frame_length;
  24   };
  25   static const TestCase kTests[] = {
  26     { "\x81\x00", 2, GG_UINT64_C(0) },
  27     { "\x81\x7D", 2, GG_UINT64_C(125) },
  28     { "\x81\x7E\x00\x7E", 4, GG_UINT64_C(126) },
  29     { "\x81\x7E\xFF\xFF", 4, GG_UINT64_C(0xFFFF) },
  30     { "\x81\x7F\x00\x00\x00\x00\x00\x01\x00\x00", 10, GG_UINT64_C(0x10000) },
  31     { "\x81\x7F\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 10,
  32       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
  33   };
  34   static const int kNumTests = arraysize(kTests);
  35
  36   for (int i = 0; i < kNumTests; ++i) {
  37     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
  38     header.final = true;
  39     header.payload_length = kTests[i].frame_length;
  40
  41     std::vector<char> expected_output(
  42         kTests[i].frame_header,
  43         kTests[i].frame_header + kTests[i].frame_header_length);
  44     std::vector<char> output(expected_output.size());
  45     EXPECT_EQ(static_cast<int>(expected_output.size()),
  46               WriteWebSocketFrameHeader(
  47                   header, NULL, &output.front(), output.size()));
  48     EXPECT_EQ(expected_output, output);
  49   }
  50 }
  51
  52 TEST(WebSocketFrameHeaderTest, FrameLengthsWithMasking) {
  53   static const char kMaskingKey[] = "\xDE\xAD\xBE\xEF";
  54   static_assert(
  55       arraysize(kMaskingKey) - 1 == WebSocketFrameHeader::kMaskingKeyLength,
  56       "incorrect masking key size");
  57
  58   struct TestCase {
  59     const char* frame_header;
  60     size_t frame_header_length;
  61     uint64 frame_length;
  62   };
  63   static const TestCase kTests[] = {
  64     { "\x81\x80\xDE\xAD\xBE\xEF", 6, GG_UINT64_C(0) },
  65     { "\x81\xFD\xDE\xAD\xBE\xEF", 6, GG_UINT64_C(125) },
  66     { "\x81\xFE\x00\x7E\xDE\xAD\xBE\xEF", 8, GG_UINT64_C(126) },
  67     { "\x81\xFE\xFF\xFF\xDE\xAD\xBE\xEF", 8, GG_UINT64_C(0xFFFF) },
  68     { "\x81\xFF\x00\x00\x00\x00\x00\x01\x00\x00\xDE\xAD\xBE\xEF", 14,
  69       GG_UINT64_C(0x10000) },
  70     { "\x81\xFF\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xDE\xAD\xBE\xEF", 14,
  71       GG_UINT64_C(0x7FFFFFFFFFFFFFFF) }
  72   };
  73   static const int kNumTests = arraysize(kTests);
  74
  75   WebSocketMaskingKey masking_key;
  76   std::copy(kMaskingKey,
  77             kMaskingKey + WebSocketFrameHeader::kMaskingKeyLength,
  78             masking_key.key);
  79
  80   for (int i = 0; i < kNumTests; ++i) {
  81     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
  82     header.final = true;
  83     header.masked = true;
  84     header.payload_length = kTests[i].frame_length;
  85
  86     std::vector<char> expected_output(
  87         kTests[i].frame_header,
  88         kTests[i].frame_header + kTests[i].frame_header_length);
  89     std::vector<char> output(expected_output.size());
  90     EXPECT_EQ(static_cast<int>(expected_output.size()),
  91               WriteWebSocketFrameHeader(
  92                   header, &masking_key, &output.front(), output.size()));
  93     EXPECT_EQ(expected_output, output);
  94   }
  95 }
  96
  97 TEST(WebSocketFrameHeaderTest, FrameOpCodes) {
  98   struct TestCase {
  99     const char* frame_header;
 100     size_t frame_header_length;
 101     WebSocketFrameHeader::OpCode opcode;
 102   };
 103   static const TestCase kTests[] = {
 104     { "\x80\x00", 2, WebSocketFrameHeader::kOpCodeContinuation },
 105     { "\x81\x00", 2, WebSocketFrameHeader::kOpCodeText },
 106     { "\x82\x00", 2, WebSocketFrameHeader::kOpCodeBinary },
 107     { "\x88\x00", 2, WebSocketFrameHeader::kOpCodeClose },
 108     { "\x89\x00", 2, WebSocketFrameHeader::kOpCodePing },
 109     { "\x8A\x00", 2, WebSocketFrameHeader::kOpCodePong },
 110     // These are undefined opcodes, but the builder should accept them anyway.
 111     { "\x83\x00", 2, 0x3 },
 112     { "\x84\x00", 2, 0x4 },
 113     { "\x85\x00", 2, 0x5 },
 114     { "\x86\x00", 2, 0x6 },
 115     { "\x87\x00", 2, 0x7 },
 116     { "\x8B\x00", 2, 0xB },
 117     { "\x8C\x00", 2, 0xC },
 118     { "\x8D\x00", 2, 0xD },
 119     { "\x8E\x00", 2, 0xE },
 120     { "\x8F\x00", 2, 0xF }
 121   };
 122   static const int kNumTests = arraysize(kTests);
 123
 124   for (int i = 0; i < kNumTests; ++i) {
 125     WebSocketFrameHeader header(kTests[i].opcode);
 126     header.final = true;
 127     header.payload_length = 0;
 128
 129     std::vector<char> expected_output(
 130         kTests[i].frame_header,
 131         kTests[i].frame_header + kTests[i].frame_header_length);
 132     std::vector<char> output(expected_output.size());
 133     EXPECT_EQ(static_cast<int>(expected_output.size()),
 134               WriteWebSocketFrameHeader(
 135                   header, NULL, &output.front(), output.size()));
 136     EXPECT_EQ(expected_output, output);
 137   }
 138 }
 139
 140 TEST(WebSocketFrameHeaderTest, FinalBitAndReservedBits) {
 141   struct TestCase {
 142     const char* frame_header;
 143     size_t frame_header_length;
 144     bool final;
 145     bool reserved1;
 146     bool reserved2;
 147     bool reserved3;
 148   };
 149   static const TestCase kTests[] = {
 150     { "\x81\x00", 2, true, false, false, false },
 151     { "\x01\x00", 2, false, false, false, false },
 152     { "\xC1\x00", 2, true, true, false, false },
 153     { "\xA1\x00", 2, true, false, true, false },
 154     { "\x91\x00", 2, true, false, false, true },
 155     { "\x71\x00", 2, false, true, true, true },
 156     { "\xF1\x00", 2, true, true, true, true }
 157   };
 158   static const int kNumTests = arraysize(kTests);
 159
 160   for (int i = 0; i < kNumTests; ++i) {
 161     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
 162     header.final = kTests[i].final;
 163     header.reserved1 = kTests[i].reserved1;
 164     header.reserved2 = kTests[i].reserved2;
 165     header.reserved3 = kTests[i].reserved3;
 166     header.payload_length = 0;
 167
 168     std::vector<char> expected_output(
 169         kTests[i].frame_header,
 170         kTests[i].frame_header + kTests[i].frame_header_length);
 171     std::vector<char> output(expected_output.size());
 172     EXPECT_EQ(static_cast<int>(expected_output.size()),
 173               WriteWebSocketFrameHeader(
 174                   header, NULL, &output.front(), output.size()));
 175     EXPECT_EQ(expected_output, output);
 176   }
 177 }
 178
 179 TEST(WebSocketFrameHeaderTest, InsufficientBufferSize) {
 180   struct TestCase {
 181     uint64 payload_length;
 182     bool masked;
 183     size_t expected_header_size;
 184   };
 185   static const TestCase kTests[] = {
 186     { GG_UINT64_C(0), false, 2u },
 187     { GG_UINT64_C(125), false, 2u },
 188     { GG_UINT64_C(126), false, 4u },
 189     { GG_UINT64_C(0xFFFF), false, 4u },
 190     { GG_UINT64_C(0x10000), false, 10u },
 191     { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), false, 10u },
 192     { GG_UINT64_C(0), true, 6u },
 193     { GG_UINT64_C(125), true, 6u },
 194     { GG_UINT64_C(126), true, 8u },
 195     { GG_UINT64_C(0xFFFF), true, 8u },
 196     { GG_UINT64_C(0x10000), true, 14u },
 197     { GG_UINT64_C(0x7FFFFFFFFFFFFFFF), true, 14u }
 198   };
 199   static const int kNumTests = arraysize(kTests);
 200
 201   for (int i = 0; i < kNumTests; ++i) {
 202     WebSocketFrameHeader header(WebSocketFrameHeader::kOpCodeText);
 203     header.final = true;
 204     header.opcode = WebSocketFrameHeader::kOpCodeText;
 205     header.masked = kTests[i].masked;
 206     header.payload_length = kTests[i].payload_length;
 207
 208     char dummy_buffer[14];
 209     // Set an insufficient size to |buffer_size|.
 210     EXPECT_EQ(
 211         ERR_INVALID_ARGUMENT,
 212         WriteWebSocketFrameHeader(
 213             header, NULL, dummy_buffer, kTests[i].expected_header_size - 1));
 214   }
 215 }
 216
 217 TEST(WebSocketFrameTest, MaskPayload) {
 218   struct TestCase {
 219     const char* masking_key;
 220     uint64 frame_offset;
 221     const char* input;
 222     const char* output;
 223     size_t data_length;
 224   };
 225   static const TestCase kTests[] = {
 226     { "\xDE\xAD\xBE\xEF", 0, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 },
 227     { "\xDE\xAD\xBE\xEF", 1, "FooBar", "\xEB\xD1\x80\x9C\xCC\xCC", 6 },
 228     { "\xDE\xAD\xBE\xEF", 2, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 },
 229     { "\xDE\xAD\xBE\xEF", 3, "FooBar", "\xA9\xB1\xC2\xFC\x8E\xAC", 6 },
 230     { "\xDE\xAD\xBE\xEF", 4, "FooBar", "\x98\xC2\xD1\xAD\xBF\xDF", 6 },
 231     { "\xDE\xAD\xBE\xEF", 42, "FooBar", "\xF8\x80\xB1\xEF\xDF\x9D", 6 },
 232     { "\xDE\xAD\xBE\xEF", 0, "", "", 0 },
 233     { "\xDE\xAD\xBE\xEF", 0, "\xDE\xAD\xBE\xEF", "\x00\x00\x00\x00", 4 },
 234     { "\xDE\xAD\xBE\xEF", 0, "\x00\x00\x00\x00", "\xDE\xAD\xBE\xEF", 4 },
 235     { "\x00\x00\x00\x00", 0, "FooBar", "FooBar", 6 },
 236     { "\xFF\xFF\xFF\xFF", 0, "FooBar", "\xB9\x90\x90\xBD\x9E\x8D", 6 },
 237   };
 238   static const int kNumTests = arraysize(kTests);
 239
 240   for (int i = 0; i < kNumTests; ++i) {
 241     WebSocketMaskingKey masking_key;
 242     std::copy(kTests[i].masking_key,
 243               kTests[i].masking_key + WebSocketFrameHeader::kMaskingKeyLength,
 244               masking_key.key);
 245     std::vector<char> frame_data(kTests[i].input,
 246                                  kTests[i].input + kTests[i].data_length);
 247     std::vector<char> expected_output(kTests[i].output,
 248                                       kTests[i].output + kTests[i].data_length);
 249     MaskWebSocketFramePayload(masking_key,
 250                               kTests[i].frame_offset,
 251                               frame_data.empty() ? NULL : &frame_data.front(),
 252                               frame_data.size());
 253     EXPECT_EQ(expected_output, frame_data);
 254   }
 255 }
 256
 257 // Check that all combinations of alignment, frame offset and chunk size work
 258 // correctly for MaskWebSocketFramePayload(). This is mainly used to ensure that
 259 // vectorisation optimisations don't break anything. We could take a "white box"
 260 // approach and only test the edge cases, but since the exhaustive "black box"
 261 // approach runs in acceptable time, we don't have to take the risk of being
 262 // clever.
 263 //
 264 // This brute-force approach runs in O(N^3) time where N is the size of the
 265 // maximum vector size we want to test again. This might need reconsidering if
 266 // MaskWebSocketFramePayload() is ever optimised for a dedicated vector
 267 // architecture.
 268 TEST(WebSocketFrameTest, MaskPayloadAlignment) {
 269   // This reflects what might be implemented in the future, rather than
 270   // the current implementation. FMA3 and FMA4 support 256-bit vector ops.
 271   static const size_t kMaxVectorSizeInBits = 256;
 272   static const size_t kMaxVectorSize = kMaxVectorSizeInBits / 8;
 273   static const size_t kMaxVectorAlignment = kMaxVectorSize;
 274   static const size_t kMaskingKeyLength =
 275       WebSocketFrameHeader::kMaskingKeyLength;
 276   static const size_t kScratchBufferSize =
 277       kMaxVectorAlignment + kMaxVectorSize * 2;
 278   static const char kTestMask[] = "\xd2\xba\x5a\xbe";
 279   // We use 786 bits of random input to reduce the risk of correlated errors.
 280   static const char kTestInput[] = {
 281     "\x3d\x77\x1d\x1b\x19\x8c\x48\xa3\x19\x6d\xf7\xcc\x39\xe7\x57\x0b"
 282     "\x69\x8c\xda\x4b\xfc\xac\x2c\xd3\x49\x96\x6e\x8a\x7b\x5a\x32\x76"
 283     "\xd0\x11\x43\xa0\x89\xfc\x76\x2b\x10\x2f\x4c\x7b\x4f\xa6\xdd\xe4"
 284     "\xfc\x8e\xd8\x72\xcf\x7e\x37\xcd\x31\xcd\xc1\xc0\x89\x0c\xa7\x4c"
 285     "\xda\xa8\x4b\x75\xa1\xcb\xa9\x77\x19\x4d\x6e\xdf\xc8\x08\x1c\xb6"
 286     "\x6d\xfb\x38\x04\x44\xd5\xba\x57\x9f\x76\xb0\x2e\x07\x91\xe6\xa8"
 287   };
 288   static const size_t kTestInputSize = arraysize(kTestInput) - 1;
 289   static const char kTestOutput[] = {
 290     "\xef\xcd\x47\xa5\xcb\x36\x12\x1d\xcb\xd7\xad\x72\xeb\x5d\x0d\xb5"
 291     "\xbb\x36\x80\xf5\x2e\x16\x76\x6d\x9b\x2c\x34\x34\xa9\xe0\x68\xc8"
 292     "\x02\xab\x19\x1e\x5b\x46\x2c\x95\xc2\x95\x16\xc5\x9d\x1c\x87\x5a"
 293     "\x2e\x34\x82\xcc\x1d\xc4\x6d\x73\xe3\x77\x9b\x7e\x5b\xb6\xfd\xf2"
 294     "\x08\x12\x11\xcb\x73\x71\xf3\xc9\xcb\xf7\x34\x61\x1a\xb2\x46\x08"
 295     "\xbf\x41\x62\xba\x96\x6f\xe0\xe9\x4d\xcc\xea\x90\xd5\x2b\xbc\x16"
 296   };
 297   static_assert(arraysize(kTestInput) == arraysize(kTestOutput),
 298                 "output and input arrays should have the same length");
 299   scoped_ptr<char, base::AlignedFreeDeleter> scratch(
 300       static_cast<char*>(
 301           base::AlignedAlloc(kScratchBufferSize, kMaxVectorAlignment)));
 302   WebSocketMaskingKey masking_key;
 303   std::copy(kTestMask, kTestMask + kMaskingKeyLength, masking_key.key);
 304   for (size_t frame_offset = 0; frame_offset < kMaskingKeyLength;
 305        ++frame_offset) {
 306     for (size_t alignment = 0; alignment < kMaxVectorAlignment; ++alignment) {
 307       char* const aligned_scratch = scratch.get() + alignment;
 308       const size_t aligned_len = std::min(kScratchBufferSize - alignment,
 309                                           kTestInputSize - frame_offset);
 310       for (size_t chunk_size = 1; chunk_size < kMaxVectorSize; ++chunk_size) {
 311         memcpy(aligned_scratch, kTestInput + frame_offset, aligned_len);
 312         for (size_t chunk_start = 0; chunk_start < aligned_len;
 313              chunk_start += chunk_size) {
 314           const size_t this_chunk_size =
 315               std::min(chunk_size, aligned_len - chunk_start);
 316           MaskWebSocketFramePayload(masking_key,
 317                                     frame_offset + chunk_start,
 318                                     aligned_scratch + chunk_start,
 319                                     this_chunk_size);
 320         }
 321         // Stop the test if it fails, since we don't want to spew thousands of
 322         // failures.
 323         ASSERT_TRUE(std::equal(aligned_scratch,
 324                                aligned_scratch + aligned_len,
 325                                kTestOutput + frame_offset))
 326             << "Output failed to match for frame_offset=" << frame_offset
 327             << ", alignment=" << alignment << ", chunk_size=" << chunk_size;
 328       }
 329     }
 330   }
 331 }
 332
 333 // "IsKnownDataOpCode" is currently implemented in an "obviously correct"
 334 // manner, but we test is anyway in case it changes to a more complex
 335 // implementation in future.
 336 TEST(WebSocketFrameHeaderTest, IsKnownDataOpCode) {
 337   // Make the test less verbose.
 338   typedef WebSocketFrameHeader Frame;
 339
 340   // Known opcode, is used for data frames
 341   EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeContinuation));
 342   EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeText));
 343   EXPECT_TRUE(Frame::IsKnownDataOpCode(Frame::kOpCodeBinary));
 344
 345   // Known opcode, is used for control frames
 346   EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeClose));
 347   EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodePing));
 348   EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodePong));
 349
 350   // Check that unused opcodes return false
 351   EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeDataUnused));
 352   EXPECT_FALSE(Frame::IsKnownDataOpCode(Frame::kOpCodeControlUnused));
 353
 354   // Check that opcodes with the 4 bit set return false
 355   EXPECT_FALSE(Frame::IsKnownDataOpCode(0x6));
 356   EXPECT_FALSE(Frame::IsKnownDataOpCode(0xF));
 357
 358   // Check that out-of-range opcodes return false
 359   EXPECT_FALSE(Frame::IsKnownDataOpCode(-1));
 360   EXPECT_FALSE(Frame::IsKnownDataOpCode(0xFF));
 361 }
 362
 363 // "IsKnownControlOpCode" is implemented in an "obviously correct" manner but
 364 // might be optimised in future.
 365 TEST(WebSocketFrameHeaderTest, IsKnownControlOpCode) {
 366   // Make the test less verbose.
 367   typedef WebSocketFrameHeader Frame;
 368
 369   // Known opcode, is used for data frames
 370   EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeContinuation));
 371   EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeText));
 372   EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeBinary));
 373
 374   // Known opcode, is used for control frames
 375   EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodeClose));
 376   EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodePing));
 377   EXPECT_TRUE(Frame::IsKnownControlOpCode(Frame::kOpCodePong));
 378
 379   // Check that unused opcodes return false
 380   EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeDataUnused));
 381   EXPECT_FALSE(Frame::IsKnownControlOpCode(Frame::kOpCodeControlUnused));
 382
 383   // Check that opcodes with the 4 bit set return false
 384   EXPECT_FALSE(Frame::IsKnownControlOpCode(0x6));
 385   EXPECT_FALSE(Frame::IsKnownControlOpCode(0xF));
 386
 387   // Check that out-of-range opcodes return false
 388   EXPECT_FALSE(Frame::IsKnownControlOpCode(-1));
 389   EXPECT_FALSE(Frame::IsKnownControlOpCode(0xFF));
 390 }
 391
 392 }  // namespace
 393
 394 }  // namespace net