Added support for signed policy blobs on desktop.

components/policy/core/common/cloud/policy_builder.cc

 // Copyright (c) 2012 The Chromium 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 "components/policy/core/common/cloud/policy_builder.h"
 
 #include <vector>
 
 #include "base/stl_util.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
@@ skipping 126 matching lines @@
   return scoped_ptr<crypto::RSAPrivateKey>(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(raw_new_signing_key_));
 }
 
 void PolicyBuilder::SetDefaultNewSigningKey() {
   std::vector<uint8> key(kNewSigningKey,
                          kNewSigningKey + arraysize(kNewSigningKey));
   raw_new_signing_key_.swap(key);
 }
 
+void PolicyBuilder::SetDefaultInitialSigningKey() {
+  std::vector<uint8> key(kSigningKey,
+                         kSigningKey + arraysize(kSigningKey));
+  raw_new_signing_key_.swap(key);
+  UnsetSigningKey();
+}
+
 void PolicyBuilder::UnsetNewSigningKey() {
   raw_new_signing_key_.clear();
 }
 
 void PolicyBuilder::Build() {
   if (policy_data_.get())
     CHECK(policy_data_->SerializeToString(policy_.mutable_policy_data()));
 
   // Generate signatures if applicable.
   scoped_ptr<crypto::RSAPrivateKey> policy_signing_key = GetNewSigningKey();
   if (policy_signing_key) {
     // Add the new public key.
     std::vector<uint8> raw_new_public_signing_key;
     CHECK(policy_signing_key->ExportPublicKey(&raw_new_public_signing_key));
     policy_.set_new_public_key(vector_as_array(&raw_new_public_signing_key),
                                raw_new_public_signing_key.size());
 
     // The new public key must be signed by the old key.
     scoped_ptr<crypto::RSAPrivateKey> old_signing_key = GetSigningKey();
     if (old_signing_key) {
       SignData(policy_.new_public_key(),
                old_signing_key.get(),
                policy_.mutable_new_public_key_signature());
     }
   } else {
+    // No new signing key, so clear the old public key (this allows us to
+    // reuse the same PolicyBuilder to build multiple policy blobs).
+    policy_.clear_new_public_key();
+    policy_.clear_new_public_key_signature();
     policy_signing_key = GetSigningKey();
   }
 
   // PolicyData signature.
   if (policy_signing_key) {
     SignData(policy_.policy_data(), policy_signing_key.get(),
              policy_.mutable_policy_data_signature());
   }
 }
 
@@ skipping 16 matching lines @@
 }
 
 // static
 scoped_ptr<crypto::RSAPrivateKey> PolicyBuilder::CreateTestOtherSigningKey() {
   std::vector<uint8> raw_new_signing_key(
       kNewSigningKey, kNewSigningKey + arraysize(kNewSigningKey));
   return scoped_ptr<crypto::RSAPrivateKey>(
       crypto::RSAPrivateKey::CreateFromPrivateKeyInfo(raw_new_signing_key));
 }
 
+// static
+std::string PolicyBuilder::GetTestSigningKeySignature() {
+  // TODO(atwilson): Return a real verification signature when one is available.
+  return std::string();
+}
+
+// static
+std::string PolicyBuilder::GetTestOtherSigningKeySignature() {
+  // TODO(atwilson): Return a real verification signature when one is available.
+  return std::string();
+}
+
 void PolicyBuilder::SignData(const std::string& data,
                              crypto::RSAPrivateKey* key,
                              std::string* signature) {
   scoped_ptr<crypto::SignatureCreator> signature_creator(
       crypto::SignatureCreator::Create(key));
   signature_creator->Update(reinterpret_cast<const uint8*>(data.c_str()),
                             data.size());
   std::vector<uint8> signature_bytes;
   CHECK(signature_creator->Final(&signature_bytes));
   signature->assign(
@@ skipping 14 matching lines @@
 template<>
 TypedPolicyBuilder<em::ExternalPolicyData>::TypedPolicyBuilder()
     : payload_(new em::ExternalPolicyData()) {
   policy_data().set_policy_type(dm_protocol::kChromeExtensionPolicyType);
 }
 
 template class TypedPolicyBuilder<em::ExternalPolicyData>;
 #endif
 
 }  // namespace policy