| // Copyright 2015 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/cryptauth/eid_generator.h" |
| |
| #include <memory> |
| |
| #include "base/logging.h" |
| #include "base/memory/ptr_util.h" |
| #include "base/strings/string_util.h" |
| #include "base/test/simple_test_clock.h" |
| #include "base/time/time.h" |
| #include "components/cryptauth/proto/cryptauth_api.pb.h" |
| #include "components/cryptauth/remote_device.h" |
| #include "testing/gmock/include/gmock/gmock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| using testing::_; |
| using testing::AtLeast; |
| using testing::NiceMock; |
| using testing::Return; |
| using testing::StrictMock; |
| using testing::SaveArg; |
| |
| namespace cryptauth { |
| |
| namespace { |
| const int64_t kNumMsInEidPeriod = |
| base::TimeDelta::FromHours(8).InMilliseconds(); |
| const int64_t kNumMsInBeginningOfEidPeriod = |
| base::TimeDelta::FromHours(2).InMilliseconds(); |
| const int32_t kNumBytesInEidValue = 2; |
| const int64_t kNumMsInEidSeedPeriod = |
| base::TimeDelta::FromDays(14).InMilliseconds(); |
| |
| // Midnight on 1/1/2020. |
| const int64_t kDefaultCurrentPeriodStart = 1577836800000L; |
| // 1:43am on 1/1/2020. |
| const int64_t kDefaultCurrentTime = 1577843000000L; |
| |
| // The Base64 encoded values of these raw data strings are, respectively: |
| // "Zmlyc3RTZWVk", "c2Vjb25kU2VlZA==", "dGhpcmRTZWVk","Zm91cnRoU2VlZA==". |
| const std::string kFirstSeed = "firstSeed"; |
| const std::string kSecondSeed = "secondSeed"; |
| const std::string kThirdSeed = "thirdSeed"; |
| const std::string kFourthSeed = "fourthSeed"; |
| |
| const std::string kDefaultAdvertisingDevicePublicKey = "publicKey"; |
| |
| static BeaconSeed CreateBeaconSeed(const std::string& data, |
| const int64_t start_timestamp_ms, |
| const int64_t end_timestamp_ms) { |
| BeaconSeed seed; |
| seed.set_data(data); |
| seed.set_start_time_millis(start_timestamp_ms); |
| seed.set_end_time_millis(end_timestamp_ms); |
| return seed; |
| } |
| |
| static std::string GenerateFakeEidData( |
| const std::string& eid_seed, |
| const int64_t start_of_period_timestamp_ms, |
| const std::string* extra_entropy) { |
| std::hash<std::string> string_hash; |
| int64_t seed_hash = string_hash(eid_seed); |
| int64_t extra_hash = extra_entropy ? string_hash(*extra_entropy) : 0; |
| int64_t fake_data_xor = seed_hash ^ start_of_period_timestamp_ms ^ extra_hash; |
| |
| std::string fake_data(reinterpret_cast<const char*>(&fake_data_xor), |
| sizeof(fake_data_xor)); |
| fake_data.resize(kNumBytesInEidValue); |
| |
| return fake_data; |
| } |
| |
| static std::string GenerateFakeAdvertisement( |
| const std::string& scanning_device_eid_seed, |
| const int64_t start_of_period_timestamp_ms, |
| const std::string& advertising_device_public_key) { |
| std::string fake_scanning_eid = GenerateFakeEidData( |
| scanning_device_eid_seed, start_of_period_timestamp_ms, nullptr); |
| std::string fake_advertising_id = GenerateFakeEidData( |
| scanning_device_eid_seed, start_of_period_timestamp_ms, |
| &advertising_device_public_key); |
| std::string fake_advertisement; |
| fake_advertisement.append(fake_scanning_eid); |
| fake_advertisement.append(fake_advertising_id); |
| return fake_advertisement; |
| } |
| |
| static RemoteDevice CreateRemoteDevice( |
| const std::string& public_key) { |
| RemoteDevice remote_device; |
| remote_device.public_key = public_key; |
| return remote_device; |
| } |
| } // namespace |
| |
| class CryptAuthEidGeneratorTest : public testing::Test { |
| protected: |
| CryptAuthEidGeneratorTest() { |
| scanning_device_beacon_seeds_.push_back(CreateBeaconSeed( |
| kFirstSeed, kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod, |
| kDefaultCurrentPeriodStart)); |
| scanning_device_beacon_seeds_.push_back( |
| CreateBeaconSeed(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod)); |
| scanning_device_beacon_seeds_.push_back(CreateBeaconSeed( |
| kThirdSeed, kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod, |
| kDefaultCurrentPeriodStart + 2 * kNumMsInEidSeedPeriod)); |
| scanning_device_beacon_seeds_.push_back(CreateBeaconSeed( |
| kFourthSeed, kDefaultCurrentPeriodStart + 2 * kNumMsInEidSeedPeriod, |
| kDefaultCurrentPeriodStart + 3 * kNumMsInEidSeedPeriod)); |
| } |
| |
| class TestEidComputationHelper : public EidGenerator::EidComputationHelper { |
| public: |
| TestEidComputationHelper() {} |
| |
| std::string GenerateEidDataForDevice( |
| const std::string& eid_seed, |
| const int64_t start_of_period_timestamp_ms, |
| const std::string* extra_entropy) override { |
| return GenerateFakeEidData(eid_seed, start_of_period_timestamp_ms, |
| extra_entropy); |
| } |
| }; |
| |
| void SetUp() override { |
| test_clock_ = new base::SimpleTestClock(); |
| test_computation_helper_ = new TestEidComputationHelper(); |
| real_computation_helper_.reset( |
| new EidGenerator::EidComputationHelperImpl()); |
| |
| SetTestTime(kDefaultCurrentTime); |
| |
| eid_generator_.reset( |
| new EidGenerator(base::WrapUnique(test_computation_helper_), |
| base::WrapUnique(test_clock_))); |
| } |
| |
| // TODO(khorimoto): Is there an easier way to do this? |
| void SetTestTime(int64_t timestamp_ms) { |
| base::Time time = base::Time::UnixEpoch() + |
| base::TimeDelta::FromMilliseconds(timestamp_ms); |
| test_clock_->SetNow(time); |
| } |
| |
| std::unique_ptr<EidGenerator> eid_generator_; |
| base::SimpleTestClock* test_clock_; |
| TestEidComputationHelper* test_computation_helper_; |
| std::unique_ptr<EidGenerator::EidComputationHelper> real_computation_helper_; |
| std::vector<BeaconSeed> scanning_device_beacon_seeds_; |
| }; |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_StartOfPeriod_AnotherSeedInPreviousPeriod) { |
| SetTestTime(kDefaultCurrentTime); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| EXPECT_EQ(data->GetAdjacentDataType(), |
| EidGenerator::EidData::AdjacentDataType::PAST); |
| |
| EXPECT_EQ(kDefaultCurrentPeriodStart, data->current_data.start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidPeriod, |
| data->current_data.end_timestamp_ms); |
| EXPECT_EQ( |
| GenerateFakeEidData(kSecondSeed, kDefaultCurrentPeriodStart, nullptr), |
| data->current_data.data); |
| |
| ASSERT_TRUE(data->adjacent_data); |
| EXPECT_EQ(kDefaultCurrentPeriodStart - kNumMsInEidPeriod, |
| data->adjacent_data->start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart, data->adjacent_data->end_timestamp_ms); |
| EXPECT_EQ( |
| GenerateFakeEidData( |
| kFirstSeed, kDefaultCurrentPeriodStart - kNumMsInEidPeriod, nullptr), |
| data->adjacent_data->data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_StartOfPeriod_NoSeedBefore) { |
| SetTestTime(kDefaultCurrentTime - kNumMsInEidSeedPeriod); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| EXPECT_EQ(data->GetAdjacentDataType(), |
| EidGenerator::EidData::AdjacentDataType::NONE); |
| |
| EXPECT_EQ(kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod, |
| data->current_data.start_timestamp_ms); |
| EXPECT_EQ( |
| kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod + kNumMsInEidPeriod, |
| data->current_data.end_timestamp_ms); |
| EXPECT_EQ(GenerateFakeEidData( |
| kFirstSeed, kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod, |
| nullptr), |
| data->current_data.data); |
| |
| EXPECT_FALSE(data->adjacent_data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_PastStartOfPeriod) { |
| SetTestTime(kDefaultCurrentTime + |
| base::TimeDelta::FromHours(3).InMilliseconds()); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| EXPECT_EQ(data->GetAdjacentDataType(), |
| EidGenerator::EidData::AdjacentDataType::FUTURE); |
| |
| EXPECT_EQ(kDefaultCurrentPeriodStart, data->current_data.start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidPeriod, |
| data->current_data.end_timestamp_ms); |
| EXPECT_EQ( |
| GenerateFakeEidData(kSecondSeed, kDefaultCurrentPeriodStart, nullptr), |
| data->current_data.data); |
| |
| ASSERT_TRUE(data->adjacent_data); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidPeriod, |
| data->adjacent_data->start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + 2 * kNumMsInEidPeriod, |
| data->adjacent_data->end_timestamp_ms); |
| EXPECT_EQ( |
| GenerateFakeEidData( |
| kSecondSeed, kDefaultCurrentPeriodStart + kNumMsInEidPeriod, nullptr), |
| data->adjacent_data->data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestGenerateEidDataForDevice_EndOfPeriod) { |
| SetTestTime(kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod - 1); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| EXPECT_EQ(data->GetAdjacentDataType(), |
| EidGenerator::EidData::AdjacentDataType::FUTURE); |
| |
| EXPECT_EQ( |
| kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod - kNumMsInEidPeriod, |
| data->current_data.start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod, |
| data->current_data.end_timestamp_ms); |
| EXPECT_EQ(GenerateFakeEidData(kSecondSeed, |
| kDefaultCurrentPeriodStart + |
| kNumMsInEidSeedPeriod - kNumMsInEidPeriod, |
| nullptr), |
| data->current_data.data); |
| |
| ASSERT_TRUE(data->adjacent_data); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod, |
| data->adjacent_data->start_timestamp_ms); |
| EXPECT_EQ( |
| kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod + kNumMsInEidPeriod, |
| data->adjacent_data->end_timestamp_ms); |
| EXPECT_EQ(GenerateFakeEidData( |
| kThirdSeed, kDefaultCurrentPeriodStart + kNumMsInEidSeedPeriod, |
| nullptr), |
| data->adjacent_data->data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_EndOfPeriod_NoSeedAfter) { |
| SetTestTime(kDefaultCurrentPeriodStart + 3 * kNumMsInEidSeedPeriod - 1); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| EXPECT_EQ(data->GetAdjacentDataType(), |
| EidGenerator::EidData::AdjacentDataType::NONE); |
| |
| EXPECT_EQ(kDefaultCurrentPeriodStart + 3 * kNumMsInEidSeedPeriod - |
| kNumMsInEidPeriod, |
| data->current_data.start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + 3 * kNumMsInEidSeedPeriod, |
| data->current_data.end_timestamp_ms); |
| EXPECT_EQ(GenerateFakeEidData(kFourthSeed, kDefaultCurrentPeriodStart + |
| 3 * kNumMsInEidSeedPeriod - |
| kNumMsInEidPeriod, |
| nullptr), |
| data->current_data.data); |
| |
| EXPECT_FALSE(data->adjacent_data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_NoCurrentPeriodSeed) { |
| SetTestTime(kDefaultCurrentPeriodStart + 4 * kNumMsInEidSeedPeriod - 1); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| EXPECT_FALSE(data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, testGenerateEidDataForDevice_EmptySeeds) { |
| SetTestTime(kDefaultCurrentTime); |
| |
| std::vector<BeaconSeed> empty; |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter(empty); |
| EXPECT_FALSE(data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_InvalidSeed_PeriodNotMultipleOf8Hours) { |
| SetTestTime(kDefaultCurrentTime); |
| |
| // Seed has a period of 1ms, but it should have a period of 8 hours. |
| std::vector<BeaconSeed> invalid_seed_vector = {CreateBeaconSeed( |
| kFirstSeed, kDefaultCurrentPeriodStart, kDefaultCurrentPeriodStart + 1)}; |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter(invalid_seed_vector); |
| EXPECT_FALSE(data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateEidDataForDevice_UsingRealEidComputationHelper) { |
| test_clock_ = new base::SimpleTestClock(); |
| SetTestTime(kDefaultCurrentTime); |
| |
| // Use real EidComputationHelper implementation instead of test version. |
| eid_generator_.reset(new EidGenerator(std::move(real_computation_helper_), |
| base::WrapUnique(test_clock_))); |
| |
| std::unique_ptr<EidGenerator::EidData> data = |
| eid_generator_->GenerateBackgroundScanFilter( |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| EXPECT_EQ(data->GetAdjacentDataType(), |
| EidGenerator::EidData::AdjacentDataType::PAST); |
| |
| EXPECT_EQ(kDefaultCurrentPeriodStart, data->current_data.start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidPeriod, |
| data->current_data.end_timestamp_ms); |
| // Since this uses the real EidComputationHelper, just make sure the data |
| // exists and has the proper length. |
| EXPECT_EQ((size_t)kNumBytesInEidValue, data->current_data.data.length()); |
| |
| ASSERT_TRUE(data->adjacent_data); |
| EXPECT_EQ(kDefaultCurrentPeriodStart - kNumMsInEidPeriod, |
| data->adjacent_data->start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart, data->adjacent_data->end_timestamp_ms); |
| // Since this uses the real EidComputationHelper, just make sure the data |
| // exists and has the proper length. |
| EXPECT_EQ((size_t)kNumBytesInEidValue, data->adjacent_data->data.length()); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestGenerateAdvertisementData) { |
| SetTestTime(kDefaultCurrentTime); |
| |
| std::unique_ptr<EidGenerator::DataWithTimestamp> data = |
| eid_generator_->GenerateAdvertisement(kDefaultAdvertisingDevicePublicKey, |
| scanning_device_beacon_seeds_); |
| ASSERT_TRUE(data); |
| |
| EXPECT_EQ(kDefaultCurrentPeriodStart, data->start_timestamp_ms); |
| EXPECT_EQ(kDefaultCurrentPeriodStart + kNumMsInEidPeriod, |
| data->end_timestamp_ms); |
| EXPECT_EQ(GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey), |
| data->data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGenerateAdvertisementData_NoSeedForPeriod) { |
| SetTestTime(kDefaultCurrentTime + 4 * kNumMsInEidSeedPeriod); |
| |
| std::unique_ptr<EidGenerator::DataWithTimestamp> data = |
| eid_generator_->GenerateAdvertisement(kDefaultAdvertisingDevicePublicKey, |
| scanning_device_beacon_seeds_); |
| EXPECT_FALSE(data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestGenerateAdvertisementData_EmptySeeds) { |
| SetTestTime(kDefaultCurrentTime + 4 * kNumMsInEidSeedPeriod); |
| |
| std::vector<BeaconSeed> empty; |
| std::unique_ptr<EidGenerator::DataWithTimestamp> data = |
| eid_generator_->GenerateAdvertisement(kDefaultAdvertisingDevicePublicKey, |
| empty); |
| EXPECT_FALSE(data); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_CurrentAndPastAdjacentPeriods) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| |
| EXPECT_EQ((size_t)2, possible_advertisements.size()); |
| EXPECT_EQ(GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[0]); |
| EXPECT_EQ(GenerateFakeAdvertisement( |
| kFirstSeed, kDefaultCurrentPeriodStart - kNumMsInEidPeriod, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[1]); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| testGeneratePossibleAdvertisements_CurrentAndFutureAdjacentPeriods) { |
| SetTestTime(kDefaultCurrentPeriodStart + |
| base::TimeDelta::FromHours(3).InMilliseconds()); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| |
| EXPECT_EQ((size_t)2, possible_advertisements.size()); |
| EXPECT_EQ(GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[0]); |
| EXPECT_EQ(GenerateFakeAdvertisement( |
| kSecondSeed, kDefaultCurrentPeriodStart + kNumMsInEidPeriod, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[1]); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_OnlyCurrentPeriod) { |
| SetTestTime(kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| |
| EXPECT_EQ((size_t)1, possible_advertisements.size()); |
| EXPECT_EQ(GenerateFakeAdvertisement( |
| kFirstSeed, kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[0]); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_OnlyFuturePeriod) { |
| SetTestTime(kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod - |
| kNumMsInEidPeriod); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| |
| EXPECT_EQ((size_t)1, possible_advertisements.size()); |
| EXPECT_EQ(GenerateFakeAdvertisement( |
| kFirstSeed, kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[0]); |
| } |
| |
| TEST_F( |
| CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_NoAdvertisements_SeedsTooFarInFuture) { |
| SetTestTime(kDefaultCurrentPeriodStart - kNumMsInEidSeedPeriod - |
| kNumMsInEidPeriod - 1); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| EXPECT_TRUE(possible_advertisements.empty()); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_OnlyPastPeriod) { |
| SetTestTime(kDefaultCurrentPeriodStart + 3 * kNumMsInEidSeedPeriod + |
| kNumMsInEidPeriod); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| |
| EXPECT_EQ((size_t)1, possible_advertisements.size()); |
| EXPECT_EQ(GenerateFakeAdvertisement( |
| kFourthSeed, kDefaultCurrentPeriodStart + |
| 3 * kNumMsInEidSeedPeriod - kNumMsInEidPeriod, |
| kDefaultAdvertisingDevicePublicKey), |
| possible_advertisements[0]); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_NoAdvertisements_SeedsTooFarInPast) { |
| SetTestTime(kDefaultCurrentPeriodStart + 3 * kNumMsInEidSeedPeriod + |
| kNumMsInEidPeriod + 1); |
| |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, scanning_device_beacon_seeds_); |
| EXPECT_TRUE(possible_advertisements.empty()); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestGeneratePossibleAdvertisements_NoAdvertisements_EmptySeeds) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::vector<BeaconSeed> empty; |
| std::vector<std::string> possible_advertisements = |
| eid_generator_->GeneratePossibleAdvertisements( |
| kDefaultAdvertisingDevicePublicKey, empty); |
| EXPECT_TRUE(possible_advertisements.empty()); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestIdentifyRemoteDevice_NoDevices) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| std::vector<RemoteDevice> device_list; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_FALSE(identified_device); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestIdentifyRemoteDevice_OneDevice_Success) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| RemoteDevice correct_device = |
| CreateRemoteDevice(kDefaultAdvertisingDevicePublicKey); |
| std::vector<RemoteDevice> device_list = {correct_device}; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_EQ(correct_device.public_key, identified_device->public_key); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestIdentifyRemoteDevice_OneDevice_ServiceDataWithOneByteFlag_Success) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| // Identifying device should still succeed if there is an extra "flag" byte |
| // after the first 4 bytes. |
| service_data.append(1, static_cast<char>(EidGenerator::kBluetooth4Flag)); |
| |
| RemoteDevice correct_device = |
| CreateRemoteDevice(kDefaultAdvertisingDevicePublicKey); |
| std::vector<RemoteDevice> device_list = {correct_device}; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_EQ(correct_device.public_key, identified_device->public_key); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestIdentifyRemoteDevice_OneDevice_ServiceDataWithLongerFlag_Success) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| // Identifying device should still succeed if there are extra "flag" bytes |
| // after the first 4 bytes. |
| service_data.append("extra_flag_bytes"); |
| |
| RemoteDevice correct_device = |
| CreateRemoteDevice(kDefaultAdvertisingDevicePublicKey); |
| std::vector<RemoteDevice> device_list = {correct_device}; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_EQ(correct_device.public_key, identified_device->public_key); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestIdentifyRemoteDevice_OneDevice_Failure) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| RemoteDevice wrong_device = |
| CreateRemoteDevice("wrongPublicKey"); |
| std::vector<RemoteDevice> device_list = {wrong_device}; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_FALSE(identified_device); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestIdentifyRemoteDevice_MultipleDevices_Success) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| RemoteDevice correct_device = |
| CreateRemoteDevice(kDefaultAdvertisingDevicePublicKey); |
| RemoteDevice wrong_device = |
| CreateRemoteDevice("wrongPublicKey"); |
| std::vector<RemoteDevice> device_list = {correct_device, |
| wrong_device}; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_EQ(correct_device.public_key, identified_device->public_key); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestIdentifyRemoteDevice_MultipleDevices_Failure) { |
| SetTestTime(kDefaultCurrentPeriodStart); |
| |
| std::string service_data = |
| GenerateFakeAdvertisement(kSecondSeed, kDefaultCurrentPeriodStart, |
| kDefaultAdvertisingDevicePublicKey); |
| |
| RemoteDevice wrong_device = |
| CreateRemoteDevice("wrongPublicKey"); |
| std::vector<RemoteDevice> device_list = {wrong_device, |
| wrong_device}; |
| const RemoteDevice* identified_device = |
| eid_generator_->IdentifyRemoteDeviceByAdvertisement( |
| service_data, device_list, scanning_device_beacon_seeds_); |
| EXPECT_FALSE(identified_device); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestEidComputationHelperImpl_ProducesTwoByteValue) { |
| EidGenerator::EidComputationHelperImpl helper; |
| std::string eid = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, nullptr); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid.length()); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, TestEidComputationHelperImpl_Deterministic) { |
| EidGenerator::EidComputationHelperImpl helper; |
| std::string eid1 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, nullptr); |
| std::string eid2 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, nullptr); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid1.length()); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid2.length()); |
| EXPECT_EQ(eid1, eid2); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestEidComputationHelperImpl_ChangingSeedChangesOutput) { |
| EidGenerator::EidComputationHelperImpl helper; |
| std::string eid1 = helper.GenerateEidDataForDevice( |
| "eidSeed1", kDefaultCurrentPeriodStart, nullptr); |
| std::string eid2 = helper.GenerateEidDataForDevice( |
| "eidSeed2", kDefaultCurrentPeriodStart, nullptr); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid1.length()); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid2.length()); |
| EXPECT_NE(eid1, eid2); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestEidComputationHelperImpl_ChangingTimestampChangesOutput) { |
| EidGenerator::EidComputationHelperImpl helper; |
| std::string eid1 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, nullptr); |
| std::string eid2 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart + 1, nullptr); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid1.length()); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid2.length()); |
| EXPECT_NE(eid1, eid2); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestEidComputationHelperImpl_ChangingExtraEntropyChangesOutput) { |
| EidGenerator::EidComputationHelperImpl helper; |
| std::string eid1 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, nullptr); |
| std::string extra_entropy = "extraEntropy"; |
| std::string eid2 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, &extra_entropy); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid1.length()); |
| EXPECT_EQ((size_t)kNumBytesInEidValue, eid2.length()); |
| EXPECT_NE(eid1, eid2); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestEidComputationHelper_ChangingTimestampWithLongExtraEntropy) { |
| EidGenerator::EidComputationHelperImpl helper; |
| std::string long_extra_entropy = |
| "reallyReallyReallyReallyReallyReallyReallyLongExtraEntropy"; |
| std::string eid1 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart, &long_extra_entropy); |
| std::string extra_entropy = "extraEntropy"; |
| std::string eid2 = helper.GenerateEidDataForDevice( |
| "eidSeed", kDefaultCurrentPeriodStart + 1, &long_extra_entropy); |
| EXPECT_NE(eid1, eid2); |
| } |
| |
| // Tests that "known test vectors" are correct. This ensures that the same test |
| // vectors produce the same outputs on other platforms. |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestEidComputationHelper_EnsureTestVectorsPass) { |
| const int8_t test_eid_seed1[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, |
| 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, |
| 23, 24, 25, 26, 27, 28, 29, 30, 31, 32}; |
| const int64_t test_timestamp1 = 2468101214L; |
| const int8_t test_entropy1[] = {2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, |
| 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, |
| 24, 25, 26, 27, 28, 29, 30, 31, 32, 33}; |
| |
| std::string test_eid_seed1_str(reinterpret_cast<const char*>(test_eid_seed1), |
| sizeof(test_eid_seed1)); |
| std::string test_entropy1_str(reinterpret_cast<const char*>(test_entropy1), |
| sizeof(test_entropy1)); |
| |
| const int8_t test_eid_seed2[] = {3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, |
| 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, |
| 25, 26, 27, 28, 29, 30, 31, 32, 33, 34}; |
| const int64_t test_timestamp2 = 51015202530L; |
| const int8_t test_entropy2[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, |
| 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, |
| 26, 27, 28, 29, 30, 31, 32, 33, 34, 35}; |
| |
| std::string test_eid_seed2_str(reinterpret_cast<const char*>(test_eid_seed2), |
| sizeof(test_eid_seed2)); |
| std::string test_entropy2_str(reinterpret_cast<const char*>(test_entropy2), |
| sizeof(test_entropy2)); |
| |
| EidGenerator::EidComputationHelperImpl helper; |
| |
| std::string test_eid_without_entropy1 = helper.GenerateEidDataForDevice( |
| test_eid_seed1_str, test_timestamp1, nullptr); |
| EXPECT_EQ("\x7d\x2c", test_eid_without_entropy1); |
| |
| std::string test_eid_with_entropy1 = helper.GenerateEidDataForDevice( |
| test_eid_seed1_str, test_timestamp1, &test_entropy1_str); |
| EXPECT_EQ("\xdc\xf3", test_eid_with_entropy1); |
| |
| std::string test_eid_without_entropy2 = helper.GenerateEidDataForDevice( |
| test_eid_seed2_str, test_timestamp2, nullptr); |
| EXPECT_EQ("\x02\xdd", test_eid_without_entropy2); |
| |
| std::string test_eid_with_entropy2 = helper.GenerateEidDataForDevice( |
| test_eid_seed2_str, test_timestamp2, &test_entropy2_str); |
| EXPECT_EQ("\xee\xcc", test_eid_with_entropy2); |
| } |
| |
| TEST_F(CryptAuthEidGeneratorTest, |
| TestDataWithTimestamp_ContainsTime) { |
| EidGenerator::DataWithTimestamp data_with_timestamp( |
| "data", /* start */ 1000L, /* end */ 2000L); |
| EXPECT_FALSE(data_with_timestamp.ContainsTime(999L)); |
| EXPECT_TRUE(data_with_timestamp.ContainsTime(1000L)); |
| EXPECT_TRUE(data_with_timestamp.ContainsTime(1500L)); |
| EXPECT_TRUE(data_with_timestamp.ContainsTime(1999L)); |
| EXPECT_FALSE(data_with_timestamp.ContainsTime(2000L)); |
| } |
| |
| } // namespace cryptauth |
