1//
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//
16
17#include "update_engine/payload_consumer/filesystem_verifier_action.h"
18
19#include <errno.h>
20#include <fcntl.h>
21#include <sys/stat.h>
22#include <sys/types.h>
23
24#include <algorithm>
25#include <cstdlib>
26#include <string>
27
28#include <base/bind.h>
29#include <brillo/data_encoding.h>
30#include <brillo/streams/file_stream.h>
31
32#include "update_engine/common/boot_control_interface.h"
33#include "update_engine/common/utils.h"
34#include "update_engine/payload_consumer/delta_performer.h"
35#include "update_engine/payload_consumer/payload_constants.h"
36
37using std::string;
38
39namespace chromeos_update_engine {
40
41namespace {
42const off_t kReadFileBufferSize = 128 * 1024;
43
44string StringForHashBytes(const brillo::Blob& hash) {
45  return brillo::data_encoding::Base64Encode(hash.data(), hash.size());
46}
47}  // namespace
48
49void FilesystemVerifierAction::PerformAction() {
50  // Will tell the ActionProcessor we've failed if we return.
51  ScopedActionCompleter abort_action_completer(processor_, this);
52
53  if (!HasInputObject()) {
54    LOG(ERROR) << "FilesystemVerifierAction missing input object.";
55    return;
56  }
57  install_plan_ = GetInputObject();
58
59  if (install_plan_.partitions.empty()) {
60    LOG(INFO) << "No partitions to verify.";
61    if (HasOutputPipe())
62      SetOutputObject(install_plan_);
63    abort_action_completer.set_code(ErrorCode::kSuccess);
64    return;
65  }
66
67  StartPartitionHashing();
68  abort_action_completer.set_should_complete(false);
69}
70
71void FilesystemVerifierAction::TerminateProcessing() {
72  cancelled_ = true;
73  Cleanup(ErrorCode::kSuccess);  // error code is ignored if canceled_ is true.
74}
75
76bool FilesystemVerifierAction::IsCleanupPending() const {
77  return src_stream_ != nullptr;
78}
79
80void FilesystemVerifierAction::Cleanup(ErrorCode code) {
81  src_stream_.reset();
82  // This memory is not used anymore.
83  buffer_.clear();
84
85  if (cancelled_)
86    return;
87  if (code == ErrorCode::kSuccess && HasOutputPipe())
88    SetOutputObject(install_plan_);
89  processor_->ActionComplete(this, code);
90}
91
92void FilesystemVerifierAction::StartPartitionHashing() {
93  if (partition_index_ == install_plan_.partitions.size()) {
94    Cleanup(ErrorCode::kSuccess);
95    return;
96  }
97  InstallPlan::Partition& partition =
98      install_plan_.partitions[partition_index_];
99
100  string part_path;
101  switch (verifier_step_) {
102    case VerifierStep::kVerifySourceHash:
103      part_path = partition.source_path;
104      remaining_size_ = partition.source_size;
105      break;
106    case VerifierStep::kVerifyTargetHash:
107      part_path = partition.target_path;
108      remaining_size_ = partition.target_size;
109      break;
110  }
111  LOG(INFO) << "Hashing partition " << partition_index_ << " ("
112            << partition.name << ") on device " << part_path;
113  if (part_path.empty())
114    return Cleanup(ErrorCode::kFilesystemVerifierError);
115
116  brillo::ErrorPtr error;
117  src_stream_ = brillo::FileStream::Open(
118      base::FilePath(part_path),
119      brillo::Stream::AccessMode::READ,
120      brillo::FileStream::Disposition::OPEN_EXISTING,
121      &error);
122
123  if (!src_stream_) {
124    LOG(ERROR) << "Unable to open " << part_path << " for reading";
125    return Cleanup(ErrorCode::kFilesystemVerifierError);
126  }
127
128  buffer_.resize(kReadFileBufferSize);
129  read_done_ = false;
130  hasher_.reset(new HashCalculator());
131
132  // Start the first read.
133  ScheduleRead();
134}
135
136void FilesystemVerifierAction::ScheduleRead() {
137  size_t bytes_to_read = std::min(static_cast<int64_t>(buffer_.size()),
138                                  remaining_size_);
139  if (!bytes_to_read) {
140    OnReadDoneCallback(0);
141    return;
142  }
143
144  bool read_async_ok = src_stream_->ReadAsync(
145    buffer_.data(),
146    bytes_to_read,
147    base::Bind(&FilesystemVerifierAction::OnReadDoneCallback,
148               base::Unretained(this)),
149    base::Bind(&FilesystemVerifierAction::OnReadErrorCallback,
150               base::Unretained(this)),
151    nullptr);
152
153  if (!read_async_ok) {
154    LOG(ERROR) << "Unable to schedule an asynchronous read from the stream.";
155    Cleanup(ErrorCode::kError);
156  }
157}
158
159void FilesystemVerifierAction::OnReadDoneCallback(size_t bytes_read) {
160  if (bytes_read == 0) {
161    read_done_ = true;
162  } else {
163    remaining_size_ -= bytes_read;
164    CHECK(!read_done_);
165    if (!hasher_->Update(buffer_.data(), bytes_read)) {
166      LOG(ERROR) << "Unable to update the hash.";
167      Cleanup(ErrorCode::kError);
168      return;
169    }
170  }
171
172  // We either terminate the current partition or have more data to read.
173  if (cancelled_)
174    return Cleanup(ErrorCode::kError);
175
176  if (read_done_ || remaining_size_ == 0) {
177    if (remaining_size_ != 0) {
178      LOG(ERROR) << "Failed to read the remaining " << remaining_size_
179                 << " bytes from partition "
180                 << install_plan_.partitions[partition_index_].name;
181      return Cleanup(ErrorCode::kFilesystemVerifierError);
182    }
183    return FinishPartitionHashing();
184  }
185  ScheduleRead();
186}
187
188void FilesystemVerifierAction::OnReadErrorCallback(
189      const brillo::Error* error) {
190  // TODO(deymo): Transform the read-error into an specific ErrorCode.
191  LOG(ERROR) << "Asynchronous read failed.";
192  Cleanup(ErrorCode::kError);
193}
194
195void FilesystemVerifierAction::FinishPartitionHashing() {
196  if (!hasher_->Finalize()) {
197    LOG(ERROR) << "Unable to finalize the hash.";
198    return Cleanup(ErrorCode::kError);
199  }
200  InstallPlan::Partition& partition =
201      install_plan_.partitions[partition_index_];
202  LOG(INFO) << "Hash of " << partition.name << ": " << hasher_->hash();
203
204  switch (verifier_step_) {
205    case VerifierStep::kVerifyTargetHash:
206      if (partition.target_hash != hasher_->raw_hash()) {
207        LOG(ERROR) << "New '" << partition.name
208                   << "' partition verification failed.";
209        if (install_plan_.payload_type == InstallPayloadType::kFull)
210          return Cleanup(ErrorCode::kNewRootfsVerificationError);
211        // If we have not verified source partition yet, now that the target
212        // partition does not match, and it's not a full payload, we need to
213        // switch to kVerifySourceHash step to check if it's because the source
214        // partition does not match either.
215        verifier_step_ = VerifierStep::kVerifySourceHash;
216      } else {
217        partition_index_++;
218      }
219      break;
220    case VerifierStep::kVerifySourceHash:
221      if (partition.source_hash != hasher_->raw_hash()) {
222        LOG(ERROR) << "Old '" << partition.name
223                   << "' partition verification failed.";
224        LOG(ERROR) << "This is a server-side error due to mismatched delta"
225                   << " update image!";
226        LOG(ERROR) << "The delta I've been given contains a " << partition.name
227                   << " delta update that must be applied over a "
228                   << partition.name << " with a specific checksum, but the "
229                   << partition.name
230                   << " we're starting with doesn't have that checksum! This"
231                      " means that the delta I've been given doesn't match my"
232                      " existing system. The "
233                   << partition.name << " partition I have has hash: "
234                   << StringForHashBytes(hasher_->raw_hash())
235                   << " but the update expected me to have "
236                   << StringForHashBytes(partition.source_hash) << " .";
237        LOG(INFO) << "To get the checksum of the " << partition.name
238                  << " partition run this command: dd if="
239                  << partition.source_path
240                  << " bs=1M count=" << partition.source_size
241                  << " iflag=count_bytes 2>/dev/null | openssl dgst -sha256 "
242                     "-binary | openssl base64";
243        LOG(INFO) << "To get the checksum of partitions in a bin file, "
244                  << "run: .../src/scripts/sha256_partitions.sh .../file.bin";
245        return Cleanup(ErrorCode::kDownloadStateInitializationError);
246      }
247      // The action will skip kVerifySourceHash step if target partition hash
248      // matches, if we are in this step, it means target hash does not match,
249      // and now that the source partition hash matches, we should set the error
250      // code to reflect the error in target partition.
251      // We only need to verify the source partition which the target hash does
252      // not match, the rest of the partitions don't matter.
253      return Cleanup(ErrorCode::kNewRootfsVerificationError);
254  }
255  // Start hashing the next partition, if any.
256  hasher_.reset();
257  buffer_.clear();
258  src_stream_->CloseBlocking(nullptr);
259  StartPartitionHashing();
260}
261
262}  // namespace chromeos_update_engine
263