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

webrtc/pc/mediasession.cc

 /*
  *  Copyright 2004 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 17 matching lines @@
 #include "webrtc/common_video/h264/profile_level_id.h"
 #include "webrtc/media/base/cryptoparams.h"
 #include "webrtc/media/base/mediaconstants.h"
 #include "webrtc/p2p/base/p2pconstants.h"
 #include "webrtc/pc/channelmanager.h"
 #include "webrtc/pc/srtpfilter.h"
 
 namespace {
 const char kInline[] = "inline:";
 
-void GetSupportedCryptoSuiteNames(void (*func)(const rtc::CryptoOptions&,
-                                      std::vector<int>*),
-                                  const rtc::CryptoOptions& crypto_options,
-                                  std::vector<std::string>* names) {
+void GetSupportedSdesCryptoSuiteNames(void (*func)(const rtc::CryptoOptions&,
+                                                   std::vector<int>*),
+                                      const rtc::CryptoOptions& crypto_options,
+                                      std::vector<std::string>* names) {
   std::vector<int> crypto_suites;
   func(crypto_options, &crypto_suites);
   for (const auto crypto : crypto_suites) {
     names->push_back(rtc::SrtpCryptoSuiteToName(crypto));
   }
 }
 }  // namespace
 
 namespace cricket {
 
@@ skipping 120 matching lines @@
        it != cryptos.end(); ++it) {
     if (crypto.Matches(*it)) {
       *out = *it;
       return true;
     }
   }
   return false;
 }
 
 // For audio, HMAC 32 is prefered over HMAC 80 because of the low overhead.
-void GetSupportedAudioCryptoSuites(const rtc::CryptoOptions& crypto_options,
-    std::vector<int>* crypto_suites) {
+void GetSupportedAudioSdesCryptoSuites(const rtc::CryptoOptions& crypto_options,
+                                       std::vector<int>* crypto_suites) {
   if (crypto_options.enable_gcm_crypto_suites) {
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_256_GCM);
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_128_GCM);
   }
   crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_32);
   crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
 }
 
-void GetSupportedAudioCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
+void GetSupportedAudioSdesCryptoSuiteNames(
+    const rtc::CryptoOptions& crypto_options,
     std::vector<std::string>* crypto_suite_names) {
-  GetSupportedCryptoSuiteNames(GetSupportedAudioCryptoSuites,
-                               crypto_options, crypto_suite_names);
+  GetSupportedSdesCryptoSuiteNames(GetSupportedAudioSdesCryptoSuites,
+                                   crypto_options, crypto_suite_names);
 }
 
-void GetSupportedVideoCryptoSuites(const rtc::CryptoOptions& crypto_options,
-    std::vector<int>* crypto_suites) {
-  GetDefaultSrtpCryptoSuites(crypto_options, crypto_suites);
-}
-
-void GetSupportedVideoCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
-    std::vector<std::string>* crypto_suite_names) {
-  GetSupportedCryptoSuiteNames(GetSupportedVideoCryptoSuites,
-                               crypto_options, crypto_suite_names);
-}
-
-void GetSupportedDataCryptoSuites(const rtc::CryptoOptions& crypto_options,
-    std::vector<int>* crypto_suites) {
-  GetDefaultSrtpCryptoSuites(crypto_options, crypto_suites);
-}
-
-void GetSupportedDataCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
-    std::vector<std::string>* crypto_suite_names) {
-  GetSupportedCryptoSuiteNames(GetSupportedDataCryptoSuites,
-                               crypto_options, crypto_suite_names);
-}
-
-void GetDefaultSrtpCryptoSuites(const rtc::CryptoOptions& crypto_options,
-    std::vector<int>* crypto_suites) {
+void GetSupportedVideoSdesCryptoSuites(const rtc::CryptoOptions& crypto_options,
+                                       std::vector<int>* crypto_suites) {
   if (crypto_options.enable_gcm_crypto_suites) {
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_256_GCM);
     crypto_suites->push_back(rtc::SRTP_AEAD_AES_128_GCM);
+  }
+  crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
+}
+
+void GetSupportedVideoSdesCryptoSuiteNames(
+    const rtc::CryptoOptions& crypto_options,
+    std::vector<std::string>* crypto_suite_names) {
+  GetSupportedSdesCryptoSuiteNames(GetSupportedVideoSdesCryptoSuites,
+                                   crypto_options, crypto_suite_names);
+}
+
+void GetSupportedDataSdesCryptoSuites(const rtc::CryptoOptions& crypto_options,
+                                      std::vector<int>* crypto_suites) {
+  if (crypto_options.enable_gcm_crypto_suites) {
+    crypto_suites->push_back(rtc::SRTP_AEAD_AES_256_GCM);
+    crypto_suites->push_back(rtc::SRTP_AEAD_AES_128_GCM);
   }
   crypto_suites->push_back(rtc::SRTP_AES128_CM_SHA1_80);
 }
 
-void GetDefaultSrtpCryptoSuiteNames(const rtc::CryptoOptions& crypto_options,
+void GetSupportedDataSdesCryptoSuiteNames(
+    const rtc::CryptoOptions& crypto_options,
     std::vector<std::string>* crypto_suite_names) {
-  GetSupportedCryptoSuiteNames(GetDefaultSrtpCryptoSuites,
-                               crypto_options, crypto_suite_names);
+  GetSupportedSdesCryptoSuiteNames(GetSupportedDataSdesCryptoSuites,
+                                   crypto_options, crypto_suite_names);
 }
 
 // Support any GCM cipher (if enabled through options). For video support only
 // 80-bit SHA1 HMAC. For audio 32-bit HMAC is tolerated unless bundle is enabled
 // because it is low overhead.
 // Pick the crypto in the list that is supported.
 static bool SelectCrypto(const MediaContentDescription* offer,
                          bool bundle,
                          const rtc::CryptoOptions& crypto_options,
                          CryptoParams *crypto) {
@@ skipping 1428 matching lines @@
       GetFirstAudioContent(current_description);
   std::string content_name =
       current_audio_content ? current_audio_content->name : CN_AUDIO;
 
   cricket::SecurePolicy sdes_policy =
       IsDtlsActive(content_name, current_description) ? cricket::SEC_DISABLED
                                                       : secure();
 
   std::unique_ptr<AudioContentDescription> audio(new AudioContentDescription());
   std::vector<std::string> crypto_suites;
-  GetSupportedAudioCryptoSuiteNames(options.crypto_options, &crypto_suites);
+  GetSupportedAudioSdesCryptoSuiteNames(options.crypto_options, &crypto_suites);
   if (!CreateMediaContentOffer(
           options,
           audio_codecs,
           sdes_policy,
           GetCryptos(GetFirstAudioContentDescription(current_description)),
           crypto_suites,
           audio_rtp_extensions,
           add_legacy_,
           current_streams,
           audio.get())) {
@@ skipping 29 matching lines @@
       GetFirstVideoContent(current_description);
   std::string content_name =
       current_video_content ? current_video_content->name : CN_VIDEO;
 
   cricket::SecurePolicy sdes_policy =
       IsDtlsActive(content_name, current_description) ? cricket::SEC_DISABLED
                                                       : secure();
 
   std::unique_ptr<VideoContentDescription> video(new VideoContentDescription());
   std::vector<std::string> crypto_suites;
-  GetSupportedVideoCryptoSuiteNames(options.crypto_options, &crypto_suites);
+  GetSupportedVideoSdesCryptoSuiteNames(options.crypto_options, &crypto_suites);
   if (!CreateMediaContentOffer(
           options,
           video_codecs,
           sdes_policy,
           GetCryptos(GetFirstVideoContentDescription(current_description)),
           crypto_suites,
           video_rtp_extensions,
           add_legacy_,
           current_streams,
           video.get())) {
@@ skipping 55 matching lines @@
     // SDES doesn't make sense for SCTP, so we disable it, and we only
     // get SDES crypto suites for RTP-based data channels.
     sdes_policy = cricket::SEC_DISABLED;
     // Unlike SetMediaProtocol below, we need to set the protocol
     // before we call CreateMediaContentOffer.  Otherwise,
     // CreateMediaContentOffer won't know this is SCTP and will
     // generate SSRCs rather than SIDs.
     data->set_protocol(
         secure_transport ? kMediaProtocolDtlsSctp : kMediaProtocolSctp);
   } else {
-    GetSupportedDataCryptoSuiteNames(options.crypto_options, &crypto_suites);
+    GetSupportedDataSdesCryptoSuiteNames(options.crypto_options,
+                                         &crypto_suites);
   }
 
   if (!CreateMediaContentOffer(
           options,
           *data_codecs,
           sdes_policy,
           GetCryptos(GetFirstDataContentDescription(current_description)),
           crypto_suites,
           RtpHeaderExtensions(),
           add_legacy_,
@@ skipping 368 matching lines @@
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_VIDEO));
 }
 
 DataContentDescription* GetFirstDataContentDescription(
     SessionDescription* sdesc) {
   return static_cast<DataContentDescription*>(
       GetFirstMediaContentDescription(sdesc, MEDIA_TYPE_DATA));
 }
 
 }  // namespace cricket