From 40e4966ab5a1906d8d144110eb5611b9ef0a28c3 Mon Sep 17 00:00:00 2001 From: Francis Tsui Date: Tue, 26 Mar 2024 22:36:15 -0700 Subject: [PATCH] Fix paired key verifiation error. PiperOrigin-RevId: 619418705 --- sharing/BUILD | 29 +++- sharing/nearby_sharing_service_impl.cc | 21 ++- sharing/nearby_sharing_service_impl.h | 2 +- sharing/paired_key_verification_runner.cc | 75 +++++------ sharing/paired_key_verification_runner.h | 20 +-- .../paired_key_verification_runner_test.cc | 127 +++++++----------- 6 files changed, 129 insertions(+), 145 deletions(-) diff --git a/sharing/BUILD b/sharing/BUILD index 572d64c9..5dc4578a 100644 --- a/sharing/BUILD +++ b/sharing/BUILD @@ -241,9 +241,33 @@ cc_test( ) cc_test( - name = "nearby_sharing_service_test", + name = "paired_key_verification_runner_test", size = "small", - timeout = "short", + srcs = ["paired_key_verification_runner_test.cc"], + deps = [ + ":nearby_sharing_service", + ":test_support", + ":types", + "//internal/platform/implementation/g3", # fixdeps: keep + "//internal/test", + "//proto:sharing_enums_cc_proto", + "//sharing/certificates", + "//sharing/certificates:test_support", + "//sharing/internal/public:logging", + "//sharing/internal/public:types", + "//sharing/internal/test:nearby_test", + "//sharing/proto:enums_cc_proto", + "//sharing/proto:share_cc_proto", + "//sharing/proto:wire_format_cc_proto", + "@com_github_protobuf_matchers//protobuf-matchers", + "@com_google_absl//absl/time", + "@com_google_googletest//:gtest_main", + ], +) + +cc_test( + name = "nearby_sharing_service_test", + size = "medium", srcs = [ "fake_nearby_connections_service.h", "incoming_frames_reader_test.cc", @@ -258,7 +282,6 @@ cc_test( "nearby_sharing_service_impl_test.cc", "nearby_sharing_service_test.cc", "nearby_sharing_settings_test.cc", - "paired_key_verification_runner_test.cc", "payload_tracker_test.cc", "share_target_test.cc", "text_attachment_test.cc", diff --git a/sharing/nearby_sharing_service_impl.cc b/sharing/nearby_sharing_service_impl.cc index e66a4ea2..9c3414c8 100644 --- a/sharing/nearby_sharing_service_impl.cc +++ b/sharing/nearby_sharing_service_impl.cc @@ -2690,7 +2690,7 @@ void NearbySharingServiceImpl::OnOutgoingConnection( info->endpoint_id())); RunPairedKeyVerification( - share_target, info->endpoint_id(), + share_target_id, info->endpoint_id(), [&, share_target, four_digit_token = std::move(four_digit_token)]( PairedKeyVerificationRunner::PairedKeyVerificationResult result, OSType remote_os_type) { @@ -3327,7 +3327,7 @@ void NearbySharingServiceImpl::OnIncomingDecryptedCertificate( nearby_connections_manager_->GetRawAuthenticationToken(endpoint_id)); RunPairedKeyVerification( - *share_target, endpoint_id, + share_target->id, endpoint_id, [&, share_target = *share_target, four_digit_token = std::move(four_digit_token)]( PairedKeyVerificationRunner::PairedKeyVerificationResult @@ -3340,7 +3340,7 @@ void NearbySharingServiceImpl::OnIncomingDecryptedCertificate( } void NearbySharingServiceImpl::RunPairedKeyVerification( - const ShareTarget& share_target, absl::string_view endpoint_id, + int64_t share_target_id, absl::string_view endpoint_id, std::function callback) { @@ -3356,21 +3356,20 @@ void NearbySharingServiceImpl::RunPairedKeyVerification( return; } - ShareTargetInfo* share_target_info = GetShareTargetInfo(share_target.id); + ShareTargetInfo* share_target_info = GetShareTargetInfo(share_target_id); NL_DCHECK(share_target_info); share_target_info->set_frames_reader(std::make_shared( context_, decoder_, share_target_info->connection())); - bool restrict_to_contacts = share_target.is_incoming && - settings_->GetVisibility() != - DeviceVisibility::DEVICE_VISIBILITY_EVERYONE; share_target_info->set_key_verification_runner( std::make_shared( - context_->GetClock(), device_info_, GetSettings(), share_target, - endpoint_id, *token, share_target_info->connection(), - share_target_info->certificate(), GetCertificateManager(), - restrict_to_contacts, share_target_info->frames_reader(), + context_->GetClock(), device_info_, share_target_id, + share_target_info->IsIncoming(), settings_->GetVisibility(), + settings_->GetLastVisibility(), + settings_->GetLastVisibilityTimestamp(), endpoint_id, *token, + share_target_info->connection(), share_target_info->certificate(), + GetCertificateManager(), share_target_info->frames_reader(), kReadFramesTimeout)); share_target_info->key_verification_runner()->Run(std::move(callback)); } diff --git a/sharing/nearby_sharing_service_impl.h b/sharing/nearby_sharing_service_impl.h index f3b644a1..35356319 100644 --- a/sharing/nearby_sharing_service_impl.h +++ b/sharing/nearby_sharing_service_impl.h @@ -350,7 +350,7 @@ class NearbySharingServiceImpl ShareTarget placeholder_share_target, std::optional certificate); void RunPairedKeyVerification( - const ShareTarget& share_target, absl::string_view endpoint_id, + int64_t share_target_id, absl::string_view endpoint_id, std::function< void(PairedKeyVerificationRunner::PairedKeyVerificationResult, ::location::nearby::proto::sharing::OSType)> diff --git a/sharing/paired_key_verification_runner.cc b/sharing/paired_key_verification_runner.cc index 4a18e419..c0552642 100644 --- a/sharing/paired_key_verification_runner.cc +++ b/sharing/paired_key_verification_runner.cc @@ -39,12 +39,10 @@ #include "sharing/incoming_frames_reader.h" #include "sharing/internal/public/logging.h" #include "sharing/nearby_connection.h" -#include "sharing/nearby_sharing_settings.h" #include "sharing/proto/enums.pb.h" #include "sharing/proto/rpc_resources.pb.h" #include "sharing/proto/timestamp.pb.h" #include "sharing/proto/wire_format.pb.h" -#include "sharing/share_target.h" namespace nearby { namespace sharing { @@ -116,42 +114,48 @@ std::ostream& operator<<( } PairedKeyVerificationRunner::PairedKeyVerificationRunner( - Clock* clock, DeviceInfo& device_info, - NearbyShareSettings* nearby_share_settings, const ShareTarget& share_target, + Clock* clock, DeviceInfo& device_info, int64_t share_target_id, + bool share_target_is_incoming, DeviceVisibility visibility, + DeviceVisibility last_visibility, absl::Time last_visibility_time, absl::string_view endpoint_id, const std::vector& token, NearbyConnection* connection, const std::optional& certificate, NearbyShareCertificateManager* certificate_manager, - bool restrict_to_contacts, IncomingFramesReader* frames_reader, - absl::Duration read_frame_timeout) + IncomingFramesReader* frames_reader, absl::Duration read_frame_timeout) : clock_(clock), device_info_(device_info), - nearby_share_settings_(nearby_share_settings), - share_target_(share_target), + share_target_id_(share_target_id), endpoint_id_(std::string(endpoint_id)), raw_token_(token), connection_(connection), certificate_(certificate), certificate_manager_(certificate_manager), - restrict_to_contacts_(restrict_to_contacts), frames_reader_(frames_reader), read_frame_timeout_(read_frame_timeout) { NL_DCHECK(clock_); - NL_DCHECK(nearby_share_settings); NL_DCHECK(connection); NL_DCHECK(certificate_manager); NL_DCHECK(frames_reader); - if (share_target.is_incoming) { + if (share_target_is_incoming) { local_prefix_ = kNearbyShareReceiverVerificationPrefix; remote_prefix_ = kNearbyShareSenderVerificationPrefix; + visibility_ = visibility; + last_visibility_ = last_visibility; + last_visibility_time_ = last_visibility_time; + // Receiver will try to re-validate signature using previous visibility if + // it has changed recently. relax_restrict_to_contacts_ = RelaxRestrictToContactsIfNeeded() || - nearby_share_settings_->GetVisibility() == - DeviceVisibility::DEVICE_VISIBILITY_EVERYONE; + visibility_ == DeviceVisibility::DEVICE_VISIBILITY_EVERYONE; } else { remote_prefix_ = kNearbyShareReceiverVerificationPrefix; local_prefix_ = kNearbyShareSenderVerificationPrefix; + // Sender always uses ALL_CONTACTS cert to sign and verify signature. + visibility_ = DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS; + last_visibility_ = DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS; + last_visibility_time_ = absl::UnixEpoch(); + relax_restrict_to_contacts_ = true; } } @@ -193,15 +197,16 @@ void PairedKeyVerificationRunner::OnReadPairedKeyEncryptionFrame( if (remote_public_certificate_result != PairedKeyVerificationResult::kSuccess) { - if (restrict_to_contacts_ && !relax_restrict_to_contacts_) { + if (!relax_restrict_to_contacts_) { NL_VLOG(1) << __func__ << ": we are only allowing connections with contacts. " "Rejecting connection from unknown ShareTarget - " - << share_target_.id; + << share_target_id_; + SendPairedKeyResultFrame(PairedKeyVerificationResult::kFail); std::move(callback_)(PairedKeyVerificationResult::kFail, OSType::UNKNOWN_OS_TYPE); return; - } else if (relax_restrict_to_contacts_) { + } else { remote_public_certificate_result = VerifyRemotePublicCertificateRelaxed(*frame); } @@ -291,18 +296,15 @@ void PairedKeyVerificationRunner::SendPairedKeyResultFrame( // Set OS type to allow remote device knowns the paring device OS type. result_frame->set_os_type(ToProtoOsType(device_info_.GetOsType())); - std::vector data(frame.ByteSize()); - frame.SerializeToArray(data.data(), frame.ByteSize()); + std::vector data(frame.ByteSizeLong()); + frame.SerializeToArray(data.data(), frame.ByteSizeLong()); connection_->Write(std::move(data)); } void PairedKeyVerificationRunner::SendPairedKeyEncryptionFrame() { - // This matches the behavior of CertificateManagerImpl.getFileNameByVisibility - // in Android. Sender always return all contacts visibility certificates. std::optional> signature = - certificate_manager_->SignWithPrivateCertificate( - DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, + certificate_manager_->SignWithPrivateCertificate(visibility_, PadPrefix(local_prefix_, raw_token_)); if (!signature.has_value() || signature->empty()) { signature = GenerateRandomBytes(kNearbyShareNumBytesRandomSignature); @@ -329,8 +331,7 @@ void PairedKeyVerificationRunner::SendPairedKeyEncryptionFrame() { << "Attempts to sign authentication token with a previous private key."; std::optional> optional_signature = certificate_manager_->SignWithPrivateCertificate( - DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, - PadPrefix(local_prefix_, raw_token_)); + last_visibility_, PadPrefix(local_prefix_, raw_token_)); if (optional_signature.has_value()) { encryption_frame->set_optional_signed_data(optional_signature->data(), @@ -339,8 +340,8 @@ void PairedKeyVerificationRunner::SendPairedKeyEncryptionFrame() { } encryption_frame->set_secret_id_hash(certificate_id_hash.data(), certificate_id_hash.size()); - std::vector data(frame.ByteSize()); - frame.SerializeToArray(data.data(), frame.ByteSize()); + std::vector data(frame.ByteSizeLong()); + frame.SerializeToArray(data.data(), frame.ByteSizeLong()); connection_->Write(std::move(data)); } @@ -348,15 +349,15 @@ void PairedKeyVerificationRunner::SendPairedKeyEncryptionFrame() { PairedKeyVerificationRunner::PairedKeyVerificationResult PairedKeyVerificationRunner::VerifyRemotePublicCertificate( const V1Frame& frame) { - return VerifyRemotePublicCertificateWithPrivateCertificate( - nearby_share_settings_->GetVisibility(), frame); + return VerifyRemotePublicCertificateWithPrivateCertificate(visibility_, + frame); } PairedKeyVerificationRunner::PairedKeyVerificationResult PairedKeyVerificationRunner::VerifyRemotePublicCertificateRelaxed( const nearby::sharing::service::proto::V1Frame& frame) { - return VerifyRemotePublicCertificateWithPrivateCertificate( - nearby_share_settings_->GetLastVisibility(), frame); + return VerifyRemotePublicCertificateWithPrivateCertificate(last_visibility_, + frame); } PairedKeyVerificationRunner::PairedKeyVerificationResult @@ -388,7 +389,7 @@ PairedKeyVerificationRunner::VerifyPairedKeyEncryptionFrame( if (!certificate_) { NL_VLOG(1) << __func__ << ": Unable to verify remote paired key encryption frame. " - "Certificate not found."; + "Remote side is not a known share target."; return PairedKeyVerificationResult::kUnable; } @@ -429,13 +430,6 @@ PairedKeyVerificationRunner::VerifyPairedKeyEncryptionFrame( } } - if (!share_target_.is_known) { - NL_LOG(INFO) << __func__ - << ": Unable to verify remote paired key encryption frame. " - "Remote side is not a known share target."; - return PairedKeyVerificationResult::kUnable; - } - NL_VLOG(1) << __func__ << ": Successfully verified remote paired key encryption frame."; return PairedKeyVerificationResult::kSuccess; @@ -456,9 +450,8 @@ PairedKeyVerificationRunner::MergeResults( } bool PairedKeyVerificationRunner::RelaxRestrictToContactsIfNeeded() const { - return share_target_.is_known && - (clock_->Now() - nearby_share_settings_->GetLastVisibilityTimestamp() < - kRelaxAfterSetVisibilityTimeout); + return certificate_.has_value() && (clock_->Now() - last_visibility_time_ < + kRelaxAfterSetVisibilityTimeout); } } // namespace sharing diff --git a/sharing/paired_key_verification_runner.h b/sharing/paired_key_verification_runner.h index 056e45c5..5680ccb8 100644 --- a/sharing/paired_key_verification_runner.h +++ b/sharing/paired_key_verification_runner.h @@ -35,7 +35,6 @@ #include "sharing/nearby_sharing_settings.h" #include "sharing/proto/enums.pb.h" #include "sharing/proto/wire_format.pb.h" -#include "sharing/share_target.h" namespace nearby { namespace sharing { @@ -55,14 +54,14 @@ class PairedKeyVerificationRunner }; PairedKeyVerificationRunner( - nearby::Clock* clock, nearby::DeviceInfo& device_info, - NearbyShareSettings* nearby_share_settings, - const ShareTarget& share_target, absl::string_view endpoint_id, - const std::vector& token, NearbyConnection* connection, + Clock* clock, DeviceInfo& device_info, int64_t share_target_id, + bool share_target_is_incoming, proto::DeviceVisibility visibility, + proto::DeviceVisibility last_visibility, absl::Time last_visibility_time, + absl::string_view endpoint_id, const std::vector& token, + NearbyConnection* connection, const std::optional& certificate, NearbyShareCertificateManager* certificate_manager, - bool restrict_to_contacts, IncomingFramesReader* frames_reader, - absl::Duration read_frame_timeout); + IncomingFramesReader* frames_reader, absl::Duration read_frame_timeout); ~PairedKeyVerificationRunner(); @@ -99,14 +98,15 @@ class PairedKeyVerificationRunner nearby::Clock* const clock_; nearby::DeviceInfo& device_info_; - NearbyShareSettings* nearby_share_settings_; - ShareTarget share_target_; + const int64_t share_target_id_; + proto::DeviceVisibility visibility_; + proto::DeviceVisibility last_visibility_; + absl::Time last_visibility_time_; std::string endpoint_id_; std::vector raw_token_; NearbyConnection* connection_; std::optional certificate_; NearbyShareCertificateManager* certificate_manager_; - bool restrict_to_contacts_ = false; IncomingFramesReader* frames_reader_; const absl::Duration read_frame_timeout_; std::function #include #include -#include #include #include #include @@ -28,9 +27,7 @@ #include "gmock/gmock.h" #include "protobuf-matchers/protocol-buffer-matchers.h" #include "gtest/gtest.h" -#include "absl/strings/string_view.h" #include "absl/time/time.h" -#include "internal/flags/nearby_flags.h" #include "internal/test/fake_clock.h" #include "internal/test/fake_device_info.h" #include "proto/sharing_enums.pb.h" @@ -38,16 +35,13 @@ #include "sharing/certificates/nearby_share_decrypted_public_certificate.h" #include "sharing/certificates/test_util.h" #include "sharing/fake_nearby_connection.h" -#include "sharing/flags/generated/nearby_sharing_feature_flags.h" #include "sharing/incoming_frames_reader.h" #include "sharing/internal/public/context.h" +#include "sharing/internal/public/logging.h" #include "sharing/internal/test/fake_context.h" -#include "sharing/internal/test/fake_preference_manager.h" -#include "sharing/local_device_data/nearby_share_local_device_data_manager.h" #include "sharing/nearby_connection.h" #include "sharing/nearby_sharing_decoder.h" #include "sharing/nearby_sharing_decoder_impl.h" -#include "sharing/nearby_sharing_settings.h" #include "sharing/proto/enums.pb.h" #include "sharing/proto/rpc_resources.pb.h" #include "sharing/proto/wire_format.pb.h" @@ -127,30 +121,6 @@ std::list GeneratePairedKeyResultFrame() { const absl::Duration kTimeout = absl::Seconds(1); -class MockNearbyShareLocalDeviceDataManager - : public NearbyShareLocalDeviceDataManager { - public: - MOCK_METHOD(std::string, GetId, (), (override)); - MOCK_METHOD(std::string, GetDeviceName, (), (override, const)); - MOCK_METHOD(std::optional, GetFullName, (), (override, const)); - MOCK_METHOD(std::optional, GetIconUrl, (), (override, const)); - MOCK_METHOD(DeviceNameValidationResult, ValidateDeviceName, - (absl::string_view), (override)); - MOCK_METHOD(DeviceNameValidationResult, SetDeviceName, (absl::string_view), - (override)); - MOCK_METHOD(void, DownloadDeviceData, (), (override)); - MOCK_METHOD(void, UploadContacts, - (std::vector, - UploadCompleteCallback), - (override)); - MOCK_METHOD(void, UploadCertificates, - (std::vector, - UploadCompleteCallback), - (override)); - MOCK_METHOD(void, OnStart, (), (override)); - MOCK_METHOD(void, OnStop, (), (override)); -}; - class MockIncomingFramesReader : public IncomingFramesReader { public: MockIncomingFramesReader(Context* context, NearbySharingDecoder* decoder, @@ -205,17 +175,14 @@ class PairedKeyVerificationRunnerTest : public testing::Test { : frames_reader_(&context_, &decoder_, &connection_) {} void SetUp() override { - nearby_share_settings_ = std::make_unique( - &context_, context_.GetClock(), fake_device_info_, preference_manager_, - &local_device_data_manager_); - nearby_share_settings_->SetVisibility( - DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS); - FastForward(absl::Minutes(15)); + GetFakeClock()->FastForward(absl::Minutes(15)); share_target_.is_incoming = true; } void RunVerification( - bool use_valid_public_certificate, bool restricted_to_contacts, + bool is_incoming, + bool use_valid_public_certificate, DeviceVisibility visibility, + DeviceVisibility last_visibility, absl::Time last_visibility_time, PairedKeyVerificationRunner::PairedKeyVerificationResult expected_result, OSType expected_os_type = OSType::UNKNOWN_OS_TYPE) { std::optional public_certificate = @@ -225,10 +192,11 @@ class PairedKeyVerificationRunnerTest : public testing::Test { : std::nullopt; auto runner = std::make_shared( - context_.GetClock(), fake_device_info_, nearby_share_settings_.get(), - share_target_, kEndpointId, GetAuthToken(), &connection_, - std::move(public_certificate), &certificate_manager_, - restricted_to_contacts, &frames_reader_, kTimeout); + context_.GetClock(), fake_device_info_, share_target_.id, + is_incoming, visibility, last_visibility, + last_visibility_time, kEndpointId, GetAuthToken(), &connection_, + std::move(public_certificate), &certificate_manager_, &frames_reader_, + kTimeout); runner->Run( [&, expected_result, expected_os_type]( @@ -274,9 +242,6 @@ class PairedKeyVerificationRunnerTest : public testing::Test { encryption_frame->set_secret_id_hash( GetPrivateCertificateHashAuthToken().data(), GetPrivateCertificateHashAuthToken().size()); - // make sure the optional codes are executed - nearby_share_settings_->SetVisibility( - DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS); } else if (frame_type == ReturnFrameType::kInValid) { nearby::sharing::service::proto::PairedKeyEncryptionFrame* encryption_frame = frame.mutable_paired_key_encryption(); @@ -339,8 +304,6 @@ class PairedKeyVerificationRunnerTest : public testing::Test { ASSERT_TRUE(frame.v1().has_paired_key_encryption()); } - void ExpectCertificateInfoSent() {} - void ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::Status status) { nearby::sharing::service::proto::Frame frame = GetWrittenFrame(); ASSERT_TRUE(frame.has_v1()); @@ -348,24 +311,18 @@ class PairedKeyVerificationRunnerTest : public testing::Test { EXPECT_EQ(status, frame.v1().paired_key_result().status()); } - void FastForward(absl::Duration duration) { - context_.fake_clock()->FastForward(duration); - } + FakeClock* GetFakeClock() { return context_.fake_clock(); } protected: ShareTarget share_target_; private: - nearby::FakePreferenceManager preference_manager_; FakeDeviceInfo fake_device_info_; FakeContext context_; FakeNearbyConnection connection_; NearbySharingDecoderImpl decoder_; testing::NiceMock frames_reader_; FakeNearbyShareCertificateManager certificate_manager_; - ::testing::NiceMock - local_device_data_manager_; - std::unique_ptr nearby_share_settings_; }; TEST_F(PairedKeyVerificationRunnerTest, @@ -374,8 +331,11 @@ TEST_F(PairedKeyVerificationRunnerTest, SetUpPairedKeyEncryptionFrame(ReturnFrameType::kEmpty); RunVerification( + share_target_.is_incoming, /*use_valid_public_certificate=*/false, - /*restricted_to_contacts=*/true, + DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, + DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, + GetFakeClock()->Now(), /*expected_result=*/ PairedKeyVerificationResult::kFail); @@ -390,36 +350,42 @@ TEST_F(PairedKeyVerificationRunnerTest, SetUpPairedKeyResultFrame(ReturnFrameType::kNull); RunVerification( + share_target_.is_incoming, /*use_valid_public_certificate=*/true, - /*restricted_to_contacts=*/false, + DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, + DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, + GetFakeClock()->Now(), /*expected_result=*/ PairedKeyVerificationResult::kFail); ExpectPairedKeyEncryptionFrameSent(); - ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::UNABLE); + ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::SUCCESS); } struct TestParameters { - bool is_target_known; - bool is_valid_certificate; + bool is_incoming; + bool has_valid_certificate; PairedKeyVerificationRunnerTest::ReturnFrameType encryption_frame_type; PairedKeyVerificationRunner::PairedKeyVerificationResult result; } kParameters[] = { - {true, true, PairedKeyVerificationRunnerTest::ReturnFrameType::kValid, - PairedKeyVerificationRunner::PairedKeyVerificationResult::kSuccess}, {true, true, PairedKeyVerificationRunnerTest::ReturnFrameType::kEmpty, PairedKeyVerificationRunner::PairedKeyVerificationResult::kFail}, - {true, false, PairedKeyVerificationRunnerTest::ReturnFrameType::kValid, - PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, - {true, false, PairedKeyVerificationRunnerTest::ReturnFrameType::kEmpty, - PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, - {false, true, PairedKeyVerificationRunnerTest::ReturnFrameType::kValid, - PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, + {true, true, PairedKeyVerificationRunnerTest::ReturnFrameType::kValid, + PairedKeyVerificationRunner::PairedKeyVerificationResult::kSuccess}, {true, true, PairedKeyVerificationRunnerTest::ReturnFrameType::kOptionalValid, PairedKeyVerificationRunner::PairedKeyVerificationResult::kSuccess}, {true, true, PairedKeyVerificationRunnerTest::ReturnFrameType::kInValid, PairedKeyVerificationRunner::PairedKeyVerificationResult::kFail}, + {true, false, PairedKeyVerificationRunnerTest::ReturnFrameType::kEmpty, + PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, + {true, false, PairedKeyVerificationRunnerTest::ReturnFrameType::kValid, + PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, + {true, false, + PairedKeyVerificationRunnerTest::ReturnFrameType::kOptionalValid, + PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, + {true, false, PairedKeyVerificationRunnerTest::ReturnFrameType::kInValid, + PairedKeyVerificationRunner::PairedKeyVerificationResult::kUnable}, }; using KeyVerificationTestParam = @@ -436,7 +402,14 @@ TEST_P(ParameterisedPairedKeyVerificationRunnerTest, PairedKeyVerificationRunner::PairedKeyVerificationResult expected_result = Merge(params.result, result_frame.status()); - share_target_.is_known = params.is_target_known; + NL_LOG(ERROR) << "ValidEncryptionFrame_ValidResultFrame: " << "is_incoming=" + << params.is_incoming + << ", has_valid_cert=" << params.has_valid_certificate + << ", encryption_frame_type=" + << (int)params.encryption_frame_type + << ", result=" << (int)params.result + << ", expected_result=" << (int)expected_result + << ", result_frame=" << (int)result_frame.status(); SetUpPairedKeyEncryptionFrame(params.encryption_frame_type); SetUpPairedKeyResultFrame( @@ -446,18 +419,18 @@ TEST_P(ParameterisedPairedKeyVerificationRunnerTest, : OSType::UNKNOWN_OS_TYPE); RunVerification( - /*use_valid_public_certificate=*/params.is_valid_certificate, - /*restricted_to_contacts=*/false, expected_result, + /*is_incoming=*/params.is_incoming, + /*use_valid_public_certificate=*/params.has_valid_certificate, + DeviceVisibility::DEVICE_VISIBILITY_EVERYONE, + DeviceVisibility::DEVICE_VISIBILITY_ALL_CONTACTS, + GetFakeClock()->Now(), expected_result, result_frame.has_os_type() ? result_frame.os_type() : OSType::UNKNOWN_OS_TYPE); ExpectPairedKeyEncryptionFrameSent(); - if (params.encryption_frame_type == - PairedKeyVerificationRunnerTest::ReturnFrameType::kValid) - ExpectCertificateInfoSent(); // Check for result frame sent. - if (!params.is_valid_certificate) { + if (!params.has_valid_certificate) { ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::UNABLE); return; } @@ -474,11 +447,7 @@ TEST_P(ParameterisedPairedKeyVerificationRunnerTest, return; } - if (params.is_target_known) { - ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::SUCCESS); - } else { - ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::UNABLE); - } + ExpectPairedKeyResultFrameSent(PairedKeyResultFrame::SUCCESS); } INSTANTIATE_TEST_SUITE_P(