device_cloud_policy_store_chromeos_unittest.cc revision a93a17c8d99d686bd4a1511e5504e5e6cc9fcadf
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/browser/chromeos/policy/device_cloud_policy_store_chromeos.h" 6 7#include <vector> 8 9#include "base/basictypes.h" 10#include "base/compiler_specific.h" 11#include "base/memory/scoped_ptr.h" 12#include "base/run_loop.h" 13#include "chrome/browser/chromeos/policy/enterprise_install_attributes.h" 14#include "chrome/browser/chromeos/settings/device_settings_test_helper.h" 15#include "chrome/browser/policy/proto/chromeos/chrome_device_policy.pb.h" 16#include "chromeos/cryptohome/cryptohome_library.h" 17#include "chromeos/dbus/cryptohome_client.h" 18#include "policy/policy_constants.h" 19#include "testing/gtest/include/gtest/gtest.h" 20 21namespace policy { 22 23namespace { 24 25void CopyLockResult(base::RunLoop* loop, 26 EnterpriseInstallAttributes::LockResult* out, 27 EnterpriseInstallAttributes::LockResult result) { 28 *out = result; 29 loop->Quit(); 30} 31 32} // namespace 33 34class DeviceCloudPolicyStoreChromeOSTest 35 : public chromeos::DeviceSettingsTestBase { 36 protected: 37 DeviceCloudPolicyStoreChromeOSTest() 38 : cryptohome_library_(chromeos::CryptohomeLibrary::GetTestImpl()), 39 stub_cryptohome_client_(chromeos::CryptohomeClient::Create( 40 chromeos::STUB_DBUS_CLIENT_IMPLEMENTATION, NULL)), 41 install_attributes_(new EnterpriseInstallAttributes( 42 cryptohome_library_.get(), stub_cryptohome_client_.get())), 43 store_(new DeviceCloudPolicyStoreChromeOS(&device_settings_service_, 44 install_attributes_.get())) {} 45 46 virtual void SetUp() OVERRIDE { 47 DeviceSettingsTestBase::SetUp(); 48 49 base::RunLoop loop; 50 EnterpriseInstallAttributes::LockResult result; 51 install_attributes_->LockDevice( 52 PolicyBuilder::kFakeUsername, 53 DEVICE_MODE_ENTERPRISE, 54 PolicyBuilder::kFakeDeviceId, 55 base::Bind(&CopyLockResult, &loop, &result)); 56 loop.Run(); 57 ASSERT_EQ(EnterpriseInstallAttributes::LOCK_SUCCESS, result); 58 } 59 60 void ExpectFailure(CloudPolicyStore::Status expected_status) { 61 EXPECT_EQ(expected_status, store_->status()); 62 EXPECT_TRUE(store_->is_initialized()); 63 EXPECT_FALSE(store_->has_policy()); 64 EXPECT_FALSE(store_->is_managed()); 65 } 66 67 void ExpectSuccess() { 68 EXPECT_EQ(CloudPolicyStore::STATUS_OK, store_->status()); 69 EXPECT_TRUE(store_->is_initialized()); 70 EXPECT_TRUE(store_->has_policy()); 71 EXPECT_TRUE(store_->is_managed()); 72 EXPECT_TRUE(store_->policy()); 73 base::FundamentalValue expected(false); 74 EXPECT_TRUE( 75 base::Value::Equals(&expected, 76 store_->policy_map().GetValue( 77 key::kDeviceMetricsReportingEnabled))); 78 } 79 80 void PrepareExistingPolicy() { 81 store_->Load(); 82 FlushDeviceSettings(); 83 ExpectSuccess(); 84 85 device_policy_.set_new_signing_key(scoped_ptr<crypto::RSAPrivateKey>()); 86 device_policy_.Build(); 87 } 88 89 void PrepareNewSigningKey() { 90 device_policy_.set_new_signing_key( 91 PolicyBuilder::CreateTestNewSigningKey()); 92 device_policy_.Build(); 93 owner_key_util_->SetPublicKeyFromPrivateKey( 94 device_policy_.new_signing_key()); 95 } 96 97 void ResetToNonEnterprise() { 98 store_.reset(); 99 cryptohome_library_->InstallAttributesSet("enterprise.owned", 100 std::string()); 101 install_attributes_.reset(new EnterpriseInstallAttributes( 102 cryptohome_library_.get(), stub_cryptohome_client_.get())); 103 store_.reset(new DeviceCloudPolicyStoreChromeOS(&device_settings_service_, 104 install_attributes_.get())); 105 } 106 107 scoped_ptr<chromeos::CryptohomeLibrary> cryptohome_library_; 108 scoped_ptr<chromeos::CryptohomeClient> stub_cryptohome_client_; 109 scoped_ptr<EnterpriseInstallAttributes> install_attributes_; 110 111 scoped_ptr<DeviceCloudPolicyStoreChromeOS> store_; 112 113 private: 114 DISALLOW_COPY_AND_ASSIGN(DeviceCloudPolicyStoreChromeOSTest); 115}; 116 117TEST_F(DeviceCloudPolicyStoreChromeOSTest, LoadNoKey) { 118 owner_key_util_->Clear(); 119 store_->Load(); 120 FlushDeviceSettings(); 121 ExpectFailure(CloudPolicyStore::STATUS_BAD_STATE); 122} 123 124TEST_F(DeviceCloudPolicyStoreChromeOSTest, LoadNoPolicy) { 125 device_settings_test_helper_.set_policy_blob(std::string()); 126 store_->Load(); 127 FlushDeviceSettings(); 128 ExpectFailure(CloudPolicyStore::STATUS_LOAD_ERROR); 129} 130 131TEST_F(DeviceCloudPolicyStoreChromeOSTest, LoadNotEnterprise) { 132 ResetToNonEnterprise(); 133 store_->Load(); 134 FlushDeviceSettings(); 135 ExpectFailure(CloudPolicyStore::STATUS_BAD_STATE); 136} 137 138TEST_F(DeviceCloudPolicyStoreChromeOSTest, LoadSuccess) { 139 store_->Load(); 140 FlushDeviceSettings(); 141 ExpectSuccess(); 142} 143 144TEST_F(DeviceCloudPolicyStoreChromeOSTest, StoreSuccess) { 145 PrepareExistingPolicy(); 146 store_->Store(device_policy_.policy()); 147 FlushDeviceSettings(); 148 ExpectSuccess(); 149} 150 151TEST_F(DeviceCloudPolicyStoreChromeOSTest, StoreNoSignature) { 152 PrepareExistingPolicy(); 153 device_policy_.policy().clear_policy_data_signature(); 154 store_->Store(device_policy_.policy()); 155 FlushDeviceSettings(); 156 EXPECT_EQ(CloudPolicyStore::STATUS_VALIDATION_ERROR, store_->status()); 157 EXPECT_EQ(CloudPolicyValidatorBase::VALIDATION_BAD_SIGNATURE, 158 store_->validation_status()); 159} 160 161TEST_F(DeviceCloudPolicyStoreChromeOSTest, StoreBadSignature) { 162 PrepareExistingPolicy(); 163 device_policy_.policy().set_policy_data_signature("invalid"); 164 store_->Store(device_policy_.policy()); 165 FlushDeviceSettings(); 166 EXPECT_EQ(CloudPolicyStore::STATUS_VALIDATION_ERROR, store_->status()); 167 EXPECT_EQ(CloudPolicyValidatorBase::VALIDATION_BAD_SIGNATURE, 168 store_->validation_status()); 169} 170 171TEST_F(DeviceCloudPolicyStoreChromeOSTest, StoreKeyRotation) { 172 PrepareExistingPolicy(); 173 device_policy_.set_new_signing_key(PolicyBuilder::CreateTestNewSigningKey()); 174 device_policy_.Build(); 175 store_->Store(device_policy_.policy()); 176 device_settings_test_helper_.FlushLoops(); 177 device_settings_test_helper_.FlushStore(); 178 owner_key_util_->SetPublicKeyFromPrivateKey(device_policy_.new_signing_key()); 179 ReloadDeviceSettings(); 180 ExpectSuccess(); 181} 182 183TEST_F(DeviceCloudPolicyStoreChromeOSTest, InstallInitialPolicySuccess) { 184 PrepareNewSigningKey(); 185 store_->InstallInitialPolicy(device_policy_.policy()); 186 FlushDeviceSettings(); 187 ExpectSuccess(); 188} 189 190TEST_F(DeviceCloudPolicyStoreChromeOSTest, InstallInitialPolicyNoSignature) { 191 PrepareNewSigningKey(); 192 device_policy_.policy().clear_policy_data_signature(); 193 store_->InstallInitialPolicy(device_policy_.policy()); 194 FlushDeviceSettings(); 195 ExpectFailure(CloudPolicyStore::STATUS_VALIDATION_ERROR); 196 EXPECT_EQ(CloudPolicyValidatorBase::VALIDATION_BAD_INITIAL_SIGNATURE, 197 store_->validation_status()); 198} 199 200TEST_F(DeviceCloudPolicyStoreChromeOSTest, InstallInitialPolicyNoKey) { 201 PrepareNewSigningKey(); 202 device_policy_.policy().clear_new_public_key(); 203 store_->InstallInitialPolicy(device_policy_.policy()); 204 FlushDeviceSettings(); 205 ExpectFailure(CloudPolicyStore::STATUS_VALIDATION_ERROR); 206 EXPECT_EQ(CloudPolicyValidatorBase::VALIDATION_BAD_INITIAL_SIGNATURE, 207 store_->validation_status()); 208} 209 210TEST_F(DeviceCloudPolicyStoreChromeOSTest, InstallInitialPolicyNotEnterprise) { 211 PrepareNewSigningKey(); 212 ResetToNonEnterprise(); 213 store_->InstallInitialPolicy(device_policy_.policy()); 214 FlushDeviceSettings(); 215 ExpectFailure(CloudPolicyStore::STATUS_BAD_STATE); 216} 217 218} // namespace policy 219