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

Metadata to DeviceIdentityMetaData Migration

Browse Source 
PiperOrigin-RevId: 616182462
This commit is contained in:
Suet-Fei Li
2024-03-15 10:57:58 -07:00
committed by Copybara-Service
parent 33e682f244
commit 989efcf2c5
22 changed files with 391 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files
presence/implementation/credential_manager.h
+12 -13
View File
@@ -19,7 +19,6 @@
#include <string>
#include <vector>
#include "absl/status/statusor.h"
#include "absl/strings/string_view.h"
#include "internal/platform/implementation/credential_callbacks.h"
#include "internal/proto/credential.pb.h"
@@ -47,7 +46,7 @@ class CredentialManager {
// The user’s own public credentials won’t be saved on local credential
// storage.
virtual void GenerateCredentials(
const nearby::internal::Metadata& metadata,
const nearby::internal::DeviceIdentityMetaData& device_identity_metadata,
absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
@@ -91,23 +90,23 @@ class CredentialManager {
// `UnsubscribeFromPublicCredentials()` return.
virtual void UnsubscribeFromPublicCredentials(SubscriberId id) = 0;
// Decrypts the device metadata from a public credential.
// Decrypts the device identity metadata from a public credential.
// Returns an empty string if decryption fails.
virtual std::string DecryptMetadata(absl::string_view metadata_encryption_key,
absl::string_view key_seed,
absl::string_view metadata_string) = 0;
virtual std::string DecryptDeviceIdentityMetaData(
absl::string_view metadata_encryption_key, absl::string_view key_seed,
absl::string_view metadata_string) = 0;
// Sets the NP service's device metadata, regenerating credentials if
// `regen_credentials` is set to true.
virtual void SetLocalDeviceMetadata(
const ::nearby::internal::Metadata& metadata, bool regen_credentials,
absl::string_view manager_app_id,
// If `regen_credentials` is set to true, regenerating credentials.
virtual void SetDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) = 0;
// Gets the NP service's device metadata.
virtual ::nearby::internal::Metadata GetLocalDeviceMetadata() = 0;
virtual ::nearby::internal::DeviceIdentityMetaData
GetDeviceIdentityMetaData() = 0;
};
} // namespace presence
presence/implementation/credential_manager_impl.cc
+29 -22
View File
@@ -66,6 +66,10 @@ using ::nearby::internal::SharedCredential;
// Key to retrieve local device's Private/Public Key Credentials from key store.
constexpr char kPairedKeyAliasPrefix[] = "nearby_presence_paired_key_alias_";
// Use an empty string because Chromium only supports 1 account.
// Windows & Apple will have their own Identity Provider.
constexpr absl::string_view kEmptyAccountName = "";
// The expected number of valid local credentials to be stored on local device.
constexpr int kExpectedValidLocalCredtialSize = 6;
// The expiration time in days for a credential.
@@ -87,7 +91,8 @@ std::string CustomizeBytesSize(absl::string_view bytes, size_t len) {
} // namespace
void CredentialManagerImpl::GenerateCredentials(
const Metadata& metadata, absl::string_view manager_app_id,
const DeviceIdentityMetaData& device_identity_metadata,
absl::string_view manager_app_id,
const std::vector<IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) {
@@ -98,8 +103,9 @@ void CredentialManagerImpl::GenerateCredentials(
absl::Time start_time = SystemClock::ElapsedRealtime();
absl::Duration gap = credential_life_cycle_days * absl::Hours(24);
for (int index = 0; index < contiguous_copy_of_credentials; index++) {
auto public_private_credentials = CreateLocalCredential(
metadata, identity_type, start_time, start_time + gap);
auto public_private_credentials =
CreateLocalCredential(device_identity_metadata, identity_type,
start_time, start_time + gap);
if (public_private_credentials.second.identity_type() !=
IdentityType::IDENTITY_TYPE_UNSPECIFIED) {
private_credentials.push_back(public_private_credentials.first);
@@ -111,12 +117,12 @@ void CredentialManagerImpl::GenerateCredentials(
// Create credential_storage object and invoke SaveCredentials.
credential_storage_ptr_->SaveCredentials(
manager_app_id, metadata.account_name(), private_credentials,
manager_app_id, kEmptyAccountName, private_credentials,
public_credentials, PublicCredentialType::kLocalPublicCredential,
SaveCredentialsResultCallback{
.credentials_saved_cb =
[this, manager_app_id = std::string(manager_app_id),
account_name = metadata.account_name(),
account_name = kEmptyAccountName,
callback = std::move(credentials_generated_cb),
public_credentials](absl::Status status) mutable {
if (!status.ok()) {
@@ -171,10 +177,9 @@ void CredentialManagerImpl::UpdateRemotePublicCredentials(
}
std::pair<LocalCredential, SharedCredential>
CredentialManagerImpl::CreateLocalCredential(const Metadata& metadata,
IdentityType identity_type,
absl::Time start_time,
absl::Time end_time) {
CredentialManagerImpl::CreateLocalCredential(
const DeviceIdentityMetaData& device_identity_metadata,
IdentityType identity_type, absl::Time start_time, absl::Time end_time) {
LocalCredential private_credential;
private_credential.set_start_time_millis(absl::ToUnixMillis(start_time));
private_credential.set_end_time_millis(absl::ToUnixMillis(end_time));
@@ -204,7 +209,7 @@ CredentialManagerImpl::CreateLocalCredential(const Metadata& metadata,
key_pair->ExportPrivateKey(&private_key);
private_credential.mutable_connection_signing_key()->set_key(
std::string(private_key.begin(), private_key.end()));
// Create an AES key to encrypt the device metadata.
// Create an AES key to encrypt the device identity metadata.
std::string metadata_key(kBaseMetadataSize, 0);
crypto::RandBytes(const_cast<std::string::value_type*>(metadata_key.data()),
metadata_key.size());
@@ -216,11 +221,13 @@ CredentialManagerImpl::CreateLocalCredential(const Metadata& metadata,
return std::pair<LocalCredential, SharedCredential>(
private_credential,
CreatePublicCredential(private_credential, metadata, public_key));
CreatePublicCredential(private_credential, device_identity_metadata,
public_key));
}
SharedCredential CredentialManagerImpl::CreatePublicCredential(
const LocalCredential& private_credential, const Metadata& metadata,
const LocalCredential& private_credential,
const DeviceIdentityMetaData& device_identity_metadata,
const std::vector<uint8_t>& public_key) {
// The start time in the public credential should be decreased by a random
// value in 0 - 3 hours range.
@@ -248,13 +255,13 @@ SharedCredential CredentialManagerImpl::CreatePublicCredential(
public_credential.set_metadata_encryption_key_tag_v0(
std::string(metadata_encryption_key_tag.AsStringView()));
// Encrypt the device metadata
auto encrypted_meta_data = EncryptMetadata(
auto encrypted_meta_data = EncryptDeviceIdentityMetaData(
private_credential.metadata_encryption_key_v0(),
private_credential.key_seed(), metadata.SerializeAsString());
private_credential.key_seed(),
device_identity_metadata.SerializeAsString());
if (encrypted_meta_data.empty()) {
NEARBY_LOGS(ERROR) << "Fails to encrypt the device metadata.";
NEARBY_LOGS(ERROR) << "Fails to encrypt the device identity metadata.";
public_credential.set_identity_type(
IdentityType::IDENTITY_TYPE_UNSPECIFIED);
return public_credential;
@@ -264,7 +271,7 @@ SharedCredential CredentialManagerImpl::CreatePublicCredential(
return public_credential;
}
std::string CredentialManagerImpl::DecryptMetadata(
std::string CredentialManagerImpl::DecryptDeviceIdentityMetaData(
absl::string_view metadata_encryption_key, absl::string_view key_seed,
absl::string_view metadata_string) {
crypto::Aead aead(crypto::Aead::AeadAlgorithm::AES_256_GCM);
@@ -286,7 +293,7 @@ std::string CredentialManagerImpl::DecryptMetadata(
return std::string(result.value().begin(), result.value().end());
}
std::string CredentialManagerImpl::EncryptMetadata(
std::string CredentialManagerImpl::EncryptDeviceIdentityMetaData(
absl::string_view metadata_encryption_key, absl::string_view key_seed,
absl::string_view metadata_string) {
crypto::Aead aead(crypto::Aead::AeadAlgorithm::AES_256_GCM);
@@ -644,9 +651,9 @@ void CredentialManagerImpl::CheckCredentialsAndRefillIfNeeded(
auto gap = kCredentialLifeCycleDays * absl::Hours(24);
for (int i = 0; i < kExpectedValidLocalCredtialSize - valid_credentials_count;
i++) {
auto pair =
CreateLocalCredential(metadata_, credential_selector.identity_type,
start_time, start_time + gap);
auto pair = CreateLocalCredential(device_identity_metadata_,
credential_selector.identity_type,
start_time, start_time + gap);
newly_generated_local_credentials.push_back(pair.first);
newly_generated_shared_credentials.push_back(pair.second);
start_time += gap;
@@ -721,7 +728,7 @@ void CredentialManagerImpl::CheckCredentialsAndRefillIfNeeded(
}
}
// Now merge newly generated credentails to already existing valid ones.
// Now merge newly generated credentials to already existing valid ones.
valid_local_credentials.insert(valid_local_credentials.end(),
newly_generated_local_credentials.begin(),
newly_generated_local_credentials.end());
presence/implementation/credential_manager_impl.h
+26 -21
View File
@@ -43,7 +43,7 @@ namespace presence {
class CredentialManagerImpl : public CredentialManager {
public:
using IdentityType = ::nearby::internal::IdentityType;
using Metadata = ::nearby::internal::Metadata;
using DeviceIdentityMetaData = ::nearby::internal::DeviceIdentityMetaData;
explicit CredentialManagerImpl(SingleThreadExecutor* executor)
: executor_(ABSL_DIE_IF_NULL(executor)) {
@@ -67,7 +67,8 @@ class CredentialManagerImpl : public CredentialManager {
static constexpr int kAesGcmIVSize = 12;
void GenerateCredentials(
const Metadata& metadata, absl::string_view manager_app_id,
const DeviceIdentityMetaData& device_identity_metadata,
absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) override;
@@ -111,43 +112,47 @@ class CredentialManagerImpl : public CredentialManager {
void UnsubscribeFromPublicCredentials(SubscriberId id) override;
std::string DecryptMetadata(absl::string_view metadata_encryption_key,
absl::string_view key_seed,
absl::string_view metadata_string) override;
std::string DecryptDeviceIdentityMetaData(
absl::string_view metadata_encryption_key, absl::string_view key_seed,
absl::string_view metadata_string) override;
std::pair<nearby::internal::LocalCredential,
nearby::internal::SharedCredential>
CreateLocalCredential(const Metadata& metadata, IdentityType identity_type,
absl::Time start_time, absl::Time end_time);
CreateLocalCredential(const DeviceIdentityMetaData& device_identity_metadata,
IdentityType identity_type, absl::Time start_time,
absl::Time end_time);
nearby::internal::SharedCredential CreatePublicCredential(
const nearby::internal::LocalCredential& private_credential,
const Metadata& metadata, const std::vector<uint8_t>& public_key);
const DeviceIdentityMetaData& device_identity_metadata,
const std::vector<uint8_t>& public_key);
virtual std::string EncryptMetadata(absl::string_view metadata_encryption_key,
absl::string_view key_seed,
absl::string_view metadata_string);
virtual std::string EncryptDeviceIdentityMetaData(
absl::string_view metadata_encryption_key, absl::string_view key_seed,
absl::string_view metadata_string);
// Extend the key from 16 bytes to 32 bytes.
std::vector<uint8_t> ExtendMetadataEncryptionKey(
absl::string_view metadata_encryption_key);
void SetLocalDeviceMetadata(
const Metadata& metadata, bool regen_credentials,
absl::string_view manager_app_id,
void SetDeviceIdentityMetaData(
const DeviceIdentityMetaData& device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) override {
metadata_ = metadata;
device_identity_metadata_ = device_identity_metadata;
if (regen_credentials) {
GenerateCredentials(
metadata, manager_app_id, identity_types, credential_life_cycle_days,
contiguous_copy_of_credentials, std::move(credentials_generated_cb));
GenerateCredentials(device_identity_metadata, manager_app_id,
identity_types, credential_life_cycle_days,
contiguous_copy_of_credentials,
std::move(credentials_generated_cb));
}
}
::nearby::internal::Metadata GetLocalDeviceMetadata() override {
return metadata_;
::nearby::internal::DeviceIdentityMetaData GetDeviceIdentityMetaData()
override {
return device_identity_metadata_;
}
private:
@@ -231,7 +236,7 @@ class CredentialManagerImpl : public CredentialManager {
ABSL_GUARDED_BY(*executor_);
SingleThreadExecutor* executor_;
std::unique_ptr<nearby::CredentialStorageImpl> credential_storage_ptr_;
Metadata metadata_;
DeviceIdentityMetaData device_identity_metadata_;
};
} // namespace presence
presence/implementation/credential_manager_impl_test.cc
+74 -84
View File
@@ -45,7 +45,8 @@ using ::nearby::Crypto;
using ::nearby::MediumEnvironment;
using ::nearby::internal::IdentityType;
using ::nearby::internal::LocalCredential;
using ::nearby::internal::Metadata;
using ::nearby::internal::DeviceIdentityMetaData;
using ::nearby::internal::SharedCredential;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE;
using ::nearby::internal::IdentityType::IDENTITY_TYPE_TRUSTED;
@@ -54,17 +55,18 @@ using ::testing::UnorderedPointwise;
using ::testing::status::StatusIs;
constexpr absl::string_view kManagerAppId = "TEST_MANAGER_APP";
constexpr absl::string_view kAccountName = "test account";
constexpr absl::string_view kAccountName = "";
constexpr int kExpectedPresenceCredentialListSize = 6;
constexpr int kExpectedPresenceCredentialValidDays = 5;
Metadata CreateTestMetadata(absl::string_view account_name = kAccountName) {
Metadata metadata;
metadata.set_account_name(account_name);
metadata.set_device_name("NP test device");
metadata.set_device_profile_url("test_image.test.com");
metadata.set_bluetooth_mac_address("FF:FF:FF:FF:FF:FF");
return metadata;
DeviceIdentityMetaData CreateTestDeviceIdentityMetaData() {
DeviceIdentityMetaData device_identity_metadata;
device_identity_metadata.set_device_type(
internal::DeviceType::DEVICE_TYPE_PHONE);
device_identity_metadata.set_device_name("NP test device");
device_identity_metadata.set_bluetooth_mac_address("FF:FF:FF:FF:FF:FF");
device_identity_metadata.set_device_id("\x12\xab\xcd");
return device_identity_metadata;
}
CredentialSelector BuildDefaultCredentialSelector() {
@@ -99,7 +101,7 @@ class CredentialManagerImplTest : public ::testing::Test {
public:
explicit MockCredentialManager(SingleThreadExecutor* executor)
: CredentialManagerImpl(executor) {}
MOCK_METHOD(std::string, EncryptMetadata,
MOCK_METHOD(std::string, EncryptDeviceIdentityMetaData,
(absl::string_view metadata_encryption_key,
absl::string_view key_seed, absl::string_view metadata_string),
(override));
@@ -124,22 +126,23 @@ class CredentialManagerImplTest : public ::testing::Test {
absl::string_view account_name,
IdentityType identity_type) {
auto public_credentials = GenerateCredentialsSync(
CreateTestMetadata(account_name), manager_app_id, {identity_type},
CreateTestDeviceIdentityMetaData(), manager_app_id, {identity_type},
/*credential_life_cycle_days=*/kExpectedPresenceCredentialValidDays,
/*contiguous_copy_of_credentials=*/1);
EXPECT_OK(public_credentials);
}
absl::StatusOr<std::vector<SharedCredential>> GenerateCredentialsSync(
const Metadata& metadata, absl::string_view manager_app_id,
const DeviceIdentityMetaData& device_identity_metadata,
absl::string_view manager_app_id,
const std::vector<IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials) {
absl::StatusOr<std::vector<SharedCredential>> public_credentials;
CountDownLatch latch(1);
credential_manager_.GenerateCredentials(
metadata, manager_app_id, identity_types, credential_life_cycle_days,
contiguous_copy_of_credentials,
device_identity_metadata, manager_app_id, identity_types,
credential_life_cycle_days, contiguous_copy_of_credentials,
{.credentials_generated_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
public_credentials = credentials;
@@ -174,12 +177,12 @@ class CredentialManagerImplTest : public ::testing::Test {
};
TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
constexpr absl::Time kStartTime = absl::FromUnixSeconds(100000);
constexpr absl::Time kEndTime = absl::FromUnixSeconds(200000);
auto credentials = credential_manager_.CreateLocalCredential(
metadata, IDENTITY_TYPE_PRIVATE, kStartTime, kEndTime);
device_identity_metadata, IDENTITY_TYPE_PRIVATE, kStartTime, kEndTime);
LocalCredential private_credential = credentials.first;
// Verify the private credential.
@@ -213,26 +216,24 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) {
public_credential.connection_signature_verification_key().empty());
EXPECT_FALSE(public_credential.encrypted_metadata_bytes_v0().empty());
// Decrypt the device metadata
auto decrypted_metadata = credential_manager_.DecryptMetadata(
auto decrypted_metadata = credential_manager_.DecryptDeviceIdentityMetaData(
private_credential.metadata_encryption_key_v0(),
public_credential.key_seed(),
public_credential.encrypted_metadata_bytes_v0());
EXPECT_EQ(metadata.SerializeAsString(), decrypted_metadata);
EXPECT_EQ(device_identity_metadata.SerializeAsString(), decrypted_metadata);
}
TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE};
absl::Time previous_start_time;
absl::Time previous_end_time;
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identityTypes,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identityTypes,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
EXPECT_OK(public_credentials);
EXPECT_EQ(public_credentials->size(), kExpectedPresenceCredentialListSize);
@@ -341,7 +342,7 @@ TEST_F(CredentialManagerImplTest, NoCallbacksAfterUnsubscribe) {
TEST_F(CredentialManagerImplTest,
GenerateCredentialsSuccessfullyButStoreFailed) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
auto credential_storage_ptr =
std::make_unique<CredentialManagerImplTest::MockCredentialStorage>();
EXPECT_CALL(*credential_storage_ptr, SaveCredentials)
@@ -358,10 +359,10 @@ TEST_F(CredentialManagerImplTest,
CredentialManagerImpl(&executor_, std::move(credential_storage_ptr));
std::vector<IdentityType> identityTypes{IDENTITY_TYPE_PRIVATE};
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identityTypes,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identityTypes,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
EXPECT_THAT(public_credentials,
StatusIs(absl::StatusCode::kFailedPrecondition));
}
@@ -472,14 +473,14 @@ TEST_F(CredentialManagerImplTest, GetPublicCredentialsFailed) {
}
TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
EXPECT_OK(public_credentials);
EXPECT_EQ(public_credentials->size(), kExpectedPresenceCredentialListSize);
@@ -488,12 +489,12 @@ TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) {
}
TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
absl::StatusOr<std::vector<SharedCredential>> public_credentials;
auto credential_manager_ptr =
std::make_unique<CredentialManagerImplTest::MockCredentialManager>(
&executor_);
EXPECT_CALL(*credential_manager_ptr, EncryptMetadata)
EXPECT_CALL(*credential_manager_ptr, EncryptDeviceIdentityMetaData)
.WillOnce(::testing::Invoke(
[](absl::string_view metadata_encryption_key,
absl::string_view key_seed,
@@ -502,7 +503,7 @@ TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) {
CountDownLatch latch(1);
credential_manager_ptr->GenerateCredentials(
metadata, kManagerAppId, identity_types,
device_identity_metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays, 1,
{.credentials_generated_cb =
[&](absl::StatusOr<std::vector<SharedCredential>> credentials) {
@@ -518,14 +519,14 @@ TEST_F(CredentialManagerImplTest, UpdateLocalCredential) {
constexpr int kSelectedCredentialId = 2;
constexpr uint16_t kSalt = 1000;
absl::Status update_status = absl::UnknownError("");
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE,
IDENTITY_TYPE_TRUSTED};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
auto private_credentials = GetLocalCredentialsSync(credential_selector);
EXPECT_EQ(kExpectedPresenceCredentialListSize, private_credentials.size());
@@ -553,47 +554,36 @@ TEST_F(CredentialManagerImplTest, UpdateLocalCredential) {
.at(kSalt));
}
TEST_F(CredentialManagerImplTest, ParseAndroidSharedCredential) {
// This SharedCredential and Metadata were generated on Android.
constexpr absl::string_view kSharedCredentialBase16 =
"0A20C8B6DB66CBA77E8CF0286A78574D1F7EADF3C3DAA3E26DAB048FD5481B4FBA7A1220"
"E809E7805FC6AB8226A4CCA9FAEA5FDDE49EE07E7D5905CCB6AA0F779069F2A818D088D4"
"EADE3020B093BEBDE0302A56E1CAE889FC26B8FBF399C86BEB8D7AB84EE476EF2E75B465"
"773A957BDEAD6732FCD74BFFC363BE068CCD9109108AAE5274C861675F3E7E0E524C4A75"
"11DC9F669FCAC072EE70062B00AEA4A736454FC1CAAE6F8D62843220D563DF856310428E"
"FE6D8B6FBD74FB9C4E762323782494D0E2DF6FEA118E17B13A5B3059301306072A8648CE"
"3D020106082A8648CE3D03010703420004169A965ACFCAE31B031147A0169823B4B6926D"
"7AA86E50CABB5F6100F6992D5C1769FC629F0F789B7B39525DA4A33FC2438A074DC1EEC0"
"21B1AA4FD2122DC5044801";
TEST_F(CredentialManagerImplTest, EncryptAndDecryptDeviceIdentityMetaData) {
constexpr absl::string_view kMetadataEncryptionKeyBase16 =
"6331578C6E244074111B2ED0BBDB";
constexpr absl::string_view kMetadataBase16 =
"08011A137363616E6E657220646576696365206E616D6522137363616E6E657220706572"
"736F6E206E616D652A107363616E6E65722069636F6E2075726C3206AABBCCDDEEFF";
SharedCredential shared_credential;
Metadata expected_metadata;
constexpr absl::string_view kSeed = "123456";
ASSERT_TRUE(shared_credential.ParseFromString(
absl::HexStringToBytes(kSharedCredentialBase16)));
ASSERT_TRUE(expected_metadata.ParseFromString(
absl::HexStringToBytes(kMetadataBase16)));
std::string decrypted_metadata = credential_manager_.DecryptMetadata(
absl::HexStringToBytes(kMetadataEncryptionKeyBase16),
shared_credential.key_seed(),
shared_credential.encrypted_metadata_bytes_v0());
Metadata metadata;
ASSERT_TRUE(metadata.ParseFromString(decrypted_metadata));
EXPECT_THAT(metadata, EqualsProto(expected_metadata));
auto encrypted_meta_data = credential_manager_.EncryptDeviceIdentityMetaData(
kMetadataEncryptionKeyBase16, kSeed,
CreateTestDeviceIdentityMetaData().SerializeAsString());
auto decrypted_meta_data = credential_manager_.DecryptDeviceIdentityMetaData(
kMetadataEncryptionKeyBase16, kSeed, encrypted_meta_data);
DeviceIdentityMetaData device_identity_metadata;
ASSERT_TRUE(device_identity_metadata.ParseFromString(decrypted_meta_data));
EXPECT_EQ(device_identity_metadata.device_id(), "\x12\xab\xcd");
EXPECT_EQ(device_identity_metadata.device_type(),
internal::DeviceType::DEVICE_TYPE_PHONE);
EXPECT_EQ(device_identity_metadata.device_name(), "NP test device");
EXPECT_EQ(device_identity_metadata.bluetooth_mac_address(),
"FF:FF:FF:FF:FF:FF");
}
TEST_F(CredentialManagerImplTest, RefillCredentialsInGetLocalCredentials) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays, 1);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays, 1);
EXPECT_OK(public_credentials);
EXPECT_EQ(1, public_credentials->size());
@@ -605,13 +595,13 @@ TEST_F(CredentialManagerImplTest, RefillCredentialsInGetLocalCredentials) {
}
TEST_F(CredentialManagerImplTest, RefillCredentialsInGetSharedCredentials) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays, 1);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays, 1);
EXPECT_OK(public_credentials);
EXPECT_EQ(1, public_credentials->size());
@@ -625,14 +615,14 @@ TEST_F(CredentialManagerImplTest, RefillCredentialsInGetSharedCredentials) {
}
TEST_F(CredentialManagerImplTest, RefillExpiredCredsInGetLocal) {
Metadata metadata = CreateTestMetadata();
auto device_identity_metadata = CreateTestDeviceIdentityMetaData();
std::vector<IdentityType> identity_types{IDENTITY_TYPE_PRIVATE};
CredentialSelector credential_selector = BuildDefaultCredentialSelector();
auto public_credentials =
GenerateCredentialsSync(metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
auto public_credentials = GenerateCredentialsSync(
device_identity_metadata, kManagerAppId, identity_types,
kExpectedPresenceCredentialValidDays,
kExpectedPresenceCredentialListSize);
ASSERT_OK(public_credentials);
EXPECT_EQ(public_credentials->size(), kExpectedPresenceCredentialListSize);
presence/implementation/mock_credential_manager.h
+8 -7
View File
@@ -30,7 +30,7 @@ class MockCredentialManager : public CredentialManager {
public:
MOCK_METHOD(
void, GenerateCredentials,
(const nearby::internal::Metadata& metadata,
(const nearby::internal::DeviceIdentityMetaData& device_identity_metadata,
absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
@@ -63,20 +63,21 @@ class MockCredentialManager : public CredentialManager {
(override));
MOCK_METHOD(void, UnsubscribeFromPublicCredentials, (SubscriberId id),
(override));
MOCK_METHOD(std::string, DecryptMetadata,
MOCK_METHOD(std::string, DecryptDeviceIdentityMetaData,
(absl::string_view metadata_encryption_key,
absl::string_view key_seed, absl::string_view metadata_string),
(override));
MOCK_METHOD(
void, SetLocalDeviceMetadata,
(const ::nearby::internal::Metadata& metadata, bool regen_credentials,
absl::string_view manager_app_id,
void, SetDeviceIdentityMetaData,
(const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb),
(override));
MOCK_METHOD(::nearby::internal::Metadata, GetLocalDeviceMetadata, (),
(override));
MOCK_METHOD(::nearby::internal::DeviceIdentityMetaData,
GetDeviceIdentityMetaData, (), (override));
};
} // namespace presence
presence/implementation/mock_service_controller.h
+11 -2
View File
@@ -49,8 +49,17 @@ class MockServiceController : public ServiceController {
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb),
(override));
MOCK_METHOD(::nearby::internal::Metadata, GetLocalDeviceMetadata, (),
(override));
MOCK_METHOD(
void, UpdateDeviceIdentityMetaData,
(const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb),
(override));
MOCK_METHOD(::nearby::internal::DeviceIdentityMetaData,
GetDeviceIdentityMetaData, (), (override));
MOCK_METHOD(void, GetLocalPublicCredentials,
(const CredentialSelector& credential_selector,
GetPublicCredentialsResultCallback callback),
presence/implementation/scan_manager.cc
+6 -4
View File
@@ -23,10 +23,10 @@
#include "absl/status/status.h"
#include "absl/types/variant.h"
#include "internal/platform/implementation/crypto.h"
#include "internal/platform/future.h"
#include "internal/platform/implementation/ble_v2.h"
#include "internal/platform/implementation/credential_callbacks.h"
#include "internal/platform/implementation/crypto.h"
#include "internal/platform/uuid.h"
#include "presence/data_types.h"
#include "presence/implementation/advertisement_decoder.h"
@@ -112,9 +112,11 @@ void ScanManager::NotifyFoundBle(ScanSessionId id, BleAdvertisementData data,
return;
}
if (it->second.decoder.MatchesScanFilter(advert->data_elements)) {
internal::Metadata metadata;
metadata.set_bluetooth_mac_address(std::string(remote_address));
PresenceDevice device(DeviceMotion(), metadata, advert->identity_type);
internal::DeviceIdentityMetaData device_identity_metadata;
device_identity_metadata.set_bluetooth_mac_address(
std::string(remote_address));
PresenceDevice device(DeviceMotion(), device_identity_metadata,
advert->identity_type);
// Ok if the advertisement is for trusted/private identity.
if (advert->public_credential.ok()) {
device.SetDecryptSharedCredential(*(advert->public_credential));
presence/implementation/scan_manager_test.cc
+2 -1
View File
@@ -200,7 +200,8 @@ TEST_F(ScanManagerTest, PresenceMetadataIsRetained) {
},
.on_discovered_cb =
[this, &address](PresenceDevice pd) {
if (pd.GetMetadata().bluetooth_mac_address() == address) {
if (pd.GetDeviceIdentityMetadata().bluetooth_mac_address() ==
address) {
EXPECT_THAT(
pd.GetExtendedProperties(),
Contains(
presence/implementation/service_controller.h
+9 -2
View File
@@ -15,7 +15,6 @@
#ifndef THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_SERVICE_CONTROLLER_H_
#define THIRD_PARTY_NEARBY_PRESENCE_IMPLEMENTATION_SERVICE_CONTROLLER_H_
#include <memory>
#include <vector>
#include "absl/status/statusor.h"
@@ -49,7 +48,15 @@ class ServiceController {
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) = 0;
virtual ::nearby::internal::Metadata GetLocalDeviceMetadata() = 0;
virtual void UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) = 0;
virtual ::nearby::internal::DeviceIdentityMetaData
GetDeviceIdentityMetaData() = 0;
virtual void GetLocalPublicCredentials(
const CredentialSelector& credential_selector,
GetPublicCredentialsResultCallback callback) = 0;
presence/implementation/service_controller_impl.cc
+12 -4
View File
@@ -43,16 +43,24 @@ void ServiceControllerImpl::StopBroadcast(BroadcastSessionId id) {
broadcast_manager_.StopBroadcast(id);
}
// TODO(b/327629276): Remove this function.
void ServiceControllerImpl::UpdateLocalDeviceMetadata(
const ::nearby::internal::Metadata& metadata, bool regen_credentials,
absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) {}
void ServiceControllerImpl::UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData& device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) {
credential_manager_.SetLocalDeviceMetadata(
metadata, regen_credentials, manager_app_id, identity_types,
credential_life_cycle_days, contiguous_copy_of_credentials,
std::move(credentials_generated_cb));
credential_manager_.SetDeviceIdentityMetaData(
device_identity_metadata, regen_credentials, manager_app_id,
identity_types, credential_life_cycle_days,
contiguous_copy_of_credentials, std::move(credentials_generated_cb));
}
void ServiceControllerImpl::GetLocalPublicCredentials(
presence/implementation/service_controller_impl.h
+10 -2
View File
@@ -62,9 +62,17 @@ class ServiceControllerImpl : public ServiceController {
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) override;
void UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) override;
::nearby::internal::Metadata GetLocalDeviceMetadata() override {
return credential_manager_.GetLocalDeviceMetadata();
::nearby::internal::DeviceIdentityMetaData GetDeviceIdentityMetaData()
override {
return credential_manager_.GetDeviceIdentityMetaData();
}
void GetLocalPublicCredentials(
const CredentialSelector& credential_selector,
presence/presence_client_test.cc
+13 -14
View File
@@ -27,7 +27,7 @@ namespace nearby {
namespace presence {
namespace {
using ::nearby::internal::Metadata;
using ::nearby::internal::DeviceIdentityMetaData;
using ::testing::status::StatusIs;
constexpr absl::string_view kMacAddr = "\x4C\x8B\x1D\xCE\xBA\xD1";
@@ -39,15 +39,14 @@ std::unique_ptr<PresenceClient> CreateDefunctPresenceClient() {
return presence_service.CreatePresenceClient();
}
Metadata CreateTestMetadata() {
Metadata metadata;
metadata.set_device_type(internal::DEVICE_TYPE_PHONE);
metadata.set_account_name("test_account");
metadata.set_device_name("NP test device");
metadata.set_user_name("Test user");
metadata.set_device_profile_url("test_image.test.com");
metadata.set_bluetooth_mac_address(kMacAddr);
return metadata;
DeviceIdentityMetaData CreateTestDeviceIdentityMetaData() {
DeviceIdentityMetaData device_identity_metadata;
device_identity_metadata.set_device_type(
internal::DeviceType::DEVICE_TYPE_PHONE);
device_identity_metadata.set_device_name("NP test device");
device_identity_metadata.set_bluetooth_mac_address(kMacAddr);
device_identity_metadata.set_device_id("\x12\xab\xcd");
return device_identity_metadata;
}
class PresenceClientTest : public testing::Test {
@@ -125,13 +124,13 @@ TEST_F(PresenceClientTest, GettingDeviceWorks) {
PresenceServiceImpl presence_service;
std::unique_ptr<PresenceClient> presence_client =
presence_service.CreatePresenceClient();
presence_service.UpdateLocalDeviceMetadata(CreateTestMetadata(), false, "",
{}, 0, 0, {});
presence_service.UpdateDeviceIdentityMetaData(
CreateTestDeviceIdentityMetaData(), false, "", {}, 0, 0, {});
auto device = presence_client->GetLocalDevice();
ASSERT_NE(device, std::nullopt);
EXPECT_EQ(device->GetEndpointId().length(), kEndpointIdLength);
EXPECT_EQ(device->GetMetadata().SerializeAsString(),
CreateTestMetadata().SerializeAsString());
EXPECT_EQ(device->GetDeviceIdentityMetadata().SerializeAsString(),
CreateTestDeviceIdentityMetaData().SerializeAsString());
}
TEST_F(PresenceClientTest, TestGettingDeviceDefunct) {
presence/presence_device.cc
+17 -16
View File
@@ -95,26 +95,28 @@ int ConvertToAndroidIdentityType(nearby::internal::IdentityType identity_type) {
PresenceDevice::PresenceDevice(absl::string_view endpoint_id) noexcept
: endpoint_id_(endpoint_id) {}
PresenceDevice::PresenceDevice(Metadata metadata) noexcept
PresenceDevice::PresenceDevice(
DeviceIdentityMetaData device_identity_metadata) noexcept
: discovery_timestamp_(nearby::SystemClock::ElapsedRealtime()),
device_motion_(DeviceMotion()),
metadata_(metadata) {
device_identity_metadata_(device_identity_metadata) {
endpoint_id_ = GenerateRandomEndpointId();
}
PresenceDevice::PresenceDevice(DeviceMotion device_motion,
Metadata metadata) noexcept
PresenceDevice::PresenceDevice(
DeviceMotion device_motion,
DeviceIdentityMetaData device_identity_metadata) noexcept
: discovery_timestamp_(nearby::SystemClock::ElapsedRealtime()),
device_motion_(device_motion),
metadata_(metadata) {
device_identity_metadata_(device_identity_metadata) {
endpoint_id_ = GenerateRandomEndpointId();
}
PresenceDevice::PresenceDevice(
DeviceMotion device_motion, Metadata metadata,
DeviceMotion device_motion, DeviceIdentityMetaData device_identity_metadata,
nearby::internal::IdentityType identity_type) noexcept
: discovery_timestamp_(nearby::SystemClock::ElapsedRealtime()),
device_motion_(device_motion),
metadata_(metadata),
device_identity_metadata_(device_identity_metadata),
identity_type_(identity_type) {
endpoint_id_ = GenerateRandomEndpointId();
}
@@ -126,9 +128,9 @@ std::vector<nearby::ConnectionInfoVariant> PresenceDevice::GetConnectionInfos()
for (const auto& action : actions_) {
transformed_actions.push_back(action.GetActionIdentifier());
}
return {nearby::BleConnectionInfo(metadata_.bluetooth_mac_address(),
/*gatt_characteristic=*/"", /*psm=*/"",
transformed_actions)};
return {nearby::BleConnectionInfo(
device_identity_metadata_.bluetooth_mac_address(),
/*gatt_characteristic=*/"", /*psm=*/"", transformed_actions)};
}
std::string PresenceDevice::ToProtoBytes() const {
@@ -151,9 +153,8 @@ std::string PresenceDevice::ToProtoBytes() const {
absl::get<BleConnectionInfo>(connection_info).ToDataElementBytes();
}
if (absl::holds_alternative<WifiLanConnectionInfo>(connection_info)) {
connection_infos +=
absl::get<WifiLanConnectionInfo>(connection_info)
.ToDataElementBytes();
connection_infos += std::get<WifiLanConnectionInfo>(connection_info)
.ToDataElementBytes();
}
if (absl::holds_alternative<BluetoothConnectionInfo>(connection_info)) {
connection_infos += absl::get<BluetoothConnectionInfo>(connection_info)
@@ -161,10 +162,10 @@ std::string PresenceDevice::ToProtoBytes() const {
}
}
device.set_device_type(
ConvertToConnectionsDeviceType(metadata_.device_type()));
device.set_device_name(metadata_.device_name());
ConvertToConnectionsDeviceType(device_identity_metadata_.device_type()));
device.set_device_name(device_identity_metadata_.device_name());
device.set_connectivity_info_list(connection_infos);
device.set_device_image_url(metadata_.device_profile_url());
device.set_device_image_url("dummy url"); // Not used.
return device.SerializeAsString();
}
} // namespace presence
presence/presence_device.h
+18 -9
View File
@@ -34,14 +34,18 @@ inline constexpr int kEndpointIdLength = 4;
class PresenceDevice : public nearby::NearbyDevice {
using Metadata = ::nearby::internal::Metadata;
using DeviceIdentityMetaData = ::nearby::internal::DeviceIdentityMetaData;
public:
explicit PresenceDevice(absl::string_view endpoint_id) noexcept;
explicit PresenceDevice(Metadata metadata) noexcept;
explicit PresenceDevice(DeviceMotion device_motion,
Metadata metadata) noexcept;
explicit PresenceDevice(
DeviceMotion device_motion, Metadata metadata,
DeviceIdentityMetaData device_identity_metadata) noexcept;
explicit PresenceDevice(
DeviceMotion device_motion,
DeviceIdentityMetaData device_identity_metadata) noexcept;
explicit PresenceDevice(
DeviceMotion device_motion,
DeviceIdentityMetaData device_identity_metadata,
nearby::internal::IdentityType identity_type) noexcept;
std::string GetEndpointId() const override { return endpoint_id_; }
std::vector<nearby::ConnectionInfoVariant> GetConnectionInfos()
@@ -63,8 +67,13 @@ class PresenceDevice : public nearby::NearbyDevice {
return NearbyDevice::Type::kPresenceDevice;
}
DeviceMotion GetDeviceMotion() const { return device_motion_; }
Metadata GetMetadata() const { return metadata_; }
void SetMetadata(const Metadata metadata) { metadata_ = metadata; }
DeviceIdentityMetaData GetDeviceIdentityMetadata() const {
return device_identity_metadata_;
}
void SetDeviceIdentityMetaData(
const DeviceIdentityMetaData& device_identity_metadata) {
device_identity_metadata_ = device_identity_metadata;
}
void SetDecryptSharedCredential(
const internal::SharedCredential& decrypt_shared_credential) {
decrypt_shared_credential_ = decrypt_shared_credential;
@@ -79,7 +88,7 @@ class PresenceDevice : public nearby::NearbyDevice {
private:
const absl::Time discovery_timestamp_;
const DeviceMotion device_motion_;
Metadata metadata_;
DeviceIdentityMetaData device_identity_metadata_;
std::vector<DataElement> extended_properties_;
std::vector<PresenceAction> actions_;
std::string endpoint_id_;
@@ -101,8 +110,8 @@ inline bool operator==(const PresenceDevice& d1, const PresenceDevice& d2) {
d2.GetDecryptSharedCredential()->SerializeAsString();
}
return d1.GetDeviceMotion() == d2.GetDeviceMotion() &&
d1.GetMetadata().SerializeAsString() ==
d2.GetMetadata().SerializeAsString() &&
d1.GetDeviceIdentityMetadata().SerializeAsString() ==
d2.GetDeviceIdentityMetadata().SerializeAsString() &&
d1.GetActions() == d2.GetActions() &&
d1.GetExtendedProperties() == d2.GetExtendedProperties() &&
d1.GetIdentityType() == d2.GetIdentityType() &&
presence/presence_device_provider.cc
+3 -3
View File
@@ -100,7 +100,7 @@ PresenceDeviceProvider::PresenceDeviceProvider(
ServiceController* service_controller,
const ConnectionAuthenticator* connection_authenticator)
: service_controller_(*service_controller),
device_{service_controller_.GetLocalDeviceMetadata()},
device_(service_controller_.GetDeviceIdentityMetaData()),
connection_authenticator_(*connection_authenticator) {
CHECK(connection_authenticator);
}
@@ -124,7 +124,7 @@ AuthenticationStatus PresenceDeviceProvider::AuthenticateAsInitiator(
service_controller_.GetLocalCredentials(
/*credential_selector=*/{.manager_app_id = manager_app_id_,
.account_name =
device_.GetMetadata().account_name(),
"dummy_account_name",
.identity_type = ::nearby::internal::
IdentityType::IDENTITY_TYPE_PRIVATE},
/*callback=*/{.credentials_fetched_cb = [this, &response, &remote_device,
@@ -226,7 +226,7 @@ bool PresenceDeviceProvider::ReadAndVerifyRemoteDeviceData(
service_controller_.GetLocalPublicCredentials(
/*credential_selector=*/{.manager_app_id = manager_app_id_,
.account_name =
device_.GetMetadata().account_name(),
"dummy_account_name",
.identity_type = ::nearby::internal::
IdentityType::IDENTITY_TYPE_PRIVATE},
/*callback=*/{.credentials_fetched_cb = [this, &read_and_verify_result,
presence/presence_device_provider.h
+5 -5
View File
@@ -60,17 +60,17 @@ class PresenceDeviceProvider : public NearbyDeviceProvider {
return AuthenticationStatus::kUnknown;
}
void UpdateMetadata(const ::nearby::internal::Metadata& metadata) {
device_.SetMetadata(metadata);
void UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata) {
device_.SetDeviceIdentityMetaData(device_identity_metadata);
}
void SetManagerAppId(absl::string_view manager_app_id) {
manager_app_id_ = manager_app_id;
}
std::string GetManagerAppId() {
return manager_app_id_;
}
std::string GetManagerAppId() { return manager_app_id_; }
private:
bool WriteToRemoteDevice(
presence/presence_device_provider_test.cc
+23 -24
View File
@@ -44,7 +44,7 @@
namespace nearby {
namespace presence {
namespace {
using ::nearby::internal::Metadata;
using ::nearby::internal::DeviceIdentityMetaData;
constexpr absl::string_view kMacAddr = "\x4C\x8B\x1D\xCE\xBA\xD1";
constexpr absl::string_view kManagerAppId = "test_app_id";
@@ -54,15 +54,14 @@ constexpr int kPresenceVersion = 1;
constexpr absl::string_view kSharedCredentialHash = "shared_cred_hash";
constexpr absl::string_view kPrivateKeySignature = "private_key_signature";
Metadata CreateTestMetadata() {
Metadata metadata;
metadata.set_device_type(internal::DEVICE_TYPE_PHONE);
metadata.set_account_name("test_account");
metadata.set_device_name("NP test device");
metadata.set_user_name("Test user");
metadata.set_device_profile_url("test_image.test.com");
metadata.set_bluetooth_mac_address(kMacAddr);
return metadata;
DeviceIdentityMetaData CreateTestDeviceIdentityMetaData() {
DeviceIdentityMetaData device_identity_metadata;
device_identity_metadata.set_device_type(
internal::DeviceType::DEVICE_TYPE_PHONE);
device_identity_metadata.set_device_name("NP test device");
device_identity_metadata.set_bluetooth_mac_address(kMacAddr);
device_identity_metadata.set_device_id("\x12\xab\xcd");
return device_identity_metadata;
}
nearby::internal::LocalCredential CreateValidLocalCredential(
@@ -110,8 +109,8 @@ class MockAuthenticationTransport : public AuthenticationTransport {
class PresenceDeviceProviderTest : public ::testing::Test {
public:
PresenceDeviceProviderTest() {
ON_CALL(mock_service_controller_, GetLocalDeviceMetadata)
.WillByDefault(testing::Return(CreateTestMetadata()));
ON_CALL(mock_service_controller_, GetDeviceIdentityMetaData)
.WillByDefault(testing::Return(CreateTestDeviceIdentityMetaData()));
provider_ = std::make_unique<PresenceDeviceProvider>(
&mock_service_controller_, &mock_connection_authenticator_);
}
@@ -136,20 +135,20 @@ TEST_F(PresenceDeviceProviderTest, DeviceProviderWorks) {
auto device = provider_->GetLocalDevice();
ASSERT_EQ(device->GetType(), NearbyDevice::Type::kPresenceDevice);
auto presence_device = static_cast<const PresenceDevice*>(device);
EXPECT_EQ(presence_device->GetMetadata().SerializeAsString(),
CreateTestMetadata().SerializeAsString());
EXPECT_EQ(presence_device->GetDeviceIdentityMetadata().SerializeAsString(),
CreateTestDeviceIdentityMetaData().SerializeAsString());
}
TEST_F(PresenceDeviceProviderTest, DeviceProviderCanUpdateDevice) {
auto device = provider_->GetLocalDevice();
ASSERT_EQ(device->GetType(), NearbyDevice::Type::kPresenceDevice);
auto presence_device = static_cast<const PresenceDevice*>(device);
EXPECT_EQ(presence_device->GetMetadata().SerializeAsString(),
CreateTestMetadata().SerializeAsString());
Metadata new_metadata = CreateTestMetadata();
EXPECT_EQ(presence_device->GetDeviceIdentityMetadata().SerializeAsString(),
CreateTestDeviceIdentityMetaData().SerializeAsString());
auto new_metadata = CreateTestDeviceIdentityMetaData();
new_metadata.set_device_name("NP interop device");
provider_->UpdateMetadata(new_metadata);
EXPECT_EQ(presence_device->GetMetadata().SerializeAsString(),
provider_->UpdateDeviceIdentityMetaData(new_metadata);
EXPECT_EQ(presence_device->GetDeviceIdentityMetadata().SerializeAsString(),
new_metadata.SerializeAsString());
}
@@ -167,7 +166,7 @@ TEST_F(PresenceDeviceProviderTest,
absl::Status(absl::StatusCode::kCancelled, /*msg=*/std::string()));
});
PresenceDevice remote_device(CreateTestMetadata());
PresenceDevice remote_device(CreateTestDeviceIdentityMetaData());
MockAuthenticationTransport authentication_transport;
auto status = provider_->AuthenticateAsInitiator(
/*remote_device=*/remote_device, /*shared_secret=*/kUkey2Secret,
@@ -185,7 +184,7 @@ TEST_F(PresenceDeviceProviderTest,
std::move(callback.credentials_fetched_cb)(credentials);
});
PresenceDevice remote_device(CreateTestMetadata());
PresenceDevice remote_device(CreateTestDeviceIdentityMetaData());
MockAuthenticationTransport authentication_transport;
auto status = provider_->AuthenticateAsInitiator(
/*remote_device=*/remote_device, /*shared_secret=*/kUkey2Secret,
@@ -203,7 +202,7 @@ TEST_F(PresenceDeviceProviderTest,
std::move(callback.credentials_fetched_cb)(credentials);
});
PresenceDevice remote_device(CreateTestMetadata());
PresenceDevice remote_device(CreateTestDeviceIdentityMetaData());
MockAuthenticationTransport authentication_transport;
auto status = provider_->AuthenticateAsInitiator(
/*remote_device=*/remote_device, /*shared_secret=*/kUkey2Secret,
@@ -228,7 +227,7 @@ TEST_F(PresenceDeviceProviderTest, AuthenticateAsInitiator_FailureToVerify) {
std::move(callback.credentials_fetched_cb)(credentials);
});
PresenceDevice remote_device(CreateTestMetadata());
PresenceDevice remote_device(CreateTestDeviceIdentityMetaData());
remote_device.SetDecryptSharedCredential(BuildSharedCredential(key_pair_));
MockAuthenticationTransport authentication_transport;
@@ -271,7 +270,7 @@ TEST_F(PresenceDeviceProviderTest, AuthenticateAsInitiator_Success) {
std::move(callback.credentials_fetched_cb)(std::move(credentials));
});
PresenceDevice remote_device(CreateTestMetadata());
PresenceDevice remote_device(CreateTestDeviceIdentityMetaData());
remote_device.SetDecryptSharedCredential(BuildSharedCredential(key_pair_));
ON_CALL(mock_connection_authenticator_, BuildSignedMessageAsInitiator)
presence/presence_device_test.cc
+63 -47
View File
@@ -31,7 +31,7 @@ namespace nearby {
namespace presence {
namespace {
using ::nearby::internal::Metadata;
using ::nearby::internal::DeviceIdentityMetaData;
using ::testing::Contains;
constexpr DeviceMotion::MotionType kDefaultMotionType =
@@ -44,68 +44,74 @@ constexpr absl::string_view kDataElementValue = "15";
constexpr char kEndpointId[] = "endpoint_id";
constexpr int kTestAction = 3;
Metadata CreateTestMetadata() {
Metadata metadata;
metadata.set_account_name("test_account");
metadata.set_device_name("NP test device");
metadata.set_device_profile_url("test_image.test.com");
metadata.set_bluetooth_mac_address(kMacAddr);
metadata.set_device_type(internal::DEVICE_TYPE_LAPTOP);
return metadata;
DeviceIdentityMetaData CreateTestDeviceIdentityMetaData() {
DeviceIdentityMetaData device_identity_metadata;
device_identity_metadata.set_device_type(
internal::DeviceType::DEVICE_TYPE_LAPTOP);
device_identity_metadata.set_device_name("NP test device");
device_identity_metadata.set_bluetooth_mac_address(kMacAddr);
device_identity_metadata.set_device_id("\x12\xab\xcd");
return device_identity_metadata;
}
TEST(PresenceDeviceTest, EndpointIdConstructor) {
PresenceDevice device(kEndpointId);
EXPECT_EQ(device.GetEndpointId(), kEndpointId);
}
TEST(PresenceDeviceTest, DefaultMotionEquals) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device1(metadata);
PresenceDevice device2(metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device1(device_identity_metadata);
PresenceDevice device2(device_identity_metadata);
EXPECT_EQ(device1, device2);
}
TEST(PresenceDeviceTest, ExplicitInitEquals) {
Metadata metadata = CreateTestMetadata();
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
internal::SharedCredential shared_credential;
shared_credential.set_credential_type(internal::CREDENTIAL_TYPE_GAIA);
PresenceDevice device1 =
PresenceDevice({kDefaultMotionType, kTestConfidence}, metadata,
internal::IDENTITY_TYPE_PUBLIC);
PresenceDevice({kDefaultMotionType, kTestConfidence},
device_identity_metadata, internal::IDENTITY_TYPE_PUBLIC);
device1.SetDecryptSharedCredential(shared_credential);
PresenceDevice device2 =
PresenceDevice({kDefaultMotionType, kTestConfidence}, metadata,
internal::IDENTITY_TYPE_PUBLIC);
PresenceDevice({kDefaultMotionType, kTestConfidence},
device_identity_metadata, internal::IDENTITY_TYPE_PUBLIC);
device2.SetDecryptSharedCredential(shared_credential);
EXPECT_EQ(device1, device2);
}
TEST(PresenceDeviceTest, ExplicitInitNotEquals) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device1 = PresenceDevice({kDefaultMotionType}, metadata,
internal::IDENTITY_TYPE_PUBLIC);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device1 =
PresenceDevice({kDefaultMotionType}, device_identity_metadata,
internal::IDENTITY_TYPE_PUBLIC);
PresenceDevice device2 =
PresenceDevice({kDefaultMotionType, kTestConfidence}, metadata,
internal::IDENTITY_TYPE_PRIVATE);
PresenceDevice({kDefaultMotionType, kTestConfidence},
device_identity_metadata, internal::IDENTITY_TYPE_PRIVATE);
EXPECT_NE(device1, device2);
}
TEST(PresenceDeviceTest, TestGetBleConnectionInfo) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device = PresenceDevice({kDefaultMotionType}, metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device =
PresenceDevice({kDefaultMotionType}, device_identity_metadata);
device.AddAction(PresenceAction(kTestAction));
auto info = (device.GetConnectionInfos().at(0));
ASSERT_TRUE(std::holds_alternative<nearby::BleConnectionInfo>(info));
auto ble_info = std::get<nearby::BleConnectionInfo>(info);
EXPECT_EQ(ble_info.GetMacAddress(),
kMacAddr);
EXPECT_EQ(ble_info.GetMacAddress(), kMacAddr);
EXPECT_EQ(ble_info.GetActions(), std::vector<uint8_t>{kTestAction});
}
TEST(PresenceDeviceTest, TestGetAddExtendedProperties) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device = PresenceDevice({kDefaultMotionType}, metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device =
PresenceDevice({kDefaultMotionType}, device_identity_metadata);
device.AddExtendedProperty({kDataElementType, kDataElementValue});
ASSERT_EQ(device.GetExtendedProperties().size(), 1);
EXPECT_EQ(device.GetExtendedProperties()[0],
@@ -113,8 +119,10 @@ TEST(PresenceDeviceTest, TestGetAddExtendedProperties) {
}
TEST(PresenceDeviceTest, TestGetAddExtendedPropertiesVector) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device = PresenceDevice({kDefaultMotionType}, metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device =
PresenceDevice({kDefaultMotionType}, device_identity_metadata);
device.AddExtendedProperties(
{DataElement(kDataElementType, kDataElementValue)});
ASSERT_EQ(device.GetExtendedProperties().size(), 1);
@@ -123,37 +131,45 @@ TEST(PresenceDeviceTest, TestGetAddExtendedPropertiesVector) {
}
TEST(PresenceDeviceTest, TestAddGetActions) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device = PresenceDevice({kDefaultMotionType}, metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device =
PresenceDevice({kDefaultMotionType}, device_identity_metadata);
device.AddAction({kTestAction});
ASSERT_EQ(device.GetActions().size(), 1);
EXPECT_EQ(device.GetActions()[0], PresenceAction(kTestAction));
}
TEST(PresenceDeviceTest, TestEndpointIdIsCorrectLength) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device = PresenceDevice({kDefaultMotionType}, metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device =
PresenceDevice({kDefaultMotionType}, device_identity_metadata);
EXPECT_EQ(device.GetEndpointId().length(), kEndpointIdLength);
}
TEST(PresenceDeviceTest, TestEndpointIdIsRandom) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device = PresenceDevice({kDefaultMotionType}, metadata);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device =
PresenceDevice({kDefaultMotionType}, device_identity_metadata);
EXPECT_EQ(device.GetEndpointId().length(), kEndpointIdLength);
EXPECT_NE(device.GetEndpointId(), std::string(kEndpointIdLength, 0));
}
TEST(PresenceDeviceTest, TestGetIdentityType) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device =
PresenceDevice(DeviceMotion(), metadata, internal::IDENTITY_TYPE_PUBLIC);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device = PresenceDevice(
DeviceMotion(), device_identity_metadata, internal::IDENTITY_TYPE_PUBLIC);
EXPECT_EQ(device.GetIdentityType(), internal::IDENTITY_TYPE_PUBLIC);
}
TEST(PresenceDeviceTest, TestGetDecryptSharedCredential) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device =
PresenceDevice(DeviceMotion(), metadata, internal::IDENTITY_TYPE_PUBLIC);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device = PresenceDevice(
DeviceMotion(), device_identity_metadata, internal::IDENTITY_TYPE_PUBLIC);
EXPECT_EQ(device.GetDecryptSharedCredential(), std::nullopt);
internal::SharedCredential shared_credential;
shared_credential.set_credential_type(internal::CREDENTIAL_TYPE_GAIA);
@@ -163,9 +179,10 @@ TEST(PresenceDeviceTest, TestGetDecryptSharedCredential) {
}
TEST(PresenceDeviceTest, TestToProtoBytes) {
Metadata metadata = CreateTestMetadata();
PresenceDevice device =
PresenceDevice(DeviceMotion(), metadata, internal::IDENTITY_TYPE_PUBLIC);
DeviceIdentityMetaData device_identity_metadata =
CreateTestDeviceIdentityMetaData();
PresenceDevice device = PresenceDevice(
DeviceMotion(), device_identity_metadata, internal::IDENTITY_TYPE_PUBLIC);
std::string proto_bytes = device.ToProtoBytes();
location::nearby::connections::PresenceDevice device_frame;
ASSERT_TRUE(device_frame.ParseFromString(proto_bytes));
@@ -177,7 +194,6 @@ TEST(PresenceDeviceTest, TestToProtoBytes) {
EXPECT_EQ(device_frame.device_type(),
location::nearby::connections::PresenceDevice::LAPTOP);
EXPECT_EQ(device_frame.device_name(), "NP test device");
EXPECT_EQ(device_frame.device_image_url(), "test_image.test.com");
}
} // namespace
presence/presence_service.h
+10 -1
View File
@@ -48,6 +48,14 @@ class PresenceService {
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) = 0;
virtual void UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) = 0;
virtual PresenceDeviceProvider* GetLocalDeviceProvider() = 0;
virtual void GetLocalPublicCredentials(
@@ -61,7 +69,8 @@ class PresenceService {
UpdateRemotePublicCredentialsCallback credentials_updated_cb) = 0;
// Testing only.
virtual ::nearby::internal::Metadata GetLocalDeviceMetadata() = 0;
virtual ::nearby::internal::DeviceIdentityMetaData
GetDeviceIdentityMetaData() = 0;
};
} // namespace presence
presence/presence_service_impl.cc
+12 -5
View File
@@ -54,13 +54,20 @@ void PresenceServiceImpl::UpdateLocalDeviceMetadata(
absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) {}
void PresenceServiceImpl::UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData& device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) {
provider_.UpdateMetadata(metadata);
provider_.UpdateDeviceIdentityMetaData(device_identity_metadata);
provider_.SetManagerAppId(manager_app_id);
service_controller_.UpdateLocalDeviceMetadata(
metadata, regen_credentials, manager_app_id, identity_types,
credential_life_cycle_days, contiguous_copy_of_credentials,
std::move(credentials_generated_cb));
service_controller_.UpdateDeviceIdentityMetaData(
device_identity_metadata, regen_credentials, manager_app_id,
identity_types, credential_life_cycle_days,
contiguous_copy_of_credentials, std::move(credentials_generated_cb));
}
void PresenceServiceImpl::GetLocalPublicCredentials(
presence/presence_service_impl.h
+11 -2
View File
@@ -69,12 +69,21 @@ class PresenceServiceImpl : public PresenceService {
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) override;
void UpdateDeviceIdentityMetaData(
const ::nearby::internal::DeviceIdentityMetaData&
device_identity_metadata,
bool regen_credentials, absl::string_view manager_app_id,
const std::vector<nearby::internal::IdentityType>& identity_types,
int credential_life_cycle_days, int contiguous_copy_of_credentials,
GenerateCredentialsResultCallback credentials_generated_cb) override;
PresenceDeviceProvider* GetLocalDeviceProvider() override {
return &provider_;
}
::nearby::internal::Metadata GetLocalDeviceMetadata() override {
return service_controller_.GetLocalDeviceMetadata();
::nearby::internal::DeviceIdentityMetaData GetDeviceIdentityMetaData()
override {
return service_controller_.GetDeviceIdentityMetaData();
}
void GetLocalPublicCredentials(
presence/presence_service_test.cc
+17 -15
View File
@@ -22,6 +22,7 @@
#include "gmock/gmock.h"
#include "protobuf-matchers/protocol-buffer-matchers.h"
#include "gtest/gtest.h"
#include "absl/strings/string_view.h"
#include "internal/platform/count_down_latch.h"
#include "internal/platform/medium_environment.h"
#include "presence/presence_client.h"
@@ -30,24 +31,25 @@
namespace nearby {
namespace presence {
namespace {
using Metadata = ::nearby::internal::Metadata;
using DeviceIdentityMetaData = ::nearby::internal::DeviceIdentityMetaData;
constexpr absl::string_view kManagerAppId = "TEST_MANAGER_APP";
constexpr absl::string_view kAccountName = "test account";
constexpr absl::string_view kAccountName = "dummy account";
class PresenceServiceTest : public testing::Test {
protected:
nearby::MediumEnvironment& env_{nearby::MediumEnvironment::Instance()};
};
Metadata CreateTestMetadata(absl::string_view account_name) {
Metadata metadata;
metadata.set_account_name(account_name);
metadata.set_device_name("NP test device");
metadata.set_device_profile_url("test_image.test.com");
metadata.set_bluetooth_mac_address("\xFF\xFF\xFF\xFF\xFF\xFF");
return metadata;
DeviceIdentityMetaData CreateTestDeviceIdentityMetaData() {
DeviceIdentityMetaData device_identity_metadata;
device_identity_metadata.set_device_type(
internal::DeviceType::DEVICE_TYPE_PHONE);
device_identity_metadata.set_device_name("NP test device");
device_identity_metadata.set_bluetooth_mac_address(
"\xFF\xFF\xFF\xFF\xFF\xFF");
device_identity_metadata.set_device_id("\x12\xab\xcd");
return device_identity_metadata;
}
CredentialSelector BuildDefaultCredentialSelector() {
@@ -89,12 +91,12 @@ TEST_F(PresenceServiceTest, StartThenStopScan) {
env_.Stop();
}
TEST_F(PresenceServiceTest, UpdatingLocalMetadataWorks) {
TEST_F(PresenceServiceTest, UpdatingDeviceIdentityMetaDataWorks) {
PresenceServiceImpl presence_service;
presence_service.UpdateLocalDeviceMetadata(CreateTestMetadata("Test account"),
false, "Test app", {}, 3, 1, {});
EXPECT_EQ(presence_service.GetLocalDeviceMetadata().SerializeAsString(),
CreateTestMetadata("Test account").SerializeAsString());
presence_service.UpdateDeviceIdentityMetaData(
CreateTestDeviceIdentityMetaData(), false, "Test app", {}, 3, 1, {});
EXPECT_EQ(presence_service.GetDeviceIdentityMetaData().SerializeAsString(),
CreateTestDeviceIdentityMetaData().SerializeAsString());
}
TEST_F(PresenceServiceTest, TestGetDeviceProvider) {