Support encrypted RTP extensions (RFC 6904)

webrtc/pc/webrtcsdp_unittest.cc

 /*
  *  Copyright 2011 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 74 matching lines @@
     "dummy_session_params\r\n";
 static const char kAttributeCryptoVideo[] =
     "a=crypto:1 AES_CM_128_HMAC_SHA1_80 "
     "inline:d0RmdmcmVCspeEc3QGZiNWpVLFJhQX1cfHAwJSoj|2^20|1:32\r\n";
 static const char kFingerprint[] = "a=fingerprint:sha-1 "
     "4A:AD:B9:B1:3F:82:18:3B:54:02:12:DF:3E:5D:49:6B:19:E5:7C:AB\r\n";
 static const int kExtmapId = 1;
 static const char kExtmapUri[] = "http://example.com/082005/ext.htm#ttime";
 static const char kExtmap[] =
     "a=extmap:1 http://example.com/082005/ext.htm#ttime\r\n";
+static const char kExtmapEncrypted[] =
+    "a=extmap:1 urn:ietf:params:rtp-hdrext:encrypt "
+    "http://example.com/082005/ext.htm#ttime\r\n";
 static const char kExtmapWithDirectionAndAttribute[] =
     "a=extmap:1/sendrecv http://example.com/082005/ext.htm#ttime a1 a2\r\n";
+static const char kExtmapWithDirectionAndAttributeEncrypted[] =
+    "a=extmap:1/sendrecv urn:ietf:params:rtp-hdrext:encrypt "
+    "http://example.com/082005/ext.htm#ttime a1 a2\r\n";
 
 static const uint8_t kIdentityDigest[] = {
     0x4A, 0xAD, 0xB9, 0xB1, 0x3F, 0x82, 0x18, 0x3B, 0x54, 0x02,
     0x12, 0xDF, 0x3E, 0x5D, 0x49, 0x6B, 0x19, 0xE5, 0x7C, 0xAB};
 
 static const char kDtlsSctp[] = "DTLS/SCTP";
 static const char kUdpDtlsSctp[] = "UDP/DTLS/SCTP";
 static const char kTcpDtlsSctp[] = "TCP/DTLS/SCTP";
 
 struct CodecParams {
@@ skipping 1096 matching lines @@
     EXPECT_EQ(cd1->streams(), cd2->streams());
 
     // extmap
     ASSERT_EQ(cd1->rtp_header_extensions().size(),
               cd2->rtp_header_extensions().size());
     for (size_t i = 0; i< cd1->rtp_header_extensions().size(); ++i) {
       const RtpExtension ext1 = cd1->rtp_header_extensions().at(i);
       const RtpExtension ext2 = cd2->rtp_header_extensions().at(i);
       EXPECT_EQ(ext1.uri, ext2.uri);
       EXPECT_EQ(ext1.id, ext2.id);
+      EXPECT_EQ(ext1.encrypted, ext2.encrypted);
     }
   }
 
   void CompareDataContentDescription(const DataContentDescription* dcd1,
                                      const DataContentDescription* dcd2) {
     EXPECT_EQ(dcd1->use_sctpmap(), dcd2->use_sctpmap());
     CompareMediaContentDescription<DataContentDescription>(dcd1, dcd2);
   }
 
   void CompareSessionDescription(const SessionDescription& desc1,
@@ skipping 201 matching lines @@
         TransportDescription(std::vector<std::string>(), kUfragVoice, kPwdVoice,
                              cricket::ICEMODE_FULL,
                              cricket::CONNECTIONROLE_NONE, &fingerprint))));
     EXPECT_TRUE(desc_.AddTransportInfo(TransportInfo(
         kVideoContentName,
         TransportDescription(std::vector<std::string>(), kUfragVideo, kPwdVideo,
                              cricket::ICEMODE_FULL,
                              cricket::CONNECTIONROLE_NONE, &fingerprint))));
   }
 
-  void AddExtmap() {
+  void AddExtmap(bool encrypted) {
     audio_desc_ = static_cast<AudioContentDescription*>(
         audio_desc_->Copy());
     video_desc_ = static_cast<VideoContentDescription*>(
         video_desc_->Copy());
-    audio_desc_->AddRtpHeaderExtension(RtpExtension(kExtmapUri, kExtmapId));
-    video_desc_->AddRtpHeaderExtension(RtpExtension(kExtmapUri, kExtmapId));
+    audio_desc_->AddRtpHeaderExtension(
+        RtpExtension(kExtmapUri, kExtmapId, encrypted));
+    video_desc_->AddRtpHeaderExtension(
+        RtpExtension(kExtmapUri, kExtmapId, encrypted));
     desc_.RemoveContentByName(kAudioContentName);
     desc_.RemoveContentByName(kVideoContentName);
     desc_.AddContent(kAudioContentName, NS_JINGLE_RTP, audio_desc_);
     desc_.AddContent(kVideoContentName, NS_JINGLE_RTP, video_desc_);
   }
 
   void RemoveCryptos() {
     audio_desc_->set_cryptos(std::vector<CryptoParams>());
     video_desc_->set_cryptos(std::vector<CryptoParams>());
   }
@@ skipping 117 matching lines @@
                    video_rejected ? "" : kPwdVideo);
     JsepSessionDescription jdesc_no_candidates(kDummyString);
     if (!jdesc_no_candidates.Initialize(desc_.Copy(), jdesc_.session_id(),
                                         jdesc_.session_version())) {
       return false;
     }
     EXPECT_TRUE(CompareSessionDescription(jdesc_no_candidates, new_jdesc));
     return true;
   }
 
-  void TestDeserializeExtmap(bool session_level, bool media_level) {
-    AddExtmap();
+  void TestDeserializeExtmap(bool session_level, bool media_level,
+      bool encrypted) {
+    AddExtmap(encrypted);
     JsepSessionDescription new_jdesc("dummy");
     ASSERT_TRUE(new_jdesc.Initialize(desc_.Copy(),
                                      jdesc_.session_id(),
                                      jdesc_.session_version()));
     JsepSessionDescription jdesc_with_extmap("dummy");
     std::string sdp_with_extmap = kSdpString;
     if (session_level) {
-      InjectAfter(kSessionTime, kExtmapWithDirectionAndAttribute,
+      InjectAfter(kSessionTime,
+                  encrypted ? kExtmapWithDirectionAndAttributeEncrypted
+                            : kExtmapWithDirectionAndAttribute,
                   &sdp_with_extmap);
     }
     if (media_level) {
-      InjectAfter(kAttributeIcePwdVoice, kExtmapWithDirectionAndAttribute,
+      InjectAfter(kAttributeIcePwdVoice,
+                  encrypted ? kExtmapWithDirectionAndAttributeEncrypted
+                            : kExtmapWithDirectionAndAttribute,
                   &sdp_with_extmap);
-      InjectAfter(kAttributeIcePwdVideo, kExtmapWithDirectionAndAttribute,
+      InjectAfter(kAttributeIcePwdVideo,
+                  encrypted ? kExtmapWithDirectionAndAttributeEncrypted
+                            : kExtmapWithDirectionAndAttribute,
                   &sdp_with_extmap);
     }
     // The extmap can't be present at the same time in both session level and
     // media level.
     if (session_level && media_level) {
       SdpParseError error;
       EXPECT_FALSE(webrtc::SdpDeserialize(sdp_with_extmap,
                    &jdesc_with_extmap, &error));
       EXPECT_NE(std::string::npos, error.description.find("a=extmap"));
     } else {
@@ skipping 518 matching lines @@
   std::string expected_sdp = kSdpString;
   expected_sdp.append(kSdpRtpDataChannelString);
   // Serializing data content shouldn't ignore bandwidth settings.
   InjectAfter("m=application 9 RTP/SAVPF 101\r\nc=IN IP4 0.0.0.0\r\n",
               "b=AS:100\r\n",
               &expected_sdp);
   EXPECT_EQ(expected_sdp, message);
 }
 
 TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithExtmap) {
-  AddExtmap();
+  bool encrypted = false;
+  AddExtmap(encrypted);
   JsepSessionDescription desc_with_extmap("dummy");
   ASSERT_TRUE(desc_with_extmap.Initialize(desc_.Copy(),
                                           kSessionId, kSessionVersion));
   std::string message = webrtc::SdpSerialize(desc_with_extmap, false);
 
   std::string sdp_with_extmap = kSdpString;
   InjectAfter("a=mid:audio_content_name\r\n",
               kExtmap, &sdp_with_extmap);
   InjectAfter("a=mid:video_content_name\r\n",
               kExtmap, &sdp_with_extmap);
 
   EXPECT_EQ(sdp_with_extmap, message);
 }
 
+TEST_F(WebRtcSdpTest, SerializeSessionDescriptionWithExtmapEncrypted) {
+  bool encrypted = true;
+  AddExtmap(encrypted);
+  JsepSessionDescription desc_with_extmap("dummy");
+  ASSERT_TRUE(desc_with_extmap.Initialize(desc_.Copy(),
+                                          kSessionId, kSessionVersion));
+  std::string message = webrtc::SdpSerialize(desc_with_extmap, false);
+
+  std::string sdp_with_extmap = kSdpString;
+  InjectAfter("a=mid:audio_content_name\r\n",
+              kExtmapEncrypted, &sdp_with_extmap);
+  InjectAfter("a=mid:video_content_name\r\n",
+              kExtmapEncrypted, &sdp_with_extmap);
+
+  EXPECT_EQ(sdp_with_extmap, message);

[Taylor Brandstetter, 2017/03/22 18:00:11]

nit: Tests for SDP string equality are fragile since they rely on a specific
ordering of attributes. Would be better (in my opinion) if the test for
serialization simply serialized and deserialized the description and verified
that they're the same, relying on the tests for deserialization to ensure that
half already works. See the comment above "TestSerialize".

[joachim, 2017/03/23 00:04:34]

I based my test on "SerializeSessionDescriptionWithExtmap" just above which also
does the string comparison. Changed the new test now.

+}
+
 TEST_F(WebRtcSdpTest, SerializeCandidates) {
   std::string message = webrtc::SdpSerializeCandidate(*jcandidate_);
   EXPECT_EQ(std::string(kRawCandidate), message);
 
   Candidate candidate_with_ufrag(candidates_.front());
   candidate_with_ufrag.set_username("ABC");
   jcandidate_.reset(new JsepIceCandidate(std::string("audio_content_name"), 0,
                                          candidate_with_ufrag));
   message = webrtc::SdpSerializeCandidate(*jcandidate_);
   EXPECT_EQ(std::string(kRawCandidate) + " ufrag ABC", message);
@@ skipping 625 matching lines @@
               "b=AS:100\r\n",
               &sdp_with_bandwidth);
   JsepSessionDescription jdesc_with_bandwidth(kDummyString);
 
   // SCTP has congestion control, so we shouldn't limit the bandwidth
   // as we do for RTP.
   EXPECT_TRUE(SdpDeserialize(sdp_with_bandwidth, &jdesc_with_bandwidth));
   EXPECT_TRUE(CompareSessionDescription(jdesc, jdesc_with_bandwidth));
 }
 
-TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithSessionLevelExtmap) {
-  TestDeserializeExtmap(true, false);
+class WebRtcSdpExtmapTest
+  : public WebRtcSdpTest, public testing::WithParamInterface<bool> {
+};
+
+TEST_P(WebRtcSdpExtmapTest,
+    DeserializeSessionDescriptionWithSessionLevelExtmap) {
+  bool encrypted = GetParam();
+  TestDeserializeExtmap(true, false, encrypted);
 }
 
-TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithMediaLevelExtmap) {
-  TestDeserializeExtmap(false, true);
+TEST_P(WebRtcSdpExtmapTest,
+    DeserializeSessionDescriptionWithMediaLevelExtmap) {
+  bool encrypted = GetParam();
+  TestDeserializeExtmap(false, true, encrypted);
 }
 
-TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithInvalidExtmap) {
-  TestDeserializeExtmap(true, true);
+TEST_P(WebRtcSdpExtmapTest,
+    DeserializeSessionDescriptionWithInvalidExtmap) {
+  bool encrypted = GetParam();
+  TestDeserializeExtmap(true, true, encrypted);
 }
 
+INSTANTIATE_TEST_CASE_P(Encrypted,
+                        WebRtcSdpExtmapTest,
+                        ::testing::Values(false, true));
+
 TEST_F(WebRtcSdpTest, DeserializeSessionDescriptionWithoutEndLineBreak) {
   JsepSessionDescription jdesc(kDummyString);
   std::string sdp = kSdpFullString;
   sdp = sdp.substr(0, sdp.size() - 2);  // Remove \r\n at the end.
   // Deserialize
   SdpParseError error;
   EXPECT_FALSE(webrtc::SdpDeserialize(sdp, &jdesc, &error));
   const std::string lastline = "a=ssrc:3 label:video_track_id_1";
   EXPECT_EQ(lastline, error.line);
   EXPECT_EQ("Invalid SDP line.", error.description);
@@ skipping 683 matching lines @@
       "s=-\r\n"
       "t=0 0\r\n"
       "m=audio 9 RTP/SAVPF 111\r\n"
       "c=IN IP4 0.0.0.0\r\n"
       "a=rtpmap:111 opus/48000/2\r\n"
       "a=msid: track_id\r\n";
 
   JsepSessionDescription jdesc_output(kDummyString);
   EXPECT_FALSE(SdpDeserialize(kSdpWithMissingStreamId, &jdesc_output));
 }