chrome/browser/chromeos/login/supervised/supervised_user_password_browsertest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/compiler_specific.h"
   8 #include "base/run_loop.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "base/threading/sequenced_worker_pool.h"
  11 #include "chrome/browser/chrome_notification_types.h"
  12 #include "chrome/browser/chromeos/login/login_manager_test.h"
  13 #include "chrome/browser/chromeos/login/startup_utils.h"
  14 #include "chrome/browser/chromeos/login/supervised/supervised_user_authentication.h"
  15 #include "chrome/browser/chromeos/login/supervised/supervised_user_test_base.h"
  16 #include "chrome/browser/chromeos/login/ui/login_display_host_impl.h"
  17 #include "chrome/browser/chromeos/login/ui/webui_login_view.h"
  18 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
  19 #include "chrome/browser/chromeos/login/users/supervised_user_manager.h"
  20 #include "chrome/browser/chromeos/net/network_portal_detector_test_impl.h"
  21 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
  22 #include "chrome/browser/supervised_user/supervised_user_constants.h"
  23 #include "chromeos/cryptohome/mock_async_method_caller.h"
  24 #include "chromeos/cryptohome/mock_homedir_methods.h"
  25 #include "content/public/browser/notification_service.h"
  26 #include "content/public/test/browser_test_utils.h"
  27 #include "content/public/test/test_utils.h"
  28 #include "sync/api/fake_sync_change_processor.h"
  29 #include "sync/api/sync_change.h"
  30 #include "sync/api/sync_error_factory_mock.h"
  31 #include "sync/internal_api/public/attachments/attachment_service_proxy_for_test.h"
  32 #include "sync/protocol/sync.pb.h"
  33
  34 using testing::_;
  35 using chromeos::SupervisedUserTestBase;
  36 using chromeos::kTestSupervisedUserDisplayName;
  37 using chromeos::kTestManager;
  38
  39 namespace chromeos {
  40
  41 class SupervisedUserPasswordTest : public SupervisedUserTestBase {
  42  public:
  43   SupervisedUserPasswordTest() : SupervisedUserTestBase() {}
  44
  45  private:
  46   DISALLOW_COPY_AND_ASSIGN(SupervisedUserPasswordTest);
  47 };
  48
  49 class SupervisedUserPasswordManagerTest : public SupervisedUserTestBase {
  50  public:
  51   SupervisedUserPasswordManagerTest() : SupervisedUserTestBase() {}
  52
  53  private:
  54   DISALLOW_COPY_AND_ASSIGN(SupervisedUserPasswordManagerTest);
  55 };
  56
  57 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
  58                        PRE_PRE_PRE_PasswordChangeFromUserTest) {
  59   PrepareUsers();
  60 }
  61
  62 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
  63                        PRE_PRE_PasswordChangeFromUserTest) {
  64   StartFlowLoginAsManager();
  65   FillNewUserData(kTestSupervisedUserDisplayName);
  66   StartUserCreation("supervised-user-creation-next-button",
  67                     kTestSupervisedUserDisplayName);
  68 }
  69
  70 // Supervised user signs in, get sync notification about password update, and
  71 // schedules password migration.
  72 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
  73                        PRE_PasswordChangeFromUserTest) {
  74   SigninAsSupervisedUser(true, 0, kTestSupervisedUserDisplayName);
  75
  76   const user_manager::User* user =
  77       user_manager::UserManager::Get()->GetUsers().at(0);
  78   std::string sync_id =
  79       ChromeUserManager::Get()->GetSupervisedUserManager()->GetUserSyncId(
  80           user->email());
  81   base::DictionaryValue password;
  82   password.SetIntegerWithoutPathExpansion(
  83       kSchemaVersion, SupervisedUserAuthentication::SCHEMA_SALT_HASHED);
  84   password.SetIntegerWithoutPathExpansion(kPasswordRevision, 2);
  85
  86   password.SetStringWithoutPathExpansion(kPasswordSignature, "signature");
  87   password.SetStringWithoutPathExpansion(kEncryptedPassword,
  88                                          "new-encrypted-password");
  89
  90   shared_settings_adapter_->AddChange(
  91       sync_id, supervised_users::kChromeOSPasswordData, password, true, false);
  92   content::RunAllPendingInMessageLoop();
  93 }
  94
  95 // Supervised user signs in for second time, and actual password migration takes
  96 // place.
  97 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
  98                        PasswordChangeFromUserTest) {
  99   EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
 100   EXPECT_CALL(*mock_homedir_methods_, UpdateKeyEx(_, _, _, _, _)).Times(1);
 101   SigninAsSupervisedUser(false, 0, kTestSupervisedUserDisplayName);
 102   testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 103 }
 104
 105 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 106                        PRE_PRE_PRE_PasswordChangeFromManagerTest) {
 107   PrepareUsers();
 108 }
 109
 110 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 111                        PRE_PRE_PasswordChangeFromManagerTest) {
 112   StartFlowLoginAsManager();
 113   FillNewUserData(kTestSupervisedUserDisplayName);
 114   StartUserCreation("supervised-user-creation-next-button",
 115                     kTestSupervisedUserDisplayName);
 116 }
 117
 118 // Manager signs in, gets sync notification about supervised user password
 119 // update, and performs migration.
 120 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 121                        PRE_PasswordChangeFromManagerTest) {
 122   const user_manager::User* supervised_user =
 123       user_manager::UserManager::Get()->GetUsers().at(0);
 124
 125   SigninAsManager(1);
 126
 127   EXPECT_CALL(*mock_homedir_methods_, AddKeyEx(_, _, _, _, _)).Times(1);
 128
 129   std::string sync_id =
 130       ChromeUserManager::Get()->GetSupervisedUserManager()->GetUserSyncId(
 131           supervised_user->email());
 132
 133   ::sync_pb::ManagedUserSpecifics managed_user_proto;
 134
 135   managed_user_proto.set_id(sync_id);
 136   managed_user_proto.set_name(kTestSupervisedUserDisplayName);
 137   managed_user_proto.set_acknowledged(true);
 138   managed_user_proto.set_master_key("master key");
 139   managed_user_proto.set_password_signature_key("signature_key");
 140   managed_user_proto.set_password_encryption_key("encryption_key");
 141
 142   supervised_users_adapter_->AddChange(managed_user_proto, false);
 143   content::RunAllPendingInMessageLoop();
 144
 145   base::DictionaryValue password;
 146   password.SetIntegerWithoutPathExpansion(
 147       kSchemaVersion, SupervisedUserAuthentication::SCHEMA_SALT_HASHED);
 148   password.SetIntegerWithoutPathExpansion(kPasswordRevision, 2);
 149
 150   password.SetStringWithoutPathExpansion(kPasswordSignature, "signature");
 151   password.SetStringWithoutPathExpansion(kEncryptedPassword,
 152                                          "new-encrypted-password");
 153   shared_settings_adapter_->AddChange(
 154       sync_id, supervised_users::kChromeOSPasswordData, password, true, false);
 155   content::RunAllPendingInMessageLoop();
 156
 157   testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 158 }
 159
 160 // After that supervised user signs in, and no password change happens.
 161 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 162                        PasswordChangeFromManagerTest) {
 163   EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
 164   EXPECT_CALL(*mock_homedir_methods_, UpdateKeyEx(_, _, _, _, _)).Times(0);
 165   SigninAsSupervisedUser(false, 1, kTestSupervisedUserDisplayName);
 166   testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 167 }
 168
 169 IN_PROC_BROWSER_TEST_F(
 170     SupervisedUserPasswordTest,
 171     PRE_PRE_PRE_PRE_PasswordChangeUserAndManagerTest) {
 172   PrepareUsers();
 173 }
 174
 175 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 176                        PRE_PRE_PRE_PasswordChangeUserAndManagerTest) {
 177   StartFlowLoginAsManager();
 178   FillNewUserData(kTestSupervisedUserDisplayName);
 179   StartUserCreation("supervised-user-creation-next-button",
 180                     kTestSupervisedUserDisplayName);
 181 }
 182
 183 // Supervised user signs in, get sync notification about password update, and
 184 // schedules password migration.
 185 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 186                        PRE_PRE_PasswordChangeUserAndManagerTest) {
 187   SigninAsSupervisedUser(true, 0, kTestSupervisedUserDisplayName);
 188
 189   const user_manager::User* user =
 190       user_manager::UserManager::Get()->GetUsers().at(0);
 191   std::string sync_id =
 192       ChromeUserManager::Get()->GetSupervisedUserManager()->GetUserSyncId(
 193           user->email());
 194   base::DictionaryValue password;
 195   password.SetIntegerWithoutPathExpansion(
 196       kSchemaVersion, SupervisedUserAuthentication::SCHEMA_SALT_HASHED);
 197   password.SetIntegerWithoutPathExpansion(kPasswordRevision, 2);
 198
 199   password.SetStringWithoutPathExpansion(kPasswordSignature, "signature");
 200   password.SetStringWithoutPathExpansion(kEncryptedPassword,
 201                                          "new-encrypted-password");
 202
 203   shared_settings_adapter_->AddChange(
 204       sync_id, supervised_users::kChromeOSPasswordData, password, true, false);
 205   content::RunAllPendingInMessageLoop();
 206 }
 207
 208 // After that manager signs in, and also detects password change. Manager
 209 // performs the migration.
 210 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 211                        PRE_PasswordChangeUserAndManagerTest) {
 212   const user_manager::User* supervised_user =
 213       user_manager::UserManager::Get()->GetUsers().at(0);
 214
 215   SigninAsManager(1);
 216
 217   EXPECT_CALL(*mock_homedir_methods_, AddKeyEx(_, _, _, _, _)).Times(1);
 218
 219   std::string sync_id =
 220       ChromeUserManager::Get()->GetSupervisedUserManager()->GetUserSyncId(
 221           supervised_user->email());
 222
 223   ::sync_pb::ManagedUserSpecifics managed_user_proto;
 224
 225   managed_user_proto.set_id(sync_id);
 226   managed_user_proto.set_name(kTestSupervisedUserDisplayName);
 227   managed_user_proto.set_acknowledged(true);
 228   managed_user_proto.set_master_key("master key");
 229   managed_user_proto.set_password_signature_key("signature_key");
 230   managed_user_proto.set_password_encryption_key("encryption_key");
 231
 232   supervised_users_adapter_->AddChange(managed_user_proto, false);
 233   content::RunAllPendingInMessageLoop();
 234
 235   base::DictionaryValue password;
 236   password.SetIntegerWithoutPathExpansion(
 237       kSchemaVersion, SupervisedUserAuthentication::SCHEMA_SALT_HASHED);
 238   password.SetIntegerWithoutPathExpansion(kPasswordRevision, 2);
 239
 240   password.SetStringWithoutPathExpansion(kPasswordSignature, "signature");
 241   password.SetStringWithoutPathExpansion(kEncryptedPassword,
 242                                          "new-encrypted-password");
 243   shared_settings_adapter_->AddChange(
 244       sync_id, supervised_users::kChromeOSPasswordData, password, true, false);
 245   content::RunAllPendingInMessageLoop();
 246
 247   testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 248 }
 249
 250 // When supervised user signs in, password is already migrated, so no migration
 251 // should be attempted.
 252 IN_PROC_BROWSER_TEST_F(SupervisedUserPasswordTest,
 253                        PasswordChangeUserAndManagerTest) {
 254   EXPECT_CALL(*mock_homedir_methods_, MountEx(_, _, _, _)).Times(1);
 255   EXPECT_CALL(*mock_homedir_methods_, UpdateKeyEx(_, _, _, _, _)).Times(0);
 256   SigninAsSupervisedUser(false, 1, kTestSupervisedUserDisplayName);
 257   testing::Mock::VerifyAndClearExpectations(mock_homedir_methods_);
 258 }
 259
 260 }  // namespace chromeos