blob: d5b0d585fa72ccde4307ebdf3605c15f5d9bac7f [file] [log] [blame]
Alex Deymoaea4c1c2015-08-19 20:24:43 -07001//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070016
Alex Deymo39910dc2015-11-09 17:04:30 -080017#include "update_engine/payload_consumer/delta_performer.h"
Darin Petkovd7061ab2010-10-06 14:37:09 -070018
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070019#include <endian.h>
20#include <errno.h>
Alex Deymo79715ad2015-10-02 14:27:53 -070021#include <linux/fs.h>
Darin Petkovd7061ab2010-10-06 14:37:09 -070022
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070023#include <algorithm>
24#include <cstring>
Ben Chan02f7c1d2014-10-18 15:18:02 -070025#include <memory>
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070026#include <string>
Amin Hassanid87304c2017-08-29 11:40:03 -070027#include <utility>
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070028#include <vector>
29
Ben Chan06c76a42014-09-05 08:21:06 -070030#include <base/files/file_util.h>
Alex Deymo161c4a12014-05-16 15:56:21 -070031#include <base/format_macros.h>
Lann Martin39f57142017-07-14 09:18:42 -060032#include <base/metrics/histogram_macros.h>
Alex Deymo67140842016-06-15 13:28:59 -070033#include <base/strings/string_number_conversions.h>
Alex Vakulenko75039d72014-03-25 12:36:28 -070034#include <base/strings/string_util.h>
35#include <base/strings/stringprintf.h>
Lann Martin39f57142017-07-14 09:18:42 -060036#include <base/time/time.h>
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -070037#include <brillo/data_encoding.h>
Alex Deymo6765a682017-05-19 13:13:54 -070038#include <bsdiff/bspatch.h>
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070039#include <google/protobuf/repeated_field.h>
Amin Hassani02855c22017-09-06 22:34:50 -070040#include <puffin/puffpatch.h>
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070041
Alex Deymo39910dc2015-11-09 17:04:30 -080042#include "update_engine/common/constants.h"
43#include "update_engine/common/hardware_interface.h"
Alex Deymo542c19b2015-12-03 07:43:31 -030044#include "update_engine/common/prefs_interface.h"
45#include "update_engine/common/subprocess.h"
46#include "update_engine/common/terminator.h"
Alex Deymo39910dc2015-11-09 17:04:30 -080047#include "update_engine/payload_consumer/bzip_extent_writer.h"
Amin Hassania3fc20a2017-09-19 17:19:34 -070048#include "update_engine/payload_consumer/cached_file_descriptor.h"
Alex Deymo542c19b2015-12-03 07:43:31 -030049#include "update_engine/payload_consumer/download_action.h"
Amin Hassanidb56be92017-09-06 12:41:23 -070050#include "update_engine/payload_consumer/extent_reader.h"
Alex Deymo39910dc2015-11-09 17:04:30 -080051#include "update_engine/payload_consumer/extent_writer.h"
Alex Deymoa48f6302016-11-04 15:49:53 -070052#include "update_engine/payload_consumer/file_descriptor_utils.h"
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -080053#if USE_MTD
Alex Deymo39910dc2015-11-09 17:04:30 -080054#include "update_engine/payload_consumer/mtd_file_descriptor.h"
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -080055#endif
Alex Deymo39910dc2015-11-09 17:04:30 -080056#include "update_engine/payload_consumer/payload_constants.h"
57#include "update_engine/payload_consumer/payload_verifier.h"
58#include "update_engine/payload_consumer/xz_extent_writer.h"
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070059
Alex Deymo161c4a12014-05-16 15:56:21 -070060using google::protobuf::RepeatedPtrField;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070061using std::min;
62using std::string;
63using std::vector;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070064
65namespace chromeos_update_engine {
66
Sen Jiangb8060e42015-09-24 17:30:50 -070067const uint64_t DeltaPerformer::kDeltaVersionOffset = sizeof(kDeltaMagic);
Jay Srinivasanf4318702012-09-24 11:56:24 -070068const uint64_t DeltaPerformer::kDeltaVersionSize = 8;
Sen Jiangb8060e42015-09-24 17:30:50 -070069const uint64_t DeltaPerformer::kDeltaManifestSizeOffset =
70 kDeltaVersionOffset + kDeltaVersionSize;
Jay Srinivasanf4318702012-09-24 11:56:24 -070071const uint64_t DeltaPerformer::kDeltaManifestSizeSize = 8;
Sen Jiangb8060e42015-09-24 17:30:50 -070072const uint64_t DeltaPerformer::kDeltaMetadataSignatureSizeSize = 4;
73const uint64_t DeltaPerformer::kMaxPayloadHeaderSize = 24;
Alex Deymo7a2c47e2015-11-04 00:47:12 -080074const uint64_t DeltaPerformer::kSupportedMajorPayloadVersion = 2;
Amin Hassani7bc9c022017-11-07 14:01:39 -080075const uint32_t DeltaPerformer::kSupportedMinorPayloadVersion = 4;
Don Garrett4d039442013-10-28 18:40:06 -070076
Gilad Arnold8a86fa52013-01-15 12:35:05 -080077const unsigned DeltaPerformer::kProgressLogMaxChunks = 10;
78const unsigned DeltaPerformer::kProgressLogTimeoutSeconds = 30;
79const unsigned DeltaPerformer::kProgressDownloadWeight = 50;
80const unsigned DeltaPerformer::kProgressOperationsWeight = 50;
Darin Petkovabc7bc02011-02-23 14:39:43 -080081
Andrew de los Reyes09e56d62010-04-23 13:45:53 -070082namespace {
Darin Petkov73058b42010-10-06 16:32:19 -070083const int kUpdateStateOperationInvalid = -1;
Darin Petkov61426142010-10-08 11:04:55 -070084const int kMaxResumedUpdateFailures = 10;
Nam T. Nguyena78b28c2015-03-06 22:30:12 -080085#if USE_MTD
86const int kUbiVolumeAttachTimeout = 5 * 60;
87#endif
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -080088
Amin Hassania3fc20a2017-09-19 17:19:34 -070089const uint64_t kCacheSize = 1024 * 1024; // 1MB
90
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -080091FileDescriptorPtr CreateFileDescriptor(const char* path) {
92 FileDescriptorPtr ret;
93#if USE_MTD
Nam T. Nguyena78b28c2015-03-06 22:30:12 -080094 if (strstr(path, "/dev/ubi") == path) {
95 if (!UbiFileDescriptor::IsUbi(path)) {
96 // The volume might not have been attached at boot time.
97 int volume_no;
98 if (utils::SplitPartitionName(path, nullptr, &volume_no)) {
99 utils::TryAttachingUbiVolume(volume_no, kUbiVolumeAttachTimeout);
100 }
101 }
102 if (UbiFileDescriptor::IsUbi(path)) {
103 LOG(INFO) << path << " is a UBI device.";
104 ret.reset(new UbiFileDescriptor);
105 }
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800106 } else if (MtdFileDescriptor::IsMtd(path)) {
Nam T. Nguyena78b28c2015-03-06 22:30:12 -0800107 LOG(INFO) << path << " is an MTD device.";
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800108 ret.reset(new MtdFileDescriptor);
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800109 } else {
Nam T. Nguyena78b28c2015-03-06 22:30:12 -0800110 LOG(INFO) << path << " is not an MTD nor a UBI device.";
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800111#endif
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800112 ret.reset(new EintrSafeFileDescriptor);
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800113#if USE_MTD
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700114 }
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800115#endif
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800116 return ret;
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700117}
118
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800119// Opens path for read/write. On success returns an open FileDescriptor
120// and sets *err to 0. On failure, sets *err to errno and returns nullptr.
Amin Hassania3fc20a2017-09-19 17:19:34 -0700121FileDescriptorPtr OpenFile(const char* path,
122 int mode,
123 bool cache_writes,
124 int* err) {
Alex Deymo5fb356c2016-03-25 18:48:22 -0700125 // Try to mark the block device read-only based on the mode. Ignore any
126 // failure since this won't work when passing regular files.
Amin Hassania3fc20a2017-09-19 17:19:34 -0700127 bool read_only = (mode & O_ACCMODE) == O_RDONLY;
128 utils::SetBlockDeviceReadOnly(path, read_only);
Alex Deymo5fb356c2016-03-25 18:48:22 -0700129
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800130 FileDescriptorPtr fd = CreateFileDescriptor(path);
Amin Hassania3fc20a2017-09-19 17:19:34 -0700131 if (cache_writes && !read_only) {
132 fd = FileDescriptorPtr(new CachedFileDescriptor(fd, kCacheSize));
133 LOG(INFO) << "Caching writes.";
134 }
Nam T. Nguyena78b28c2015-03-06 22:30:12 -0800135#if USE_MTD
136 // On NAND devices, we can either read, or write, but not both. So here we
137 // use O_WRONLY.
138 if (UbiFileDescriptor::IsUbi(path) || MtdFileDescriptor::IsMtd(path)) {
139 mode = O_WRONLY;
140 }
141#endif
142 if (!fd->Open(path, mode, 000)) {
Nam T. Nguyenf1d582e2014-12-08 15:07:17 -0800143 *err = errno;
144 PLOG(ERROR) << "Unable to open file " << path;
145 return nullptr;
146 }
147 *err = 0;
148 return fd;
149}
Alex Deymob86787c2016-05-12 18:46:25 -0700150
151// Discard the tail of the block device referenced by |fd|, from the offset
152// |data_size| until the end of the block device. Returns whether the data was
153// discarded.
Chih-Hung Hsieh5c6bb1d2016-07-27 13:33:15 -0700154bool DiscardPartitionTail(const FileDescriptorPtr& fd, uint64_t data_size) {
Alex Deymob86787c2016-05-12 18:46:25 -0700155 uint64_t part_size = fd->BlockDevSize();
156 if (!part_size || part_size <= data_size)
157 return false;
158
Alex Deymo72a68d82016-06-15 16:31:04 -0700159 struct blkioctl_request {
160 int number;
161 const char* name;
162 };
163 const vector<blkioctl_request> blkioctl_requests = {
Alex Deymo72a68d82016-06-15 16:31:04 -0700164 {BLKDISCARD, "BLKDISCARD"},
Amin Hassani41555202017-06-23 12:42:00 -0700165 {BLKSECDISCARD, "BLKSECDISCARD"},
Alex Deymob86787c2016-05-12 18:46:25 -0700166#ifdef BLKZEROOUT
Alex Deymo72a68d82016-06-15 16:31:04 -0700167 {BLKZEROOUT, "BLKZEROOUT"},
Alex Deymob86787c2016-05-12 18:46:25 -0700168#endif
169 };
Alex Deymo72a68d82016-06-15 16:31:04 -0700170 for (const auto& req : blkioctl_requests) {
Alex Deymob86787c2016-05-12 18:46:25 -0700171 int error = 0;
Alex Deymo72a68d82016-06-15 16:31:04 -0700172 if (fd->BlkIoctl(req.number, data_size, part_size - data_size, &error) &&
Alex Deymob86787c2016-05-12 18:46:25 -0700173 error == 0) {
174 return true;
175 }
176 LOG(WARNING) << "Error discarding the last "
177 << (part_size - data_size) / 1024 << " KiB using ioctl("
Alex Deymo72a68d82016-06-15 16:31:04 -0700178 << req.name << ")";
Alex Deymob86787c2016-05-12 18:46:25 -0700179 }
180 return false;
181}
182
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700183} // namespace
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700184
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800185
186// Computes the ratio of |part| and |total|, scaled to |norm|, using integer
187// arithmetic.
188static uint64_t IntRatio(uint64_t part, uint64_t total, uint64_t norm) {
189 return part * norm / total;
190}
191
192void DeltaPerformer::LogProgress(const char* message_prefix) {
193 // Format operations total count and percentage.
194 string total_operations_str("?");
195 string completed_percentage_str("");
196 if (num_total_operations_) {
Alex Deymoc00c98a2015-03-17 17:38:00 -0700197 total_operations_str = std::to_string(num_total_operations_);
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800198 // Upcasting to 64-bit to avoid overflow, back to size_t for formatting.
199 completed_percentage_str =
Alex Vakulenko75039d72014-03-25 12:36:28 -0700200 base::StringPrintf(" (%" PRIu64 "%%)",
Alex Deymoc00c98a2015-03-17 17:38:00 -0700201 IntRatio(next_operation_num_, num_total_operations_,
202 100));
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800203 }
204
205 // Format download total count and percentage.
Sen Jiang0affc2c2017-02-10 15:55:05 -0800206 size_t payload_size = payload_->size;
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800207 string payload_size_str("?");
208 string downloaded_percentage_str("");
209 if (payload_size) {
Alex Deymoc00c98a2015-03-17 17:38:00 -0700210 payload_size_str = std::to_string(payload_size);
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800211 // Upcasting to 64-bit to avoid overflow, back to size_t for formatting.
212 downloaded_percentage_str =
Alex Vakulenko75039d72014-03-25 12:36:28 -0700213 base::StringPrintf(" (%" PRIu64 "%%)",
Alex Deymoc00c98a2015-03-17 17:38:00 -0700214 IntRatio(total_bytes_received_, payload_size, 100));
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800215 }
216
217 LOG(INFO) << (message_prefix ? message_prefix : "") << next_operation_num_
218 << "/" << total_operations_str << " operations"
219 << completed_percentage_str << ", " << total_bytes_received_
220 << "/" << payload_size_str << " bytes downloaded"
221 << downloaded_percentage_str << ", overall progress "
222 << overall_progress_ << "%";
223}
224
225void DeltaPerformer::UpdateOverallProgress(bool force_log,
226 const char* message_prefix) {
227 // Compute our download and overall progress.
228 unsigned new_overall_progress = 0;
Alex Vakulenko0103c362016-01-20 07:56:15 -0800229 static_assert(kProgressDownloadWeight + kProgressOperationsWeight == 100,
230 "Progress weights don't add up");
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800231 // Only consider download progress if its total size is known; otherwise
232 // adjust the operations weight to compensate for the absence of download
233 // progress. Also, make sure to cap the download portion at
234 // kProgressDownloadWeight, in case we end up downloading more than we
235 // initially expected (this indicates a problem, but could generally happen).
236 // TODO(garnold) the correction of operations weight when we do not have the
237 // total payload size, as well as the conditional guard below, should both be
238 // eliminated once we ensure that the payload_size in the install plan is
239 // always given and is non-zero. This currently isn't the case during unit
240 // tests (see chromium-os:37969).
Sen Jiang0affc2c2017-02-10 15:55:05 -0800241 size_t payload_size = payload_->size;
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800242 unsigned actual_operations_weight = kProgressOperationsWeight;
243 if (payload_size)
244 new_overall_progress += min(
245 static_cast<unsigned>(IntRatio(total_bytes_received_, payload_size,
246 kProgressDownloadWeight)),
247 kProgressDownloadWeight);
248 else
249 actual_operations_weight += kProgressDownloadWeight;
250
251 // Only add completed operations if their total number is known; we definitely
252 // expect an update to have at least one operation, so the expectation is that
253 // this will eventually reach |actual_operations_weight|.
254 if (num_total_operations_)
255 new_overall_progress += IntRatio(next_operation_num_, num_total_operations_,
256 actual_operations_weight);
257
258 // Progress ratio cannot recede, unless our assumptions about the total
259 // payload size, total number of operations, or the monotonicity of progress
260 // is breached.
261 if (new_overall_progress < overall_progress_) {
262 LOG(WARNING) << "progress counter receded from " << overall_progress_
263 << "% down to " << new_overall_progress << "%; this is a bug";
264 force_log = true;
265 }
266 overall_progress_ = new_overall_progress;
267
268 // Update chunk index, log as needed: if forced by called, or we completed a
269 // progress chunk, or a timeout has expired.
270 base::Time curr_time = base::Time::Now();
271 unsigned curr_progress_chunk =
272 overall_progress_ * kProgressLogMaxChunks / 100;
273 if (force_log || curr_progress_chunk > last_progress_chunk_ ||
274 curr_time > forced_progress_log_time_) {
275 forced_progress_log_time_ = curr_time + forced_progress_log_wait_;
276 LogProgress(message_prefix);
277 }
278 last_progress_chunk_ = curr_progress_chunk;
279}
280
281
Gilad Arnoldfe133932014-01-14 12:25:50 -0800282size_t DeltaPerformer::CopyDataToBuffer(const char** bytes_p, size_t* count_p,
283 size_t max) {
284 const size_t count = *count_p;
285 if (!count)
286 return 0; // Special case shortcut.
Alex Deymof329b932014-10-30 01:37:48 -0700287 size_t read_len = min(count, max - buffer_.size());
Gilad Arnoldfe133932014-01-14 12:25:50 -0800288 const char* bytes_start = *bytes_p;
289 const char* bytes_end = bytes_start + read_len;
Sen Jiangbe19a242017-11-17 11:48:17 -0800290 buffer_.reserve(max);
Gilad Arnoldfe133932014-01-14 12:25:50 -0800291 buffer_.insert(buffer_.end(), bytes_start, bytes_end);
292 *bytes_p = bytes_end;
293 *count_p = count - read_len;
294 return read_len;
295}
296
297
298bool DeltaPerformer::HandleOpResult(bool op_result, const char* op_type_name,
299 ErrorCode* error) {
300 if (op_result)
301 return true;
302
Alex Deymo3d009062016-05-13 15:51:25 -0700303 size_t partition_first_op_num =
304 current_partition_ ? acc_num_operations_[current_partition_ - 1] : 0;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800305 LOG(ERROR) << "Failed to perform " << op_type_name << " operation "
Alex Deymo3d009062016-05-13 15:51:25 -0700306 << next_operation_num_ << ", which is the operation "
307 << next_operation_num_ - partition_first_op_num
308 << " in partition \""
309 << partitions_[current_partition_].partition_name() << "\"";
Sen Jiangbe2c47b2016-06-15 14:09:27 -0700310 if (*error == ErrorCode::kSuccess)
311 *error = ErrorCode::kDownloadOperationExecutionError;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800312 return false;
313}
314
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700315int DeltaPerformer::Close() {
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700316 int err = -CloseCurrentPartition();
Sen Jiangf6813802015-11-03 21:27:29 -0800317 LOG_IF(ERROR, !payload_hash_calculator_.Finalize() ||
318 !signed_hash_calculator_.Finalize())
319 << "Unable to finalize the hash.";
Darin Petkov934bb412010-11-18 11:21:35 -0800320 if (!buffer_.empty()) {
Jay Srinivasan1c0fe792013-03-28 16:45:25 -0700321 LOG(INFO) << "Discarding " << buffer_.size() << " unused downloaded bytes";
322 if (err >= 0)
Darin Petkov934bb412010-11-18 11:21:35 -0800323 err = 1;
Darin Petkov934bb412010-11-18 11:21:35 -0800324 }
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700325 return -err;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700326}
327
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700328int DeltaPerformer::CloseCurrentPartition() {
329 int err = 0;
330 if (source_fd_ && !source_fd_->Close()) {
331 err = errno;
332 PLOG(ERROR) << "Error closing source partition";
333 if (!err)
334 err = 1;
335 }
336 source_fd_.reset();
337 source_path_.clear();
338
339 if (target_fd_ && !target_fd_->Close()) {
340 err = errno;
341 PLOG(ERROR) << "Error closing target partition";
342 if (!err)
343 err = 1;
344 }
345 target_fd_.reset();
346 target_path_.clear();
347 return -err;
348}
349
350bool DeltaPerformer::OpenCurrentPartition() {
351 if (current_partition_ >= partitions_.size())
352 return false;
353
354 const PartitionUpdate& partition = partitions_[current_partition_];
Sen Jiangd2ff2a02017-04-06 14:53:31 -0700355 size_t num_previous_partitions =
356 install_plan_->partitions.size() - partitions_.size();
357 const InstallPlan::Partition& install_part =
358 install_plan_->partitions[num_previous_partitions + current_partition_];
Sen Jiang889c65d2015-11-17 15:04:02 -0800359 // Open source fds if we have a delta payload with minor version >= 2.
Sen Jiangcdd52062017-05-18 15:33:10 -0700360 if (payload_->type == InstallPayloadType::kDelta &&
Sen Jiang889c65d2015-11-17 15:04:02 -0800361 GetMinorVersion() != kInPlaceMinorPayloadVersion) {
Sen Jiangd2ff2a02017-04-06 14:53:31 -0700362 source_path_ = install_part.source_path;
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700363 int err;
Amin Hassania3fc20a2017-09-19 17:19:34 -0700364 source_fd_ = OpenFile(source_path_.c_str(), O_RDONLY, false, &err);
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700365 if (!source_fd_) {
366 LOG(ERROR) << "Unable to open source partition "
367 << partition.partition_name() << " on slot "
368 << BootControlInterface::SlotName(install_plan_->source_slot)
369 << ", file " << source_path_;
370 return false;
371 }
372 }
373
Sen Jiangd2ff2a02017-04-06 14:53:31 -0700374 target_path_ = install_part.target_path;
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700375 int err;
Grant Grundlera763c2d2017-05-10 11:12:52 -0700376
Amin Hassani7ecda262017-07-11 17:10:50 -0700377 int flags = O_RDWR;
378 if (!is_interactive_)
379 flags |= O_DSYNC;
380
381 LOG(INFO) << "Opening " << target_path_ << " partition with"
382 << (is_interactive_ ? "out" : "") << " O_DSYNC";
383
Amin Hassania3fc20a2017-09-19 17:19:34 -0700384 target_fd_ = OpenFile(target_path_.c_str(), flags, true, &err);
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700385 if (!target_fd_) {
386 LOG(ERROR) << "Unable to open target partition "
387 << partition.partition_name() << " on slot "
388 << BootControlInterface::SlotName(install_plan_->target_slot)
389 << ", file " << target_path_;
390 return false;
391 }
Alex Deymob86787c2016-05-12 18:46:25 -0700392
393 LOG(INFO) << "Applying " << partition.operations().size()
394 << " operations to partition \"" << partition.partition_name()
395 << "\"";
396
397 // Discard the end of the partition, but ignore failures.
Sen Jiangd2ff2a02017-04-06 14:53:31 -0700398 DiscardPartitionTail(target_fd_, install_part.target_size);
Alex Deymob86787c2016-05-12 18:46:25 -0700399
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700400 return true;
401}
402
Andrew de los Reyes89f17be2010-10-22 13:39:09 -0700403namespace {
404
405void LogPartitionInfoHash(const PartitionInfo& info, const string& tag) {
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700406 string sha256 = brillo::data_encoding::Base64Encode(info.hash());
Alex Vakulenko981a9fb2015-02-09 12:51:24 -0800407 LOG(INFO) << "PartitionInfo " << tag << " sha256: " << sha256
408 << " size: " << info.size();
Andrew de los Reyes89f17be2010-10-22 13:39:09 -0700409}
410
Alex Deymo39910dc2015-11-09 17:04:30 -0800411void LogPartitionInfo(const vector<PartitionUpdate>& partitions) {
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700412 for (const PartitionUpdate& partition : partitions) {
413 LogPartitionInfoHash(partition.old_partition_info(),
414 "old " + partition.partition_name());
415 LogPartitionInfoHash(partition.new_partition_info(),
416 "new " + partition.partition_name());
417 }
Andrew de los Reyes89f17be2010-10-22 13:39:09 -0700418}
419
Alex Vakulenkod2779df2014-06-16 13:19:00 -0700420} // namespace
Andrew de los Reyes89f17be2010-10-22 13:39:09 -0700421
Sen Jiangb8060e42015-09-24 17:30:50 -0700422bool DeltaPerformer::GetMetadataSignatureSizeOffset(
423 uint64_t* out_offset) const {
424 if (GetMajorVersion() == kBrilloMajorPayloadVersion) {
425 *out_offset = kDeltaManifestSizeOffset + kDeltaManifestSizeSize;
426 return true;
427 }
428 return false;
Don Garrett4d039442013-10-28 18:40:06 -0700429}
430
Sen Jiangb8060e42015-09-24 17:30:50 -0700431bool DeltaPerformer::GetManifestOffset(uint64_t* out_offset) const {
432 // Actual manifest begins right after the manifest size field or
433 // metadata signature size field if major version >= 2.
434 if (major_payload_version_ == kChromeOSMajorPayloadVersion) {
435 *out_offset = kDeltaManifestSizeOffset + kDeltaManifestSizeSize;
436 return true;
437 }
438 if (major_payload_version_ == kBrilloMajorPayloadVersion) {
439 *out_offset = kDeltaManifestSizeOffset + kDeltaManifestSizeSize +
440 kDeltaMetadataSignatureSizeSize;
441 return true;
442 }
443 LOG(ERROR) << "Unknown major payload version: " << major_payload_version_;
444 return false;
Jay Srinivasanf4318702012-09-24 11:56:24 -0700445}
446
Gilad Arnoldfe133932014-01-14 12:25:50 -0800447uint64_t DeltaPerformer::GetMetadataSize() const {
Gilad Arnolddaa27402014-01-23 11:56:17 -0800448 return metadata_size_;
449}
450
Sen Jiangb8060e42015-09-24 17:30:50 -0700451uint64_t DeltaPerformer::GetMajorVersion() const {
452 return major_payload_version_;
453}
454
Allie Woodfdf00512015-03-02 13:34:55 -0800455uint32_t DeltaPerformer::GetMinorVersion() const {
456 if (manifest_.has_minor_version()) {
457 return manifest_.minor_version();
458 } else {
Sen Jiangcdd52062017-05-18 15:33:10 -0700459 return payload_->type == InstallPayloadType::kDelta
Alex Deymo64d98782016-02-05 18:03:48 -0800460 ? kSupportedMinorPayloadVersion
461 : kFullPayloadMinorVersion;
Allie Woodfdf00512015-03-02 13:34:55 -0800462 }
463}
464
Gilad Arnolddaa27402014-01-23 11:56:17 -0800465bool DeltaPerformer::GetManifest(DeltaArchiveManifest* out_manifest_p) const {
466 if (!manifest_parsed_)
467 return false;
468 *out_manifest_p = manifest_;
469 return true;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800470}
471
Sen Jiangb8060e42015-09-24 17:30:50 -0700472bool DeltaPerformer::IsHeaderParsed() const {
473 return metadata_size_ != 0;
474}
Jay Srinivasanf4318702012-09-24 11:56:24 -0700475
Darin Petkov9574f7e2011-01-13 10:48:12 -0800476DeltaPerformer::MetadataParseResult DeltaPerformer::ParsePayloadMetadata(
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -0700477 const brillo::Blob& payload, ErrorCode* error) {
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700478 *error = ErrorCode::kSuccess;
Sen Jiangb8060e42015-09-24 17:30:50 -0700479 uint64_t manifest_offset;
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700480
Sen Jiangb8060e42015-09-24 17:30:50 -0700481 if (!IsHeaderParsed()) {
482 // Ensure we have data to cover the major payload version.
483 if (payload.size() < kDeltaManifestSizeOffset)
Gilad Arnoldfe133932014-01-14 12:25:50 -0800484 return kMetadataParseInsufficientData;
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700485
Gilad Arnoldfe133932014-01-14 12:25:50 -0800486 // Validate the magic string.
Sen Jiangb8060e42015-09-24 17:30:50 -0700487 if (memcmp(payload.data(), kDeltaMagic, sizeof(kDeltaMagic)) != 0) {
Gilad Arnoldfe133932014-01-14 12:25:50 -0800488 LOG(ERROR) << "Bad payload format -- invalid delta magic.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700489 *error = ErrorCode::kDownloadInvalidMetadataMagicString;
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800490 return kMetadataParseError;
491 }
Gilad Arnoldfe133932014-01-14 12:25:50 -0800492
493 // Extract the payload version from the metadata.
Alex Vakulenko0103c362016-01-20 07:56:15 -0800494 static_assert(sizeof(major_payload_version_) == kDeltaVersionSize,
495 "Major payload version size mismatch");
Sen Jiangb8060e42015-09-24 17:30:50 -0700496 memcpy(&major_payload_version_,
497 &payload[kDeltaVersionOffset],
Gilad Arnoldfe133932014-01-14 12:25:50 -0800498 kDeltaVersionSize);
499 // switch big endian to host
Sen Jiangb8060e42015-09-24 17:30:50 -0700500 major_payload_version_ = be64toh(major_payload_version_);
Gilad Arnoldfe133932014-01-14 12:25:50 -0800501
Alex Deymo7a2c47e2015-11-04 00:47:12 -0800502 if (major_payload_version_ != supported_major_version_ &&
503 major_payload_version_ != kChromeOSMajorPayloadVersion) {
Gilad Arnoldfe133932014-01-14 12:25:50 -0800504 LOG(ERROR) << "Bad payload format -- unsupported payload version: "
Sen Jiangb8060e42015-09-24 17:30:50 -0700505 << major_payload_version_;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700506 *error = ErrorCode::kUnsupportedMajorPayloadVersion;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800507 return kMetadataParseError;
508 }
509
Sen Jiangb8060e42015-09-24 17:30:50 -0700510 // Get the manifest offset now that we have payload version.
511 if (!GetManifestOffset(&manifest_offset)) {
512 *error = ErrorCode::kUnsupportedMajorPayloadVersion;
513 return kMetadataParseError;
514 }
515 // Check again with the manifest offset.
516 if (payload.size() < manifest_offset)
517 return kMetadataParseInsufficientData;
518
Gilad Arnoldfe133932014-01-14 12:25:50 -0800519 // Next, parse the manifest size.
Alex Vakulenko0103c362016-01-20 07:56:15 -0800520 static_assert(sizeof(manifest_size_) == kDeltaManifestSizeSize,
521 "manifest_size size mismatch");
Sen Jiangb8060e42015-09-24 17:30:50 -0700522 memcpy(&manifest_size_,
523 &payload[kDeltaManifestSizeOffset],
Gilad Arnoldfe133932014-01-14 12:25:50 -0800524 kDeltaManifestSizeSize);
Sen Jiangb8060e42015-09-24 17:30:50 -0700525 manifest_size_ = be64toh(manifest_size_); // switch big endian to host
526
Sen Jiangb8060e42015-09-24 17:30:50 -0700527 if (GetMajorVersion() == kBrilloMajorPayloadVersion) {
528 // Parse the metadata signature size.
Alex Vakulenko0103c362016-01-20 07:56:15 -0800529 static_assert(sizeof(metadata_signature_size_) ==
530 kDeltaMetadataSignatureSizeSize,
531 "metadata_signature_size size mismatch");
Sen Jiangb8060e42015-09-24 17:30:50 -0700532 uint64_t metadata_signature_size_offset;
533 if (!GetMetadataSignatureSizeOffset(&metadata_signature_size_offset)) {
534 *error = ErrorCode::kError;
535 return kMetadataParseError;
536 }
Sen Jiang76bfa742015-10-12 17:13:26 -0700537 memcpy(&metadata_signature_size_,
Sen Jiangb8060e42015-09-24 17:30:50 -0700538 &payload[metadata_signature_size_offset],
539 kDeltaMetadataSignatureSizeSize);
Sen Jiang76bfa742015-10-12 17:13:26 -0700540 metadata_signature_size_ = be32toh(metadata_signature_size_);
Sen Jiangb8060e42015-09-24 17:30:50 -0700541 }
Gilad Arnoldfe133932014-01-14 12:25:50 -0800542
543 // If the metadata size is present in install plan, check for it immediately
544 // even before waiting for that many number of bytes to be downloaded in the
545 // payload. This will prevent any attack which relies on us downloading data
546 // beyond the expected metadata size.
Sen Jiang76bfa742015-10-12 17:13:26 -0700547 metadata_size_ = manifest_offset + manifest_size_;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800548 if (install_plan_->hash_checks_mandatory) {
Sen Jiang0affc2c2017-02-10 15:55:05 -0800549 if (payload_->metadata_size != metadata_size_) {
Gilad Arnoldfe133932014-01-14 12:25:50 -0800550 LOG(ERROR) << "Mandatory metadata size in Omaha response ("
Sen Jiang0affc2c2017-02-10 15:55:05 -0800551 << payload_->metadata_size
Gilad Arnoldfe133932014-01-14 12:25:50 -0800552 << ") is missing/incorrect, actual = " << metadata_size_;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700553 *error = ErrorCode::kDownloadInvalidMetadataSize;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800554 return kMetadataParseError;
555 }
556 }
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700557 }
558
559 // Now that we have validated the metadata size, we should wait for the full
Sen Jiang76bfa742015-10-12 17:13:26 -0700560 // metadata and its signature (if exist) to be read in before we can parse it.
561 if (payload.size() < metadata_size_ + metadata_signature_size_)
Darin Petkov9574f7e2011-01-13 10:48:12 -0800562 return kMetadataParseInsufficientData;
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700563
564 // Log whether we validated the size or simply trusting what's in the payload
Jay Srinivasanf4318702012-09-24 11:56:24 -0700565 // here. This is logged here (after we received the full metadata data) so
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700566 // that we just log once (instead of logging n times) if it takes n
567 // DeltaPerformer::Write calls to download the full manifest.
Sen Jiang0affc2c2017-02-10 15:55:05 -0800568 if (payload_->metadata_size == metadata_size_) {
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700569 LOG(INFO) << "Manifest size in payload matches expected value from Omaha";
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800570 } else {
571 // For mandatory-cases, we'd have already returned a kMetadataParseError
572 // above. We'll be here only for non-mandatory cases. Just send a UMA stat.
573 LOG(WARNING) << "Ignoring missing/incorrect metadata size ("
Sen Jiang0affc2c2017-02-10 15:55:05 -0800574 << payload_->metadata_size
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800575 << ") in Omaha response as validation is not mandatory. "
Gilad Arnoldfe133932014-01-14 12:25:50 -0800576 << "Trusting metadata size in payload = " << metadata_size_;
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800577 }
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700578
Jay Srinivasanf4318702012-09-24 11:56:24 -0700579 // We have the full metadata in |payload|. Verify its integrity
580 // and authenticity based on the information we have in Omaha response.
Sen Jiang76bfa742015-10-12 17:13:26 -0700581 *error = ValidateMetadataSignature(payload);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700582 if (*error != ErrorCode::kSuccess) {
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800583 if (install_plan_->hash_checks_mandatory) {
David Zeuthenbc27aac2013-11-26 11:17:48 -0800584 // The autoupdate_CatchBadSignatures test checks for this string
585 // in log-files. Keep in sync.
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800586 LOG(ERROR) << "Mandatory metadata signature validation failed";
587 return kMetadataParseError;
588 }
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700589
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800590 // For non-mandatory cases, just send a UMA stat.
591 LOG(WARNING) << "Ignoring metadata signature validation failures";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700592 *error = ErrorCode::kSuccess;
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700593 }
594
Sen Jiangb8060e42015-09-24 17:30:50 -0700595 if (!GetManifestOffset(&manifest_offset)) {
596 *error = ErrorCode::kUnsupportedMajorPayloadVersion;
597 return kMetadataParseError;
598 }
Gilad Arnolddaa27402014-01-23 11:56:17 -0800599 // The payload metadata is deemed valid, it's safe to parse the protobuf.
Sen Jiangb8060e42015-09-24 17:30:50 -0700600 if (!manifest_.ParseFromArray(&payload[manifest_offset], manifest_size_)) {
Darin Petkov9574f7e2011-01-13 10:48:12 -0800601 LOG(ERROR) << "Unable to parse manifest in update file.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700602 *error = ErrorCode::kDownloadManifestParseError;
Darin Petkov9574f7e2011-01-13 10:48:12 -0800603 return kMetadataParseError;
604 }
Gilad Arnolddaa27402014-01-23 11:56:17 -0800605
606 manifest_parsed_ = true;
Darin Petkov9574f7e2011-01-13 10:48:12 -0800607 return kMetadataParseSuccess;
608}
609
Lann Martin39f57142017-07-14 09:18:42 -0600610#define OP_DURATION_HISTOGRAM(_op_name, _start_time) \
611 LOCAL_HISTOGRAM_CUSTOM_TIMES( \
612 "UpdateEngine.DownloadAction.InstallOperation::" \
613 _op_name ".Duration", \
614 base::TimeTicks::Now() - _start_time, \
615 base::TimeDelta::FromMilliseconds(10), \
616 base::TimeDelta::FromMinutes(5), \
617 20);
618
Don Garrette410e0f2011-11-10 15:39:01 -0800619// Wrapper around write. Returns true if all requested bytes
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -0800620// were written, or false on any error, regardless of progress
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700621// and stores an action exit code in |error|.
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800622bool DeltaPerformer::Write(const void* bytes, size_t count, ErrorCode *error) {
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700623 *error = ErrorCode::kSuccess;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700624 const char* c_bytes = reinterpret_cast<const char*>(bytes);
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800625
626 // Update the total byte downloaded count and the progress logs.
627 total_bytes_received_ += count;
628 UpdateOverallProgress(false, "Completed ");
629
Gilad Arnoldfe133932014-01-14 12:25:50 -0800630 while (!manifest_valid_) {
Sen Jiangb8060e42015-09-24 17:30:50 -0700631 // Read data up to the needed limit; this is either maximium payload header
632 // size, or the full metadata size (once it becomes known).
633 const bool do_read_header = !IsHeaderParsed();
Gilad Arnoldfe133932014-01-14 12:25:50 -0800634 CopyDataToBuffer(&c_bytes, &count,
Sen Jiangb8060e42015-09-24 17:30:50 -0700635 (do_read_header ? kMaxPayloadHeaderSize :
Sen Jiang76bfa742015-10-12 17:13:26 -0700636 metadata_size_ + metadata_signature_size_));
Gilad Arnoldfe133932014-01-14 12:25:50 -0800637
Gilad Arnolddaa27402014-01-23 11:56:17 -0800638 MetadataParseResult result = ParsePayloadMetadata(buffer_, error);
Gilad Arnold5cac5912013-05-24 17:21:17 -0700639 if (result == kMetadataParseError)
Don Garrette410e0f2011-11-10 15:39:01 -0800640 return false;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800641 if (result == kMetadataParseInsufficientData) {
642 // If we just processed the header, make an attempt on the manifest.
Sen Jiangb8060e42015-09-24 17:30:50 -0700643 if (do_read_header && IsHeaderParsed())
Gilad Arnoldfe133932014-01-14 12:25:50 -0800644 continue;
645
Don Garrette410e0f2011-11-10 15:39:01 -0800646 return true;
Gilad Arnoldfe133932014-01-14 12:25:50 -0800647 }
Gilad Arnold21504f02013-05-24 08:51:22 -0700648
649 // Checks the integrity of the payload manifest.
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700650 if ((*error = ValidateManifest()) != ErrorCode::kSuccess)
Gilad Arnold21504f02013-05-24 08:51:22 -0700651 return false;
Gilad Arnolddaa27402014-01-23 11:56:17 -0800652 manifest_valid_ = true;
Gilad Arnold21504f02013-05-24 08:51:22 -0700653
Gilad Arnoldfe133932014-01-14 12:25:50 -0800654 // Clear the download buffer.
Sen Jiangf6813802015-11-03 21:27:29 -0800655 DiscardBuffer(false, metadata_size_);
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700656
657 // This populates |partitions_| and the |install_plan.partitions| with the
658 // list of partitions from the manifest.
659 if (!ParseManifestPartitions(error))
660 return false;
661
Sen Jiang5ae865b2017-04-18 14:24:40 -0700662 // |install_plan.partitions| was filled in, nothing need to be done here if
663 // the payload was already applied, returns false to terminate http fetcher,
664 // but keep |error| as ErrorCode::kSuccess.
665 if (payload_->already_applied)
666 return false;
667
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700668 num_total_operations_ = 0;
669 for (const auto& partition : partitions_) {
670 num_total_operations_ += partition.operations_size();
671 acc_num_operations_.push_back(num_total_operations_);
672 }
673
Darin Petkov73058b42010-10-06 16:32:19 -0700674 LOG_IF(WARNING, !prefs_->SetInt64(kPrefsManifestMetadataSize,
Gilad Arnoldfe133932014-01-14 12:25:50 -0800675 metadata_size_))
Darin Petkov73058b42010-10-06 16:32:19 -0700676 << "Unable to save the manifest metadata size.";
Alex Deymof25eb492016-02-26 00:20:08 -0800677 LOG_IF(WARNING, !prefs_->SetInt64(kPrefsManifestSignatureSize,
678 metadata_signature_size_))
679 << "Unable to save the manifest signature size.";
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700680
Darin Petkov9b230572010-10-08 10:20:09 -0700681 if (!PrimeUpdateState()) {
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700682 *error = ErrorCode::kDownloadStateInitializationError;
Darin Petkov9b230572010-10-08 10:20:09 -0700683 LOG(ERROR) << "Unable to prime the update state.";
Don Garrette410e0f2011-11-10 15:39:01 -0800684 return false;
Darin Petkov9b230572010-10-08 10:20:09 -0700685 }
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800686
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700687 if (!OpenCurrentPartition()) {
688 *error = ErrorCode::kInstallDeviceOpenError;
689 return false;
Allie Woodfdf00512015-03-02 13:34:55 -0800690 }
691
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800692 if (next_operation_num_ > 0)
693 UpdateOverallProgress(true, "Resuming after ");
694 LOG(INFO) << "Starting to apply update payload operations";
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700695 }
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800696
697 while (next_operation_num_ < num_total_operations_) {
Jay Srinivasan1c0fe792013-03-28 16:45:25 -0700698 // Check if we should cancel the current attempt for any reason.
699 // In this case, *error will have already been populated with the reason
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700700 // why we're canceling.
Alex Deymo542c19b2015-12-03 07:43:31 -0300701 if (download_delegate_ && download_delegate_->ShouldCancel(error))
Jay Srinivasan1c0fe792013-03-28 16:45:25 -0700702 return false;
703
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700704 // We know there are more operations to perform because we didn't reach the
705 // |num_total_operations_| limit yet.
706 while (next_operation_num_ >= acc_num_operations_[current_partition_]) {
707 CloseCurrentPartition();
708 current_partition_++;
709 if (!OpenCurrentPartition()) {
710 *error = ErrorCode::kInstallDeviceOpenError;
711 return false;
712 }
713 }
714 const size_t partition_operation_num = next_operation_num_ - (
715 current_partition_ ? acc_num_operations_[current_partition_ - 1] : 0);
716
Alex Deymoa12ee112015-08-12 22:19:32 -0700717 const InstallOperation& op =
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700718 partitions_[current_partition_].operations(partition_operation_num);
Gilad Arnoldfe133932014-01-14 12:25:50 -0800719
720 CopyDataToBuffer(&c_bytes, &count, op.data_length());
721
722 // Check whether we received all of the next operation's data payload.
723 if (!CanPerformInstallOperation(op))
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700724 return true;
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700725
Jay Srinivasanf4318702012-09-24 11:56:24 -0700726 // Validate the operation only if the metadata signature is present.
Jay Srinivasan00f76b62012-09-17 18:48:36 -0700727 // Otherwise, keep the old behavior. This serves as a knob to disable
728 // the validation logic in case we find some regression after rollout.
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800729 // NOTE: If hash checks are mandatory and if metadata_signature is empty,
730 // we would have already failed in ParsePayloadMetadata method and thus not
731 // even be here. So no need to handle that case again here.
Sen Jiang0affc2c2017-02-10 15:55:05 -0800732 if (!payload_->metadata_signature.empty()) {
Jay Srinivasan00f76b62012-09-17 18:48:36 -0700733 // Note: Validate must be called only if CanPerformInstallOperation is
734 // called. Otherwise, we might be failing operations before even if there
735 // isn't sufficient data to compute the proper hash.
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800736 *error = ValidateOperationHash(op);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700737 if (*error != ErrorCode::kSuccess) {
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800738 if (install_plan_->hash_checks_mandatory) {
739 LOG(ERROR) << "Mandatory operation hash check failed";
740 return false;
741 }
Jay Srinivasanf0572052012-10-23 18:12:56 -0700742
Jay Srinivasan738fdf32012-12-07 17:40:54 -0800743 // For non-mandatory cases, just send a UMA stat.
744 LOG(WARNING) << "Ignoring operation validation errors";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -0700745 *error = ErrorCode::kSuccess;
Jay Srinivasan00f76b62012-09-17 18:48:36 -0700746 }
Jay Srinivasan51dcf262012-09-13 17:24:32 -0700747 }
748
Darin Petkov45580e42010-10-08 14:02:40 -0700749 // Makes sure we unblock exit when this operation completes.
Darin Petkov9c0baf82010-10-07 13:44:48 -0700750 ScopedTerminatorExitUnblocker exit_unblocker =
751 ScopedTerminatorExitUnblocker(); // Avoids a compiler unused var bug.
Gilad Arnoldfe133932014-01-14 12:25:50 -0800752
Lann Martin39f57142017-07-14 09:18:42 -0600753 base::TimeTicks op_start_time = base::TimeTicks::Now();
754
Gilad Arnoldfe133932014-01-14 12:25:50 -0800755 bool op_result;
Alex Deymo2d621a32015-10-01 11:09:01 -0700756 switch (op.type()) {
757 case InstallOperation::REPLACE:
758 case InstallOperation::REPLACE_BZ:
759 case InstallOperation::REPLACE_XZ:
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700760 op_result = PerformReplaceOperation(op);
Lann Martin39f57142017-07-14 09:18:42 -0600761 OP_DURATION_HISTOGRAM("REPLACE", op_start_time);
Alex Deymo2d621a32015-10-01 11:09:01 -0700762 break;
Alex Deymo79715ad2015-10-02 14:27:53 -0700763 case InstallOperation::ZERO:
764 case InstallOperation::DISCARD:
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700765 op_result = PerformZeroOrDiscardOperation(op);
Lann Martin39f57142017-07-14 09:18:42 -0600766 OP_DURATION_HISTOGRAM("ZERO_OR_DISCARD", op_start_time);
Alex Deymo79715ad2015-10-02 14:27:53 -0700767 break;
Alex Deymo2d621a32015-10-01 11:09:01 -0700768 case InstallOperation::MOVE:
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700769 op_result = PerformMoveOperation(op);
Lann Martin39f57142017-07-14 09:18:42 -0600770 OP_DURATION_HISTOGRAM("MOVE", op_start_time);
Alex Deymo2d621a32015-10-01 11:09:01 -0700771 break;
772 case InstallOperation::BSDIFF:
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700773 op_result = PerformBsdiffOperation(op);
Lann Martin39f57142017-07-14 09:18:42 -0600774 OP_DURATION_HISTOGRAM("BSDIFF", op_start_time);
Alex Deymo2d621a32015-10-01 11:09:01 -0700775 break;
776 case InstallOperation::SOURCE_COPY:
Sen Jiangbe2c47b2016-06-15 14:09:27 -0700777 op_result = PerformSourceCopyOperation(op, error);
Lann Martin39f57142017-07-14 09:18:42 -0600778 OP_DURATION_HISTOGRAM("SOURCE_COPY", op_start_time);
Alex Deymo2d621a32015-10-01 11:09:01 -0700779 break;
780 case InstallOperation::SOURCE_BSDIFF:
Amin Hassaniefa62d92017-11-09 13:46:56 -0800781 case InstallOperation::BROTLI_BSDIFF:
Sen Jiangbe2c47b2016-06-15 14:09:27 -0700782 op_result = PerformSourceBsdiffOperation(op, error);
Lann Martin39f57142017-07-14 09:18:42 -0600783 OP_DURATION_HISTOGRAM("SOURCE_BSDIFF", op_start_time);
Alex Deymo2d621a32015-10-01 11:09:01 -0700784 break;
Amin Hassani49fdb092017-08-04 13:10:59 -0700785 case InstallOperation::PUFFDIFF:
Amin Hassani02855c22017-09-06 22:34:50 -0700786 op_result = PerformPuffDiffOperation(op, error);
787 OP_DURATION_HISTOGRAM("PUFFDIFF", op_start_time);
Sen Jiangbc3e6b02016-01-19 18:39:26 +0800788 break;
Alex Deymo2d621a32015-10-01 11:09:01 -0700789 default:
Alex Deymoeecb0a52017-05-19 15:15:08 -0700790 op_result = false;
Alex Deymo2d621a32015-10-01 11:09:01 -0700791 }
792 if (!HandleOpResult(op_result, InstallOperationTypeName(op.type()), error))
Gilad Arnoldfe133932014-01-14 12:25:50 -0800793 return false;
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800794
Amin Hassani5192fe52017-08-28 10:28:46 -0700795 if (!target_fd_->Flush()) {
796 return false;
797 }
798
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -0700799 next_operation_num_++;
Gilad Arnold8a86fa52013-01-15 12:35:05 -0800800 UpdateOverallProgress(false, "Completed ");
Darin Petkov73058b42010-10-06 16:32:19 -0700801 CheckpointUpdateProgress();
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700802 }
Sen Jiangf6813802015-11-03 21:27:29 -0800803
804 // In major version 2, we don't add dummy operation to the payload.
Alex Deymof25eb492016-02-26 00:20:08 -0800805 // If we already extracted the signature we should skip this step.
Sen Jiangf6813802015-11-03 21:27:29 -0800806 if (major_payload_version_ == kBrilloMajorPayloadVersion &&
Alex Deymof25eb492016-02-26 00:20:08 -0800807 manifest_.has_signatures_offset() && manifest_.has_signatures_size() &&
808 signatures_message_data_.empty()) {
Sen Jiangf6813802015-11-03 21:27:29 -0800809 if (manifest_.signatures_offset() != buffer_offset_) {
810 LOG(ERROR) << "Payload signatures offset points to blob offset "
811 << manifest_.signatures_offset()
812 << " but signatures are expected at offset "
813 << buffer_offset_;
814 *error = ErrorCode::kDownloadPayloadVerificationError;
815 return false;
816 }
817 CopyDataToBuffer(&c_bytes, &count, manifest_.signatures_size());
818 // Needs more data to cover entire signature.
819 if (buffer_.size() < manifest_.signatures_size())
820 return true;
821 if (!ExtractSignatureMessage()) {
822 LOG(ERROR) << "Extract payload signature failed.";
823 *error = ErrorCode::kDownloadPayloadVerificationError;
824 return false;
825 }
826 DiscardBuffer(true, 0);
Alex Deymof25eb492016-02-26 00:20:08 -0800827 // Since we extracted the SignatureMessage we need to advance the
828 // checkpoint, otherwise we would reload the signature and try to extract
829 // it again.
830 CheckpointUpdateProgress();
Sen Jiangf6813802015-11-03 21:27:29 -0800831 }
832
Don Garrette410e0f2011-11-10 15:39:01 -0800833 return true;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700834}
835
David Zeuthen8f191b22013-08-06 12:27:50 -0700836bool DeltaPerformer::IsManifestValid() {
837 return manifest_valid_;
838}
839
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700840bool DeltaPerformer::ParseManifestPartitions(ErrorCode* error) {
841 if (major_payload_version_ == kBrilloMajorPayloadVersion) {
842 partitions_.clear();
843 for (const PartitionUpdate& partition : manifest_.partitions()) {
844 partitions_.push_back(partition);
845 }
846 manifest_.clear_partitions();
847 } else if (major_payload_version_ == kChromeOSMajorPayloadVersion) {
848 LOG(INFO) << "Converting update information from old format.";
849 PartitionUpdate root_part;
850 root_part.set_partition_name(kLegacyPartitionNameRoot);
Alex Deymo5fa2c6d2015-10-15 17:31:23 -0700851#ifdef __ANDROID__
852 LOG(WARNING) << "Legacy payload major version provided to an Android "
853 "build. Assuming no post-install. Please use major version "
854 "2 or newer.";
855 root_part.set_run_postinstall(false);
856#else
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700857 root_part.set_run_postinstall(true);
Alex Deymo5fa2c6d2015-10-15 17:31:23 -0700858#endif // __ANDROID__
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700859 if (manifest_.has_old_rootfs_info()) {
860 *root_part.mutable_old_partition_info() = manifest_.old_rootfs_info();
861 manifest_.clear_old_rootfs_info();
862 }
863 if (manifest_.has_new_rootfs_info()) {
864 *root_part.mutable_new_partition_info() = manifest_.new_rootfs_info();
865 manifest_.clear_new_rootfs_info();
866 }
867 *root_part.mutable_operations() = manifest_.install_operations();
868 manifest_.clear_install_operations();
869 partitions_.push_back(std::move(root_part));
870
871 PartitionUpdate kern_part;
872 kern_part.set_partition_name(kLegacyPartitionNameKernel);
873 kern_part.set_run_postinstall(false);
874 if (manifest_.has_old_kernel_info()) {
875 *kern_part.mutable_old_partition_info() = manifest_.old_kernel_info();
876 manifest_.clear_old_kernel_info();
877 }
878 if (manifest_.has_new_kernel_info()) {
879 *kern_part.mutable_new_partition_info() = manifest_.new_kernel_info();
880 manifest_.clear_new_kernel_info();
881 }
882 *kern_part.mutable_operations() = manifest_.kernel_install_operations();
883 manifest_.clear_kernel_install_operations();
884 partitions_.push_back(std::move(kern_part));
885 }
886
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700887 // Fill in the InstallPlan::partitions based on the partitions from the
888 // payload.
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700889 for (const auto& partition : partitions_) {
890 InstallPlan::Partition install_part;
891 install_part.name = partition.partition_name();
892 install_part.run_postinstall =
893 partition.has_run_postinstall() && partition.run_postinstall();
Alex Deymo390efed2016-02-18 11:00:40 -0800894 if (install_part.run_postinstall) {
895 install_part.postinstall_path =
896 (partition.has_postinstall_path() ? partition.postinstall_path()
897 : kPostinstallDefaultScript);
898 install_part.filesystem_type = partition.filesystem_type();
Alex Deymo5b91c6b2016-08-04 20:33:36 -0700899 install_part.postinstall_optional = partition.postinstall_optional();
Alex Deymo390efed2016-02-18 11:00:40 -0800900 }
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700901
902 if (partition.has_old_partition_info()) {
903 const PartitionInfo& info = partition.old_partition_info();
904 install_part.source_size = info.size();
905 install_part.source_hash.assign(info.hash().begin(), info.hash().end());
906 }
907
908 if (!partition.has_new_partition_info()) {
909 LOG(ERROR) << "Unable to get new partition hash info on partition "
910 << install_part.name << ".";
911 *error = ErrorCode::kDownloadNewPartitionInfoError;
912 return false;
913 }
914 const PartitionInfo& info = partition.new_partition_info();
915 install_part.target_size = info.size();
916 install_part.target_hash.assign(info.hash().begin(), info.hash().end());
917
918 install_plan_->partitions.push_back(install_part);
919 }
920
Alex Deymo542c19b2015-12-03 07:43:31 -0300921 if (!install_plan_->LoadPartitionsFromSlots(boot_control_)) {
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700922 LOG(ERROR) << "Unable to determine all the partition devices.";
923 *error = ErrorCode::kInstallDeviceOpenError;
924 return false;
925 }
926 LogPartitionInfo(partitions_);
927 return true;
928}
929
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700930bool DeltaPerformer::CanPerformInstallOperation(
Alex Deymoa12ee112015-08-12 22:19:32 -0700931 const chromeos_update_engine::InstallOperation& operation) {
Alex Deymo0497d052016-03-23 09:16:59 -0700932 // If we don't have a data blob we can apply it right away.
933 if (!operation.has_data_offset() && !operation.has_data_length())
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700934 return true;
935
936 // See if we have the entire data blob in the buffer
937 if (operation.data_offset() < buffer_offset_) {
938 LOG(ERROR) << "we threw away data it seems?";
939 return false;
940 }
Darin Petkovd7061ab2010-10-06 14:37:09 -0700941
Gilad Arnoldfe133932014-01-14 12:25:50 -0800942 return (operation.data_offset() + operation.data_length() <=
943 buffer_offset_ + buffer_.size());
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700944}
945
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700946bool DeltaPerformer::PerformReplaceOperation(
947 const InstallOperation& operation) {
Alex Deymoa12ee112015-08-12 22:19:32 -0700948 CHECK(operation.type() == InstallOperation::REPLACE ||
Alex Deymo2d621a32015-10-01 11:09:01 -0700949 operation.type() == InstallOperation::REPLACE_BZ ||
950 operation.type() == InstallOperation::REPLACE_XZ);
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700951
952 // Since we delete data off the beginning of the buffer as we use it,
953 // the data we need should be exactly at the beginning of the buffer.
Darin Petkov9b230572010-10-08 10:20:09 -0700954 TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
955 TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
Darin Petkovd7061ab2010-10-06 14:37:09 -0700956
Darin Petkov437adc42010-10-07 13:12:24 -0700957 // Extract the signature message if it's in this operation.
Sen Jiangf6813802015-11-03 21:27:29 -0800958 if (ExtractSignatureMessageFromOperation(operation)) {
959 // If this is dummy replace operation, we ignore it after extracting the
960 // signature.
961 DiscardBuffer(true, 0);
962 return true;
963 }
Darin Petkovd7061ab2010-10-06 14:37:09 -0700964
Alex Deymo05322872015-09-30 09:50:24 -0700965 // Setup the ExtentWriter stack based on the operation type.
Ben Chanab5a0af2017-10-12 14:57:50 -0700966 std::unique_ptr<ExtentWriter> writer = std::make_unique<ZeroPadExtentWriter>(
967 std::make_unique<DirectExtentWriter>());
Darin Petkovd7061ab2010-10-06 14:37:09 -0700968
Alex Deymo2d621a32015-10-01 11:09:01 -0700969 if (operation.type() == InstallOperation::REPLACE_BZ) {
Alex Deymo05322872015-09-30 09:50:24 -0700970 writer.reset(new BzipExtentWriter(std::move(writer)));
Alex Deymo2d621a32015-10-01 11:09:01 -0700971 } else if (operation.type() == InstallOperation::REPLACE_XZ) {
972 writer.reset(new XzExtentWriter(std::move(writer)));
973 }
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700974
Amin Hassanicd7edbe2017-09-18 17:05:02 -0700975 TEST_AND_RETURN_FALSE(
976 writer->Init(target_fd_, operation.dst_extents(), block_size_));
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -0800977 TEST_AND_RETURN_FALSE(writer->Write(buffer_.data(), operation.data_length()));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700978 TEST_AND_RETURN_FALSE(writer->End());
Darin Petkovd7061ab2010-10-06 14:37:09 -0700979
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700980 // Update buffer
Sen Jiangf6813802015-11-03 21:27:29 -0800981 DiscardBuffer(true, buffer_.size());
Andrew de los Reyes09e56d62010-04-23 13:45:53 -0700982 return true;
983}
984
Alex Deymo79715ad2015-10-02 14:27:53 -0700985bool DeltaPerformer::PerformZeroOrDiscardOperation(
Alex Deymoe5e5fe92015-10-05 09:28:19 -0700986 const InstallOperation& operation) {
Alex Deymo79715ad2015-10-02 14:27:53 -0700987 CHECK(operation.type() == InstallOperation::DISCARD ||
988 operation.type() == InstallOperation::ZERO);
989
990 // These operations have no blob.
991 TEST_AND_RETURN_FALSE(!operation.has_data_offset());
992 TEST_AND_RETURN_FALSE(!operation.has_data_length());
993
Alex Deymo05e0e382015-12-07 20:18:16 -0800994#ifdef BLKZEROOUT
995 bool attempt_ioctl = true;
Alex Deymo79715ad2015-10-02 14:27:53 -0700996 int request =
997 (operation.type() == InstallOperation::ZERO ? BLKZEROOUT : BLKDISCARD);
Alex Deymo05e0e382015-12-07 20:18:16 -0800998#else // !defined(BLKZEROOUT)
999 bool attempt_ioctl = false;
1000 int request = 0;
1001#endif // !defined(BLKZEROOUT)
Alex Deymo79715ad2015-10-02 14:27:53 -07001002
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001003 brillo::Blob zeros;
Chih-Hung Hsieh5c6bb1d2016-07-27 13:33:15 -07001004 for (const Extent& extent : operation.dst_extents()) {
Alex Deymo79715ad2015-10-02 14:27:53 -07001005 const uint64_t start = extent.start_block() * block_size_;
1006 const uint64_t length = extent.num_blocks() * block_size_;
1007 if (attempt_ioctl) {
1008 int result = 0;
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001009 if (target_fd_->BlkIoctl(request, start, length, &result) && result == 0)
Alex Deymo79715ad2015-10-02 14:27:53 -07001010 continue;
1011 attempt_ioctl = false;
1012 zeros.resize(16 * block_size_);
1013 }
1014 // In case of failure, we fall back to writing 0 to the selected region.
1015 for (uint64_t offset = 0; offset < length; offset += zeros.size()) {
Alex Deymo42791782015-10-08 11:01:28 -07001016 uint64_t chunk_length = min(length - offset,
1017 static_cast<uint64_t>(zeros.size()));
Amin Hassanid87304c2017-08-29 11:40:03 -07001018 TEST_AND_RETURN_FALSE(utils::PWriteAll(
1019 target_fd_, zeros.data(), chunk_length, start + offset));
Alex Deymo79715ad2015-10-02 14:27:53 -07001020 }
1021 }
1022 return true;
1023}
1024
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001025bool DeltaPerformer::PerformMoveOperation(const InstallOperation& operation) {
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001026 // Calculate buffer size. Note, this function doesn't do a sliding
1027 // window to copy in case the source and destination blocks overlap.
1028 // If we wanted to do a sliding window, we could program the server
1029 // to generate deltas that effectively did a sliding window.
1030
1031 uint64_t blocks_to_read = 0;
1032 for (int i = 0; i < operation.src_extents_size(); i++)
1033 blocks_to_read += operation.src_extents(i).num_blocks();
1034
1035 uint64_t blocks_to_write = 0;
1036 for (int i = 0; i < operation.dst_extents_size(); i++)
1037 blocks_to_write += operation.dst_extents(i).num_blocks();
1038
1039 DCHECK_EQ(blocks_to_write, blocks_to_read);
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001040 brillo::Blob buf(blocks_to_write * block_size_);
Andrew de los Reyesf4c7ef12010-04-30 10:37:00 -07001041
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001042 // Read in bytes.
1043 ssize_t bytes_read = 0;
1044 for (int i = 0; i < operation.src_extents_size(); i++) {
1045 ssize_t bytes_read_this_iteration = 0;
1046 const Extent& extent = operation.src_extents(i);
Darin Petkov8a075a72013-04-25 14:46:09 +02001047 const size_t bytes = extent.num_blocks() * block_size_;
Allie Wood56873452015-03-27 17:48:40 -07001048 TEST_AND_RETURN_FALSE(extent.start_block() != kSparseHole);
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001049 TEST_AND_RETURN_FALSE(utils::PReadAll(target_fd_,
Allie Wood56873452015-03-27 17:48:40 -07001050 &buf[bytes_read],
1051 bytes,
1052 extent.start_block() * block_size_,
1053 &bytes_read_this_iteration));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001054 TEST_AND_RETURN_FALSE(
Darin Petkov8a075a72013-04-25 14:46:09 +02001055 bytes_read_this_iteration == static_cast<ssize_t>(bytes));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001056 bytes_read += bytes_read_this_iteration;
1057 }
1058
1059 // Write bytes out.
1060 ssize_t bytes_written = 0;
1061 for (int i = 0; i < operation.dst_extents_size(); i++) {
1062 const Extent& extent = operation.dst_extents(i);
Darin Petkov8a075a72013-04-25 14:46:09 +02001063 const size_t bytes = extent.num_blocks() * block_size_;
Allie Wood56873452015-03-27 17:48:40 -07001064 TEST_AND_RETURN_FALSE(extent.start_block() != kSparseHole);
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001065 TEST_AND_RETURN_FALSE(utils::PWriteAll(target_fd_,
Allie Wood56873452015-03-27 17:48:40 -07001066 &buf[bytes_written],
1067 bytes,
1068 extent.start_block() * block_size_));
Darin Petkov8a075a72013-04-25 14:46:09 +02001069 bytes_written += bytes;
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001070 }
1071 DCHECK_EQ(bytes_written, bytes_read);
1072 DCHECK_EQ(bytes_written, static_cast<ssize_t>(buf.size()));
1073 return true;
1074}
1075
Allie Wood9f6f0a52015-03-30 11:25:47 -07001076namespace {
1077
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001078// Compare |calculated_hash| with source hash in |operation|, return false and
Sen Jiangbe2c47b2016-06-15 14:09:27 -07001079// dump hash and set |error| if don't match.
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001080bool ValidateSourceHash(const brillo::Blob& calculated_hash,
Sen Jiangbe2c47b2016-06-15 14:09:27 -07001081 const InstallOperation& operation,
1082 ErrorCode* error) {
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001083 brillo::Blob expected_source_hash(operation.src_sha256_hash().begin(),
1084 operation.src_sha256_hash().end());
1085 if (calculated_hash != expected_source_hash) {
Alex Deymo67140842016-06-15 13:28:59 -07001086 LOG(ERROR) << "The hash of the source data on disk for this operation "
1087 << "doesn't match the expected value. This could mean that the "
1088 << "delta update payload was targeted for another version, or "
1089 << "that the source partition was modified after it was "
1090 << "installed, for example, by mounting a filesystem.";
1091 LOG(ERROR) << "Expected: sha256|hex = "
1092 << base::HexEncode(expected_source_hash.data(),
1093 expected_source_hash.size());
1094 LOG(ERROR) << "Calculated: sha256|hex = "
1095 << base::HexEncode(calculated_hash.data(),
1096 calculated_hash.size());
1097
1098 vector<string> source_extents;
1099 for (const Extent& ext : operation.src_extents()) {
Tamas Berghammer9d66d762016-07-15 14:19:04 +01001100 source_extents.push_back(
1101 base::StringPrintf("%" PRIu64 ":%" PRIu64,
1102 static_cast<uint64_t>(ext.start_block()),
1103 static_cast<uint64_t>(ext.num_blocks())));
Alex Deymo67140842016-06-15 13:28:59 -07001104 }
1105 LOG(ERROR) << "Operation source (offset:size) in blocks: "
1106 << base::JoinString(source_extents, ",");
Sen Jiangbe2c47b2016-06-15 14:09:27 -07001107
1108 *error = ErrorCode::kDownloadStateInitializationError;
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001109 return false;
1110 }
1111 return true;
1112}
1113
Allie Wood9f6f0a52015-03-30 11:25:47 -07001114} // namespace
1115
1116bool DeltaPerformer::PerformSourceCopyOperation(
Sen Jiangbe2c47b2016-06-15 14:09:27 -07001117 const InstallOperation& operation, ErrorCode* error) {
Allie Wood9f6f0a52015-03-30 11:25:47 -07001118 if (operation.has_src_length())
1119 TEST_AND_RETURN_FALSE(operation.src_length() % block_size_ == 0);
1120 if (operation.has_dst_length())
1121 TEST_AND_RETURN_FALSE(operation.dst_length() % block_size_ == 0);
1122
Alex Deymoa48f6302016-11-04 15:49:53 -07001123 brillo::Blob source_hash;
1124 TEST_AND_RETURN_FALSE(fd_utils::CopyAndHashExtents(source_fd_,
1125 operation.src_extents(),
1126 target_fd_,
1127 operation.dst_extents(),
1128 block_size_,
1129 &source_hash));
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001130
1131 if (operation.has_src_sha256_hash()) {
Alex Deymoa48f6302016-11-04 15:49:53 -07001132 TEST_AND_RETURN_FALSE(ValidateSourceHash(source_hash, operation, error));
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001133 }
1134
Allie Wood9f6f0a52015-03-30 11:25:47 -07001135 return true;
1136}
1137
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001138bool DeltaPerformer::ExtentsToBsdiffPositionsString(
1139 const RepeatedPtrField<Extent>& extents,
1140 uint64_t block_size,
1141 uint64_t full_length,
1142 string* positions_string) {
1143 string ret;
1144 uint64_t length = 0;
Chih-Hung Hsieh5c6bb1d2016-07-27 13:33:15 -07001145 for (const Extent& extent : extents) {
Allie Wood56873452015-03-27 17:48:40 -07001146 int64_t start = extent.start_block() * block_size;
Tamas Berghammer9d66d762016-07-15 14:19:04 +01001147 uint64_t this_length =
1148 min(full_length - length,
1149 static_cast<uint64_t>(extent.num_blocks()) * block_size);
Alex Vakulenko75039d72014-03-25 12:36:28 -07001150 ret += base::StringPrintf("%" PRIi64 ":%" PRIu64 ",", start, this_length);
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001151 length += this_length;
1152 }
1153 TEST_AND_RETURN_FALSE(length == full_length);
1154 if (!ret.empty())
1155 ret.resize(ret.size() - 1); // Strip trailing comma off
1156 *positions_string = ret;
1157 return true;
1158}
1159
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001160bool DeltaPerformer::PerformBsdiffOperation(const InstallOperation& operation) {
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001161 // Since we delete data off the beginning of the buffer as we use it,
1162 // the data we need should be exactly at the beginning of the buffer.
Darin Petkov9b230572010-10-08 10:20:09 -07001163 TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
1164 TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001165
1166 string input_positions;
1167 TEST_AND_RETURN_FALSE(ExtentsToBsdiffPositionsString(operation.src_extents(),
1168 block_size_,
1169 operation.src_length(),
1170 &input_positions));
1171 string output_positions;
1172 TEST_AND_RETURN_FALSE(ExtentsToBsdiffPositionsString(operation.dst_extents(),
1173 block_size_,
1174 operation.dst_length(),
1175 &output_positions));
1176
Sen Jiang7a659092016-05-10 15:31:46 -07001177 TEST_AND_RETURN_FALSE(bsdiff::bspatch(target_path_.c_str(),
1178 target_path_.c_str(),
1179 buffer_.data(),
1180 buffer_.size(),
1181 input_positions.c_str(),
1182 output_positions.c_str()) == 0);
Sen Jiangf6813802015-11-03 21:27:29 -08001183 DiscardBuffer(true, buffer_.size());
Darin Petkov7f2ec752013-04-03 14:45:19 +02001184
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001185 if (operation.dst_length() % block_size_) {
1186 // Zero out rest of final block.
1187 // TODO(adlr): build this into bspatch; it's more efficient that way.
1188 const Extent& last_extent =
1189 operation.dst_extents(operation.dst_extents_size() - 1);
1190 const uint64_t end_byte =
1191 (last_extent.start_block() + last_extent.num_blocks()) * block_size_;
1192 const uint64_t begin_byte =
1193 end_byte - (block_size_ - operation.dst_length() % block_size_);
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001194 brillo::Blob zeros(end_byte - begin_byte);
Amin Hassanid87304c2017-08-29 11:40:03 -07001195 TEST_AND_RETURN_FALSE(utils::PWriteAll(
1196 target_fd_, zeros.data(), end_byte - begin_byte, begin_byte));
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001197 }
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001198 return true;
1199}
1200
Amin Hassanidb56be92017-09-06 12:41:23 -07001201bool DeltaPerformer::CalculateAndValidateSourceHash(
1202 const InstallOperation& operation, ErrorCode* error) {
1203 const uint64_t kMaxBlocksToRead = 256; // 1MB if block size is 4KB
1204 auto total_blocks = utils::BlocksInExtents(operation.src_extents());
1205 brillo::Blob buf(std::min(kMaxBlocksToRead, total_blocks) * block_size_);
1206 DirectExtentReader reader;
1207 TEST_AND_RETURN_FALSE(
1208 reader.Init(source_fd_, operation.src_extents(), block_size_));
1209 HashCalculator source_hasher;
1210 while (total_blocks > 0) {
1211 auto read_blocks = std::min(total_blocks, kMaxBlocksToRead);
1212 TEST_AND_RETURN_FALSE(reader.Read(buf.data(), read_blocks * block_size_));
1213 TEST_AND_RETURN_FALSE(
1214 source_hasher.Update(buf.data(), read_blocks * block_size_));
1215 total_blocks -= read_blocks;
1216 }
1217 TEST_AND_RETURN_FALSE(source_hasher.Finalize());
1218 TEST_AND_RETURN_FALSE(
1219 ValidateSourceHash(source_hasher.raw_hash(), operation, error));
1220 return true;
1221}
1222
Amin Hassanid9cb2902017-09-20 12:11:39 -07001223namespace {
1224
1225class BsdiffExtentFile : public bsdiff::FileInterface {
1226 public:
1227 BsdiffExtentFile(std::unique_ptr<ExtentReader> reader, size_t size)
1228 : BsdiffExtentFile(std::move(reader), nullptr, size) {}
1229 BsdiffExtentFile(std::unique_ptr<ExtentWriter> writer, size_t size)
1230 : BsdiffExtentFile(nullptr, std::move(writer), size) {}
1231
1232 ~BsdiffExtentFile() override = default;
1233
1234 bool Read(void* buf, size_t count, size_t* bytes_read) override {
1235 TEST_AND_RETURN_FALSE(reader_->Read(buf, count));
1236 *bytes_read = count;
1237 offset_ += count;
1238 return true;
1239 }
1240
1241 bool Write(const void* buf, size_t count, size_t* bytes_written) override {
1242 TEST_AND_RETURN_FALSE(writer_->Write(buf, count));
1243 *bytes_written = count;
1244 offset_ += count;
1245 return true;
1246 }
1247
1248 bool Seek(off_t pos) override {
1249 if (reader_ != nullptr) {
1250 TEST_AND_RETURN_FALSE(reader_->Seek(pos));
1251 offset_ = pos;
1252 } else {
1253 // For writes technically there should be no change of position, or it
1254 // should be equivalent of current offset.
1255 TEST_AND_RETURN_FALSE(offset_ == static_cast<uint64_t>(pos));
1256 }
1257 return true;
1258 }
1259
1260 bool Close() override {
1261 if (writer_ != nullptr) {
1262 TEST_AND_RETURN_FALSE(writer_->End());
1263 }
1264 return true;
1265 }
1266
1267 bool GetSize(uint64_t* size) override {
1268 *size = size_;
1269 return true;
1270 }
1271
1272 private:
1273 BsdiffExtentFile(std::unique_ptr<ExtentReader> reader,
1274 std::unique_ptr<ExtentWriter> writer,
1275 size_t size)
1276 : reader_(std::move(reader)),
1277 writer_(std::move(writer)),
1278 size_(size),
1279 offset_(0) {}
1280
1281 std::unique_ptr<ExtentReader> reader_;
1282 std::unique_ptr<ExtentWriter> writer_;
1283 uint64_t size_;
1284 uint64_t offset_;
1285
1286 DISALLOW_COPY_AND_ASSIGN(BsdiffExtentFile);
1287};
1288
1289} // namespace
1290
Allie Wood9f6f0a52015-03-30 11:25:47 -07001291bool DeltaPerformer::PerformSourceBsdiffOperation(
Sen Jiangbe2c47b2016-06-15 14:09:27 -07001292 const InstallOperation& operation, ErrorCode* error) {
Allie Wood9f6f0a52015-03-30 11:25:47 -07001293 // Since we delete data off the beginning of the buffer as we use it,
1294 // the data we need should be exactly at the beginning of the buffer.
1295 TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
1296 TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
1297 if (operation.has_src_length())
1298 TEST_AND_RETURN_FALSE(operation.src_length() % block_size_ == 0);
1299 if (operation.has_dst_length())
1300 TEST_AND_RETURN_FALSE(operation.dst_length() % block_size_ == 0);
1301
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001302 if (operation.has_src_sha256_hash()) {
Amin Hassanidb56be92017-09-06 12:41:23 -07001303 TEST_AND_RETURN_FALSE(CalculateAndValidateSourceHash(operation, error));
Sen Jiang2ec4aab2015-11-13 15:04:03 -08001304 }
1305
Amin Hassanid9cb2902017-09-20 12:11:39 -07001306 auto reader = std::make_unique<DirectExtentReader>();
1307 TEST_AND_RETURN_FALSE(
1308 reader->Init(source_fd_, operation.src_extents(), block_size_));
1309 auto src_file = std::make_unique<BsdiffExtentFile>(
1310 std::move(reader),
1311 utils::BlocksInExtents(operation.src_extents()) * block_size_);
Allie Wood9f6f0a52015-03-30 11:25:47 -07001312
Amin Hassanid9cb2902017-09-20 12:11:39 -07001313 auto writer = std::make_unique<DirectExtentWriter>();
1314 TEST_AND_RETURN_FALSE(
1315 writer->Init(target_fd_, operation.dst_extents(), block_size_));
1316 auto dst_file = std::make_unique<BsdiffExtentFile>(
1317 std::move(writer),
1318 utils::BlocksInExtents(operation.dst_extents()) * block_size_);
1319
1320 TEST_AND_RETURN_FALSE(bsdiff::bspatch(std::move(src_file),
1321 std::move(dst_file),
Sen Jiang7a659092016-05-10 15:31:46 -07001322 buffer_.data(),
Amin Hassanid9cb2902017-09-20 12:11:39 -07001323 buffer_.size()) == 0);
Sen Jiangbc3e6b02016-01-19 18:39:26 +08001324 DiscardBuffer(true, buffer_.size());
1325 return true;
1326}
1327
Amin Hassani02855c22017-09-06 22:34:50 -07001328namespace {
1329
1330// A class to be passed to |puffpatch| for reading from |source_fd_| and writing
1331// into |target_fd_|.
1332class PuffinExtentStream : public puffin::StreamInterface {
1333 public:
1334 // Constructor for creating a stream for reading from an |ExtentReader|.
1335 PuffinExtentStream(std::unique_ptr<ExtentReader> reader, size_t size)
1336 : PuffinExtentStream(std::move(reader), nullptr, size) {}
1337
1338 // Constructor for creating a stream for writing to an |ExtentWriter|.
1339 PuffinExtentStream(std::unique_ptr<ExtentWriter> writer, size_t size)
1340 : PuffinExtentStream(nullptr, std::move(writer), size) {}
1341
1342 ~PuffinExtentStream() override = default;
1343
1344 bool GetSize(size_t* size) const override {
1345 *size = size_;
1346 return true;
1347 }
1348
1349 bool GetOffset(size_t* offset) const override {
1350 *offset = offset_;
1351 return true;
1352 }
1353
1354 bool Seek(size_t offset) override {
1355 if (is_read_) {
1356 TEST_AND_RETURN_FALSE(reader_->Seek(offset));
1357 offset_ = offset;
1358 } else {
1359 // For writes technically there should be no change of position, or it
1360 // should equivalent of current offset.
1361 TEST_AND_RETURN_FALSE(offset_ == offset);
1362 }
1363 return true;
1364 }
1365
1366 bool Read(void* buffer, size_t count) override {
1367 TEST_AND_RETURN_FALSE(is_read_);
1368 TEST_AND_RETURN_FALSE(reader_->Read(buffer, count));
1369 offset_ += count;
1370 return true;
1371 }
1372
1373 bool Write(const void* buffer, size_t count) override {
1374 TEST_AND_RETURN_FALSE(!is_read_);
1375 TEST_AND_RETURN_FALSE(writer_->Write(buffer, count));
1376 offset_ += count;
1377 return true;
1378 }
1379
1380 bool Close() override {
1381 if (!is_read_) {
1382 TEST_AND_RETURN_FALSE(writer_->End());
1383 }
1384 return true;
1385 }
1386
1387 private:
1388 PuffinExtentStream(std::unique_ptr<ExtentReader> reader,
1389 std::unique_ptr<ExtentWriter> writer,
1390 size_t size)
1391 : reader_(std::move(reader)),
1392 writer_(std::move(writer)),
1393 size_(size),
1394 offset_(0),
1395 is_read_(reader_ ? true : false) {}
1396
1397 std::unique_ptr<ExtentReader> reader_;
1398 std::unique_ptr<ExtentWriter> writer_;
1399 uint64_t size_;
1400 uint64_t offset_;
1401 bool is_read_;
1402
1403 DISALLOW_COPY_AND_ASSIGN(PuffinExtentStream);
1404};
1405
1406} // namespace
1407
1408bool DeltaPerformer::PerformPuffDiffOperation(const InstallOperation& operation,
1409 ErrorCode* error) {
1410 // Since we delete data off the beginning of the buffer as we use it,
1411 // the data we need should be exactly at the beginning of the buffer.
1412 TEST_AND_RETURN_FALSE(buffer_offset_ == operation.data_offset());
1413 TEST_AND_RETURN_FALSE(buffer_.size() >= operation.data_length());
1414
1415 if (operation.has_src_sha256_hash()) {
1416 TEST_AND_RETURN_FALSE(CalculateAndValidateSourceHash(operation, error));
1417 }
1418
1419 auto reader = std::make_unique<DirectExtentReader>();
1420 TEST_AND_RETURN_FALSE(
1421 reader->Init(source_fd_, operation.src_extents(), block_size_));
1422 puffin::UniqueStreamPtr src_stream(new PuffinExtentStream(
1423 std::move(reader),
1424 utils::BlocksInExtents(operation.src_extents()) * block_size_));
1425
1426 auto writer = std::make_unique<DirectExtentWriter>();
1427 TEST_AND_RETURN_FALSE(
1428 writer->Init(target_fd_, operation.dst_extents(), block_size_));
1429 puffin::UniqueStreamPtr dst_stream(new PuffinExtentStream(
1430 std::move(writer),
1431 utils::BlocksInExtents(operation.dst_extents()) * block_size_));
1432
1433 const size_t kMaxCacheSize = 5 * 1024 * 1024; // Total 5MB cache.
1434 TEST_AND_RETURN_FALSE(puffin::PuffPatch(std::move(src_stream),
1435 std::move(dst_stream),
1436 buffer_.data(),
1437 buffer_.size(),
1438 kMaxCacheSize));
Allie Wood9f6f0a52015-03-30 11:25:47 -07001439 DiscardBuffer(true, buffer_.size());
Alex Deymoa12ee112015-08-12 22:19:32 -07001440 return true;
1441}
Darin Petkovd7061ab2010-10-06 14:37:09 -07001442
Darin Petkovd7061ab2010-10-06 14:37:09 -07001443bool DeltaPerformer::ExtractSignatureMessageFromOperation(
1444 const InstallOperation& operation) {
1445 if (operation.type() != InstallOperation::REPLACE ||
1446 !manifest_.has_signatures_offset() ||
1447 manifest_.signatures_offset() != operation.data_offset()) {
1448 return false;
1449 }
1450 TEST_AND_RETURN_FALSE(manifest_.has_signatures_size() &&
1451 manifest_.signatures_size() == operation.data_length());
Sen Jiangf6813802015-11-03 21:27:29 -08001452 TEST_AND_RETURN_FALSE(ExtractSignatureMessage());
1453 return true;
1454}
1455
1456bool DeltaPerformer::ExtractSignatureMessage() {
Darin Petkovd7061ab2010-10-06 14:37:09 -07001457 TEST_AND_RETURN_FALSE(signatures_message_data_.empty());
1458 TEST_AND_RETURN_FALSE(buffer_offset_ == manifest_.signatures_offset());
1459 TEST_AND_RETURN_FALSE(buffer_.size() >= manifest_.signatures_size());
Darin Petkov4f0a07b2011-05-25 16:47:20 -07001460 signatures_message_data_.assign(
Darin Petkovd7061ab2010-10-06 14:37:09 -07001461 buffer_.begin(),
1462 buffer_.begin() + manifest_.signatures_size());
Darin Petkov4f0a07b2011-05-25 16:47:20 -07001463
1464 // Save the signature blob because if the update is interrupted after the
1465 // download phase we don't go through this path anymore. Some alternatives to
1466 // consider:
1467 //
1468 // 1. On resume, re-download the signature blob from the server and re-verify
1469 // it.
1470 //
1471 // 2. Verify the signature as soon as it's received and don't checkpoint the
1472 // blob and the signed sha-256 context.
1473 LOG_IF(WARNING, !prefs_->SetString(kPrefsUpdateStateSignatureBlob,
Alex Vakulenkof68bbbc2015-02-09 12:53:18 -08001474 string(signatures_message_data_.begin(),
1475 signatures_message_data_.end())))
Darin Petkov4f0a07b2011-05-25 16:47:20 -07001476 << "Unable to store the signature blob.";
Sen Jiangf6813802015-11-03 21:27:29 -08001477
Darin Petkovd7061ab2010-10-06 14:37:09 -07001478 LOG(INFO) << "Extracted signature data of size "
1479 << manifest_.signatures_size() << " at "
1480 << manifest_.signatures_offset();
1481 return true;
1482}
1483
David Zeuthene7f89172013-10-31 10:21:04 -07001484bool DeltaPerformer::GetPublicKeyFromResponse(base::FilePath *out_tmp_key) {
Alex Deymo542c19b2015-12-03 07:43:31 -03001485 if (hardware_->IsOfficialBuild() ||
David Zeuthene7f89172013-10-31 10:21:04 -07001486 utils::FileExists(public_key_path_.c_str()) ||
1487 install_plan_->public_key_rsa.empty())
1488 return false;
1489
1490 if (!utils::DecodeAndStoreBase64String(install_plan_->public_key_rsa,
1491 out_tmp_key))
1492 return false;
1493
1494 return true;
1495}
1496
David Zeuthena99981f2013-04-29 13:42:47 -07001497ErrorCode DeltaPerformer::ValidateMetadataSignature(
Sen Jiang76bfa742015-10-12 17:13:26 -07001498 const brillo::Blob& payload) {
1499 if (payload.size() < metadata_size_ + metadata_signature_size_)
1500 return ErrorCode::kDownloadMetadataSignatureError;
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001501
Sen Jiang76bfa742015-10-12 17:13:26 -07001502 brillo::Blob metadata_signature_blob, metadata_signature_protobuf_blob;
Sen Jiang0affc2c2017-02-10 15:55:05 -08001503 if (!payload_->metadata_signature.empty()) {
Sen Jiang76bfa742015-10-12 17:13:26 -07001504 // Convert base64-encoded signature to raw bytes.
Sen Jiang0affc2c2017-02-10 15:55:05 -08001505 if (!brillo::data_encoding::Base64Decode(payload_->metadata_signature,
1506 &metadata_signature_blob)) {
Sen Jiang76bfa742015-10-12 17:13:26 -07001507 LOG(ERROR) << "Unable to decode base64 metadata signature: "
Sen Jiang0affc2c2017-02-10 15:55:05 -08001508 << payload_->metadata_signature;
Sen Jiang76bfa742015-10-12 17:13:26 -07001509 return ErrorCode::kDownloadMetadataSignatureError;
1510 }
1511 } else if (major_payload_version_ == kBrilloMajorPayloadVersion) {
Sen Jiang0affc2c2017-02-10 15:55:05 -08001512 metadata_signature_protobuf_blob.assign(
1513 payload.begin() + metadata_size_,
1514 payload.begin() + metadata_size_ + metadata_signature_size_);
Sen Jiang76bfa742015-10-12 17:13:26 -07001515 }
1516
1517 if (metadata_signature_blob.empty() &&
1518 metadata_signature_protobuf_blob.empty()) {
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001519 if (install_plan_->hash_checks_mandatory) {
Sen Jiang76bfa742015-10-12 17:13:26 -07001520 LOG(ERROR) << "Missing mandatory metadata signature in both Omaha "
1521 << "response and payload.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001522 return ErrorCode::kDownloadMetadataSignatureMissingError;
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001523 }
1524
Jay Srinivasanf4318702012-09-24 11:56:24 -07001525 LOG(WARNING) << "Cannot validate metadata as the signature is empty";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001526 return ErrorCode::kSuccess;
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001527 }
1528
David Zeuthene7f89172013-10-31 10:21:04 -07001529 // See if we should use the public RSA key in the Omaha response.
1530 base::FilePath path_to_public_key(public_key_path_);
1531 base::FilePath tmp_key;
1532 if (GetPublicKeyFromResponse(&tmp_key))
1533 path_to_public_key = tmp_key;
1534 ScopedPathUnlinker tmp_key_remover(tmp_key.value());
1535 if (tmp_key.empty())
1536 tmp_key_remover.set_should_remove(false);
1537
1538 LOG(INFO) << "Verifying metadata hash signature using public key: "
1539 << path_to_public_key.value();
1540
Sen Jiang2703ef42017-03-16 13:36:21 -07001541 brillo::Blob calculated_metadata_hash;
1542 if (!HashCalculator::RawHashOfBytes(
1543 payload.data(), metadata_size_, &calculated_metadata_hash)) {
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001544 LOG(ERROR) << "Unable to compute actual hash of manifest";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001545 return ErrorCode::kDownloadMetadataSignatureVerificationError;
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001546 }
1547
Alex Deymo923d8fa2014-07-15 17:58:51 -07001548 PayloadVerifier::PadRSA2048SHA256Hash(&calculated_metadata_hash);
Jay Srinivasanf4318702012-09-24 11:56:24 -07001549 if (calculated_metadata_hash.empty()) {
1550 LOG(ERROR) << "Computed actual hash of metadata is empty.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001551 return ErrorCode::kDownloadMetadataSignatureVerificationError;
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001552 }
1553
Sen Jiang76bfa742015-10-12 17:13:26 -07001554 if (!metadata_signature_blob.empty()) {
1555 brillo::Blob expected_metadata_hash;
1556 if (!PayloadVerifier::GetRawHashFromSignature(metadata_signature_blob,
1557 path_to_public_key.value(),
1558 &expected_metadata_hash)) {
1559 LOG(ERROR) << "Unable to compute expected hash from metadata signature";
1560 return ErrorCode::kDownloadMetadataSignatureError;
1561 }
1562 if (calculated_metadata_hash != expected_metadata_hash) {
1563 LOG(ERROR) << "Manifest hash verification failed. Expected hash = ";
1564 utils::HexDumpVector(expected_metadata_hash);
1565 LOG(ERROR) << "Calculated hash = ";
1566 utils::HexDumpVector(calculated_metadata_hash);
1567 return ErrorCode::kDownloadMetadataSignatureMismatch;
1568 }
1569 } else {
1570 if (!PayloadVerifier::VerifySignature(metadata_signature_protobuf_blob,
1571 path_to_public_key.value(),
1572 calculated_metadata_hash)) {
1573 LOG(ERROR) << "Manifest hash verification failed.";
1574 return ErrorCode::kDownloadMetadataSignatureMismatch;
1575 }
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001576 }
1577
David Zeuthenbc27aac2013-11-26 11:17:48 -08001578 // The autoupdate_CatchBadSignatures test checks for this string in
1579 // log-files. Keep in sync.
David Zeuthene7f89172013-10-31 10:21:04 -07001580 LOG(INFO) << "Metadata hash signature matches value in Omaha response.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001581 return ErrorCode::kSuccess;
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001582}
1583
Gilad Arnold21504f02013-05-24 08:51:22 -07001584ErrorCode DeltaPerformer::ValidateManifest() {
Don Garrettb8dd1d92013-11-22 17:40:02 -08001585 // Perform assorted checks to sanity check the manifest, make sure it
1586 // matches data from other sources, and that it is a supported version.
Don Garrettb8dd1d92013-11-22 17:40:02 -08001587
Alex Deymo64d98782016-02-05 18:03:48 -08001588 bool has_old_fields =
1589 (manifest_.has_old_kernel_info() || manifest_.has_old_rootfs_info());
1590 for (const PartitionUpdate& partition : manifest_.partitions()) {
1591 has_old_fields = has_old_fields || partition.has_old_partition_info();
1592 }
Sen Jiangc8f6b7a2015-10-21 11:09:59 -07001593
Alex Deymo64d98782016-02-05 18:03:48 -08001594 // The presence of an old partition hash is the sole indicator for a delta
1595 // update.
1596 InstallPayloadType actual_payload_type =
1597 has_old_fields ? InstallPayloadType::kDelta : InstallPayloadType::kFull;
1598
Sen Jiangcdd52062017-05-18 15:33:10 -07001599 if (payload_->type == InstallPayloadType::kUnknown) {
Alex Deymo64d98782016-02-05 18:03:48 -08001600 LOG(INFO) << "Detected a '"
1601 << InstallPayloadTypeToString(actual_payload_type)
1602 << "' payload.";
Sen Jiangcdd52062017-05-18 15:33:10 -07001603 payload_->type = actual_payload_type;
1604 } else if (payload_->type != actual_payload_type) {
Alex Deymo64d98782016-02-05 18:03:48 -08001605 LOG(ERROR) << "InstallPlan expected a '"
Sen Jiangcdd52062017-05-18 15:33:10 -07001606 << InstallPayloadTypeToString(payload_->type)
Alex Deymo64d98782016-02-05 18:03:48 -08001607 << "' payload but the downloaded manifest contains a '"
1608 << InstallPayloadTypeToString(actual_payload_type)
1609 << "' payload.";
1610 return ErrorCode::kPayloadMismatchedType;
1611 }
1612
1613 // Check that the minor version is compatible.
1614 if (actual_payload_type == InstallPayloadType::kFull) {
Don Garrettb8dd1d92013-11-22 17:40:02 -08001615 if (manifest_.minor_version() != kFullPayloadMinorVersion) {
1616 LOG(ERROR) << "Manifest contains minor version "
1617 << manifest_.minor_version()
1618 << ", but all full payloads should have version "
1619 << kFullPayloadMinorVersion << ".";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001620 return ErrorCode::kUnsupportedMinorPayloadVersion;
Don Garrettb8dd1d92013-11-22 17:40:02 -08001621 }
1622 } else {
Allie Woodfdf00512015-03-02 13:34:55 -08001623 if (manifest_.minor_version() != supported_minor_version_) {
Don Garrettb8dd1d92013-11-22 17:40:02 -08001624 LOG(ERROR) << "Manifest contains minor version "
1625 << manifest_.minor_version()
1626 << " not the supported "
Allie Woodfdf00512015-03-02 13:34:55 -08001627 << supported_minor_version_;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001628 return ErrorCode::kUnsupportedMinorPayloadVersion;
Don Garrettb8dd1d92013-11-22 17:40:02 -08001629 }
Gilad Arnold21504f02013-05-24 08:51:22 -07001630 }
1631
Sen Jiang3e728fe2015-11-05 11:37:23 -08001632 if (major_payload_version_ != kChromeOSMajorPayloadVersion) {
1633 if (manifest_.has_old_rootfs_info() ||
1634 manifest_.has_new_rootfs_info() ||
1635 manifest_.has_old_kernel_info() ||
1636 manifest_.has_new_kernel_info() ||
1637 manifest_.install_operations_size() != 0 ||
1638 manifest_.kernel_install_operations_size() != 0) {
1639 LOG(ERROR) << "Manifest contains deprecated field only supported in "
1640 << "major payload version 1, but the payload major version is "
1641 << major_payload_version_;
1642 return ErrorCode::kPayloadMismatchedType;
1643 }
1644 }
1645
Gilad Arnold21504f02013-05-24 08:51:22 -07001646 // TODO(garnold) we should be adding more and more manifest checks, such as
1647 // partition boundaries etc (see chromium-os:37661).
1648
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001649 return ErrorCode::kSuccess;
Gilad Arnold21504f02013-05-24 08:51:22 -07001650}
1651
David Zeuthena99981f2013-04-29 13:42:47 -07001652ErrorCode DeltaPerformer::ValidateOperationHash(
Alex Deymoa12ee112015-08-12 22:19:32 -07001653 const InstallOperation& operation) {
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001654 if (!operation.data_sha256_hash().size()) {
1655 if (!operation.data_length()) {
1656 // Operations that do not have any data blob won't have any operation hash
1657 // either. So, these operations are always considered validated since the
Jay Srinivasanf4318702012-09-24 11:56:24 -07001658 // metadata that contains all the non-data-blob portions of the operation
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001659 // has already been validated. This is true for both HTTP and HTTPS cases.
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001660 return ErrorCode::kSuccess;
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001661 }
1662
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001663 // No hash is present for an operation that has data blobs. This shouldn't
1664 // happen normally for any client that has this code, because the
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001665 // corresponding update should have been produced with the operation
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001666 // hashes. So if it happens it means either we've turned operation hash
1667 // generation off in DeltaDiffGenerator or it's a regression of some sort.
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001668 // One caveat though: The last operation is a dummy signature operation
1669 // that doesn't have a hash at the time the manifest is created. So we
1670 // should not complaint about that operation. This operation can be
1671 // recognized by the fact that it's offset is mentioned in the manifest.
1672 if (manifest_.signatures_offset() &&
1673 manifest_.signatures_offset() == operation.data_offset()) {
1674 LOG(INFO) << "Skipping hash verification for signature operation "
1675 << next_operation_num_ + 1;
1676 } else {
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001677 if (install_plan_->hash_checks_mandatory) {
1678 LOG(ERROR) << "Missing mandatory operation hash for operation "
1679 << next_operation_num_ + 1;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001680 return ErrorCode::kDownloadOperationHashMissingError;
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001681 }
1682
Jay Srinivasan738fdf32012-12-07 17:40:54 -08001683 LOG(WARNING) << "Cannot validate operation " << next_operation_num_ + 1
1684 << " as there's no operation hash in manifest";
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001685 }
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001686 return ErrorCode::kSuccess;
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001687 }
1688
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001689 brillo::Blob expected_op_hash;
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001690 expected_op_hash.assign(operation.data_sha256_hash().data(),
1691 (operation.data_sha256_hash().data() +
1692 operation.data_sha256_hash().size()));
1693
Sen Jiang2703ef42017-03-16 13:36:21 -07001694 brillo::Blob calculated_op_hash;
1695 if (!HashCalculator::RawHashOfBytes(
1696 buffer_.data(), operation.data_length(), &calculated_op_hash)) {
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001697 LOG(ERROR) << "Unable to compute actual hash of operation "
1698 << next_operation_num_;
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001699 return ErrorCode::kDownloadOperationHashVerificationError;
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001700 }
1701
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001702 if (calculated_op_hash != expected_op_hash) {
1703 LOG(ERROR) << "Hash verification failed for operation "
1704 << next_operation_num_ << ". Expected hash = ";
1705 utils::HexDumpVector(expected_op_hash);
1706 LOG(ERROR) << "Calculated hash over " << operation.data_length()
1707 << " bytes at offset: " << operation.data_offset() << " = ";
1708 utils::HexDumpVector(calculated_op_hash);
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001709 return ErrorCode::kDownloadOperationHashMismatch;
Jay Srinivasan00f76b62012-09-17 18:48:36 -07001710 }
1711
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001712 return ErrorCode::kSuccess;
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001713}
1714
Andrew de los Reyes771e1bd2011-08-30 14:47:23 -07001715#define TEST_AND_RETURN_VAL(_retval, _condition) \
1716 do { \
1717 if (!(_condition)) { \
1718 LOG(ERROR) << "VerifyPayload failure: " << #_condition; \
1719 return _retval; \
1720 } \
1721 } while (0);
Andrew de los Reyesfb830ba2011-04-04 11:42:43 -07001722
David Zeuthena99981f2013-04-29 13:42:47 -07001723ErrorCode DeltaPerformer::VerifyPayload(
Sen Jiang2703ef42017-03-16 13:36:21 -07001724 const brillo::Blob& update_check_response_hash,
Andrew de los Reyes771e1bd2011-08-30 14:47:23 -07001725 const uint64_t update_check_response_size) {
David Zeuthene7f89172013-10-31 10:21:04 -07001726
1727 // See if we should use the public RSA key in the Omaha response.
1728 base::FilePath path_to_public_key(public_key_path_);
1729 base::FilePath tmp_key;
1730 if (GetPublicKeyFromResponse(&tmp_key))
1731 path_to_public_key = tmp_key;
1732 ScopedPathUnlinker tmp_key_remover(tmp_key.value());
1733 if (tmp_key.empty())
1734 tmp_key_remover.set_should_remove(false);
1735
1736 LOG(INFO) << "Verifying payload using public key: "
1737 << path_to_public_key.value();
Darin Petkov437adc42010-10-07 13:12:24 -07001738
Jay Srinivasan0d8fb402012-05-07 19:19:38 -07001739 // Verifies the download size.
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001740 TEST_AND_RETURN_VAL(ErrorCode::kPayloadSizeMismatchError,
Jay Srinivasan0d8fb402012-05-07 19:19:38 -07001741 update_check_response_size ==
Sen Jiang76bfa742015-10-12 17:13:26 -07001742 metadata_size_ + metadata_signature_size_ +
1743 buffer_offset_);
Jay Srinivasan0d8fb402012-05-07 19:19:38 -07001744
Jay Srinivasan51dcf262012-09-13 17:24:32 -07001745 // Verifies the payload hash.
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001746 TEST_AND_RETURN_VAL(ErrorCode::kDownloadPayloadVerificationError,
Sen Jiang2703ef42017-03-16 13:36:21 -07001747 !payload_hash_calculator_.raw_hash().empty());
1748 TEST_AND_RETURN_VAL(
1749 ErrorCode::kPayloadHashMismatchError,
1750 payload_hash_calculator_.raw_hash() == update_check_response_hash);
Darin Petkov437adc42010-10-07 13:12:24 -07001751
Darin Petkov437adc42010-10-07 13:12:24 -07001752 // Verifies the signed payload hash.
David Zeuthene7f89172013-10-31 10:21:04 -07001753 if (!utils::FileExists(path_to_public_key.value().c_str())) {
Darin Petkov437adc42010-10-07 13:12:24 -07001754 LOG(WARNING) << "Not verifying signed delta payload -- missing public key.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001755 return ErrorCode::kSuccess;
Darin Petkovd7061ab2010-10-06 14:37:09 -07001756 }
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001757 TEST_AND_RETURN_VAL(ErrorCode::kSignedDeltaPayloadExpectedError,
Andrew de los Reyes771e1bd2011-08-30 14:47:23 -07001758 !signatures_message_data_.empty());
Sen Jiangf6813802015-11-03 21:27:29 -08001759 brillo::Blob hash_data = signed_hash_calculator_.raw_hash();
Alex Deymob552a682015-09-30 09:36:49 -07001760 TEST_AND_RETURN_VAL(ErrorCode::kDownloadPayloadPubKeyVerificationError,
1761 PayloadVerifier::PadRSA2048SHA256Hash(&hash_data));
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001762 TEST_AND_RETURN_VAL(ErrorCode::kDownloadPayloadPubKeyVerificationError,
Andrew de los Reyes771e1bd2011-08-30 14:47:23 -07001763 !hash_data.empty());
Alex Deymob552a682015-09-30 09:36:49 -07001764
1765 if (!PayloadVerifier::VerifySignature(
1766 signatures_message_data_, path_to_public_key.value(), hash_data)) {
David Zeuthenbc27aac2013-11-26 11:17:48 -08001767 // The autoupdate_CatchBadSignatures test checks for this string
1768 // in log-files. Keep in sync.
Alex Deymob552a682015-09-30 09:36:49 -07001769 LOG(ERROR) << "Public key verification failed, thus update failed.";
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001770 return ErrorCode::kDownloadPayloadPubKeyVerificationError;
Andrew de los Reyesfb830ba2011-04-04 11:42:43 -07001771 }
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -08001772
David Zeuthene7f89172013-10-31 10:21:04 -07001773 LOG(INFO) << "Payload hash matches value in payload.";
1774
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -08001775 // At this point, we are guaranteed to have downloaded a full payload, i.e
1776 // the one whose size matches the size mentioned in Omaha response. If any
1777 // errors happen after this, it's likely a problem with the payload itself or
1778 // the state of the system and not a problem with the URL or network. So,
Alex Deymo542c19b2015-12-03 07:43:31 -03001779 // indicate that to the download delegate so that AU can backoff
1780 // appropriately.
1781 if (download_delegate_)
1782 download_delegate_->DownloadComplete();
Jay Srinivasan2b5a0f02012-12-19 17:25:56 -08001783
Gilad Arnoldd1c4d2d2014-06-05 14:07:53 -07001784 return ErrorCode::kSuccess;
Darin Petkovd7061ab2010-10-06 14:37:09 -07001785}
1786
Sen Jiangf6813802015-11-03 21:27:29 -08001787void DeltaPerformer::DiscardBuffer(bool do_advance_offset,
1788 size_t signed_hash_buffer_size) {
Gilad Arnoldfe133932014-01-14 12:25:50 -08001789 // Update the buffer offset.
Gilad Arnolddaa27402014-01-23 11:56:17 -08001790 if (do_advance_offset)
Gilad Arnoldfe133932014-01-14 12:25:50 -08001791 buffer_offset_ += buffer_.size();
1792
1793 // Hash the content.
Sen Jiangf6813802015-11-03 21:27:29 -08001794 payload_hash_calculator_.Update(buffer_.data(), buffer_.size());
1795 signed_hash_calculator_.Update(buffer_.data(), signed_hash_buffer_size);
Gilad Arnoldfe133932014-01-14 12:25:50 -08001796
1797 // Swap content with an empty vector to ensure that all memory is released.
Alex Vakulenko3f39d5c2015-10-13 09:27:13 -07001798 brillo::Blob().swap(buffer_);
Darin Petkovd7061ab2010-10-06 14:37:09 -07001799}
1800
Darin Petkov0406e402010-10-06 21:33:11 -07001801bool DeltaPerformer::CanResumeUpdate(PrefsInterface* prefs,
Chih-Hung Hsieh5c6bb1d2016-07-27 13:33:15 -07001802 const string& update_check_response_hash) {
Darin Petkov0406e402010-10-06 21:33:11 -07001803 int64_t next_operation = kUpdateStateOperationInvalid;
Alex Deymo3310b222015-03-30 15:59:07 -07001804 if (!(prefs->GetInt64(kPrefsUpdateStateNextOperation, &next_operation) &&
1805 next_operation != kUpdateStateOperationInvalid &&
1806 next_operation > 0))
1807 return false;
Darin Petkov0406e402010-10-06 21:33:11 -07001808
1809 string interrupted_hash;
Alex Deymo3310b222015-03-30 15:59:07 -07001810 if (!(prefs->GetString(kPrefsUpdateCheckResponseHash, &interrupted_hash) &&
1811 !interrupted_hash.empty() &&
1812 interrupted_hash == update_check_response_hash))
1813 return false;
Darin Petkov0406e402010-10-06 21:33:11 -07001814
Darin Petkov61426142010-10-08 11:04:55 -07001815 int64_t resumed_update_failures;
Alex Deymof25eb492016-02-26 00:20:08 -08001816 // Note that storing this value is optional, but if it is there it should not
1817 // be more than the limit.
1818 if (prefs->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures) &&
1819 resumed_update_failures > kMaxResumedUpdateFailures)
Alex Deymo3310b222015-03-30 15:59:07 -07001820 return false;
Darin Petkov61426142010-10-08 11:04:55 -07001821
Darin Petkov0406e402010-10-06 21:33:11 -07001822 // Sanity check the rest.
1823 int64_t next_data_offset = -1;
Alex Deymo3310b222015-03-30 15:59:07 -07001824 if (!(prefs->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset) &&
1825 next_data_offset >= 0))
1826 return false;
Darin Petkov0406e402010-10-06 21:33:11 -07001827
Darin Petkov437adc42010-10-07 13:12:24 -07001828 string sha256_context;
Alex Deymo3310b222015-03-30 15:59:07 -07001829 if (!(prefs->GetString(kPrefsUpdateStateSHA256Context, &sha256_context) &&
1830 !sha256_context.empty()))
1831 return false;
Darin Petkov0406e402010-10-06 21:33:11 -07001832
1833 int64_t manifest_metadata_size = 0;
Alex Deymo3310b222015-03-30 15:59:07 -07001834 if (!(prefs->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size) &&
1835 manifest_metadata_size > 0))
1836 return false;
Darin Petkov0406e402010-10-06 21:33:11 -07001837
Alex Deymof25eb492016-02-26 00:20:08 -08001838 int64_t manifest_signature_size = 0;
1839 if (!(prefs->GetInt64(kPrefsManifestSignatureSize,
1840 &manifest_signature_size) &&
1841 manifest_signature_size >= 0))
1842 return false;
1843
Darin Petkov0406e402010-10-06 21:33:11 -07001844 return true;
1845}
1846
Darin Petkov9b230572010-10-08 10:20:09 -07001847bool DeltaPerformer::ResetUpdateProgress(PrefsInterface* prefs, bool quick) {
Darin Petkov0406e402010-10-06 21:33:11 -07001848 TEST_AND_RETURN_FALSE(prefs->SetInt64(kPrefsUpdateStateNextOperation,
1849 kUpdateStateOperationInvalid));
Darin Petkov9b230572010-10-08 10:20:09 -07001850 if (!quick) {
Darin Petkov9b230572010-10-08 10:20:09 -07001851 prefs->SetInt64(kPrefsUpdateStateNextDataOffset, -1);
David Zeuthen41996ad2013-09-24 15:43:24 -07001852 prefs->SetInt64(kPrefsUpdateStateNextDataLength, 0);
Darin Petkov9b230572010-10-08 10:20:09 -07001853 prefs->SetString(kPrefsUpdateStateSHA256Context, "");
1854 prefs->SetString(kPrefsUpdateStateSignedSHA256Context, "");
Darin Petkov4f0a07b2011-05-25 16:47:20 -07001855 prefs->SetString(kPrefsUpdateStateSignatureBlob, "");
Darin Petkov9b230572010-10-08 10:20:09 -07001856 prefs->SetInt64(kPrefsManifestMetadataSize, -1);
Alex Deymof25eb492016-02-26 00:20:08 -08001857 prefs->SetInt64(kPrefsManifestSignatureSize, -1);
Darin Petkov61426142010-10-08 11:04:55 -07001858 prefs->SetInt64(kPrefsResumedUpdateFailures, 0);
Sen Jiang02c49422017-10-31 15:14:11 -07001859 prefs->Delete(kPrefsPostInstallSucceeded);
Darin Petkov9b230572010-10-08 10:20:09 -07001860 }
Darin Petkov73058b42010-10-06 16:32:19 -07001861 return true;
1862}
1863
1864bool DeltaPerformer::CheckpointUpdateProgress() {
Darin Petkov9c0baf82010-10-07 13:44:48 -07001865 Terminator::set_exit_blocked(true);
Darin Petkov0406e402010-10-06 21:33:11 -07001866 if (last_updated_buffer_offset_ != buffer_offset_) {
Darin Petkov9c0baf82010-10-07 13:44:48 -07001867 // Resets the progress in case we die in the middle of the state update.
Darin Petkov9b230572010-10-08 10:20:09 -07001868 ResetUpdateProgress(prefs_, true);
Darin Petkov0406e402010-10-06 21:33:11 -07001869 TEST_AND_RETURN_FALSE(
Darin Petkov437adc42010-10-07 13:12:24 -07001870 prefs_->SetString(kPrefsUpdateStateSHA256Context,
Sen Jiangf6813802015-11-03 21:27:29 -08001871 payload_hash_calculator_.GetContext()));
1872 TEST_AND_RETURN_FALSE(
1873 prefs_->SetString(kPrefsUpdateStateSignedSHA256Context,
1874 signed_hash_calculator_.GetContext()));
Darin Petkov0406e402010-10-06 21:33:11 -07001875 TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextDataOffset,
1876 buffer_offset_));
1877 last_updated_buffer_offset_ = buffer_offset_;
David Zeuthen41996ad2013-09-24 15:43:24 -07001878
1879 if (next_operation_num_ < num_total_operations_) {
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001880 size_t partition_index = current_partition_;
1881 while (next_operation_num_ >= acc_num_operations_[partition_index])
1882 partition_index++;
1883 const size_t partition_operation_num = next_operation_num_ - (
1884 partition_index ? acc_num_operations_[partition_index - 1] : 0);
Alex Deymoa12ee112015-08-12 22:19:32 -07001885 const InstallOperation& op =
Alex Deymoe5e5fe92015-10-05 09:28:19 -07001886 partitions_[partition_index].operations(partition_operation_num);
David Zeuthen41996ad2013-09-24 15:43:24 -07001887 TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextDataLength,
1888 op.data_length()));
1889 } else {
1890 TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextDataLength,
1891 0));
1892 }
Darin Petkov0406e402010-10-06 21:33:11 -07001893 }
Darin Petkov73058b42010-10-06 16:32:19 -07001894 TEST_AND_RETURN_FALSE(prefs_->SetInt64(kPrefsUpdateStateNextOperation,
1895 next_operation_num_));
1896 return true;
1897}
1898
Darin Petkov9b230572010-10-08 10:20:09 -07001899bool DeltaPerformer::PrimeUpdateState() {
1900 CHECK(manifest_valid_);
1901 block_size_ = manifest_.block_size();
1902
1903 int64_t next_operation = kUpdateStateOperationInvalid;
1904 if (!prefs_->GetInt64(kPrefsUpdateStateNextOperation, &next_operation) ||
1905 next_operation == kUpdateStateOperationInvalid ||
1906 next_operation <= 0) {
1907 // Initiating a new update, no more state needs to be initialized.
1908 return true;
1909 }
1910 next_operation_num_ = next_operation;
1911
1912 // Resuming an update -- load the rest of the update state.
1913 int64_t next_data_offset = -1;
1914 TEST_AND_RETURN_FALSE(prefs_->GetInt64(kPrefsUpdateStateNextDataOffset,
1915 &next_data_offset) &&
1916 next_data_offset >= 0);
1917 buffer_offset_ = next_data_offset;
1918
Darin Petkov4f0a07b2011-05-25 16:47:20 -07001919 // The signed hash context and the signature blob may be empty if the
1920 // interrupted update didn't reach the signature.
Sen Jiangf6813802015-11-03 21:27:29 -08001921 string signed_hash_context;
1922 if (prefs_->GetString(kPrefsUpdateStateSignedSHA256Context,
1923 &signed_hash_context)) {
1924 TEST_AND_RETURN_FALSE(
1925 signed_hash_calculator_.SetContext(signed_hash_context));
1926 }
1927
Darin Petkov4f0a07b2011-05-25 16:47:20 -07001928 string signature_blob;
1929 if (prefs_->GetString(kPrefsUpdateStateSignatureBlob, &signature_blob)) {
1930 signatures_message_data_.assign(signature_blob.begin(),
1931 signature_blob.end());
1932 }
Darin Petkov9b230572010-10-08 10:20:09 -07001933
1934 string hash_context;
1935 TEST_AND_RETURN_FALSE(prefs_->GetString(kPrefsUpdateStateSHA256Context,
1936 &hash_context) &&
Sen Jiangf6813802015-11-03 21:27:29 -08001937 payload_hash_calculator_.SetContext(hash_context));
Darin Petkov9b230572010-10-08 10:20:09 -07001938
1939 int64_t manifest_metadata_size = 0;
1940 TEST_AND_RETURN_FALSE(prefs_->GetInt64(kPrefsManifestMetadataSize,
1941 &manifest_metadata_size) &&
1942 manifest_metadata_size > 0);
Gilad Arnoldfe133932014-01-14 12:25:50 -08001943 metadata_size_ = manifest_metadata_size;
Darin Petkov9b230572010-10-08 10:20:09 -07001944
Alex Deymof25eb492016-02-26 00:20:08 -08001945 int64_t manifest_signature_size = 0;
1946 TEST_AND_RETURN_FALSE(
1947 prefs_->GetInt64(kPrefsManifestSignatureSize, &manifest_signature_size) &&
1948 manifest_signature_size >= 0);
1949 metadata_signature_size_ = manifest_signature_size;
1950
Gilad Arnold8a86fa52013-01-15 12:35:05 -08001951 // Advance the download progress to reflect what doesn't need to be
1952 // re-downloaded.
1953 total_bytes_received_ += buffer_offset_;
1954
Darin Petkov61426142010-10-08 11:04:55 -07001955 // Speculatively count the resume as a failure.
1956 int64_t resumed_update_failures;
1957 if (prefs_->GetInt64(kPrefsResumedUpdateFailures, &resumed_update_failures)) {
1958 resumed_update_failures++;
1959 } else {
1960 resumed_update_failures = 1;
1961 }
1962 prefs_->SetInt64(kPrefsResumedUpdateFailures, resumed_update_failures);
Darin Petkov9b230572010-10-08 10:20:09 -07001963 return true;
1964}
1965
Andrew de los Reyes09e56d62010-04-23 13:45:53 -07001966} // namespace chromeos_update_engine