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

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 560 matching lines @@
     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;
 }
 
+bool DeltaPerformer::VerifySourcePartitions() {
+  LOG(INFO) << "Verifying source partitions.";
+  CHECK(manifest_valid_);
+  if (manifest_.has_old_kernel_info()) {
+    const PartitionInfo& info = manifest_.old_kernel_info();
+    TEST_AND_RETURN_FALSE(current_kernel_hash_ != NULL &&
+                          current_kernel_hash_->size() == info.hash().size() &&
+                          memcmp(current_kernel_hash_->data(),
+                                 info.hash().data(),
+                                 current_kernel_hash_->size()) == 0);
+  }
+  if (manifest_.has_old_rootfs_info()) {
+    const PartitionInfo& info = manifest_.old_rootfs_info();
+    TEST_AND_RETURN_FALSE(current_rootfs_hash_ != NULL &&
+                          current_rootfs_hash_->size() == info.hash().size() &&
+                          memcmp(current_rootfs_hash_->data(),
+                                 info.hash().data(),
+                                 current_rootfs_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 63 matching lines @@
 
 bool DeltaPerformer::PrimeUpdateState() {
   CHECK(manifest_valid_);
   block_size_ = manifest_.block_size();
 
   int64_t next_operation = kUpdateStateOperationInvalid;
   if (!prefs_->GetInt64(kPrefsUpdateStateNextOperation, &next_operation) ||
       next_operation == kUpdateStateOperationInvalid ||
       next_operation <= 0) {
     // Initiating a new update, no more state needs to be initialized.
+    TEST_AND_RETURN_FALSE(VerifySourcePartitions());
     return true;
   }
   next_operation_num_ = next_operation;
 
   // Resuming an update -- load the rest of the update state.
   int64_t next_data_offset = -1;
   TEST_AND_RETURN_FALSE(prefs_->GetInt64(kPrefsUpdateStateNextDataOffset,
                                          &next_data_offset) &&
                         next_data_offset >= 0);
   buffer_offset_ = next_data_offset;
@@ skipping 19 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