diff options
Diffstat (limited to 'chromium/components/password_manager/core/browser/hash_password_manager_unittest.cc')
| -rw-r--r-- | chromium/components/password_manager/core/browser/hash_password_manager_unittest.cc | 191 |
1 files changed, 185 insertions, 6 deletions
diff --git a/chromium/components/password_manager/core/browser/hash_password_manager_unittest.cc b/chromium/components/password_manager/core/browser/hash_password_manager_unittest.cc index 5ff06f30fb7..02ed3e064ff 100644 --- a/chromium/components/password_manager/core/browser/hash_password_manager_unittest.cc +++ b/chromium/components/password_manager/core/browser/hash_password_manager_unittest.cc @@ -23,6 +23,8 @@ class HashPasswordManagerTest : public testing::Test { prefs_.registry()->RegisterStringPref(prefs::kSyncPasswordLengthAndHashSalt, std::string(), PrefRegistry::NO_REGISTRATION_FLAGS); + prefs_.registry()->RegisterListPref(prefs::kPasswordHashDataList, + PrefRegistry::NO_REGISTRATION_FLAGS); // Mock OSCrypt. There is a call to OSCrypt on initializling // PasswordReuseDetector, so it should be mocked. OSCryptMocker::SetUp(); @@ -34,7 +36,7 @@ class HashPasswordManagerTest : public testing::Test { TestingPrefServiceSimple prefs_; }; -TEST_F(HashPasswordManagerTest, Saving) { +TEST_F(HashPasswordManagerTest, SavingSyncPasswordData) { ASSERT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); HashPasswordManager hash_password_manager; hash_password_manager.set_prefs(&prefs_); @@ -61,7 +63,116 @@ TEST_F(HashPasswordManagerTest, Saving) { EXPECT_TRUE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); } -TEST_F(HashPasswordManagerTest, Clearing) { +TEST_F(HashPasswordManagerTest, SavingPasswordHashData) { + ASSERT_FALSE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + HashPasswordManager hash_password_manager; + hash_password_manager.set_prefs(&prefs_); + base::string16 password(base::UTF8ToUTF16("password")); + std::string username("user@example.com"); + + // Verify |SavePasswordHash(const std::string,const base::string16&)| + // behavior. + hash_password_manager.SavePasswordHash(username, password, + /*force_update=*/true); + EXPECT_TRUE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + + // Saves the same password again won't change password hash, length or salt. + base::Optional<PasswordHashData> current_password_hash_data = + hash_password_manager.RetrievePasswordHash(username, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash(username, password, + /*force_update=*/true); + base::Optional<PasswordHashData> existing_password_data = + hash_password_manager.RetrievePasswordHash(username, + /*is_gaia_password=*/true); + EXPECT_EQ(current_password_hash_data->hash, existing_password_data->hash); + EXPECT_EQ(current_password_hash_data->salt, existing_password_data->salt); + EXPECT_TRUE(current_password_hash_data->is_gaia_password); + EXPECT_TRUE(existing_password_data->is_gaia_password); + + // Verify |SavePasswordHash(const PasswordHashData&)| behavior. + base::string16 new_password(base::UTF8ToUTF16("new_password")); + PasswordHashData new_password_data(username, new_password, + /*force_update=*/true); + EXPECT_TRUE(hash_password_manager.SavePasswordHash(new_password_data)); + EXPECT_NE(current_password_hash_data->hash, + hash_password_manager + .RetrievePasswordHash(username, /*is_gaia_password=*/true) + ->hash); +} + +TEST_F(HashPasswordManagerTest, SavingGaiaPasswordAndNonGaiaPassword) { + ASSERT_FALSE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + HashPasswordManager hash_password_manager; + hash_password_manager.set_prefs(&prefs_); + base::string16 password(base::UTF8ToUTF16("password")); + std::string username("user@example.com"); + + // Saves a Gaia password. + hash_password_manager.SavePasswordHash(username, password, + /*is_gaia_password=*/true); + EXPECT_TRUE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + EXPECT_EQ(1u, hash_password_manager.RetrieveAllPasswordHashes().size()); + + // Saves the same password again but this time it is not a Gaia password. + hash_password_manager.SavePasswordHash(username, password, + /*is_gaia_password=*/false); + // Verifies that there should be two separate entry in the saved hash list. + EXPECT_EQ(2u, hash_password_manager.RetrieveAllPasswordHashes().size()); +} + +TEST_F(HashPasswordManagerTest, SavingMultipleHashesAndRetrieveAll) { + ASSERT_FALSE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + HashPasswordManager hash_password_manager; + hash_password_manager.set_prefs(&prefs_); + base::string16 password(base::UTF8ToUTF16("password")); + + // Save password hash for 6 different users. + hash_password_manager.SavePasswordHash("username1", password, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash("username2", password, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash("username3", password, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash("username4", password, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash("username5", password, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash("username6", password, + /*is_gaia_password=*/true); + hash_password_manager.SavePasswordHash("username3", password, + /*is_gaia_password=*/false); + + // Since kMaxPasswordHashDataDictSize is set to 5, we will only save 5 + // password hashes that were most recently signed in. + EXPECT_EQ(5u, hash_password_manager.RetrieveAllPasswordHashes().size()); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username1", /*is_gaia_password=*/true)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username1", /*is_gaia_password=*/false)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username2", /*is_gaia_password=*/true)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username2", /*is_gaia_password=*/false)); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("username3", + /*is_gaia_password=*/true)); + EXPECT_TRUE(hash_password_manager.HasPasswordHash( + "username3", /*is_gaia_password=*/false)); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("username4", + /*is_gaia_password=*/true)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username4", /*is_gaia_password=*/false)); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("username5", + /*is_gaia_password=*/true)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username5", /*is_gaia_password=*/false)); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("username6", + /*is_gaia_password=*/true)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username6", /*is_gaia_password=*/false)); +} + +TEST_F(HashPasswordManagerTest, ClearingSyncPasswordData) { ASSERT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); HashPasswordManager hash_password_manager; hash_password_manager.set_prefs(&prefs_); @@ -70,7 +181,31 @@ TEST_F(HashPasswordManagerTest, Clearing) { EXPECT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); } -TEST_F(HashPasswordManagerTest, Retrieving) { +TEST_F(HashPasswordManagerTest, ClearingPasswordHashData) { + ASSERT_FALSE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + HashPasswordManager hash_password_manager; + hash_password_manager.set_prefs(&prefs_); + hash_password_manager.SavePasswordHash("username", + base::UTF8ToUTF16("sync_password"), + /*is_gaia_password=*/true); + + hash_password_manager.ClearSavedPasswordHash("other_username", + /*is_gaia_password=*/true); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("username", + /*is_gaia_password=*/true)); + hash_password_manager.ClearSavedPasswordHash("username", + /*is_gaia_password=*/false); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("username", + /*is_gaia_password=*/true)); + + hash_password_manager.ClearSavedPasswordHash("username", + /*is_gaia_password=*/true); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "username", /*is_gaia_password=*/true)); + EXPECT_EQ(0u, hash_password_manager.RetrieveAllPasswordHashes().size()); +} + +TEST_F(HashPasswordManagerTest, RetrievingSyncPasswordData) { ASSERT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); HashPasswordManager hash_password_manager; hash_password_manager.set_prefs(&prefs_); @@ -82,12 +217,39 @@ TEST_F(HashPasswordManagerTest, Retrieving) { ASSERT_TRUE(sync_password_data); EXPECT_EQ(13u, sync_password_data->length); EXPECT_EQ(16u, sync_password_data->salt.size()); - uint64_t expected_hash = HashPasswordManager::CalculateSyncPasswordHash( + uint64_t expected_hash = HashPasswordManager::CalculatePasswordHash( base::UTF8ToUTF16("sync_password"), sync_password_data->salt); EXPECT_EQ(expected_hash, sync_password_data->hash); } -TEST_F(HashPasswordManagerTest, CalculateSyncPasswordHash) { +TEST_F(HashPasswordManagerTest, RetrievingPasswordHashData) { + ASSERT_FALSE(prefs_.HasPrefPath(prefs::kPasswordHashDataList)); + HashPasswordManager hash_password_manager; + hash_password_manager.set_prefs(&prefs_); + hash_password_manager.SavePasswordHash("username", + base::UTF8ToUTF16("password"), + /*is_gaia_password=*/true); + EXPECT_EQ(1u, hash_password_manager.RetrieveAllPasswordHashes().size()); + + base::Optional<PasswordHashData> password_hash_data = + hash_password_manager.RetrievePasswordHash("username", + /*is_gaia_password=*/false); + ASSERT_FALSE(password_hash_data); + password_hash_data = hash_password_manager.RetrievePasswordHash( + "username", /*is_gaia_password=*/true); + ASSERT_TRUE(password_hash_data); + EXPECT_EQ(8u, password_hash_data->length); + EXPECT_EQ(16u, password_hash_data->salt.size()); + uint64_t expected_hash = HashPasswordManager::CalculatePasswordHash( + base::UTF8ToUTF16("password"), password_hash_data->salt); + EXPECT_EQ(expected_hash, password_hash_data->hash); + + base::Optional<PasswordHashData> non_existing_data = + hash_password_manager.RetrievePasswordHash("non_existing_user", true); + ASSERT_FALSE(non_existing_data); +} + +TEST_F(HashPasswordManagerTest, CalculatePasswordHash) { const char* kPlainText[] = {"", "password", "password", "secret"}; const char* kSalt[] = {"", "salt", "123", "456"}; @@ -105,9 +267,26 @@ TEST_F(HashPasswordManagerTest, CalculateSyncPasswordHash) { SCOPED_TRACE(i); base::string16 text = base::UTF8ToUTF16(kPlainText[i]); EXPECT_EQ(kExpectedHash[i], - HashPasswordManager::CalculateSyncPasswordHash(text, kSalt[i])); + HashPasswordManager::CalculatePasswordHash(text, kSalt[i])); } } +TEST_F(HashPasswordManagerTest, MigrateCapturedPasswordHash) { + ASSERT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); + HashPasswordManager hash_password_manager; + hash_password_manager.set_prefs(&prefs_); + hash_password_manager.SavePasswordHash(base::UTF8ToUTF16("sync_password")); + EXPECT_TRUE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); + EXPECT_TRUE(prefs_.HasPrefPath(prefs::kSyncPasswordLengthAndHashSalt)); + + hash_password_manager.MaybeMigrateExistingSyncPasswordHash("sync_username"); + EXPECT_TRUE(hash_password_manager.HasPasswordHash("sync_username", + /*is_gaia_password=*/true)); + EXPECT_FALSE(hash_password_manager.HasPasswordHash( + "sync_username", /*is_gaia_password=*/false)); + EXPECT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordHash)); + EXPECT_FALSE(prefs_.HasPrefPath(prefs::kSyncPasswordLengthAndHashSalt)); +} + } // namespace } // namespace password_manager |