Alex Deymo | aea4c1c | 2015-08-19 20:24:43 -0700 | [diff] [blame] | 1 | // |
| 2 | // Copyright (C) 2011 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 | // |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 16 | |
| 17 | #include "update_engine/omaha_response_handler_action.h" |
Darin Petkov | 73058b4 | 2010-10-06 16:32:19 -0700 | [diff] [blame] | 18 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 19 | #include <string> |
Darin Petkov | 73058b4 | 2010-10-06 16:32:19 -0700 | [diff] [blame] | 20 | |
| 21 | #include <base/logging.h> |
Sen Jiang | 2703ef4 | 2017-03-16 13:36:21 -0700 | [diff] [blame] | 22 | #include <base/strings/string_number_conversions.h> |
Alex Vakulenko | 75039d7 | 2014-03-25 12:36:28 -0700 | [diff] [blame] | 23 | #include <base/strings/string_util.h> |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 24 | #include <policy/device_policy.h> |
Darin Petkov | 73058b4 | 2010-10-06 16:32:19 -0700 | [diff] [blame] | 25 | |
Alex Deymo | 39910dc | 2015-11-09 17:04:30 -0800 | [diff] [blame] | 26 | #include "update_engine/common/constants.h" |
| 27 | #include "update_engine/common/hardware_interface.h" |
| 28 | #include "update_engine/common/prefs_interface.h" |
| 29 | #include "update_engine/common/utils.h" |
Alex Deymo | f6ee016 | 2015-07-31 12:35:22 -0700 | [diff] [blame] | 30 | #include "update_engine/connection_manager_interface.h" |
Gilad Arnold | 1f84723 | 2014-04-07 12:07:49 -0700 | [diff] [blame] | 31 | #include "update_engine/omaha_request_params.h" |
Alex Deymo | 39910dc | 2015-11-09 17:04:30 -0800 | [diff] [blame] | 32 | #include "update_engine/payload_consumer/delta_performer.h" |
Jay Srinivasan | 55f50c2 | 2013-01-10 19:24:35 -0800 | [diff] [blame] | 33 | #include "update_engine/payload_state_interface.h" |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 34 | |
| 35 | using std::string; |
| 36 | |
| 37 | namespace chromeos_update_engine { |
| 38 | |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 39 | OmahaResponseHandlerAction::OmahaResponseHandlerAction( |
| 40 | SystemState* system_state) |
Alex Deymo | 6dd160a | 2015-10-09 18:45:14 -0700 | [diff] [blame] | 41 | : OmahaResponseHandlerAction(system_state, |
| 42 | constants::kOmahaResponseDeadlineFile) {} |
Gilad Arnold | 4dbd47e | 2013-07-22 05:39:26 -0700 | [diff] [blame] | 43 | |
| 44 | OmahaResponseHandlerAction::OmahaResponseHandlerAction( |
| 45 | SystemState* system_state, const string& deadline_file) |
| 46 | : system_state_(system_state), |
| 47 | got_no_update_response_(false), |
Alex Deymo | e6fc8e1 | 2015-09-28 14:02:17 -0700 | [diff] [blame] | 48 | key_path_(constants::kUpdatePayloadPublicKeyPath), |
Gilad Arnold | 4dbd47e | 2013-07-22 05:39:26 -0700 | [diff] [blame] | 49 | deadline_file_(deadline_file) {} |
Darin Petkov | abc7bc0 | 2011-02-23 14:39:43 -0800 | [diff] [blame] | 50 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 51 | void OmahaResponseHandlerAction::PerformAction() { |
| 52 | CHECK(HasInputObject()); |
| 53 | ScopedActionCompleter completer(processor_, this); |
Darin Petkov | 6a5b322 | 2010-07-13 14:55:28 -0700 | [diff] [blame] | 54 | const OmahaResponse& response = GetInputObject(); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 55 | if (!response.update_exists) { |
Andrew de los Reyes | 4fe15d0 | 2009-12-10 19:01:36 -0800 | [diff] [blame] | 56 | got_no_update_response_ = true; |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 57 | LOG(INFO) << "There are no updates. Aborting."; |
| 58 | return; |
| 59 | } |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 60 | |
| 61 | // All decisions as to which URL should be used have already been done. So, |
Jay Srinivasan | 53173b9 | 2013-05-17 17:13:01 -0700 | [diff] [blame] | 62 | // make the current URL as the download URL. |
| 63 | string current_url = system_state_->payload_state()->GetCurrentUrl(); |
| 64 | if (current_url.empty()) { |
| 65 | // This shouldn't happen as we should always supply the HTTPS backup URL. |
| 66 | // Handling this anyway, just in case. |
| 67 | LOG(ERROR) << "There are no suitable URLs in the response to use."; |
Gilad Arnold | d1c4d2d | 2014-06-05 14:07:53 -0700 | [diff] [blame] | 68 | completer.set_code(ErrorCode::kOmahaResponseInvalid); |
Jay Srinivasan | 53173b9 | 2013-05-17 17:13:01 -0700 | [diff] [blame] | 69 | return; |
| 70 | } |
| 71 | |
| 72 | install_plan_.download_url = current_url; |
Chris Sosa | fb1020e | 2013-07-29 17:27:33 -0700 | [diff] [blame] | 73 | install_plan_.version = response.version; |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 74 | |
Gilad Arnold | 74b5f55 | 2014-10-07 08:17:16 -0700 | [diff] [blame] | 75 | OmahaRequestParams* const params = system_state_->request_params(); |
| 76 | PayloadStateInterface* const payload_state = system_state_->payload_state(); |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 77 | |
| 78 | // If we're using p2p to download and there is a local peer, use it. |
Gilad Arnold | 74b5f55 | 2014-10-07 08:17:16 -0700 | [diff] [blame] | 79 | if (payload_state->GetUsingP2PForDownloading() && |
| 80 | !payload_state->GetP2PUrl().empty()) { |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 81 | LOG(INFO) << "Replacing URL " << install_plan_.download_url |
Gilad Arnold | 74b5f55 | 2014-10-07 08:17:16 -0700 | [diff] [blame] | 82 | << " with local URL " << payload_state->GetP2PUrl() |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 83 | << " since p2p is enabled."; |
Gilad Arnold | 74b5f55 | 2014-10-07 08:17:16 -0700 | [diff] [blame] | 84 | install_plan_.download_url = payload_state->GetP2PUrl(); |
| 85 | payload_state->SetUsingP2PForDownloading(true); |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 86 | } |
| 87 | |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 88 | // Fill up the other properties based on the response. |
Sen Jiang | 0affc2c | 2017-02-10 15:55:05 -0800 | [diff] [blame^] | 89 | string update_check_response_hash; |
| 90 | for (const auto& package : response.packages) { |
| 91 | brillo::Blob raw_hash; |
| 92 | if (!base::HexStringToBytes(package.hash, &raw_hash)) { |
| 93 | LOG(ERROR) << "Failed to convert payload hash from hex string to bytes: " |
| 94 | << package.hash; |
| 95 | completer.set_code(ErrorCode::kOmahaResponseInvalid); |
| 96 | return; |
| 97 | } |
| 98 | install_plan_.payloads.push_back( |
| 99 | {.size = package.size, |
| 100 | .metadata_size = package.metadata_size, |
| 101 | .metadata_signature = package.metadata_signature, |
| 102 | .hash = raw_hash}); |
| 103 | update_check_response_hash += package.hash + ":"; |
Sen Jiang | 2703ef4 | 2017-03-16 13:36:21 -0700 | [diff] [blame] | 104 | } |
David Zeuthen | e7f8917 | 2013-10-31 10:21:04 -0700 | [diff] [blame] | 105 | install_plan_.public_key_rsa = response.public_key_rsa; |
Jay Srinivasan | 738fdf3 | 2012-12-07 17:40:54 -0800 | [diff] [blame] | 106 | install_plan_.hash_checks_mandatory = AreHashChecksMandatory(response); |
Sen Jiang | 0affc2c | 2017-02-10 15:55:05 -0800 | [diff] [blame^] | 107 | install_plan_.is_resume = DeltaPerformer::CanResumeUpdate( |
| 108 | system_state_->prefs(), update_check_response_hash); |
Chris Sosa | be45bef | 2013-04-09 18:25:12 -0700 | [diff] [blame] | 109 | if (install_plan_.is_resume) { |
Gilad Arnold | 74b5f55 | 2014-10-07 08:17:16 -0700 | [diff] [blame] | 110 | payload_state->UpdateResumed(); |
Chris Sosa | be45bef | 2013-04-09 18:25:12 -0700 | [diff] [blame] | 111 | } else { |
Gilad Arnold | 74b5f55 | 2014-10-07 08:17:16 -0700 | [diff] [blame] | 112 | payload_state->UpdateRestarted(); |
Sen Jiang | 0affc2c | 2017-02-10 15:55:05 -0800 | [diff] [blame^] | 113 | LOG_IF(WARNING, |
| 114 | !DeltaPerformer::ResetUpdateProgress(system_state_->prefs(), false)) |
Darin Petkov | 0406e40 | 2010-10-06 21:33:11 -0700 | [diff] [blame] | 115 | << "Unable to reset the update progress."; |
Sen Jiang | 0affc2c | 2017-02-10 15:55:05 -0800 | [diff] [blame^] | 116 | LOG_IF(WARNING, |
| 117 | !system_state_->prefs()->SetString(kPrefsUpdateCheckResponseHash, |
| 118 | update_check_response_hash)) |
Darin Petkov | 0406e40 | 2010-10-06 21:33:11 -0700 | [diff] [blame] | 119 | << "Unable to save the update check response hash."; |
| 120 | } |
Alex Deymo | 64d9878 | 2016-02-05 18:03:48 -0800 | [diff] [blame] | 121 | install_plan_.payload_type = response.is_delta_payload |
| 122 | ? InstallPayloadType::kDelta |
| 123 | : InstallPayloadType::kFull; |
Darin Petkov | 0406e40 | 2010-10-06 21:33:11 -0700 | [diff] [blame] | 124 | |
Alex Deymo | 763e7db | 2015-08-27 21:08:08 -0700 | [diff] [blame] | 125 | install_plan_.source_slot = system_state_->boot_control()->GetCurrentSlot(); |
| 126 | install_plan_.target_slot = install_plan_.source_slot == 0 ? 1 : 0; |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 127 | |
Alex Deymo | 8561665 | 2015-10-15 18:48:31 -0700 | [diff] [blame] | 128 | // The Omaha response doesn't include the channel name for this image, so we |
| 129 | // use the download_channel we used during the request to tag the target slot. |
| 130 | // This will be used in the next boot to know the channel the image was |
| 131 | // downloaded from. |
| 132 | string current_channel_key = |
| 133 | kPrefsChannelOnSlotPrefix + std::to_string(install_plan_.target_slot); |
| 134 | system_state_->prefs()->SetString(current_channel_key, |
| 135 | params->download_channel()); |
| 136 | |
Jay Srinivasan | 1c0fe79 | 2013-03-28 16:45:25 -0700 | [diff] [blame] | 137 | if (params->to_more_stable_channel() && params->is_powerwash_allowed()) |
Jay Srinivasan | ae4697c | 2013-03-18 17:08:08 -0700 | [diff] [blame] | 138 | install_plan_.powerwash_required = true; |
Jay Srinivasan | 1c0fe79 | 2013-03-28 16:45:25 -0700 | [diff] [blame] | 139 | |
Andrew de los Reyes | f98bff8 | 2010-05-06 13:33:25 -0700 | [diff] [blame] | 140 | TEST_AND_RETURN(HasOutputPipe()); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 141 | if (HasOutputPipe()) |
Andrew de los Reyes | 63b96d7 | 2010-05-10 13:08:54 -0700 | [diff] [blame] | 142 | SetOutputObject(install_plan_); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 143 | LOG(INFO) << "Using this install plan:"; |
Andrew de los Reyes | 63b96d7 | 2010-05-10 13:08:54 -0700 | [diff] [blame] | 144 | install_plan_.Dump(); |
Darin Petkov | 6a5b322 | 2010-07-13 14:55:28 -0700 | [diff] [blame] | 145 | |
Darin Petkov | 6c11864 | 2010-10-21 12:06:30 -0700 | [diff] [blame] | 146 | // Send the deadline data (if any) to Chrome through a file. This is a pretty |
| 147 | // hacky solution but should be OK for now. |
| 148 | // |
Alex Vakulenko | 072359c | 2014-07-18 11:41:07 -0700 | [diff] [blame] | 149 | // TODO(petkov): Re-architect this to avoid communication through a |
Chris Sosa | be45bef | 2013-04-09 18:25:12 -0700 | [diff] [blame] | 150 | // file. Ideally, we would include this information in D-Bus's GetStatus |
Darin Petkov | 6c11864 | 2010-10-21 12:06:30 -0700 | [diff] [blame] | 151 | // method and UpdateStatus signal. A potential issue is that update_engine may |
| 152 | // be unresponsive during an update download. |
Alex Deymo | 6dd160a | 2015-10-09 18:45:14 -0700 | [diff] [blame] | 153 | if (!deadline_file_.empty()) { |
| 154 | utils::WriteFile(deadline_file_.c_str(), |
| 155 | response.deadline.data(), |
| 156 | response.deadline.size()); |
| 157 | chmod(deadline_file_.c_str(), S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH); |
| 158 | } |
Darin Petkov | 6c11864 | 2010-10-21 12:06:30 -0700 | [diff] [blame] | 159 | |
Gilad Arnold | d1c4d2d | 2014-06-05 14:07:53 -0700 | [diff] [blame] | 160 | completer.set_code(ErrorCode::kSuccess); |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 161 | } |
| 162 | |
Jay Srinivasan | 738fdf3 | 2012-12-07 17:40:54 -0800 | [diff] [blame] | 163 | bool OmahaResponseHandlerAction::AreHashChecksMandatory( |
| 164 | const OmahaResponse& response) { |
David Pursell | 907b4fa | 2015-01-27 10:27:38 -0800 | [diff] [blame] | 165 | // We sometimes need to waive the hash checks in order to download from |
| 166 | // sources that don't provide hashes, such as dev server. |
| 167 | // At this point UpdateAttempter::IsAnyUpdateSourceAllowed() has already been |
| 168 | // checked, so an unofficial update URL won't get this far unless it's OK to |
| 169 | // use without a hash. Additionally, we want to always waive hash checks on |
| 170 | // unofficial builds (i.e. dev/test images). |
| 171 | // The end result is this: |
| 172 | // * Base image: |
| 173 | // - Official URLs require a hash. |
| 174 | // - Unofficial URLs only get this far if the IsAnyUpdateSourceAllowed() |
| 175 | // devmode/debugd checks pass, in which case the hash is waived. |
| 176 | // * Dev/test image: |
| 177 | // - Any URL is allowed through with no hash checking. |
| 178 | if (!system_state_->request_params()->IsUpdateUrlOfficial() || |
| 179 | !system_state_->hardware()->IsOfficialBuild()) { |
David Pursell | 02c1864 | 2014-11-06 11:26:11 -0800 | [diff] [blame] | 180 | // Still do a hash check if a public key is included. |
David Zeuthen | e7f8917 | 2013-10-31 10:21:04 -0700 | [diff] [blame] | 181 | if (!response.public_key_rsa.empty()) { |
David Zeuthen | bc27aac | 2013-11-26 11:17:48 -0800 | [diff] [blame] | 182 | // The autoupdate_CatchBadSignatures test checks for this string |
| 183 | // in log-files. Keep in sync. |
David Zeuthen | e7f8917 | 2013-10-31 10:21:04 -0700 | [diff] [blame] | 184 | LOG(INFO) << "Mandating payload hash checks since Omaha Response " |
| 185 | << "for unofficial build includes public RSA key."; |
| 186 | return true; |
| 187 | } else { |
David Pursell | 02c1864 | 2014-11-06 11:26:11 -0800 | [diff] [blame] | 188 | LOG(INFO) << "Waiving payload hash checks for unofficial update URL."; |
David Zeuthen | e7f8917 | 2013-10-31 10:21:04 -0700 | [diff] [blame] | 189 | return false; |
| 190 | } |
Jay Srinivasan | 738fdf3 | 2012-12-07 17:40:54 -0800 | [diff] [blame] | 191 | } |
| 192 | |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 193 | // If we're using p2p, |install_plan_.download_url| may contain a |
| 194 | // HTTP URL even if |response.payload_urls| contain only HTTPS URLs. |
Alex Vakulenko | 0103c36 | 2016-01-20 07:56:15 -0800 | [diff] [blame] | 195 | if (!base::StartsWith(install_plan_.download_url, "https://", |
| 196 | base::CompareCase::INSENSITIVE_ASCII)) { |
David Zeuthen | 8f191b2 | 2013-08-06 12:27:50 -0700 | [diff] [blame] | 197 | LOG(INFO) << "Mandating hash checks since download_url is not HTTPS."; |
| 198 | return true; |
| 199 | } |
| 200 | |
Jay Srinivasan | 738fdf3 | 2012-12-07 17:40:54 -0800 | [diff] [blame] | 201 | // TODO(jaysri): VALIDATION: For official builds, we currently waive hash |
| 202 | // checks for HTTPS until we have rolled out at least once and are confident |
| 203 | // nothing breaks. chromium-os:37082 tracks turning this on for HTTPS |
| 204 | // eventually. |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 205 | |
| 206 | // Even if there's a single non-HTTPS URL, make the hash checks as |
| 207 | // mandatory because we could be downloading the payload from any URL later |
| 208 | // on. It's really hard to do book-keeping based on each byte being |
| 209 | // downloaded to see whether we only used HTTPS throughout. |
Sen Jiang | 0affc2c | 2017-02-10 15:55:05 -0800 | [diff] [blame^] | 210 | for (const auto& package : response.packages) { |
| 211 | for (const string& payload_url : package.payload_urls) { |
| 212 | if (!base::StartsWith( |
| 213 | payload_url, "https://", base::CompareCase::INSENSITIVE_ASCII)) { |
| 214 | LOG(INFO) << "Mandating payload hash checks since Omaha response " |
| 215 | << "contains non-HTTPS URL(s)"; |
| 216 | return true; |
| 217 | } |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 218 | } |
Jay Srinivasan | 738fdf3 | 2012-12-07 17:40:54 -0800 | [diff] [blame] | 219 | } |
| 220 | |
Jay Srinivasan | 6f6ea00 | 2012-12-14 11:26:28 -0800 | [diff] [blame] | 221 | LOG(INFO) << "Waiving payload hash checks since Omaha response " |
| 222 | << "only has HTTPS URL(s)"; |
| 223 | return false; |
Jay Srinivasan | 738fdf3 | 2012-12-07 17:40:54 -0800 | [diff] [blame] | 224 | } |
| 225 | |
adlr@google.com | 3defe6a | 2009-12-04 20:57:17 +0000 | [diff] [blame] | 226 | } // namespace chromeos_update_engine |