TySS-Dev/nearby
1
0
Fork 0
mirror of https://github.com/kidfromjupiter/nearby.git synced 2026-09-16 15:36:12 -04:00
Code Issues Packages Projects Releases Wiki Activity

Fix paired key verifiation error.

Browse Source 
PiperOrigin-RevId: 619418705
This commit is contained in:
Francis Tsui
2024-03-26 22:38:08 -07:00
committed by Copybara-Service
parent 5bc1c83472
commit 40e4966ab5
6 changed files with 129 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
sharing/BUILD
+26 -3
View File
@@ -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",
sharing/nearby_sharing_service_impl.cc
+10 -11
View File
@@ -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<void(PairedKeyVerificationRunner::PairedKeyVerificationResult,
OSType)>
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<IncomingFramesReader>(
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<PairedKeyVerificationRunner>(
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));
}
sharing/nearby_sharing_service_impl.h
+1 -1
View File
@@ -350,7 +350,7 @@ class NearbySharingServiceImpl
ShareTarget placeholder_share_target,
std::optional<NearbyShareDecryptedPublicCertificate> 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)>
sharing/paired_key_verification_runner.cc
+34 -41
View File
@@ -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<uint8_t>& token,
NearbyConnection* connection,
const std::optional<NearbyShareDecryptedPublicCertificate>& 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<uint8_t> data(frame.ByteSize());
frame.SerializeToArray(data.data(), frame.ByteSize());
std::vector<uint8_t> 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<std::vector<uint8_t>> 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<std::vector<uint8_t>> 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<uint8_t> data(frame.ByteSize());
frame.SerializeToArray(data.data(), frame.ByteSize());
std::vector<uint8_t> 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
sharing/paired_key_verification_runner.h
+10 -10
View File
@@ -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<uint8_t>& 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<uint8_t>& token,
NearbyConnection* connection,
const std::optional<NearbyShareDecryptedPublicCertificate>& 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<uint8_t> raw_token_;
NearbyConnection* connection_;
std::optional<NearbyShareDecryptedPublicCertificate> certificate_;
NearbyShareCertificateManager* certificate_manager_;
bool restrict_to_contacts_ = false;
IncomingFramesReader* frames_reader_;
const absl::Duration read_frame_timeout_;
std::function<void(PairedKeyVerificationResult,
sharing/paired_key_verification_runner_test.cc
+48 -79
View File
@@ -20,7 +20,6 @@
#include <list>
#include <memory>
#include <optional>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
@@ -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<PairedKeyResultFrame> 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<std::string>, GetFullName, (), (override, const));
MOCK_METHOD(std::optional<std::string>, 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<nearby::sharing::proto::Contact>,
UploadCompleteCallback),
(override));
MOCK_METHOD(void, UploadCertificates,
(std::vector<nearby::sharing::proto::PublicCertificate>,
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<NearbyShareSettings>(
&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<NearbyShareDecryptedPublicCertificate> public_certificate =
@@ -225,10 +192,11 @@ class PairedKeyVerificationRunnerTest : public testing::Test {
: std::nullopt;
auto runner = std::make_shared<PairedKeyVerificationRunner>(
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<MockIncomingFramesReader> frames_reader_;
FakeNearbyShareCertificateManager certificate_manager_;
::testing::NiceMock<MockNearbyShareLocalDeviceDataManager>
local_device_data_manager_;
std::unique_ptr<NearbyShareSettings> 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(