AU: Verify source rootfs/kernel hashes before applying delta.

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 95 matching lines @@
   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;
 }
 
+off_t OmahaHashCalculator::RawHashOfFile(const std::string& name, off_t length,
+                                         std::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;
+}
+
 string OmahaHashCalculator::OmahaHashOfBytes(
     const void* data, size_t length) {
   OmahaHashCalculator calc;
   calc.Update(reinterpret_cast<const char*>(data), length);
   calc.Finalize();
   return calc.hash();
 }
 
 string OmahaHashCalculator::OmahaHashOfString(const string& str) {
   return OmahaHashOfBytes(str.data(), str.size());
 }
 
 string OmahaHashCalculator::OmahaHashOfData(const vector<char>& data) {
   return OmahaHashOfBytes(&data[0], data.size());
 }
 
 string OmahaHashCalculator::GetContext() const {
   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