| /* |
| * 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 "pc/dtls_srtp_transport.h" |
| |
| #include <string.h> |
| |
| #include <cstdint> |
| #include <memory> |
| |
| #include "call/rtp_demuxer.h" |
| #include "media/base/fake_rtp.h" |
| #include "p2p/base/dtls_transport_internal.h" |
| #include "p2p/base/fake_dtls_transport.h" |
| #include "p2p/base/fake_ice_transport.h" |
| #include "p2p/base/p2p_constants.h" |
| #include "pc/rtp_transport.h" |
| #include "pc/test/rtp_transport_test_util.h" |
| #include "rtc_base/async_packet_socket.h" |
| #include "rtc_base/byte_order.h" |
| #include "rtc_base/containers/flat_set.h" |
| #include "rtc_base/copy_on_write_buffer.h" |
| #include "rtc_base/rtc_certificate.h" |
| #include "rtc_base/ssl_identity.h" |
| #include "rtc_base/third_party/sigslot/sigslot.h" |
| #include "test/gtest.h" |
| #include "test/scoped_key_value_config.h" |
| |
| using cricket::FakeDtlsTransport; |
| using cricket::FakeIceTransport; |
| using webrtc::DtlsSrtpTransport; |
| using webrtc::RtpTransport; |
| using webrtc::SrtpTransport; |
| |
| const int kRtpAuthTagLen = 10; |
| |
| class DtlsSrtpTransportTest : public ::testing::Test, |
| public sigslot::has_slots<> { |
| protected: |
| DtlsSrtpTransportTest() {} |
| |
| ~DtlsSrtpTransportTest() { |
| if (dtls_srtp_transport1_) { |
| dtls_srtp_transport1_->UnregisterRtpDemuxerSink(&transport_observer1_); |
| } |
| if (dtls_srtp_transport2_) { |
| dtls_srtp_transport2_->UnregisterRtpDemuxerSink(&transport_observer2_); |
| } |
| } |
| |
| std::unique_ptr<DtlsSrtpTransport> MakeDtlsSrtpTransport( |
| FakeDtlsTransport* rtp_dtls, |
| FakeDtlsTransport* rtcp_dtls, |
| bool rtcp_mux_enabled) { |
| auto dtls_srtp_transport = |
| std::make_unique<DtlsSrtpTransport>(rtcp_mux_enabled, field_trials_); |
| |
| dtls_srtp_transport->SetDtlsTransports(rtp_dtls, rtcp_dtls); |
| |
| return dtls_srtp_transport; |
| } |
| |
| void MakeDtlsSrtpTransports(FakeDtlsTransport* rtp_dtls1, |
| FakeDtlsTransport* rtcp_dtls1, |
| FakeDtlsTransport* rtp_dtls2, |
| FakeDtlsTransport* rtcp_dtls2, |
| bool rtcp_mux_enabled) { |
| dtls_srtp_transport1_ = |
| MakeDtlsSrtpTransport(rtp_dtls1, rtcp_dtls1, rtcp_mux_enabled); |
| dtls_srtp_transport2_ = |
| MakeDtlsSrtpTransport(rtp_dtls2, rtcp_dtls2, rtcp_mux_enabled); |
| |
| dtls_srtp_transport1_->SignalRtcpPacketReceived.connect( |
| &transport_observer1_, |
| &webrtc::TransportObserver::OnRtcpPacketReceived); |
| dtls_srtp_transport1_->SignalReadyToSend.connect( |
| &transport_observer1_, &webrtc::TransportObserver::OnReadyToSend); |
| |
| dtls_srtp_transport2_->SignalRtcpPacketReceived.connect( |
| &transport_observer2_, |
| &webrtc::TransportObserver::OnRtcpPacketReceived); |
| dtls_srtp_transport2_->SignalReadyToSend.connect( |
| &transport_observer2_, &webrtc::TransportObserver::OnReadyToSend); |
| webrtc::RtpDemuxerCriteria demuxer_criteria; |
| // 0x00 is the payload type used in kPcmuFrame. |
| demuxer_criteria.payload_types() = {0x00}; |
| dtls_srtp_transport1_->RegisterRtpDemuxerSink(demuxer_criteria, |
| &transport_observer1_); |
| dtls_srtp_transport2_->RegisterRtpDemuxerSink(demuxer_criteria, |
| &transport_observer2_); |
| } |
| |
| void CompleteDtlsHandshake(FakeDtlsTransport* fake_dtls1, |
| FakeDtlsTransport* fake_dtls2) { |
| auto cert1 = rtc::RTCCertificate::Create( |
| rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT)); |
| fake_dtls1->SetLocalCertificate(cert1); |
| auto cert2 = rtc::RTCCertificate::Create( |
| rtc::SSLIdentity::Create("session1", rtc::KT_DEFAULT)); |
| fake_dtls2->SetLocalCertificate(cert2); |
| fake_dtls1->SetDestination(fake_dtls2); |
| } |
| |
| void SendRecvRtpPackets() { |
| ASSERT_TRUE(dtls_srtp_transport1_); |
| ASSERT_TRUE(dtls_srtp_transport2_); |
| ASSERT_TRUE(dtls_srtp_transport1_->IsSrtpActive()); |
| ASSERT_TRUE(dtls_srtp_transport2_->IsSrtpActive()); |
| |
| size_t rtp_len = sizeof(kPcmuFrame); |
| size_t packet_size = rtp_len + kRtpAuthTagLen; |
| rtc::Buffer rtp_packet_buffer(packet_size); |
| char* rtp_packet_data = rtp_packet_buffer.data<char>(); |
| memcpy(rtp_packet_data, kPcmuFrame, rtp_len); |
| // In order to be able to run this test function multiple times we can not |
| // use the same sequence number twice. Increase the sequence number by one. |
| rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_data) + 2, |
| ++sequence_number_); |
| rtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len, |
| packet_size); |
| rtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len, |
| packet_size); |
| |
| rtc::PacketOptions options; |
| // Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify |
| // that the packet can be successfully received and decrypted. |
| int prev_received_packets = transport_observer2_.rtp_count(); |
| ASSERT_TRUE(dtls_srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options, |
| cricket::PF_SRTP_BYPASS)); |
| ASSERT_TRUE(transport_observer2_.last_recv_rtp_packet().data()); |
| EXPECT_EQ(0, memcmp(transport_observer2_.last_recv_rtp_packet().data(), |
| kPcmuFrame, rtp_len)); |
| EXPECT_EQ(prev_received_packets + 1, transport_observer2_.rtp_count()); |
| |
| prev_received_packets = transport_observer1_.rtp_count(); |
| ASSERT_TRUE(dtls_srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options, |
| cricket::PF_SRTP_BYPASS)); |
| ASSERT_TRUE(transport_observer1_.last_recv_rtp_packet().data()); |
| EXPECT_EQ(0, memcmp(transport_observer1_.last_recv_rtp_packet().data(), |
| kPcmuFrame, rtp_len)); |
| EXPECT_EQ(prev_received_packets + 1, transport_observer1_.rtp_count()); |
| } |
| |
| void SendRecvRtcpPackets() { |
| size_t rtcp_len = sizeof(kRtcpReport); |
| size_t packet_size = rtcp_len + 4 + kRtpAuthTagLen; |
| rtc::Buffer rtcp_packet_buffer(packet_size); |
| |
| // TODO(zhihuang): Remove the extra copy when the SendRtpPacket method |
| // doesn't take the CopyOnWriteBuffer by pointer. |
| rtc::CopyOnWriteBuffer rtcp_packet1to2(kRtcpReport, rtcp_len, packet_size); |
| rtc::CopyOnWriteBuffer rtcp_packet2to1(kRtcpReport, rtcp_len, packet_size); |
| |
| rtc::PacketOptions options; |
| // Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify |
| // that the packet can be successfully received and decrypted. |
| int prev_received_packets = transport_observer2_.rtcp_count(); |
| ASSERT_TRUE(dtls_srtp_transport1_->SendRtcpPacket(&rtcp_packet1to2, options, |
| cricket::PF_SRTP_BYPASS)); |
| ASSERT_TRUE(transport_observer2_.last_recv_rtcp_packet().data()); |
| EXPECT_EQ(0, memcmp(transport_observer2_.last_recv_rtcp_packet().data(), |
| kRtcpReport, rtcp_len)); |
| EXPECT_EQ(prev_received_packets + 1, transport_observer2_.rtcp_count()); |
| |
| // Do the same thing in the opposite direction; |
| prev_received_packets = transport_observer1_.rtcp_count(); |
| ASSERT_TRUE(dtls_srtp_transport2_->SendRtcpPacket(&rtcp_packet2to1, options, |
| cricket::PF_SRTP_BYPASS)); |
| ASSERT_TRUE(transport_observer1_.last_recv_rtcp_packet().data()); |
| EXPECT_EQ(0, memcmp(transport_observer1_.last_recv_rtcp_packet().data(), |
| kRtcpReport, rtcp_len)); |
| EXPECT_EQ(prev_received_packets + 1, transport_observer1_.rtcp_count()); |
| } |
| |
| void SendRecvRtpPacketsWithHeaderExtension( |
| const std::vector<int>& encrypted_header_ids) { |
| ASSERT_TRUE(dtls_srtp_transport1_); |
| ASSERT_TRUE(dtls_srtp_transport2_); |
| ASSERT_TRUE(dtls_srtp_transport1_->IsSrtpActive()); |
| ASSERT_TRUE(dtls_srtp_transport2_->IsSrtpActive()); |
| |
| size_t rtp_len = sizeof(kPcmuFrameWithExtensions); |
| size_t packet_size = rtp_len + kRtpAuthTagLen; |
| rtc::Buffer rtp_packet_buffer(packet_size); |
| char* rtp_packet_data = rtp_packet_buffer.data<char>(); |
| memcpy(rtp_packet_data, kPcmuFrameWithExtensions, rtp_len); |
| // In order to be able to run this test function multiple times we can not |
| // use the same sequence number twice. Increase the sequence number by one. |
| rtc::SetBE16(reinterpret_cast<uint8_t*>(rtp_packet_data) + 2, |
| ++sequence_number_); |
| rtc::CopyOnWriteBuffer rtp_packet1to2(rtp_packet_data, rtp_len, |
| packet_size); |
| rtc::CopyOnWriteBuffer rtp_packet2to1(rtp_packet_data, rtp_len, |
| packet_size); |
| |
| char original_rtp_data[sizeof(kPcmuFrameWithExtensions)]; |
| memcpy(original_rtp_data, rtp_packet_data, rtp_len); |
| |
| rtc::PacketOptions options; |
| // Send a packet from `srtp_transport1_` to `srtp_transport2_` and verify |
| // that the packet can be successfully received and decrypted. |
| ASSERT_TRUE(dtls_srtp_transport1_->SendRtpPacket(&rtp_packet1to2, options, |
| cricket::PF_SRTP_BYPASS)); |
| ASSERT_TRUE(transport_observer2_.last_recv_rtp_packet().data()); |
| EXPECT_EQ(0, memcmp(transport_observer2_.last_recv_rtp_packet().data(), |
| original_rtp_data, rtp_len)); |
| // Get the encrypted packet from underneath packet transport and verify the |
| // data and header extension are actually encrypted. |
| auto fake_dtls_transport = static_cast<FakeDtlsTransport*>( |
| dtls_srtp_transport1_->rtp_packet_transport()); |
| auto fake_ice_transport = |
| static_cast<FakeIceTransport*>(fake_dtls_transport->ice_transport()); |
| EXPECT_NE(0, memcmp(fake_ice_transport->last_sent_packet().data(), |
| original_rtp_data, rtp_len)); |
| CompareHeaderExtensions(reinterpret_cast<const char*>( |
| fake_ice_transport->last_sent_packet().data()), |
| fake_ice_transport->last_sent_packet().size(), |
| original_rtp_data, rtp_len, encrypted_header_ids, |
| false); |
| |
| // Do the same thing in the opposite direction. |
| ASSERT_TRUE(dtls_srtp_transport2_->SendRtpPacket(&rtp_packet2to1, options, |
| cricket::PF_SRTP_BYPASS)); |
| ASSERT_TRUE(transport_observer1_.last_recv_rtp_packet().data()); |
| EXPECT_EQ(0, memcmp(transport_observer1_.last_recv_rtp_packet().data(), |
| original_rtp_data, rtp_len)); |
| // Get the encrypted packet from underneath packet transport and verify the |
| // data and header extension are actually encrypted. |
| fake_dtls_transport = static_cast<FakeDtlsTransport*>( |
| dtls_srtp_transport2_->rtp_packet_transport()); |
| fake_ice_transport = |
| static_cast<FakeIceTransport*>(fake_dtls_transport->ice_transport()); |
| EXPECT_NE(0, memcmp(fake_ice_transport->last_sent_packet().data(), |
| original_rtp_data, rtp_len)); |
| CompareHeaderExtensions(reinterpret_cast<const char*>( |
| fake_ice_transport->last_sent_packet().data()), |
| fake_ice_transport->last_sent_packet().size(), |
| original_rtp_data, rtp_len, encrypted_header_ids, |
| false); |
| } |
| |
| void SendRecvPackets() { |
| SendRecvRtpPackets(); |
| SendRecvRtcpPackets(); |
| } |
| |
| rtc::AutoThread main_thread_; |
| std::unique_ptr<DtlsSrtpTransport> dtls_srtp_transport1_; |
| std::unique_ptr<DtlsSrtpTransport> dtls_srtp_transport2_; |
| webrtc::TransportObserver transport_observer1_; |
| webrtc::TransportObserver transport_observer2_; |
| |
| int sequence_number_ = 0; |
| webrtc::test::ScopedKeyValueConfig field_trials_; |
| }; |
| |
| // Tests that if RTCP muxing is enabled and transports are set after RTP |
| // transport finished the handshake, SRTP is set up. |
| TEST_F(DtlsSrtpTransportTest, SetTransportsAfterHandshakeCompleteWithRtcpMux) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "video", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "video", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), nullptr, rtp_dtls2.get(), nullptr, |
| /*rtcp_mux_enabled=*/true); |
| |
| auto rtp_dtls3 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtp_dtls4 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| |
| CompleteDtlsHandshake(rtp_dtls3.get(), rtp_dtls4.get()); |
| |
| dtls_srtp_transport1_->SetDtlsTransports(rtp_dtls3.get(), nullptr); |
| dtls_srtp_transport2_->SetDtlsTransports(rtp_dtls4.get(), nullptr); |
| |
| SendRecvPackets(); |
| } |
| |
| // Tests that if RTCP muxing is not enabled and transports are set after both |
| // RTP and RTCP transports finished the handshake, SRTP is set up. |
| TEST_F(DtlsSrtpTransportTest, |
| SetTransportsAfterHandshakeCompleteWithoutRtcpMux) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "video", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "video", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "video", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "video", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), /*rtcp_mux_enabled=*/false); |
| |
| auto rtp_dtls3 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls3 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls4 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls4 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| CompleteDtlsHandshake(rtp_dtls3.get(), rtp_dtls4.get()); |
| CompleteDtlsHandshake(rtcp_dtls3.get(), rtcp_dtls4.get()); |
| |
| dtls_srtp_transport1_->SetDtlsTransports(rtp_dtls3.get(), rtcp_dtls3.get()); |
| dtls_srtp_transport2_->SetDtlsTransports(rtp_dtls4.get(), rtcp_dtls4.get()); |
| |
| SendRecvPackets(); |
| } |
| |
| // Tests if RTCP muxing is enabled, SRTP is set up as soon as the RTP DTLS |
| // handshake is finished. |
| TEST_F(DtlsSrtpTransportTest, SetTransportsBeforeHandshakeCompleteWithRtcpMux) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), |
| /*rtcp_mux_enabled=*/false); |
| |
| dtls_srtp_transport1_->SetRtcpMuxEnabled(true); |
| dtls_srtp_transport2_->SetRtcpMuxEnabled(true); |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| SendRecvPackets(); |
| } |
| |
| // Tests if RTCP muxing is not enabled, SRTP is set up when both the RTP and |
| // RTCP DTLS handshake are finished. |
| TEST_F(DtlsSrtpTransportTest, |
| SetTransportsBeforeHandshakeCompleteWithoutRtcpMux) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), /*rtcp_mux_enabled=*/false); |
| |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| EXPECT_FALSE(dtls_srtp_transport1_->IsSrtpActive()); |
| EXPECT_FALSE(dtls_srtp_transport2_->IsSrtpActive()); |
| CompleteDtlsHandshake(rtcp_dtls1.get(), rtcp_dtls2.get()); |
| SendRecvPackets(); |
| } |
| |
| // Tests that if the DtlsTransport underneath is changed, the previous DTLS-SRTP |
| // context will be reset and will be re-setup once the new transports' handshake |
| // complete. |
| TEST_F(DtlsSrtpTransportTest, DtlsSrtpResetAfterDtlsTransportChange) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), nullptr, rtp_dtls2.get(), nullptr, |
| /*rtcp_mux_enabled=*/true); |
| |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| EXPECT_TRUE(dtls_srtp_transport1_->IsSrtpActive()); |
| EXPECT_TRUE(dtls_srtp_transport2_->IsSrtpActive()); |
| |
| auto rtp_dtls3 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtp_dtls4 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| |
| // The previous context is reset. |
| dtls_srtp_transport1_->SetDtlsTransports(rtp_dtls3.get(), nullptr); |
| dtls_srtp_transport2_->SetDtlsTransports(rtp_dtls4.get(), nullptr); |
| EXPECT_FALSE(dtls_srtp_transport1_->IsSrtpActive()); |
| EXPECT_FALSE(dtls_srtp_transport2_->IsSrtpActive()); |
| |
| // Re-setup. |
| CompleteDtlsHandshake(rtp_dtls3.get(), rtp_dtls4.get()); |
| SendRecvPackets(); |
| } |
| |
| // Tests if only the RTP DTLS handshake complete, and then RTCP muxing is |
| // enabled, SRTP is set up. |
| TEST_F(DtlsSrtpTransportTest, |
| RtcpMuxEnabledAfterRtpTransportHandshakeComplete) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), /*rtcp_mux_enabled=*/false); |
| |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| // Inactive because the RTCP transport handshake didn't complete. |
| EXPECT_FALSE(dtls_srtp_transport1_->IsSrtpActive()); |
| EXPECT_FALSE(dtls_srtp_transport2_->IsSrtpActive()); |
| |
| dtls_srtp_transport1_->SetRtcpMuxEnabled(true); |
| dtls_srtp_transport2_->SetRtcpMuxEnabled(true); |
| // The transports should be active and be able to send packets when the |
| // RTCP muxing is enabled. |
| SendRecvPackets(); |
| } |
| |
| // Tests that when SetSend/RecvEncryptedHeaderExtensionIds is called, the SRTP |
| // sessions are updated with new encryped header extension IDs immediately. |
| TEST_F(DtlsSrtpTransportTest, EncryptedHeaderExtensionIdUpdated) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), nullptr, rtp_dtls2.get(), nullptr, |
| /*rtcp_mux_enabled=*/true); |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| |
| std::vector<int> encrypted_headers; |
| encrypted_headers.push_back(kHeaderExtensionIDs[0]); |
| encrypted_headers.push_back(kHeaderExtensionIDs[1]); |
| |
| dtls_srtp_transport1_->UpdateSendEncryptedHeaderExtensionIds( |
| encrypted_headers); |
| dtls_srtp_transport1_->UpdateRecvEncryptedHeaderExtensionIds( |
| encrypted_headers); |
| dtls_srtp_transport2_->UpdateSendEncryptedHeaderExtensionIds( |
| encrypted_headers); |
| dtls_srtp_transport2_->UpdateRecvEncryptedHeaderExtensionIds( |
| encrypted_headers); |
| } |
| |
| // Tests if RTCP muxing is enabled. DtlsSrtpTransport is ready to send once the |
| // RTP DtlsTransport is ready. |
| TEST_F(DtlsSrtpTransportTest, SignalReadyToSendFiredWithRtcpMux) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), nullptr, rtp_dtls2.get(), nullptr, |
| /*rtcp_mux_enabled=*/true); |
| |
| rtp_dtls1->SetDestination(rtp_dtls2.get()); |
| EXPECT_TRUE(transport_observer1_.ready_to_send()); |
| EXPECT_TRUE(transport_observer2_.ready_to_send()); |
| } |
| |
| // Tests if RTCP muxing is not enabled. DtlsSrtpTransport is ready to send once |
| // both the RTP and RTCP DtlsTransport are ready. |
| TEST_F(DtlsSrtpTransportTest, SignalReadyToSendFiredWithoutRtcpMux) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), /*rtcp_mux_enabled=*/false); |
| |
| rtp_dtls1->SetDestination(rtp_dtls2.get()); |
| EXPECT_FALSE(transport_observer1_.ready_to_send()); |
| EXPECT_FALSE(transport_observer2_.ready_to_send()); |
| |
| rtcp_dtls1->SetDestination(rtcp_dtls2.get()); |
| EXPECT_TRUE(transport_observer1_.ready_to_send()); |
| EXPECT_TRUE(transport_observer2_.ready_to_send()); |
| } |
| |
| // Test that if an endpoint "fully" enables RTCP mux, setting the RTCP |
| // transport to null, it *doesn't* reset its SRTP context. That would cause the |
| // ROC and SRTCP index to be reset, causing replay detection and other errors |
| // when attempting to unprotect packets. |
| // Regression test for bugs.webrtc.org/8996 |
| TEST_F(DtlsSrtpTransportTest, SrtpSessionNotResetWhenRtcpTransportRemoved) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), /*rtcp_mux_enabled=*/true); |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| CompleteDtlsHandshake(rtcp_dtls1.get(), rtcp_dtls2.get()); |
| |
| // Send some RTCP packets, causing the SRTCP index to be incremented. |
| SendRecvRtcpPackets(); |
| |
| // Set RTCP transport to null, which previously would trigger this problem. |
| dtls_srtp_transport1_->SetDtlsTransports(rtp_dtls1.get(), nullptr); |
| |
| // Attempt to send more RTCP packets. If the issue occurred, one side would |
| // reset its context while the other would not, causing replay detection |
| // errors when a packet with a duplicate SRTCP index is received. |
| SendRecvRtcpPackets(); |
| } |
| |
| // Tests that RTCP packets can be sent and received if both sides actively reset |
| // the SRTP parameters with the `active_reset_srtp_params_` flag. |
| TEST_F(DtlsSrtpTransportTest, ActivelyResetSrtpParams) { |
| auto rtp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls1 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| auto rtp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTP); |
| auto rtcp_dtls2 = std::make_unique<FakeDtlsTransport>( |
| "audio", cricket::ICE_CANDIDATE_COMPONENT_RTCP); |
| |
| MakeDtlsSrtpTransports(rtp_dtls1.get(), rtcp_dtls1.get(), rtp_dtls2.get(), |
| rtcp_dtls2.get(), /*rtcp_mux_enabled=*/true); |
| CompleteDtlsHandshake(rtp_dtls1.get(), rtp_dtls2.get()); |
| CompleteDtlsHandshake(rtcp_dtls1.get(), rtcp_dtls2.get()); |
| |
| // Send some RTCP packets, causing the SRTCP index to be incremented. |
| SendRecvRtcpPackets(); |
| |
| // Only set the `active_reset_srtp_params_` flag to be true one side. |
| dtls_srtp_transport1_->SetActiveResetSrtpParams(true); |
| // Set RTCP transport to null to trigger the SRTP parameters update. |
| dtls_srtp_transport1_->SetDtlsTransports(rtp_dtls1.get(), nullptr); |
| dtls_srtp_transport2_->SetDtlsTransports(rtp_dtls2.get(), nullptr); |
| |
| // Sending some RTCP packets. |
| size_t rtcp_len = sizeof(kRtcpReport); |
| size_t packet_size = rtcp_len + 4 + kRtpAuthTagLen; |
| rtc::Buffer rtcp_packet_buffer(packet_size); |
| rtc::CopyOnWriteBuffer rtcp_packet(kRtcpReport, rtcp_len, packet_size); |
| int prev_received_packets = transport_observer2_.rtcp_count(); |
| ASSERT_TRUE(dtls_srtp_transport1_->SendRtcpPacket( |
| &rtcp_packet, rtc::PacketOptions(), cricket::PF_SRTP_BYPASS)); |
| // The RTCP packet is not exepected to be received because the SRTP parameters |
| // are only reset on one side and the SRTCP index is out of sync. |
| EXPECT_EQ(prev_received_packets, transport_observer2_.rtcp_count()); |
| |
| // Set the flag to be true on the other side. |
| dtls_srtp_transport2_->SetActiveResetSrtpParams(true); |
| // Set RTCP transport to null to trigger the SRTP parameters update. |
| dtls_srtp_transport1_->SetDtlsTransports(rtp_dtls1.get(), nullptr); |
| dtls_srtp_transport2_->SetDtlsTransports(rtp_dtls2.get(), nullptr); |
| |
| // RTCP packets flow is expected to work just fine. |
| SendRecvRtcpPackets(); |
| } |
