Negotiate the same SRTP crypto suites for every DTLS association formed.

webrtc/pc/channel_unittest.cc

 /*
  *  Copyright 2009 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 79 matching lines @@
 // Base class for Voice/Video/RtpDataChannel tests
 template<class T>
 class ChannelTest : public testing::Test, public sigslot::has_slots<> {
  public:
   enum Flags {
     RTCP_MUX = 0x1,
     RTCP_MUX_REQUIRED = 0x2,
     SECURE = 0x4,
     SSRC_MUX = 0x8,
     DTLS = 0x10,
-    GCM_CIPHER = 0x20,
     // Use BaseChannel with PacketTransportInternal rather than
     // DtlsTransportInternal.
-    RAW_PACKET_TRANSPORT = 0x40,
+    RAW_PACKET_TRANSPORT = 0x20,
   };
 
   ChannelTest(bool verify_playout,
               rtc::ArrayView<const uint8_t> rtp_data,
               rtc::ArrayView<const uint8_t> rtcp_data,
               NetworkIsWorker network_is_worker)
       : verify_playout_(verify_playout),
         rtp_packet_(rtp_data.data(), rtp_data.size()),
         rtcp_packet_(rtcp_data.data(), rtcp_data.size()) {
     if (network_is_worker == NetworkIsWorker::Yes) {
@@ skipping 142 matching lines @@
       cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
       cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
       rtc::PacketTransportInternal* fake_rtp_packet_transport,
       rtc::PacketTransportInternal* fake_rtcp_packet_transport,
       int flags) {
     rtc::Thread* signaling_thread = rtc::Thread::Current();
     typename T::Channel* channel = new typename T::Channel(
         worker_thread, network_thread, signaling_thread, engine, ch,
         cricket::CN_AUDIO, (flags & RTCP_MUX_REQUIRED) != 0,
         (flags & SECURE) != 0);
-    rtc::CryptoOptions crypto_options;
-    crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
-    channel->SetCryptoOptions(crypto_options);
     if (!channel->NeedsRtcpTransport()) {
       fake_rtcp_dtls_transport = nullptr;
     }
     if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
                          fake_rtp_packet_transport,
                          fake_rtcp_packet_transport)) {
       delete channel;
       channel = NULL;
     }
     return channel;
@@ skipping 183 matching lines @@
   }
   bool CheckNoRtp2() {
     return media_channel2_->CheckNoRtp();
   }
   bool CheckNoRtcp1() {
     return media_channel1_->CheckNoRtcp();
   }
   bool CheckNoRtcp2() {
     return media_channel2_->CheckNoRtcp();
   }
-  // Checks that the channel is using GCM iff GCM_CIPHER is set in flags.
-  // Returns true if so.
-  bool CheckGcmCipher(typename T::Channel* channel, int flags) {
-    int suite;
-    cricket::FakeDtlsTransport* transport =
-        (channel == channel1_.get()) ? fake_rtp_dtls_transport1_.get()
-                                     : fake_rtp_dtls_transport2_.get();
-    RTC_DCHECK(transport);
-    if (!transport->GetSrtpCryptoSuite(&suite)) {
-      return false;
-    }
-
-    if (flags & GCM_CIPHER) {
-      return rtc::IsGcmCryptoSuite(suite);
-    } else {
-      return (suite != rtc::SRTP_INVALID_CRYPTO_SUITE &&
-          !rtc::IsGcmCryptoSuite(suite));
-    }
-  }
 
   void CreateContent(int flags,
                      const cricket::AudioCodec& audio_codec,
                      const cricket::VideoCodec& video_codec,
                      typename T::Content* content) {
     // overridden in specialized classes
   }
   void CopyContent(const typename T::Content& source,
                    typename T::Content* content) {
     // overridden in specialized classes
@@ skipping 831 matching lines @@
     EXPECT_FALSE(channel1_->NeedsRtcpTransport());
     EXPECT_EQ(1, rtcp_mux_activated_callbacks1_);
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtcp2());
     EXPECT_TRUE(CheckRtcp1());
   }
 
   // Test that we properly send SRTP with RTCP in both directions.
-  // You can pass in DTLS, RTCP_MUX, GCM_CIPHER and RAW_PACKET_TRANSPORT as
-  // flags.
+  // You can pass in DTLS, RTCP_MUX, and RAW_PACKET_TRANSPORT as flags.
   void SendSrtpToSrtp(int flags1_in = 0, int flags2_in = 0) {
-    RTC_CHECK((flags1_in &
-               ~(RTCP_MUX | DTLS | GCM_CIPHER | RAW_PACKET_TRANSPORT)) == 0);
-    RTC_CHECK((flags2_in &
-               ~(RTCP_MUX | DTLS | GCM_CIPHER | RAW_PACKET_TRANSPORT)) == 0);
+    RTC_CHECK((flags1_in & ~(RTCP_MUX | DTLS | RAW_PACKET_TRANSPORT)) == 0);
+    RTC_CHECK((flags2_in & ~(RTCP_MUX | DTLS | RAW_PACKET_TRANSPORT)) == 0);
 
     int flags1 = SECURE | flags1_in;
     int flags2 = SECURE | flags2_in;
     bool dtls1 = !!(flags1_in & DTLS);
     bool dtls2 = !!(flags2_in & DTLS);
     CreateChannels(flags1, flags2);
     EXPECT_FALSE(channel1_->secure());
     EXPECT_FALSE(channel2_->secure());
     EXPECT_TRUE(SendInitiate());
     WaitForThreads();
     EXPECT_TRUE(channel1_->writable());
     EXPECT_TRUE(channel2_->writable());
     EXPECT_TRUE(SendAccept());
     EXPECT_TRUE(channel1_->secure());
     EXPECT_TRUE(channel2_->secure());
     EXPECT_EQ(dtls1 && dtls2, channel1_->secure_dtls());
     EXPECT_EQ(dtls1 && dtls2, channel2_->secure_dtls());
-    // We can only query the negotiated cipher suite for DTLS-SRTP transport
-    // channels.
-    if (dtls1 && dtls2) {
-      // A GCM cipher is only used if both channels support GCM ciphers.
-      int common_gcm_flags = flags1 & flags2 & GCM_CIPHER;
-      EXPECT_TRUE(CheckGcmCipher(channel1_.get(), common_gcm_flags));
-      EXPECT_TRUE(CheckGcmCipher(channel2_.get(), common_gcm_flags));
-    }
     SendRtp1();
     SendRtp2();
     SendRtcp1();
     SendRtcp2();
     WaitForThreads();
     EXPECT_TRUE(CheckRtp1());
     EXPECT_TRUE(CheckRtp2());
     EXPECT_TRUE(CheckNoRtp1());
     EXPECT_TRUE(CheckNoRtp2());
     EXPECT_TRUE(CheckRtcp1());
@@ skipping 733 matching lines @@
     cricket::FakeVideoMediaChannel* ch,
     cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
     cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
     rtc::PacketTransportInternal* fake_rtp_packet_transport,
     rtc::PacketTransportInternal* fake_rtcp_packet_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
   cricket::VideoChannel* channel = new cricket::VideoChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_VIDEO,
       (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
-  rtc::CryptoOptions crypto_options;
-  crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
-  channel->SetCryptoOptions(crypto_options);
   if (!channel->NeedsRtcpTransport()) {
     fake_rtcp_dtls_transport = nullptr;
   }
   if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
                        fake_rtp_packet_transport, fake_rtcp_packet_transport)) {
     delete channel;
     channel = NULL;
   }
   return channel;
 }
@@ skipping 202 matching lines @@
 }
 
 TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToSrtp) {
   Base::SendSrtpToSrtp(DTLS, 0);
 }
 
 TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtp) {
   Base::SendSrtpToSrtp(DTLS, DTLS);
 }
 
-TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpGcmBoth) {
-  Base::SendSrtpToSrtp(DTLS | GCM_CIPHER, DTLS | GCM_CIPHER);
-}
-
-TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpGcmOne) {
-  Base::SendSrtpToSrtp(DTLS | GCM_CIPHER, DTLS);
-}
-
-TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpGcmTwo) {
-  Base::SendSrtpToSrtp(DTLS, DTLS | GCM_CIPHER);
-}
-
 TEST_F(VoiceChannelSingleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
   Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
 }
 
 // Test using the channel with a raw packet interface, as opposed to a DTLS
 // transport interface.
 TEST_F(VoiceChannelSingleThreadTest, SendSrtpToSrtpWithRawPacketTransport) {
   Base::SendSrtpToSrtp(RAW_PACKET_TRANSPORT, RAW_PACKET_TRANSPORT);
 }
 
@@ skipping 301 matching lines @@
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToSrtp) {
   Base::SendSrtpToSrtp(DTLS, 0);
 }
 
 TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtp) {
   Base::SendSrtpToSrtp(DTLS, DTLS);
 }
 
-TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpGcmBoth) {
-  Base::SendSrtpToSrtp(DTLS | GCM_CIPHER, DTLS | GCM_CIPHER);
-}
-
-TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpGcmOne) {
-  Base::SendSrtpToSrtp(DTLS | GCM_CIPHER, DTLS);
-}
-
-TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpGcmTwo) {
-  Base::SendSrtpToSrtp(DTLS, DTLS | GCM_CIPHER);
-}
-
 TEST_F(VoiceChannelDoubleThreadTest, SendDtlsSrtpToDtlsSrtpRtcpMux) {
   Base::SendSrtpToSrtp(DTLS | RTCP_MUX, DTLS | RTCP_MUX);
 }
 
 // Test using the channel with a raw packet interface, as opposed to a DTLS
 // transport interface.
 TEST_F(VoiceChannelDoubleThreadTest, SendSrtpToSrtpWithRawPacketTransport) {
   Base::SendSrtpToSrtp(RAW_PACKET_TRANSPORT, RAW_PACKET_TRANSPORT);
 }
 
@@ skipping 654 matching lines @@
     cricket::FakeDataMediaChannel* ch,
     cricket::DtlsTransportInternal* fake_rtp_dtls_transport,
     cricket::DtlsTransportInternal* fake_rtcp_dtls_transport,
     rtc::PacketTransportInternal* fake_rtp_packet_transport,
     rtc::PacketTransportInternal* fake_rtcp_packet_transport,
     int flags) {
   rtc::Thread* signaling_thread = rtc::Thread::Current();
   cricket::RtpDataChannel* channel = new cricket::RtpDataChannel(
       worker_thread, network_thread, signaling_thread, ch, cricket::CN_DATA,
       (flags & RTCP_MUX_REQUIRED) != 0, (flags & SECURE) != 0);
-  rtc::CryptoOptions crypto_options;
-  crypto_options.enable_gcm_crypto_suites = (flags & GCM_CIPHER) != 0;
-  channel->SetCryptoOptions(crypto_options);
   if (!channel->NeedsRtcpTransport()) {
     fake_rtcp_dtls_transport = nullptr;
   }
   if (!channel->Init_w(fake_rtp_dtls_transport, fake_rtcp_dtls_transport,
                        fake_rtp_packet_transport, fake_rtcp_packet_transport)) {
     delete channel;
     channel = NULL;
   }
   return channel;
 }
@@ skipping 401 matching lines @@
   ASSERT_TRUE(voice_channel_.Init_w(nullptr, nullptr, &fake_rtp_dtls_transport_,
                                     &fake_rtcp_dtls_transport_));
   EXPECT_DEATH(voice_channel_.SetTransports(&fake_rtp_dtls_transport_,
                                             &fake_rtp_dtls_transport_),
                "");
 }
 
 #endif  // RTC_DCHECK_IS_ON && GTEST_HAS_DEATH_TEST && !defined(WEBRTC_ANDROID)
 
 // TODO(pthatcher): TestSetReceiver?