components/ownership/owner_settings_service.cc

   1 // Copyright 2014 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 "components/ownership/owner_settings_service.h"
   6
   7 #include <cryptohi.h>
   8 #include <keyhi.h>
   9
  10 #include "base/basictypes.h"
  11 #include "base/bind.h"
  12 #include "base/callback.h"
  13 #include "base/location.h"
  14 #include "base/logging.h"
  15 #include "base/message_loop/message_loop.h"
  16 #include "base/task_runner.h"
  17 #include "base/task_runner_util.h"
  18 #include "base/values.h"
  19 #include "components/ownership/owner_key_util.h"
  20 #include "crypto/scoped_nss_types.h"
  21
  22 namespace em = enterprise_management;
  23
  24 namespace ownership {
  25
  26 namespace {
  27
  28 using ScopedSGNContext =
  29     scoped_ptr<SGNContext,
  30                crypto::NSSDestroyer1<SGNContext, SGN_DestroyContext, PR_TRUE>>;
  31
  32 scoped_ptr<em::PolicyFetchResponse> AssembleAndSignPolicy(
  33     scoped_ptr<em::PolicyData> policy,
  34     SECKEYPrivateKey* private_key) {
  35   // Assemble the policy.
  36   scoped_ptr<em::PolicyFetchResponse> policy_response(
  37       new em::PolicyFetchResponse());
  38   if (!policy->SerializeToString(policy_response->mutable_policy_data())) {
  39     LOG(ERROR) << "Failed to encode policy payload.";
  40     return scoped_ptr<em::PolicyFetchResponse>(nullptr).Pass();
  41   }
  42
  43   ScopedSGNContext sign_context(
  44       SGN_NewContext(SEC_OID_PKCS1_SHA1_WITH_RSA_ENCRYPTION, private_key));
  45   if (!sign_context) {
  46     NOTREACHED();
  47     return nullptr;
  48   }
  49
  50   SECItem signature_item;
  51   if (SGN_Begin(sign_context.get()) != SECSuccess ||
  52       SGN_Update(sign_context.get(),
  53                  reinterpret_cast<const uint8*>(
  54                      policy_response->policy_data().c_str()),
  55                  policy_response->policy_data().size()) != SECSuccess ||
  56       SGN_End(sign_context.get(), &signature_item) != SECSuccess) {
  57     LOG(ERROR) << "Failed to create policy signature.";
  58     return nullptr;
  59   }
  60
  61   policy_response->mutable_policy_data_signature()->assign(
  62       reinterpret_cast<const char*>(signature_item.data), signature_item.len);
  63   SECITEM_FreeItem(&signature_item, PR_FALSE);
  64
  65   return policy_response.Pass();
  66 }
  67
  68 }  // namepace
  69
  70 OwnerSettingsService::OwnerSettingsService(
  71     const scoped_refptr<ownership::OwnerKeyUtil>& owner_key_util)
  72     : owner_key_util_(owner_key_util), weak_factory_(this) {
  73 }
  74
  75 OwnerSettingsService::~OwnerSettingsService() {
  76   DCHECK(thread_checker_.CalledOnValidThread());
  77 }
  78
  79 void OwnerSettingsService::AddObserver(Observer* observer) {
  80   if (observer && !observers_.HasObserver(observer))
  81     observers_.AddObserver(observer);
  82 }
  83
  84 void OwnerSettingsService::RemoveObserver(Observer* observer) {
  85   observers_.RemoveObserver(observer);
  86 }
  87
  88 bool OwnerSettingsService::IsOwner() {
  89   DCHECK(thread_checker_.CalledOnValidThread());
  90   return private_key_.get() && private_key_->key();
  91 }
  92
  93 void OwnerSettingsService::IsOwnerAsync(const IsOwnerCallback& callback) {
  94   DCHECK(thread_checker_.CalledOnValidThread());
  95   if (private_key_.get()) {
  96     base::MessageLoop::current()->PostTask(FROM_HERE,
  97                                            base::Bind(callback, IsOwner()));
  98   } else {
  99     pending_is_owner_callbacks_.push_back(callback);
 100   }
 101 }
 102
 103 bool OwnerSettingsService::AssembleAndSignPolicyAsync(
 104     base::TaskRunner* task_runner,
 105     scoped_ptr<em::PolicyData> policy,
 106     const AssembleAndSignPolicyAsyncCallback& callback) {
 107   DCHECK(thread_checker_.CalledOnValidThread());
 108   if (!task_runner || !IsOwner())
 109     return false;
 110   return base::PostTaskAndReplyWithResult(
 111       task_runner,
 112       FROM_HERE,
 113       base::Bind(
 114           &AssembleAndSignPolicy, base::Passed(&policy), private_key_->key()),
 115       callback);
 116 }
 117
 118 bool OwnerSettingsService::SetBoolean(const std::string& setting, bool value) {
 119   DCHECK(thread_checker_.CalledOnValidThread());
 120   base::FundamentalValue in_value(value);
 121   return Set(setting, in_value);
 122 }
 123
 124 bool OwnerSettingsService::SetInteger(const std::string& setting, int value) {
 125   DCHECK(thread_checker_.CalledOnValidThread());
 126   base::FundamentalValue in_value(value);
 127   return Set(setting, in_value);
 128 }
 129
 130 bool OwnerSettingsService::SetDouble(const std::string& setting, double value) {
 131   DCHECK(thread_checker_.CalledOnValidThread());
 132   base::FundamentalValue in_value(value);
 133   return Set(setting, in_value);
 134 }
 135
 136 bool OwnerSettingsService::SetString(const std::string& setting,
 137                                      const std::string& value) {
 138   DCHECK(thread_checker_.CalledOnValidThread());
 139   base::StringValue in_value(value);
 140   return Set(setting, in_value);
 141 }
 142
 143 void OwnerSettingsService::ReloadKeypair() {
 144   ReloadKeypairImpl(
 145       base::Bind(&OwnerSettingsService::OnKeypairLoaded, as_weak_ptr()));
 146 }
 147
 148 void OwnerSettingsService::OnKeypairLoaded(
 149     const scoped_refptr<PublicKey>& public_key,
 150     const scoped_refptr<PrivateKey>& private_key) {
 151   DCHECK(thread_checker_.CalledOnValidThread());
 152
 153   public_key_ = public_key;
 154   private_key_ = private_key;
 155
 156   const bool is_owner = IsOwner();
 157   std::vector<IsOwnerCallback> is_owner_callbacks;
 158   is_owner_callbacks.swap(pending_is_owner_callbacks_);
 159   for (std::vector<IsOwnerCallback>::iterator it(is_owner_callbacks.begin());
 160        it != is_owner_callbacks.end();
 161        ++it) {
 162     it->Run(is_owner);
 163   }
 164
 165   OnPostKeypairLoadedActions();
 166 }
 167
 168 }  // namespace ownership