Home | History | Annotate | Download | only in settings 
      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/settings/device_settings_service.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/logging.h"
      9 #include "base/message_loop/message_loop.h"
     10 #include "base/stl_util.h"
     11 #include "base/time/time.h"
     12 #include "chrome/browser/chrome_notification_types.h"
     13 #include "chrome/browser/chromeos/policy/proto/chrome_device_policy.pb.h"
     14 #include "chrome/browser/chromeos/settings/session_manager_operation.h"
     15 #include "components/ownership/owner_key_util.h"
     16 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
     17 #include "content/public/browser/browser_thread.h"
     18 #include "content/public/browser/notification_service.h"
     19 #include "content/public/browser/notification_source.h"
     20 #include "crypto/rsa_private_key.h"
     21 
     22 namespace em = enterprise_management;
     23 
     24 using ownership::OwnerKeyUtil;
     25 using ownership::PublicKey;
     26 
     27 namespace {
     28 
     29 // Delay between load retries when there was a validation error.
     30 // NOTE: This code is here to mitigate clock loss on some devices where policy
     31 // loads will fail with a validation error caused by RTC clock being reset when
     32 // the battery is drained.
     33 int kLoadRetryDelayMs = 1000 * 5;
     34 // Maximal number of retries before we give up. Calculated to allow for 10 min
     35 // of retry time.
     36 int kMaxLoadRetries = (1000 * 60 * 10) / kLoadRetryDelayMs;
     37 
     38 // Assembles PolicyData based on |settings|, |policy_data| and
     39 // |user_id|.
     40 scoped_ptr<em::PolicyData> AssemblePolicy(
     41     const std::string& user_id,
     42     const em::PolicyData* policy_data,
     43     const em::ChromeDeviceSettingsProto* settings) {
     44   scoped_ptr<em::PolicyData> policy(new em::PolicyData());
     45   if (policy_data) {
     46     // Preserve management settings.
     47     if (policy_data->has_management_mode())
     48       policy->set_management_mode(policy_data->management_mode());
     49     if (policy_data->has_request_token())
     50       policy->set_request_token(policy_data->request_token());
     51     if (policy_data->has_device_id())
     52       policy->set_device_id(policy_data->device_id());
     53   } else {
     54     // If there's no previous policy data, this is the first time the device
     55     // setting is set. We set the management mode to NOT_MANAGED initially.
     56     policy->set_management_mode(em::PolicyData::NOT_MANAGED);
     57   }
     58   policy->set_policy_type(policy::dm_protocol::kChromeDevicePolicyType);
     59   policy->set_timestamp(
     60       (base::Time::Now() - base::Time::UnixEpoch()).InMilliseconds());
     61   policy->set_username(user_id);
     62   if (!settings->SerializeToString(policy->mutable_policy_value()))
     63     return scoped_ptr<em::PolicyData>();
     64 
     65   return policy.Pass();
     66 }
     67 
     68 // Returns true if it is okay to transfer from the current mode to the new
     69 // mode. This function should be called in SetManagementMode().
     70 bool CheckManagementModeTransition(em::PolicyData::ManagementMode current_mode,
     71                                    em::PolicyData::ManagementMode new_mode) {
     72   // Mode is not changed.
     73   if (current_mode == new_mode)
     74     return true;
     75 
     76   switch (current_mode) {
     77     case em::PolicyData::NOT_MANAGED:
     78       // For consumer management enrollment.
     79       return new_mode == em::PolicyData::CONSUMER_MANAGED;
     80 
     81     case em::PolicyData::ENTERPRISE_MANAGED:
     82       // Management mode cannot be set when it is currently ENTERPRISE_MANAGED.
     83       return false;
     84 
     85     case em::PolicyData::CONSUMER_MANAGED:
     86       // For consumer management unenrollment.
     87       return new_mode == em::PolicyData::NOT_MANAGED;
     88   }
     89 
     90   NOTREACHED();
     91   return false;
     92 }
     93 
     94 }  // namespace
     95 
     96 namespace chromeos {
     97 
     98 DeviceSettingsService::Observer::~Observer() {}
     99 
    100 static DeviceSettingsService* g_device_settings_service = NULL;
    101 
    102 // static
    103 void DeviceSettingsService::Initialize() {
    104   CHECK(!g_device_settings_service);
    105   g_device_settings_service = new DeviceSettingsService();
    106 }
    107 
    108 // static
    109 bool DeviceSettingsService::IsInitialized() {
    110   return g_device_settings_service;
    111 }
    112 
    113 // static
    114 void DeviceSettingsService::Shutdown() {
    115   DCHECK(g_device_settings_service);
    116   delete g_device_settings_service;
    117   g_device_settings_service = NULL;
    118 }
    119 
    120 // static
    121 DeviceSettingsService* DeviceSettingsService::Get() {
    122   CHECK(g_device_settings_service);
    123   return g_device_settings_service;
    124 }
    125 
    126 DeviceSettingsService::DeviceSettingsService()
    127     : session_manager_client_(NULL),
    128       store_status_(STORE_SUCCESS),
    129       load_retries_left_(kMaxLoadRetries),
    130       weak_factory_(this) {
    131 }
    132 
    133 DeviceSettingsService::~DeviceSettingsService() {
    134   DCHECK(pending_operations_.empty());
    135 }
    136 
    137 void DeviceSettingsService::SetSessionManager(
    138     SessionManagerClient* session_manager_client,
    139     scoped_refptr<OwnerKeyUtil> owner_key_util) {
    140   DCHECK(session_manager_client);
    141   DCHECK(owner_key_util.get());
    142   DCHECK(!session_manager_client_);
    143   DCHECK(!owner_key_util_.get());
    144 
    145   session_manager_client_ = session_manager_client;
    146   owner_key_util_ = owner_key_util;
    147 
    148   session_manager_client_->AddObserver(this);
    149 
    150   StartNextOperation();
    151 }
    152 
    153 void DeviceSettingsService::UnsetSessionManager() {
    154   STLDeleteContainerPointers(pending_operations_.begin(),
    155                              pending_operations_.end());
    156   pending_operations_.clear();
    157 
    158   if (session_manager_client_)
    159     session_manager_client_->RemoveObserver(this);
    160   session_manager_client_ = NULL;
    161   owner_key_util_ = NULL;
    162 }
    163 
    164 scoped_refptr<PublicKey> DeviceSettingsService::GetPublicKey() {
    165   return public_key_;
    166 }
    167 
    168 void DeviceSettingsService::Load() {
    169   EnqueueLoad(false);
    170 }
    171 
    172 void DeviceSettingsService::SignAndStore(
    173     scoped_ptr<em::ChromeDeviceSettingsProto> new_settings,
    174     const base::Closure& callback) {
    175   if (!owner_settings_service_) {
    176     HandleError(STORE_KEY_UNAVAILABLE, callback);
    177     return;
    178   }
    179   scoped_ptr<em::PolicyData> policy =
    180       AssemblePolicy(GetUsername(), policy_data(), new_settings.get());
    181   if (!policy) {
    182     HandleError(STORE_POLICY_ERROR, callback);
    183     return;
    184   }
    185 
    186   owner_settings_service_->SignAndStorePolicyAsync(policy.Pass(), callback);
    187 }
    188 
    189 void DeviceSettingsService::SetManagementSettings(
    190     em::PolicyData::ManagementMode management_mode,
    191     const std::string& request_token,
    192     const std::string& device_id,
    193     const base::Closure& callback) {
    194   if (!owner_settings_service_) {
    195     HandleError(STORE_KEY_UNAVAILABLE, callback);
    196     return;
    197   }
    198 
    199   em::PolicyData::ManagementMode current_mode = em::PolicyData::NOT_MANAGED;
    200   if (policy_data() && policy_data()->has_management_mode())
    201     current_mode = policy_data()->management_mode();
    202 
    203   if (!CheckManagementModeTransition(current_mode, management_mode)) {
    204     LOG(ERROR) << "Invalid management mode transition: current mode = "
    205                << current_mode << ", new mode = " << management_mode;
    206     HandleError(DeviceSettingsService::STORE_POLICY_ERROR, callback);
    207     return;
    208   }
    209 
    210   scoped_ptr<em::PolicyData> policy =
    211       AssemblePolicy(GetUsername(), policy_data(), device_settings());
    212   if (!policy) {
    213     HandleError(DeviceSettingsService::STORE_POLICY_ERROR, callback);
    214     return;
    215   }
    216 
    217   policy->set_management_mode(management_mode);
    218   policy->set_request_token(request_token);
    219   policy->set_device_id(device_id);
    220 
    221   owner_settings_service_->SignAndStorePolicyAsync(policy.Pass(), callback);
    222 }
    223 
    224 void DeviceSettingsService::Store(scoped_ptr<em::PolicyFetchResponse> policy,
    225                                   const base::Closure& callback) {
    226   Enqueue(
    227       new StoreSettingsOperation(
    228           base::Bind(&DeviceSettingsService::HandleCompletedOperation,
    229                      weak_factory_.GetWeakPtr(),
    230                      callback),
    231           policy.Pass()));
    232 }
    233 
    234 DeviceSettingsService::OwnershipStatus
    235     DeviceSettingsService::GetOwnershipStatus() {
    236   if (public_key_.get())
    237     return public_key_->is_loaded() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
    238   return OWNERSHIP_UNKNOWN;
    239 }
    240 
    241 void DeviceSettingsService::GetOwnershipStatusAsync(
    242     const OwnershipStatusCallback& callback) {
    243   if (public_key_.get()) {
    244     // If there is a key, report status immediately.
    245     base::MessageLoop::current()->PostTask(
    246         FROM_HERE, base::Bind(callback, GetOwnershipStatus()));
    247   } else {
    248     // If the key hasn't been loaded yet, enqueue the callback to be fired when
    249     // the next SessionManagerOperation completes. If no operation is pending,
    250     // start a load operation to fetch the key and report the result.
    251     pending_ownership_status_callbacks_.push_back(callback);
    252     if (pending_operations_.empty())
    253       EnqueueLoad(false);
    254   }
    255 }
    256 
    257 bool DeviceSettingsService::HasPrivateOwnerKey() {
    258   return owner_settings_service_ && owner_settings_service_->IsOwner();
    259 }
    260 
    261 void DeviceSettingsService::InitOwner(
    262     const std::string& username,
    263     const base::WeakPtr<ownership::OwnerSettingsService>&
    264         owner_settings_service) {
    265   // When InitOwner() is called twice with the same |username| it's
    266   // worth to reload settings since owner key may become available.
    267   if (!username_.empty() && username_ != username)
    268     return;
    269   username_ = username;
    270   owner_settings_service_ = owner_settings_service;
    271 
    272   EnsureReload(true);
    273 }
    274 
    275 const std::string& DeviceSettingsService::GetUsername() const {
    276   return username_;
    277 }
    278 
    279 void DeviceSettingsService::AddObserver(Observer* observer) {
    280   observers_.AddObserver(observer);
    281 }
    282 
    283 void DeviceSettingsService::RemoveObserver(Observer* observer) {
    284   observers_.RemoveObserver(observer);
    285 }
    286 
    287 void DeviceSettingsService::OwnerKeySet(bool success) {
    288   if (!success) {
    289     LOG(ERROR) << "Owner key change failed.";
    290     return;
    291   }
    292 
    293   public_key_ = NULL;
    294   EnsureReload(true);
    295 }
    296 
    297 void DeviceSettingsService::PropertyChangeComplete(bool success) {
    298   if (!success) {
    299     LOG(ERROR) << "Policy update failed.";
    300     return;
    301   }
    302 
    303   EnsureReload(false);
    304 }
    305 
    306 void DeviceSettingsService::Enqueue(SessionManagerOperation* operation) {
    307   pending_operations_.push_back(operation);
    308   if (pending_operations_.front() == operation)
    309     StartNextOperation();
    310 }
    311 
    312 void DeviceSettingsService::EnqueueLoad(bool force_key_load) {
    313   SessionManagerOperation* operation =
    314       new LoadSettingsOperation(
    315           base::Bind(&DeviceSettingsService::HandleCompletedOperation,
    316                      weak_factory_.GetWeakPtr(),
    317                      base::Closure()));
    318   operation->set_force_key_load(force_key_load);
    319   operation->set_username(username_);
    320   operation->set_owner_settings_service(owner_settings_service_);
    321   Enqueue(operation);
    322 }
    323 
    324 void DeviceSettingsService::EnsureReload(bool force_key_load) {
    325   if (!pending_operations_.empty()) {
    326     pending_operations_.front()->set_username(username_);
    327     pending_operations_.front()->set_owner_settings_service(
    328         owner_settings_service_);
    329     pending_operations_.front()->RestartLoad(force_key_load);
    330   } else {
    331     EnqueueLoad(force_key_load);
    332   }
    333 }
    334 
    335 void DeviceSettingsService::StartNextOperation() {
    336   if (!pending_operations_.empty() &&
    337       session_manager_client_ &&
    338       owner_key_util_.get()) {
    339     pending_operations_.front()->Start(
    340         session_manager_client_, owner_key_util_, public_key_);
    341   }
    342 }
    343 
    344 void DeviceSettingsService::HandleCompletedOperation(
    345     const base::Closure& callback,
    346     SessionManagerOperation* operation,
    347     Status status) {
    348   DCHECK_EQ(operation, pending_operations_.front());
    349   store_status_ = status;
    350 
    351   OwnershipStatus ownership_status = OWNERSHIP_UNKNOWN;
    352   scoped_refptr<PublicKey> new_key(operation->public_key());
    353   if (new_key.get()) {
    354     ownership_status = new_key->is_loaded() ? OWNERSHIP_TAKEN : OWNERSHIP_NONE;
    355   } else {
    356     NOTREACHED() << "Failed to determine key status.";
    357   }
    358 
    359   bool new_owner_key = false;
    360   if (public_key_.get() != new_key.get()) {
    361     public_key_ = new_key;
    362     new_owner_key = true;
    363   }
    364 
    365   if (status == STORE_SUCCESS) {
    366     policy_data_ = operation->policy_data().Pass();
    367     device_settings_ = operation->device_settings().Pass();
    368     load_retries_left_ = kMaxLoadRetries;
    369   } else if (status != STORE_KEY_UNAVAILABLE) {
    370     LOG(ERROR) << "Session manager operation failed: " << status;
    371     // Validation errors can be temporary if the rtc has gone on holiday for a
    372     // short while. So we will retry such loads for up to 10 minutes.
    373     if (status == STORE_TEMP_VALIDATION_ERROR) {
    374       if (load_retries_left_ > 0) {
    375         load_retries_left_--;
    376         LOG(ERROR) << "A re-load has been scheduled due to a validation error.";
    377         content::BrowserThread::PostDelayedTask(
    378             content::BrowserThread::UI,
    379             FROM_HERE,
    380             base::Bind(&DeviceSettingsService::Load, base::Unretained(this)),
    381             base::TimeDelta::FromMilliseconds(kLoadRetryDelayMs));
    382       } else {
    383         // Once we've given up retrying, the validation error is not temporary
    384         // anymore.
    385         store_status_ = STORE_VALIDATION_ERROR;
    386       }
    387     }
    388   }
    389 
    390   if (new_owner_key) {
    391     FOR_EACH_OBSERVER(Observer, observers_, OwnershipStatusChanged());
    392     content::NotificationService::current()->Notify(
    393         chrome::NOTIFICATION_OWNERSHIP_STATUS_CHANGED,
    394         content::Source<DeviceSettingsService>(this),
    395         content::NotificationService::NoDetails());
    396   }
    397 
    398   FOR_EACH_OBSERVER(Observer, observers_, DeviceSettingsUpdated());
    399 
    400   std::vector<OwnershipStatusCallback> callbacks;
    401   callbacks.swap(pending_ownership_status_callbacks_);
    402   for (std::vector<OwnershipStatusCallback>::iterator iter(callbacks.begin());
    403        iter != callbacks.end(); ++iter) {
    404     iter->Run(ownership_status);
    405   }
    406 
    407   // The completion callback happens after the notification so clients can
    408   // filter self-triggered updates.
    409   if (!callback.is_null())
    410     callback.Run();
    411 
    412   // Only remove the pending operation here, so new operations triggered by any
    413   // of the callbacks above are queued up properly.
    414   pending_operations_.pop_front();
    415   delete operation;
    416 
    417   StartNextOperation();
    418 }
    419 
    420 void DeviceSettingsService::HandleError(Status status,
    421                                         const base::Closure& callback) {
    422   store_status_ = status;
    423 
    424   LOG(ERROR) << "Session manager operation failed: " << status;
    425 
    426   FOR_EACH_OBSERVER(Observer, observers_, DeviceSettingsUpdated());
    427 
    428   // The completion callback happens after the notification so clients can
    429   // filter self-triggered updates.
    430   if (!callback.is_null())
    431     callback.Run();
    432 }
    433 
    434 void DeviceSettingsService::OnSignAndStoreOperationCompleted(Status status) {
    435   store_status_ = status;
    436   FOR_EACH_OBSERVER(Observer, observers_, DeviceSettingsUpdated());
    437 }
    438 
    439 ScopedTestDeviceSettingsService::ScopedTestDeviceSettingsService() {
    440   DeviceSettingsService::Initialize();
    441 }
    442 
    443 ScopedTestDeviceSettingsService::~ScopedTestDeviceSettingsService() {
    444   // Clean pending operations.
    445   DeviceSettingsService::Get()->UnsetSessionManager();
    446   DeviceSettingsService::Shutdown();
    447 }
    448 
    449 }  // namespace chromeos
    450