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_UNSAFE(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 COMPILE_ASSERT(ARRAYSIZE_UNSAFE(kMaskingKey) - 1 == 55 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_UNSAFE(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_UNSAFE(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_UNSAFE(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_UNSAFE(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_UNSAFE(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 COMPILE_ASSERT(arraysize(kTestInput) == arraysize(kTestOutput), 298 output_and_input_arrays_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 395
