AU: Support signed payload verification through the delta generator.

omaha_hash_calculator.cc

 // Copyright (c) 2009 The Chromium OS 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 "update_engine/omaha_hash_calculator.h"
 
 #include <fcntl.h>
 
 #include <base/eintr_wrapper.h>
 #include <base/logging.h>
@@ skipping 87 matching lines @@
   TEST_AND_RETURN_FALSE(raw_hash_.empty());
   raw_hash_.resize(SHA256_DIGEST_LENGTH);
   TEST_AND_RETURN_FALSE(
       SHA256_Final(reinterpret_cast<unsigned char*>(&raw_hash_[0]),
                    &ctx_) == 1);
 
   // Convert raw_hash_ to base64 encoding and store it in hash_.
   return Base64Encode(&raw_hash_[0], raw_hash_.size(), &hash_);;
 }
 
+bool OmahaHashCalculator::RawHashOfBytes(const char* data,
+                                         size_t length,
+                                         vector<char>* out_hash) {
+  OmahaHashCalculator calc;
+  TEST_AND_RETURN_FALSE(calc.Update(data, length));
+  TEST_AND_RETURN_FALSE(calc.Finalize());
+  *out_hash = calc.raw_hash();
+  return true;
+}
+
 bool OmahaHashCalculator::RawHashOfData(const vector<char>& data,
                                         vector<char>* out_hash) {
-  OmahaHashCalculator calc;
-  calc.Update(&data[0], data.size());
-
-  out_hash->resize(out_hash->size() + SHA256_DIGEST_LENGTH);
-  TEST_AND_RETURN_FALSE(
-      SHA256_Final(reinterpret_cast<unsigned char*>(&(*(out_hash->end() -
-                                                        SHA256_DIGEST_LENGTH))),
-                   &calc.ctx_) == 1);
-  return true;
+  return RawHashOfBytes(data.data(), data.size(), out_hash);
 }
 
-off_t OmahaHashCalculator::RawHashOfFile(const std::string& name, off_t length,
-                                         std::vector<char>* out_hash) {
+off_t OmahaHashCalculator::RawHashOfFile(const string& name, off_t length,
+                                         vector<char>* out_hash) {
   OmahaHashCalculator calc;
   off_t res = calc.UpdateFile(name, length);
   if (res < 0) {
     return res;
   }
   if (!calc.Finalize()) {
     return -1;
   }
   *out_hash = calc.raw_hash();
   return res;
@@ skipping 19 matching lines @@
   return string(reinterpret_cast<const char*>(&ctx_), sizeof(ctx_));
 }
 
 bool OmahaHashCalculator::SetContext(const std::string& context) {
   TEST_AND_RETURN_FALSE(context.size() == sizeof(ctx_));
   memcpy(&ctx_, context.data(), sizeof(ctx_));
   return true;
 }
 
 }  // namespace chromeos_update_engine