[login_manager] Allow new owner keys to be pushed with StorePolicy

session_manager_unittest.cc

-// Copyright (c) 2009-2010 The Chromium OS Authors. All rights reserved.
+// Copyright (c) 2011 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 30 matching lines @@
 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::_;
 
+MATCHER_P(CastEq, str, "") {                                            \
+  return std::string(reinterpret_cast<const char*>(arg)) == str;        \
+}
+
 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); }
 
@@ skipping 108 matching lines @@
     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))
         .WillOnce(Return(true));
   }
 
   void ExpectStartSessionUnowned(const std::string& email_string,
                                  MockPrefStore* store) {
     MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
     EXPECT_CALL(*job, StartSession(email_string))
         .Times(1);
 
     MockChildJob* k_job = new MockChildJob;
@@ skipping 44 matching lines @@
                                   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(_, _, _))
         .WillOnce(Return(true))
         .RetiresOnSaturation();
     EXPECT_CALL(*store, Set(_, email_string, _))
         .Times(1);
-    EXPECT_CALL(*key, Sign(StrEq(email_string), email_string.length(), _))
+    EXPECT_CALL(*key, Sign(CastEq(email_string), email_string.length(), _))
         .WillOnce(Return(true))
         .RetiresOnSaturation();
     EXPECT_CALL(*store, Whitelist(email_string, _))
         .Times(1);
     EXPECT_CALL(*store, Persist())
         .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))
+        .Times(AtMost(2))
         .WillRepeatedly(Return(true));
   }
 
   void StartFakeSession() {
     manager_->test_api().set_session_started(true, kFakeEmail);
   }
 
   enum ChildRuns {
     ALWAYS, NEVER, ONCE, EXACTLY_ONCE, TWICE, MAYBE_NEVER
   };
@@ skipping 529 matching lines @@
               SendSignalToChromium(chromium::kPropertyChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kWhitelistChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   MockUtils();
 
   std::vector<uint8> pub_key;
-  NssUtil::KeyFromBuffer(kPropValue, &pub_key);
+  NssUtil::BlobFromBuffer(kPropValue, &pub_key);
 
   MockPrefStore* store = new MockPrefStore;
   MockOwnerKey* key = new MockOwnerKey;
   MockDevicePolicy* policy = new MockDevicePolicy;
 
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, PopulateFromBuffer(pub_key))
       .WillOnce(Return(true));
   EXPECT_CALL(*key, Sign(_, _, _))
@@ skipping 43 matching lines @@
 
 TEST_F(SessionManagerTest, WhitelistVerifyFail) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   MockUtils();
 
   MockOwnerKey* key = new MockOwnerKey;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, IsPopulated())
       .WillOnce(Return(true));
-  EXPECT_CALL(*key, Verify(StrEq(kFakeEmail), strlen(kFakeEmail),
-                           fake_sig_->data, fake_sig_->len))
+  EXPECT_CALL(*key, Verify(CastEq(kFakeEmail), strlen(kFakeEmail),
+                           CastEq(fake_sig_->data), fake_sig_->len))
       .WillOnce(Return(false));
   manager_->test_api().set_ownerkey(key);
 
   GError* error = NULL;
   EXPECT_EQ(FALSE, manager_->Whitelist(kFakeEmail, fake_sig_, &error));
   EXPECT_EQ(CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, error->code);
   g_error_free(error);
   SimpleRunManager(new MockPrefStore, new MockDevicePolicy);
 }
 
 TEST_F(SessionManagerTest, Whitelist) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kWhitelistChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   MockUtils();
 
   MockPrefStore* store = new MockPrefStore;
   MockOwnerKey* key = new MockOwnerKey;
   MockDevicePolicy* policy = new MockDevicePolicy;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, IsPopulated())
       .WillOnce(Return(true));
-  EXPECT_CALL(*key, Verify(StrEq(kFakeEmail), strlen(kFakeEmail),
-                           fake_sig_->data, fake_sig_->len))
+  EXPECT_CALL(*key, Verify(CastEq(kFakeEmail), strlen(kFakeEmail),
+                           CastEq(fake_sig_->data), fake_sig_->len))
       .WillOnce(Return(true));
 
   manager_->test_api().set_ownerkey(key);
 
   EXPECT_CALL(*store, Whitelist(kFakeEmail, _))
       .Times(1);
   EXPECT_CALL(*store, Persist())
       .WillOnce(Return(true))
       .WillOnce(Return(true));
 
@@ skipping 14 matching lines @@
       .Times(1);
   MockUtils();
 
   MockPrefStore* store = new MockPrefStore;
   MockOwnerKey* key = new MockOwnerKey;
   MockDevicePolicy* policy = new MockDevicePolicy;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, IsPopulated())
       .WillOnce(Return(true));
-  EXPECT_CALL(*key, Verify(StrEq(kFakeEmail), strlen(kFakeEmail),
-                           fake_sig_->data, fake_sig_->len))
+  EXPECT_CALL(*key, Verify(CastEq(kFakeEmail), strlen(kFakeEmail),
+                           CastEq(fake_sig_->data), fake_sig_->len))
       .WillOnce(Return(true));
 
   manager_->test_api().set_ownerkey(key);
 
   EXPECT_CALL(*store, Unwhitelist(kFakeEmail))
       .Times(1);
   EXPECT_CALL(*store, Persist())
       .WillOnce(Return(true))
       .WillOnce(Return(true));
 
@@ skipping 103 matching lines @@
     EXPECT_EQ(fake_whitelisted[i], out_list[i]);
   }
   EXPECT_EQ(fake_whitelisted.size(), i);
   g_strfreev(out_list);
 }
 
 TEST_F(SessionManagerTest, StorePolicy) {
   enterprise_management::PolicyFetchResponse fake_policy;
   fake_policy.set_policy_data(kPropName);
   fake_policy.set_policy_data_signature(kPropValue);
+  fake_policy.set_new_public_key(kPropName);
+  fake_policy.set_new_public_key_signature(kPropValue);
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
 
   MockPrefStore* store = new MockPrefStore;
   MockOwnerKey* key = new MockOwnerKey;
   MockDevicePolicy* policy = new MockDevicePolicy;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
+  EXPECT_CALL(*key, PopulateFromBuffer(_))
+      .WillOnce(Return(true));
   EXPECT_CALL(*key, IsPopulated())
+      .WillOnce(Return(false))
       .WillOnce(Return(true));
-  EXPECT_CALL(*key, Verify(StrEq(kPropName), strlen(kPropName),
-                           StrEq(kPropValue), strlen(kPropValue)))
+  EXPECT_CALL(*key, Verify(CastEq(kPropName), strlen(kPropName),
+                           CastEq(kPropValue), strlen(kPropValue)))
+      .WillOnce(Return(true));
+  EXPECT_CALL(*key, Equals(StrEq(kPropName)))
+      .WillOnce(Return(false));
+  EXPECT_CALL(*key, Persist())
       .WillOnce(Return(true));
   manager_->test_api().set_ownerkey(key);
 
   EXPECT_CALL(*store, Persist())
       .WillOnce(Return(true));
   manager_->test_api().set_prefstore(store);
 
   EXPECT_CALL(*policy, Persist())
       .WillOnce(Return(true))
       .WillOnce(Return(true));
   EXPECT_CALL(*policy, Set(_))
       .Times(1);
   manager_->test_api().set_policy(policy);
 
+  EXPECT_CALL(*(utils_.get()),
+              SendSignalToChromium(chromium::kOwnerKeySetSignal,
+                                   StrEq("success")))
+      .Times(1);
+  MockUtils();
+
   std::string pol_str = fake_policy.SerializeAsString();
   ASSERT_FALSE(pol_str.empty());
   GArray* policy_array = CreateArray(pol_str.c_str(), pol_str.length());
   EXPECT_EQ(TRUE, manager_->StorePolicy(policy_array, NULL));
   manager_->Run();
   g_array_free(policy_array, TRUE);
 }
 
 TEST_F(SessionManagerTest, StorePropertyNoKey) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
@@ skipping 18 matching lines @@
 
 TEST_F(SessionManagerTest, StorePropertyVerifyFail) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   MockUtils();
 
   MockOwnerKey* key = new MockOwnerKey;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, IsPopulated())
       .WillOnce(Return(true));
-  EXPECT_CALL(*key, Verify(StrEq(property_), property_.length(),
-                           fake_sig_->data, fake_sig_->len))
+  EXPECT_CALL(*key, Verify(CastEq(property_), property_.length(),
+                           CastEq(fake_sig_->data), fake_sig_->len))
       .WillOnce(Return(false));
   manager_->test_api().set_ownerkey(key);
 
   GError* error = NULL;
   EXPECT_EQ(FALSE, manager_->StoreProperty(kPropName,
                                            kPropValue,
                                            fake_sig_,
                                            &error));
   EXPECT_EQ(CHROMEOS_LOGIN_ERROR_VERIFY_FAIL, error->code);
   g_error_free(error);
   SimpleRunManager(new MockPrefStore, new MockDevicePolicy);
 }
 
 TEST_F(SessionManagerTest, StoreProperty) {
   MockChildJob* job = CreateTrivialMockJob(MAYBE_NEVER);
   EXPECT_CALL(*(utils_.get()),
               SendSignalToChromium(chromium::kPropertyChangeCompleteSignal,
                                    StrEq("success")))
       .Times(1);
   MockUtils();
 
   MockPrefStore* store = new MockPrefStore;
   MockOwnerKey* key = new MockOwnerKey;
   MockDevicePolicy* policy = new MockDevicePolicy;
   EXPECT_CALL(*key, PopulateFromDiskIfPossible())
       .WillOnce(Return(true));
   EXPECT_CALL(*key, IsPopulated())
       .WillOnce(Return(true));
-  EXPECT_CALL(*key, Verify(StrEq(property_), property_.length(),
-                           fake_sig_->data, fake_sig_->len))
+  EXPECT_CALL(*key, Verify(CastEq(property_), property_.length(),
+                           CastEq(fake_sig_->data), fake_sig_->len))
       .WillOnce(Return(true));
   manager_->test_api().set_ownerkey(key);
 
   EXPECT_CALL(*store, Set(kPropName, kPropValue, _))
       .Times(1);
   EXPECT_CALL(*store, Persist())
       .WillOnce(Return(true))
       .WillOnce(Return(true));
   manager_->test_api().set_prefstore(store);
 
@@ skipping 236 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