[login_manager] Use keygen helper to generate owner key

session_manager_service.cc

 // Copyright (c) 2009-2010 The Chromium OS 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 "login_manager/session_manager_service.h"
 
 #include <dbus/dbus-glib-lowlevel.h>
 #include <errno.h>
 #include <glib.h>
 #include <grp.h>
@@ skipping 112 matching lines @@
     ".@1234567890-+_";
 // static
 const char SessionManagerService::kIncognitoUser[] = "";
 // static
 const char SessionManagerService::kDeviceOwnerPref[] = "cros.device.owner";
 // static
 const char SessionManagerService::kTestingChannelFlag[] =
     "--testing-channel=NamedTestingInterface:";
 // static
 const char SessionManagerService::kIOThreadName[] = "ThreadForIO";
+// static
+const char SessionManagerService::kKeygenExecutable[] = "/sbin/keygen";
+// static
+const char SessionManagerService::kTemporaryKeyFilename[] = "key.pub";
 
 namespace {
 
 // Time we wait for child job to die (in seconds).
 const int kKillTimeout = 3;
 
 const int kMaxArgumentsSize = 512;
 
 }  // namespace
 
 SessionManagerService::SessionManagerService(
     std::vector<ChildJobInterface*> child_jobs)
     : child_jobs_(child_jobs.begin(), child_jobs.end()),
       child_pids_(child_jobs.size(), -1),
       exit_on_child_done_(false),
+      keygen_job_(NULL),
       session_manager_(NULL),
       main_loop_(g_main_loop_new(NULL, FALSE)),
       system_(new SystemUtils),
       nss_(NssUtil::Create()),
       key_(new OwnerKey(nss_->GetOwnerKeyFilePath())),
       store_(new PrefStore(FilePath(PrefStore::kDefaultPath))),
       upstart_signal_emitter_(new UpstartSignalEmitter),
       session_started_(false),
       io_thread_(kIOThreadName),
       dont_use_directly_(new MessageLoopForUI),
@@ skipping 314 matching lines @@
   StoreOwnerProperties(NULL);
   // Now, the flip side...if we believe the current user to be the owner
   // based on the cros.owner.device setting, and he DOESN'T have the private
   // half of the public key, we must mitigate.
   if (CurrentUserIsOwner(error) &&
       !CurrentUserHasOwnerKey(key_->public_key_der(), error)) {
     if (!(*OUT_done = mitigator_->Mitigate()))
       return FALSE;
   }
 
-  if (set_uid_) {
-    *OUT_done =
-        upstart_signal_emitter_->EmitSignal(
-            "start-user-session",
-            StringPrintf("CHROMEOS_USER=%s USER_ID=%d",
-                         current_user_.c_str(), uid_),
-            error);
-  } else {
-    *OUT_done =
-        upstart_signal_emitter_->EmitSignal(
-            "start-user-session",
-            StringPrintf("CHROMEOS_USER=%s", current_user_.c_str()),
-            error);
-  }
+  *OUT_done =
+      upstart_signal_emitter_->EmitSignal(
+          "start-user-session",
+          StringPrintf("CHROMEOS_USER=%s", current_user_.c_str()),
+          error);
 
   if (*OUT_done) {
     for (size_t i_child = 0; i_child < child_jobs_.size(); ++i_child) {
       ChildJobInterface* child_job = child_jobs_[i_child];
       child_job->StartSession(current_user_);
     }
     session_started_ = true;
     DLOG(INFO) << "emitting D-Bus signal SessionStateChanged:started";
     if (signals_[kSignalSessionStateChanged]) {
       g_signal_emit(session_manager_,
                     signals_[kSignalSessionStateChanged],
                     0, "started", current_user_.c_str());
     }
+    if (key_->HaveCheckedDisk() && !key_->IsPopulated())
+      StartKeyGeneration();
   }
 
   return *OUT_done;
 }
 
+void SessionManagerService::HandleKeygenExit(GPid pid,
+                                             gint status,
+                                             gpointer data) {
+  SessionManagerService* manager = static_cast<SessionManagerService*>(data);
+  int i_child = manager->FindChildByPid(pid);
+  manager->child_pids_[i_child] = -1;
+  delete *(manager->child_jobs_.erase(manager->child_jobs_.begin() + i_child));
+
+  if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
+    std::string key;
+    file_util::ReadFileToString(
+        FilePath(file_util::GetHomeDir().AppendASCII(kTemporaryKeyFilename)),
+        &key);
+    manager->ValidateAndStoreOwnerKey(key);
+  } else {
+    if (WIFSIGNALED(status))
+      LOG(ERROR) << "keygen exited on signal " << WTERMSIG(status);
+    else
+      LOG(ERROR) << "keygen exited with exit code " << WEXITSTATUS(status);
+  }
+}
+
+void SessionManagerService::ValidateAndStoreOwnerKey(const std::string& buf) {
+  std::vector<uint8> pub_key;
+  NssUtil::KeyFromBuffer(buf, &pub_key);
+
+  if (!CurrentUserHasOwnerKey(pub_key, NULL)) {
+    SendSignal(chromium::kOwnerKeySetSignal, false);
+    return;
+  }
+
+  if (!key_->PopulateFromBuffer(pub_key)) {
+    SendSignal(chromium::kOwnerKeySetSignal, false);
+    return;
+  }
+  io_thread_.message_loop()->PostTask(
+      FROM_HERE, NewRunnableMethod(this, &SessionManagerService::PersistKey));
+  StoreOwnerProperties(NULL);
+}
+
+void SessionManagerService::StartKeyGeneration() {
+  if (!keygen_job_.get()) {
+    LOG(INFO) << "Creating keygen job";
+    std::vector<std::string> keygen_argv;
+    keygen_argv.push_back(kKeygenExecutable);
+    keygen_argv.push_back(
+        file_util::GetHomeDir().AppendASCII(kTemporaryKeyFilename).value());

[Will Drewry, 2011/02/23 03:30:16]

I was going to suggest a random location, but since the private key should be in
nss, it seems fine to put the public key in the home dir.  Is this a safe
assumption? 

+    keygen_job_.reset(new ChildJob(keygen_argv));
+  }
+
+  if (set_uid_)
+    keygen_job_->SetDesiredUid(uid_);
+  int pid = key_->StartGeneration(keygen_job_.get());
+  g_child_watch_add_full(G_PRIORITY_HIGH_IDLE,
+                         pid,
+                         HandleKeygenExit,
+                         this,
+                         NULL);
+  child_jobs_.push_back(keygen_job_.release());
+  child_pids_.push_back(pid);
+}
+
 gboolean SessionManagerService::StopSession(gchar* unique_identifier,
                                             gboolean* OUT_done,
                                             GError** error) {
   // Most calls to StopSession() will log the reason for the call.
   // If you don't see a log message saying the reason for the call, it is
   // likely a DBUS message. See interface.cc for that call.
   LOG(INFO) << "SessionManagerService StopSession";
   g_idle_add_full(G_PRIORITY_DEFAULT_IDLE,
                   ServiceShutdown,
                   this,
                   NULL);
   // TODO(cmasone): re-enable these when we try to enable logout without exiting
   //                the session manager
   // child_job_->StopSession();
   // session_started_ = false;
   return *OUT_done = TRUE;
 }
 
 gboolean SessionManagerService::SetOwnerKey(GArray* public_key_der,
                                             GError** error) {
-  LOG(INFO) << "key size is " << public_key_der->len;
-
-  if (!session_started_) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY,
-              "Cannot set the owner's public key outside of a session.");
-    return FALSE;
-  }
-
-  std::vector<uint8> pub_key;
-  NssUtil::KeyFromBuffer(public_key_der, &pub_key);
-
-  if (!CurrentUserHasOwnerKey(pub_key, error)) {
-    return FALSE;  // error set by CurrentUserHasOwnerKey()
-  }
-
-  if (!key_->PopulateFromBuffer(pub_key)) {
-    SetGError(error,
-              CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY,
-              "Attempted to set invalid key as owner's public key.");
-    return FALSE;
-  }
-  io_thread_.message_loop()->PostTask(
-      FROM_HERE, NewRunnableMethod(this, &SessionManagerService::PersistKey));
-  return StoreOwnerProperties(error);
+  SetGError(error,
+            CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY,
+            "The session_manager now sets the Owner's public key.");
+  // Just to be safe, send back a nACK in addition to returning an error.
+  SendSignal(chromium::kOwnerKeySetSignal, false);
+  return FALSE;
 }
 
 gboolean SessionManagerService::Unwhitelist(gchar* email_address,
                                             GArray* signature,
                                             GError** error) {
   LOG(INFO) << "Unwhitelisting " << email_address;
   if (!key_->IsPopulated()) {
     SetGError(error,
               CHROMEOS_LOGIN_ERROR_NO_OWNER_KEY,
               "Attempt to unwhitelist before owner's key is set.");
@@ skipping 208 matching lines @@
     DLOG(INFO) << "  Exited...somehow, without an exit code or a signal??";
   }
 
   // If the child _ever_ exits uncleanly, we want to start it up again.
   SessionManagerService* manager = static_cast<SessionManagerService*>(data);
 
   // Do nothing if already shutting down.
   if (manager->shutting_down_)
     return;
 
-  int i_child = -1;
-  for (int i = 0; i < manager->child_pids_.size(); ++i) {
-    if (manager->child_pids_[i] == pid) {
-      i_child = i;
-      manager->child_pids_[i] = -1;
-      break;
-    }
+  ChildJobInterface* child_job = NULL;
+  int i_child = manager->FindChildByPid(pid);
+  if (i_child >= 0) {
+    child_job = manager->child_jobs_[i_child];
+    manager->child_pids_[i_child] = -1;
   }
 
-  ChildJobInterface* child_job = i_child >= 0
-                                 ? manager->child_jobs_[i_child]
-                                 : NULL;
-
   LOG(ERROR) << StringPrintf(
       "Process %s(%d) exited.",
       child_job ? child_job->GetName().c_str() : "",
       pid);
   if (manager->screen_locked_) {
     LOG(ERROR) << "Screen locked, shutting down",
     ServiceShutdown(data);
     return;
   }
 
@@ skipping 211 matching lines @@
   if (email_string != kIncognitoUser && !ValidateEmail(email_string)) {
     SetGError(error,
               CHROMEOS_LOGIN_ERROR_INVALID_EMAIL,
               "Provided email address is not valid.  ASCII only.");
     return FALSE;
   }
   current_user_ = StringToLowerASCII(email_string);
   return TRUE;
 }
 
+int SessionManagerService::FindChildByPid(int pid) {
+  for (int i = 0; i < child_pids_.size(); ++i) {
+    if (child_pids_[i] == pid)
+      return i;
+  }
+  return -1;
+}
+
 void SessionManagerService::CleanupChildren(int timeout) {
   vector<pair<int, uid_t> > pids_to_kill;
 
   for (size_t i = 0; i < child_pids_.size(); ++i) {
     const int pid = child_pids_[i];
     if (pid < 0)
       continue;
 
     ChildJobInterface* job = child_jobs_[i];
     if (job->ShouldNeverKill())
@@ skipping 133 matching lines @@
       arg_list.push_back(args[i_arg]);
     }
   }
   if (arg_list.size()) {
     arg_lists.push_back(arg_list);
   }
   return arg_lists;
 }
 
 }  // namespace login_manager