diff --git a/internal/platform/credential_storage_impl.cc b/internal/platform/credential_storage_impl.cc index f8a10102..77ccdcb7 100644 --- a/internal/platform/credential_storage_impl.cc +++ b/internal/platform/credential_storage_impl.cc @@ -20,8 +20,8 @@ namespace nearby { -using ::nearby::internal::PrivateCredential; -using ::nearby::internal::PublicCredential; +using ::nearby::internal::LocalCredential; +using ::nearby::internal::SharedCredential; using ::nearby::presence::CredentialSelector; using ::nearby::presence::GetPrivateCredentialsResultCallback; using ::nearby::presence::GetPublicCredentialsResultCallback; @@ -29,8 +29,8 @@ using ::nearby::presence::PublicCredentialType; void CredentialStorageImpl::SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& private_credentials, - const std::vector& public_credentials, + const std::vector& private_credentials, + const std::vector& public_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback) { return impl_->SaveCredentials(manager_app_id, account_name, diff --git a/internal/platform/credential_storage_impl.h b/internal/platform/credential_storage_impl.h index d0b7bc50..d9176929 100644 --- a/internal/platform/credential_storage_impl.h +++ b/internal/platform/credential_storage_impl.h @@ -42,8 +42,8 @@ class CredentialStorageImpl : public api::CredentialStorage { void SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& private_credentials, - const std::vector& public_credentials, + const std::vector& private_credentials, + const std::vector& public_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback) override; diff --git a/internal/platform/credential_storage_impl_test.cc b/internal/platform/credential_storage_impl_test.cc index 6b60c74e..f2ef8479 100644 --- a/internal/platform/credential_storage_impl_test.cc +++ b/internal/platform/credential_storage_impl_test.cc @@ -33,8 +33,8 @@ namespace nearby { namespace { using ::nearby::internal::IdentityType; -using ::nearby::internal::PrivateCredential; -using ::nearby::internal::PublicCredential; +using ::nearby::internal::LocalCredential; +using ::nearby::internal::SharedCredential; using ::nearby::presence::CredentialSelector; using ::nearby::presence::GetPrivateCredentialsResultCallback; using ::nearby::presence::GetPublicCredentialsResultCallback; @@ -49,24 +49,24 @@ constexpr absl::string_view kManagerAppId = "manager app id"; constexpr absl::string_view kAccountName = "test_account"; // `secret_id` is used to create credentials with different content. -PrivateCredential CreatePrivateCredential(absl::string_view secret_id, +LocalCredential CreatePrivateCredential(absl::string_view secret_id, IdentityType identity_type) { - PrivateCredential private_credential; + LocalCredential private_credential; private_credential.set_secret_id(secret_id); private_credential.set_identity_type(identity_type); return private_credential; } -PublicCredential CreatePublicCredential(absl::string_view secret_id, +SharedCredential CreatePublicCredential(absl::string_view secret_id, IdentityType identity_type) { - PublicCredential public_credential; + SharedCredential public_credential; public_credential.set_secret_id(secret_id); public_credential.set_identity_type(identity_type); return public_credential; } -std::vector BuildPrivateCreds(absl::string_view secret_id) { - std::vector private_credentials = { +std::vector BuildPrivateCreds(absl::string_view secret_id) { + std::vector private_credentials = { CreatePrivateCredential(secret_id, IdentityType::IDENTITY_TYPE_PRIVATE), CreatePrivateCredential(secret_id, IdentityType::IDENTITY_TYPE_TRUSTED), CreatePrivateCredential(secret_id, @@ -74,8 +74,8 @@ std::vector BuildPrivateCreds(absl::string_view secret_id) { return private_credentials; } -std::vector BuildPublicCreds(absl::string_view secret_id) { - std::vector public_credentials = { +std::vector BuildPublicCreds(absl::string_view secret_id) { + std::vector public_credentials = { CreatePublicCredential(secret_id, IdentityType::IDENTITY_TYPE_PRIVATE), CreatePublicCredential(secret_id, IdentityType::IDENTITY_TYPE_TRUSTED), CreatePublicCredential(secret_id, @@ -83,25 +83,25 @@ std::vector BuildPublicCreds(absl::string_view secret_id) { return public_credentials; } -absl::StatusOr> GetPrivateCredentials( +absl::StatusOr> GetPrivateCredentials( CredentialStorageImpl& credential_storage, IdentityType identity_type, absl::string_view manager_app_id = kManagerAppId, absl::string_view account_name = kAccountName) { CredentialSelector selector = {.manager_app_id = std::string(manager_app_id), .account_name = std::string(account_name), .identity_type = identity_type}; - absl::StatusOr> private_credentials; + absl::StatusOr> private_credentials; credential_storage.GetPrivateCredentials( selector, GetPrivateCredentialsResultCallback{ .credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { private_credentials = std::move(credentials); }}); return private_credentials; } -absl::StatusOr> GetPublicCredentials( +absl::StatusOr> GetPublicCredentials( CredentialStorageImpl& credential_storage, IdentityType identity_type, PublicCredentialType credential_type, absl::string_view manager_app_id = kManagerAppId, @@ -109,12 +109,12 @@ absl::StatusOr> GetPublicCredentials( CredentialSelector selector = {.manager_app_id = std::string(manager_app_id), .account_name = std::string(account_name), .identity_type = identity_type}; - absl::StatusOr> public_credentials; + absl::StatusOr> public_credentials; credential_storage.GetPublicCredentials( selector, credential_type, GetPublicCredentialsResultCallback{ .credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); return public_credentials; @@ -123,8 +123,8 @@ absl::StatusOr> GetPublicCredentials( absl::Status SaveCredentials(CredentialStorageImpl& credential_storage, absl::string_view manager_app_id, absl::string_view account_name, - std::vector private_credentials, - std::vector public_credentials, + std::vector private_credentials, + std::vector public_credentials, PublicCredentialType public_credential_type) { absl::Status save_status = absl::UnknownError(""); @@ -139,8 +139,8 @@ absl::Status SaveCredentials(CredentialStorageImpl& credential_storage, } absl::Status SaveCredentials(CredentialStorageImpl& credential_storage, - std::vector private_credentials, - std::vector public_credentials) { + std::vector private_credentials, + std::vector public_credentials) { return SaveCredentials(credential_storage, kManagerAppId, kAccountName, private_credentials, public_credentials, PublicCredentialType::kLocalPublicCredential); @@ -150,7 +150,7 @@ absl::Status SavePrivateCredentials(CredentialStorageImpl& credential_storage, absl::string_view secret_id) { return SaveCredentials(credential_storage, kManagerAppId, kAccountName, BuildPrivateCreds(secret_id), - std::vector(), + std::vector(), PublicCredentialType::kLocalPublicCredential); } @@ -158,14 +158,14 @@ absl::Status SavePublicCredentials(CredentialStorageImpl& credential_storage, PublicCredentialType credential_type, absl::string_view secret_id) { return SaveCredentials(credential_storage, kManagerAppId, kAccountName, - std::vector(), + std::vector(), BuildPublicCreds(secret_id), credential_type); } TEST(CredentialStorageImplTest, SaveAndGetPrivateCredentials) { - std::vector default_private_creds = + std::vector default_private_creds = BuildPrivateCreds(kSecretId); - std::vector empty_public_creds; + std::vector empty_public_creds; CredentialStorageImpl credential_storage; absl::Status save_status = absl::UnknownError(""); @@ -201,8 +201,8 @@ TEST(CredentialStorageImplTest, ReplaceAndGetPrivateCredentials) { } TEST(CredentialStorageImplTest, SaveAndGetLocalPublicCredentials) { - std::vector empty_private_creds; - std::vector public_creds = BuildPublicCreds(kSecretId); + std::vector empty_private_creds; + std::vector public_creds = BuildPublicCreds(kSecretId); CredentialStorageImpl credential_storage; absl::Status save_status = absl::UnknownError(""); @@ -244,8 +244,8 @@ TEST(CredentialStorageImplTest, ReplaceAndGetLocalPublicCredentials) { } TEST(CredentialStorageImplTest, SaveAndGetRemotePublicCredentials) { - std::vector empty_private_creds; - std::vector public_creds = BuildPublicCreds(kSecretId); + std::vector empty_private_creds; + std::vector public_creds = BuildPublicCreds(kSecretId); CredentialStorageImpl credential_storage; absl::Status save_status = absl::UnknownError(""); @@ -287,8 +287,8 @@ TEST(CredentialStorageImplTest, ReplaceAndGetRemotePublicCredentials) { } TEST(CredentialStorageImplTest, SavePrivateAndLocalPublicCredentials) { - std::vector private_creds = BuildPrivateCreds(kSecretId); - std::vector public_creds = BuildPublicCreds(kSecretId); + std::vector private_creds = BuildPrivateCreds(kSecretId); + std::vector public_creds = BuildPublicCreds(kSecretId); CredentialStorageImpl credential_storage; absl::Status status = @@ -309,8 +309,8 @@ TEST(CredentialStorageImplTest, SavePrivateAndLocalPublicCredentials) { } TEST(CredentialStorageImplTest, SaveCredentialsFailsWhenNoCredentials) { - std::vector empty_private_creds; - std::vector empty_public_creds; + std::vector empty_private_creds; + std::vector empty_public_creds; CredentialStorageImpl credential_storage; absl::Status save_status = absl::UnknownError(""); @@ -415,7 +415,7 @@ TEST_P(IdentityFilterTest, FilterPrivateCredentialsByIdentityType) { EXPECT_THAT( *private_credentials, UnorderedPointwise(EqualsProto(), - std::vector{CreatePrivateCredential( + std::vector{CreatePrivateCredential( kSecretId, identity_type)})); } @@ -426,7 +426,7 @@ TEST_P(IdentityFilterTest, IdentityType other_type = identity_type == IdentityType::IDENTITY_TYPE_PRIVATE ? IdentityType::IDENTITY_TYPE_TRUSTED : IdentityType::IDENTITY_TYPE_PRIVATE; - std::vector private_creds = { + std::vector private_creds = { CreatePrivateCredential(kSecretId, other_type)}; CredentialStorageImpl credential_storage; EXPECT_OK(SaveCredentials(credential_storage, private_creds, @@ -452,7 +452,7 @@ TEST_P(IdentityFilterTest, FilterPublicCredentialsByIdentityType) { EXPECT_THAT( *public_credentials, UnorderedPointwise(EqualsProto(), - std::vector{CreatePublicCredential( + std::vector{CreatePublicCredential( kSecretId, identity_type)})); } @@ -462,7 +462,7 @@ TEST_P(IdentityFilterTest, FilterPublicCredentialsFailsWhenNoCredentialsMatch) { IdentityType other_type = identity_type == IdentityType::IDENTITY_TYPE_PRIVATE ? IdentityType::IDENTITY_TYPE_TRUSTED : IdentityType::IDENTITY_TYPE_PRIVATE; - std::vector public_creds = { + std::vector public_creds = { CreatePublicCredential(kSecretId, other_type)}; CredentialStorageImpl credential_storage; EXPECT_OK(SaveCredentials(credential_storage, BuildPrivateCreds(kSecretId), diff --git a/internal/platform/implementation/credential_callbacks.h b/internal/platform/implementation/credential_callbacks.h index 4db7e6ac..a201c4e1 100644 --- a/internal/platform/implementation/credential_callbacks.h +++ b/internal/platform/implementation/credential_callbacks.h @@ -66,7 +66,7 @@ struct SaveCredentialsResultCallback { struct GenerateCredentialsResultCallback { absl::AnyInvocable>)> + absl::StatusOr>)> credentials_generated_cb; }; @@ -76,13 +76,13 @@ struct UpdateRemotePublicCredentialsCallback { struct GetPrivateCredentialsResultCallback { absl::AnyInvocable>)> + absl::StatusOr>)> credentials_fetched_cb; }; struct GetPublicCredentialsResultCallback { absl::AnyInvocable>)> + absl::StatusOr>)> credentials_fetched_cb; }; diff --git a/internal/platform/implementation/credential_storage.h b/internal/platform/implementation/credential_storage.h index 64f31306..c682b357 100644 --- a/internal/platform/implementation/credential_storage.h +++ b/internal/platform/implementation/credential_storage.h @@ -28,8 +28,8 @@ namespace api { // Credential Storage interface class CredentialStorage { public: - using PrivateCredential = ::nearby::internal::PrivateCredential; - using PublicCredential = ::nearby::internal::PublicCredential; + using LocalCredential = ::nearby::internal::LocalCredential; + using SharedCredential = ::nearby::internal::SharedCredential; using PublicCredentialType = ::nearby::presence::PublicCredentialType; using SaveCredentialsResultCallback = ::nearby::presence::SaveCredentialsResultCallback; @@ -55,8 +55,8 @@ class CredentialStorage { // which is used for querying credentials. virtual void SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& private_credentials, - const std::vector& public_credentials, + const std::vector& Local_credentials, + const std::vector& Shared_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback) = 0; diff --git a/internal/platform/implementation/g3/credential_storage_impl.cc b/internal/platform/implementation/g3/credential_storage_impl.cc index 8c53ec29..1195c563 100644 --- a/internal/platform/implementation/g3/credential_storage_impl.cc +++ b/internal/platform/implementation/g3/credential_storage_impl.cc @@ -52,8 +52,8 @@ void FilterIdentityType(std::vector& credentials, void CredentialStorageImpl::SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& private_credentials, - const std::vector& public_credentials, + const std::vector& private_credentials, + const std::vector& public_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback) { if (private_credentials.empty() && public_credentials.empty()) { @@ -117,7 +117,7 @@ void CredentialStorageImpl::GetPrivateCredentials( absl::StrFormat("No private credentials for %v", credential_selector))); return; } - std::vector private_credentials = + std::vector private_credentials = private_credentials_map_[key]; FilterIdentityType(private_credentials, credential_selector.identity_type); if (private_credentials.empty()) { @@ -145,7 +145,7 @@ void CredentialStorageImpl::GetPublicCredentials( absl::StrFormat("No public credentials for %v", credential_selector))); return; } - std::vector public_credentials = + std::vector public_credentials = public_credentials_map_[key]; FilterIdentityType(public_credentials, credential_selector.identity_type); if (public_credentials.empty()) { diff --git a/internal/platform/implementation/g3/credential_storage_impl.h b/internal/platform/implementation/g3/credential_storage_impl.h index 01956dd4..2d14be72 100644 --- a/internal/platform/implementation/g3/credential_storage_impl.h +++ b/internal/platform/implementation/g3/credential_storage_impl.h @@ -38,8 +38,8 @@ namespace g3 { */ class CredentialStorageImpl : public api::CredentialStorage { public: - using PrivateCredential = ::nearby::internal::PrivateCredential; - using PublicCredential = ::nearby::internal::PublicCredential; + using LocalCredential = ::nearby::internal::LocalCredential; + using SharedCredential = ::nearby::internal::SharedCredential; using PublicCredentialType = ::nearby::presence::PublicCredentialType; using PrivateCredentialKey = std::pair; using PublicCredentialKey = @@ -51,8 +51,8 @@ class CredentialStorageImpl : public api::CredentialStorage { // Used to save private and public credentials. void SaveCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& private_credentials, - const std::vector& public_credentials, + const std::vector& private_credentials, + const std::vector& public_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback) override; @@ -79,9 +79,9 @@ class CredentialStorageImpl : public api::CredentialStorage { return std::make_tuple(std::string(manager_app_id), std::string(account_name), credential_type); } - absl::flat_hash_map> + absl::flat_hash_map> private_credentials_map_; - absl::flat_hash_map> + absl::flat_hash_map> public_credentials_map_; absl::Mutex private_mutex_; absl::Mutex public_mutex_; diff --git a/internal/proto/credential.proto b/internal/proto/credential.proto index c6ca1432..1a70c7ff 100644 --- a/internal/proto/credential.proto +++ b/internal/proto/credential.proto @@ -15,12 +15,12 @@ enum IdentityType { } // A proto to store the local device's private credential. -message PrivateCredential { +message LocalCredential { optional IdentityType identity_type = 1; // The unique id of (and hashed based on) a pair of secret - // key (PrivateCredential.verification_key) and X509Certificate's public - // key (PublicCredential.verification_key). + // key (LocalCredential.verification_key) and X509Certificate's public + // key (SharedCredential.verification_key). optional bytes secret_id = 2; // The aes key to encrypt personal fields in public certificates. @@ -48,7 +48,7 @@ message PrivateCredential { optional DeviceMetadata device_metadata = 9; } -message PublicCredential { +message SharedCredential { optional IdentityType identity_type = 1; // The unique id of (and hashed based on) a pair of secret diff --git a/presence/credential_test.cc b/presence/credential_test.cc index b9b6aa87..5dec370c 100644 --- a/presence/credential_test.cc +++ b/presence/credential_test.cc @@ -25,21 +25,21 @@ namespace nearby { namespace presence { namespace { using ::nearby::internal::DeviceMetadata; -using ::nearby::internal::PrivateCredential; -using ::nearby::internal::PublicCredential; +using ::nearby::internal::LocalCredential; +using ::nearby::internal::SharedCredential; using ::nearby::internal::IdentityType::IDENTITY_TYPE_PROVISIONED; using ::nearby::internal::IdentityType::IDENTITY_TYPE_PUBLIC; using ::protobuf_matchers::EqualsProto; TEST(CredentialsTest, NoDefaultConstructor) { - EXPECT_FALSE(std::is_trivially_constructible::value); - EXPECT_FALSE(std::is_trivially_constructible::value); + EXPECT_FALSE(std::is_trivially_constructible::value); + EXPECT_FALSE(std::is_trivially_constructible::value); } -TEST(CredentialsTest, InitPublicCredential) { - PublicCredential pc1 = {}; - PublicCredential pc2 = {}; +TEST(CredentialsTest, InitSharedCredential) { + SharedCredential pc1 = {}; + SharedCredential pc2 = {}; EXPECT_THAT(pc1, EqualsProto(pc2)); pc1.set_identity_type(IDENTITY_TYPE_PUBLIC); EXPECT_THAT(pc1, ::testing::Not(EqualsProto(pc2))); @@ -47,9 +47,9 @@ TEST(CredentialsTest, InitPublicCredential) { EXPECT_THAT(pc1, EqualsProto(pc2)); } -TEST(CredentialsTest, InitPrivateCredential) { - PrivateCredential pc1 = {}; - PrivateCredential pc2 = {}; +TEST(CredentialsTest, InitLocalCredential) { + LocalCredential pc1 = {}; + LocalCredential pc2 = {}; EXPECT_THAT(pc1, EqualsProto(pc2)); pc1.set_identity_type(IDENTITY_TYPE_PUBLIC); EXPECT_THAT(pc1, ::testing::Not(EqualsProto(pc2))); @@ -57,24 +57,24 @@ TEST(CredentialsTest, InitPrivateCredential) { EXPECT_THAT(pc1, EqualsProto(pc2)); } -TEST(CredentialsTest, CopyPrivateCredential) { - PrivateCredential pc1 = {}; +TEST(CredentialsTest, CopyLocalCredential) { + LocalCredential pc1 = {}; pc1.set_identity_type(IDENTITY_TYPE_PROVISIONED); auto salts = pc1.mutable_consumed_salts(); salts->insert(std::pair(15, true)); pc1.mutable_device_metadata()->set_device_name("Android Phone"); pc1.mutable_device_metadata()->set_device_type(DeviceMetadata::PHONE); - PrivateCredential pc1_copy = {pc1}; + LocalCredential pc1_copy = {pc1}; EXPECT_THAT(pc1, EqualsProto(pc1_copy)); } -TEST(CredentialsTest, CopyPublicCredential) { - PublicCredential pc1 = {}; +TEST(CredentialsTest, CopySharedCredential) { + SharedCredential pc1 = {}; pc1.set_identity_type(IDENTITY_TYPE_PROVISIONED); for (const uint8_t byte : nearby::Uuid().data()) { pc1.mutable_secret_id()->push_back(byte); } - PublicCredential pc1_copy = {pc1}; + SharedCredential pc1_copy = {pc1}; EXPECT_THAT(pc1, EqualsProto(pc1_copy)); } } // namespace diff --git a/presence/implementation/advertisement_decoder.cc b/presence/implementation/advertisement_decoder.cc index ed40a333..ddc1ac95 100644 --- a/presence/implementation/advertisement_decoder.cc +++ b/presence/implementation/advertisement_decoder.cc @@ -212,7 +212,7 @@ void AdvertisementDecoder::DecodeBaseTxAndAction( } absl::StatusOr AdvertisementDecoder::DecryptLdt( - const std::vector& credentials, + const std::vector& credentials, absl::string_view salt, absl::string_view data_elements) { if (credentials.empty()) { return absl::UnavailableError("No credentials"); @@ -278,7 +278,7 @@ absl::StatusOr AdvertisementDecoder::Decrypt( if (!absl::holds_alternative(scan_filter)) { continue; } - const std::vector& credentials = + const std::vector& credentials = absl::get(scan_filter) .remote_public_credentials; if (credentials.empty()) { diff --git a/presence/implementation/advertisement_decoder.h b/presence/implementation/advertisement_decoder.h index 9d9feac5..aacd270f 100644 --- a/presence/implementation/advertisement_decoder.h +++ b/presence/implementation/advertisement_decoder.h @@ -33,7 +33,7 @@ namespace presence { struct Advertisement { uint8_t version = 0; std::vector data_elements; - absl::StatusOr public_credential = + absl::StatusOr public_credential = absl::NotFoundError(""); internal::IdentityType identity_type = internal::IDENTITY_TYPE_UNSPECIFIED; std::string metadata_key; @@ -45,7 +45,7 @@ class AdvertisementDecoder { AdvertisementDecoder( ScanRequest scan_request, absl::flat_hash_map>* credentials) + std::vector>* credentials) : scan_request_(scan_request), credentials_(credentials) { AddBannedDataTypes(); } @@ -76,7 +76,7 @@ class AdvertisementDecoder { absl::string_view encrypted); void DecodeBaseTxAndAction(absl::string_view serialized_action); absl::StatusOr DecryptLdt( - const std::vector& credentials, + const std::vector& credentials, absl::string_view salt, absl::string_view data_elements); void AddBannedDataTypes(); bool MatchesScanFilter(const std::vector& data_elements, @@ -86,7 +86,7 @@ class AdvertisementDecoder { ScanRequest scan_request_; absl::flat_hash_map>* credentials_ = + std::vector>* credentials_ = nullptr; absl::flat_hash_set banned_data_types_; Advertisement decoded_advertisement_; diff --git a/presence/implementation/advertisement_decoder_test.cc b/presence/implementation/advertisement_decoder_test.cc index 2ed4fec5..22f2977d 100644 --- a/presence/implementation/advertisement_decoder_test.cc +++ b/presence/implementation/advertisement_decoder_test.cc @@ -35,7 +35,7 @@ namespace presence { namespace { using ::nearby::ByteArray; // NOLINT -using ::nearby::internal::PublicCredential; // NOLINT +using ::nearby::internal::SharedCredential; // NOLINT using ::testing::ElementsAre; using ::protobuf_matchers::EqualsProto; using ::testing::Matcher; @@ -55,7 +55,7 @@ ScanRequest GetScanRequest() { } #if USE_RUST_LDT == 1 -ScanRequest GetScanRequest(std::vector credentials) { +ScanRequest GetScanRequest(std::vector credentials) { LegacyPresenceScanFilter scan_filter = {.remote_public_credentials = credentials}; return ScanRequestBuilder() @@ -68,7 +68,7 @@ ScanRequest GetScanRequest(std::vector credentials) { .Build(); } -PublicCredential GetPublicCredential() { +SharedCredential GetPublicCredential() { // Values copied from LDT tests ByteArray seed({204, 219, 36, 137, 233, 252, 172, 66, 179, 147, 72, 184, 148, 30, 209, 154, 29, 54, 14, 117, 224, 152, @@ -76,7 +76,7 @@ PublicCredential GetPublicCredential() { ByteArray known_mac({223, 185, 10, 31, 155, 31, 226, 141, 24, 187, 204, 165, 34, 64, 181, 204, 44, 203, 95, 141, 82, 137, 163, 203, 100, 235, 53, 65, 202, 97, 75, 180}); - PublicCredential public_credential; + SharedCredential public_credential; public_credential.set_authenticity_key(seed.AsStringView()); public_credential.set_metadata_encryption_key_tag(known_mac.AsStringView()); return public_credential; @@ -87,7 +87,7 @@ TEST(AdvertisementDecoder, DecodeBaseNpPrivateAdvertisement) { ByteArray metadata_key( {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174}); absl::flat_hash_map> + std::vector> credentials; credentials[internal::IDENTITY_TYPE_PRIVATE].push_back(GetPublicCredential()); AdvertisementDecoder decoder(GetScanRequest(), &credentials); @@ -111,7 +111,7 @@ TEST(AdvertisementDecoder, const std::string salt = "AB"; ByteArray metadata_key( {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174}); - std::vector credentials = {GetPublicCredential()}; + std::vector credentials = {GetPublicCredential()}; AdvertisementDecoder decoder(GetScanRequest(credentials)); @@ -134,7 +134,7 @@ TEST(AdvertisementDecoder, DecodeBaseNpTrustedAdvertisement) { ByteArray metadata_key( {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174}); absl::flat_hash_map> + std::vector> credentials; credentials[internal::IDENTITY_TYPE_TRUSTED].push_back(GetPublicCredential()); AdvertisementDecoder decoder(GetScanRequest(), &credentials); @@ -161,7 +161,7 @@ TEST(AdvertisementDecoder, DecodeBaseNpProvisionedAdvertisement) { ByteArray metadata_key( {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174}); absl::flat_hash_map> + std::vector> credentials; credentials[internal::IDENTITY_TYPE_PROVISIONED].push_back( GetPublicCredential()); @@ -189,7 +189,7 @@ TEST(AdvertisementDecoder, InvalidEncryptedContent) { ByteArray metadata_key( {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174}); absl::flat_hash_map> + std::vector> credentials; credentials[internal::IDENTITY_TYPE_PRIVATE].push_back(GetPublicCredential()); AdvertisementDecoder decoder(GetScanRequest(), &credentials); diff --git a/presence/implementation/advertisement_factory.cc b/presence/implementation/advertisement_factory.cc index f9e48937..6327360f 100644 --- a/presence/implementation/advertisement_factory.cc +++ b/presence/implementation/advertisement_factory.cc @@ -96,7 +96,7 @@ std::string SerializeAction(const Action& action) { absl::StatusOr AdvertisementFactory::CreateAdvertisement( const BaseBroadcastRequest& request, - std::vector& credentials) const { + std::vector& credentials) const { AdvertisementData advert = {}; if (absl::holds_alternative( request.variant)) { @@ -108,7 +108,7 @@ absl::StatusOr AdvertisementFactory::CreateAdvertisement( absl::StatusOr AdvertisementFactory::CreateBaseNpAdvertisement( const BaseBroadcastRequest& request, - std::vector& credentials) const { + std::vector& credentials) const { const auto& presence = absl::get(request.variant); std::string payload; @@ -181,9 +181,9 @@ AdvertisementFactory::CreateBaseNpAdvertisement( .content = payload}; } absl::StatusOr AdvertisementFactory::EncryptDataElements( - std::vector& credentials, absl::string_view salt, + std::vector& credentials, absl::string_view salt, absl::string_view data_elements) const { - PrivateCredential& credential = credentials.front(); + LocalCredential& credential = credentials.front(); if (credential.metadata_encryption_key().size() != kBaseMetadataSize) { return absl::FailedPreconditionError(absl::StrFormat( "Metadata key size %d, expected %d", diff --git a/presence/implementation/advertisement_factory.h b/presence/implementation/advertisement_factory.h index 019e50f7..edde9aa0 100644 --- a/presence/implementation/advertisement_factory.h +++ b/presence/implementation/advertisement_factory.h @@ -29,7 +29,7 @@ namespace presence { // Builds BLE advertisements from broadcast requests. class AdvertisementFactory { public: - using PrivateCredential = internal::PrivateCredential; + using LocalCredential = internal::LocalCredential; // Returns a `CredentialSelector` if credentials are required to create an // advertisement from the `request`. @@ -39,20 +39,20 @@ class AdvertisementFactory { // Returns a BLE advertisement for given `request. absl::StatusOr CreateAdvertisement( const BaseBroadcastRequest& request, - std::vector& credentials) const; + std::vector& credentials) const; absl::StatusOr CreateAdvertisement( const BaseBroadcastRequest& request) const { - std::vector empty; + std::vector empty; return CreateAdvertisement(request, empty); } private: absl::StatusOr CreateBaseNpAdvertisement( const BaseBroadcastRequest& request, - std::vector& credentials) const; + std::vector& credentials) const; absl::StatusOr EncryptDataElements( - std::vector& credentials, absl::string_view salt, + std::vector& credentials, absl::string_view salt, absl::string_view data_elements) const; }; diff --git a/presence/implementation/advertisement_factory_test.cc b/presence/implementation/advertisement_factory_test.cc index fa138863..3db93440 100644 --- a/presence/implementation/advertisement_factory_test.cc +++ b/presence/implementation/advertisement_factory_test.cc @@ -35,13 +35,13 @@ namespace { using ::nearby::ByteArray; // NOLINT using ::nearby::internal::IdentityType; -using ::nearby::internal::PrivateCredential; // NOLINT +using ::nearby::internal::LocalCredential; // NOLINT using ::testing::NiceMock; using ::testing::Return; using ::testing::status::StatusIs; #if USE_RUST_LDT == 1 -PrivateCredential CreatePrivateCredential(IdentityType identity_type) { +LocalCredential CreatePrivateCredential(IdentityType identity_type) { // Values copied from LDT tests ByteArray seed({204, 219, 36, 137, 233, 252, 172, 66, 179, 147, 72, 184, 148, 30, 209, 154, 29, 54, 14, 117, 224, 152, @@ -49,7 +49,7 @@ PrivateCredential CreatePrivateCredential(IdentityType identity_type) { ByteArray metadata_key( {205, 104, 63, 225, 161, 209, 248, 70, 84, 61, 10, 19, 212, 174}); - PrivateCredential private_credential; + LocalCredential private_credential; private_credential.set_identity_type(identity_type); private_credential.set_authenticity_key(seed.AsStringView()); private_credential.set_metadata_encryption_key(metadata_key.AsStringView()); @@ -60,7 +60,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromPrivateIdentity) { std::string account_name = "Test account"; std::string salt = "AB"; constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PRIVATE; - std::vector credentials = { + std::vector credentials = { CreatePrivateCredential(kIdentity)}; std::vector data_elements; data_elements.emplace_back(DataElement(ActionBit::kActiveUnlockAction)); @@ -85,7 +85,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromTrustedIdentity) { std::string account_name = "Test account"; std::string salt = "AB"; constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_TRUSTED; - std::vector credentials = { + std::vector credentials = { CreatePrivateCredential(kIdentity)}; std::vector data_elements; data_elements.emplace_back(DataElement(ActionBit::kActiveUnlockAction)); @@ -111,7 +111,7 @@ TEST(AdvertisementFactory, CreateAdvertisementFromProvisionedIdentity) { std::string account_name = "Test account"; std::string salt = "AB"; constexpr IdentityType kIdentity = IdentityType::IDENTITY_TYPE_PROVISIONED; - std::vector credentials = { + std::vector credentials = { CreatePrivateCredential(kIdentity)}; std::vector data_elements; data_elements.emplace_back(DataElement(ActionBit::kActiveUnlockAction)); diff --git a/presence/implementation/broadcast_manager.cc b/presence/implementation/broadcast_manager.cc index 1dc2a5e4..3f88b1e4 100644 --- a/presence/implementation/broadcast_manager.cc +++ b/presence/implementation/broadcast_manager.cc @@ -69,7 +69,7 @@ void BroadcastManager::FetchCredentials( .credentials_fetched_cb = [this, id, broadcast_request = std::move(broadcast_request)]( absl::StatusOr< - std::vector<::nearby::internal::PrivateCredential>> + std::vector<::nearby::internal::LocalCredential>> credentials) { if (!credentials.ok()) { NEARBY_LOGS(WARNING) @@ -90,7 +90,7 @@ void BroadcastManager::FetchCredentials( void BroadcastManager::Advertise(BroadcastSessionId id, BaseBroadcastRequest broadcast_request, - std::vector credentials) { + std::vector credentials) { auto it = sessions_.find(id); if (it == sessions_.end()) { NEARBY_LOGS(INFO) << "Broadcast session terminated, id: " << id; diff --git a/presence/implementation/broadcast_manager.h b/presence/implementation/broadcast_manager.h index 7458a76d..81eecf62 100644 --- a/presence/implementation/broadcast_manager.h +++ b/presence/implementation/broadcast_manager.h @@ -42,7 +42,7 @@ class BroadcastManager { using AdvertisingSession = ::nearby::api::ble_v2::BleMedium::AdvertisingSession; using Runnable = ::nearby::Runnable; - using PrivateCredential = internal::PrivateCredential; + using LocalCredential = internal::LocalCredential; BroadcastManager(Mediums& mediums, CredentialManager& credential_manager, SingleThreadExecutor& executor) { mediums_ = &mediums, credential_manager_ = &credential_manager, @@ -85,7 +85,7 @@ class BroadcastManager { ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_); void Advertise(BroadcastSessionId id, BaseBroadcastRequest broadcast_request, - std::vector credentials) + std::vector credentials) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_); absl::flat_hash_map sessions_ ABSL_GUARDED_BY(*executor_); diff --git a/presence/implementation/credential_manager.h b/presence/implementation/credential_manager.h index e5798d8d..84588a26 100644 --- a/presence/implementation/credential_manager.h +++ b/presence/implementation/credential_manager.h @@ -55,7 +55,7 @@ class CredentialManager { // Update remote public credentials. virtual void UpdateRemotePublicCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& + const std::vector& remote_public_creds, UpdateRemotePublicCredentialsCallback credentials_updated_cb) = 0; diff --git a/presence/implementation/credential_manager_impl.cc b/presence/implementation/credential_manager_impl.cc index fb92ef6d..7966bb22 100644 --- a/presence/implementation/credential_manager_impl.cc +++ b/presence/implementation/credential_manager_impl.cc @@ -33,6 +33,7 @@ #include "internal/platform/implementation/crypto.h" #include "internal/platform/logging.h" #include "internal/proto/credential.pb.h" +#include "internal/proto/credential.proto.h" #include "presence/implementation/encryption.h" #include "presence/implementation/ldt.h" @@ -46,8 +47,8 @@ using ::nearby::ExceptionOr; using ::nearby::Future; using ::nearby::internal::DeviceMetadata; using ::nearby::internal::IdentityType; -using ::nearby::internal::PrivateCredential; -using ::nearby::internal::PublicCredential; +using ::nearby::internal::LocalCredential; +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_"; @@ -61,8 +62,8 @@ void CredentialManagerImpl::GenerateCredentials( const std::vector& identity_types, int credential_life_cycle_days, int contiguous_copy_of_credentials, GenerateCredentialsResultCallback credentials_generated_cb) { - std::vector public_credentials; - std::vector private_credentials; + std::vector public_credentials; + std::vector private_credentials; for (auto identity_type : identity_types) { // TODO(b/241587906): Get linux time from the platform (like Android) @@ -115,7 +116,7 @@ void CredentialManagerImpl::GenerateCredentials( void CredentialManagerImpl::UpdateRemotePublicCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& remote_public_creds, + const std::vector& remote_public_creds, UpdateRemotePublicCredentialsCallback credentials_updated_cb) { credential_storage_ptr_->SaveCredentials( manager_app_id, account_name, /* private_credentials */ {}, @@ -144,11 +145,11 @@ void CredentialManagerImpl::UpdateRemotePublicCredentials( }}); } -std::pair +std::pair CredentialManagerImpl::CreatePrivateCredential( const DeviceMetadata& device_metadata, IdentityType identity_type, uint64_t start_time_ms, uint64_t end_time_ms) { - PrivateCredential private_credential; + LocalCredential private_credential; private_credential.set_start_time_millis(start_time_ms); private_credential.set_end_time_millis(end_time_ms); private_credential.set_identity_type(identity_type); @@ -189,15 +190,15 @@ CredentialManagerImpl::CreatePrivateCredential( std::vector public_key; key_pair->ExportPublicKey(&public_key); - return std::pair( + return std::pair( private_credential, CreatePublicCredential(private_credential, public_key)); } -PublicCredential CredentialManagerImpl::CreatePublicCredential( - const PrivateCredential& private_credential, +SharedCredential CredentialManagerImpl::CreatePublicCredential( + const LocalCredential& private_credential, const std::vector& public_key) { - PublicCredential public_credential; + SharedCredential public_credential; public_credential.set_identity_type(private_credential.identity_type()); public_credential.set_secret_id(private_credential.secret_id()); public_credential.set_authenticity_key(private_credential.authenticity_key()); @@ -304,14 +305,14 @@ void CredentialManagerImpl::GetPublicCredentials( credential_selector, public_credential_type, std::move(callback)); } -ExceptionOr> +ExceptionOr> CredentialManagerImpl::GetPrivateCredentialsSync( const CredentialSelector& credential_selector, absl::Duration timeout) { - Future> result; + Future> result; GetPrivateCredentials( credential_selector, {.credentials_fetched_cb = - [result](absl::StatusOr> + [result](absl::StatusOr> credentials) mutable { if (!credentials.ok()) { result.SetException({Exception::kFailed}); @@ -322,15 +323,15 @@ CredentialManagerImpl::GetPrivateCredentialsSync( return result.Get(timeout); } -ExceptionOr> +ExceptionOr> CredentialManagerImpl::GetPublicCredentialsSync( const CredentialSelector& credential_selector, PublicCredentialType public_credential_type, absl::Duration timeout) { - Future> result; + Future> result; GetPublicCredentials( credential_selector, public_credential_type, {.credentials_fetched_cb = - [result](absl::StatusOr> + [result](absl::StatusOr> credentials) mutable { if (!credentials.ok()) { result.SetException({Exception::kFailed}); @@ -424,7 +425,7 @@ CredentialManagerImpl::CreateNotifySubscribersCallback(SubscriberKey key) { return GetPublicCredentialsResultCallback{ .credentials_fetched_cb = [this, key]( - absl::StatusOr> + absl::StatusOr> credentials) { if (!credentials.ok()) { NEARBY_LOGS(WARNING) @@ -443,7 +444,7 @@ CredentialManagerImpl::CreateNotifySubscribersCallback(SubscriberKey key) { void CredentialManagerImpl::NotifySubscribers( const SubscriberKey& key, - std::vector<::nearby::internal::PublicCredential> credentials) { + std::vector credentials) { // We are on `executor_` thread, so we can iterate over `subscribers_` // without locking. auto it = subscribers_.find(key); @@ -463,7 +464,7 @@ void CredentialManagerImpl::NotifySubscribers( } void CredentialManagerImpl::Subscriber::NotifyCredentialsFetched( - std::vector<::nearby::internal::PublicCredential>& credentials) { + std::vector& credentials) { callback_.credentials_fetched_cb(credentials); } diff --git a/presence/implementation/credential_manager_impl.h b/presence/implementation/credential_manager_impl.h index ab155d0b..9388df4e 100644 --- a/presence/implementation/credential_manager_impl.h +++ b/presence/implementation/credential_manager_impl.h @@ -71,7 +71,7 @@ class CredentialManagerImpl : public CredentialManager { void UpdateRemotePublicCredentials( absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& + const std::vector& remote_public_creds, UpdateRemotePublicCredentialsCallback credentials_updated_cb) override; @@ -80,7 +80,7 @@ class CredentialManagerImpl : public CredentialManager { GetPrivateCredentialsResultCallback callback) override; // Blocking version of `GetPrivateCredentials` - nearby::ExceptionOr> + nearby::ExceptionOr> GetPrivateCredentialsSync(const CredentialSelector& credential_selector, absl::Duration timeout); @@ -91,7 +91,7 @@ class CredentialManagerImpl : public CredentialManager { GetPublicCredentialsResultCallback callback) override; // Blocking version of `GetPublicCredentials`. - ::nearby::ExceptionOr> + ::nearby::ExceptionOr> GetPublicCredentialsSync(const CredentialSelector& credential_selector, PublicCredentialType public_credential_type, absl::Duration timeout); @@ -108,14 +108,14 @@ class CredentialManagerImpl : public CredentialManager { absl::string_view authenticity_key, absl::string_view device_metadata_string) override; - std::pair + std::pair CreatePrivateCredential( const nearby::internal::DeviceMetadata& device_metadata, IdentityType identity_type, uint64_t start_time_ms, uint64_t end_time_ms); - nearby::internal::PublicCredential CreatePublicCredential( - const nearby::internal::PrivateCredential& private_credential, + nearby::internal::SharedCredential CreatePublicCredential( + const nearby::internal::LocalCredential& private_credential, const std::vector& public_key); virtual std::string EncryptDeviceMetadata( @@ -150,7 +150,7 @@ class CredentialManagerImpl : public CredentialManager { // Notifies the subscriber about fetched credentials. void NotifyCredentialsFetched( - std::vector<::nearby::internal::PublicCredential>& credentials); + std::vector<::nearby::internal::SharedCredential>& credentials); private: GetPublicCredentialsResultCallback callback_; @@ -167,7 +167,7 @@ class CredentialManagerImpl : public CredentialManager { ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_); void NotifySubscribers( const SubscriberKey& key, - std::vector<::nearby::internal::PublicCredential> credentials) + std::vector<::nearby::internal::SharedCredential> credentials) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_); void AddSubscriber(SubscriberKey key, SubscriberId id, GetPublicCredentialsResultCallback callback) diff --git a/presence/implementation/credential_manager_impl_test.cc b/presence/implementation/credential_manager_impl_test.cc index b61b4727..e9b136e5 100644 --- a/presence/implementation/credential_manager_impl_test.cc +++ b/presence/implementation/credential_manager_impl_test.cc @@ -40,8 +40,8 @@ using ::nearby::Crypto; using ::nearby::MediumEnvironment; using ::nearby::internal::DeviceMetadata; using ::nearby::internal::IdentityType; -using ::nearby::internal::PrivateCredential; -using ::nearby::internal::PublicCredential; +using ::nearby::internal::LocalCredential; +using ::nearby::internal::SharedCredential; using ::nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE; using ::proto2::contrib::parse_proto::ParseTestProto; using ::protobuf_matchers::EqualsProto; @@ -77,9 +77,9 @@ class CredentialManagerImplTest : public ::testing::Test { MOCK_METHOD(void, SaveCredentials, (absl::string_view manager_app_id, absl::string_view account_name, - const std::vector<::nearby::internal::PrivateCredential>& + const std::vector& private_credentials, - const std::vector<::nearby::internal::PublicCredential>& + const std::vector& public_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback), @@ -127,7 +127,7 @@ class CredentialManagerImplTest : public ::testing::Test { device_metadata, manager_app_id, {identity_type}, /*credential_life_cycle_days=*/1, /*contigous_copy_of_credentials=*/1, - {[](absl::StatusOr> credentials) { + {[](absl::StatusOr> credentials) { EXPECT_OK(credentials); }}); } @@ -145,7 +145,7 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) { device_metadata, IDENTITY_TYPE_PRIVATE, /* start_time_ms= */ 0, /* end_time_ms= */ 1000); - PrivateCredential private_credential = credentials.first; + LocalCredential private_credential = credentials.first; // Verify the private credential. EXPECT_THAT(private_credential.device_metadata(), @@ -160,7 +160,7 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) { EXPECT_EQ(private_credential.metadata_encryption_key().size(), CredentialManagerImpl::kAuthenticityKeyByteSize); - PublicCredential public_credential = credentials.second; + SharedCredential public_credential = credentials.second; // Verify the public credential. EXPECT_EQ(public_credential.identity_type(), IDENTITY_TYPE_PRIVATE); EXPECT_FALSE(public_credential.secret_id().empty()); @@ -187,14 +187,14 @@ TEST_F(CredentialManagerImplTest, CreateOneCredentialSuccessfully) { TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) { DeviceMetadata device_metadata = CreateTestDeviceMetadata(); - absl::StatusOr> + absl::StatusOr> public_credentials; std::vector identityTypes{IDENTITY_TYPE_PRIVATE}; credential_manager_.GenerateCredentials( device_metadata, kManagerAppId, identityTypes, 1, 2, {.credentials_generated_cb = - [&](absl::StatusOr> + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); @@ -213,8 +213,8 @@ TEST_F(CredentialManagerImplTest, GenerateCredentialsSuccessfully) { TEST_F(CredentialManagerImplTest, SubscribeCallsCallbackWithExistingCredentials) { - absl::StatusOr> public_credentials1; - absl::StatusOr> public_credentials2; + absl::StatusOr> public_credentials1; + absl::StatusOr> public_credentials2; AddLocalIdentity(kManagerAppId, kAccountName, IDENTITY_TYPE_PRIVATE); SubscriberId id1 = credential_manager_.SubscribeForPublicCredentials( @@ -223,7 +223,7 @@ TEST_F(CredentialManagerImplTest, .identity_type = IDENTITY_TYPE_PRIVATE}, PublicCredentialType::kLocalPublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { public_credentials1 = std::move(credentials); }}); SubscriberId id2 = credential_manager_.SubscribeForPublicCredentials( @@ -232,7 +232,7 @@ TEST_F(CredentialManagerImplTest, .identity_type = IDENTITY_TYPE_PRIVATE}, PublicCredentialType::kLocalPublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { public_credentials2 = std::move(credentials); }}); @@ -249,7 +249,7 @@ TEST_F(CredentialManagerImplTest, TEST_F(CredentialManagerImplTest, SubscribeCallsCallbackWithUpdatedCredentials) { - absl::StatusOr> public_credentials; + absl::StatusOr> public_credentials; SubscriberId id = credential_manager_.SubscribeForPublicCredentials( CredentialSelector{.manager_app_id = std::string(kManagerAppId), @@ -257,7 +257,7 @@ TEST_F(CredentialManagerImplTest, .identity_type = IDENTITY_TYPE_PRIVATE}, PublicCredentialType::kLocalPublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); Fence(); @@ -274,14 +274,14 @@ TEST_F(CredentialManagerImplTest, } TEST_F(CredentialManagerImplTest, NoCallbacksAfterUnsubscribe) { - absl::StatusOr> public_credentials; + absl::StatusOr> public_credentials; SubscriberId id = credential_manager_.SubscribeForPublicCredentials( CredentialSelector{.manager_app_id = std::string(kManagerAppId), .account_name = std::string(kAccountName), .identity_type = IDENTITY_TYPE_PRIVATE}, PublicCredentialType::kLocalPublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); @@ -300,8 +300,8 @@ TEST_F(CredentialManagerImplTest, EXPECT_CALL(*credential_storage_ptr, SaveCredentials) .WillOnce(::testing::Invoke( [](absl::string_view manager_app_id, absl::string_view account_name, - const std::vector& private_credentials, - const std::vector& public_credentials, + const std::vector& private_credentials, + const std::vector& public_credentials, PublicCredentialType public_credential_type, SaveCredentialsResultCallback callback) { callback.credentials_saved_cb( @@ -309,14 +309,14 @@ TEST_F(CredentialManagerImplTest, })); credential_manager_ = CredentialManagerImpl(&executor_, std::move(credential_storage_ptr)); - absl::StatusOr> + absl::StatusOr> public_credentials; std::vector identityTypes{IDENTITY_TYPE_PRIVATE}; credential_manager_.GenerateCredentials( device_metadata, kManagerAppId, identityTypes, 1, 2, {.credentials_generated_cb = - [&](absl::StatusOr> + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); @@ -325,10 +325,10 @@ TEST_F(CredentialManagerImplTest, } TEST_F(CredentialManagerImplTest, UpdateRemotePublicCredentialsSuccessfully) { - nearby::internal::PublicCredential public_credential_for_test; + SharedCredential public_credential_for_test; public_credential_for_test.set_identity_type( - nearby::internal::IdentityType::IDENTITY_TYPE_TRUSTED); - std::vector public_credentials{ + IdentityType::IDENTITY_TYPE_TRUSTED); + std::vector public_credentials{ {public_credential_for_test}}; nearby::CountDownLatch updated_latch(1); @@ -350,11 +350,11 @@ TEST_F(CredentialManagerImplTest, UpdateRemotePublicCredentialsSuccessfully) { TEST_F(CredentialManagerImplTest, UpdateRemotePublicCredentialsNotifiesSubscribers) { - absl::StatusOr> subscribed_credentials; - nearby::internal::PublicCredential public_credential_for_test; + absl::StatusOr> subscribed_credentials; + SharedCredential public_credential_for_test; public_credential_for_test.set_identity_type( - nearby::internal::IdentityType::IDENTITY_TYPE_PRIVATE); - std::vector public_credentials{ + IdentityType::IDENTITY_TYPE_PRIVATE); + std::vector public_credentials{ {public_credential_for_test}}; nearby::CountDownLatch updated_latch(1); UpdateRemotePublicCredentialsCallback update_credentials_cb{ @@ -371,7 +371,7 @@ TEST_F(CredentialManagerImplTest, .identity_type = internal::IDENTITY_TYPE_PRIVATE}, PublicCredentialType::kRemotePublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { subscribed_credentials = std::move(credentials); }}); SubscriberId id2 = credential_manager_.SubscribeForPublicCredentials( @@ -380,7 +380,7 @@ TEST_F(CredentialManagerImplTest, .identity_type = internal::IDENTITY_TYPE_TRUSTED}, PublicCredentialType::kRemotePublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { // This callback should not be called because there are no Trusted // credentials in this test. GTEST_FAIL(); @@ -398,14 +398,14 @@ TEST_F(CredentialManagerImplTest, credential_manager_.UnsubscribeFromPublicCredentials(id2); } -TEST_F(CredentialManagerImplTest, GetPrivateCredentialsFailed) { - absl::StatusOr> private_credentials; +TEST_F(CredentialManagerImplTest, GetLocalCredentialsFailed) { + absl::StatusOr> private_credentials; CredentialSelector credential_selector = BuildDefaultCredentialSelector(); credential_manager_.GetPrivateCredentials( credential_selector, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { private_credentials = std::move(credentials); }}); @@ -413,13 +413,13 @@ TEST_F(CredentialManagerImplTest, GetPrivateCredentialsFailed) { } TEST_F(CredentialManagerImplTest, GetPublicCredentialsFailed) { - absl::StatusOr> public_credentials; + absl::StatusOr> public_credentials; CredentialSelector credential_selector = BuildDefaultCredentialSelector(); credential_manager_.GetPublicCredentials( credential_selector, PublicCredentialType::kLocalPublicCredential, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); @@ -428,23 +428,23 @@ TEST_F(CredentialManagerImplTest, GetPublicCredentialsFailed) { TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) { DeviceMetadata device_metadata = CreateTestDeviceMetadata(); - absl::StatusOr> + absl::StatusOr> public_credentials; std::vector identity_types{IDENTITY_TYPE_PRIVATE}; - absl::StatusOr> private_credentials; + absl::StatusOr> private_credentials; CredentialSelector credential_selector = BuildDefaultCredentialSelector(); credential_manager_.GenerateCredentials( device_metadata, kManagerAppId, identity_types, 1, 1, {.credentials_generated_cb = - [&](absl::StatusOr> + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); credential_manager_.GetPrivateCredentials( credential_selector, {.credentials_fetched_cb = - [&](absl::StatusOr> credentials) { + [&](absl::StatusOr> credentials) { private_credentials = std::move(credentials); }}); @@ -456,7 +456,7 @@ TEST_F(CredentialManagerImplTest, GetCredentialsSuccessfully) { TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) { DeviceMetadata device_metadata = CreateTestDeviceMetadata(); - absl::StatusOr> + absl::StatusOr> public_credentials; auto credential_manager_ptr = std::make_unique( @@ -471,7 +471,7 @@ TEST_F(CredentialManagerImplTest, PublicCredentialsFailEncryption) { credential_manager_ptr->GenerateCredentials( device_metadata, kManagerAppId, identity_types, 1, 1, {.credentials_generated_cb = - [&](absl::StatusOr> + [&](absl::StatusOr> credentials) { public_credentials = std::move(credentials); }}); diff --git a/presence/implementation/scan_manager.cc b/presence/implementation/scan_manager.cc index d335bee6..5af4678c 100644 --- a/presence/implementation/scan_manager.cc +++ b/presence/implementation/scan_manager.cc @@ -131,7 +131,7 @@ void ScanManager::FetchCredentials(ScanSessionId id, {.credentials_fetched_cb = [this, id, identity_type = selector.identity_type]( absl::StatusOr< - std::vector<::nearby::internal::PublicCredential>> + std::vector<::nearby::internal::SharedCredential>> credentials) { if (!credentials.ok()) { NEARBY_LOGS(WARNING) @@ -152,7 +152,7 @@ void ScanManager::FetchCredentials(ScanSessionId id, void ScanManager::UpdateCredentials(ScanSessionId id, IdentityType identity_type, - std::vector credentials) { + std::vector credentials) { auto it = scan_sessions_.find(id); if (it == scan_sessions_.end()) { return; diff --git a/presence/implementation/scan_manager.h b/presence/implementation/scan_manager.h index 422e1453..9262c09b 100644 --- a/presence/implementation/scan_manager.h +++ b/presence/implementation/scan_manager.h @@ -19,6 +19,7 @@ #include #include #include +#include #include "absl/container/flat_hash_map.h" #include "internal/platform/single_thread_executor.h" @@ -42,7 +43,7 @@ class ScanManager { using ScanningSession = ::nearby::api::ble_v2::BleMedium::ScanningSession; using Runnable = ::nearby::Runnable; using BleAdvertisementData = ::nearby::api::ble_v2::BleAdvertisementData; - using PublicCredential = ::nearby::internal::PublicCredential; + using SharedCredential = ::nearby::internal::SharedCredential; using IdentityType = ::nearby::internal::IdentityType; ScanManager(Mediums& mediums, CredentialManager& credential_manager, @@ -62,7 +63,7 @@ class ScanManager { struct ScanSessionState { ScanRequest request; ScanCallback callback; - absl::flat_hash_map> + absl::flat_hash_map> credentials; AdvertisementDecoder decoder; std::unique_ptr scanning_session; @@ -73,7 +74,7 @@ class ScanManager { void FetchCredentials(ScanSessionId id, const ScanRequest& scan_request) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_); void UpdateCredentials(ScanSessionId id, IdentityType identity_type, - std::vector credentials) + std::vector credentials) ABSL_EXCLUSIVE_LOCKS_REQUIRED(*executor_); void RunOnServiceControllerThread(absl::string_view name, Runnable runnable) { executor_->Execute(std::string(name), std::move(runnable)); diff --git a/presence/scan_request.h b/presence/scan_request.h index 9030fa2d..ff05e53b 100644 --- a/presence/scan_request.h +++ b/presence/scan_request.h @@ -56,7 +56,7 @@ struct LegacyPresenceScanFilter { // Android T needs clients to provide remote public credentials in scan // requests. - std::vector remote_public_credentials; + std::vector remote_public_credentials; // A list of presence actions for matching. Matching condition is met as // long as there’s one or more equal actions between Scan actions and