AU: Verify that the applied delta update matches the server-sent hashes.

delta_performer.cc

 // Copyright (c) 2010 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/delta_performer.h"
 
 #include <endian.h>
 #include <errno.h>
 
 #include <algorithm>
@@ skipping 527 matching lines @@
   if (!utils::FileExists(key_path.c_str())) {
     LOG(WARNING) << "Not verifying signed delta payload -- missing public key.";
     return true;
   }
   TEST_AND_RETURN_FALSE(!signatures_message_data_.empty());
   vector<char> signed_hash_data;
   TEST_AND_RETURN_FALSE(PayloadSigner::VerifySignature(signatures_message_data_,
                                                        key_path,
                                                        &signed_hash_data));
   OmahaHashCalculator signed_hasher;
-  // TODO(petkov): Make sure signed_hash_context_ is loaded when resuming an
-  // update.
   TEST_AND_RETURN_FALSE(signed_hasher.SetContext(signed_hash_context_));
   TEST_AND_RETURN_FALSE(signed_hasher.Finalize());
   const vector<char>& hash_data = signed_hasher.raw_hash();
   TEST_AND_RETURN_FALSE(!hash_data.empty());
   TEST_AND_RETURN_FALSE(hash_data == signed_hash_data);
   return true;
 }
 
+bool DeltaPerformer::VerifyAppliedUpdate(const string& path,
+                                         const string& kernel_path) {
+  LOG(INFO) << "Verifying applied update.";
+  TEST_AND_RETURN_FALSE(manifest_valid_ &&
+                        manifest_.has_new_kernel_info() &&
+                        manifest_.has_new_rootfs_info());
+  const string* paths[] = { &kernel_path, &path };
+  const PartitionInfo* infos[] = {
+    &manifest_.new_kernel_info(), &manifest_.new_rootfs_info()
+  };
+  for (size_t i = 0; i < arraysize(paths); ++i) {
+    OmahaHashCalculator hasher;
+    TEST_AND_RETURN_FALSE(hasher.UpdateFile(*paths[i], infos[i]->size()));
+    TEST_AND_RETURN_FALSE(hasher.Finalize());
+    TEST_AND_RETURN_FALSE(hasher.raw_hash().size() == infos[i]->hash().size());
+    TEST_AND_RETURN_FALSE(memcmp(hasher.raw_hash().data(),
+                                 infos[i]->hash().data(),
+                                 hasher.raw_hash().size()) == 0);
+  }
+  return true;
+}
+
 void DeltaPerformer::DiscardBufferHeadBytes(size_t count) {
   hash_calculator_.Update(&buffer_[0], count);
   buffer_.erase(buffer_.begin(), buffer_.begin() + count);
 }
 
 bool DeltaPerformer::CanResumeUpdate(PrefsInterface* prefs,
                                      string update_check_response_hash) {
   int64_t next_operation = kUpdateStateOperationInvalid;
   TEST_AND_RETURN_FALSE(prefs->GetInt64(kPrefsUpdateStateNextOperation,
                                         &next_operation) &&
@@ skipping 102 matching lines @@
   if (prefs_->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures)) {
     resumed_update_failures++;
   } else {
     resumed_update_failures = 1;
   }
   prefs_->SetInt64(kPrefsResumedUpdateFailures, resumed_update_failures);
   return true;
 }
 
 }  // namespace chromeos_update_engine