content/browser/renderer_host/p2p/socket_host_unittest.cc

   1 // Copyright (c) 2014 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 "content/browser/renderer_host/p2p/socket_host.h"
   6
   7 #include <vector>
   8
   9 #include "base/memory/scoped_ptr.h"
  10 #include "content/browser/renderer_host/p2p/socket_host_test_utils.h"
  11 #include "net/base/ip_endpoint.h"
  12 #include "testing/gmock/include/gmock/gmock.h"
  13 #include "testing/gtest/include/gtest/gtest.h"
  14
  15 static unsigned char kFakeTag[4] = { 0xba, 0xdd, 0xba, 0xdd };
  16 static unsigned char kTestKey[] = "12345678901234567890";
  17 static unsigned char kTestAstValue[3] = { 0xaa, 0xbb, 0xcc };
  18
  19 // Rtp message with invalid length.
  20 static unsigned char kRtpMsgWithInvalidLength[] = {
  21   0x94, 0x00, 0x00, 0x00,
  22   0x00, 0x00, 0x00, 0x00,
  23   0xAA, 0xBB, 0xCC, 0XDD,  // SSRC
  24   0xDD, 0xCC, 0xBB, 0xAA   // Only 1 CSRC, but CC count is 4.
  25 };
  26
  27 // Rtp message with single byte header extension, invalid extension length.
  28 static unsigned char kRtpMsgWithInvalidExtnLength[] = {
  29   0x90, 0x00, 0x00, 0x00,
  30   0x00, 0x00, 0x00, 0x00,
  31   0x00, 0x00, 0x00, 0x00,
  32   0xBE, 0xDE, 0x0A, 0x00   // Extn length - 0x0A00
  33 };
  34
  35 // Valid rtp Message with 2 byte header extension.
  36 static unsigned char kRtpMsgWith2ByteExtnHeader[] = {
  37   0x90, 0x00, 0x00, 0x00,
  38   0x00, 0x00, 0x00, 0x00,
  39   0xAA, 0xBB, 0xCC, 0XDD,  // SSRC
  40   0x10, 0x00, 0x00, 0x01,  // 2 Byte header extension
  41   0x01, 0x00, 0x00, 0x00
  42 };
  43
  44 // Stun Indication message with Zero length
  45 static unsigned char kTurnSendIndicationMsgWithNoAttributes[] = {
  46   0x00, 0x16, 0x00, 0x00,  // Zero length
  47   0x21, 0x12, 0xA4, 0x42,  // magic cookie
  48   '0', '1', '2', '3',      // transaction id
  49   '4', '5', '6', '7',
  50   '8', '9', 'a', 'b',
  51 };
  52
  53 // Stun Send Indication message with invalid length in stun header.
  54 static unsigned char kTurnSendIndicationMsgWithInvalidLength[] = {
  55   0x00, 0x16, 0xFF, 0x00,  // length of 0xFF00
  56   0x21, 0x12, 0xA4, 0x42,  // magic cookie
  57   '0', '1', '2', '3',      // transaction id
  58   '4', '5', '6', '7',
  59   '8', '9', 'a', 'b',
  60 };
  61
  62 // Stun Send Indication message with no DATA attribute in message.
  63 static unsigned char kTurnSendIndicatinMsgWithNoDataAttribute[] = {
  64   0x00, 0x16, 0x00, 0x08,  // length of
  65   0x21, 0x12, 0xA4, 0x42,  // magic cookie
  66   '0', '1', '2', '3',      // transaction id
  67   '4', '5', '6', '7',
  68   '8', '9', 'a', 'b',
  69   0x00, 0x20, 0x00, 0x04,  // Mapped address.
  70   0x00, 0x00, 0x00, 0x00
  71 };
  72
  73 // A valid STUN indication message with a valid RTP header in data attribute
  74 // payload field and no extension bit set.
  75 static unsigned char kTurnSendIndicationMsgWithoutRtpExtension[] = {
  76   0x00, 0x16, 0x00, 0x18,  // length of
  77   0x21, 0x12, 0xA4, 0x42,  // magic cookie
  78   '0', '1', '2', '3',      // transaction id
  79   '4', '5', '6', '7',
  80   '8', '9', 'a', 'b',
  81   0x00, 0x20, 0x00, 0x04,  // Mapped address.
  82   0x00, 0x00, 0x00, 0x00,
  83   0x00, 0x13, 0x00, 0x0C,  // Data attribute.
  84   0x80, 0x00, 0x00, 0x00,  // RTP packet.
  85   0x00, 0x00, 0x00, 0x00,
  86   0x00, 0x00, 0x00, 0x00,
  87 };
  88
  89 // A valid STUN indication message with a valid RTP header and a extension
  90 // header.
  91 static unsigned char kTurnSendIndicationMsgWithAbsSendTimeExtension[] = {
  92   0x00, 0x16, 0x00, 0x24,  // length of
  93   0x21, 0x12, 0xA4, 0x42,  // magic cookie
  94   '0', '1', '2', '3',      // transaction id
  95   '4', '5', '6', '7',
  96   '8', '9', 'a', 'b',
  97   0x00, 0x20, 0x00, 0x04,  // Mapped address.
  98   0x00, 0x00, 0x00, 0x00,
  99   0x00, 0x13, 0x00, 0x18,  // Data attribute.
 100   0x90, 0x00, 0x00, 0x00,  // RTP packet.
 101   0x00, 0x00, 0x00, 0x00,
 102   0x00, 0x00, 0x00, 0x00,
 103   0xBE, 0xDE, 0x00, 0x02,
 104   0x22, 0xaa, 0xbb, 0xcc,
 105   0x32, 0xaa, 0xbb, 0xcc,
 106 };
 107
 108 // A valid TURN channel header, but not RTP packet.
 109 static unsigned char kTurnChannelMsgNoRtpPacket[] = {
 110   0x40, 0x00, 0x00, 0x04,
 111   0xaa, 0xbb, 0xcc, 0xdd,
 112 };
 113
 114 // Turn ChannelMessage with zero length of payload.
 115 static unsigned char kTurnChannelMsgWithZeroLength[] = {
 116   0x40, 0x00, 0x00, 0x00
 117 };
 118
 119 // Turn ChannelMessage, wrapping a RTP packet without extension.
 120 static unsigned char kTurnChannelMsgWithRtpPacket[] = {
 121   0x40, 0x00, 0x00, 0x0C,
 122   0x80, 0x00, 0x00, 0x00,  // RTP packet.
 123   0x00, 0x00, 0x00, 0x00,
 124   0x00, 0x00, 0x00, 0x00,
 125 };
 126
 127 // Turn ChannelMessage, wrapping a RTP packet with AbsSendTime Extension.
 128 static unsigned char kTurnChannelMsgWithAbsSendTimeExtension[] = {
 129   0x40, 0x00, 0x00, 0x14,
 130   0x90, 0x00, 0x00, 0x00,  // RTP packet.
 131   0x00, 0x00, 0x00, 0x00,
 132   0x00, 0x00, 0x00, 0x00,
 133   0xBE, 0xDE, 0x00, 0x01,
 134   0x32, 0xaa, 0xbb, 0xcc,
 135 };
 136
 137 // RTP packet with single byte extension header of length 4 bytes.
 138 // Extension id = 3 and length = 3
 139 static unsigned char kRtpMsgWithAbsSendTimeExtension[] = {
 140   0x90, 0x00, 0x00, 0x00,
 141   0x00, 0x00, 0x00, 0x00,
 142   0x00, 0x00, 0x00, 0x00,
 143   0xBE, 0xDE, 0x00, 0x02,
 144   0x22, 0x00, 0x02, 0x1c,
 145   0x32, 0xaa, 0xbb, 0xcc,
 146 };
 147
 148 // Index of AbsSendTimeExtn data in message |kRtpMsgWithAbsSendTimeExtension|.
 149 static const int kAstIndexInRtpMsg = 21;
 150
 151 namespace content {
 152
 153 // This test verifies parsing of all invalid raw packets.
 154 TEST(P2PSocketHostTest, TestInvalidRawRtpMessages) {
 155   int start_pos = INT_MAX, rtp_length = INT_MAX;
 156   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 157       reinterpret_cast<char*>(kRtpMsgWithInvalidLength),
 158       sizeof(kRtpMsgWithInvalidLength),
 159       &start_pos, &rtp_length));
 160   EXPECT_EQ(INT_MAX, start_pos);
 161   EXPECT_EQ(INT_MAX, rtp_length);
 162
 163   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 164       reinterpret_cast<char*>(kRtpMsgWithInvalidExtnLength),
 165       sizeof(kRtpMsgWithInvalidExtnLength),
 166       &start_pos, &rtp_length));
 167   EXPECT_EQ(INT_MAX, start_pos);
 168   EXPECT_EQ(INT_MAX, rtp_length);
 169 }
 170
 171 // Verify invalid TURN send indication messages. Messages are proper STUN
 172 // messages with incorrect values in attributes.
 173 TEST(P2PSocketHostTest, TestInvalidTurnSendIndicationMessages) {
 174   // Initializing out params to very large value.
 175   int start_pos = INT_MAX, rtp_length = INT_MAX;
 176   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 177       reinterpret_cast<char*>(kTurnSendIndicationMsgWithNoAttributes),
 178       sizeof(kTurnSendIndicationMsgWithNoAttributes),
 179       &start_pos, &rtp_length));
 180   EXPECT_EQ(INT_MAX, start_pos);
 181   EXPECT_EQ(INT_MAX, rtp_length);
 182
 183   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 184       reinterpret_cast<char*>(kTurnSendIndicationMsgWithInvalidLength),
 185       sizeof(kTurnSendIndicationMsgWithInvalidLength),
 186       &start_pos, &rtp_length));
 187   EXPECT_EQ(INT_MAX, start_pos);
 188   EXPECT_EQ(INT_MAX, rtp_length);
 189
 190   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 191       reinterpret_cast<char*>(kTurnSendIndicatinMsgWithNoDataAttribute),
 192       sizeof(kTurnSendIndicatinMsgWithNoDataAttribute),
 193       &start_pos, &rtp_length));
 194   EXPECT_EQ(INT_MAX, start_pos);
 195   EXPECT_EQ(INT_MAX, rtp_length);
 196 }
 197
 198 // This test verifies incorrectly formed TURN channel messages.
 199 TEST(P2PSocketHostTest, TestInvalidTurnChannelMessages) {
 200   int start_pos = INT_MAX, rtp_length = INT_MAX;
 201   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 202       reinterpret_cast<char*>(kTurnChannelMsgNoRtpPacket),
 203       sizeof(kTurnChannelMsgNoRtpPacket),
 204       &start_pos, &rtp_length));
 205   EXPECT_EQ(INT_MAX, start_pos);
 206   EXPECT_EQ(INT_MAX, rtp_length);
 207
 208   EXPECT_FALSE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 209       reinterpret_cast<char*>(kTurnChannelMsgWithZeroLength),
 210       sizeof(kTurnChannelMsgWithZeroLength),
 211       &start_pos, &rtp_length));
 212   EXPECT_EQ(INT_MAX, start_pos);
 213   EXPECT_EQ(INT_MAX, rtp_length);
 214 }
 215
 216 // This test verifies parsing of a valid RTP packet which has 2byte header
 217 // extension instead of a 1 byte header extension.
 218 TEST(P2PSocketHostTest, TestValid2ByteExtnHdrRtpMessage) {
 219   int start_pos = INT_MAX, rtp_length = INT_MAX;
 220   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 221       reinterpret_cast<char*>(kRtpMsgWith2ByteExtnHeader),
 222       sizeof(kRtpMsgWith2ByteExtnHeader),
 223       &start_pos, &rtp_length));
 224   EXPECT_EQ(20, rtp_length);
 225   EXPECT_EQ(0, start_pos);
 226 }
 227
 228 // This test verifies parsing of a valid RTP packet which has 1 byte header
 229 // AbsSendTime extension in it.
 230 TEST(P2PSocketHostTest, TestValidRtpPacketWithAbsSendTimeExtension) {
 231   int start_pos = INT_MAX, rtp_length = INT_MAX;
 232   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 233       reinterpret_cast<char*>(kRtpMsgWithAbsSendTimeExtension),
 234       sizeof(kRtpMsgWithAbsSendTimeExtension),
 235       &start_pos, &rtp_length));
 236   EXPECT_EQ(24, rtp_length);
 237   EXPECT_EQ(0, start_pos);
 238 }
 239
 240 // This test verifies parsing of a valid TURN Send Indication messages.
 241 TEST(P2PSocketHostTest, TestValidTurnSendIndicationMessages) {
 242   int start_pos = INT_MAX, rtp_length = INT_MAX;
 243   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 244       reinterpret_cast<char*>(kTurnSendIndicationMsgWithoutRtpExtension),
 245       sizeof(kTurnSendIndicationMsgWithoutRtpExtension),
 246       &start_pos, &rtp_length));
 247   EXPECT_EQ(12, rtp_length);
 248   EXPECT_EQ(32, start_pos);
 249
 250   start_pos = INT_MAX, rtp_length = INT_MAX;
 251   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 252       reinterpret_cast<char*>(kTurnSendIndicationMsgWithAbsSendTimeExtension),
 253       sizeof(kTurnSendIndicationMsgWithAbsSendTimeExtension),
 254       &start_pos, &rtp_length));
 255   EXPECT_EQ(24, rtp_length);
 256   EXPECT_EQ(32, start_pos);
 257 }
 258
 259 // This test verifies parsing of valid TURN Channel Messages.
 260 TEST(P2PSocketHostTest, TestValidTurnChannelMessages) {
 261   int start_pos = -1, rtp_length = -1;
 262   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 263       reinterpret_cast<char*>(kTurnChannelMsgWithRtpPacket),
 264       sizeof(kTurnChannelMsgWithRtpPacket), &start_pos, &rtp_length));
 265   EXPECT_EQ(12, rtp_length);
 266   EXPECT_EQ(4, start_pos);
 267
 268   start_pos = -1, rtp_length = -1;
 269   EXPECT_TRUE(packet_processing_helpers::GetRtpPacketStartPositionAndLength(
 270       reinterpret_cast<char*>(kTurnChannelMsgWithAbsSendTimeExtension),
 271       sizeof(kTurnChannelMsgWithAbsSendTimeExtension),
 272       &start_pos, &rtp_length));
 273   EXPECT_EQ(20, rtp_length);
 274   EXPECT_EQ(4, start_pos);
 275 }
 276
 277 // Verify handling of a 2 byte extension header RTP messsage. Currently we don't
 278 // handle this kind of message.
 279 TEST(P2PSocketHostTest, TestUpdateAbsSendTimeExtensionIn2ByteHeaderExtn) {
 280   EXPECT_FALSE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
 281     reinterpret_cast<char*>(kRtpMsgWith2ByteExtnHeader),
 282     sizeof(kRtpMsgWith2ByteExtnHeader), 3, 0));
 283 }
 284
 285 // Verify finding an extension ID in the TURN send indication message.
 286 TEST(P2PSocketHostTest, TestUpdateAbsSendTimeExtensionInTurnSendIndication) {
 287   EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
 288       reinterpret_cast<char*>(kTurnSendIndicationMsgWithoutRtpExtension),
 289       sizeof(kTurnSendIndicationMsgWithoutRtpExtension), 3, 0));
 290
 291   EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
 292       reinterpret_cast<char*>(kTurnSendIndicationMsgWithAbsSendTimeExtension),
 293       sizeof(kTurnSendIndicationMsgWithAbsSendTimeExtension), 3, 0));
 294 }
 295
 296 // Test without any packet options variables set. This method should return
 297 // without HMAC value in the packet.
 298 TEST(P2PSocketHostTest, TestApplyPacketOptionsWithDefaultValues) {
 299   unsigned char fake_tag[4] = { 0xba, 0xdd, 0xba, 0xdd };
 300   rtc::PacketOptions options;
 301   std::vector<char> rtp_packet;
 302   rtp_packet.resize(sizeof(kRtpMsgWithAbsSendTimeExtension) + 4);  // tag length
 303   memcpy(&rtp_packet[0], kRtpMsgWithAbsSendTimeExtension,
 304          sizeof(kRtpMsgWithAbsSendTimeExtension));
 305   memcpy(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)], fake_tag, 4);
 306   EXPECT_TRUE(
 307       packet_processing_helpers::ApplyPacketOptions(
 308       &rtp_packet[0], rtp_packet.size(), options, 0));
 309   // Making sure we have't updated the HMAC.
 310   EXPECT_EQ(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
 311                       fake_tag, 4));
 312
 313   // Verify AbsouluteSendTime extension field is not modified.
 314   EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg],
 315                       kTestAstValue, sizeof(kTestAstValue)));
 316 }
 317
 318 // Veirfy HMAC is updated when packet option parameters are set.
 319 TEST(P2PSocketHostTest, TestApplyPacketOptionsWithAuthParams) {
 320   rtc::PacketOptions options;
 321   options.packet_time_params.srtp_auth_key.resize(20);
 322   options.packet_time_params.srtp_auth_key.assign(
 323       kTestKey, kTestKey + sizeof(kTestKey));
 324   options.packet_time_params.srtp_auth_tag_len = 4;
 325
 326   std::vector<char> rtp_packet;
 327   rtp_packet.resize(sizeof(kRtpMsgWithAbsSendTimeExtension) + 4);  // tag length
 328   memcpy(&rtp_packet[0], kRtpMsgWithAbsSendTimeExtension,
 329          sizeof(kRtpMsgWithAbsSendTimeExtension));
 330   memcpy(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)], kFakeTag, 4);
 331   EXPECT_TRUE(packet_processing_helpers::ApplyPacketOptions(
 332                   &rtp_packet[0], rtp_packet.size(), options, 0));
 333   // HMAC should be different from fake_tag.
 334   EXPECT_NE(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
 335                       kFakeTag, sizeof(kFakeTag)));
 336
 337    // Verify AbsouluteSendTime extension field is not modified.
 338   EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg],
 339                       kTestAstValue, sizeof(kTestAstValue)));
 340 }
 341
 342 // Verify finding an extension ID in a raw rtp message.
 343 TEST(P2PSocketHostTest, TestUpdateAbsSendTimeExtensionInRtpPacket) {
 344   EXPECT_TRUE(packet_processing_helpers::UpdateRtpAbsSendTimeExtn(
 345       reinterpret_cast<char*>(kRtpMsgWithAbsSendTimeExtension),
 346       sizeof(kRtpMsgWithAbsSendTimeExtension), 3, 0));
 347 }
 348
 349 // Verify we update both AbsSendTime extension header and HMAC.
 350 TEST(P2PSocketHostTest, TestApplyPacketOptionsWithAuthParamsAndAbsSendTime) {
 351   rtc::PacketOptions options;
 352   options.packet_time_params.srtp_auth_key.resize(20);
 353   options.packet_time_params.srtp_auth_key.assign(
 354       kTestKey, kTestKey + sizeof(kTestKey));
 355   options.packet_time_params.srtp_auth_tag_len = 4;
 356   options.packet_time_params.rtp_sendtime_extension_id = 3;
 357   // 3 is also present in the test message.
 358
 359   std::vector<char> rtp_packet;
 360   rtp_packet.resize(sizeof(kRtpMsgWithAbsSendTimeExtension) + 4);  // tag length
 361   memcpy(&rtp_packet[0], kRtpMsgWithAbsSendTimeExtension,
 362          sizeof(kRtpMsgWithAbsSendTimeExtension));
 363   memcpy(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)], kFakeTag, 4);
 364   EXPECT_TRUE(packet_processing_helpers::ApplyPacketOptions(
 365                   &rtp_packet[0], rtp_packet.size(), options, 0xccbbaa));
 366   // HMAC should be different from fake_tag.
 367   EXPECT_NE(0, memcmp(&rtp_packet[sizeof(kRtpMsgWithAbsSendTimeExtension)],
 368                       kFakeTag, sizeof(kFakeTag)));
 369
 370   // ApplyPackets should have the new timestamp passed as input.
 371   unsigned char timestamp_array[3] = { 0xcc, 0xbb, 0xaa };
 372   EXPECT_EQ(0, memcmp(&rtp_packet[kAstIndexInRtpMsg],
 373                       timestamp_array, sizeof(timestamp_array)));
 374 }
 375
 376 }  // namespace content