1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Permission is hereby granted, free of charge, to any person 5 * obtaining a copy of this software and associated documentation 6 * files (the "Software"), to deal in the Software without 7 * restriction, including without limitation the rights to use, copy, 8 * modify, merge, publish, distribute, sublicense, and/or sell copies 9 * of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 */ 24 #include <common.h> 25 #include <android_image.h> 26 #include <android_avb/avb_slot_verify.h> 27 #include <android_avb/avb_chain_partition_descriptor.h> 28 #include <android_avb/avb_cmdline.h> 29 #include <android_avb/avb_footer.h> 30 #include <android_avb/avb_hash_descriptor.h> 31 #include <android_avb/avb_hashtree_descriptor.h> 32 #include <android_avb/avb_kernel_cmdline_descriptor.h> 33 #include <android_avb/avb_ops_user.h> 34 #include <android_avb/avb_sha.h> 35 #include <android_avb/avb_util.h> 36 #include <android_avb/avb_vbmeta_image.h> 37 #include <android_avb/avb_version.h> 38 39 /* Maximum number of partitions that can be loaded with avb_slot_verify(). */ 40 #define MAX_NUMBER_OF_LOADED_PARTITIONS 32 41 42 /* Maximum number of vbmeta images that can be loaded with avb_slot_verify(). */ 43 #define MAX_NUMBER_OF_VBMETA_IMAGES 32 44 45 /* Maximum size of a vbmeta image - 64 KiB. */ 46 #define VBMETA_MAX_SIZE (64 * 1024) 47 48 static AvbSlotVerifyResult initialize_persistent_digest( 49 AvbOps* ops, 50 const char* part_name, 51 const char* persistent_value_name, 52 size_t digest_size, 53 const uint8_t* initial_digest, 54 uint8_t* out_digest); 55 56 /* Helper function to see if we should continue with verification in 57 * allow_verification_error=true mode if something goes wrong. See the 58 * comments for the avb_slot_verify() function for more information. 59 */ 60 static inline bool result_should_continue(AvbSlotVerifyResult result) { 61 switch (result) { 62 case AVB_SLOT_VERIFY_RESULT_ERROR_OOM: 63 case AVB_SLOT_VERIFY_RESULT_ERROR_IO: 64 case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA: 65 case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION: 66 case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT: 67 return false; 68 69 case AVB_SLOT_VERIFY_RESULT_OK: 70 case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION: 71 case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX: 72 case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED: 73 return true; 74 } 75 76 return false; 77 } 78 79 static AvbSlotVerifyResult load_full_partition(AvbOps* ops, 80 const char* part_name, 81 uint64_t image_size, 82 uint8_t** out_image_buf, 83 bool* out_image_preloaded, 84 int allow_verification_error) { 85 size_t part_num_read; 86 AvbIOResult io_ret; 87 88 /* Make sure that we do not overwrite existing data. */ 89 avb_assert(*out_image_buf == NULL); 90 avb_assert(!*out_image_preloaded); 91 92 /* We are going to implicitly cast image_size from uint64_t to size_t in the 93 * following code, so we need to make sure that the cast is safe. */ 94 if (image_size != (size_t)(image_size)) { 95 avb_errorv(part_name, ": Partition size too large to load.\n", NULL); 96 return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 97 } 98 99 /* Try use a preloaded one. */ 100 if (ops->get_preloaded_partition != NULL) { 101 io_ret = ops->get_preloaded_partition( 102 ops, part_name, image_size, out_image_buf, &part_num_read, 103 allow_verification_error); 104 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 105 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 106 } else if (io_ret != AVB_IO_RESULT_OK) { 107 avb_errorv(part_name, ": Error loading data from partition.\n", NULL); 108 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 109 } 110 111 if (*out_image_buf != NULL) { 112 if (part_num_read != image_size) { 113 avb_errorv(part_name, ": Read incorrect number of bytes.\n", NULL); 114 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 115 } 116 *out_image_preloaded = true; 117 } 118 } 119 120 /* Allocate and copy the partition. */ 121 if (!*out_image_preloaded) { 122 *out_image_buf = avb_malloc(image_size); 123 if (*out_image_buf == NULL) { 124 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 125 } 126 127 io_ret = ops->read_from_partition(ops, 128 part_name, 129 0 /* offset */, 130 image_size, 131 *out_image_buf, 132 &part_num_read); 133 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 134 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 135 } else if (io_ret != AVB_IO_RESULT_OK) { 136 avb_errorv(part_name, ": Error loading data from partition.\n", NULL); 137 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 138 } 139 if (part_num_read != image_size) { 140 avb_errorv(part_name, ": Read incorrect number of bytes.\n", NULL); 141 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 142 } 143 } 144 145 return AVB_SLOT_VERIFY_RESULT_OK; 146 } 147 148 /* Reads a persistent digest stored as a named persistent value corresponding to 149 * the given |part_name|. The value is returned in |out_digest| which must point 150 * to |expected_digest_size| bytes. If there is no digest stored for |part_name| 151 * it can be initialized by providing a non-NULL |initial_digest| of length 152 * |expected_digest_size|. This automatic initialization will only occur if the 153 * device is currently locked. The |initial_digest| may be NULL. 154 * 155 * Returns AVB_SLOT_VERIFY_RESULT_OK on success, otherwise returns an 156 * AVB_SLOT_VERIFY_RESULT_ERROR_* error code. 157 * 158 * If the value does not exist, is not supported, or is not populated, and 159 * |initial_digest| is NULL, returns 160 * AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA. If |expected_digest_size| does 161 * not match the stored digest size, also returns 162 * AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA. 163 */ 164 static AvbSlotVerifyResult read_persistent_digest(AvbOps* ops, 165 const char* part_name, 166 size_t expected_digest_size, 167 const uint8_t* initial_digest, 168 uint8_t* out_digest) { 169 char* persistent_value_name = NULL; 170 AvbIOResult io_ret = AVB_IO_RESULT_OK; 171 size_t stored_digest_size = 0; 172 173 if (ops->read_persistent_value == NULL) { 174 avb_errorv(part_name, ": Persistent values are not implemented.\n", NULL); 175 return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 176 } 177 persistent_value_name = 178 avb_strdupv(AVB_NPV_PERSISTENT_DIGEST_PREFIX, part_name, NULL); 179 if (persistent_value_name == NULL) { 180 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 181 } 182 183 io_ret = ops->read_persistent_value(ops, 184 persistent_value_name, 185 expected_digest_size, 186 out_digest, 187 &stored_digest_size); 188 189 // If no such named persistent value exists and an initial digest value was 190 // given, initialize the named persistent value with the given digest. If 191 // initialized successfully, this will recurse into this function but with a 192 // NULL initial_digest. 193 if (io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_VALUE && initial_digest) { 194 AvbSlotVerifyResult ret = 195 initialize_persistent_digest(ops, 196 part_name, 197 persistent_value_name, 198 expected_digest_size, 199 initial_digest, 200 out_digest); 201 avb_free(persistent_value_name); 202 return ret; 203 } 204 avb_free(persistent_value_name); 205 206 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 207 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 208 } else if (io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_VALUE) { 209 // Treat a missing persistent value as a verification error, which is 210 // ignoreable, rather than a metadata error which is not. 211 avb_errorv(part_name, ": Persistent digest does not exist.\n", NULL); 212 return AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION; 213 } else if (io_ret == AVB_IO_RESULT_ERROR_INVALID_VALUE_SIZE || 214 io_ret == AVB_IO_RESULT_ERROR_INSUFFICIENT_SPACE) { 215 avb_errorv( 216 part_name, ": Persistent digest is not of expected size.\n", NULL); 217 return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 218 } else if (io_ret != AVB_IO_RESULT_OK) { 219 avb_errorv(part_name, ": Error reading persistent digest.\n", NULL); 220 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 221 } else if (expected_digest_size != stored_digest_size) { 222 avb_errorv( 223 part_name, ": Persistent digest is not of expected size.\n", NULL); 224 return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 225 } 226 return AVB_SLOT_VERIFY_RESULT_OK; 227 } 228 229 static AvbSlotVerifyResult initialize_persistent_digest( 230 AvbOps* ops, 231 const char* part_name, 232 const char* persistent_value_name, 233 size_t digest_size, 234 const uint8_t* initial_digest, 235 uint8_t* out_digest) { 236 AvbSlotVerifyResult ret; 237 AvbIOResult io_ret = AVB_IO_RESULT_OK; 238 bool is_device_unlocked = true; 239 240 io_ret = ops->read_is_device_unlocked(ops, &is_device_unlocked); 241 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 242 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 243 } else if (io_ret != AVB_IO_RESULT_OK) { 244 avb_error("Error getting device lock state.\n"); 245 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 246 } 247 248 if (is_device_unlocked) { 249 avb_debugv(part_name, 250 ": Digest does not exist, device unlocked so not initializing " 251 "digest.\n", 252 NULL); 253 return AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION; 254 } 255 256 // Device locked; initialize digest with given initial value. 257 avb_debugv(part_name, 258 ": Digest does not exist, initializing persistent digest.\n", 259 NULL); 260 io_ret = ops->write_persistent_value( 261 ops, persistent_value_name, digest_size, initial_digest); 262 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 263 return AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 264 } else if (io_ret != AVB_IO_RESULT_OK) { 265 avb_errorv(part_name, ": Error initializing persistent digest.\n", NULL); 266 return AVB_SLOT_VERIFY_RESULT_ERROR_IO; 267 } 268 269 // To ensure that the digest value was written successfully - and avoid a 270 // scenario where the digest is simply 'initialized' on every verify - recurse 271 // into read_persistent_digest to read back the written value. The NULL 272 // initial_digest ensures that this will not recurse again. 273 ret = read_persistent_digest(ops, part_name, digest_size, NULL, out_digest); 274 if (ret != AVB_SLOT_VERIFY_RESULT_OK) { 275 avb_errorv(part_name, 276 ": Reading back initialized persistent digest failed!\n", 277 NULL); 278 } 279 return ret; 280 } 281 282 static AvbSlotVerifyResult load_and_verify_hash_partition( 283 AvbOps* ops, 284 const char* const* requested_partitions, 285 const char* ab_suffix, 286 bool allow_verification_error, 287 const AvbDescriptor* descriptor, 288 AvbSlotVerifyData* slot_data) { 289 AvbHashDescriptor hash_desc; 290 const uint8_t* desc_partition_name = NULL; 291 const uint8_t* desc_salt; 292 const uint8_t* desc_digest; 293 char part_name[AVB_PART_NAME_MAX_SIZE]; 294 AvbSlotVerifyResult ret; 295 AvbIOResult io_ret; 296 uint8_t* image_buf = NULL; 297 bool image_preloaded = false; 298 uint8_t* digest; 299 size_t digest_len; 300 const char* found; 301 uint64_t image_size; 302 size_t expected_digest_len = 0; 303 uint8_t expected_digest_buf[AVB_SHA512_DIGEST_SIZE]; 304 const uint8_t* expected_digest = NULL; 305 306 if (!avb_hash_descriptor_validate_and_byteswap( 307 (const AvbHashDescriptor*)descriptor, &hash_desc)) { 308 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 309 goto out; 310 } 311 312 desc_partition_name = 313 ((const uint8_t*)descriptor) + sizeof(AvbHashDescriptor); 314 desc_salt = desc_partition_name + hash_desc.partition_name_len; 315 desc_digest = desc_salt + hash_desc.salt_len; 316 317 if (!avb_validate_utf8(desc_partition_name, hash_desc.partition_name_len)) { 318 avb_error("Partition name is not valid UTF-8.\n"); 319 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 320 goto out; 321 } 322 323 /* Don't bother loading or validating unless the partition was 324 * requested in the first place. 325 */ 326 found = avb_strv_find_str(requested_partitions, 327 (const char*)desc_partition_name, 328 hash_desc.partition_name_len); 329 if (found == NULL) { 330 ret = AVB_SLOT_VERIFY_RESULT_OK; 331 goto out; 332 } 333 334 if ((hash_desc.flags & AVB_HASH_DESCRIPTOR_FLAGS_DO_NOT_USE_AB) != 0) { 335 /* No ab_suffix, just copy the partition name as is. */ 336 if (hash_desc.partition_name_len >= AVB_PART_NAME_MAX_SIZE) { 337 avb_error("Partition name does not fit.\n"); 338 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 339 goto out; 340 } 341 avb_memcpy(part_name, desc_partition_name, hash_desc.partition_name_len); 342 part_name[hash_desc.partition_name_len] = '\0'; 343 } else if (hash_desc.digest_len == 0 && avb_strlen(ab_suffix) != 0) { 344 /* No ab_suffix allowed for partitions without a digest in the descriptor 345 * because these partitions hold data unique to this device and are not 346 * updated using an A/B scheme. 347 */ 348 avb_error("Cannot use A/B with a persistent digest.\n"); 349 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 350 goto out; 351 } else { 352 /* Add ab_suffix to the partition name. */ 353 if (!avb_str_concat(part_name, 354 sizeof part_name, 355 (const char*)desc_partition_name, 356 hash_desc.partition_name_len, 357 ab_suffix, 358 avb_strlen(ab_suffix))) { 359 avb_error("Partition name and suffix does not fit.\n"); 360 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 361 goto out; 362 } 363 } 364 365 /* If we're allowing verification errors then hash_desc.image_size 366 * may no longer match what's in the partition... so in this case 367 * just load the entire partition. 368 * 369 * For example, this can happen if a developer does 'fastboot flash 370 * boot /path/to/new/and/bigger/boot.img'. We want this to work 371 * since it's such a common workflow. 372 */ 373 image_size = hash_desc.image_size; 374 if (allow_verification_error) { 375 io_ret = ops->get_size_of_partition(ops, part_name, &image_size); 376 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 377 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 378 goto out; 379 } else if (io_ret != AVB_IO_RESULT_OK) { 380 avb_errorv(part_name, ": Error determining partition size.\n", NULL); 381 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 382 goto out; 383 } 384 avb_debugv(part_name, ": Loading entire partition.\n", NULL); 385 } 386 387 ret = load_full_partition( 388 ops, part_name, image_size, &image_buf, &image_preloaded, 389 allow_verification_error); 390 if (ret != AVB_SLOT_VERIFY_RESULT_OK) { 391 goto out; 392 } else if (allow_verification_error) { 393 goto out; 394 } 395 396 // Although only one of the type might be used, we have to defined the 397 // structure here so that they would live outside the 'if/else' scope to be 398 // used later. 399 AvbSHA256Ctx sha256_ctx; 400 AvbSHA512Ctx sha512_ctx; 401 size_t image_size_to_hash = hash_desc.image_size; 402 // If we allow verification error and the whole partition is smaller than 403 // image size in hash descriptor, we just hash the whole partition. 404 if (image_size_to_hash > image_size) { 405 image_size_to_hash = image_size; 406 } 407 if (avb_strcmp((const char*)hash_desc.hash_algorithm, "sha256") == 0) { 408 sha256_ctx.tot_len = hash_desc.salt_len + image_size_to_hash; 409 avb_sha256_init(&sha256_ctx); 410 avb_sha256_update(&sha256_ctx, desc_salt, hash_desc.salt_len); 411 avb_sha256_update(&sha256_ctx, image_buf, image_size_to_hash); 412 digest = avb_sha256_final(&sha256_ctx); 413 digest_len = AVB_SHA256_DIGEST_SIZE; 414 } else if (avb_strcmp((const char*)hash_desc.hash_algorithm, "sha512") == 0) { 415 sha512_ctx.tot_len = hash_desc.salt_len + image_size_to_hash; 416 avb_sha512_init(&sha512_ctx); 417 avb_sha512_update(&sha512_ctx, desc_salt, hash_desc.salt_len); 418 avb_sha512_update(&sha512_ctx, image_buf, image_size_to_hash); 419 digest = avb_sha512_final(&sha512_ctx); 420 digest_len = AVB_SHA512_DIGEST_SIZE; 421 } else { 422 avb_errorv(part_name, ": Unsupported hash algorithm.\n", NULL); 423 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 424 goto out; 425 } 426 427 if (hash_desc.digest_len == 0) { 428 /* Expect a match to a persistent digest. */ 429 avb_debugv(part_name, ": No digest, using persistent digest.\n", NULL); 430 expected_digest_len = digest_len; 431 expected_digest = expected_digest_buf; 432 avb_assert(expected_digest_len <= sizeof(expected_digest_buf)); 433 /* Pass |digest| as the |initial_digest| so devices not yet initialized get 434 * initialized to the current partition digest. 435 */ 436 ret = read_persistent_digest( 437 ops, part_name, digest_len, digest, expected_digest_buf); 438 if (ret != AVB_SLOT_VERIFY_RESULT_OK) { 439 goto out; 440 } 441 } else { 442 /* Expect a match to the digest in the descriptor. */ 443 expected_digest_len = hash_desc.digest_len; 444 expected_digest = desc_digest; 445 } 446 447 if (digest_len != expected_digest_len) { 448 avb_errorv( 449 part_name, ": Digest in descriptor not of expected size.\n", NULL); 450 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 451 goto out; 452 } 453 454 if (avb_safe_memcmp(digest, expected_digest, digest_len) != 0) { 455 avb_errorv(part_name, 456 ": Hash of data does not match digest in descriptor.\n", 457 NULL); 458 ret = AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION; 459 goto out; 460 } 461 462 ret = AVB_SLOT_VERIFY_RESULT_OK; 463 464 out: 465 466 /* If it worked and something was loaded, copy to slot_data. */ 467 if ((ret == AVB_SLOT_VERIFY_RESULT_OK || result_should_continue(ret)) && 468 image_buf != NULL) { 469 AvbPartitionData* loaded_partition; 470 if (slot_data->num_loaded_partitions == MAX_NUMBER_OF_LOADED_PARTITIONS) { 471 avb_errorv(part_name, ": Too many loaded partitions.\n", NULL); 472 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 473 goto fail; 474 } 475 loaded_partition = 476 &slot_data->loaded_partitions[slot_data->num_loaded_partitions++]; 477 loaded_partition->partition_name = avb_strdup(found); 478 loaded_partition->data_size = image_size; 479 loaded_partition->data = image_buf; 480 loaded_partition->preloaded = image_preloaded; 481 image_buf = NULL; 482 } 483 484 fail: 485 if (image_buf != NULL && !image_preloaded) { 486 avb_free(image_buf); 487 } 488 return ret; 489 } 490 491 static AvbSlotVerifyResult load_requested_partitions( 492 AvbOps* ops, 493 const char* const* requested_partitions, 494 const char* ab_suffix, 495 AvbSlotVerifyData* slot_data) { 496 AvbSlotVerifyResult ret; 497 uint8_t* image_buf = NULL; 498 bool image_preloaded = false; 499 size_t n; 500 501 for (n = 0; requested_partitions[n] != NULL; n++) { 502 char part_name[AVB_PART_NAME_MAX_SIZE]; 503 AvbIOResult io_ret; 504 uint64_t image_size; 505 AvbPartitionData* loaded_partition; 506 507 if (!avb_str_concat(part_name, 508 sizeof part_name, 509 requested_partitions[n], 510 avb_strlen(requested_partitions[n]), 511 ab_suffix, 512 avb_strlen(ab_suffix))) { 513 avb_error("Partition name and suffix does not fit.\n"); 514 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 515 goto out; 516 } 517 518 io_ret = ops->get_size_of_partition(ops, part_name, &image_size); 519 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 520 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 521 goto out; 522 } else if (io_ret != AVB_IO_RESULT_OK) { 523 avb_errorv(part_name, ": Error determining partition size.\n", NULL); 524 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 525 goto out; 526 } 527 avb_debugv(part_name, ": Loading entire partition.\n", NULL); 528 529 ret = load_full_partition( 530 ops, part_name, image_size, &image_buf, &image_preloaded, 1); 531 if (ret != AVB_SLOT_VERIFY_RESULT_OK) { 532 goto out; 533 } 534 535 /* Move to slot_data. */ 536 if (slot_data->num_loaded_partitions == MAX_NUMBER_OF_LOADED_PARTITIONS) { 537 avb_errorv(part_name, ": Too many loaded partitions.\n", NULL); 538 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 539 goto out; 540 } 541 loaded_partition = 542 &slot_data->loaded_partitions[slot_data->num_loaded_partitions++]; 543 loaded_partition->partition_name = avb_strdup(requested_partitions[n]); 544 if (loaded_partition->partition_name == NULL) { 545 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 546 goto out; 547 } 548 loaded_partition->data_size = image_size; 549 loaded_partition->data = image_buf; /* Transferring the owner. */ 550 loaded_partition->preloaded = image_preloaded; 551 image_buf = NULL; 552 image_preloaded = false; 553 } 554 555 ret = AVB_SLOT_VERIFY_RESULT_OK; 556 557 out: 558 /* Free the current buffer if any. */ 559 if (image_buf != NULL && !image_preloaded) { 560 avb_free(image_buf); 561 } 562 /* Buffers that are already saved in slot_data will be handled by the caller 563 * even on failure. */ 564 return ret; 565 } 566 567 static AvbSlotVerifyResult load_and_verify_vbmeta( 568 AvbOps* ops, 569 const char* const* requested_partitions, 570 const char* ab_suffix, 571 AvbSlotVerifyFlags flags, 572 bool allow_verification_error, 573 AvbVBMetaImageFlags toplevel_vbmeta_flags, 574 int rollback_index_location, 575 const char* partition_name, 576 size_t partition_name_len, 577 const uint8_t* expected_public_key, 578 size_t expected_public_key_length, 579 AvbSlotVerifyData* slot_data, 580 AvbAlgorithmType* out_algorithm_type, 581 AvbCmdlineSubstList* out_additional_cmdline_subst) { 582 char full_partition_name[AVB_PART_NAME_MAX_SIZE]; 583 AvbSlotVerifyResult ret; 584 AvbIOResult io_ret; 585 uint64_t vbmeta_offset; 586 size_t vbmeta_size; 587 uint8_t* vbmeta_buf = NULL; 588 size_t vbmeta_num_read; 589 AvbVBMetaVerifyResult vbmeta_ret; 590 const uint8_t* pk_data; 591 size_t pk_len; 592 AvbVBMetaImageHeader vbmeta_header; 593 uint64_t stored_rollback_index; 594 const AvbDescriptor** descriptors = NULL; 595 size_t num_descriptors; 596 size_t n; 597 bool is_main_vbmeta; 598 bool look_for_vbmeta_footer; 599 AvbVBMetaData* vbmeta_image_data = NULL; 600 601 ret = AVB_SLOT_VERIFY_RESULT_OK; 602 603 avb_assert(slot_data != NULL); 604 605 /* Since we allow top-level vbmeta in 'boot', use 606 * rollback_index_location to determine whether we're the main 607 * vbmeta struct. 608 */ 609 is_main_vbmeta = false; 610 if (rollback_index_location == 0) { 611 if ((flags & AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION) == 0) { 612 is_main_vbmeta = true; 613 } 614 } 615 616 /* Don't use footers for vbmeta partitions ('vbmeta' or 617 * 'vbmeta_<partition_name>'). 618 */ 619 look_for_vbmeta_footer = true; 620 if (avb_strncmp(partition_name, "vbmeta", avb_strlen("vbmeta")) == 0) { 621 look_for_vbmeta_footer = false; 622 } 623 624 if (!avb_validate_utf8((const uint8_t*)partition_name, partition_name_len)) { 625 avb_error("Partition name is not valid UTF-8.\n"); 626 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 627 goto out; 628 } 629 630 /* Construct full partition name e.g. system_a. */ 631 if (!avb_str_concat(full_partition_name, 632 sizeof full_partition_name, 633 partition_name, 634 partition_name_len, 635 ab_suffix, 636 avb_strlen(ab_suffix))) { 637 avb_error("Partition name and suffix does not fit.\n"); 638 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 639 goto out; 640 } 641 642 /* If we're loading from the main vbmeta partition, the vbmeta struct is in 643 * the beginning. Otherwise we may have to locate it via a footer... if no 644 * footer is found, we look in the beginning to support e.g. vbmeta_<org> 645 * partitions holding data for e.g. super partitions (b/80195851 for 646 * rationale). 647 */ 648 vbmeta_offset = 0; 649 vbmeta_size = VBMETA_MAX_SIZE; 650 if (look_for_vbmeta_footer) { 651 uint8_t footer_buf[AVB_FOOTER_SIZE]; 652 size_t footer_num_read; 653 AvbFooter footer; 654 655 io_ret = ops->read_from_partition(ops, 656 full_partition_name, 657 -AVB_FOOTER_SIZE, 658 AVB_FOOTER_SIZE, 659 footer_buf, 660 &footer_num_read); 661 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 662 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 663 goto out; 664 } else if (io_ret != AVB_IO_RESULT_OK) { 665 avb_errorv(full_partition_name, ": Error loading footer.\n", NULL); 666 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 667 goto out; 668 } 669 avb_assert(footer_num_read == AVB_FOOTER_SIZE); 670 671 if (!avb_footer_validate_and_byteswap((const AvbFooter*)footer_buf, 672 &footer)) { 673 avb_debugv(full_partition_name, ": No footer detected.\n", NULL); 674 } else { 675 /* Basic footer sanity check since the data is untrusted. */ 676 if (footer.vbmeta_size > VBMETA_MAX_SIZE) { 677 avb_errorv( 678 full_partition_name, ": Invalid vbmeta size in footer.\n", NULL); 679 } else { 680 vbmeta_offset = footer.vbmeta_offset; 681 vbmeta_size = footer.vbmeta_size; 682 } 683 } 684 } 685 686 vbmeta_buf = avb_malloc(vbmeta_size); 687 if (vbmeta_buf == NULL) { 688 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 689 goto out; 690 } 691 692 if (vbmeta_offset != 0) { 693 avb_debugv("Loading vbmeta struct in footer from partition '", 694 full_partition_name, 695 "'.\n", 696 NULL); 697 } else { 698 avb_debugv("Loading vbmeta struct from partition '", 699 full_partition_name, 700 "'.\n", 701 NULL); 702 } 703 704 io_ret = ops->read_from_partition(ops, 705 full_partition_name, 706 vbmeta_offset, 707 vbmeta_size, 708 vbmeta_buf, 709 &vbmeta_num_read); 710 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 711 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 712 goto out; 713 } else if (io_ret != AVB_IO_RESULT_OK) { 714 /* If we're looking for 'vbmeta' but there is no such partition, 715 * go try to get it from the boot partition instead. 716 */ 717 if (is_main_vbmeta && io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION && 718 !look_for_vbmeta_footer) { 719 avb_debugv(full_partition_name, 720 ": No such partition. Trying 'boot' instead.\n", 721 NULL); 722 ret = load_and_verify_vbmeta(ops, 723 requested_partitions, 724 ab_suffix, 725 flags, 726 allow_verification_error, 727 0 /* toplevel_vbmeta_flags */, 728 0 /* rollback_index_location */, 729 "boot", 730 avb_strlen("boot"), 731 NULL /* expected_public_key */, 732 0 /* expected_public_key_length */, 733 slot_data, 734 out_algorithm_type, 735 out_additional_cmdline_subst); 736 goto out; 737 } else { 738 avb_errorv(full_partition_name, ": Error loading vbmeta data.\n", NULL); 739 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 740 goto out; 741 } 742 } 743 avb_assert(vbmeta_num_read <= vbmeta_size); 744 745 /* Check if the image is properly signed and get the public key used 746 * to sign the image. 747 */ 748 vbmeta_ret = 749 avb_vbmeta_image_verify(vbmeta_buf, vbmeta_num_read, &pk_data, &pk_len); 750 switch (vbmeta_ret) { 751 case AVB_VBMETA_VERIFY_RESULT_OK: 752 avb_assert(pk_data != NULL && pk_len > 0); 753 break; 754 755 case AVB_VBMETA_VERIFY_RESULT_OK_NOT_SIGNED: 756 case AVB_VBMETA_VERIFY_RESULT_HASH_MISMATCH: 757 case AVB_VBMETA_VERIFY_RESULT_SIGNATURE_MISMATCH: 758 ret = AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION; 759 avb_errorv(full_partition_name, 760 ": Error verifying vbmeta image: ", 761 avb_vbmeta_verify_result_to_string(vbmeta_ret), 762 "\n", 763 NULL); 764 if (!allow_verification_error) { 765 goto out; 766 } 767 break; 768 769 case AVB_VBMETA_VERIFY_RESULT_INVALID_VBMETA_HEADER: 770 /* No way to continue this case. */ 771 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 772 avb_errorv(full_partition_name, 773 ": Error verifying vbmeta image: invalid vbmeta header\n", 774 NULL); 775 goto out; 776 777 case AVB_VBMETA_VERIFY_RESULT_UNSUPPORTED_VERSION: 778 /* No way to continue this case. */ 779 ret = AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION; 780 avb_errorv(full_partition_name, 781 ": Error verifying vbmeta image: unsupported AVB version\n", 782 NULL); 783 goto out; 784 } 785 786 /* Byteswap the header. */ 787 avb_vbmeta_image_header_to_host_byte_order((AvbVBMetaImageHeader*)vbmeta_buf, 788 &vbmeta_header); 789 790 /* If we're the toplevel, assign flags so they'll be passed down. */ 791 if (is_main_vbmeta) { 792 toplevel_vbmeta_flags = (AvbVBMetaImageFlags)vbmeta_header.flags; 793 } else { 794 if (vbmeta_header.flags != 0) { 795 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 796 avb_errorv(full_partition_name, 797 ": chained vbmeta image has non-zero flags\n", 798 NULL); 799 goto out; 800 } 801 } 802 803 uint32_t rollback_index_location_to_use = rollback_index_location; 804 805 /* Check if key used to make signature matches what is expected. */ 806 if (pk_data != NULL) { 807 if (expected_public_key != NULL) { 808 avb_assert(!is_main_vbmeta); 809 if (expected_public_key_length != pk_len || 810 avb_safe_memcmp(expected_public_key, pk_data, pk_len) != 0) { 811 avb_errorv(full_partition_name, 812 ": Public key used to sign data does not match key in chain " 813 "partition descriptor.\n", 814 NULL); 815 ret = AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED; 816 if (!allow_verification_error) { 817 goto out; 818 } 819 } 820 } else { 821 bool key_is_trusted = false; 822 const uint8_t* pk_metadata = NULL; 823 size_t pk_metadata_len = 0; 824 825 if (vbmeta_header.public_key_metadata_size > 0) { 826 pk_metadata = vbmeta_buf + sizeof(AvbVBMetaImageHeader) + 827 vbmeta_header.authentication_data_block_size + 828 vbmeta_header.public_key_metadata_offset; 829 pk_metadata_len = vbmeta_header.public_key_metadata_size; 830 } 831 832 // If we're not using a vbmeta partition, need to use another AvbOps... 833 if (flags & AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION) { 834 io_ret = ops->validate_public_key_for_partition( 835 ops, 836 full_partition_name, 837 pk_data, 838 pk_len, 839 pk_metadata, 840 pk_metadata_len, 841 &key_is_trusted, 842 &rollback_index_location_to_use); 843 } else { 844 avb_assert(is_main_vbmeta); 845 io_ret = ops->validate_vbmeta_public_key(ops, 846 pk_data, 847 pk_len, 848 pk_metadata, 849 pk_metadata_len, 850 &key_is_trusted); 851 } 852 853 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 854 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 855 goto out; 856 } else if (io_ret != AVB_IO_RESULT_OK) { 857 avb_errorv(full_partition_name, 858 ": Error while checking public key used to sign data.\n", 859 NULL); 860 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 861 goto out; 862 } 863 if (!key_is_trusted) { 864 avb_errorv(full_partition_name, 865 ": Public key used to sign data rejected.\n", 866 NULL); 867 ret = AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED; 868 if (!allow_verification_error) { 869 goto out; 870 } 871 } 872 } 873 } 874 875 /* Check rollback index. */ 876 io_ret = ops->read_rollback_index( 877 ops, rollback_index_location_to_use, &stored_rollback_index); 878 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 879 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 880 goto out; 881 } else if (io_ret != AVB_IO_RESULT_OK) { 882 avb_errorv(full_partition_name, 883 ": Error getting rollback index for location.\n", 884 NULL); 885 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 886 goto out; 887 } 888 if (vbmeta_header.rollback_index < stored_rollback_index) { 889 avb_errorv( 890 full_partition_name, 891 ": Image rollback index is less than the stored rollback index.\n", 892 NULL); 893 ret = AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX; 894 if (!allow_verification_error) { 895 goto out; 896 } 897 } 898 899 /* Copy vbmeta to vbmeta_images before recursing. */ 900 if (is_main_vbmeta) { 901 avb_assert(slot_data->num_vbmeta_images == 0); 902 } else { 903 if (!(flags & AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION)) { 904 avb_assert(slot_data->num_vbmeta_images > 0); 905 } 906 } 907 if (slot_data->num_vbmeta_images == MAX_NUMBER_OF_VBMETA_IMAGES) { 908 avb_errorv(full_partition_name, ": Too many vbmeta images.\n", NULL); 909 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 910 goto out; 911 } 912 vbmeta_image_data = &slot_data->vbmeta_images[slot_data->num_vbmeta_images++]; 913 vbmeta_image_data->partition_name = avb_strdup(partition_name); 914 vbmeta_image_data->vbmeta_data = vbmeta_buf; 915 /* Note that |vbmeta_buf| is actually |vbmeta_num_read| bytes long 916 * and this includes data past the end of the image. Pass the 917 * actual size of the vbmeta image. Also, no need to use 918 * avb_safe_add() since the header has already been verified. 919 */ 920 vbmeta_image_data->vbmeta_size = 921 sizeof(AvbVBMetaImageHeader) + 922 vbmeta_header.authentication_data_block_size + 923 vbmeta_header.auxiliary_data_block_size; 924 vbmeta_image_data->verify_result = vbmeta_ret; 925 926 /* If verification has been disabled by setting a bit in the image, 927 * we're done... except that we need to load the entirety of the 928 * requested partitions. 929 */ 930 if (vbmeta_header.flags & AVB_VBMETA_IMAGE_FLAGS_VERIFICATION_DISABLED) { 931 AvbSlotVerifyResult sub_ret; 932 avb_debugv( 933 full_partition_name, ": VERIFICATION_DISABLED bit is set.\n", NULL); 934 /* If load_requested_partitions() fail it is always a fatal 935 * failure (e.g. ERROR_INVALID_ARGUMENT, ERROR_OOM, etc.) rather 936 * than recoverable (e.g. one where result_should_continue() 937 * returns true) and we want to convey that error. 938 */ 939 sub_ret = load_requested_partitions( 940 ops, requested_partitions, ab_suffix, slot_data); 941 if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) { 942 ret = sub_ret; 943 } 944 goto out; 945 } 946 947 /* Now go through all descriptors and take the appropriate action: 948 * 949 * - hash descriptor: Load data from partition, calculate hash, and 950 * checks that it matches what's in the hash descriptor. 951 * 952 * - hashtree descriptor: Do nothing since verification happens 953 * on-the-fly from within the OS. (Unless the descriptor uses a 954 * persistent digest, in which case we need to find it). 955 * 956 * - chained partition descriptor: Load the footer, load the vbmeta 957 * image, verify vbmeta image (includes rollback checks, hash 958 * checks, bail on chained partitions). 959 */ 960 descriptors = 961 avb_descriptor_get_all(vbmeta_buf, vbmeta_num_read, &num_descriptors); 962 for (n = 0; n < num_descriptors; n++) { 963 AvbDescriptor desc; 964 965 if (!avb_descriptor_validate_and_byteswap(descriptors[n], &desc)) { 966 avb_errorv(full_partition_name, ": Descriptor is invalid.\n", NULL); 967 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 968 goto out; 969 } 970 971 switch (desc.tag) { 972 case AVB_DESCRIPTOR_TAG_HASH: { 973 AvbSlotVerifyResult sub_ret; 974 sub_ret = load_and_verify_hash_partition(ops, 975 requested_partitions, 976 ab_suffix, 977 allow_verification_error, 978 descriptors[n], 979 slot_data); 980 if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) { 981 ret = sub_ret; 982 if (!allow_verification_error || !result_should_continue(ret)) { 983 goto out; 984 } 985 } 986 } break; 987 988 case AVB_DESCRIPTOR_TAG_CHAIN_PARTITION: { 989 AvbSlotVerifyResult sub_ret; 990 AvbChainPartitionDescriptor chain_desc; 991 const uint8_t* chain_partition_name; 992 const uint8_t* chain_public_key; 993 994 /* Only allow CHAIN_PARTITION descriptors in the main vbmeta image. */ 995 if (!is_main_vbmeta) { 996 avb_errorv(full_partition_name, 997 ": Encountered chain descriptor not in main image.\n", 998 NULL); 999 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1000 goto out; 1001 } 1002 1003 if (!avb_chain_partition_descriptor_validate_and_byteswap( 1004 (AvbChainPartitionDescriptor*)descriptors[n], &chain_desc)) { 1005 avb_errorv(full_partition_name, 1006 ": Chain partition descriptor is invalid.\n", 1007 NULL); 1008 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1009 goto out; 1010 } 1011 1012 if (chain_desc.rollback_index_location == 0) { 1013 avb_errorv(full_partition_name, 1014 ": Chain partition has invalid " 1015 "rollback_index_location field.\n", 1016 NULL); 1017 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1018 goto out; 1019 } 1020 1021 chain_partition_name = ((const uint8_t*)descriptors[n]) + 1022 sizeof(AvbChainPartitionDescriptor); 1023 chain_public_key = chain_partition_name + chain_desc.partition_name_len; 1024 1025 sub_ret = 1026 load_and_verify_vbmeta(ops, 1027 requested_partitions, 1028 ab_suffix, 1029 flags, 1030 allow_verification_error, 1031 toplevel_vbmeta_flags, 1032 chain_desc.rollback_index_location, 1033 (const char*)chain_partition_name, 1034 chain_desc.partition_name_len, 1035 chain_public_key, 1036 chain_desc.public_key_len, 1037 slot_data, 1038 NULL, /* out_algorithm_type */ 1039 NULL /* out_additional_cmdline_subst */); 1040 if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) { 1041 ret = sub_ret; 1042 if (!result_should_continue(ret)) { 1043 goto out; 1044 } 1045 } 1046 } break; 1047 1048 case AVB_DESCRIPTOR_TAG_KERNEL_CMDLINE: { 1049 const uint8_t* kernel_cmdline; 1050 AvbKernelCmdlineDescriptor kernel_cmdline_desc; 1051 bool apply_cmdline; 1052 1053 if (!avb_kernel_cmdline_descriptor_validate_and_byteswap( 1054 (AvbKernelCmdlineDescriptor*)descriptors[n], 1055 &kernel_cmdline_desc)) { 1056 avb_errorv(full_partition_name, 1057 ": Kernel cmdline descriptor is invalid.\n", 1058 NULL); 1059 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1060 goto out; 1061 } 1062 1063 kernel_cmdline = ((const uint8_t*)descriptors[n]) + 1064 sizeof(AvbKernelCmdlineDescriptor); 1065 1066 if (!avb_validate_utf8(kernel_cmdline, 1067 kernel_cmdline_desc.kernel_cmdline_length)) { 1068 avb_errorv(full_partition_name, 1069 ": Kernel cmdline is not valid UTF-8.\n", 1070 NULL); 1071 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1072 goto out; 1073 } 1074 1075 /* Compare the flags for top-level VBMeta struct with flags in 1076 * the command-line descriptor so command-line snippets only 1077 * intended for a certain mode (dm-verity enabled/disabled) 1078 * are skipped if applicable. 1079 */ 1080 apply_cmdline = true; 1081 if (toplevel_vbmeta_flags & AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED) { 1082 if (kernel_cmdline_desc.flags & 1083 AVB_KERNEL_CMDLINE_FLAGS_USE_ONLY_IF_HASHTREE_NOT_DISABLED) { 1084 apply_cmdline = false; 1085 } 1086 } else { 1087 if (kernel_cmdline_desc.flags & 1088 AVB_KERNEL_CMDLINE_FLAGS_USE_ONLY_IF_HASHTREE_DISABLED) { 1089 apply_cmdline = false; 1090 } 1091 } 1092 1093 if (apply_cmdline) { 1094 if (slot_data->cmdline == NULL) { 1095 slot_data->cmdline = 1096 avb_calloc(kernel_cmdline_desc.kernel_cmdline_length + 1); 1097 if (slot_data->cmdline == NULL) { 1098 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1099 goto out; 1100 } 1101 avb_memcpy(slot_data->cmdline, 1102 kernel_cmdline, 1103 kernel_cmdline_desc.kernel_cmdline_length); 1104 } else { 1105 /* new cmdline is: <existing_cmdline> + ' ' + <newcmdline> + '\0' */ 1106 size_t orig_size = avb_strlen(slot_data->cmdline); 1107 size_t new_size = 1108 orig_size + 1 + kernel_cmdline_desc.kernel_cmdline_length + 1; 1109 char* new_cmdline = avb_calloc(new_size); 1110 if (new_cmdline == NULL) { 1111 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1112 goto out; 1113 } 1114 avb_memcpy(new_cmdline, slot_data->cmdline, orig_size); 1115 new_cmdline[orig_size] = ' '; 1116 avb_memcpy(new_cmdline + orig_size + 1, 1117 kernel_cmdline, 1118 kernel_cmdline_desc.kernel_cmdline_length); 1119 avb_free(slot_data->cmdline); 1120 slot_data->cmdline = new_cmdline; 1121 } 1122 } 1123 } break; 1124 1125 case AVB_DESCRIPTOR_TAG_HASHTREE: { 1126 AvbHashtreeDescriptor hashtree_desc; 1127 1128 if (!avb_hashtree_descriptor_validate_and_byteswap( 1129 (AvbHashtreeDescriptor*)descriptors[n], &hashtree_desc)) { 1130 avb_errorv( 1131 full_partition_name, ": Hashtree descriptor is invalid.\n", NULL); 1132 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1133 goto out; 1134 } 1135 1136 /* We only need to continue when there is no digest in the descriptor. 1137 * This is because the only processing here is to find the digest and 1138 * make it available on the kernel command line. 1139 */ 1140 if (hashtree_desc.root_digest_len == 0) { 1141 char part_name[AVB_PART_NAME_MAX_SIZE]; 1142 size_t digest_len = 0; 1143 uint8_t digest_buf[AVB_SHA512_DIGEST_SIZE]; 1144 const uint8_t* desc_partition_name = 1145 ((const uint8_t*)descriptors[n]) + sizeof(AvbHashtreeDescriptor); 1146 1147 if (!avb_validate_utf8(desc_partition_name, 1148 hashtree_desc.partition_name_len)) { 1149 avb_error("Partition name is not valid UTF-8.\n"); 1150 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1151 goto out; 1152 } 1153 1154 /* No ab_suffix for partitions without a digest in the descriptor 1155 * because these partitions hold data unique to this device and are 1156 * not updated using an A/B scheme. 1157 */ 1158 if ((hashtree_desc.flags & 1159 AVB_HASHTREE_DESCRIPTOR_FLAGS_DO_NOT_USE_AB) == 0 && 1160 avb_strlen(ab_suffix) != 0) { 1161 avb_error("Cannot use A/B with a persistent root digest.\n"); 1162 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1163 goto out; 1164 } 1165 if (hashtree_desc.partition_name_len >= AVB_PART_NAME_MAX_SIZE) { 1166 avb_error("Partition name does not fit.\n"); 1167 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1168 goto out; 1169 } 1170 avb_memcpy( 1171 part_name, desc_partition_name, hashtree_desc.partition_name_len); 1172 part_name[hashtree_desc.partition_name_len] = '\0'; 1173 1174 /* Determine the expected digest size from the hash algorithm. */ 1175 if (avb_strcmp((const char*)hashtree_desc.hash_algorithm, "sha1") == 1176 0) { 1177 digest_len = AVB_SHA1_DIGEST_SIZE; 1178 } else if (avb_strcmp((const char*)hashtree_desc.hash_algorithm, 1179 "sha256") == 0) { 1180 digest_len = AVB_SHA256_DIGEST_SIZE; 1181 } else if (avb_strcmp((const char*)hashtree_desc.hash_algorithm, 1182 "sha512") == 0) { 1183 digest_len = AVB_SHA512_DIGEST_SIZE; 1184 } else { 1185 avb_errorv(part_name, ": Unsupported hash algorithm.\n", NULL); 1186 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1187 goto out; 1188 } 1189 1190 ret = read_persistent_digest(ops, 1191 part_name, 1192 digest_len, 1193 NULL /* initial_digest */, 1194 digest_buf); 1195 if (ret != AVB_SLOT_VERIFY_RESULT_OK) { 1196 goto out; 1197 } 1198 1199 if (out_additional_cmdline_subst) { 1200 ret = 1201 avb_add_root_digest_substitution(part_name, 1202 digest_buf, 1203 digest_len, 1204 out_additional_cmdline_subst); 1205 if (ret != AVB_SLOT_VERIFY_RESULT_OK) { 1206 goto out; 1207 } 1208 } 1209 } 1210 } break; 1211 1212 case AVB_DESCRIPTOR_TAG_PROPERTY: 1213 /* Do nothing. */ 1214 break; 1215 } 1216 } 1217 1218 if (rollback_index_location < 0 || 1219 rollback_index_location >= AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS) { 1220 avb_errorv( 1221 full_partition_name, ": Invalid rollback_index_location.\n", NULL); 1222 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA; 1223 goto out; 1224 } 1225 1226 slot_data->rollback_indexes[rollback_index_location] = 1227 vbmeta_header.rollback_index; 1228 1229 if (out_algorithm_type != NULL) { 1230 *out_algorithm_type = (AvbAlgorithmType)vbmeta_header.algorithm_type; 1231 } 1232 1233 out: 1234 /* If |vbmeta_image_data| isn't NULL it means that it adopted 1235 * |vbmeta_buf| so in that case don't free it here. 1236 */ 1237 if (vbmeta_image_data == NULL) { 1238 if (vbmeta_buf != NULL) { 1239 avb_free(vbmeta_buf); 1240 } 1241 } 1242 if (descriptors != NULL) { 1243 avb_free(descriptors); 1244 } 1245 return ret; 1246 } 1247 1248 static AvbIOResult avb_manage_hashtree_error_mode( 1249 AvbOps* ops, 1250 AvbSlotVerifyFlags flags, 1251 AvbSlotVerifyData* data, 1252 AvbHashtreeErrorMode* out_hashtree_error_mode) { 1253 AvbHashtreeErrorMode ret = AVB_HASHTREE_ERROR_MODE_RESTART; 1254 AvbIOResult io_ret = AVB_IO_RESULT_OK; 1255 uint8_t vbmeta_digest_sha256[AVB_SHA256_DIGEST_SIZE]; 1256 uint8_t stored_vbmeta_digest_sha256[AVB_SHA256_DIGEST_SIZE]; 1257 size_t num_bytes_read; 1258 1259 avb_assert(out_hashtree_error_mode != NULL); 1260 avb_assert(ops->read_persistent_value != NULL); 1261 avb_assert(ops->write_persistent_value != NULL); 1262 1263 // If we're rebooting because of dm-verity corruption, make a note of 1264 // the vbmeta hash so we can stay in 'eio' mode until things change. 1265 if (flags & AVB_SLOT_VERIFY_FLAGS_RESTART_CAUSED_BY_HASHTREE_CORRUPTION) { 1266 avb_debug( 1267 "Rebooting because of dm-verity corruption - " 1268 "recording OS instance and using 'eio' mode.\n"); 1269 avb_slot_verify_data_calculate_vbmeta_digest( 1270 data, AVB_DIGEST_TYPE_SHA256, vbmeta_digest_sha256); 1271 io_ret = ops->write_persistent_value(ops, 1272 AVB_NPV_MANAGED_VERITY_MODE, 1273 AVB_SHA256_DIGEST_SIZE, 1274 vbmeta_digest_sha256); 1275 if (io_ret != AVB_IO_RESULT_OK) { 1276 avb_error("Error writing to " AVB_NPV_MANAGED_VERITY_MODE ".\n"); 1277 goto out; 1278 } 1279 ret = AVB_HASHTREE_ERROR_MODE_EIO; 1280 io_ret = AVB_IO_RESULT_OK; 1281 goto out; 1282 } 1283 1284 // See if we're in 'eio' mode. 1285 io_ret = ops->read_persistent_value(ops, 1286 AVB_NPV_MANAGED_VERITY_MODE, 1287 AVB_SHA256_DIGEST_SIZE, 1288 stored_vbmeta_digest_sha256, 1289 &num_bytes_read); 1290 if (io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_VALUE || 1291 (io_ret == AVB_IO_RESULT_OK && num_bytes_read == 0)) { 1292 // This is the usual case ('eio' mode not set). 1293 avb_debug("No dm-verity corruption - using in 'restart' mode.\n"); 1294 ret = AVB_HASHTREE_ERROR_MODE_RESTART; 1295 io_ret = AVB_IO_RESULT_OK; 1296 goto out; 1297 } else if (io_ret != AVB_IO_RESULT_OK) { 1298 avb_error("Error reading from " AVB_NPV_MANAGED_VERITY_MODE ".\n"); 1299 goto out; 1300 } 1301 if (num_bytes_read != AVB_SHA256_DIGEST_SIZE) { 1302 avb_error( 1303 "Unexpected number of bytes read from " AVB_NPV_MANAGED_VERITY_MODE 1304 ".\n"); 1305 io_ret = AVB_IO_RESULT_ERROR_IO; 1306 goto out; 1307 } 1308 1309 // OK, so we're currently in 'eio' mode and the vbmeta digest of the OS 1310 // that caused this is in |stored_vbmeta_digest_sha256| ... now see if 1311 // the OS we're dealing with now is the same. 1312 avb_slot_verify_data_calculate_vbmeta_digest( 1313 data, AVB_DIGEST_TYPE_SHA256, vbmeta_digest_sha256); 1314 if (avb_memcmp(vbmeta_digest_sha256, 1315 stored_vbmeta_digest_sha256, 1316 AVB_SHA256_DIGEST_SIZE) == 0) { 1317 // It's the same so we're still in 'eio' mode. 1318 avb_debug("Same OS instance detected - staying in 'eio' mode.\n"); 1319 ret = AVB_HASHTREE_ERROR_MODE_EIO; 1320 io_ret = AVB_IO_RESULT_OK; 1321 } else { 1322 // It did change! 1323 avb_debug( 1324 "New OS instance detected - changing from 'eio' to 'restart' mode.\n"); 1325 io_ret = 1326 ops->write_persistent_value(ops, 1327 AVB_NPV_MANAGED_VERITY_MODE, 1328 0, // This clears the persistent property. 1329 vbmeta_digest_sha256); 1330 if (io_ret != AVB_IO_RESULT_OK) { 1331 avb_error("Error clearing " AVB_NPV_MANAGED_VERITY_MODE ".\n"); 1332 goto out; 1333 } 1334 ret = AVB_HASHTREE_ERROR_MODE_RESTART; 1335 io_ret = AVB_IO_RESULT_OK; 1336 } 1337 1338 out: 1339 *out_hashtree_error_mode = ret; 1340 return io_ret; 1341 } 1342 1343 static bool has_system_partition(AvbOps* ops, const char* ab_suffix) { 1344 char part_name[AVB_PART_NAME_MAX_SIZE]; 1345 char* system_part_name = "system"; 1346 char guid_buf[37]; 1347 AvbIOResult io_ret; 1348 1349 if (!avb_str_concat(part_name, 1350 sizeof part_name, 1351 system_part_name, 1352 avb_strlen(system_part_name), 1353 ab_suffix, 1354 avb_strlen(ab_suffix))) { 1355 avb_error("System partition name and suffix does not fit.\n"); 1356 return false; 1357 } 1358 1359 io_ret = ops->get_unique_guid_for_partition( 1360 ops, part_name, guid_buf, sizeof guid_buf); 1361 if (io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION) { 1362 avb_debug("No system partition.\n"); 1363 return false; 1364 } else if (io_ret != AVB_IO_RESULT_OK) { 1365 avb_error("Error getting unique GUID for system partition.\n"); 1366 return false; 1367 } 1368 1369 return true; 1370 } 1371 1372 AvbSlotVerifyResult avb_slot_verify(AvbOps* ops, 1373 const char* const* requested_partitions, 1374 const char* ab_suffix, 1375 AvbSlotVerifyFlags flags, 1376 AvbHashtreeErrorMode hashtree_error_mode, 1377 AvbSlotVerifyData** out_data) { 1378 AvbSlotVerifyResult ret = 0; 1379 AvbSlotVerifyData* slot_data = NULL; 1380 AvbAlgorithmType algorithm_type = AVB_ALGORITHM_TYPE_NONE; 1381 bool using_boot_for_vbmeta = false; 1382 AvbVBMetaImageHeader toplevel_vbmeta; 1383 bool allow_verification_error = 1384 (flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR); 1385 AvbCmdlineSubstList* additional_cmdline_subst = NULL; 1386 1387 /* Fail early if we're missing the AvbOps needed for slot verification. */ 1388 avb_assert(ops->read_is_device_unlocked != NULL); 1389 avb_assert(ops->read_from_partition != NULL); 1390 avb_assert(ops->get_size_of_partition != NULL); 1391 avb_assert(ops->read_rollback_index != NULL); 1392 avb_assert(ops->get_unique_guid_for_partition != NULL); 1393 1394 if (out_data != NULL) { 1395 *out_data = NULL; 1396 } 1397 1398 /* Allowing dm-verity errors defeats the purpose of verified boot so 1399 * only allow this if set up to allow verification errors 1400 * (e.g. typically only UNLOCKED mode). 1401 */ 1402 if (hashtree_error_mode == AVB_HASHTREE_ERROR_MODE_LOGGING && 1403 !allow_verification_error) { 1404 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT; 1405 goto fail; 1406 } 1407 1408 /* Make sure passed-in AvbOps support persistent values if 1409 * asking for libavb to manage verity state. 1410 */ 1411 if (hashtree_error_mode == AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO) { 1412 if (ops->read_persistent_value == NULL || 1413 ops->write_persistent_value == NULL) { 1414 avb_error( 1415 "Persistent values required for " 1416 "AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO " 1417 "but are not implemented in given AvbOps.\n"); 1418 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT; 1419 goto fail; 1420 } 1421 } 1422 1423 /* Make sure passed-in AvbOps support verifying public keys and getting 1424 * rollback index location if not using a vbmeta partition. 1425 */ 1426 if (flags & AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION) { 1427 if (ops->validate_public_key_for_partition == NULL) { 1428 avb_error( 1429 "AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION was passed but the " 1430 "validate_public_key_for_partition() operation isn't implemented.\n"); 1431 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT; 1432 goto fail; 1433 } 1434 } else { 1435 avb_assert(ops->validate_vbmeta_public_key != NULL); 1436 } 1437 1438 slot_data = avb_calloc(sizeof(AvbSlotVerifyData)); 1439 if (slot_data == NULL) { 1440 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1441 goto fail; 1442 } 1443 slot_data->vbmeta_images = 1444 avb_calloc(sizeof(AvbVBMetaData) * MAX_NUMBER_OF_VBMETA_IMAGES); 1445 if (slot_data->vbmeta_images == NULL) { 1446 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1447 goto fail; 1448 } 1449 slot_data->loaded_partitions = 1450 avb_calloc(sizeof(AvbPartitionData) * MAX_NUMBER_OF_LOADED_PARTITIONS); 1451 if (slot_data->loaded_partitions == NULL) { 1452 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1453 goto fail; 1454 } 1455 1456 additional_cmdline_subst = avb_new_cmdline_subst_list(); 1457 if (additional_cmdline_subst == NULL) { 1458 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1459 goto fail; 1460 } 1461 1462 if (flags & AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION) { 1463 if (requested_partitions == NULL || requested_partitions[0] == NULL) { 1464 avb_fatal( 1465 "Requested partitions cannot be empty when using " 1466 "AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION"); 1467 ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT; 1468 goto fail; 1469 } 1470 1471 /* No vbmeta partition, go through each of the requested partitions... */ 1472 for (size_t n = 0; requested_partitions[n] != NULL; n++) { 1473 ret = load_and_verify_vbmeta(ops, 1474 requested_partitions, 1475 ab_suffix, 1476 flags, 1477 allow_verification_error, 1478 0 /* toplevel_vbmeta_flags */, 1479 0 /* rollback_index_location */, 1480 requested_partitions[n], 1481 avb_strlen(requested_partitions[n]), 1482 NULL /* expected_public_key */, 1483 0 /* expected_public_key_length */, 1484 slot_data, 1485 &algorithm_type, 1486 additional_cmdline_subst); 1487 if (!allow_verification_error && ret != AVB_SLOT_VERIFY_RESULT_OK) { 1488 goto fail; 1489 } 1490 } 1491 1492 } else { 1493 /* Usual path, load "vbmeta"... */ 1494 ret = load_and_verify_vbmeta(ops, 1495 requested_partitions, 1496 ab_suffix, 1497 flags, 1498 allow_verification_error, 1499 0 /* toplevel_vbmeta_flags */, 1500 0 /* rollback_index_location */, 1501 "vbmeta", 1502 avb_strlen("vbmeta"), 1503 NULL /* expected_public_key */, 1504 0 /* expected_public_key_length */, 1505 slot_data, 1506 &algorithm_type, 1507 additional_cmdline_subst); 1508 if (!allow_verification_error && ret != AVB_SLOT_VERIFY_RESULT_OK) { 1509 goto fail; 1510 } 1511 } 1512 1513 if (!result_should_continue(ret)) { 1514 goto fail; 1515 } 1516 1517 /* If things check out, mangle the kernel command-line as needed. */ 1518 if (!(flags & AVB_SLOT_VERIFY_FLAGS_NO_VBMETA_PARTITION)) { 1519 if (avb_strcmp(slot_data->vbmeta_images[0].partition_name, "vbmeta") != 0) { 1520 avb_assert( 1521 avb_strcmp(slot_data->vbmeta_images[0].partition_name, "boot") == 0); 1522 using_boot_for_vbmeta = true; 1523 } 1524 } 1525 1526 /* Byteswap top-level vbmeta header since we'll need it below. */ 1527 avb_vbmeta_image_header_to_host_byte_order( 1528 (const AvbVBMetaImageHeader*)slot_data->vbmeta_images[0].vbmeta_data, 1529 &toplevel_vbmeta); 1530 1531 /* Fill in |ab_suffix| field. */ 1532 slot_data->ab_suffix = avb_strdup(ab_suffix); 1533 if (slot_data->ab_suffix == NULL) { 1534 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1535 goto fail; 1536 } 1537 1538 /* If verification is disabled, we are done ... we specifically 1539 * don't want to add any androidboot.* options since verification 1540 * is disabled. 1541 */ 1542 if (toplevel_vbmeta.flags & AVB_VBMETA_IMAGE_FLAGS_VERIFICATION_DISABLED) { 1543 /* Since verification is disabled we didn't process any 1544 * descriptors and thus there's no cmdline... so set root= such 1545 * that the system partition is mounted. 1546 */ 1547 avb_assert(slot_data->cmdline == NULL); 1548 // Devices with dynamic partitions won't have system partition. 1549 // Instead, it has a large super partition to accommodate *.img files. 1550 // See b/119551429 for details. 1551 if (has_system_partition(ops, ab_suffix)) { 1552 slot_data->cmdline = 1553 avb_strdup("root=PARTUUID=$(ANDROID_SYSTEM_PARTUUID)"); 1554 } else { 1555 // The |cmdline| field should be a NUL-terminated string. 1556 slot_data->cmdline = avb_strdup(""); 1557 } 1558 if (slot_data->cmdline == NULL) { 1559 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1560 goto fail; 1561 } 1562 } else { 1563 /* If requested, manage dm-verity mode... */ 1564 AvbHashtreeErrorMode resolved_hashtree_error_mode = hashtree_error_mode; 1565 if (hashtree_error_mode == 1566 AVB_HASHTREE_ERROR_MODE_MANAGED_RESTART_AND_EIO) { 1567 AvbIOResult io_ret; 1568 io_ret = avb_manage_hashtree_error_mode( 1569 ops, flags, slot_data, &resolved_hashtree_error_mode); 1570 if (io_ret != AVB_IO_RESULT_OK) { 1571 ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO; 1572 if (io_ret == AVB_IO_RESULT_ERROR_OOM) { 1573 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1574 } 1575 goto fail; 1576 } 1577 } 1578 slot_data->resolved_hashtree_error_mode = resolved_hashtree_error_mode; 1579 1580 /* Add options... */ 1581 AvbSlotVerifyResult sub_ret; 1582 sub_ret = avb_append_options(ops, 1583 flags, 1584 slot_data, 1585 &toplevel_vbmeta, 1586 algorithm_type, 1587 hashtree_error_mode, 1588 resolved_hashtree_error_mode); 1589 if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) { 1590 ret = sub_ret; 1591 goto fail; 1592 } 1593 } 1594 1595 /* Substitute $(ANDROID_SYSTEM_PARTUUID) and friends. */ 1596 if (slot_data->cmdline != NULL && avb_strlen(slot_data->cmdline) != 0) { 1597 char* new_cmdline; 1598 new_cmdline = avb_sub_cmdline(ops, 1599 slot_data->cmdline, 1600 ab_suffix, 1601 using_boot_for_vbmeta, 1602 additional_cmdline_subst); 1603 if (new_cmdline != slot_data->cmdline) { 1604 if (new_cmdline == NULL) { 1605 ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM; 1606 goto fail; 1607 } 1608 avb_free(slot_data->cmdline); 1609 slot_data->cmdline = new_cmdline; 1610 } 1611 } 1612 1613 if (out_data != NULL) { 1614 *out_data = slot_data; 1615 } else { 1616 avb_slot_verify_data_free(slot_data); 1617 } 1618 1619 avb_free_cmdline_subst_list(additional_cmdline_subst); 1620 additional_cmdline_subst = NULL; 1621 1622 if (!allow_verification_error) { 1623 avb_assert(ret == AVB_SLOT_VERIFY_RESULT_OK); 1624 } 1625 1626 return ret; 1627 1628 fail: 1629 if (slot_data != NULL) { 1630 avb_slot_verify_data_free(slot_data); 1631 } 1632 if (additional_cmdline_subst != NULL) { 1633 avb_free_cmdline_subst_list(additional_cmdline_subst); 1634 } 1635 return ret; 1636 } 1637 1638 void avb_slot_verify_data_free(AvbSlotVerifyData* data) { 1639 if (data->ab_suffix != NULL) { 1640 avb_free(data->ab_suffix); 1641 } 1642 if (data->cmdline != NULL) { 1643 avb_free(data->cmdline); 1644 } 1645 if (data->vbmeta_images != NULL) { 1646 size_t n; 1647 for (n = 0; n < data->num_vbmeta_images; n++) { 1648 AvbVBMetaData* vbmeta_image = &data->vbmeta_images[n]; 1649 if (vbmeta_image->partition_name != NULL) { 1650 avb_free(vbmeta_image->partition_name); 1651 } 1652 if (vbmeta_image->vbmeta_data != NULL) { 1653 avb_free(vbmeta_image->vbmeta_data); 1654 } 1655 } 1656 avb_free(data->vbmeta_images); 1657 } 1658 if (data->loaded_partitions != NULL) { 1659 size_t n; 1660 for (n = 0; n < data->num_loaded_partitions; n++) { 1661 AvbPartitionData* loaded_partition = &data->loaded_partitions[n]; 1662 if (loaded_partition->partition_name != NULL) { 1663 avb_free(loaded_partition->partition_name); 1664 } 1665 if (loaded_partition->data != NULL && !loaded_partition->preloaded) { 1666 avb_free(loaded_partition->data); 1667 } 1668 } 1669 avb_free(data->loaded_partitions); 1670 } 1671 avb_free(data); 1672 } 1673 1674 const char* avb_slot_verify_result_to_string(AvbSlotVerifyResult result) { 1675 const char* ret = NULL; 1676 1677 switch (result) { 1678 case AVB_SLOT_VERIFY_RESULT_OK: 1679 ret = "OK"; 1680 break; 1681 case AVB_SLOT_VERIFY_RESULT_ERROR_OOM: 1682 ret = "ERROR_OOM"; 1683 break; 1684 case AVB_SLOT_VERIFY_RESULT_ERROR_IO: 1685 ret = "ERROR_IO"; 1686 break; 1687 case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION: 1688 ret = "ERROR_VERIFICATION"; 1689 break; 1690 case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX: 1691 ret = "ERROR_ROLLBACK_INDEX"; 1692 break; 1693 case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED: 1694 ret = "ERROR_PUBLIC_KEY_REJECTED"; 1695 break; 1696 case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA: 1697 ret = "ERROR_INVALID_METADATA"; 1698 break; 1699 case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION: 1700 ret = "ERROR_UNSUPPORTED_VERSION"; 1701 break; 1702 case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT: 1703 ret = "ERROR_INVALID_ARGUMENT"; 1704 break; 1705 /* Do not add a 'default:' case here because of -Wswitch. */ 1706 } 1707 1708 if (ret == NULL) { 1709 avb_error("Unknown AvbSlotVerifyResult value.\n"); 1710 ret = "(unknown)"; 1711 } 1712 1713 return ret; 1714 } 1715 1716 void avb_slot_verify_data_calculate_vbmeta_digest(AvbSlotVerifyData* data, 1717 AvbDigestType digest_type, 1718 uint8_t* out_digest) { 1719 bool ret = false; 1720 size_t n; 1721 1722 switch (digest_type) { 1723 case AVB_DIGEST_TYPE_SHA256: { 1724 AvbSHA256Ctx ctx; 1725 1726 ctx.tot_len = 0; 1727 for (n = 0; n < data->num_vbmeta_images; n++) 1728 ctx.tot_len += data->vbmeta_images[n].vbmeta_size; 1729 1730 avb_sha256_init(&ctx); 1731 for (n = 0; n < data->num_vbmeta_images; n++) { 1732 avb_sha256_update(&ctx, 1733 data->vbmeta_images[n].vbmeta_data, 1734 data->vbmeta_images[n].vbmeta_size); 1735 } 1736 avb_memcpy(out_digest, avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE); 1737 ret = true; 1738 } break; 1739 1740 case AVB_DIGEST_TYPE_SHA512: { 1741 AvbSHA512Ctx ctx; 1742 1743 ctx.tot_len = 0; 1744 for (n = 0; n < data->num_vbmeta_images; n++) 1745 ctx.tot_len += data->vbmeta_images[n].vbmeta_size; 1746 1747 avb_sha512_init(&ctx); 1748 for (n = 0; n < data->num_vbmeta_images; n++) { 1749 avb_sha512_update(&ctx, 1750 data->vbmeta_images[n].vbmeta_data, 1751 data->vbmeta_images[n].vbmeta_size); 1752 } 1753 avb_memcpy(out_digest, avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE); 1754 ret = true; 1755 } break; 1756 1757 /* Do not add a 'default:' case here because of -Wswitch. */ 1758 } 1759 1760 if (!ret) { 1761 avb_fatal("Unknown digest type"); 1762 } 1763 } 1764