Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 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 | /* |
Tao Bao | 1cc0351 | 2018-04-18 17:10:49 -0700 | [diff] [blame] | 18 | * update_verifier verifies the integrity of the partitions after an A/B OTA update. It gets invoked |
| 19 | * by init, and will only perform the verification if it's the first boot post an A/B OTA update |
| 20 | * (https://source.android.com/devices/tech/ota/ab/#after_reboot). |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 21 | * |
Tao Bao | 1cc0351 | 2018-04-18 17:10:49 -0700 | [diff] [blame] | 22 | * update_verifier relies on device-mapper-verity (dm-verity) to capture any corruption on the |
| 23 | * partitions being verified (https://source.android.com/security/verifiedboot). The verification |
| 24 | * will be skipped, if dm-verity is not enabled on the device. |
| 25 | * |
| 26 | * Upon detecting verification failures, the device will be rebooted, although the trigger of the |
| 27 | * reboot depends on the dm-verity mode. |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 28 | * enforcing mode: dm-verity reboots the device |
| 29 | * eio mode: dm-verity fails the read and update_verifier reboots the device |
| 30 | * other mode: not supported and update_verifier reboots the device |
| 31 | * |
Tao Bao | 1cc0351 | 2018-04-18 17:10:49 -0700 | [diff] [blame] | 32 | * All these reboots prevent the device from booting into a known corrupt state. If the device |
| 33 | * continuously fails to boot into the new slot, the bootloader should mark the slot as unbootable |
| 34 | * and trigger a fallback to the old slot. |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 35 | * |
Tao Bao | 1cc0351 | 2018-04-18 17:10:49 -0700 | [diff] [blame] | 36 | * The current slot will be marked as having booted successfully if the verifier reaches the end |
| 37 | * after the verification. |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 38 | */ |
| 39 | |
Tao Bao | 83b0780 | 2017-04-26 14:30:56 -0700 | [diff] [blame] | 40 | #include "update_verifier/update_verifier.h" |
Daniel Rosenberg | 15f22bd | 2019-01-22 19:57:28 -0800 | [diff] [blame] | 41 | #include <android/os/IVold.h> |
Tao Bao | 83b0780 | 2017-04-26 14:30:56 -0700 | [diff] [blame] | 42 | |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 43 | #include <dirent.h> |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 44 | #include <errno.h> |
| 45 | #include <fcntl.h> |
| 46 | #include <stdio.h> |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 47 | #include <string.h> |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 48 | #include <unistd.h> |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 49 | |
Tianjie Xu | 8fa8f0b | 2017-04-27 11:47:35 -0700 | [diff] [blame] | 50 | #include <algorithm> |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 51 | #include <future> |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 52 | |
| 53 | #include <android-base/file.h> |
Tianjie Xu | 7b0ad9c | 2016-08-05 18:00:04 -0700 | [diff] [blame] | 54 | #include <android-base/logging.h> |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 55 | #include <android-base/parseint.h> |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 56 | #include <android-base/properties.h> |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 57 | #include <android-base/strings.h> |
| 58 | #include <android-base/unique_fd.h> |
Connor O'Brien | ad43d2d | 2016-11-21 12:47:33 -0800 | [diff] [blame] | 59 | #include <android/hardware/boot/1.0/IBootControl.h> |
Daniel Rosenberg | 15f22bd | 2019-01-22 19:57:28 -0800 | [diff] [blame] | 60 | #include <binder/BinderService.h> |
| 61 | #include <binder/Status.h> |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 62 | #include <cutils/android_reboot.h> |
Connor O'Brien | ad43d2d | 2016-11-21 12:47:33 -0800 | [diff] [blame] | 63 | |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 64 | #include "care_map.pb.h" |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 65 | |
Connor O'Brien | ad43d2d | 2016-11-21 12:47:33 -0800 | [diff] [blame] | 66 | using android::sp; |
| 67 | using android::hardware::boot::V1_0::IBootControl; |
| 68 | using android::hardware::boot::V1_0::BoolResult; |
| 69 | using android::hardware::boot::V1_0::CommandResult; |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 70 | |
xunchang | aab4b82 | 2019-03-13 14:21:48 -0700 | [diff] [blame] | 71 | // TODO(xunchang) remove the prefix and use a default path instead. |
Tianjie Xu | 9eed65e | 2018-09-14 12:52:02 -0700 | [diff] [blame] | 72 | constexpr const char* kDefaultCareMapPrefix = "/data/ota_package/care_map"; |
| 73 | |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 74 | // Find directories in format of "/sys/block/dm-X". |
| 75 | static int dm_name_filter(const dirent* de) { |
| 76 | if (android::base::StartsWith(de->d_name, "dm-")) { |
| 77 | return 1; |
| 78 | } |
| 79 | return 0; |
| 80 | } |
| 81 | |
Tianjie Xu | 9eed65e | 2018-09-14 12:52:02 -0700 | [diff] [blame] | 82 | UpdateVerifier::UpdateVerifier() |
| 83 | : care_map_prefix_(kDefaultCareMapPrefix), |
| 84 | property_reader_([](const std::string& id) { return android::base::GetProperty(id, ""); }) {} |
| 85 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 86 | // Iterate the content of "/sys/block/dm-X/dm/name" and find all the dm-wrapped block devices. |
| 87 | // We will later read all the ("cared") blocks from "/dev/block/dm-X" to ensure the target |
| 88 | // partition's integrity. |
| 89 | std::map<std::string, std::string> UpdateVerifier::FindDmPartitions() { |
Tao Bao | 83b0780 | 2017-04-26 14:30:56 -0700 | [diff] [blame] | 90 | static constexpr auto DM_PATH_PREFIX = "/sys/block/"; |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 91 | dirent** namelist; |
| 92 | int n = scandir(DM_PATH_PREFIX, &namelist, dm_name_filter, alphasort); |
| 93 | if (n == -1) { |
| 94 | PLOG(ERROR) << "Failed to scan dir " << DM_PATH_PREFIX; |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 95 | return {}; |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 96 | } |
| 97 | if (n == 0) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 98 | LOG(ERROR) << "No dm block device found."; |
| 99 | return {}; |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 100 | } |
| 101 | |
Tao Bao | 83b0780 | 2017-04-26 14:30:56 -0700 | [diff] [blame] | 102 | static constexpr auto DM_PATH_SUFFIX = "/dm/name"; |
| 103 | static constexpr auto DEV_PATH = "/dev/block/"; |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 104 | std::map<std::string, std::string> dm_block_devices; |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 105 | while (n--) { |
| 106 | std::string path = DM_PATH_PREFIX + std::string(namelist[n]->d_name) + DM_PATH_SUFFIX; |
| 107 | std::string content; |
| 108 | if (!android::base::ReadFileToString(path, &content)) { |
| 109 | PLOG(WARNING) << "Failed to read " << path; |
David Zeuthen | 8ed9738 | 2017-05-08 13:41:28 -0400 | [diff] [blame] | 110 | } else { |
| 111 | std::string dm_block_name = android::base::Trim(content); |
David Zeuthen | 8ed9738 | 2017-05-08 13:41:28 -0400 | [diff] [blame] | 112 | // AVB is using 'vroot' for the root block device but we're expecting 'system'. |
| 113 | if (dm_block_name == "vroot") { |
| 114 | dm_block_name = "system"; |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 115 | } |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 116 | |
| 117 | dm_block_devices.emplace(dm_block_name, DEV_PATH + std::string(namelist[n]->d_name)); |
Tianjie Xu | b0ac872 | 2017-01-18 18:41:53 -0800 | [diff] [blame] | 118 | } |
| 119 | free(namelist[n]); |
| 120 | } |
| 121 | free(namelist); |
| 122 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 123 | return dm_block_devices; |
| 124 | } |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 125 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 126 | bool UpdateVerifier::ReadBlocks(const std::string partition_name, |
| 127 | const std::string& dm_block_device, const RangeSet& ranges) { |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 128 | // RangeSet::Split() splits the ranges into multiple groups with same number of blocks (except for |
| 129 | // the last group). |
| 130 | size_t thread_num = std::thread::hardware_concurrency() ?: 4; |
| 131 | std::vector<RangeSet> groups = ranges.Split(thread_num); |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 132 | |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 133 | std::vector<std::future<bool>> threads; |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 134 | for (const auto& group : groups) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 135 | auto thread_func = [&group, &dm_block_device, &partition_name]() { |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 136 | android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(dm_block_device.c_str(), O_RDONLY))); |
| 137 | if (fd.get() == -1) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 138 | PLOG(ERROR) << "Error reading " << dm_block_device << " for partition " << partition_name; |
Tianjie Xu | 8fa8f0b | 2017-04-27 11:47:35 -0700 | [diff] [blame] | 139 | return false; |
| 140 | } |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 141 | |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 142 | static constexpr size_t kBlockSize = 4096; |
| 143 | std::vector<uint8_t> buf(1024 * kBlockSize); |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 144 | |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 145 | size_t block_count = 0; |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 146 | for (const auto& [range_start, range_end] : group) { |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 147 | if (lseek64(fd.get(), static_cast<off64_t>(range_start) * kBlockSize, SEEK_SET) == -1) { |
| 148 | PLOG(ERROR) << "lseek to " << range_start << " failed"; |
| 149 | return false; |
| 150 | } |
| 151 | |
| 152 | size_t remain = (range_end - range_start) * kBlockSize; |
| 153 | while (remain > 0) { |
| 154 | size_t to_read = std::min(remain, 1024 * kBlockSize); |
| 155 | if (!android::base::ReadFully(fd.get(), buf.data(), to_read)) { |
| 156 | PLOG(ERROR) << "Failed to read blocks " << range_start << " to " << range_end; |
| 157 | return false; |
| 158 | } |
| 159 | remain -= to_read; |
| 160 | } |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 161 | block_count += (range_end - range_start); |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 162 | } |
Tao Bao | 160514b | 2017-11-04 00:08:08 -0700 | [diff] [blame] | 163 | LOG(INFO) << "Finished reading " << block_count << " blocks on " << dm_block_device; |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 164 | return true; |
| 165 | }; |
| 166 | |
| 167 | threads.emplace_back(std::async(std::launch::async, thread_func)); |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 168 | } |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 169 | |
Wei Wang | 5226f47 | 2017-08-02 10:27:31 -0700 | [diff] [blame] | 170 | bool ret = true; |
| 171 | for (auto& t : threads) { |
| 172 | ret = t.get() && ret; |
| 173 | } |
| 174 | LOG(INFO) << "Finished reading blocks on " << dm_block_device << " with " << thread_num |
| 175 | << " threads."; |
| 176 | return ret; |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 177 | } |
| 178 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 179 | bool UpdateVerifier::VerifyPartitions() { |
| 180 | auto dm_block_devices = FindDmPartitions(); |
| 181 | if (dm_block_devices.empty()) { |
| 182 | LOG(ERROR) << "No dm-enabled block device is found."; |
Tao Bao | 5a1dee0 | 2017-07-21 15:15:31 -0700 | [diff] [blame] | 183 | return false; |
| 184 | } |
| 185 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 186 | for (const auto& [partition_name, ranges] : partition_map_) { |
| 187 | if (dm_block_devices.find(partition_name) == dm_block_devices.end()) { |
| 188 | LOG(ERROR) << "Failed to find dm block device for " << partition_name; |
| 189 | return false; |
Tao Bao | 5a1dee0 | 2017-07-21 15:15:31 -0700 | [diff] [blame] | 190 | } |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 191 | |
| 192 | if (!ReadBlocks(partition_name, dm_block_devices.at(partition_name), ranges)) { |
Tao Bao | 5a1dee0 | 2017-07-21 15:15:31 -0700 | [diff] [blame] | 193 | return false; |
| 194 | } |
| 195 | } |
| 196 | |
| 197 | return true; |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 198 | } |
| 199 | |
Tianjie Xu | 9eed65e | 2018-09-14 12:52:02 -0700 | [diff] [blame] | 200 | bool UpdateVerifier::ParseCareMap() { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 201 | partition_map_.clear(); |
| 202 | |
Tianjie Xu | 9eed65e | 2018-09-14 12:52:02 -0700 | [diff] [blame] | 203 | std::string care_map_name = care_map_prefix_ + ".pb"; |
| 204 | if (access(care_map_name.c_str(), R_OK) == -1) { |
xunchang | aab4b82 | 2019-03-13 14:21:48 -0700 | [diff] [blame] | 205 | LOG(ERROR) << care_map_name << " doesn't exist"; |
| 206 | return false; |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 209 | android::base::unique_fd care_map_fd(TEMP_FAILURE_RETRY(open(care_map_name.c_str(), O_RDONLY))); |
| 210 | // If the device is flashed before the current boot, it may not have care_map.txt in |
| 211 | // /data/ota_package. To allow the device to continue booting in this situation, we should |
| 212 | // print a warning and skip the block verification. |
| 213 | if (care_map_fd.get() == -1) { |
| 214 | PLOG(WARNING) << "Failed to open " << care_map_name; |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 215 | return false; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 216 | } |
| 217 | |
| 218 | std::string file_content; |
| 219 | if (!android::base::ReadFdToString(care_map_fd.get(), &file_content)) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 220 | PLOG(WARNING) << "Failed to read " << care_map_name; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 221 | return false; |
| 222 | } |
| 223 | |
| 224 | if (file_content.empty()) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 225 | LOG(WARNING) << "Unexpected empty care map"; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 226 | return false; |
| 227 | } |
| 228 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 229 | recovery_update_verifier::CareMap care_map; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 230 | if (!care_map.ParseFromString(file_content)) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 231 | LOG(WARNING) << "Failed to parse " << care_map_name << " in protobuf format."; |
| 232 | return false; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 233 | } |
| 234 | |
| 235 | for (const auto& partition : care_map.partitions()) { |
| 236 | if (partition.name().empty()) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 237 | LOG(WARNING) << "Unexpected empty partition name."; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 238 | return false; |
| 239 | } |
| 240 | if (partition.ranges().empty()) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 241 | LOG(WARNING) << "Unexpected block ranges for partition " << partition.name(); |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 242 | return false; |
| 243 | } |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 244 | RangeSet ranges = RangeSet::Parse(partition.ranges()); |
| 245 | if (!ranges) { |
| 246 | LOG(WARNING) << "Error parsing RangeSet string " << partition.ranges(); |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 247 | return false; |
| 248 | } |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 249 | |
Tianjie Xu | 9eed65e | 2018-09-14 12:52:02 -0700 | [diff] [blame] | 250 | // Continues to check other partitions if there is a fingerprint mismatch. |
| 251 | if (partition.id().empty() || partition.id() == "unknown") { |
| 252 | LOG(WARNING) << "Skip reading partition " << partition.name() |
| 253 | << ": property_id is not provided to get fingerprint."; |
| 254 | continue; |
| 255 | } |
| 256 | |
| 257 | std::string fingerprint = property_reader_(partition.id()); |
| 258 | if (fingerprint != partition.fingerprint()) { |
| 259 | LOG(WARNING) << "Skip reading partition " << partition.name() << ": fingerprint " |
| 260 | << fingerprint << " doesn't match the expected value " |
| 261 | << partition.fingerprint(); |
| 262 | continue; |
| 263 | } |
| 264 | |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 265 | partition_map_.emplace(partition.name(), ranges); |
| 266 | } |
| 267 | |
| 268 | if (partition_map_.empty()) { |
| 269 | LOG(WARNING) << "No partition to verify"; |
| 270 | return false; |
Tianjie Xu | 4d9e62d | 2018-05-11 10:41:44 -0700 | [diff] [blame] | 271 | } |
| 272 | |
| 273 | return true; |
| 274 | } |
| 275 | |
Tianjie Xu | 9eed65e | 2018-09-14 12:52:02 -0700 | [diff] [blame] | 276 | void UpdateVerifier::set_care_map_prefix(const std::string& prefix) { |
| 277 | care_map_prefix_ = prefix; |
| 278 | } |
| 279 | |
| 280 | void UpdateVerifier::set_property_reader( |
| 281 | const std::function<std::string(const std::string&)>& property_reader) { |
| 282 | property_reader_ = property_reader; |
| 283 | } |
| 284 | |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 285 | static int reboot_device() { |
| 286 | if (android_reboot(ANDROID_RB_RESTART2, 0, nullptr) == -1) { |
| 287 | LOG(ERROR) << "Failed to reboot."; |
| 288 | return -1; |
| 289 | } |
| 290 | while (true) pause(); |
| 291 | } |
| 292 | |
Tao Bao | 83b0780 | 2017-04-26 14:30:56 -0700 | [diff] [blame] | 293 | int update_verifier(int argc, char** argv) { |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 294 | for (int i = 1; i < argc; i++) { |
Tianjie Xu | 7b0ad9c | 2016-08-05 18:00:04 -0700 | [diff] [blame] | 295 | LOG(INFO) << "Started with arg " << i << ": " << argv[i]; |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 296 | } |
| 297 | |
Chris Phoenix | 0157c78 | 2017-01-20 11:34:00 -0800 | [diff] [blame] | 298 | sp<IBootControl> module = IBootControl::getService(); |
Connor O'Brien | ad43d2d | 2016-11-21 12:47:33 -0800 | [diff] [blame] | 299 | if (module == nullptr) { |
Tianjie Xu | 7b0ad9c | 2016-08-05 18:00:04 -0700 | [diff] [blame] | 300 | LOG(ERROR) << "Error getting bootctrl module."; |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 301 | return reboot_device(); |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 302 | } |
| 303 | |
Connor O'Brien | ad43d2d | 2016-11-21 12:47:33 -0800 | [diff] [blame] | 304 | uint32_t current_slot = module->getCurrentSlot(); |
| 305 | BoolResult is_successful = module->isSlotMarkedSuccessful(current_slot); |
| 306 | LOG(INFO) << "Booting slot " << current_slot << ": isSlotMarkedSuccessful=" |
| 307 | << static_cast<int32_t>(is_successful); |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 308 | |
Connor O'Brien | ad43d2d | 2016-11-21 12:47:33 -0800 | [diff] [blame] | 309 | if (is_successful == BoolResult::FALSE) { |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 310 | // The current slot has not booted successfully. |
Tao Bao | db57f0d | 2017-03-10 14:21:25 -0800 | [diff] [blame] | 311 | |
David Zeuthen | 1a0929c | 2017-08-07 18:47:27 -0400 | [diff] [blame] | 312 | bool skip_verification = false; |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 313 | std::string verity_mode = android::base::GetProperty("ro.boot.veritymode", ""); |
| 314 | if (verity_mode.empty()) { |
Tao Bao | 1cc0351 | 2018-04-18 17:10:49 -0700 | [diff] [blame] | 315 | // Skip the verification if ro.boot.veritymode property is not set. This could be a result |
| 316 | // that device doesn't support dm-verity, or has disabled that. |
| 317 | LOG(WARNING) << "dm-verity not enabled; marking without verification."; |
David Zeuthen | 1a0929c | 2017-08-07 18:47:27 -0400 | [diff] [blame] | 318 | skip_verification = true; |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 319 | } else if (android::base::EqualsIgnoreCase(verity_mode, "eio")) { |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 320 | // We shouldn't see verity in EIO mode if the current slot hasn't booted successfully before. |
| 321 | // Continue the verification until we fail to read some blocks. |
| 322 | LOG(WARNING) << "Found dm-verity in EIO mode."; |
David Zeuthen | 1a0929c | 2017-08-07 18:47:27 -0400 | [diff] [blame] | 323 | } else if (android::base::EqualsIgnoreCase(verity_mode, "disabled")) { |
| 324 | LOG(WARNING) << "dm-verity in disabled mode; marking without verification."; |
| 325 | skip_verification = true; |
Tao Bao | 4f8d217 | 2017-01-13 15:36:32 -0800 | [diff] [blame] | 326 | } else if (verity_mode != "enforcing") { |
Tao Bao | 1cc0351 | 2018-04-18 17:10:49 -0700 | [diff] [blame] | 327 | LOG(ERROR) << "Unexpected dm-verity mode: " << verity_mode << ", expecting enforcing."; |
Tianjie Xu | 3958a95 | 2017-03-01 15:31:25 -0800 | [diff] [blame] | 328 | return reboot_device(); |
| 329 | } |
| 330 | |
David Zeuthen | 1a0929c | 2017-08-07 18:47:27 -0400 | [diff] [blame] | 331 | if (!skip_verification) { |
Tianjie Xu | 446b64b | 2018-09-19 15:45:28 -0700 | [diff] [blame] | 332 | UpdateVerifier verifier; |
| 333 | if (!verifier.ParseCareMap()) { |
| 334 | LOG(WARNING) << "Failed to parse the care map file, skipping verification"; |
| 335 | } else if (!verifier.VerifyPartitions()) { |
David Zeuthen | 1a0929c | 2017-08-07 18:47:27 -0400 | [diff] [blame] | 336 | LOG(ERROR) << "Failed to verify all blocks in care map file."; |
| 337 | return reboot_device(); |
| 338 | } |
Tianjie Xu | d007cf2 | 2016-02-29 16:08:06 -0800 | [diff] [blame] | 339 | } |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 340 | |
Daniel Rosenberg | 15f22bd | 2019-01-22 19:57:28 -0800 | [diff] [blame] | 341 | bool supports_checkpoint = false; |
| 342 | auto sm = android::defaultServiceManager(); |
| 343 | android::sp<android::IBinder> binder = sm->getService(android::String16("vold")); |
| 344 | if (binder) { |
| 345 | auto vold = android::interface_cast<android::os::IVold>(binder); |
| 346 | android::binder::Status status = vold->supportsCheckpoint(&supports_checkpoint); |
| 347 | if (!status.isOk()) { |
| 348 | LOG(ERROR) << "Failed to check if checkpoints supported. Continuing"; |
| 349 | } |
| 350 | } else { |
| 351 | LOG(ERROR) << "Failed to obtain vold Binder. Continuing"; |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 352 | } |
Daniel Rosenberg | 15f22bd | 2019-01-22 19:57:28 -0800 | [diff] [blame] | 353 | |
| 354 | if (!supports_checkpoint) { |
| 355 | CommandResult cr; |
| 356 | module->markBootSuccessful([&cr](CommandResult result) { cr = result; }); |
| 357 | if (!cr.success) { |
| 358 | LOG(ERROR) << "Error marking booted successfully: " << cr.errMsg; |
| 359 | return reboot_device(); |
| 360 | } |
| 361 | LOG(INFO) << "Marked slot " << current_slot << " as booted successfully."; |
| 362 | } else { |
| 363 | LOG(INFO) << "Deferred marking slot " << current_slot << " as booted successfully."; |
| 364 | } |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 365 | } |
| 366 | |
Tianjie Xu | 7b0ad9c | 2016-08-05 18:00:04 -0700 | [diff] [blame] | 367 | LOG(INFO) << "Leaving update_verifier."; |
Tao Bao | 7197ee0 | 2015-12-05 21:21:27 -0800 | [diff] [blame] | 368 | return 0; |
| 369 | } |