update_engine/cros/install_action.cc - third_party/platform2 - Git at Google

 // Copyright 2022 The ChromiumOS Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "update_engine/cros/install_action.h"

 #include <inttypes.h>

 #include <string>
 #include <utility>

 #include <base/files/file_path.h>
 #include <base/files/file_util.h>
 #include <base/logging.h>
 #include <base/strings/string_number_conversions.h>
 #include <chromeos/constants/imageloader.h>
 #include <crypto/secure_hash.h>
 #include <crypto/sha2.h>
 #include <libimageloader/manifest.h>

 #include "update_engine/common/boot_control.h"
 #include "update_engine/common/dlcservice_interface.h"
 #include "update_engine/common/system_state.h"
 #include "update_engine/common/utils.h"
 #include "update_engine/cros/image_properties.h"

 namespace chromeos_update_engine {

 namespace {
 constexpr char kBandaidUrl[] = "https://edgedl.me.gvt1.com/edgedl/dlc";
 constexpr char kLorryUrl[] = "https://dl.google.com/dlc";

 constexpr char kBandaidArtifactsMetaUrl[] = "https://edgedl.me.gvt1.com/edgedl";
 constexpr char kLorryArtifactsMetaUrl[] = "https://dl.google.com";

 constexpr char kUrlNameBandaid[] = "<BANDAID>";
 constexpr char kUrlNameLorry[] = "<LORRY>";

 constexpr char kUrlNameBandaidArtifactsMeta[] = "<BANDAID_ARTIFACTS_META>";
 constexpr char kUrlNameLorryArtifactsMeta[] = "<LORRY_ARTIFACTS_META>";

 constexpr char kDefaultArtifact[] = "dlc.img";
 constexpr char kDefaultPackage[] = "package";

 constexpr char kRedactedDlcPartition[] = "<REDACTED_PARTITION>";
 }  // namespace

 const char kDefaultSlotting[] = "dlc-scaled";
 const char kForceOTASlotting[] = "dlc";

 InstallAction::InstallAction(std::unique_ptr<HttpFetcher> http_fetcher,
                              const std::string& id,
                              const std::string& slotting,
                              const std::string& manifest_dir)
     : http_fetcher_(std::move(http_fetcher)), id_(id) {
   slotting_ = slotting.empty() ? kDefaultSlotting : slotting;
   manifest_dir_ =
       manifest_dir.empty() ? imageloader::kDlcManifestRootpath : manifest_dir;
 }

 InstallAction::~InstallAction() {}

 void InstallAction::PerformAction() {
   LOG(INFO) << "InstallAction performing action.";

   manifest_ = SystemState::Get()->dlc_utils()->GetDlcManifest(
       id_, base::FilePath(manifest_dir_));
   if (!manifest_) {
     LOG(ERROR) << "Could not retrieve manifest for " << id_;
     processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
     return;
   }
   image_props_ = LoadImageProperties();
   http_fetcher_->set_delegate(this);
   bool user_tied = manifest_->user_tied();
   if (user_tied)
     http_fetcher_->set_payload_info_visible(false);

   // Get the DLC device partition.
   auto partition_name =
       base::FilePath("dlc").Append(id_).Append(kDefaultPackage).value();
   auto* boot_control = SystemState::Get()->boot_control();

   std::string partition;
   const auto& sanitized_id = manifest_->sanitized_id();
   if (!boot_control->GetPartitionDevice(
           partition_name, boot_control->GetCurrentSlot(), &partition)) {
     LOG(ERROR) << "Could not retrieve device partition for " << sanitized_id;
     processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
     return;
   }
   const auto& sanitized_partition =
       user_tied ? kRedactedDlcPartition : partition;

   f_.Initialize(base::FilePath(partition), base::File::Flags::FLAG_OPEN |
                                                base::File::Flags::FLAG_READ |
                                                base::File::Flags::FLAG_WRITE);
   if (!f_.IsValid()) {
     LOG(ERROR) << "Could not open device partition for " << sanitized_id
                << " at " << sanitized_partition;
     processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
     return;
   }
   LOG(INFO) << "Installing to " << sanitized_partition;

   std::string url_to_fetch;
   std::string sanitized_url;
   const auto& artifacts_meta = manifest_->artifacts_meta();
   if (artifacts_meta.valid) {
     auto UrlToFetch = [artifacts_meta](const std::string& url) -> std::string {
       return base::FilePath(url)
           .Append(artifacts_meta.uri)
           .Append(kDefaultArtifact)
           .value();
     };
     url_to_fetch = UrlToFetch(kBandaidArtifactsMetaUrl);
     sanitized_url = user_tied ? kUrlNameBandaidArtifactsMeta : url_to_fetch;
     backup_urls_ = {UrlToFetch(kLorryArtifactsMetaUrl)};
     backup_urls_sanitized_ =
         user_tied ? std::vector<std::string>({kUrlNameLorryArtifactsMeta})
                   : backup_urls_;
   } else {
     auto UrlToFetch = [this](const std::string& url) -> std::string {
       return base::FilePath(url)
           .Append(image_props_.builder_path)
           .Append(slotting_)
           .Append(id_)
           .Append(kDefaultPackage)
           .Append(kDefaultArtifact)
           .value();
     };
     url_to_fetch = UrlToFetch(kBandaidUrl);
     sanitized_url = user_tied ? kUrlNameBandaid : url_to_fetch;
     backup_urls_ = {UrlToFetch(kLorryUrl)};
     backup_urls_sanitized_ =
         user_tied ? std::vector<std::string>({kUrlNameLorry}) : backup_urls_;
   }
   StartInstallation(url_to_fetch, sanitized_url);
 }

 void InstallAction::TerminateProcessing() {
   http_fetcher_->TerminateTransfer();
 }

 bool InstallAction::ReceivedBytes(HttpFetcher* fetcher,
                                   const void* bytes,
                                   size_t length) {
   uint64_t new_offset = offset_ + length;
   // Overflow upper bound check against manifest.
   if (new_offset > manifest_->size()) {
     LOG(ERROR) << "Overflow of bytes, terminating.";
     http_fetcher_->TerminateTransfer();
     return false;
   }

   if (delegate()) {
     delegate_->BytesReceived(new_offset, manifest_->size());
   }

   hash_->Update(bytes, length);
   int64_t total_written_bytes = 0;
   do {
     int written_bytes =
         f_.Write(offset_ + total_written_bytes,
                  static_cast<const char*>(bytes) + total_written_bytes,
                  length - total_written_bytes);
     if (written_bytes == -1) {
       PLOG(ERROR) << "Failed to write bytes.";
       http_fetcher_->TerminateTransfer();
       return false;
     }

     total_written_bytes += written_bytes;
   } while (total_written_bytes != length);

   offset_ = new_offset;
   return true;
 }

 void InstallAction::TransferComplete(HttpFetcher* fetcher, bool successful) {
   if (!successful) {
     // Continue to use backup URLs.
     if (backup_url_index_ < backup_urls_.size()) {
       LOG(INFO) << "Using backup url at index=" << backup_url_index_;
       const auto& url = backup_urls_[backup_url_index_];
       const auto& url_sanitized = backup_urls_sanitized_[backup_url_index_];
       ++backup_url_index_;
       StartInstallation(url, url_sanitized);
       return;
     }
     LOG(ERROR) << "Transfer failed.";
     TerminateInstallation();
     return;
   }

   auto expected_offset = manifest_->size();
   if (offset_ != expected_offset) {
     LOG(ERROR) << "Transferred bytes offset (" << offset_
                << ") don't match the expected offset ("
                << manifest_->sanitized_size() << ").";
     TerminateInstallation();
     return;
   }
   LOG(INFO) << "Transferred bytes offset (" << manifest_->sanitized_size()
             << ") is valid.";

   std::vector<uint8_t> sha256(crypto::kSHA256Length);
   hash_->Finish(sha256.data(), sha256.size());
   auto expected_sha256 = manifest_->image_sha256();
   auto expected_sha256_str =
       base::HexEncode(expected_sha256.data(), expected_sha256.size());
   if (sha256 != expected_sha256) {
     LOG(ERROR) << "Transferred bytes hash ("
                << base::HexEncode(sha256.data(), sha256.size())
                << ") don't match the expected hash ("
                << manifest_->sanitized_image_sha256() << ").";
     TerminateInstallation();
     return;
   }
   LOG(INFO) << "Transferred bytes hash (" << manifest_->sanitized_image_sha256()
             << ") is valid.";

   processor_->ActionComplete(this, ErrorCode::kSuccess);
 }

 void InstallAction::TransferTerminated(HttpFetcher* fetcher) {
   LOG(ERROR) << "Failed to complete transfer.";
   TerminateInstallation();
 }

 void InstallAction::StartInstallation(const std::string& url_to_fetch,
                                       const std::string& sanitized_url) {
   LOG(INFO) << "Starting installation using URL=" << sanitized_url;
   offset_ = 0;
   hash_.reset(crypto::SecureHash::Create(crypto::SecureHash::SHA256));
   http_fetcher_->SetOffset(0);
   http_fetcher_->UnsetLength();
   http_fetcher_->BeginTransfer(url_to_fetch);
 }

 void InstallAction::TerminateInstallation() {
   processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
 }

 }  // namespace chromeos_update_engine
	// Copyright 2022 The ChromiumOS Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "update_engine/cros/install_action.h"

	#include <inttypes.h>

	#include <string>
	#include <utility>

	#include <base/files/file_path.h>
	#include <base/files/file_util.h>
	#include <base/logging.h>
	#include <base/strings/string_number_conversions.h>
	#include <chromeos/constants/imageloader.h>
	#include <crypto/secure_hash.h>
	#include <crypto/sha2.h>
	#include <libimageloader/manifest.h>

	#include "update_engine/common/boot_control.h"
	#include "update_engine/common/dlcservice_interface.h"
	#include "update_engine/common/system_state.h"
	#include "update_engine/common/utils.h"
	#include "update_engine/cros/image_properties.h"

	namespace chromeos_update_engine {

	namespace {
	constexpr char kBandaidUrl[] = "https://edgedl.me.gvt1.com/edgedl/dlc";
	constexpr char kLorryUrl[] = "https://dl.google.com/dlc";

	constexpr char kBandaidArtifactsMetaUrl[] = "https://edgedl.me.gvt1.com/edgedl";
	constexpr char kLorryArtifactsMetaUrl[] = "https://dl.google.com";

	constexpr char kUrlNameBandaid[] = "<BANDAID>";
	constexpr char kUrlNameLorry[] = "<LORRY>";

	constexpr char kUrlNameBandaidArtifactsMeta[] = "<BANDAID_ARTIFACTS_META>";
	constexpr char kUrlNameLorryArtifactsMeta[] = "<LORRY_ARTIFACTS_META>";

	constexpr char kDefaultArtifact[] = "dlc.img";
	constexpr char kDefaultPackage[] = "package";

	constexpr char kRedactedDlcPartition[] = "<REDACTED_PARTITION>";
	} // namespace

	const char kDefaultSlotting[] = "dlc-scaled";
	const char kForceOTASlotting[] = "dlc";

	InstallAction::InstallAction(std::unique_ptr<HttpFetcher> http_fetcher,
	const std::string& id,
	const std::string& slotting,
	const std::string& manifest_dir)
	: http_fetcher_(std::move(http_fetcher)), id_(id) {
	slotting_ = slotting.empty() ? kDefaultSlotting : slotting;
	manifest_dir_ =
	manifest_dir.empty() ? imageloader::kDlcManifestRootpath : manifest_dir;
	}

	InstallAction::~InstallAction() {}

	void InstallAction::PerformAction() {
	LOG(INFO) << "InstallAction performing action.";

	manifest_ = SystemState::Get()->dlc_utils()->GetDlcManifest(
	id_, base::FilePath(manifest_dir_));
	if (!manifest_) {
	LOG(ERROR) << "Could not retrieve manifest for " << id_;
	processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
	return;
	}
	image_props_ = LoadImageProperties();
	http_fetcher_->set_delegate(this);
	bool user_tied = manifest_->user_tied();
	if (user_tied)
	http_fetcher_->set_payload_info_visible(false);

	// Get the DLC device partition.
	auto partition_name =
	base::FilePath("dlc").Append(id_).Append(kDefaultPackage).value();
	auto* boot_control = SystemState::Get()->boot_control();

	std::string partition;
	const auto& sanitized_id = manifest_->sanitized_id();
	if (!boot_control->GetPartitionDevice(
	partition_name, boot_control->GetCurrentSlot(), &partition)) {
	LOG(ERROR) << "Could not retrieve device partition for " << sanitized_id;
	processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
	return;
	}
	const auto& sanitized_partition =
	user_tied ? kRedactedDlcPartition : partition;

	f_.Initialize(base::FilePath(partition), base::File::Flags::FLAG_OPEN \|
	base::File::Flags::FLAG_READ \|
	base::File::Flags::FLAG_WRITE);
	if (!f_.IsValid()) {
	LOG(ERROR) << "Could not open device partition for " << sanitized_id
	<< " at " << sanitized_partition;
	processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
	return;
	}
	LOG(INFO) << "Installing to " << sanitized_partition;

	std::string url_to_fetch;
	std::string sanitized_url;
	const auto& artifacts_meta = manifest_->artifacts_meta();
	if (artifacts_meta.valid) {
	auto UrlToFetch = [artifacts_meta](const std::string& url) -> std::string {
	return base::FilePath(url)
	.Append(artifacts_meta.uri)
	.Append(kDefaultArtifact)
	.value();
	};
	url_to_fetch = UrlToFetch(kBandaidArtifactsMetaUrl);
	sanitized_url = user_tied ? kUrlNameBandaidArtifactsMeta : url_to_fetch;
	backup_urls_ = {UrlToFetch(kLorryArtifactsMetaUrl)};
	backup_urls_sanitized_ =
	user_tied ? std::vector<std::string>({kUrlNameLorryArtifactsMeta})
	: backup_urls_;
	} else {
	auto UrlToFetch = [this](const std::string& url) -> std::string {
	return base::FilePath(url)
	.Append(image_props_.builder_path)
	.Append(slotting_)
	.Append(id_)
	.Append(kDefaultPackage)
	.Append(kDefaultArtifact)
	.value();
	};
	url_to_fetch = UrlToFetch(kBandaidUrl);
	sanitized_url = user_tied ? kUrlNameBandaid : url_to_fetch;
	backup_urls_ = {UrlToFetch(kLorryUrl)};
	backup_urls_sanitized_ =
	user_tied ? std::vector<std::string>({kUrlNameLorry}) : backup_urls_;
	}
	StartInstallation(url_to_fetch, sanitized_url);
	}

	void InstallAction::TerminateProcessing() {
	http_fetcher_->TerminateTransfer();
	}

	bool InstallAction::ReceivedBytes(HttpFetcher* fetcher,
	const void* bytes,
	size_t length) {
	uint64_t new_offset = offset_ + length;
	// Overflow upper bound check against manifest.
	if (new_offset > manifest_->size()) {
	LOG(ERROR) << "Overflow of bytes, terminating.";
	http_fetcher_->TerminateTransfer();
	return false;
	}

	if (delegate()) {
	delegate_->BytesReceived(new_offset, manifest_->size());
	}

	hash_->Update(bytes, length);
	int64_t total_written_bytes = 0;
	do {
	int written_bytes =
	f_.Write(offset_ + total_written_bytes,
	static_cast<const char*>(bytes) + total_written_bytes,
	length - total_written_bytes);
	if (written_bytes == -1) {
	PLOG(ERROR) << "Failed to write bytes.";
	http_fetcher_->TerminateTransfer();
	return false;
	}

	total_written_bytes += written_bytes;
	} while (total_written_bytes != length);

	offset_ = new_offset;
	return true;
	}

	void InstallAction::TransferComplete(HttpFetcher* fetcher, bool successful) {
	if (!successful) {
	// Continue to use backup URLs.
	if (backup_url_index_ < backup_urls_.size()) {
	LOG(INFO) << "Using backup url at index=" << backup_url_index_;
	const auto& url = backup_urls_[backup_url_index_];
	const auto& url_sanitized = backup_urls_sanitized_[backup_url_index_];
	++backup_url_index_;
	StartInstallation(url, url_sanitized);
	return;
	}
	LOG(ERROR) << "Transfer failed.";
	TerminateInstallation();
	return;
	}

	auto expected_offset = manifest_->size();
	if (offset_ != expected_offset) {
	LOG(ERROR) << "Transferred bytes offset (" << offset_
	<< ") don't match the expected offset ("
	<< manifest_->sanitized_size() << ").";
	TerminateInstallation();
	return;
	}
	LOG(INFO) << "Transferred bytes offset (" << manifest_->sanitized_size()
	<< ") is valid.";

	std::vector<uint8_t> sha256(crypto::kSHA256Length);
	hash_->Finish(sha256.data(), sha256.size());
	auto expected_sha256 = manifest_->image_sha256();
	auto expected_sha256_str =
	base::HexEncode(expected_sha256.data(), expected_sha256.size());
	if (sha256 != expected_sha256) {
	LOG(ERROR) << "Transferred bytes hash ("
	<< base::HexEncode(sha256.data(), sha256.size())
	<< ") don't match the expected hash ("
	<< manifest_->sanitized_image_sha256() << ").";
	TerminateInstallation();
	return;
	}
	LOG(INFO) << "Transferred bytes hash (" << manifest_->sanitized_image_sha256()
	<< ") is valid.";

	processor_->ActionComplete(this, ErrorCode::kSuccess);
	}

	void InstallAction::TransferTerminated(HttpFetcher* fetcher) {
	LOG(ERROR) << "Failed to complete transfer.";
	TerminateInstallation();
	}

	void InstallAction::StartInstallation(const std::string& url_to_fetch,
	const std::string& sanitized_url) {
	LOG(INFO) << "Starting installation using URL=" << sanitized_url;
	offset_ = 0;
	hash_.reset(crypto::SecureHash::Create(crypto::SecureHash::SHA256));
	http_fetcher_->SetOffset(0);
	http_fetcher_->UnsetLength();
	http_fetcher_->BeginTransfer(url_to_fetch);
	}

	void InstallAction::TerminateInstallation() {
	processor_->ActionComplete(this, ErrorCode::kScaledInstallationError);
	}

	} // namespace chromeos_update_engine