AU: Check the delta magic and fail on mismatch.

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 128 matching lines @@
 
 bool DeltaPerformer::OpenKernel(const char* kernel_path) {
   int err;
   bool success = OpenFile(kernel_path, &kernel_fd_, &err);
   if (success)
     kernel_path_ = kernel_path;
   return success;
 }
 
 int DeltaPerformer::Close() {
-  if (!buffer_.empty()) {
-    LOG(ERROR) << "Called Close() while buffer not empty!";
-    return -1;
-  }
   int err = 0;
   if (close(kernel_fd_) == -1) {
     err = errno;
     PLOG(ERROR) << "Unable to close kernel fd:";
   }
   if (close(fd_) == -1) {
     err = errno;
     PLOG(ERROR) << "Unable to close rootfs fd:";
   }
   LOG_IF(ERROR, !hash_calculator_.Finalize()) << "Unable to finalize the hash.";
-  fd_ = -2;  // Set so that isn't not valid AND calls to Open() will fail.
+  fd_ = -2;  // Set to invalid so that calls to Open() will fail.
   path_ = "";
+  if (!buffer_.empty()) {
+    LOG(ERROR) << "Called Close() while buffer not empty!";
+    if (err >= 0) {
+      err = 1;
+    }
+  }
   return -err;
 }
 
 namespace {
 
 void LogPartitionInfoHash(const PartitionInfo& info, const string& tag) {
   string sha256;
   if (OmahaHashCalculator::Base64Encode(info.hash().data(),
                                         info.hash().size(),
                                         &sha256)) {
@@ skipping 19 matching lines @@
 
 // Wrapper around write. Returns bytes written on success or
 // -errno on error.
 // This function performs as many actions as it can, given the amount of
 // data received thus far.
 ssize_t DeltaPerformer::Write(const void* bytes, size_t count) {
   const char* c_bytes = reinterpret_cast<const char*>(bytes);
   buffer_.insert(buffer_.end(), c_bytes, c_bytes + count);
 
   if (!manifest_valid_) {
-    // See if we have enough bytes for the manifest yet
     if (buffer_.size() < strlen(kDeltaMagic) +
         kDeltaVersionLength + kDeltaProtobufLengthLength) {
-      // Don't have enough bytes to even know the protobuf length
+      // Don't have enough bytes to know the protobuf length.
       return count;
     }
+    if (memcmp(buffer_.data(), kDeltaMagic, strlen(kDeltaMagic)) != 0) {
+      LOG(ERROR) << "Bad payload format -- invalid delta magic.";
+      return -EINVAL;
+    }
     uint64_t protobuf_length;
     COMPILE_ASSERT(sizeof(protobuf_length) == kDeltaProtobufLengthLength,
                    protobuf_length_size_mismatch);
     memcpy(&protobuf_length,
            &buffer_[strlen(kDeltaMagic) + kDeltaVersionLength],
            kDeltaProtobufLengthLength);
     protobuf_length = be64toh(protobuf_length);  // switch big endian to host
     if (buffer_.size() < strlen(kDeltaMagic) + kDeltaVersionLength +
         kDeltaProtobufLengthLength + protobuf_length) {
       return count;
@@ skipping 524 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