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