Create the SrtpTransportInterface.

webrtc/ortc/ortcfactory_integrationtest.cc

 /*
  *  Copyright 2017 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.
  */
 
 #include <memory>
 #include <utility>  // For std::pair, std::move.
 
 #include "webrtc/api/ortc/ortcfactoryinterface.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/fakenetwork.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/physicalsocketserver.h"
 #include "webrtc/base/virtualsocketserver.h"
 #include "webrtc/ortc/testrtpparameters.h"
 #include "webrtc/p2p/base/udptransport.h"
 #include "webrtc/pc/test/fakeaudiocapturemodule.h"
 #include "webrtc/pc/test/fakeperiodicvideocapturer.h"
 #include "webrtc/pc/test/fakevideotrackrenderer.h"
 
 namespace {
 
-const int kDefaultTimeout = 10000;  // 10 seconds.
+const int kDefaultTimeout = 10000;    // 10 seconds.
+const int kReceivingDuration = 1000;  // 1 second.
 // Default number of audio/video frames to wait for before considering a test a
 // success.
 const int kDefaultNumFrames = 3;
 const rtc::IPAddress kIPv4LocalHostAddress =
     rtc::IPAddress(0x7F000001);  // 127.0.0.1
 
+static const char kTestKeyParams1[] =
+    "inline:WVNfX19zZW1jdGwgKskgewkyMjA7fQp9CnVubGVz";
+static const char kTestKeyParams2[] =
+    "inline:PS1uQCVeeCFCanVmcjkpaywjNWhcYD0mXXtxaVBR";
+static const char kTestKeyParams3[] =
+    "inline:WVNfX19zZW1jdGwgKskgewkyMjA7fQp9CnVubGVa";
+static const char kTestKeyParams4[] =
+    "inline:WVNfX19zZW1jdGwgKskgewkyMjA7fQp9CnVubGVb";
+static const cricket::CryptoParams kTestCryptoParams1(1,
+                                                      "AES_CM_128_HMAC_SHA1_80",
+                                                      kTestKeyParams1,
+                                                      "");
+static const cricket::CryptoParams kTestCryptoParams2(1,
+                                                      "AES_CM_128_HMAC_SHA1_80",
+                                                      kTestKeyParams2,
+                                                      "");
+static const cricket::CryptoParams kTestCryptoParams3(1,
+                                                      "AES_CM_128_HMAC_SHA1_80",
+                                                      kTestKeyParams3,
+                                                      "");
+static const cricket::CryptoParams kTestCryptoParams4(1,
+                                                      "AES_CM_128_HMAC_SHA1_80",
+                                                      kTestKeyParams4,
+                                                      "");
 }  // namespace
 
 namespace webrtc {
 
 // Used to test that things work end-to-end when using the default
 // implementations of threads/etc. provided by OrtcFactory, with the exception
 // of using a virtual network.
 //
 // By default, the virtual network manager doesn't enumerate any networks, but
 // sockets can still be created in this state.
@@ skipping 19 matching lines @@
                          .MoveValue();
   }
 
  protected:
   typedef std::pair<std::unique_ptr<UdpTransportInterface>,
                     std::unique_ptr<UdpTransportInterface>>
       UdpTransportPair;
   typedef std::pair<std::unique_ptr<RtpTransportInterface>,
                     std::unique_ptr<RtpTransportInterface>>
       RtpTransportPair;
+  typedef std::pair<std::unique_ptr<SrtpTransportInterface>,
+                    std::unique_ptr<SrtpTransportInterface>>
+      SrtpTransportPair;
   typedef std::pair<std::unique_ptr<RtpTransportControllerInterface>,
                     std::unique_ptr<RtpTransportControllerInterface>>
       RtpTransportControllerPair;
 
   // Helper function that creates one UDP transport each for |ortc_factory1_|
   // and |ortc_factory2_|, and connects them.
   UdpTransportPair CreateAndConnectUdpTransportPair() {
     auto transport1 = ortc_factory1_->CreateUdpTransport(AF_INET).MoveValue();
     auto transport2 = ortc_factory2_->CreateUdpTransport(AF_INET).MoveValue();
     transport1->SetRemoteAddress(
@@ skipping 24 matching lines @@
       const RtpTransportControllerPair& transport_controllers) {
     auto transport_result1 = ortc_factory1_->CreateRtpTransport(
         rtcp_parameters, rtp_udp_transports.first.get(),
         rtcp_udp_transports.first.get(), transport_controllers.first.get());
     auto transport_result2 = ortc_factory2_->CreateRtpTransport(
         rtcp_parameters, rtp_udp_transports.second.get(),
         rtcp_udp_transports.second.get(), transport_controllers.second.get());
     return {transport_result1.MoveValue(), transport_result2.MoveValue()};
   }
 
+  SrtpTransportPair CreateSrtpTransportPair(
+      const RtcpParameters& rtcp_parameters,
+      const UdpTransportPair& rtp_udp_transports,
+      const UdpTransportPair& rtcp_udp_transports,
+      const RtpTransportControllerPair& transport_controllers) {
+    auto transport_result1 = ortc_factory1_->CreateSrtpTransport(
+        rtcp_parameters, rtp_udp_transports.first.get(),
+        rtcp_udp_transports.first.get(), transport_controllers.first.get());
+    auto transport_result2 = ortc_factory2_->CreateSrtpTransport(
+        rtcp_parameters, rtp_udp_transports.second.get(),
+        rtcp_udp_transports.second.get(), transport_controllers.second.get());
+    return {transport_result1.MoveValue(), transport_result2.MoveValue()};
+  }
+
   // For convenience when |rtcp_udp_transports| and |transport_controllers|
   // aren't needed.
   RtpTransportPair CreateRtpTransportPair(
       const RtcpParameters& rtcp_parameters,
       const UdpTransportPair& rtp_udp_transports) {
     return CreateRtpTransportPair(rtcp_parameters, rtp_udp_transports,
                                   UdpTransportPair(),
                                   RtpTransportControllerPair());
   }
 
+  SrtpTransportPair CreateSrtpTransportPairAndSetKeys(
+      const RtcpParameters& rtcp_parameters,
+      const UdpTransportPair& rtp_udp_transports) {
+    SrtpTransportPair srtp_transports = CreateSrtpTransportPair(
+        rtcp_parameters, rtp_udp_transports, UdpTransportPair(),
+        RtpTransportControllerPair());
+    EXPECT_TRUE(srtp_transports.first->SetSrtpSendKey(kTestCryptoParams1).ok());
+    EXPECT_TRUE(
+        srtp_transports.first->SetSrtpReceiveKey(kTestCryptoParams2).ok());
+    EXPECT_TRUE(
+        srtp_transports.second->SetSrtpSendKey(kTestCryptoParams2).ok());
+    EXPECT_TRUE(
+        srtp_transports.second->SetSrtpReceiveKey(kTestCryptoParams1).ok());
+    return srtp_transports;
+  }
+
+  SrtpTransportPair CreateSrtpTransportPairAndSetMismatchingKeys(
+      const RtcpParameters& rtcp_parameters,
+      const UdpTransportPair& rtp_udp_transports) {
+    SrtpTransportPair srtp_transports = CreateSrtpTransportPair(
+        rtcp_parameters, rtp_udp_transports, UdpTransportPair(),
+        RtpTransportControllerPair());
+    EXPECT_TRUE(srtp_transports.first->SetSrtpSendKey(kTestCryptoParams1).ok());
+    EXPECT_TRUE(
+        srtp_transports.first->SetSrtpReceiveKey(kTestCryptoParams2).ok());
+    EXPECT_TRUE(
+        srtp_transports.second->SetSrtpSendKey(kTestCryptoParams1).ok());
+    EXPECT_TRUE(
+        srtp_transports.second->SetSrtpReceiveKey(kTestCryptoParams2).ok());
+    return srtp_transports;
+  }
+
   // Ends up using fake audio capture module, which was passed into OrtcFactory
   // on creation.
   rtc::scoped_refptr<webrtc::AudioTrackInterface> CreateLocalAudioTrack(
       const std::string& id,
       OrtcFactoryInterface* ortc_factory) {
     // Disable echo cancellation to make test more efficient.
     cricket::AudioOptions options;
     options.echo_cancellation.emplace(true);
     rtc::scoped_refptr<webrtc::AudioSourceInterface> source =
         ortc_factory->CreateAudioSource(options);
     return ortc_factory->CreateAudioTrack(id, source);
   }
 
   // Stores created capturer in |fake_video_capturers_|.
   rtc::scoped_refptr<webrtc::VideoTrackInterface>
   CreateLocalVideoTrackAndFakeCapturer(const std::string& id,
                                        OrtcFactoryInterface* ortc_factory) {
     cricket::FakeVideoCapturer* fake_capturer =
         new webrtc::FakePeriodicVideoCapturer();
     fake_video_capturers_.push_back(fake_capturer);
     rtc::scoped_refptr<webrtc::VideoTrackSourceInterface> source =
         ortc_factory->CreateVideoSource(
             std::unique_ptr<cricket::VideoCapturer>(fake_capturer));
     return rtc::scoped_refptr<webrtc::VideoTrackInterface>(
         ortc_factory->CreateVideoTrack(id, source));
   }
 
+  // Helper function used to test two way RTP senders and receivers with basic
+  // configurations.
+  // If |expect_success| is true, waits for kDefaultTimeout for
+  // kDefaultNumFrames frames to be received by all RtpReceivers.
+  // If |expect_success| is false, simply waits for |kReceivingDuration|, and
+  // stores the number of received frames in |received_audio_frame1_| etc.
+  void BasicTwoWayRtpSendersAndReceiversTest(RtpTransportPair srtp_transports,
+                                             bool expect_success) {
+    received_audio_frames1_ = 0;
+    received_audio_frames2_ = 0;
+    rendered_video_frames1_ = 0;
+    rendered_video_frames2_ = 0;
+    // Create all the senders and receivers (four per endpoint).
+    auto audio_sender_result1 = ortc_factory1_->CreateRtpSender(
+        cricket::MEDIA_TYPE_AUDIO, srtp_transports.first.get());
+    auto video_sender_result1 = ortc_factory1_->CreateRtpSender(
+        cricket::MEDIA_TYPE_VIDEO, srtp_transports.first.get());
+    auto audio_receiver_result1 = ortc_factory1_->CreateRtpReceiver(
+        cricket::MEDIA_TYPE_AUDIO, srtp_transports.first.get());
+    auto video_receiver_result1 = ortc_factory1_->CreateRtpReceiver(
+        cricket::MEDIA_TYPE_VIDEO, srtp_transports.first.get());
+    ASSERT_TRUE(audio_sender_result1.ok());
+    ASSERT_TRUE(video_sender_result1.ok());
+    ASSERT_TRUE(audio_receiver_result1.ok());
+    ASSERT_TRUE(video_receiver_result1.ok());
+    auto audio_sender1 = audio_sender_result1.MoveValue();
+    auto video_sender1 = video_sender_result1.MoveValue();
+    auto audio_receiver1 = audio_receiver_result1.MoveValue();
+    auto video_receiver1 = video_receiver_result1.MoveValue();
+
+    auto audio_sender_result2 = ortc_factory2_->CreateRtpSender(
+        cricket::MEDIA_TYPE_AUDIO, srtp_transports.second.get());
+    auto video_sender_result2 = ortc_factory2_->CreateRtpSender(
+        cricket::MEDIA_TYPE_VIDEO, srtp_transports.second.get());
+    auto audio_receiver_result2 = ortc_factory2_->CreateRtpReceiver(
+        cricket::MEDIA_TYPE_AUDIO, srtp_transports.second.get());
+    auto video_receiver_result2 = ortc_factory2_->CreateRtpReceiver(
+        cricket::MEDIA_TYPE_VIDEO, srtp_transports.second.get());
+    ASSERT_TRUE(audio_sender_result2.ok());
+    ASSERT_TRUE(video_sender_result2.ok());
+    ASSERT_TRUE(audio_receiver_result2.ok());
+    ASSERT_TRUE(video_receiver_result2.ok());
+    auto audio_sender2 = audio_sender_result2.MoveValue();
+    auto video_sender2 = video_sender_result2.MoveValue();
+    auto audio_receiver2 = audio_receiver_result2.MoveValue();
+    auto video_receiver2 = video_receiver_result2.MoveValue();
+
+    // Add fake tracks.
+    RTCError error = audio_sender1->SetTrack(
+        CreateLocalAudioTrack("audio", ortc_factory1_.get()));
+    EXPECT_TRUE(error.ok());
+    error = video_sender1->SetTrack(
+        CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory1_.get()));
+    EXPECT_TRUE(error.ok());
+    error = audio_sender2->SetTrack(
+        CreateLocalAudioTrack("audio", ortc_factory2_.get()));
+    EXPECT_TRUE(error.ok());
+    error = video_sender2->SetTrack(
+        CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory2_.get()));
+    EXPECT_TRUE(error.ok());
+
+    // "sent_X_parameters1" are the parameters that endpoint 1 sends with and
+    // endpoint 2 receives with.
+    RtpParameters sent_opus_parameters1 =
+        MakeMinimalOpusParametersWithSsrc(0xdeadbeef);
+    RtpParameters sent_vp8_parameters1 =
+        MakeMinimalVp8ParametersWithSsrc(0xbaadfeed);
+    RtpParameters sent_opus_parameters2 =
+        MakeMinimalOpusParametersWithSsrc(0x13333337);
+    RtpParameters sent_vp8_parameters2 =
+        MakeMinimalVp8ParametersWithSsrc(0x12345678);
+
+    // Configure the senders' and receivers' parameters.
+    EXPECT_TRUE(audio_receiver1->Receive(sent_opus_parameters2).ok());
+    EXPECT_TRUE(video_receiver1->Receive(sent_vp8_parameters2).ok());
+    EXPECT_TRUE(audio_receiver2->Receive(sent_opus_parameters1).ok());
+    EXPECT_TRUE(video_receiver2->Receive(sent_vp8_parameters1).ok());
+    EXPECT_TRUE(audio_sender1->Send(sent_opus_parameters1).ok());
+    EXPECT_TRUE(video_sender1->Send(sent_vp8_parameters1).ok());
+    EXPECT_TRUE(audio_sender2->Send(sent_opus_parameters2).ok());
+    EXPECT_TRUE(video_sender2->Send(sent_vp8_parameters2).ok());
+
+    FakeVideoTrackRenderer fake_video_renderer1(
+        static_cast<VideoTrackInterface*>(video_receiver1->GetTrack().get()));
+    FakeVideoTrackRenderer fake_video_renderer2(
+        static_cast<VideoTrackInterface*>(video_receiver2->GetTrack().get()));
+
+    if (expect_success) {
+      EXPECT_TRUE_WAIT(
+          fake_audio_capture_module1_->frames_received() > kDefaultNumFrames &&
+              fake_video_renderer1.num_rendered_frames() > kDefaultNumFrames &&
+              fake_audio_capture_module2_->frames_received() >
+                  kDefaultNumFrames &&
+              fake_video_renderer1.num_rendered_frames() > kDefaultNumFrames,
+          kDefaultTimeout);
+    } else {
+      WAIT(false, kReceivingDuration);
+      rendered_video_frames1_ = fake_video_renderer1.num_rendered_frames();
+      rendered_video_frames2_ = fake_video_renderer2.num_rendered_frames();
+      received_audio_frames1_ = fake_audio_capture_module1_->frames_received();
+      received_audio_frames2_ = fake_audio_capture_module2_->frames_received();
+    }
+  }
+
   rtc::PhysicalSocketServer physical_socket_server_;
   rtc::VirtualSocketServer virtual_socket_server_;
   rtc::Thread network_thread_;
   rtc::FakeNetworkManager fake_network_manager_;
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module1_;
   rtc::scoped_refptr<FakeAudioCaptureModule> fake_audio_capture_module2_;
   std::unique_ptr<OrtcFactoryInterface> ortc_factory1_;
   std::unique_ptr<OrtcFactoryInterface> ortc_factory2_;
   // Actually owned by video tracks.
   std::vector<cricket::FakeVideoCapturer*> fake_video_capturers_;
+  int received_audio_frames1_ = 0;
+  int received_audio_frames2_ = 0;
+  int rendered_video_frames1_ = 0;
+  int rendered_video_frames2_ = 0;
 };
 
 // Very basic end-to-end test with a single pair of audio RTP sender and
 // receiver.
 //
 // Uses muxed RTCP, and minimal parameters with a hard-coded config that's
 // known to work.
 TEST_F(OrtcFactoryIntegrationTest, BasicOneWayAudioRtpSenderAndReceiver) {
   auto udp_transports = CreateAndConnectUdpTransportPair();
   auto rtp_transports =
@@ skipping 103 matching lines @@
 // End-to-end test with two pairs of RTP senders and receivers, for audio and
 // video.
 //
 // Uses muxed RTCP, and minimal parameters with hard-coded configs that are
 // known to work.
 TEST_F(OrtcFactoryIntegrationTest,
        BasicTwoWayAudioVideoRtpSendersAndReceivers) {
   auto udp_transports = CreateAndConnectUdpTransportPair();
   auto rtp_transports =
       CreateRtpTransportPair(MakeRtcpMuxParameters(), udp_transports);
+  bool expect_success = true;
+  BasicTwoWayRtpSendersAndReceiversTest(std::move(rtp_transports),
+                                        expect_success);
+}
 
-  // Create all the senders and receivers (four per endpoint).
-  auto audio_sender_result1 = ortc_factory1_->CreateRtpSender(
-      cricket::MEDIA_TYPE_AUDIO, rtp_transports.first.get());
-  auto video_sender_result1 = ortc_factory1_->CreateRtpSender(
-      cricket::MEDIA_TYPE_VIDEO, rtp_transports.first.get());
-  auto audio_receiver_result1 = ortc_factory1_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_AUDIO, rtp_transports.first.get());
-  auto video_receiver_result1 = ortc_factory1_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_VIDEO, rtp_transports.first.get());
-  ASSERT_TRUE(audio_sender_result1.ok());
-  ASSERT_TRUE(video_sender_result1.ok());
-  ASSERT_TRUE(audio_receiver_result1.ok());
-  ASSERT_TRUE(video_receiver_result1.ok());
-  auto audio_sender1 = audio_sender_result1.MoveValue();
-  auto video_sender1 = video_sender_result1.MoveValue();
-  auto audio_receiver1 = audio_receiver_result1.MoveValue();
-  auto video_receiver1 = video_receiver_result1.MoveValue();
+TEST_F(OrtcFactoryIntegrationTest,
+       BasicTwoWayAudioVideoSrtpSendersAndReceivers) {
+  auto udp_transports = CreateAndConnectUdpTransportPair();
+  auto srtp_transports = CreateSrtpTransportPairAndSetKeys(
+      MakeRtcpMuxParameters(), udp_transports);
+  bool expect_success = true;
+  BasicTwoWayRtpSendersAndReceiversTest(std::move(srtp_transports),
+                                        expect_success);
+}
 
-  auto audio_sender_result2 = ortc_factory2_->CreateRtpSender(
-      cricket::MEDIA_TYPE_AUDIO, rtp_transports.second.get());
-  auto video_sender_result2 = ortc_factory2_->CreateRtpSender(
-      cricket::MEDIA_TYPE_VIDEO, rtp_transports.second.get());
-  auto audio_receiver_result2 = ortc_factory2_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_AUDIO, rtp_transports.second.get());
-  auto video_receiver_result2 = ortc_factory2_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_VIDEO, rtp_transports.second.get());
-  ASSERT_TRUE(audio_sender_result2.ok());
-  ASSERT_TRUE(video_sender_result2.ok());
-  ASSERT_TRUE(audio_receiver_result2.ok());
-  ASSERT_TRUE(video_receiver_result2.ok());
-  auto audio_sender2 = audio_sender_result2.MoveValue();
-  auto video_sender2 = video_sender_result2.MoveValue();
-  auto audio_receiver2 = audio_receiver_result2.MoveValue();
-  auto video_receiver2 = video_receiver_result2.MoveValue();
+// Tests that the packets cannot be decoded if the keys are mismatched.
+TEST_F(OrtcFactoryIntegrationTest, SrtpSendersAndReceiversWithMismatchingKeys) {
+  auto udp_transports = CreateAndConnectUdpTransportPair();
+  auto srtp_transports = CreateSrtpTransportPairAndSetMismatchingKeys(
+      MakeRtcpMuxParameters(), udp_transports);
+  bool expect_success = false;
+  BasicTwoWayRtpSendersAndReceiversTest(std::move(srtp_transports),
+                                        expect_success);
+  // No frames are expected to be decoded.
+  EXPECT_TRUE(received_audio_frames1_ == 0 && received_audio_frames2_ == 0 &&
+              rendered_video_frames1_ == 0 && rendered_video_frames2_ == 0);
+}
 
-  // Add fake tracks.
-  RTCError error = audio_sender1->SetTrack(
-      CreateLocalAudioTrack("audio", ortc_factory1_.get()));
-  EXPECT_TRUE(error.ok());
-  error = video_sender1->SetTrack(
-      CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory1_.get()));
-  EXPECT_TRUE(error.ok());
-  error = audio_sender2->SetTrack(
-      CreateLocalAudioTrack("audio", ortc_factory2_.get()));
-  EXPECT_TRUE(error.ok());
-  error = video_sender2->SetTrack(
-      CreateLocalVideoTrackAndFakeCapturer("video", ortc_factory2_.get()));
-  EXPECT_TRUE(error.ok());
+// Tests that the frames cannot be decoded if only one side uses SRTP.
+TEST_F(OrtcFactoryIntegrationTest, OneSideSrtpSenderAndReceiver) {
+  auto rtcp_parameters = MakeRtcpMuxParameters();
+  auto udp_transports = CreateAndConnectUdpTransportPair();
+  auto rtcp_udp_transports = UdpTransportPair();
+  auto transport_controllers = RtpTransportControllerPair();
+  auto transport_result1 = ortc_factory1_->CreateRtpTransport(
+      rtcp_parameters, udp_transports.first.get(),
+      rtcp_udp_transports.first.get(), transport_controllers.first.get());
+  auto transport_result2 = ortc_factory2_->CreateSrtpTransport(
+      rtcp_parameters, udp_transports.second.get(),
+      rtcp_udp_transports.second.get(), transport_controllers.second.get());
 
-  // "sent_X_parameters1" are the parameters that endpoint 1 sends with and
-  // endpoint 2 receives with.
-  RtpParameters sent_opus_parameters1 =
-      MakeMinimalOpusParametersWithSsrc(0xdeadbeef);
-  RtpParameters sent_vp8_parameters1 =
-      MakeMinimalVp8ParametersWithSsrc(0xbaadfeed);
-  RtpParameters sent_opus_parameters2 =
-      MakeMinimalOpusParametersWithSsrc(0x13333337);
-  RtpParameters sent_vp8_parameters2 =
-      MakeMinimalVp8ParametersWithSsrc(0x12345678);
+  auto rtp_transport = transport_result1.MoveValue();
+  auto srtp_transport = transport_result2.MoveValue();
+  EXPECT_TRUE(srtp_transport->SetSrtpSendKey(kTestCryptoParams1).ok());
+  EXPECT_TRUE(srtp_transport->SetSrtpReceiveKey(kTestCryptoParams2).ok());
+  bool expect_success = false;
+  BasicTwoWayRtpSendersAndReceiversTest(
+      {std::move(rtp_transport), std::move(srtp_transport)}, expect_success);
 
-  // Configure the senders' and receivers' parameters.
-  EXPECT_TRUE(audio_receiver1->Receive(sent_opus_parameters2).ok());
-  EXPECT_TRUE(video_receiver1->Receive(sent_vp8_parameters2).ok());
-  EXPECT_TRUE(audio_receiver2->Receive(sent_opus_parameters1).ok());
-  EXPECT_TRUE(video_receiver2->Receive(sent_vp8_parameters1).ok());
-  EXPECT_TRUE(audio_sender1->Send(sent_opus_parameters1).ok());
-  EXPECT_TRUE(video_sender1->Send(sent_vp8_parameters1).ok());
-  EXPECT_TRUE(audio_sender2->Send(sent_opus_parameters2).ok());
-  EXPECT_TRUE(video_sender2->Send(sent_vp8_parameters2).ok());
-
-  FakeVideoTrackRenderer fake_video_renderer1(
-      static_cast<VideoTrackInterface*>(video_receiver1->GetTrack().get()));
-  FakeVideoTrackRenderer fake_video_renderer2(
-      static_cast<VideoTrackInterface*>(video_receiver2->GetTrack().get()));
-
-  // Senders and receivers are connected and configured; audio and video frames
-  // should be able to flow at this point.
-  EXPECT_TRUE_WAIT(
-      fake_audio_capture_module1_->frames_received() > kDefaultNumFrames &&
-          fake_video_renderer1.num_rendered_frames() > kDefaultNumFrames &&
-          fake_audio_capture_module2_->frames_received() > kDefaultNumFrames &&
-          fake_video_renderer2.num_rendered_frames() > kDefaultNumFrames,
-      kDefaultTimeout);
+  // The SRTP side is not expected to decode any audio or video frames.
+  // The RTP side is not expected to decode any video frames while it is
+  // possible that the encrypted audio frames can be accidentally decoded which
+  // is why received_audio_frames1_ is not validated.
+  EXPECT_TRUE(received_audio_frames2_ == 0 && rendered_video_frames1_ == 0 &&
+              rendered_video_frames2_ == 0);
 }
 
 // End-to-end test with two pairs of RTP senders and receivers, for audio and
 // video. Unlike the test above, this attempts to make the parameters as
-// complex as possible.
+// complex as possible. The senders and receivers use the SRTP transport with
+// different keys.
 //
 // Uses non-muxed RTCP, with separate audio/video transports, and a full set of
 // parameters, as would normally be used in a PeerConnection.
 //
 // TODO(deadbeef): Update this test as more audio/video features become
 // supported.
-TEST_F(OrtcFactoryIntegrationTest, FullTwoWayAudioVideoRtpSendersAndReceivers) {
+TEST_F(OrtcFactoryIntegrationTest,
+       FullTwoWayAudioVideoSrtpSendersAndReceivers) {
   // We want four pairs of UDP transports for this test, for audio/video and
   // RTP/RTCP.
   auto audio_rtp_udp_transports = CreateAndConnectUdpTransportPair();
   auto audio_rtcp_udp_transports = CreateAndConnectUdpTransportPair();
   auto video_rtp_udp_transports = CreateAndConnectUdpTransportPair();
   auto video_rtcp_udp_transports = CreateAndConnectUdpTransportPair();
 
   // Since we have multiple RTP transports on each side, we need an RTP
   // transport controller.
   auto transport_controllers = CreateRtpTransportControllerPair();
 
   RtcpParameters audio_rtcp_parameters;
   audio_rtcp_parameters.mux = false;
-  auto audio_rtp_transports =
-      CreateRtpTransportPair(audio_rtcp_parameters, audio_rtp_udp_transports,
-                             audio_rtcp_udp_transports, transport_controllers);
+  auto audio_srtp_transports =
+      CreateSrtpTransportPair(audio_rtcp_parameters, audio_rtp_udp_transports,
+                              audio_rtcp_udp_transports, transport_controllers);
 
   RtcpParameters video_rtcp_parameters;
   video_rtcp_parameters.mux = false;
   video_rtcp_parameters.reduced_size = true;
-  auto video_rtp_transports =
-      CreateRtpTransportPair(video_rtcp_parameters, video_rtp_udp_transports,
-                             video_rtcp_udp_transports, transport_controllers);
+  auto video_srtp_transports =
+      CreateSrtpTransportPair(video_rtcp_parameters, video_rtp_udp_transports,
+                              video_rtcp_udp_transports, transport_controllers);
+
+  // Set keys for SRTP transports.
+  audio_srtp_transports.first->SetSrtpSendKey(kTestCryptoParams1);
+  audio_srtp_transports.first->SetSrtpReceiveKey(kTestCryptoParams2);
+  video_srtp_transports.first->SetSrtpSendKey(kTestCryptoParams3);
+  video_srtp_transports.first->SetSrtpReceiveKey(kTestCryptoParams4);
+
+  audio_srtp_transports.second->SetSrtpSendKey(kTestCryptoParams2);
+  audio_srtp_transports.second->SetSrtpReceiveKey(kTestCryptoParams1);
+  video_srtp_transports.second->SetSrtpSendKey(kTestCryptoParams4);
+  video_srtp_transports.second->SetSrtpReceiveKey(kTestCryptoParams3);
 
   // Create all the senders and receivers (four per endpoint).
   auto audio_sender_result1 = ortc_factory1_->CreateRtpSender(
-      cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.first.get());
+      cricket::MEDIA_TYPE_AUDIO, audio_srtp_transports.first.get());
   auto video_sender_result1 = ortc_factory1_->CreateRtpSender(
-      cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.first.get());
+      cricket::MEDIA_TYPE_VIDEO, video_srtp_transports.first.get());
   auto audio_receiver_result1 = ortc_factory1_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.first.get());
+      cricket::MEDIA_TYPE_AUDIO, audio_srtp_transports.first.get());
   auto video_receiver_result1 = ortc_factory1_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.first.get());
+      cricket::MEDIA_TYPE_VIDEO, video_srtp_transports.first.get());
   ASSERT_TRUE(audio_sender_result1.ok());
   ASSERT_TRUE(video_sender_result1.ok());
   ASSERT_TRUE(audio_receiver_result1.ok());
   ASSERT_TRUE(video_receiver_result1.ok());
   auto audio_sender1 = audio_sender_result1.MoveValue();
   auto video_sender1 = video_sender_result1.MoveValue();
   auto audio_receiver1 = audio_receiver_result1.MoveValue();
   auto video_receiver1 = video_receiver_result1.MoveValue();
 
   auto audio_sender_result2 = ortc_factory2_->CreateRtpSender(
-      cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.second.get());
+      cricket::MEDIA_TYPE_AUDIO, audio_srtp_transports.second.get());
   auto video_sender_result2 = ortc_factory2_->CreateRtpSender(
-      cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.second.get());
+      cricket::MEDIA_TYPE_VIDEO, video_srtp_transports.second.get());
   auto audio_receiver_result2 = ortc_factory2_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_AUDIO, audio_rtp_transports.second.get());
+      cricket::MEDIA_TYPE_AUDIO, audio_srtp_transports.second.get());
   auto video_receiver_result2 = ortc_factory2_->CreateRtpReceiver(
-      cricket::MEDIA_TYPE_VIDEO, video_rtp_transports.second.get());
+      cricket::MEDIA_TYPE_VIDEO, video_srtp_transports.second.get());
   ASSERT_TRUE(audio_sender_result2.ok());
   ASSERT_TRUE(video_sender_result2.ok());
   ASSERT_TRUE(audio_receiver_result2.ok());
   ASSERT_TRUE(video_receiver_result2.ok());
   auto audio_sender2 = audio_sender_result2.MoveValue();
   auto video_sender2 = video_sender_result2.MoveValue();
   auto audio_receiver2 = audio_receiver_result2.MoveValue();
   auto video_receiver2 = video_receiver_result2.MoveValue();
 
   RTCError error = audio_sender1->SetTrack(
@@ skipping 59 matching lines @@
 // TODO(deadbeef): End-to-end test for multiple senders/receivers of the same
 // media type, once that's supported. Currently, it is not because the
 // BaseChannel model relies on there being a single VoiceChannel and
 // VideoChannel, and these only support a single set of codecs/etc. per
 // send/receive direction.
 
 // TODO(deadbeef): End-to-end test for simulcast, once that's supported by this
 // API.
 
 }  // namespace webrtc