ChromeOS cryptohome should be able to use gaia id as user identifier.

chromeos/dbus/session_manager_client.cc

 // Copyright (c) 2012 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 "chromeos/dbus/session_manager_client.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <sys/socket.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/task_runner_util.h"
 #include "base/threading/worker_pool.h"
 #include "chromeos/chromeos_paths.h"
+#include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/blocking_method_caller.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "crypto/sha2.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
 #include "dbus/object_path.h"
 #include "dbus/object_proxy.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 namespace chromeos {
 
 namespace {
 
-// Returns a location for |file| that is specific to the given |username|.
+// Returns a location for |file| that is specific to the given |cryptohome_id|.
 // These paths will be relative to DIR_USER_POLICY_KEYS, and can be used only
 // to store stub files.
-base::FilePath GetUserFilePath(const std::string& username, const char* file) {
+base::FilePath GetUserFilePath(const cryptohome::Identification& cryptohome_id,
+                               const char* file) {
   base::FilePath keys_path;
   if (!PathService::Get(chromeos::DIR_USER_POLICY_KEYS, &keys_path))
     return base::FilePath();
   const std::string sanitized =
-      CryptohomeClient::GetStubSanitizedUsername(username);
+      CryptohomeClient::GetStubSanitizedUsername(cryptohome_id);
   return keys_path.AppendASCII(sanitized).AppendASCII(file);
 }
 
 // Helper to asynchronously retrieve a file's content.
 std::string GetFileContent(const base::FilePath& path) {
   std::string result;
   if (!path.empty())
     base::ReadFileToString(path, &result);
   return result;
 }
@@ skipping 90 matching lines @@
         &CreateValidCredConduit, local_auth_fd.get(), remote_auth_fd.get());
 
     base::WorkerPool::PostTaskAndReply(
         FROM_HERE, create_credentials_conduit_closure,
         base::Bind(&SessionManagerClientImpl::CallRestartJobWithValidFd,
                    weak_ptr_factory_.GetWeakPtr(), base::Passed(&local_auth_fd),
                    base::Passed(&remote_auth_fd), argv),
         false);
   }
 
-  void StartSession(const std::string& user_email) override {
+  void StartSession(const cryptohome::Identification& cryptohome_id) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerStartSession);
     dbus::MessageWriter writer(&method_call);
-    writer.AppendString(user_email);
+    writer.AppendString(cryptohome_id.id());
     writer.AppendString("");  // Unique ID is deprecated
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStartSession,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void StopSession() override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
@@ skipping 60 matching lines @@
                                  login_manager::kSessionManagerRetrievePolicy);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnRetrievePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
                    login_manager::kSessionManagerRetrievePolicy,
                    callback));
   }
 
-  void RetrievePolicyForUser(const std::string& username,
+  void RetrievePolicyForUser(const cryptohome::Identification& cryptohome_id,
                              const RetrievePolicyCallback& callback) override {
     CallRetrievePolicyByUsername(
-        login_manager::kSessionManagerRetrievePolicyForUser,
-        username,
+        login_manager::kSessionManagerRetrievePolicyForUser, cryptohome_id.id(),
         callback);
   }
 
   std::string BlockingRetrievePolicyForUser(
-      const std::string& username) override {
+      const cryptohome::Identification& cryptohome_id) override {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
         login_manager::kSessionManagerRetrievePolicyForUser);
     dbus::MessageWriter writer(&method_call);
-    writer.AppendString(username);
+    writer.AppendString(cryptohome_id.id());
     scoped_ptr<dbus::Response> response =
         blocking_method_caller_->CallMethodAndBlock(&method_call);
     std::string policy;
     ExtractString(login_manager::kSessionManagerRetrievePolicyForUser,
                   response.get(),
                   &policy);
     return policy;
   }
 
   void RetrieveDeviceLocalAccountPolicy(
@@ skipping 16 matching lines @@
         policy_blob.size());
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&SessionManagerClientImpl::OnStorePolicy,
                    weak_ptr_factory_.GetWeakPtr(),
                    login_manager::kSessionManagerStorePolicy,
                    callback));
   }
 
-  void StorePolicyForUser(const std::string& username,
+  void StorePolicyForUser(const cryptohome::Identification& cryptohome_id,
                           const std::string& policy_blob,
                           const StorePolicyCallback& callback) override {
     CallStorePolicyByUsername(login_manager::kSessionManagerStorePolicyForUser,
-                              username,
-                              policy_blob,
-                              callback);
+                              cryptohome_id.id(), policy_blob, callback);
   }
 
   void StoreDeviceLocalAccountPolicy(
       const std::string& account_name,
       const std::string& policy_blob,
       const StorePolicyCallback& callback) override {
     CallStorePolicyByUsername(
         login_manager::kSessionManagerStoreDeviceLocalAccountPolicy,
         account_name,
         policy_blob,
         callback);
   }
 
-  void SetFlagsForUser(const std::string& username,
+  void SetFlagsForUser(const cryptohome::Identification& cryptohome_id,
                        const std::vector<std::string>& flags) override {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  login_manager::kSessionManagerSetFlagsForUser);
     dbus::MessageWriter writer(&method_call);
-    writer.AppendString(username);
+    writer.AppendString(cryptohome_id.id());
     writer.AppendArrayOfStrings(flags);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   void GetServerBackedStateKeys(const StateKeysCallback& callback) override {
     dbus::MethodCall method_call(
         login_manager::kSessionManagerInterface,
@@ skipping 88 matching lines @@
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         dbus::ObjectProxy::EmptyResponseCallback());
   }
 
   // Helper for RetrieveDeviceLocalAccountPolicy and RetrievePolicyForUser.
   void CallRetrievePolicyByUsername(const std::string& method_name,
-                                    const std::string& username,
+                                    const std::string& account_id,
                                     const RetrievePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
-    writer.AppendString(username);
+    writer.AppendString(account_id);
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &SessionManagerClientImpl::OnRetrievePolicy,
             weak_ptr_factory_.GetWeakPtr(),
             method_name,
             callback));
   }
 
   void CallStorePolicyByUsername(const std::string& method_name,
-                                 const std::string& username,
+                                 const std::string& account_id,
                                  const std::string& policy_blob,
                                  const StorePolicyCallback& callback) {
     dbus::MethodCall method_call(login_manager::kSessionManagerInterface,
                                  method_name);
     dbus::MessageWriter writer(&method_call);
-    writer.AppendString(username);
+    writer.AppendString(account_id);
     // static_cast does not work due to signedness.
     writer.AppendArrayOfBytes(
         reinterpret_cast<const uint8_t*>(policy_blob.data()),
         policy_blob.size());
     session_manager_proxy_->CallMethod(
         &method_call,
         dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(
             &SessionManagerClientImpl::OnStorePolicy,
             weak_ptr_factory_.GetWeakPtr(),
@@ skipping 77 matching lines @@
       while (array_reader.HasMoreData()) {
         dbus::MessageReader dict_entry_reader(NULL);
         std::string key;
         std::string value;
         if (!array_reader.PopDictEntry(&dict_entry_reader) ||
             !dict_entry_reader.PopString(&key) ||
             !dict_entry_reader.PopString(&value)) {
           LOG(ERROR) << method_name << " response is incorrect: "
                      << response->ToString();
         } else {
-          sessions[key] = value;
+          sessions[cryptohome::Identification::FromString(key)] = value;
         }
       }
       success = true;
     }
     callback.Run(sessions, success);
   }
 
   void ExtractString(const std::string& method_name,
                      dbus::Response* response,
                      std::string* extracted) {
@@ skipping 176 matching lines @@
   }
   void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
   bool HasObserver(const Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
   bool IsScreenLocked() const override { return screen_is_locked_; }
   void EmitLoginPromptVisible() override {}
   void RestartJob(const std::vector<std::string>& argv) override {}
-  void StartSession(const std::string& user_email) override {}
+  void StartSession(const cryptohome::Identification& cryptohome_id) override {}
   void StopSession() override {}
   void NotifySupervisedUserCreationStarted() override {}
   void NotifySupervisedUserCreationFinished() override {}
   void StartDeviceWipe() override {}
   void RequestLockScreen() override {
     if (delegate_)
       delegate_->LockScreenForStub();
   }
   void NotifyLockScreenShown() override {
     screen_is_locked_ = true;
@@ skipping 12 matching lines @@
       return;
     }
     base::FilePath device_policy_path =
         owner_key_path.DirName().AppendASCII("stub_device_policy");
     base::PostTaskAndReplyWithResult(
         base::WorkerPool::GetTaskRunner(false).get(),
         FROM_HERE,
         base::Bind(&GetFileContent, device_policy_path),
         callback);
   }
-  void RetrievePolicyForUser(const std::string& username,
+  void RetrievePolicyForUser(const cryptohome::Identification& cryptohome_id,
                              const RetrievePolicyCallback& callback) override {
     base::PostTaskAndReplyWithResult(
-        base::WorkerPool::GetTaskRunner(false).get(),
-        FROM_HERE,
-        base::Bind(&GetFileContent, GetUserFilePath(username, "stub_policy")),
+        base::WorkerPool::GetTaskRunner(false).get(), FROM_HERE,
+        base::Bind(&GetFileContent,
+                   GetUserFilePath(cryptohome_id, "stub_policy")),
         callback);
   }
   std::string BlockingRetrievePolicyForUser(
-      const std::string& username) override {
-    return GetFileContent(GetUserFilePath(username, "stub_policy"));
+      const cryptohome::Identification& cryptohome_id) override {
+    return GetFileContent(GetUserFilePath(cryptohome_id, "stub_policy"));
   }
   void RetrieveDeviceLocalAccountPolicy(
-      const std::string& account_name,
+      const std::string& account_id,
       const RetrievePolicyCallback& callback) override {
-    RetrievePolicyForUser(account_name, callback);
+    RetrievePolicyForUser(cryptohome::Identification::FromString(account_id),
+                          callback);
   }
   void StoreDevicePolicy(const std::string& policy_blob,
                          const StorePolicyCallback& callback) override {
     enterprise_management::PolicyFetchResponse response;
     base::FilePath owner_key_path;
     if (!response.ParseFromString(policy_blob) ||
         !PathService::Get(chromeos::FILE_OWNER_KEY, &owner_key_path)) {
       callback.Run(false);
       return;
     }
@@ skipping 11 matching lines @@
     // Note also that the owner key will be written before the device policy,
     // if it was present in the blob.
     base::FilePath device_policy_path =
         owner_key_path.DirName().AppendASCII("stub_device_policy");
     base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
         base::Bind(&StoreFile, device_policy_path, policy_blob),
         base::Bind(callback, true),
         false);
   }
-  void StorePolicyForUser(const std::string& username,
+  void StorePolicyForUser(const cryptohome::Identification& cryptohome_id,
                           const std::string& policy_blob,
                           const StorePolicyCallback& callback) override {
     // The session manager writes the user policy key to a well-known
     // location. Do the same with the stub impl, so that user policy works and
     // can be tested on desktop builds.
     enterprise_management::PolicyFetchResponse response;
     if (!response.ParseFromString(policy_blob)) {
       callback.Run(false);
       return;
     }
 
     if (response.has_new_public_key()) {
-      base::FilePath key_path = GetUserFilePath(username, "policy.pub");
+      base::FilePath key_path = GetUserFilePath(cryptohome_id, "policy.pub");
       base::WorkerPool::PostTask(
           FROM_HERE,
           base::Bind(&StoreFile, key_path, response.new_public_key()),
           false);
     }
 
     // This file isn't read directly by Chrome, but is used by this class to
     // reload the user policy across restarts.
-    base::FilePath stub_policy_path = GetUserFilePath(username, "stub_policy");
+    base::FilePath stub_policy_path =
+        GetUserFilePath(cryptohome_id, "stub_policy");
     base::WorkerPool::PostTaskAndReply(
         FROM_HERE,
         base::Bind(&StoreFile, stub_policy_path, policy_blob),
         base::Bind(callback, true),
         false);
   }
   void StoreDeviceLocalAccountPolicy(
-      const std::string& account_name,
+      const std::string& account_id,
       const std::string& policy_blob,
       const StorePolicyCallback& callback) override {
-    StorePolicyForUser(account_name, policy_blob, callback);
+    StorePolicyForUser(cryptohome::Identification::FromString(account_id),
+                       policy_blob, callback);
   }
-  void SetFlagsForUser(const std::string& username,
+  void SetFlagsForUser(const cryptohome::Identification& cryptohome_id,
                        const std::vector<std::string>& flags) override {}
 
   void GetServerBackedStateKeys(const StateKeysCallback& callback) override {
     std::vector<std::string> state_keys;
     for (int i = 0; i < 5; ++i)
       state_keys.push_back(crypto::SHA256HashString(base::IntToString(i)));
 
     if (!callback.is_null())
       callback.Run(state_keys);
   }
@@ skipping 28 matching lines @@
 
 SessionManagerClient* SessionManagerClient::Create(
     DBusClientImplementationType type) {
   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
     return new SessionManagerClientImpl();
   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
   return new SessionManagerClientStubImpl();
 }
 
 }  // namespace chromeos