Add support for GCM cipher suites from RFC 7714.

webrtc/api/webrtcsession_unittest.cc

 /*
  *  Copyright 2012 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 441 matching lines @@
     // Add kTelephoneEventCodec for dtmf test.
     const cricket::AudioCodec kTelephoneEventCodec(106, "telephone-event", 8000,
                                                    0, 1);
     std::vector<cricket::AudioCodec> codecs;
     codecs.push_back(kTelephoneEventCodec);
     media_engine_->SetAudioCodecs(codecs);
     desc_factory_->set_audio_codecs(codecs);
     Init();
   }
 
+  void InitWithGcm() {
+    rtc::CryptoOptions crypto_options;
+    crypto_options.enable_gcm_crypto_suites = true;
+    channel_manager_->SetCryptoOptions(crypto_options);
+    with_gcm_ = true;
+    Init();
+  }
+
   void SendAudioVideoStream1() {
     send_stream_1_ = true;
     send_stream_2_ = false;
     send_audio_ = true;
     send_video_ = true;
   }
 
   void SendAudioVideoStream2() {
     send_stream_1_ = false;
     send_stream_2_ = true;
@@ skipping 70 matching lines @@
           session_options->HasSendMediaStream(cricket::MEDIA_TYPE_VIDEO);
     }
     session_options->bundle_enabled =
         session_options->bundle_enabled &&
         (session_options->has_audio() || session_options->has_video() ||
          session_options->has_data());
 
     if (session_->data_channel_type() == cricket::DCT_SCTP && data_channel_) {
       session_options->data_channel_type = cricket::DCT_SCTP;
     }
+
+    if (with_gcm_) {
+      session_options->crypto_options.enable_gcm_crypto_suites = true;
+    }
   }
 
   void GetOptionsForAnswer(cricket::MediaSessionOptions* session_options) {
     // ParseConstraintsForAnswer is used to set some defaults.
     ASSERT_TRUE(webrtc::ParseConstraintsForAnswer(nullptr, session_options));
 
     AddStreamsToOptions(session_options);
     session_options->bundle_enabled =
         session_options->bundle_enabled &&
         (session_options->has_audio() || session_options->has_video() ||
          session_options->has_data());
 
     if (session_->data_channel_type() == cricket::DCT_SCTP) {
       session_options->data_channel_type = cricket::DCT_SCTP;
     }
+
+    if (with_gcm_) {
+      session_options->crypto_options.enable_gcm_crypto_suites = true;
+    }
   }
 
   // Creates a local offer and applies it. Starts ICE.
   // Call SendAudioVideoStreamX() before this function
   // to decide which streams to create.
   void InitiateCall() {
     SessionDescriptionInterface* offer = CreateOffer();
     SetLocalDescriptionWithoutError(offer);
     EXPECT_TRUE_WAIT(PeerConnectionInterface::kIceGatheringNew !=
         observer_.ice_gathering_state_,
@@ skipping 42 matching lines @@
     options.recv_video = true;
     options.recv_audio = true;
     return CreateAnswer(options);
   }
 
   bool ChannelsExist() const {
     return (session_->voice_channel() != NULL &&
             session_->video_channel() != NULL);
   }
 
-  void VerifyCryptoParams(const cricket::SessionDescription* sdp) {
+  void VerifyCryptoParams(const cricket::SessionDescription* sdp,
+      bool gcm_enabled = false) {
     ASSERT_TRUE(session_.get() != NULL);
     const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
     ASSERT_TRUE(content != NULL);
     const cricket::AudioContentDescription* audio_content =
         static_cast<const cricket::AudioContentDescription*>(
             content->description);
     ASSERT_TRUE(audio_content != NULL);
-    ASSERT_EQ(1U, audio_content->cryptos().size());
-    ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
-    ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
-              audio_content->cryptos()[0].cipher_suite);
-    EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
-              audio_content->protocol());
+    if (!gcm_enabled) {
+      ASSERT_EQ(1U, audio_content->cryptos().size());
+      ASSERT_EQ(47U, audio_content->cryptos()[0].key_params.size());
+      ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
+                audio_content->cryptos()[0].cipher_suite);
+      EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
+                audio_content->protocol());
+    } else {
+      // The offer contains 3 possible crypto suites, the answer 1.
+      EXPECT_LE(1U, audio_content->cryptos().size());
+      EXPECT_NE(2U, audio_content->cryptos().size());
+      EXPECT_GE(3U, audio_content->cryptos().size());
+      ASSERT_EQ(67U, audio_content->cryptos()[0].key_params.size());
+      ASSERT_EQ("AEAD_AES_256_GCM",
+                audio_content->cryptos()[0].cipher_suite);
+      EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
+                audio_content->protocol());
+    }
 
     content = cricket::GetFirstVideoContent(sdp);
     ASSERT_TRUE(content != NULL);
     const cricket::VideoContentDescription* video_content =
         static_cast<const cricket::VideoContentDescription*>(
             content->description);
     ASSERT_TRUE(video_content != NULL);
-    ASSERT_EQ(1U, video_content->cryptos().size());
-    ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
-              video_content->cryptos()[0].cipher_suite);
-    ASSERT_EQ(47U, video_content->cryptos()[0].key_params.size());
-    EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
-              video_content->protocol());
+    if (!gcm_enabled) {
+      ASSERT_EQ(1U, video_content->cryptos().size());
+      ASSERT_EQ("AES_CM_128_HMAC_SHA1_80",
+                video_content->cryptos()[0].cipher_suite);
+      ASSERT_EQ(47U, video_content->cryptos()[0].key_params.size());
+      EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
+                video_content->protocol());
+    } else {
+      // The offer contains 3 possible crypto suites, the answer 1.
+      EXPECT_LE(1U, video_content->cryptos().size());
+      EXPECT_NE(2U, video_content->cryptos().size());
+      EXPECT_GE(3U, video_content->cryptos().size());
+      ASSERT_EQ("AEAD_AES_256_GCM",
+                video_content->cryptos()[0].cipher_suite);
+      ASSERT_EQ(67U, video_content->cryptos()[0].key_params.size());
+      EXPECT_EQ(std::string(cricket::kMediaProtocolSavpf),
+                video_content->protocol());
+    }
   }
 
   void VerifyNoCryptoParams(const cricket::SessionDescription* sdp, bool dtls) {
     const cricket::ContentInfo* content = cricket::GetFirstAudioContent(sdp);
     ASSERT_TRUE(content != NULL);
     const cricket::AudioContentDescription* audio_content =
         static_cast<const cricket::AudioContentDescription*>(
             content->description);
     ASSERT_TRUE(audio_content != NULL);
     ASSERT_EQ(0U, audio_content->cryptos().size());
@@ skipping 775 matching lines @@
   // The following flags affect options created for CreateOffer/CreateAnswer.
   bool send_stream_1_ = false;
   bool send_stream_2_ = false;
   bool send_audio_ = false;
   bool send_video_ = false;
   rtc::scoped_refptr<DataChannel> data_channel_;
   // Last values received from data channel creation signal.
   std::string last_data_channel_label_;
   InternalDataChannelInit last_data_channel_config_;
   bool session_destroyed_ = false;
+  bool with_gcm_ = false;
 };
 
 TEST_P(WebRtcSessionTest, TestInitializeWithDtls) {
   InitWithDtls(GetParam());
   // SDES is disabled when DTLS is on.
   EXPECT_EQ(cricket::SEC_DISABLED, session_->SdesPolicy());
 }
 
 TEST_F(WebRtcSessionTest, TestInitializeWithoutDtls) {
   Init();
@@ skipping 1322 matching lines @@
 TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDP) {
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
   VerifyCryptoParams(offer->description());
   SetRemoteDescriptionWithoutError(offer.release());
   std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
   VerifyCryptoParams(answer->description());
 }
 
+TEST_F(WebRtcSessionTest, VerifyCryptoParamsInSDPGcm) {
+  InitWithGcm();
+  SendAudioVideoStream1();
+  std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
+  VerifyCryptoParams(offer->description(), true);
+  SetRemoteDescriptionWithoutError(offer.release());
+  std::unique_ptr<SessionDescriptionInterface> answer(CreateAnswer());
+  VerifyCryptoParams(answer->description(), true);
+}
+
 TEST_F(WebRtcSessionTest, VerifyNoCryptoParamsInSDP) {
   options_.disable_encryption = true;
   Init();
   SendAudioVideoStream1();
   std::unique_ptr<SessionDescriptionInterface> offer(CreateOffer());
   VerifyNoCryptoParams(offer->description(), false);
 }
 
 TEST_F(WebRtcSessionTest, VerifyAnswerFromNonCryptoOffer) {
   Init();
@@ skipping 551 matching lines @@
   EXPECT_TRUE((local_offer)->Initialize(offer_str, NULL));
   SetLocalDescriptionOfferExpectError(kBundleWithoutRtcpMux, local_offer);
   JsepSessionDescription* remote_offer =
       new JsepSessionDescription(JsepSessionDescription::kOffer);
   EXPECT_TRUE((remote_offer)->Initialize(offer_str, NULL));
   SetRemoteDescriptionOfferExpectError(kBundleWithoutRtcpMux, remote_offer);
   // Trying unmodified SDP.
   SetLocalDescriptionWithoutError(offer);
 }
 
+TEST_F(WebRtcSessionTest, SetSetupGcm) {
+  InitWithGcm();
+  SendAudioVideoStream1();
+  CreateAndSetRemoteOfferAndLocalAnswer();
+}
+
 TEST_F(WebRtcSessionTest, SetAudioPlayout) {
   Init();
   SendAudioVideoStream1();
   CreateAndSetRemoteOfferAndLocalAnswer();
   cricket::FakeVoiceMediaChannel* channel = media_engine_->GetVoiceChannel(0);
   ASSERT_TRUE(channel != NULL);
   ASSERT_EQ(1u, channel->recv_streams().size());
   uint32_t receive_ssrc = channel->recv_streams()[0].first_ssrc();
   double volume;
   EXPECT_TRUE(channel->GetOutputVolume(receive_ssrc, &volume));
@@ skipping 1022 matching lines @@
 }
 
 // TODO(bemasc): Add a TestIceStatesBundle with BUNDLE enabled.  That test
 // currently fails because upon disconnection and reconnection OnIceComplete is
 // called more than once without returning to IceGatheringGathering.
 
 INSTANTIATE_TEST_CASE_P(WebRtcSessionTests,
                         WebRtcSessionTest,
                         testing::Values(ALREADY_GENERATED,
                                         DTLS_IDENTITY_STORE));