Added support for signed policy blobs on desktop.

components/policy/core/common/cloud/cloud_policy_validator_unittest.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 <vector>
 
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "components/policy/core/common/cloud/cloud_policy_constants.h"
 #include "components/policy/core/common/cloud/cloud_policy_validator.h"
 #include "components/policy/core/common/cloud/policy_builder.h"
 #include "crypto/rsa_private_key.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace em = enterprise_management;
 
@@ skipping 29 matching lines @@
     EXPECT_CALL(*this, ValidationCompletion(validator.get())).WillOnce(
         check_action);
     validator.release()->StartValidation(
         base::Bind(&CloudPolicyValidatorTest::ValidationCompletion,
                    base::Unretained(this)));
     loop_.RunUntilIdle();
     Mock::VerifyAndClearExpectations(this);
   }
 
   scoped_ptr<UserCloudPolicyValidator> CreateValidator() {
-    std::vector<uint8> public_key;
+    std::vector<uint8> public_key_bytes;
     EXPECT_TRUE(
-        PolicyBuilder::CreateTestSigningKey()->ExportPublicKey(&public_key));
+        PolicyBuilder::CreateTestSigningKey()->ExportPublicKey(
+            &public_key_bytes));
     policy_.Build();
 
+    // Convert from bytes to string format (which is what ValidateSignature()
+    // takes).
+    std::string public_key = std::string(
+        reinterpret_cast<const char*>(vector_as_array(&public_key_bytes)),
+        public_key_bytes.size());
+
     UserCloudPolicyValidator* validator = UserCloudPolicyValidator::Create(
         policy_.GetCopy(), base::MessageLoopProxy::current());
     validator->ValidateTimestamp(timestamp_, timestamp_,
                                  timestamp_option_);
     validator->ValidateUsername(PolicyBuilder::kFakeUsername);
     validator->ValidateDomain(PolicyBuilder::kFakeDomain);
     validator->ValidateDMToken(existing_dm_token_, ignore_missing_dm_token_);
     validator->ValidatePolicyType(dm_protocol::kChromeUserPolicyType);
     validator->ValidatePayload();
-    validator->ValidateSignature(public_key, allow_key_rotation_);
+    validator->ValidateSignature(public_key,
+                                 GetPolicyVerificationKey(),
+                                 PolicyBuilder::GetTestSigningKeySignature(),
+                                 allow_key_rotation_);
     if (allow_key_rotation_)
-      validator->ValidateInitialKey();
+      validator->ValidateInitialKey(GetPolicyVerificationKey());
     return make_scoped_ptr(validator);
   }
 
 
   void CheckSuccessfulValidation(UserCloudPolicyValidator* validator) {
     EXPECT_TRUE(validator->success());
     EXPECT_EQ(policy_.policy().SerializeAsString(),
               validator->policy()->SerializeAsString());
     EXPECT_EQ(policy_.policy_data().SerializeAsString(),
               validator->policy_data()->SerializeAsString());
@@ skipping 200 matching lines @@
 
 TEST_F(CloudPolicyValidatorTest, NoRotation) {
   allow_key_rotation_ = false;
   policy_.UnsetNewSigningKey();
   Validate(CheckStatus(CloudPolicyValidatorBase::VALIDATION_OK));
 }
 
 }  // namespace
 
 }  // namespace policy