Make CryptohomeAuthenticator's Login*() methods work with pre-hashed keys

chrome/browser/chromeos/login/auth/cryptohome_authenticator_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/login/auth/chrome_cryptohome_authenticator.h"
 
 #include <string>
 
+#include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
 #include "chrome/browser/chromeos/login/users/scoped_user_manager_enabler.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service.h"
 #include "chrome/browser/chromeos/ownership/owner_settings_service_factory.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/device_settings_test_helper.h"
 #include "chrome/browser/chromeos/settings/mock_owner_key_util.h"
 #include "chrome/browser/chromeos/settings/stub_cros_settings_provider.h"
 #include "chrome/test/base/testing_browser_process.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chrome/test/base/testing_profile_manager.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/cryptohome/homedir_methods.h"
 #include "chromeos/cryptohome/mock_async_method_caller.h"
 #include "chromeos/cryptohome/mock_homedir_methods.h"
 #include "chromeos/cryptohome/system_salt_getter.h"
 #include "chromeos/dbus/cros_disks_client.h"
+#include "chromeos/dbus/cryptohome/rpc.pb.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/dbus/fake_cryptohome_client.h"
 #include "chromeos/login/auth/key.h"
 #include "chromeos/login/auth/mock_auth_status_consumer.h"
 #include "chromeos/login/auth/mock_url_fetchers.h"
 #include "chromeos/login/auth/test_attempt_state.h"
 #include "chromeos/login/auth/user_context.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "crypto/nss_util_internal.h"
 #include "crypto/scoped_test_nss_chromeos_user.h"
 #include "google_apis/gaia/mock_url_fetcher_factory.h"
 #include "net/base/net_errors.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "url/gurl.h"
 
 using ::testing::Invoke;
 using ::testing::Return;
+using ::testing::WithArg;
 using ::testing::_;
 
 namespace chromeos {
 
 namespace {
 
+// Label under which the user's key is stored.
+const char kCryptohomeGAIAKeyLabel[] = "gaia";
+
+// Salt used by pre-hashed key.
+const char kSalt[] = "SALT $$";
+
 // An owner key in PKCS#8 PrivateKeyInfo for testing owner checks.
 const uint8 kOwnerPrivateKey[] = {
     0x30, 0x82, 0x01, 0x53, 0x02, 0x01, 0x00, 0x30, 0x0d, 0x06, 0x09, 0x2a,
     0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01, 0x01, 0x01, 0x05, 0x00, 0x04, 0x82,
     0x01, 0x3d, 0x30, 0x82, 0x01, 0x39, 0x02, 0x01, 0x00, 0x02, 0x41, 0x00,
     0xb4, 0xf5, 0xab, 0xfe, 0xd8, 0xf1, 0xcb, 0x5f, 0x8f, 0x48, 0x3e, 0xdf,
     0x40, 0x8e, 0x2b, 0x15, 0x43, 0x6c, 0x67, 0x74, 0xa2, 0xcb, 0xe4, 0xf3,
     0xec, 0xab, 0x41, 0x57, 0x1d, 0x5f, 0xed, 0xcf, 0x09, 0xf4, 0xcc, 0xbb,
     0x52, 0x52, 0xe8, 0x46, 0xf5, 0xc5, 0x01, 0xa3, 0xd8, 0x24, 0xc0, 0x15,
     0xc5, 0x65, 0x50, 0x7d, 0xbd, 0x4e, 0x81, 0xb2, 0x28, 0x38, 0xf9, 0x3d,
@@ skipping 54 matching lines @@
         mock_homedir_methods_(NULL),
         owner_key_util_(new MockOwnerKeyUtil) {
     user_context_.SetKey(Key("fakepass"));
     user_context_.SetUserIDHash("me_nowhere_com_hash");
     const user_manager::User* user =
         user_manager_->AddUser(user_context_.GetUserID());
     profile_.set_profile_name(user_context_.GetUserID());
 
     ProfileHelper::Get()->SetUserToProfileMappingForTesting(user, &profile_);
 
-    transformed_key_ = *user_context_.GetKey();
-    transformed_key_.Transform(Key::KEY_TYPE_SALTED_SHA256_TOP_HALF,
-                               SystemSaltGetter::ConvertRawSaltToHexString(
-                                   FakeCryptohomeClient::GetStubSystemSalt()));
+    CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256_TOP_HALF,
+                         SystemSaltGetter::ConvertRawSaltToHexString(
+                             FakeCryptohomeClient::GetStubSystemSalt()));
   }
 
   virtual ~CryptohomeAuthenticatorTest() {}
 
   virtual void SetUp() {
     CommandLine::ForCurrentProcess()->AppendSwitch(switches::kLoginManager);
 
     mock_caller_ = new cryptohome::MockAsyncMethodCaller;
     cryptohome::AsyncMethodCaller::InitializeForTesting(mock_caller_);
     mock_homedir_methods_ = new cryptohome::MockHomedirMethods;
@@ skipping 17 matching lines @@
     OwnerSettingsService::SetOwnerKeyUtilForTesting(NULL);
     SystemSaltGetter::Shutdown();
     DBusThreadManager::Shutdown();
 
     cryptohome::AsyncMethodCaller::Shutdown();
     mock_caller_ = NULL;
     cryptohome::HomedirMethods::Shutdown();
     mock_homedir_methods_ = NULL;
   }
 
+  void CreateTransformedKey(Key::KeyType type, const std::string& salt) {
+    user_context_with_transformed_key_ = user_context_;
+    user_context_with_transformed_key_.GetKey()->Transform(type, salt);
+    transformed_key_ = *user_context_with_transformed_key_.GetKey();
+  }
+
   base::FilePath PopulateTempFile(const char* data, int data_len) {
     base::FilePath out;
     FILE* tmp_file = base::CreateAndOpenTemporaryFile(&out);
     EXPECT_NE(tmp_file, static_cast<FILE*>(NULL));
     EXPECT_EQ(base::WriteFile(out, data, data_len), data_len);
     EXPECT_TRUE(base::CloseFile(tmp_file));
     return out;
   }
 
   // Allow test to fail and exit gracefully, even if OnAuthFailure()
@@ skipping 47 matching lines @@
         .WillOnce(Invoke(MockAuthStatusConsumer::OnGuestSuccessQuit))
         .RetiresOnSaturation();
   }
 
   void ExpectPasswordChange() {
     EXPECT_CALL(consumer_, OnPasswordChangeDetected())
         .WillOnce(Invoke(MockAuthStatusConsumer::OnMigrateQuit))
         .RetiresOnSaturation();
   }
 
+  void ExpectGetKeyDataExCall(scoped_ptr<int64> key_type,
+                              scoped_ptr<std::string> salt) {
+    key_data_.clear();
+    key_data_.push_back(new cryptohome::RetrievedKeyData(
+       cryptohome::RetrievedKeyData::TYPE_PASSWORD,
+       kCryptohomeGAIAKeyLabel,
+       1));
+    key_data_.front()->privileges = cryptohome::PRIV_DEFAULT;
+    key_data_.front()->authorization_types.push_back(
+        cryptohome::RetrievedKeyData::AUTHORIZATION_TYPE_HMACSHA256);
+    if (key_type) {
+      scoped_ptr<cryptohome::RetrievedKeyData::ProviderData> provider_data(
+          new cryptohome::RetrievedKeyData::ProviderData("type"));
+      provider_data->number = key_type.Pass();
+      key_data_.front()->provider_data.push_back(provider_data.release());
+    }
+    if (salt) {
+      scoped_ptr<cryptohome::RetrievedKeyData::ProviderData> provider_data(
+          new cryptohome::RetrievedKeyData::ProviderData("salt"));
+      provider_data->bytes = salt.Pass();
+      key_data_.front()->provider_data.push_back(provider_data.release());
+    }
+    EXPECT_CALL(*mock_homedir_methods_, GetKeyDataEx(
+        cryptohome::Identification(user_context_.GetUserID()),
+        kCryptohomeGAIAKeyLabel,
+        _))
+        .WillOnce(WithArg<2>(Invoke(
+            this,
+            &CryptohomeAuthenticatorTest::InvokeGetDataExCallback)));
+  }
+
+  void ExpectMountExCall(bool expect_create_attempt) {
+    const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
+                                             std::string(),
+                                             cryptohome::PRIV_DEFAULT);
+    cryptohome::MountParameters mount(false /* ephemeral */);
+    if (expect_create_attempt) {
+      mount.create_keys.push_back(cryptohome::KeyDefinition(
+          transformed_key_.GetSecret(),
+          kCryptohomeGAIAKeyLabel,
+          cryptohome::PRIV_DEFAULT));
+    }
+    EXPECT_CALL(*mock_homedir_methods_,
+                MountEx(cryptohome::Identification(user_context_.GetUserID()),
+                        cryptohome::Authorization(auth_key),
+                        mount,
+                        _))
+        .Times(1)
+        .RetiresOnSaturation();
+  }
+
   void RunResolve(CryptohomeAuthenticator* auth) {
     auth->Resolve();
     base::MessageLoop::current()->RunUntilIdle();
   }
 
   void SetAttemptState(CryptohomeAuthenticator* auth, TestAttemptState* state) {
     auth->set_attempt_state(state);
   }
 
   CryptohomeAuthenticator::AuthState SetAndResolveState(
       CryptohomeAuthenticator* auth,
       TestAttemptState* state) {
     auth->set_attempt_state(state);
     return auth->ResolveState();
   }
 
   void SetOwnerState(bool owner_check_finished, bool check_result) {
     auth_->SetOwnerState(owner_check_finished, check_result);
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
 
   UserContext user_context_;
+  UserContext user_context_with_transformed_key_;
   Key transformed_key_;
 
+  ScopedVector<cryptohome::RetrievedKeyData> key_data_;
+
   ScopedDeviceSettingsTestHelper device_settings_test_helper_;
   ScopedTestCrosSettings test_cros_settings_;
 
   TestingProfile profile_;
   scoped_ptr<TestingProfileManager> profile_manager_;
   FakeUserManager* user_manager_;
   ScopedUserManagerEnabler user_manager_enabler_;
 
   cryptohome::MockAsyncMethodCaller* mock_caller_;
   cryptohome::MockHomedirMethods* mock_homedir_methods_;
 
   MockAuthStatusConsumer consumer_;
 
   scoped_refptr<CryptohomeAuthenticator> auth_;
   scoped_ptr<TestAttemptState> state_;
   FakeCryptohomeClient* fake_cryptohome_client_;
 
   scoped_refptr<MockOwnerKeyUtil> owner_key_util_;
+
+ private:
+  void InvokeGetDataExCallback(
+      const cryptohome::HomedirMethods::GetKeyDataCallback& callback) {
+    callback.Run(true /* success */,
+                 cryptohome::MOUNT_ERROR_NONE,
+                 key_data_.Pass());
+  }
 };
 
 TEST_F(CryptohomeAuthenticatorTest, OnAuthSuccess) {
   EXPECT_CALL(consumer_, OnAuthSuccess(user_context_))
       .Times(1)
       .RetiresOnSaturation();
 
   SetAttemptState(auth_.get(), state_.release());
   auth_->OnAuthSuccess();
 }
@@ skipping 230 matching lines @@
   // Set up mock async method caller to respond as though a tmpfs mount
   // attempt has occurred and failed.
   mock_caller_->SetUp(false, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncMountGuest(_)).Times(1).RetiresOnSaturation();
 
   auth_->LoginRetailMode();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataResync) {
-  UserContext expected_user_context(user_context_);
+  UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a cryptohome
   // remove attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncRemove(user_context_.GetUserID(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
-  const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
-                                           std::string(),
-                                           cryptohome::PRIV_DEFAULT);
-  cryptohome::MountParameters mount(false /* ephemeral */);
-  mount.create_keys.push_back(cryptohome::KeyDefinition(
-      transformed_key_.GetSecret(),
-      "gaia",
-      cryptohome::PRIV_DEFAULT));
-  EXPECT_CALL(*mock_homedir_methods_,
-              MountEx(cryptohome::Identification(user_context_.GetUserID()),
-                      cryptohome::Authorization(auth_key),
-                      mount,
-                      _))
-      .Times(1);
+  ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
+  ExpectMountExCall(true /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->ResyncEncryptedData();
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveResyncFail) {
   FailOnLoginSuccess();
@@ skipping 16 matching lines @@
   ExpectPasswordChange();
 
   state_->PresetCryptohomeStatus(false, cryptohome::MOUNT_ERROR_KEY_FAILURE);
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecover) {
-  UserContext expected_user_context(user_context_);
+  UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock async method caller to respond successfully to a key migration.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(
       *mock_caller_,
       AsyncMigrateKey(
           user_context_.GetUserID(), _, transformed_key_.GetSecret(), _))
       .Times(1)
       .RetiresOnSaturation();
 
   // Set up mock homedir methods to respond successfully to a cryptohome mount
   // attempt.
-  const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
-                                           std::string(),
-                                           cryptohome::PRIV_DEFAULT);
-  EXPECT_CALL(*mock_homedir_methods_,
-              MountEx(cryptohome::Identification(user_context_.GetUserID()),
-                      cryptohome::Authorization(auth_key),
-                      cryptohome::MountParameters(false /* ephemeral */),
-                      _));
+  ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
+  ExpectMountExCall(false /* expect_create_attempt */);
 
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   auth_->RecoverEncryptedData(std::string());
   base::MessageLoop::current()->Run();
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveDataRecoverButFail) {
   FailOnLoginSuccess();
@@ skipping 33 matching lines @@
   // an online auth attempt has completed successfully.
   state_->PresetCryptohomeStatus(false,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
 
   EXPECT_EQ(CryptohomeAuthenticator::CREATE_NEW,
             SetAndResolveState(auth_.get(), state_.release()));
 }
 
 TEST_F(CryptohomeAuthenticatorTest, DriveCreateForNewUser) {
-  UserContext expected_user_context(user_context_);
+  UserContext expected_user_context(user_context_with_transformed_key_);
   expected_user_context.SetUserIDHash(
       cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
   ExpectLoginSuccess(expected_user_context);
   FailOnLoginFailure();
 
   // Set up mock homedir methods to respond successfully to a cryptohome create
   // attempt.
-  const cryptohome::KeyDefinition auth_key(transformed_key_.GetSecret(),
-                                           std::string(),
-                                           cryptohome::PRIV_DEFAULT);
-  cryptohome::MountParameters mount(false /* ephemeral */);
-  mount.create_keys.push_back(cryptohome::KeyDefinition(
-      transformed_key_.GetSecret(),
-      "gaia",
-      cryptohome::PRIV_DEFAULT));
-  EXPECT_CALL(*mock_homedir_methods_,
-              MountEx(cryptohome::Identification(user_context_.GetUserID()),
-                      cryptohome::Authorization(auth_key),
-                      mount,
-                      _));
+  ExpectGetKeyDataExCall(scoped_ptr<int64>(), scoped_ptr<std::string>());
+  ExpectMountExCall(true /* expect_create_attempt */);
 
   // Set up state as though a cryptohome mount attempt has occurred
   // and been rejected because the user doesn't exist; additionally,
   // an online auth attempt has completed successfully.
   state_->PresetCryptohomeStatus(false,
                                  cryptohome::MOUNT_ERROR_USER_DOES_NOT_EXIST);
   state_->PresetOnlineLoginStatus(AuthFailure::AuthFailureNone());
   SetAttemptState(auth_.get(), state_.release());
 
   RunResolve(auth_.get());
@@ skipping 32 matching lines @@
   // key-check attempt.
   mock_caller_->SetUp(true, cryptohome::MOUNT_ERROR_NONE);
   EXPECT_CALL(*mock_caller_, AsyncCheckKey(user_context_.GetUserID(), _, _))
       .Times(1)
       .RetiresOnSaturation();
 
   auth_->AuthenticateToUnlock(user_context_);
   base::MessageLoop::current()->Run();
 }
 
+TEST_F(CryptohomeAuthenticatorTest, DriveLoginWithPreHashedPassword) {
+  CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256, kSalt);
+
+  UserContext expected_user_context(user_context_with_transformed_key_);
+  expected_user_context.SetUserIDHash(
+      cryptohome::MockAsyncMethodCaller::kFakeSanitizedUsername);
+  ExpectLoginSuccess(expected_user_context);
+  FailOnLoginFailure();
+
+  // Set up mock homedir methods to respond with key metadata indicating that a
+  // pre-hashed key was used to create the cryptohome and allow a successful
+  // mount when this pre-hashed key is used.
+
+  ExpectGetKeyDataExCall(
+      make_scoped_ptr(new int64(Key::KEY_TYPE_SALTED_SHA256)),
+      make_scoped_ptr(new std::string(kSalt)));
+  ExpectMountExCall(false /* expect_create_attempt */);
+
+  auth_->AuthenticateToLogin(NULL, user_context_);
+  base::RunLoop().Run();
+}
+
+TEST_F(CryptohomeAuthenticatorTest, FailLoginWithMissingSalt) {

[dzhioev (left Google), 2014/09/02 15:56:26]

What about missing/wrong "type" test?

[bartfab (slow), 2014/09/02 17:24:58]

All existing cryptohomes have no type - this is the legacy code path in which we
use the default hashing algorithm and system salt.

+  CreateTransformedKey(Key::KEY_TYPE_SALTED_SHA256, kSalt);
+
+  FailOnLoginSuccess();
+  ExpectLoginFailure(AuthFailure(AuthFailure::COULD_NOT_MOUNT_CRYPTOHOME));
+
+  // Set up mock homedir methods to respond with key metadata indicating that a
+  // pre-hashed key was used to create the cryptohome but without the required
+  // salt.
+  ExpectGetKeyDataExCall(
+      make_scoped_ptr(new int64(Key::KEY_TYPE_SALTED_SHA256)),
+      scoped_ptr<std::string>());
+
+  auth_->AuthenticateToLogin(NULL, user_context_);
+  base::RunLoop().Run();
+}
+
 }  // namespace chromeos