[login_manager] Use keygen helper to generate owner key

session_manager_unittest.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 <errno.h>
 #include <gtest/gtest.h>
 #include <signal.h>
 #include <unistd.h>
@@ skipping 22 matching lines @@
 #include "login_manager/mock_nss_util.h"
 #include "login_manager/mock_owner_key.h"
 #include "login_manager/mock_pref_store.h"
 #include "login_manager/mock_system_utils.h"
 #include "login_manager/mock_upstart_signal_emitter.h"
 #include "login_manager/system_utils.h"
 
 namespace login_manager {
 
 using ::testing::AnyNumber;
+using ::testing::AtMost;
 using ::testing::DoAll;
 using ::testing::Invoke;
 using ::testing::Eq;
 using ::testing::Return;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 using ::testing::_;
 
 static const char kCheckedFile[] = "/tmp/checked_file";
 static const char kUptimeFile[] = "/tmp/uptime-chrome-exec";
 static const char kDiskFile[] = "/tmp/disk-chrome-exec";
 
+// compatible with void Run()
+static void BadExit() { _exit(1); }
+static void BadExitAfterSleep() { sleep(1); _exit(1); }
+static void RunAndSleep() { while (true) { sleep(1); } };
+static void CleanExit() { _exit(0); }
+
 // Used as a base class for the tests in this file.
 // Gives useful shared functionality.
 class SessionManagerTest : public ::testing::Test {
  public:
   SessionManagerTest()
       : manager_(NULL),
         utils_(new MockSystemUtils),
         file_checker_(new MockFileChecker(kCheckedFile)),
         mitigator_(new MockMitigator),
         upstart_(new MockUpstartSignalEmitter),
-        must_destroy_mocks_(true),
-        fake_key_(CreateArray("dummy", strlen("dummy"))) {
+        must_destroy_mocks_(true) {
   }
 
   virtual ~SessionManagerTest() {
     if (must_destroy_mocks_) {
       delete file_checker_;
       delete mitigator_;
       delete upstart_;
     }
     FilePath uptime(kUptimeFile);
     FilePath disk(kDiskFile);
     file_util::Delete(uptime, false);
     file_util::Delete(disk, false);
-
-    g_array_free(fake_key_, TRUE);
   }
 
   virtual void SetUp() {
     property_ = StringPrintf("%s=%s", kPropName, kPropValue);
     char sig[] = "signature";
     int len = strlen(sig);
     sig[2] = '\0';  // to make sure we can handle NULL inside a signature.
     fake_sig_ = CreateArray(sig, len);
     ASSERT_TRUE(base::Base64Encode(std::string(fake_sig_->data, fake_sig_->len),
                                    &fake_sig_encoded_));
@@ skipping 13 matching lines @@
     manager_->test_api().set_prefstore(store);
     manager_->Run();
   }
 
  protected:
   // NOT const so that they can be passed to methods that implement dbus calls,
   // which (of necessity) take bare gchar*.
   static char kFakeEmail[];
   static char kPropName[];
   static char kPropValue[];
+  static const pid_t kDummyPid;
 
   // Creates the manager with the jobs. Mocks the file checker.
   // The second job can be NULL.
   void InitManager(MockChildJob* job1, MockChildJob* job2) {
     std::vector<ChildJobInterface*> jobs;
     EXPECT_CALL(*job1, GetName())
         .WillRepeatedly(Return(std::string("job1")));
     EXPECT_CALL(*job1, IsDesiredUidSet())
         .WillRepeatedly(Return(false));
     jobs.push_back(job1);
@@ skipping 30 matching lines @@
         .WillOnce(Return(false));
     manager_->test_api().set_ownerkey(key);
     // Now, expect an attempt to check whether this user is the owner; respond
     // as though he is not.
     std::string other_user("notme");
     EXPECT_CALL(*store, Get(_, _, _))
         .WillOnce(DoAll(SetArgumentPointee<1>(other_user),
                         Return(true)));
     EXPECT_CALL(*key, Verify(_, _, _, _))
         .WillOnce(Return(true));
+    // Confirm that the device is owned.
+    EXPECT_CALL(*key, HaveCheckedDisk())
+        .WillOnce(Return(true));
+    EXPECT_CALL(*key, IsPopulated())
+        .WillOnce(Return(true));
   }
 
   void ExpectStartSessionUnowned(const std::string& email_string,
-                                 MockChildJob* job,
                                  MockPrefStore* store) {
+    MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
     EXPECT_CALL(*job, StartSession(email_string))
         .Times(1);
+
+    MockChildJob* k_job = new MockChildJob;
+    EXPECT_CALL(*k_job, SetDesiredUid(getuid()))
+        .Times(1);
+    EXPECT_CALL(*k_job, GetDesiredUid())
+        .Times(1)
+        .WillRepeatedly(Return(getuid()));
+    EXPECT_CALL(*k_job, IsDesiredUidSet())
+        .WillRepeatedly(Return(true));
+    ON_CALL(*k_job, Run())
+        .WillByDefault(Invoke(CleanExit));
+    int keygen_pid = kDummyPid + 1;
+
     MockOwnerKey* key = new MockOwnerKey;
     EXPECT_CALL(*key, PopulateFromDiskIfPossible())
         .WillRepeatedly(Return(true));
-    // First, expect an attempt to set the device owner property, but
+    EXPECT_CALL(*key, StartGeneration(k_job))
+        .WillOnce(Return(keygen_pid));
     // act like this user isn't the owner.
     EXPECT_CALL(*key, Sign(_, _, _))
         .WillOnce(Return(false));
-    manager_->test_api().set_ownerkey(key);
+
     // Now, expect an attempt to check whether this user is the owner; respond
     // as though there isn't one.
     EXPECT_CALL(*store, Get(_, _, _))
         .WillOnce(Return(false));
+    // Confirm that the device is NOT owned.
+    EXPECT_CALL(*key, HaveCheckedDisk())
+        .WillOnce(Return(true));
+    EXPECT_CALL(*key, IsPopulated())
+        .WillOnce(Return(false));
+
+    manager_->test_api().set_keygen_job(k_job);  // manager_ takes ownership.
+    manager_->set_uid(getuid());
+    manager_->test_api().set_ownerkey(key);
+    manager_->test_api().set_prefstore(store);
+
+    EXPECT_CALL(*(utils_.get()), kill(keygen_pid, getuid(), SIGTERM))
+        .WillOnce(Return(0));
+    EXPECT_CALL(*(utils_.get()), ChildIsGone(keygen_pid, _))
+        .WillOnce(Return(true));
+    MockUtils();
   }
 
   void ExpectStartSessionForOwner(const std::string& email_string,
                                   MockOwnerKey* key,
                                   MockPrefStore* store) {
     ON_CALL(*key, PopulateFromDiskIfPossible())
         .WillByDefault(Return(true));
     // First, mimic attempt to whitelist the owner and set a the
     // device owner pref.
     EXPECT_CALL(*key, Sign(_, _, _))
@@ skipping 10 matching lines @@
         .WillOnce(Return(true))
         .WillOnce(Return(true))
         .WillOnce(Return(true));
     // Now, expect an attempt to check whether this user is the owner;
     // respond as though he is.
     EXPECT_CALL(*store, Get(_, _, _))
         .WillOnce(DoAll(SetArgumentPointee<1>(email_string),
                         Return(true)));
     EXPECT_CALL(*key, Verify(_, _, _, _))
         .WillOnce(Return(true));
+    // Confirm that the device is owned.
+    EXPECT_CALL(*key, HaveCheckedDisk())
+        .Times(AtMost(1))
+        .WillRepeatedly(Return(true));
+    EXPECT_CALL(*key, IsPopulated())
+        .Times(AtMost(1))
+        .WillRepeatedly(Return(true));
   }
 
   void StartFakeSession() {
     manager_->test_api().set_session_started(true, kFakeEmail);
   }
 
   enum ChildRuns {
     ALWAYS, NEVER, ONCE, EXACTLY_ONCE, TWICE, MAYBE_NEVER
   };
 
@@ skipping 51 matching lines @@
     return output;
   }
 
   scoped_refptr<SessionManagerService> manager_;
   scoped_ptr<MockSystemUtils> utils_;
   MockFileChecker* file_checker_;
   MockMitigator* mitigator_;
   MockUpstartSignalEmitter* upstart_;
   bool must_destroy_mocks_;
   std::string property_;
-  GArray* fake_key_;
   GArray* fake_sig_;
   std::string fake_sig_encoded_;
 };
 
 // static
 char SessionManagerTest::kFakeEmail[] = "cmasone@whaaat.org";
 char SessionManagerTest::kPropName[] = "name";
 char SessionManagerTest::kPropValue[] = "value";
+const pid_t SessionManagerTest::kDummyPid = 4;
 
 
-// compatible with void Run()
-static void BadExit() { _exit(1); }
-static void BadExitAfterSleep() { sleep(1); _exit(1); }
-static void RunAndSleep() { while (true) { sleep(1); } };
-static void CleanExit() { _exit(0); }
-
 TEST_F(SessionManagerTest, NoLoopTest) {
   MockChildJob* job = CreateTrivialMockJob(NEVER);
   SimpleRunManager(new MockPrefStore);
 }
 
 TEST_F(SessionManagerTest, BadExitChild) {
   MockChildJob* job = CreateTrivialMockJob(ONCE);
   EXPECT_CALL(*job, RecordTime())
       .Times(1);
   EXPECT_CALL(*job, ShouldStop())
@@ skipping 156 matching lines @@
 
   ASSERT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
   ASSERT_TRUE(file_util::PathExists(key_file_path));
 
   SystemUtils utils;
   int32 file_size = 0;
   ASSERT_TRUE(utils.EnsureAndReturnSafeFileSize(key_file_path, &file_size));
   ASSERT_GT(file_size, 0);
 }
 
-static const pid_t kDummyPid = 4;
 TEST_F(SessionManagerTest, SessionNotStartedCleanup) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   manager_->test_api().set_child_pid(0, kDummyPid);
 
   int timeout = 3;
   EXPECT_CALL(*(utils_.get()), kill(kDummyPid, getuid(), SIGKILL))
       .WillOnce(Return(0));
   EXPECT_CALL(*(utils_.get()), ChildIsGone(kDummyPid, timeout))
       .WillOnce(Return(true));
   MockUtils();
@@ skipping 28 matching lines @@
   EXPECT_CALL(*(utils_.get()), kill(kDummyPid, getuid(), SIGTERM))
       .WillOnce(Return(0));
   EXPECT_CALL(*(utils_.get()), ChildIsGone(kDummyPid, timeout))
       .WillOnce(Return(true));
   MockUtils();
 
   MockPrefStore* store = new MockPrefStore;
   ExpectStartSession(email, job, store);
   manager_->test_api().set_prefstore(store);
   manager_->StartSession(email, nothing, &out, NULL);
-  manager_->test_api().CleanupChildren(timeout);
+  SimpleRunManager(store);
 }
 
 TEST_F(SessionManagerTest, SessionStartedSlowKillCleanup) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
-  SessionManagerService::TestApi test_api = manager_->test_api();
-  test_api.set_child_pid(0, kDummyPid);
+  manager_->test_api().set_child_pid(0, kDummyPid);
 
+  gboolean out;
+  gchar email[] = "user@somewhere";
+  gchar nothing[] = "";
   int timeout = 3;
   EXPECT_CALL(*(utils_.get()), kill(kDummyPid, getuid(), SIGTERM))
       .WillOnce(Return(0));
   EXPECT_CALL(*(utils_.get()), ChildIsGone(kDummyPid, timeout))
       .WillOnce(Return(false));
   EXPECT_CALL(*(utils_.get()), kill(kDummyPid, getuid(), SIGABRT))
       .WillOnce(Return(0));
   MockUtils();
 
-  gboolean out;
-  gchar email[] = "user@somewhere";
-  gchar nothing[] = "";
-
   MockPrefStore* store = new MockPrefStore;
   ExpectStartSession(email, job, store);
   manager_->test_api().set_prefstore(store);
   manager_->StartSession(email, nothing, &out, NULL);
-  test_api.CleanupChildren(timeout);
+  SimpleRunManager(store);
 }
 
 // Test that we avoid killing jobs that return true from their ShouldNeverKill()
 // methods.
 TEST_F(SessionManagerTest, HonorShouldNeverKill) {
   const int kNormalPid = 100;
   const int kShouldNeverKillPid = 101;
   const int kTimeout = 3;
 
   MockChildJob* normal_job = new MockChildJob;
@@ skipping 32 matching lines @@
   gboolean out;
   gchar email[] = "user@somewhere";
   gchar nothing[] = "";
   MockPrefStore* store = new MockPrefStore;
   ExpectStartSession(email, job, store);
   manager_->test_api().set_prefstore(store);
   manager_->StartSession(email, nothing, &out, NULL);
 }
 
 TEST_F(SessionManagerTest, StartSessionNew) {
-  MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
-
   gboolean out;
   gchar email[] = "user@somewhere";
   gchar nothing[] = "";
   MockPrefStore* store = new MockPrefStore;
-  ExpectStartSessionUnowned(email, job, store);
-  manager_->test_api().set_prefstore(store);
+  ExpectStartSessionUnowned(email, store);
   chromeos::glib::ScopedError error;
   EXPECT_EQ(TRUE, manager_->StartSession(email,
                                          nothing,
                                          &out,
                                          &chromeos::Resetter(&error).lvalue()));
+
+  SimpleRunManager(store);
 }
 
 TEST_F(SessionManagerTest, StartOwnerSession) {
   MockFactory<KeyCheckUtil> factory;
   NssUtil::set_factory(&factory);
 
   gboolean out;
   gchar email[] = "user@somewhere";
   gchar nothing[] = "";
 
@@ skipping 86 matching lines @@
   EXPECT_CALL(*job, ShouldStop())
       .WillOnce(Return(false));
   ON_CALL(*job, GetName())
       .WillByDefault(Return(std::string("foo")));
   SimpleRunManager(new MockPrefStore);
   LOG(INFO) << "Finished the run!";
   EXPECT_TRUE(file_util::PathExists(uptime));
   EXPECT_TRUE(file_util::PathExists(disk));
 }
 
-TEST_F(SessionManagerTest, SetOwnerKeyNoSession) {
+TEST_F(SessionManagerTest, SetOwnerKeyShouldFail) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
+  EXPECT_CALL(*(utils_.get()),
+              SendSignalToChromium(chromium::kOwnerKeySetSignal,
+                                   StrEq("failure")))
+      .Times(1);
   MockUtils();
 
   GError* error = NULL;
-  EXPECT_EQ(FALSE, manager_->SetOwnerKey(fake_key_, &error));
+  GArray* fake_key = CreateArray(kPropValue, strlen(kPropValue));
+  EXPECT_EQ(FALSE, manager_->SetOwnerKey(fake_key, &error));
   EXPECT_EQ(CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, error->code);
+  g_array_free(fake_key, TRUE);
   g_error_free(error);
 }
 
-TEST_F(SessionManagerTest, SetOwnerKeyNssDbFail) {
-  MockFactory<SadNssUtil> factory;
-  NssUtil::set_factory(&factory);
-
-  MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
-  MockUtils();
-  StartFakeSession();
-
-  GError* error = NULL;
-  EXPECT_EQ(FALSE, manager_->SetOwnerKey(fake_key_, &error));
-  EXPECT_EQ(CHROMEOS_LOGIN_ERROR_NO_USER_NSSDB, error->code);
-  g_error_free(error);
-}
-
-TEST_F(SessionManagerTest, SetOwnerKeyCheckFail) {
-  MockFactory<KeyFailUtil> factory;
-  NssUtil::set_factory(&factory);
-
-  MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
-  MockUtils();
-  StartFakeSession();
-
-  GError* error = NULL;
-  EXPECT_EQ(FALSE, manager_->SetOwnerKey(fake_key_, &error));
-  EXPECT_EQ(CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, error->code);
-  g_error_free(error);
-}
-
-TEST_F(SessionManagerTest, SetOwnerKeyPopulateFail) {
+TEST_F(SessionManagerTest, ValidateAndStoreOwnerKey) {
   MockFactory<KeyCheckUtil> factory;
   NssUtil::set_factory(&factory);
 
-  MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
-  MockUtils();
-  StartFakeSession();
-
-  std::vector<uint8> pub_key;
-  NssUtil::KeyFromBuffer(fake_key_, &pub_key);
-
-  MockOwnerKey* key = new MockOwnerKey;
-  EXPECT_CALL(*key, PopulateFromBuffer(pub_key))
-      .WillOnce(Return(false));
-  manager_->test_api().set_ownerkey(key);
-
-  GError* error = NULL;
-  EXPECT_EQ(FALSE, manager_->SetOwnerKey(fake_key_, &error));
-  EXPECT_EQ(CHROMEOS_LOGIN_ERROR_ILLEGAL_PUBKEY, error->code);
-  g_error_free(error);
-}
-
-TEST_F(SessionManagerTest, SetOwnerKey) {
-  MockFactory<KeyCheckUtil> factory;
-  NssUtil::set_factory(&factory);
-
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kOwnerKeySetSignal,
                                    StrEq("success")))
       .Times(1);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kPropertyChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kWhitelistChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   MockUtils();
-  StartFakeSession();
 
   std::vector<uint8> pub_key;
-  NssUtil::KeyFromBuffer(fake_key_, &pub_key);
+  NssUtil::KeyFromBuffer(kPropValue, &pub_key);
 
   MockPrefStore* store = new MockPrefStore;
   MockOwnerKey* key = new MockOwnerKey;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, PopulateFromBuffer(pub_key))
       .WillOnce(Return(true));
   EXPECT_CALL(*key, Sign(_, _, _))
       .WillOnce(Return(true))
       .WillOnce(Return(true));
   EXPECT_CALL(*key, Persist())
       .WillOnce(Return(true));
-
   manager_->test_api().set_ownerkey(key);
 
   EXPECT_CALL(*store, Whitelist(kFakeEmail, _))
       .Times(1);
   EXPECT_CALL(*store, Set(_, kFakeEmail, _))
       .Times(1);
   EXPECT_CALL(*store, Persist())
       .WillOnce(Return(true))
       .WillOnce(Return(true))
       .WillOnce(Return(true));
 
   manager_->test_api().set_prefstore(store);
-  EXPECT_EQ(TRUE, manager_->SetOwnerKey(fake_key_, NULL));
+  StartFakeSession();
+  manager_->ValidateAndStoreOwnerKey(kPropValue);
   manager_->Run();
 }
 
 TEST_F(SessionManagerTest, WhitelistNoKey) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   MockUtils();
 
   MockOwnerKey* key = new MockOwnerKey;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
@@ skipping 496 matching lines @@
 }
 
 TEST(SessionManagerTestStatic, GetArgLists3_InitialDashes) {
   const char* c_args[] = {"--", "a", "b", "c", NULL};
   std::vector<std::vector<std::string> > arg_lists = GetArgs(c_args);
   EXPECT_EQ(1, arg_lists.size());
   EXPECT_EQ(3, arg_lists[0].size());
 }
 
 }  // namespace login_manager