Repo created
This commit is contained in:
parent
81b91f4139
commit
f8c34fa5ee
22732 changed files with 4815320 additions and 2 deletions
|
|
@ -0,0 +1,526 @@
|
|||
/*
|
||||
* 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 <stddef.h>
|
||||
|
||||
#include <memory>
|
||||
#include <ostream>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
#include "absl/types/optional.h"
|
||||
#include "api/audio/audio_mixer.h"
|
||||
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
|
||||
#include "api/audio_codecs/builtin_audio_encoder_factory.h"
|
||||
#include "api/create_peerconnection_factory.h"
|
||||
#include "api/crypto/crypto_options.h"
|
||||
#include "api/jsep.h"
|
||||
#include "api/peer_connection_interface.h"
|
||||
#include "api/scoped_refptr.h"
|
||||
#include "api/video_codecs/video_decoder_factory_template.h"
|
||||
#include "api/video_codecs/video_decoder_factory_template_dav1d_adapter.h"
|
||||
#include "api/video_codecs/video_decoder_factory_template_libvpx_vp8_adapter.h"
|
||||
#include "api/video_codecs/video_decoder_factory_template_libvpx_vp9_adapter.h"
|
||||
#include "api/video_codecs/video_decoder_factory_template_open_h264_adapter.h"
|
||||
#include "api/video_codecs/video_encoder_factory_template.h"
|
||||
#include "api/video_codecs/video_encoder_factory_template_libaom_av1_adapter.h"
|
||||
#include "api/video_codecs/video_encoder_factory_template_libvpx_vp8_adapter.h"
|
||||
#include "api/video_codecs/video_encoder_factory_template_libvpx_vp9_adapter.h"
|
||||
#include "api/video_codecs/video_encoder_factory_template_open_h264_adapter.h"
|
||||
#include "modules/audio_device/include/audio_device.h"
|
||||
#include "modules/audio_processing/include/audio_processing.h"
|
||||
#include "p2p/base/fake_port_allocator.h"
|
||||
#include "p2p/base/port_allocator.h"
|
||||
#include "p2p/base/transport_description.h"
|
||||
#include "p2p/base/transport_info.h"
|
||||
#include "pc/media_protocol_names.h"
|
||||
#include "pc/media_session.h"
|
||||
#include "pc/peer_connection_wrapper.h"
|
||||
#include "pc/sdp_utils.h"
|
||||
#include "pc/session_description.h"
|
||||
#include "pc/test/mock_peer_connection_observers.h"
|
||||
#include "rtc_base/checks.h"
|
||||
#include "rtc_base/rtc_certificate.h"
|
||||
#include "rtc_base/rtc_certificate_generator.h"
|
||||
#include "rtc_base/ssl_fingerprint.h"
|
||||
#include "rtc_base/thread.h"
|
||||
#include "test/gmock.h"
|
||||
#include "test/gtest.h"
|
||||
#include "test/scoped_key_value_config.h"
|
||||
#ifdef WEBRTC_ANDROID
|
||||
#include "pc/test/android_test_initializer.h"
|
||||
#endif
|
||||
#include "pc/test/fake_audio_capture_module.h"
|
||||
#include "pc/test/fake_rtc_certificate_generator.h"
|
||||
#include "rtc_base/gunit.h"
|
||||
#include "rtc_base/virtual_socket_server.h"
|
||||
|
||||
namespace webrtc {
|
||||
|
||||
using RTCConfiguration = PeerConnectionInterface::RTCConfiguration;
|
||||
using RTCOfferAnswerOptions = PeerConnectionInterface::RTCOfferAnswerOptions;
|
||||
using ::testing::Combine;
|
||||
using ::testing::HasSubstr;
|
||||
using ::testing::Values;
|
||||
|
||||
constexpr int kGenerateCertTimeout = 1000;
|
||||
|
||||
class PeerConnectionCryptoBaseTest : public ::testing::Test {
|
||||
protected:
|
||||
typedef std::unique_ptr<PeerConnectionWrapper> WrapperPtr;
|
||||
|
||||
explicit PeerConnectionCryptoBaseTest(SdpSemantics sdp_semantics)
|
||||
: vss_(new rtc::VirtualSocketServer()),
|
||||
main_(vss_.get()),
|
||||
sdp_semantics_(sdp_semantics) {
|
||||
#ifdef WEBRTC_ANDROID
|
||||
InitializeAndroidObjects();
|
||||
#endif
|
||||
pc_factory_ = CreatePeerConnectionFactory(
|
||||
rtc::Thread::Current(), rtc::Thread::Current(), rtc::Thread::Current(),
|
||||
FakeAudioCaptureModule::Create(), CreateBuiltinAudioEncoderFactory(),
|
||||
CreateBuiltinAudioDecoderFactory(),
|
||||
std::make_unique<VideoEncoderFactoryTemplate<
|
||||
LibvpxVp8EncoderTemplateAdapter, LibvpxVp9EncoderTemplateAdapter,
|
||||
OpenH264EncoderTemplateAdapter, LibaomAv1EncoderTemplateAdapter>>(),
|
||||
std::make_unique<VideoDecoderFactoryTemplate<
|
||||
LibvpxVp8DecoderTemplateAdapter, LibvpxVp9DecoderTemplateAdapter,
|
||||
OpenH264DecoderTemplateAdapter, Dav1dDecoderTemplateAdapter>>(),
|
||||
nullptr /* audio_mixer */, nullptr /* audio_processing */);
|
||||
}
|
||||
|
||||
WrapperPtr CreatePeerConnection() {
|
||||
return CreatePeerConnection(RTCConfiguration());
|
||||
}
|
||||
|
||||
WrapperPtr CreatePeerConnection(const RTCConfiguration& config) {
|
||||
return CreatePeerConnection(config, nullptr);
|
||||
}
|
||||
|
||||
WrapperPtr CreatePeerConnection(
|
||||
const RTCConfiguration& config,
|
||||
std::unique_ptr<rtc::RTCCertificateGeneratorInterface> cert_gen) {
|
||||
auto fake_port_allocator = std::make_unique<cricket::FakePortAllocator>(
|
||||
rtc::Thread::Current(),
|
||||
std::make_unique<rtc::BasicPacketSocketFactory>(vss_.get()),
|
||||
&field_trials_);
|
||||
auto observer = std::make_unique<MockPeerConnectionObserver>();
|
||||
RTCConfiguration modified_config = config;
|
||||
modified_config.sdp_semantics = sdp_semantics_;
|
||||
PeerConnectionDependencies pc_dependencies(observer.get());
|
||||
pc_dependencies.allocator = std::move(fake_port_allocator);
|
||||
pc_dependencies.cert_generator = std::move(cert_gen);
|
||||
auto result = pc_factory_->CreatePeerConnectionOrError(
|
||||
modified_config, std::move(pc_dependencies));
|
||||
if (!result.ok()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
observer->SetPeerConnectionInterface(result.value().get());
|
||||
return std::make_unique<PeerConnectionWrapper>(
|
||||
pc_factory_, result.MoveValue(), std::move(observer));
|
||||
}
|
||||
|
||||
// Accepts the same arguments as CreatePeerConnection and adds default audio
|
||||
// and video tracks.
|
||||
template <typename... Args>
|
||||
WrapperPtr CreatePeerConnectionWithAudioVideo(Args&&... args) {
|
||||
auto wrapper = CreatePeerConnection(std::forward<Args>(args)...);
|
||||
if (!wrapper) {
|
||||
return nullptr;
|
||||
}
|
||||
wrapper->AddAudioTrack("a");
|
||||
wrapper->AddVideoTrack("v");
|
||||
return wrapper;
|
||||
}
|
||||
|
||||
cricket::ConnectionRole& AudioConnectionRole(
|
||||
cricket::SessionDescription* desc) {
|
||||
return ConnectionRoleFromContent(desc, cricket::GetFirstAudioContent(desc));
|
||||
}
|
||||
|
||||
cricket::ConnectionRole& VideoConnectionRole(
|
||||
cricket::SessionDescription* desc) {
|
||||
return ConnectionRoleFromContent(desc, cricket::GetFirstVideoContent(desc));
|
||||
}
|
||||
|
||||
cricket::ConnectionRole& ConnectionRoleFromContent(
|
||||
cricket::SessionDescription* desc,
|
||||
cricket::ContentInfo* content) {
|
||||
RTC_DCHECK(content);
|
||||
auto* transport_info = desc->GetTransportInfoByName(content->name);
|
||||
RTC_DCHECK(transport_info);
|
||||
return transport_info->description.connection_role;
|
||||
}
|
||||
|
||||
test::ScopedKeyValueConfig field_trials_;
|
||||
std::unique_ptr<rtc::VirtualSocketServer> vss_;
|
||||
rtc::AutoSocketServerThread main_;
|
||||
rtc::scoped_refptr<PeerConnectionFactoryInterface> pc_factory_;
|
||||
const SdpSemantics sdp_semantics_;
|
||||
};
|
||||
|
||||
SdpContentPredicate HaveDtlsFingerprint() {
|
||||
return [](const cricket::ContentInfo* content,
|
||||
const cricket::TransportInfo* transport) {
|
||||
return transport->description.identity_fingerprint != nullptr;
|
||||
};
|
||||
}
|
||||
|
||||
SdpContentPredicate HaveProtocol(const std::string& protocol) {
|
||||
return [protocol](const cricket::ContentInfo* content,
|
||||
const cricket::TransportInfo* transport) {
|
||||
return content->media_description()->protocol() == protocol;
|
||||
};
|
||||
}
|
||||
|
||||
class PeerConnectionCryptoTest
|
||||
: public PeerConnectionCryptoBaseTest,
|
||||
public ::testing::WithParamInterface<SdpSemantics> {
|
||||
protected:
|
||||
PeerConnectionCryptoTest() : PeerConnectionCryptoBaseTest(GetParam()) {}
|
||||
};
|
||||
|
||||
SdpContentMutator RemoveDtlsFingerprint() {
|
||||
return [](cricket::ContentInfo* content, cricket::TransportInfo* transport) {
|
||||
transport->description.identity_fingerprint.reset();
|
||||
};
|
||||
}
|
||||
|
||||
// When DTLS is enabled, the SDP offer/answer should have a DTLS fingerprint
|
||||
TEST_P(PeerConnectionCryptoTest, CorrectCryptoInOfferWhenDtlsEnabled) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
auto offer = caller->CreateOffer();
|
||||
ASSERT_TRUE(offer);
|
||||
|
||||
ASSERT_FALSE(offer->description()->contents().empty());
|
||||
EXPECT_TRUE(SdpContentsAll(HaveDtlsFingerprint(), offer->description()));
|
||||
EXPECT_TRUE(SdpContentsAll(HaveProtocol(cricket::kMediaProtocolDtlsSavpf),
|
||||
offer->description()));
|
||||
}
|
||||
TEST_P(PeerConnectionCryptoTest, CorrectCryptoInAnswerWhenDtlsEnabled) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
callee->SetRemoteDescription(caller->CreateOffer());
|
||||
auto answer = callee->CreateAnswer();
|
||||
ASSERT_TRUE(answer);
|
||||
|
||||
ASSERT_FALSE(answer->description()->contents().empty());
|
||||
EXPECT_TRUE(SdpContentsAll(HaveDtlsFingerprint(), answer->description()));
|
||||
EXPECT_TRUE(SdpContentsAll(HaveProtocol(cricket::kMediaProtocolDtlsSavpf),
|
||||
answer->description()));
|
||||
}
|
||||
|
||||
// The following group tests that two PeerConnections can successfully exchange
|
||||
// an offer/answer when DTLS is on and that they will refuse any offer/answer
|
||||
// applied locally/remotely if it does not include a DTLS fingerprint.
|
||||
TEST_P(PeerConnectionCryptoTest, ExchangeOfferAnswerWhenDtlsOn) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
auto offer = caller->CreateOfferAndSetAsLocal();
|
||||
ASSERT_TRUE(offer);
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(std::move(offer)));
|
||||
|
||||
auto answer = callee->CreateAnswerAndSetAsLocal();
|
||||
ASSERT_TRUE(answer);
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(std::move(answer)));
|
||||
}
|
||||
TEST_P(PeerConnectionCryptoTest,
|
||||
FailToSetLocalOfferWithNoFingerprintWhenDtlsOn) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
auto offer = caller->CreateOffer();
|
||||
SdpContentsForEach(RemoveDtlsFingerprint(), offer->description());
|
||||
|
||||
EXPECT_FALSE(caller->SetLocalDescription(std::move(offer)));
|
||||
}
|
||||
TEST_P(PeerConnectionCryptoTest,
|
||||
FailToSetRemoteOfferWithNoFingerprintWhenDtlsOn) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
auto offer = caller->CreateOffer();
|
||||
SdpContentsForEach(RemoveDtlsFingerprint(), offer->description());
|
||||
|
||||
EXPECT_FALSE(callee->SetRemoteDescription(std::move(offer)));
|
||||
}
|
||||
TEST_P(PeerConnectionCryptoTest,
|
||||
FailToSetLocalAnswerWithNoFingerprintWhenDtlsOn) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal());
|
||||
auto answer = callee->CreateAnswer();
|
||||
SdpContentsForEach(RemoveDtlsFingerprint(), answer->description());
|
||||
}
|
||||
TEST_P(PeerConnectionCryptoTest,
|
||||
FailToSetRemoteAnswerWithNoFingerprintWhenDtlsOn) {
|
||||
RTCConfiguration config;
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(config);
|
||||
|
||||
callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal());
|
||||
auto answer = callee->CreateAnswerAndSetAsLocal();
|
||||
SdpContentsForEach(RemoveDtlsFingerprint(), answer->description());
|
||||
|
||||
EXPECT_FALSE(caller->SetRemoteDescription(std::move(answer)));
|
||||
}
|
||||
|
||||
// Tests that a DTLS call can be established when the certificate is specified
|
||||
// in the PeerConnection config and no certificate generator is specified.
|
||||
TEST_P(PeerConnectionCryptoTest,
|
||||
ExchangeOfferAnswerWhenDtlsCertificateInConfig) {
|
||||
RTCConfiguration caller_config;
|
||||
caller_config.certificates.push_back(
|
||||
FakeRTCCertificateGenerator::GenerateCertificate());
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(caller_config);
|
||||
|
||||
RTCConfiguration callee_config;
|
||||
callee_config.certificates.push_back(
|
||||
FakeRTCCertificateGenerator::GenerateCertificate());
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(callee_config);
|
||||
|
||||
auto offer = caller->CreateOfferAndSetAsLocal();
|
||||
ASSERT_TRUE(offer);
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(std::move(offer)));
|
||||
|
||||
auto answer = callee->CreateAnswerAndSetAsLocal();
|
||||
ASSERT_TRUE(answer);
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(std::move(answer)));
|
||||
}
|
||||
|
||||
// The following parameterized test verifies that CreateOffer/CreateAnswer
|
||||
// returns successfully (or with failure if the underlying certificate generator
|
||||
// fails) no matter when the DTLS certificate is generated. If multiple
|
||||
// CreateOffer/CreateAnswer calls are made while waiting for the certificate,
|
||||
// they all finish after the certificate is generated.
|
||||
|
||||
// Whether the certificate will be generated before calling CreateOffer or
|
||||
// while CreateOffer is executing.
|
||||
enum class CertGenTime { kBefore, kDuring };
|
||||
std::ostream& operator<<(std::ostream& out, CertGenTime value) {
|
||||
switch (value) {
|
||||
case CertGenTime::kBefore:
|
||||
return out << "before";
|
||||
case CertGenTime::kDuring:
|
||||
return out << "during";
|
||||
default:
|
||||
return out << "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
// Whether the fake certificate generator will produce a certificate or fail.
|
||||
enum class CertGenResult { kSucceed, kFail };
|
||||
std::ostream& operator<<(std::ostream& out, CertGenResult value) {
|
||||
switch (value) {
|
||||
case CertGenResult::kSucceed:
|
||||
return out << "succeed";
|
||||
case CertGenResult::kFail:
|
||||
return out << "fail";
|
||||
default:
|
||||
return out << "unknown";
|
||||
}
|
||||
}
|
||||
|
||||
class PeerConnectionCryptoDtlsCertGenTest
|
||||
: public PeerConnectionCryptoBaseTest,
|
||||
public ::testing::WithParamInterface<std::tuple<SdpSemantics,
|
||||
SdpType,
|
||||
CertGenTime,
|
||||
CertGenResult,
|
||||
size_t>> {
|
||||
protected:
|
||||
PeerConnectionCryptoDtlsCertGenTest()
|
||||
: PeerConnectionCryptoBaseTest(std::get<0>(GetParam())) {
|
||||
sdp_type_ = std::get<1>(GetParam());
|
||||
cert_gen_time_ = std::get<2>(GetParam());
|
||||
cert_gen_result_ = std::get<3>(GetParam());
|
||||
concurrent_calls_ = std::get<4>(GetParam());
|
||||
}
|
||||
|
||||
SdpType sdp_type_;
|
||||
CertGenTime cert_gen_time_;
|
||||
CertGenResult cert_gen_result_;
|
||||
size_t concurrent_calls_;
|
||||
};
|
||||
|
||||
TEST_P(PeerConnectionCryptoDtlsCertGenTest, TestCertificateGeneration) {
|
||||
RTCConfiguration config;
|
||||
auto owned_fake_certificate_generator =
|
||||
std::make_unique<FakeRTCCertificateGenerator>();
|
||||
auto* fake_certificate_generator = owned_fake_certificate_generator.get();
|
||||
fake_certificate_generator->set_should_fail(cert_gen_result_ ==
|
||||
CertGenResult::kFail);
|
||||
fake_certificate_generator->set_should_wait(cert_gen_time_ ==
|
||||
CertGenTime::kDuring);
|
||||
WrapperPtr pc;
|
||||
if (sdp_type_ == SdpType::kOffer) {
|
||||
pc = CreatePeerConnectionWithAudioVideo(
|
||||
config, std::move(owned_fake_certificate_generator));
|
||||
} else {
|
||||
auto caller = CreatePeerConnectionWithAudioVideo(config);
|
||||
pc = CreatePeerConnectionWithAudioVideo(
|
||||
config, std::move(owned_fake_certificate_generator));
|
||||
pc->SetRemoteDescription(caller->CreateOfferAndSetAsLocal());
|
||||
}
|
||||
if (cert_gen_time_ == CertGenTime::kBefore) {
|
||||
ASSERT_TRUE_WAIT(fake_certificate_generator->generated_certificates() +
|
||||
fake_certificate_generator->generated_failures() >
|
||||
0,
|
||||
kGenerateCertTimeout);
|
||||
} else {
|
||||
ASSERT_EQ(fake_certificate_generator->generated_certificates(), 0);
|
||||
fake_certificate_generator->set_should_wait(false);
|
||||
}
|
||||
std::vector<rtc::scoped_refptr<MockCreateSessionDescriptionObserver>>
|
||||
observers;
|
||||
for (size_t i = 0; i < concurrent_calls_; i++) {
|
||||
rtc::scoped_refptr<MockCreateSessionDescriptionObserver> observer =
|
||||
rtc::make_ref_counted<MockCreateSessionDescriptionObserver>();
|
||||
observers.push_back(observer);
|
||||
if (sdp_type_ == SdpType::kOffer) {
|
||||
pc->pc()->CreateOffer(observer.get(),
|
||||
PeerConnectionInterface::RTCOfferAnswerOptions());
|
||||
} else {
|
||||
pc->pc()->CreateAnswer(observer.get(),
|
||||
PeerConnectionInterface::RTCOfferAnswerOptions());
|
||||
}
|
||||
}
|
||||
for (auto& observer : observers) {
|
||||
EXPECT_TRUE_WAIT(observer->called(), 1000);
|
||||
if (cert_gen_result_ == CertGenResult::kSucceed) {
|
||||
EXPECT_TRUE(observer->result());
|
||||
} else {
|
||||
EXPECT_FALSE(observer->result());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(
|
||||
PeerConnectionCryptoTest,
|
||||
PeerConnectionCryptoDtlsCertGenTest,
|
||||
Combine(Values(SdpSemantics::kPlanB_DEPRECATED, SdpSemantics::kUnifiedPlan),
|
||||
Values(SdpType::kOffer, SdpType::kAnswer),
|
||||
Values(CertGenTime::kBefore, CertGenTime::kDuring),
|
||||
Values(CertGenResult::kSucceed, CertGenResult::kFail),
|
||||
Values(1, 3)));
|
||||
|
||||
// Test that we can create and set an answer correctly when different
|
||||
// SSL roles have been negotiated for different transports.
|
||||
// See: https://bugs.chromium.org/p/webrtc/issues/detail?id=4525
|
||||
TEST_P(PeerConnectionCryptoTest, CreateAnswerWithDifferentSslRoles) {
|
||||
auto caller = CreatePeerConnectionWithAudioVideo();
|
||||
auto callee = CreatePeerConnectionWithAudioVideo();
|
||||
|
||||
RTCOfferAnswerOptions options_no_bundle;
|
||||
options_no_bundle.use_rtp_mux = false;
|
||||
|
||||
// First, negotiate different SSL roles for audio and video.
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
|
||||
auto answer = callee->CreateAnswer(options_no_bundle);
|
||||
|
||||
AudioConnectionRole(answer->description()) = cricket::CONNECTIONROLE_ACTIVE;
|
||||
VideoConnectionRole(answer->description()) = cricket::CONNECTIONROLE_PASSIVE;
|
||||
|
||||
ASSERT_TRUE(
|
||||
callee->SetLocalDescription(CloneSessionDescription(answer.get())));
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(std::move(answer)));
|
||||
|
||||
// Now create an offer in the reverse direction, and ensure the initial
|
||||
// offerer responds with an answer with the correct SSL roles.
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(callee->CreateOfferAndSetAsLocal()));
|
||||
answer = caller->CreateAnswer(options_no_bundle);
|
||||
|
||||
EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
|
||||
AudioConnectionRole(answer->description()));
|
||||
EXPECT_EQ(cricket::CONNECTIONROLE_ACTIVE,
|
||||
VideoConnectionRole(answer->description()));
|
||||
|
||||
ASSERT_TRUE(
|
||||
caller->SetLocalDescription(CloneSessionDescription(answer.get())));
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(std::move(answer)));
|
||||
|
||||
// Lastly, start BUNDLE-ing on "audio", expecting that the "passive" role of
|
||||
// audio is transferred over to video in the answer that completes the BUNDLE
|
||||
// negotiation.
|
||||
RTCOfferAnswerOptions options_bundle;
|
||||
options_bundle.use_rtp_mux = true;
|
||||
|
||||
ASSERT_TRUE(caller->SetRemoteDescription(callee->CreateOfferAndSetAsLocal()));
|
||||
answer = caller->CreateAnswer(options_bundle);
|
||||
|
||||
EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
|
||||
AudioConnectionRole(answer->description()));
|
||||
EXPECT_EQ(cricket::CONNECTIONROLE_PASSIVE,
|
||||
VideoConnectionRole(answer->description()));
|
||||
|
||||
ASSERT_TRUE(
|
||||
caller->SetLocalDescription(CloneSessionDescription(answer.get())));
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(std::move(answer)));
|
||||
}
|
||||
|
||||
// Tests that if the DTLS fingerprint is invalid then all future calls to
|
||||
// SetLocalDescription and SetRemoteDescription will fail due to a session
|
||||
// error.
|
||||
// This is a regression test for crbug.com/800775
|
||||
TEST_P(PeerConnectionCryptoTest, SessionErrorIfFingerprintInvalid) {
|
||||
auto callee_certificate = rtc::RTCCertificate::FromPEM(kRsaPems[0]);
|
||||
auto other_certificate = rtc::RTCCertificate::FromPEM(kRsaPems[1]);
|
||||
|
||||
auto caller = CreatePeerConnectionWithAudioVideo();
|
||||
RTCConfiguration callee_config;
|
||||
callee_config.certificates.push_back(callee_certificate);
|
||||
auto callee = CreatePeerConnectionWithAudioVideo(callee_config);
|
||||
|
||||
ASSERT_TRUE(callee->SetRemoteDescription(caller->CreateOfferAndSetAsLocal()));
|
||||
|
||||
// Create an invalid answer with the other certificate's fingerprint.
|
||||
auto valid_answer = callee->CreateAnswer();
|
||||
auto invalid_answer = CloneSessionDescription(valid_answer.get());
|
||||
auto* audio_content =
|
||||
cricket::GetFirstAudioContent(invalid_answer->description());
|
||||
ASSERT_TRUE(audio_content);
|
||||
auto* audio_transport_info =
|
||||
invalid_answer->description()->GetTransportInfoByName(
|
||||
audio_content->name);
|
||||
ASSERT_TRUE(audio_transport_info);
|
||||
audio_transport_info->description.identity_fingerprint =
|
||||
rtc::SSLFingerprint::CreateFromCertificate(*other_certificate);
|
||||
|
||||
// Set the invalid answer and expect a fingerprint error.
|
||||
std::string error;
|
||||
ASSERT_FALSE(callee->SetLocalDescription(std::move(invalid_answer), &error));
|
||||
EXPECT_THAT(error, HasSubstr("Local fingerprint does not match identity."));
|
||||
|
||||
// Make sure that setting a valid remote offer or local answer also fails now.
|
||||
ASSERT_FALSE(callee->SetRemoteDescription(caller->CreateOffer(), &error));
|
||||
EXPECT_THAT(error, HasSubstr("Session error code: ERROR_CONTENT."));
|
||||
ASSERT_FALSE(callee->SetLocalDescription(std::move(valid_answer), &error));
|
||||
EXPECT_THAT(error, HasSubstr("Session error code: ERROR_CONTENT."));
|
||||
}
|
||||
|
||||
INSTANTIATE_TEST_SUITE_P(PeerConnectionCryptoTest,
|
||||
PeerConnectionCryptoTest,
|
||||
Values(SdpSemantics::kPlanB_DEPRECATED,
|
||||
SdpSemantics::kUnifiedPlan));
|
||||
|
||||
} // namespace webrtc
|
||||
Loading…
Add table
Add a link
Reference in a new issue