lib/libavb/avb_slot_verify.c

   1 // SPDX-License-Identifier: MIT
   2 /*
   3  * Copyright (C) 2016 The Android Open Source Project
   4  */
   5
   6 #include "avb_slot_verify.h"
   7 #include "avb_chain_partition_descriptor.h"
   8 #include "avb_cmdline.h"
   9 #include "avb_footer.h"
  10 #include "avb_hash_descriptor.h"
  11 #include "avb_hashtree_descriptor.h"
  12 #include "avb_kernel_cmdline_descriptor.h"
  13 #include "avb_sha.h"
  14 #include "avb_util.h"
  15 #include "avb_vbmeta_image.h"
  16 #include "avb_version.h"
  17
  18 /* Maximum number of partitions that can be loaded with avb_slot_verify(). */
  19 #define MAX_NUMBER_OF_LOADED_PARTITIONS 32
  20
  21 /* Maximum number of vbmeta images that can be loaded with avb_slot_verify(). */
  22 #define MAX_NUMBER_OF_VBMETA_IMAGES 32
  23
  24 /* Maximum size of a vbmeta image - 64 KiB. */
  25 #define VBMETA_MAX_SIZE (64 * 1024)
  26
  27 /* Helper function to see if we should continue with verification in
  28  * allow_verification_error=true mode if something goes wrong. See the
  29  * comments for the avb_slot_verify() function for more information.
  30  */
  31 static inline bool result_should_continue(AvbSlotVerifyResult result) {
  32   switch (result) {
  33     case AVB_SLOT_VERIFY_RESULT_ERROR_OOM:
  34     case AVB_SLOT_VERIFY_RESULT_ERROR_IO:
  35     case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA:
  36     case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION:
  37     case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT:
  38       return false;
  39
  40     case AVB_SLOT_VERIFY_RESULT_OK:
  41     case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION:
  42     case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX:
  43     case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED:
  44       return true;
  45   }
  46
  47   return false;
  48 }
  49
  50 static AvbSlotVerifyResult load_full_partition(AvbOps* ops,
  51                                                const char* part_name,
  52                                                uint64_t image_size,
  53                                                uint8_t** out_image_buf,
  54                                                bool* out_image_preloaded) {
  55   size_t part_num_read;
  56   AvbIOResult io_ret;
  57
  58   /* Make sure that we do not overwrite existing data. */
  59   avb_assert(*out_image_buf == NULL);
  60   avb_assert(!*out_image_preloaded);
  61
  62   /* We are going to implicitly cast image_size from uint64_t to size_t in the
  63    * following code, so we need to make sure that the cast is safe. */
  64   if (image_size != (size_t)(image_size)) {
  65     avb_errorv(part_name, ": Partition size too large to load.\n", NULL);
  66     return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
  67   }
  68
  69   /* Try use a preloaded one. */
  70   if (ops->get_preloaded_partition != NULL) {
  71     io_ret = ops->get_preloaded_partition(
  72         ops, part_name, image_size, out_image_buf, &part_num_read);
  73     if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
  74       return AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
  75     } else if (io_ret != AVB_IO_RESULT_OK) {
  76       avb_errorv(part_name, ": Error loading data from partition.\n", NULL);
  77       return AVB_SLOT_VERIFY_RESULT_ERROR_IO;
  78     }
  79
  80     if (*out_image_buf != NULL) {
  81       if (part_num_read != image_size) {
  82         avb_errorv(part_name, ": Read incorrect number of bytes.\n", NULL);
  83         return AVB_SLOT_VERIFY_RESULT_ERROR_IO;
  84       }
  85       *out_image_preloaded = true;
  86     }
  87   }
  88
  89   /* Allocate and copy the partition. */
  90   if (!*out_image_preloaded) {
  91     *out_image_buf = avb_malloc(image_size);
  92     if (*out_image_buf == NULL) {
  93       return AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
  94     }
  95
  96     io_ret = ops->read_from_partition(ops,
  97                                       part_name,
  98                                       0 /* offset */,
  99                                       image_size,
 100                                       *out_image_buf,
 101                                       &part_num_read);
 102     if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 103       return AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 104     } else if (io_ret != AVB_IO_RESULT_OK) {
 105       avb_errorv(part_name, ": Error loading data from partition.\n", NULL);
 106       return AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 107     }
 108     if (part_num_read != image_size) {
 109       avb_errorv(part_name, ": Read incorrect number of bytes.\n", NULL);
 110       return AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 111     }
 112   }
 113
 114   return AVB_SLOT_VERIFY_RESULT_OK;
 115 }
 116
 117 static AvbSlotVerifyResult read_persistent_digest(AvbOps* ops,
 118                                                   const char* part_name,
 119                                                   size_t expected_digest_size,
 120                                                   uint8_t* out_digest) {
 121   char* persistent_value_name = NULL;
 122   AvbIOResult io_ret = AVB_IO_RESULT_OK;
 123   size_t stored_digest_size = 0;
 124
 125   if (ops->read_persistent_value == NULL) {
 126     avb_errorv(part_name, ": Persistent values are not implemented.\n", NULL);
 127     return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 128   }
 129   persistent_value_name =
 130       avb_strdupv(AVB_NPV_PERSISTENT_DIGEST_PREFIX, part_name, NULL);
 131   if (persistent_value_name == NULL) {
 132     return AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 133   }
 134   io_ret = ops->read_persistent_value(ops,
 135                                       persistent_value_name,
 136                                       expected_digest_size,
 137                                       out_digest,
 138                                       &stored_digest_size);
 139   avb_free(persistent_value_name);
 140   if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 141     return AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 142   } else if (io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_VALUE) {
 143     avb_errorv(part_name, ": Persistent digest does not exist.\n", NULL);
 144     return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 145   } else if (io_ret == AVB_IO_RESULT_ERROR_INVALID_VALUE_SIZE ||
 146              io_ret == AVB_IO_RESULT_ERROR_INSUFFICIENT_SPACE ||
 147              expected_digest_size != stored_digest_size) {
 148     avb_errorv(
 149         part_name, ": Persistent digest is not of expected size.\n", NULL);
 150     return AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 151   } else if (io_ret != AVB_IO_RESULT_OK) {
 152     avb_errorv(part_name, ": Error reading persistent digest.\n", NULL);
 153     return AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 154   }
 155   return AVB_SLOT_VERIFY_RESULT_OK;
 156 }
 157
 158 static AvbSlotVerifyResult load_and_verify_hash_partition(
 159     AvbOps* ops,
 160     const char* const* requested_partitions,
 161     const char* ab_suffix,
 162     bool allow_verification_error,
 163     const AvbDescriptor* descriptor,
 164     AvbSlotVerifyData* slot_data) {
 165   AvbHashDescriptor hash_desc;
 166   const uint8_t* desc_partition_name = NULL;
 167   const uint8_t* desc_salt;
 168   const uint8_t* desc_digest;
 169   char part_name[AVB_PART_NAME_MAX_SIZE];
 170   AvbSlotVerifyResult ret;
 171   AvbIOResult io_ret;
 172   uint8_t* image_buf = NULL;
 173   bool image_preloaded = false;
 174   uint8_t* digest;
 175   size_t digest_len;
 176   const char* found;
 177   uint64_t image_size;
 178   size_t expected_digest_len = 0;
 179   uint8_t expected_digest_buf[AVB_SHA512_DIGEST_SIZE];
 180   const uint8_t* expected_digest = NULL;
 181
 182   if (!avb_hash_descriptor_validate_and_byteswap(
 183           (const AvbHashDescriptor*)descriptor, &hash_desc)) {
 184     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 185     goto out;
 186   }
 187
 188   desc_partition_name =
 189       ((const uint8_t*)descriptor) + sizeof(AvbHashDescriptor);
 190   desc_salt = desc_partition_name + hash_desc.partition_name_len;
 191   desc_digest = desc_salt + hash_desc.salt_len;
 192
 193   if (!avb_validate_utf8(desc_partition_name, hash_desc.partition_name_len)) {
 194     avb_error("Partition name is not valid UTF-8.\n");
 195     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 196     goto out;
 197   }
 198
 199   /* Don't bother loading or validating unless the partition was
 200    * requested in the first place.
 201    */
 202   found = avb_strv_find_str(requested_partitions,
 203                             (const char*)desc_partition_name,
 204                             hash_desc.partition_name_len);
 205   if (found == NULL) {
 206     ret = AVB_SLOT_VERIFY_RESULT_OK;
 207     goto out;
 208   }
 209
 210   if ((hash_desc.flags & AVB_HASH_DESCRIPTOR_FLAGS_DO_NOT_USE_AB) != 0) {
 211     /* No ab_suffix, just copy the partition name as is. */
 212     if (hash_desc.partition_name_len >= AVB_PART_NAME_MAX_SIZE) {
 213       avb_error("Partition name does not fit.\n");
 214       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 215       goto out;
 216     }
 217     avb_memcpy(part_name, desc_partition_name, hash_desc.partition_name_len);
 218     part_name[hash_desc.partition_name_len] = '\0';
 219   } else if (hash_desc.digest_len == 0 && avb_strlen(ab_suffix) != 0) {
 220     /* No ab_suffix allowed for partitions without a digest in the descriptor
 221      * because these partitions hold data unique to this device and are not
 222      * updated using an A/B scheme.
 223      */
 224     avb_error("Cannot use A/B with a persistent digest.\n");
 225     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 226     goto out;
 227   } else {
 228     /* Add ab_suffix to the partition name. */
 229     if (!avb_str_concat(part_name,
 230                         sizeof part_name,
 231                         (const char*)desc_partition_name,
 232                         hash_desc.partition_name_len,
 233                         ab_suffix,
 234                         avb_strlen(ab_suffix))) {
 235       avb_error("Partition name and suffix does not fit.\n");
 236       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 237       goto out;
 238     }
 239   }
 240
 241   /* If we're allowing verification errors then hash_desc.image_size
 242    * may no longer match what's in the partition... so in this case
 243    * just load the entire partition.
 244    *
 245    * For example, this can happen if a developer does 'fastboot flash
 246    * boot /path/to/new/and/bigger/boot.img'. We want this to work
 247    * since it's such a common workflow.
 248    */
 249   image_size = hash_desc.image_size;
 250   if (allow_verification_error) {
 251     if (ops->get_size_of_partition == NULL) {
 252       avb_errorv(part_name,
 253                  ": The get_size_of_partition() operation is "
 254                  "not implemented so we may not load the entire partition. "
 255                  "Please implement.",
 256                  NULL);
 257     } else {
 258       io_ret = ops->get_size_of_partition(ops, part_name, &image_size);
 259       if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 260         ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 261         goto out;
 262       } else if (io_ret != AVB_IO_RESULT_OK) {
 263         avb_errorv(part_name, ": Error determining partition size.\n", NULL);
 264         ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 265         goto out;
 266       }
 267       avb_debugv(part_name, ": Loading entire partition.\n", NULL);
 268     }
 269   }
 270
 271   ret = load_full_partition(
 272       ops, part_name, image_size, &image_buf, &image_preloaded);
 273   if (ret != AVB_SLOT_VERIFY_RESULT_OK) {
 274     goto out;
 275   }
 276
 277   if (avb_strcmp((const char*)hash_desc.hash_algorithm, "sha256") == 0) {
 278     AvbSHA256Ctx sha256_ctx;
 279     avb_sha256_init(&sha256_ctx);
 280     avb_sha256_update(&sha256_ctx, desc_salt, hash_desc.salt_len);
 281     avb_sha256_update(&sha256_ctx, image_buf, hash_desc.image_size);
 282     digest = avb_sha256_final(&sha256_ctx);
 283     digest_len = AVB_SHA256_DIGEST_SIZE;
 284   } else if (avb_strcmp((const char*)hash_desc.hash_algorithm, "sha512") == 0) {
 285     AvbSHA512Ctx sha512_ctx;
 286     avb_sha512_init(&sha512_ctx);
 287     avb_sha512_update(&sha512_ctx, desc_salt, hash_desc.salt_len);
 288     avb_sha512_update(&sha512_ctx, image_buf, hash_desc.image_size);
 289     digest = avb_sha512_final(&sha512_ctx);
 290     digest_len = AVB_SHA512_DIGEST_SIZE;
 291   } else {
 292     avb_errorv(part_name, ": Unsupported hash algorithm.\n", NULL);
 293     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 294     goto out;
 295   }
 296
 297   if (hash_desc.digest_len == 0) {
 298     // Expect a match to a persistent digest.
 299     avb_debugv(part_name, ": No digest, using persistent digest.\n", NULL);
 300     expected_digest_len = digest_len;
 301     expected_digest = expected_digest_buf;
 302     avb_assert(expected_digest_len <= sizeof(expected_digest_buf));
 303     ret =
 304         read_persistent_digest(ops, part_name, digest_len, expected_digest_buf);
 305     if (ret != AVB_SLOT_VERIFY_RESULT_OK) {
 306       goto out;
 307     }
 308   } else {
 309     // Expect a match to the digest in the descriptor.
 310     expected_digest_len = hash_desc.digest_len;
 311     expected_digest = desc_digest;
 312   }
 313
 314   if (digest_len != expected_digest_len) {
 315     avb_errorv(
 316         part_name, ": Digest in descriptor not of expected size.\n", NULL);
 317     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 318     goto out;
 319   }
 320
 321   if (avb_safe_memcmp(digest, expected_digest, digest_len) != 0) {
 322     avb_errorv(part_name,
 323                ": Hash of data does not match digest in descriptor.\n",
 324                NULL);
 325     ret = AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION;
 326     goto out;
 327   }
 328
 329   ret = AVB_SLOT_VERIFY_RESULT_OK;
 330
 331 out:
 332
 333   /* If it worked and something was loaded, copy to slot_data. */
 334   if ((ret == AVB_SLOT_VERIFY_RESULT_OK || result_should_continue(ret)) &&
 335       image_buf != NULL) {
 336     AvbPartitionData* loaded_partition;
 337     if (slot_data->num_loaded_partitions == MAX_NUMBER_OF_LOADED_PARTITIONS) {
 338       avb_errorv(part_name, ": Too many loaded partitions.\n", NULL);
 339       ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 340       goto fail;
 341     }
 342     loaded_partition =
 343         &slot_data->loaded_partitions[slot_data->num_loaded_partitions++];
 344     loaded_partition->partition_name = avb_strdup(found);
 345     loaded_partition->data_size = image_size;
 346     loaded_partition->data = image_buf;
 347     loaded_partition->preloaded = image_preloaded;
 348     image_buf = NULL;
 349   }
 350
 351 fail:
 352   if (image_buf != NULL && !image_preloaded) {
 353     avb_free(image_buf);
 354   }
 355   return ret;
 356 }
 357
 358 static AvbSlotVerifyResult load_requested_partitions(
 359     AvbOps* ops,
 360     const char* const* requested_partitions,
 361     const char* ab_suffix,
 362     AvbSlotVerifyData* slot_data) {
 363   AvbSlotVerifyResult ret;
 364   uint8_t* image_buf = NULL;
 365   bool image_preloaded = false;
 366   size_t n;
 367
 368   if (ops->get_size_of_partition == NULL) {
 369     avb_error("get_size_of_partition() not implemented.\n");
 370     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT;
 371     goto out;
 372   }
 373
 374   for (n = 0; requested_partitions[n] != NULL; n++) {
 375     char part_name[AVB_PART_NAME_MAX_SIZE];
 376     AvbIOResult io_ret;
 377     uint64_t image_size;
 378     AvbPartitionData* loaded_partition;
 379
 380     if (!avb_str_concat(part_name,
 381                         sizeof part_name,
 382                         requested_partitions[n],
 383                         avb_strlen(requested_partitions[n]),
 384                         ab_suffix,
 385                         avb_strlen(ab_suffix))) {
 386       avb_error("Partition name and suffix does not fit.\n");
 387       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 388       goto out;
 389     }
 390
 391     io_ret = ops->get_size_of_partition(ops, part_name, &image_size);
 392     if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 393       ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 394       goto out;
 395     } else if (io_ret != AVB_IO_RESULT_OK) {
 396       avb_errorv(part_name, ": Error determining partition size.\n", NULL);
 397       ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 398       goto out;
 399     }
 400     avb_debugv(part_name, ": Loading entire partition.\n", NULL);
 401
 402     ret = load_full_partition(
 403         ops, part_name, image_size, &image_buf, &image_preloaded);
 404     if (ret != AVB_SLOT_VERIFY_RESULT_OK) {
 405       goto out;
 406     }
 407
 408     /* Move to slot_data. */
 409     if (slot_data->num_loaded_partitions == MAX_NUMBER_OF_LOADED_PARTITIONS) {
 410       avb_errorv(part_name, ": Too many loaded partitions.\n", NULL);
 411       ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 412       goto out;
 413     }
 414     loaded_partition =
 415         &slot_data->loaded_partitions[slot_data->num_loaded_partitions++];
 416     loaded_partition->partition_name = avb_strdup(requested_partitions[n]);
 417     if (loaded_partition->partition_name == NULL) {
 418       ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 419       goto out;
 420     }
 421     loaded_partition->data_size = image_size;
 422     loaded_partition->data = image_buf; /* Transferring the owner. */
 423     loaded_partition->preloaded = image_preloaded;
 424     image_buf = NULL;
 425     image_preloaded = false;
 426   }
 427
 428   ret = AVB_SLOT_VERIFY_RESULT_OK;
 429
 430 out:
 431   /* Free the current buffer if any. */
 432   if (image_buf != NULL && !image_preloaded) {
 433     avb_free(image_buf);
 434   }
 435   /* Buffers that are already saved in slot_data will be handled by the caller
 436    * even on failure. */
 437   return ret;
 438 }
 439
 440 static AvbSlotVerifyResult load_and_verify_vbmeta(
 441     AvbOps* ops,
 442     const char* const* requested_partitions,
 443     const char* ab_suffix,
 444     bool allow_verification_error,
 445     AvbVBMetaImageFlags toplevel_vbmeta_flags,
 446     int rollback_index_location,
 447     const char* partition_name,
 448     size_t partition_name_len,
 449     const uint8_t* expected_public_key,
 450     size_t expected_public_key_length,
 451     AvbSlotVerifyData* slot_data,
 452     AvbAlgorithmType* out_algorithm_type,
 453     AvbCmdlineSubstList* out_additional_cmdline_subst) {
 454   char full_partition_name[AVB_PART_NAME_MAX_SIZE];
 455   AvbSlotVerifyResult ret;
 456   AvbIOResult io_ret;
 457   size_t vbmeta_offset;
 458   size_t vbmeta_size;
 459   uint8_t* vbmeta_buf = NULL;
 460   size_t vbmeta_num_read;
 461   AvbVBMetaVerifyResult vbmeta_ret;
 462   const uint8_t* pk_data;
 463   size_t pk_len;
 464   AvbVBMetaImageHeader vbmeta_header;
 465   uint64_t stored_rollback_index;
 466   const AvbDescriptor** descriptors = NULL;
 467   size_t num_descriptors;
 468   size_t n;
 469   bool is_main_vbmeta;
 470   bool is_vbmeta_partition;
 471   AvbVBMetaData* vbmeta_image_data = NULL;
 472
 473   ret = AVB_SLOT_VERIFY_RESULT_OK;
 474
 475   avb_assert(slot_data != NULL);
 476
 477   /* Since we allow top-level vbmeta in 'boot', use
 478    * rollback_index_location to determine whether we're the main
 479    * vbmeta struct.
 480    */
 481   is_main_vbmeta = (rollback_index_location == 0);
 482   is_vbmeta_partition = (avb_strcmp(partition_name, "vbmeta") == 0);
 483
 484   if (!avb_validate_utf8((const uint8_t*)partition_name, partition_name_len)) {
 485     avb_error("Partition name is not valid UTF-8.\n");
 486     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 487     goto out;
 488   }
 489
 490   /* Construct full partition name. */
 491   if (!avb_str_concat(full_partition_name,
 492                       sizeof full_partition_name,
 493                       partition_name,
 494                       partition_name_len,
 495                       ab_suffix,
 496                       avb_strlen(ab_suffix))) {
 497     avb_error("Partition name and suffix does not fit.\n");
 498     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 499     goto out;
 500   }
 501
 502   avb_debugv("Loading vbmeta struct from partition '",
 503              full_partition_name,
 504              "'.\n",
 505              NULL);
 506
 507   /* If we're loading from the main vbmeta partition, the vbmeta
 508    * struct is in the beginning. Otherwise we have to locate it via a
 509    * footer.
 510    */
 511   if (is_vbmeta_partition) {
 512     vbmeta_offset = 0;
 513     vbmeta_size = VBMETA_MAX_SIZE;
 514   } else {
 515     uint8_t footer_buf[AVB_FOOTER_SIZE];
 516     size_t footer_num_read;
 517     AvbFooter footer;
 518
 519     io_ret = ops->read_from_partition(ops,
 520                                       full_partition_name,
 521                                       -AVB_FOOTER_SIZE,
 522                                       AVB_FOOTER_SIZE,
 523                                       footer_buf,
 524                                       &footer_num_read);
 525     if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 526       ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 527       goto out;
 528     } else if (io_ret != AVB_IO_RESULT_OK) {
 529       avb_errorv(full_partition_name, ": Error loading footer.\n", NULL);
 530       ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 531       goto out;
 532     }
 533     avb_assert(footer_num_read == AVB_FOOTER_SIZE);
 534
 535     if (!avb_footer_validate_and_byteswap((const AvbFooter*)footer_buf,
 536                                           &footer)) {
 537       avb_errorv(full_partition_name, ": Error validating footer.\n", NULL);
 538       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 539       goto out;
 540     }
 541
 542     /* Basic footer sanity check since the data is untrusted. */
 543     if (footer.vbmeta_size > VBMETA_MAX_SIZE) {
 544       avb_errorv(
 545           full_partition_name, ": Invalid vbmeta size in footer.\n", NULL);
 546       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 547       goto out;
 548     }
 549
 550     vbmeta_offset = footer.vbmeta_offset;
 551     vbmeta_size = footer.vbmeta_size;
 552   }
 553
 554   vbmeta_buf = avb_malloc(vbmeta_size);
 555   if (vbmeta_buf == NULL) {
 556     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 557     goto out;
 558   }
 559
 560   io_ret = ops->read_from_partition(ops,
 561                                     full_partition_name,
 562                                     vbmeta_offset,
 563                                     vbmeta_size,
 564                                     vbmeta_buf,
 565                                     &vbmeta_num_read);
 566   if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 567     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 568     goto out;
 569   } else if (io_ret != AVB_IO_RESULT_OK) {
 570     /* If we're looking for 'vbmeta' but there is no such partition,
 571      * go try to get it from the boot partition instead.
 572      */
 573     if (is_main_vbmeta && io_ret == AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION &&
 574         is_vbmeta_partition) {
 575       avb_debugv(full_partition_name,
 576                  ": No such partition. Trying 'boot' instead.\n",
 577                  NULL);
 578       ret = load_and_verify_vbmeta(ops,
 579                                    requested_partitions,
 580                                    ab_suffix,
 581                                    allow_verification_error,
 582                                    0 /* toplevel_vbmeta_flags */,
 583                                    0 /* rollback_index_location */,
 584                                    "boot",
 585                                    avb_strlen("boot"),
 586                                    NULL /* expected_public_key */,
 587                                    0 /* expected_public_key_length */,
 588                                    slot_data,
 589                                    out_algorithm_type,
 590                                    out_additional_cmdline_subst);
 591       goto out;
 592     } else {
 593       avb_errorv(full_partition_name, ": Error loading vbmeta data.\n", NULL);
 594       ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 595       goto out;
 596     }
 597   }
 598   avb_assert(vbmeta_num_read <= vbmeta_size);
 599
 600   /* Check if the image is properly signed and get the public key used
 601    * to sign the image.
 602    */
 603   vbmeta_ret =
 604       avb_vbmeta_image_verify(vbmeta_buf, vbmeta_num_read, &pk_data, &pk_len);
 605   switch (vbmeta_ret) {
 606     case AVB_VBMETA_VERIFY_RESULT_OK:
 607       avb_assert(pk_data != NULL && pk_len > 0);
 608       break;
 609
 610     case AVB_VBMETA_VERIFY_RESULT_OK_NOT_SIGNED:
 611     case AVB_VBMETA_VERIFY_RESULT_HASH_MISMATCH:
 612     case AVB_VBMETA_VERIFY_RESULT_SIGNATURE_MISMATCH:
 613       ret = AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION;
 614       avb_errorv(full_partition_name,
 615                  ": Error verifying vbmeta image: ",
 616                  avb_vbmeta_verify_result_to_string(vbmeta_ret),
 617                  "\n",
 618                  NULL);
 619       if (!allow_verification_error) {
 620         goto out;
 621       }
 622       break;
 623
 624     case AVB_VBMETA_VERIFY_RESULT_INVALID_VBMETA_HEADER:
 625       /* No way to continue this case. */
 626       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 627       avb_errorv(full_partition_name,
 628                  ": Error verifying vbmeta image: invalid vbmeta header\n",
 629                  NULL);
 630       goto out;
 631
 632     case AVB_VBMETA_VERIFY_RESULT_UNSUPPORTED_VERSION:
 633       /* No way to continue this case. */
 634       ret = AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION;
 635       avb_errorv(full_partition_name,
 636                  ": Error verifying vbmeta image: unsupported AVB version\n",
 637                  NULL);
 638       goto out;
 639   }
 640
 641   /* Byteswap the header. */
 642   avb_vbmeta_image_header_to_host_byte_order((AvbVBMetaImageHeader*)vbmeta_buf,
 643                                              &vbmeta_header);
 644
 645   /* If we're the toplevel, assign flags so they'll be passed down. */
 646   if (is_main_vbmeta) {
 647     toplevel_vbmeta_flags = (AvbVBMetaImageFlags)vbmeta_header.flags;
 648   } else {
 649     if (vbmeta_header.flags != 0) {
 650       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 651       avb_errorv(full_partition_name,
 652                  ": chained vbmeta image has non-zero flags\n",
 653                  NULL);
 654       goto out;
 655     }
 656   }
 657
 658   /* Check if key used to make signature matches what is expected. */
 659   if (pk_data != NULL) {
 660     if (expected_public_key != NULL) {
 661       avb_assert(!is_main_vbmeta);
 662       if (expected_public_key_length != pk_len ||
 663           avb_safe_memcmp(expected_public_key, pk_data, pk_len) != 0) {
 664         avb_errorv(full_partition_name,
 665                    ": Public key used to sign data does not match key in chain "
 666                    "partition descriptor.\n",
 667                    NULL);
 668         ret = AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED;
 669         if (!allow_verification_error) {
 670           goto out;
 671         }
 672       }
 673     } else {
 674       bool key_is_trusted = false;
 675       const uint8_t* pk_metadata = NULL;
 676       size_t pk_metadata_len = 0;
 677
 678       if (vbmeta_header.public_key_metadata_size > 0) {
 679         pk_metadata = vbmeta_buf + sizeof(AvbVBMetaImageHeader) +
 680                       vbmeta_header.authentication_data_block_size +
 681                       vbmeta_header.public_key_metadata_offset;
 682         pk_metadata_len = vbmeta_header.public_key_metadata_size;
 683       }
 684
 685       avb_assert(is_main_vbmeta);
 686       io_ret = ops->validate_vbmeta_public_key(
 687           ops, pk_data, pk_len, pk_metadata, pk_metadata_len, &key_is_trusted);
 688       if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 689         ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 690         goto out;
 691       } else if (io_ret != AVB_IO_RESULT_OK) {
 692         avb_errorv(full_partition_name,
 693                    ": Error while checking public key used to sign data.\n",
 694                    NULL);
 695         ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 696         goto out;
 697       }
 698       if (!key_is_trusted) {
 699         avb_errorv(full_partition_name,
 700                    ": Public key used to sign data rejected.\n",
 701                    NULL);
 702         ret = AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED;
 703         if (!allow_verification_error) {
 704           goto out;
 705         }
 706       }
 707     }
 708   }
 709
 710   /* Check rollback index. */
 711   io_ret = ops->read_rollback_index(
 712       ops, rollback_index_location, &stored_rollback_index);
 713   if (io_ret == AVB_IO_RESULT_ERROR_OOM) {
 714     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 715     goto out;
 716   } else if (io_ret != AVB_IO_RESULT_OK) {
 717     avb_errorv(full_partition_name,
 718                ": Error getting rollback index for location.\n",
 719                NULL);
 720     ret = AVB_SLOT_VERIFY_RESULT_ERROR_IO;
 721     goto out;
 722   }
 723   if (vbmeta_header.rollback_index < stored_rollback_index) {
 724     avb_errorv(
 725         full_partition_name,
 726         ": Image rollback index is less than the stored rollback index.\n",
 727         NULL);
 728     ret = AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX;
 729     if (!allow_verification_error) {
 730       goto out;
 731     }
 732   }
 733
 734   /* Copy vbmeta to vbmeta_images before recursing. */
 735   if (is_main_vbmeta) {
 736     avb_assert(slot_data->num_vbmeta_images == 0);
 737   } else {
 738     avb_assert(slot_data->num_vbmeta_images > 0);
 739   }
 740   if (slot_data->num_vbmeta_images == MAX_NUMBER_OF_VBMETA_IMAGES) {
 741     avb_errorv(full_partition_name, ": Too many vbmeta images.\n", NULL);
 742     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 743     goto out;
 744   }
 745   vbmeta_image_data = &slot_data->vbmeta_images[slot_data->num_vbmeta_images++];
 746   vbmeta_image_data->partition_name = avb_strdup(partition_name);
 747   vbmeta_image_data->vbmeta_data = vbmeta_buf;
 748   /* Note that |vbmeta_buf| is actually |vbmeta_num_read| bytes long
 749    * and this includes data past the end of the image. Pass the
 750    * actual size of the vbmeta image. Also, no need to use
 751    * avb_safe_add() since the header has already been verified.
 752    */
 753   vbmeta_image_data->vbmeta_size =
 754       sizeof(AvbVBMetaImageHeader) +
 755       vbmeta_header.authentication_data_block_size +
 756       vbmeta_header.auxiliary_data_block_size;
 757   vbmeta_image_data->verify_result = vbmeta_ret;
 758
 759   /* If verification has been disabled by setting a bit in the image,
 760    * we're done... except that we need to load the entirety of the
 761    * requested partitions.
 762    */
 763   if (vbmeta_header.flags & AVB_VBMETA_IMAGE_FLAGS_VERIFICATION_DISABLED) {
 764     AvbSlotVerifyResult sub_ret;
 765     avb_debugv(
 766         full_partition_name, ": VERIFICATION_DISABLED bit is set.\n", NULL);
 767     /* If load_requested_partitions() fail it is always a fatal
 768      * failure (e.g. ERROR_INVALID_ARGUMENT, ERROR_OOM, etc.) rather
 769      * than recoverable (e.g. one where result_should_continue()
 770      * returns true) and we want to convey that error.
 771      */
 772     sub_ret = load_requested_partitions(
 773         ops, requested_partitions, ab_suffix, slot_data);
 774     if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) {
 775       ret = sub_ret;
 776     }
 777     goto out;
 778   }
 779
 780   /* Now go through all descriptors and take the appropriate action:
 781    *
 782    * - hash descriptor: Load data from partition, calculate hash, and
 783    *   checks that it matches what's in the hash descriptor.
 784    *
 785    * - hashtree descriptor: Do nothing since verification happens
 786    *   on-the-fly from within the OS. (Unless the descriptor uses a
 787    *   persistent digest, in which case we need to find it).
 788    *
 789    * - chained partition descriptor: Load the footer, load the vbmeta
 790    *   image, verify vbmeta image (includes rollback checks, hash
 791    *   checks, bail on chained partitions).
 792    */
 793   descriptors =
 794       avb_descriptor_get_all(vbmeta_buf, vbmeta_num_read, &num_descriptors);
 795   for (n = 0; n < num_descriptors; n++) {
 796     AvbDescriptor desc;
 797
 798     if (!avb_descriptor_validate_and_byteswap(descriptors[n], &desc)) {
 799       avb_errorv(full_partition_name, ": Descriptor is invalid.\n", NULL);
 800       ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 801       goto out;
 802     }
 803
 804     switch (desc.tag) {
 805       case AVB_DESCRIPTOR_TAG_HASH: {
 806         AvbSlotVerifyResult sub_ret;
 807         sub_ret = load_and_verify_hash_partition(ops,
 808                                                  requested_partitions,
 809                                                  ab_suffix,
 810                                                  allow_verification_error,
 811                                                  descriptors[n],
 812                                                  slot_data);
 813         if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) {
 814           ret = sub_ret;
 815           if (!allow_verification_error || !result_should_continue(ret)) {
 816             goto out;
 817           }
 818         }
 819       } break;
 820
 821       case AVB_DESCRIPTOR_TAG_CHAIN_PARTITION: {
 822         AvbSlotVerifyResult sub_ret;
 823         AvbChainPartitionDescriptor chain_desc;
 824         const uint8_t* chain_partition_name;
 825         const uint8_t* chain_public_key;
 826
 827         /* Only allow CHAIN_PARTITION descriptors in the main vbmeta image. */
 828         if (!is_main_vbmeta) {
 829           avb_errorv(full_partition_name,
 830                      ": Encountered chain descriptor not in main image.\n",
 831                      NULL);
 832           ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 833           goto out;
 834         }
 835
 836         if (!avb_chain_partition_descriptor_validate_and_byteswap(
 837                 (AvbChainPartitionDescriptor*)descriptors[n], &chain_desc)) {
 838           avb_errorv(full_partition_name,
 839                      ": Chain partition descriptor is invalid.\n",
 840                      NULL);
 841           ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 842           goto out;
 843         }
 844
 845         if (chain_desc.rollback_index_location == 0) {
 846           avb_errorv(full_partition_name,
 847                      ": Chain partition has invalid "
 848                      "rollback_index_location field.\n",
 849                      NULL);
 850           ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 851           goto out;
 852         }
 853
 854         chain_partition_name = ((const uint8_t*)descriptors[n]) +
 855                                sizeof(AvbChainPartitionDescriptor);
 856         chain_public_key = chain_partition_name + chain_desc.partition_name_len;
 857
 858         sub_ret =
 859             load_and_verify_vbmeta(ops,
 860                                    requested_partitions,
 861                                    ab_suffix,
 862                                    allow_verification_error,
 863                                    toplevel_vbmeta_flags,
 864                                    chain_desc.rollback_index_location,
 865                                    (const char*)chain_partition_name,
 866                                    chain_desc.partition_name_len,
 867                                    chain_public_key,
 868                                    chain_desc.public_key_len,
 869                                    slot_data,
 870                                    NULL, /* out_algorithm_type */
 871                                    NULL /* out_additional_cmdline_subst */);
 872         if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) {
 873           ret = sub_ret;
 874           if (!result_should_continue(ret)) {
 875             goto out;
 876           }
 877         }
 878       } break;
 879
 880       case AVB_DESCRIPTOR_TAG_KERNEL_CMDLINE: {
 881         const uint8_t* kernel_cmdline;
 882         AvbKernelCmdlineDescriptor kernel_cmdline_desc;
 883         bool apply_cmdline;
 884
 885         if (!avb_kernel_cmdline_descriptor_validate_and_byteswap(
 886                 (AvbKernelCmdlineDescriptor*)descriptors[n],
 887                 &kernel_cmdline_desc)) {
 888           avb_errorv(full_partition_name,
 889                      ": Kernel cmdline descriptor is invalid.\n",
 890                      NULL);
 891           ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 892           goto out;
 893         }
 894
 895         kernel_cmdline = ((const uint8_t*)descriptors[n]) +
 896                          sizeof(AvbKernelCmdlineDescriptor);
 897
 898         if (!avb_validate_utf8(kernel_cmdline,
 899                                kernel_cmdline_desc.kernel_cmdline_length)) {
 900           avb_errorv(full_partition_name,
 901                      ": Kernel cmdline is not valid UTF-8.\n",
 902                      NULL);
 903           ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 904           goto out;
 905         }
 906
 907         /* Compare the flags for top-level VBMeta struct with flags in
 908          * the command-line descriptor so command-line snippets only
 909          * intended for a certain mode (dm-verity enabled/disabled)
 910          * are skipped if applicable.
 911          */
 912         apply_cmdline = true;
 913         if (toplevel_vbmeta_flags & AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED) {
 914           if (kernel_cmdline_desc.flags &
 915               AVB_KERNEL_CMDLINE_FLAGS_USE_ONLY_IF_HASHTREE_NOT_DISABLED) {
 916             apply_cmdline = false;
 917           }
 918         } else {
 919           if (kernel_cmdline_desc.flags &
 920               AVB_KERNEL_CMDLINE_FLAGS_USE_ONLY_IF_HASHTREE_DISABLED) {
 921             apply_cmdline = false;
 922           }
 923         }
 924
 925         if (apply_cmdline) {
 926           if (slot_data->cmdline == NULL) {
 927             slot_data->cmdline =
 928                 avb_calloc(kernel_cmdline_desc.kernel_cmdline_length + 1);
 929             if (slot_data->cmdline == NULL) {
 930               ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 931               goto out;
 932             }
 933             avb_memcpy(slot_data->cmdline,
 934                        kernel_cmdline,
 935                        kernel_cmdline_desc.kernel_cmdline_length);
 936           } else {
 937             /* new cmdline is: <existing_cmdline> + ' ' + <newcmdline> + '\0' */
 938             size_t orig_size = avb_strlen(slot_data->cmdline);
 939             size_t new_size =
 940                 orig_size + 1 + kernel_cmdline_desc.kernel_cmdline_length + 1;
 941             char* new_cmdline = avb_calloc(new_size);
 942             if (new_cmdline == NULL) {
 943               ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
 944               goto out;
 945             }
 946             avb_memcpy(new_cmdline, slot_data->cmdline, orig_size);
 947             new_cmdline[orig_size] = ' ';
 948             avb_memcpy(new_cmdline + orig_size + 1,
 949                        kernel_cmdline,
 950                        kernel_cmdline_desc.kernel_cmdline_length);
 951             avb_free(slot_data->cmdline);
 952             slot_data->cmdline = new_cmdline;
 953           }
 954         }
 955       } break;
 956
 957       case AVB_DESCRIPTOR_TAG_HASHTREE: {
 958         AvbHashtreeDescriptor hashtree_desc;
 959
 960         if (!avb_hashtree_descriptor_validate_and_byteswap(
 961                 (AvbHashtreeDescriptor*)descriptors[n], &hashtree_desc)) {
 962           avb_errorv(
 963               full_partition_name, ": Hashtree descriptor is invalid.\n", NULL);
 964           ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 965           goto out;
 966         }
 967
 968         /* We only need to continue when there is no digest in the descriptor.
 969          * This is because the only processing here is to find the digest and
 970          * make it available on the kernel command line.
 971          */
 972         if (hashtree_desc.root_digest_len == 0) {
 973           char part_name[AVB_PART_NAME_MAX_SIZE];
 974           size_t digest_len = 0;
 975           uint8_t digest_buf[AVB_SHA512_DIGEST_SIZE];
 976           const uint8_t* desc_partition_name =
 977               ((const uint8_t*)descriptors[n]) + sizeof(AvbHashtreeDescriptor);
 978
 979           if (!avb_validate_utf8(desc_partition_name,
 980                                  hashtree_desc.partition_name_len)) {
 981             avb_error("Partition name is not valid UTF-8.\n");
 982             ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 983             goto out;
 984           }
 985
 986           /* No ab_suffix for partitions without a digest in the descriptor
 987            * because these partitions hold data unique to this device and are
 988            * not updated using an A/B scheme.
 989            */
 990           if ((hashtree_desc.flags &
 991                AVB_HASHTREE_DESCRIPTOR_FLAGS_DO_NOT_USE_AB) == 0 &&
 992               avb_strlen(ab_suffix) != 0) {
 993             avb_error("Cannot use A/B with a persistent root digest.\n");
 994             ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
 995             goto out;
 996           }
 997           if (hashtree_desc.partition_name_len >= AVB_PART_NAME_MAX_SIZE) {
 998             avb_error("Partition name does not fit.\n");
 999             ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
1000             goto out;
1001           }
1002           avb_memcpy(
1003               part_name, desc_partition_name, hashtree_desc.partition_name_len);
1004           part_name[hashtree_desc.partition_name_len] = '\0';
1005
1006           /* Determine the expected digest size from the hash algorithm. */
1007           if (avb_strcmp((const char*)hashtree_desc.hash_algorithm, "sha1") ==
1008               0) {
1009             digest_len = AVB_SHA1_DIGEST_SIZE;
1010           } else if (avb_strcmp((const char*)hashtree_desc.hash_algorithm,
1011                                 "sha256") == 0) {
1012             digest_len = AVB_SHA256_DIGEST_SIZE;
1013           } else if (avb_strcmp((const char*)hashtree_desc.hash_algorithm,
1014                                 "sha512") == 0) {
1015             digest_len = AVB_SHA512_DIGEST_SIZE;
1016           } else {
1017             avb_errorv(part_name, ": Unsupported hash algorithm.\n", NULL);
1018             ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
1019             goto out;
1020           }
1021
1022           ret = read_persistent_digest(ops, part_name, digest_len, digest_buf);
1023           if (ret != AVB_SLOT_VERIFY_RESULT_OK) {
1024             goto out;
1025           }
1026
1027           if (out_additional_cmdline_subst) {
1028             ret =
1029                 avb_add_root_digest_substitution(part_name,
1030                                                  digest_buf,
1031                                                  digest_len,
1032                                                  out_additional_cmdline_subst);
1033             if (ret != AVB_SLOT_VERIFY_RESULT_OK) {
1034               goto out;
1035             }
1036           }
1037         }
1038       } break;
1039
1040       case AVB_DESCRIPTOR_TAG_PROPERTY:
1041         /* Do nothing. */
1042         break;
1043     }
1044   }
1045
1046   if (rollback_index_location >= AVB_MAX_NUMBER_OF_ROLLBACK_INDEX_LOCATIONS) {
1047     avb_errorv(
1048         full_partition_name, ": Invalid rollback_index_location.\n", NULL);
1049     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;
1050     goto out;
1051   }
1052
1053   slot_data->rollback_indexes[rollback_index_location] =
1054       vbmeta_header.rollback_index;
1055
1056   if (out_algorithm_type != NULL) {
1057     *out_algorithm_type = (AvbAlgorithmType)vbmeta_header.algorithm_type;
1058   }
1059
1060 out:
1061   /* If |vbmeta_image_data| isn't NULL it means that it adopted
1062    * |vbmeta_buf| so in that case don't free it here.
1063    */
1064   if (vbmeta_image_data == NULL) {
1065     if (vbmeta_buf != NULL) {
1066       avb_free(vbmeta_buf);
1067     }
1068   }
1069   if (descriptors != NULL) {
1070     avb_free(descriptors);
1071   }
1072   return ret;
1073 }
1074
1075 AvbSlotVerifyResult avb_slot_verify(AvbOps* ops,
1076                                     const char* const* requested_partitions,
1077                                     const char* ab_suffix,
1078                                     AvbSlotVerifyFlags flags,
1079                                     AvbHashtreeErrorMode hashtree_error_mode,
1080                                     AvbSlotVerifyData** out_data) {
1081   AvbSlotVerifyResult ret;
1082   AvbSlotVerifyData* slot_data = NULL;
1083   AvbAlgorithmType algorithm_type = AVB_ALGORITHM_TYPE_NONE;
1084   bool using_boot_for_vbmeta = false;
1085   AvbVBMetaImageHeader toplevel_vbmeta;
1086   bool allow_verification_error =
1087       (flags & AVB_SLOT_VERIFY_FLAGS_ALLOW_VERIFICATION_ERROR);
1088   AvbCmdlineSubstList* additional_cmdline_subst = NULL;
1089
1090   /* Fail early if we're missing the AvbOps needed for slot verification.
1091    *
1092    * For now, handle get_size_of_partition() not being implemented. In
1093    * a later release we may change that.
1094    */
1095   avb_assert(ops->read_is_device_unlocked != NULL);
1096   avb_assert(ops->read_from_partition != NULL);
1097   avb_assert(ops->validate_vbmeta_public_key != NULL);
1098   avb_assert(ops->read_rollback_index != NULL);
1099   avb_assert(ops->get_unique_guid_for_partition != NULL);
1100
1101   if (out_data != NULL) {
1102     *out_data = NULL;
1103   }
1104
1105   /* Allowing dm-verity errors defeats the purpose of verified boot so
1106    * only allow this if set up to allow verification errors
1107    * (e.g. typically only UNLOCKED mode).
1108    */
1109   if (hashtree_error_mode == AVB_HASHTREE_ERROR_MODE_LOGGING &&
1110       !allow_verification_error) {
1111     ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT;
1112     goto fail;
1113   }
1114
1115   slot_data = avb_calloc(sizeof(AvbSlotVerifyData));
1116   if (slot_data == NULL) {
1117     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1118     goto fail;
1119   }
1120   slot_data->vbmeta_images =
1121       avb_calloc(sizeof(AvbVBMetaData) * MAX_NUMBER_OF_VBMETA_IMAGES);
1122   if (slot_data->vbmeta_images == NULL) {
1123     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1124     goto fail;
1125   }
1126   slot_data->loaded_partitions =
1127       avb_calloc(sizeof(AvbPartitionData) * MAX_NUMBER_OF_LOADED_PARTITIONS);
1128   if (slot_data->loaded_partitions == NULL) {
1129     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1130     goto fail;
1131   }
1132
1133   additional_cmdline_subst = avb_new_cmdline_subst_list();
1134   if (additional_cmdline_subst == NULL) {
1135     ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1136     goto fail;
1137   }
1138
1139   ret = load_and_verify_vbmeta(ops,
1140                                requested_partitions,
1141                                ab_suffix,
1142                                allow_verification_error,
1143                                0 /* toplevel_vbmeta_flags */,
1144                                0 /* rollback_index_location */,
1145                                "vbmeta",
1146                                avb_strlen("vbmeta"),
1147                                NULL /* expected_public_key */,
1148                                0 /* expected_public_key_length */,
1149                                slot_data,
1150                                &algorithm_type,
1151                                additional_cmdline_subst);
1152   if (!allow_verification_error && ret != AVB_SLOT_VERIFY_RESULT_OK) {
1153     goto fail;
1154   }
1155
1156   /* If things check out, mangle the kernel command-line as needed. */
1157   if (result_should_continue(ret)) {
1158     if (avb_strcmp(slot_data->vbmeta_images[0].partition_name, "vbmeta") != 0) {
1159       avb_assert(
1160           avb_strcmp(slot_data->vbmeta_images[0].partition_name, "boot") == 0);
1161       using_boot_for_vbmeta = true;
1162     }
1163
1164     /* Byteswap top-level vbmeta header since we'll need it below. */
1165     avb_vbmeta_image_header_to_host_byte_order(
1166         (const AvbVBMetaImageHeader*)slot_data->vbmeta_images[0].vbmeta_data,
1167         &toplevel_vbmeta);
1168
1169     /* Fill in |ab_suffix| field. */
1170     slot_data->ab_suffix = avb_strdup(ab_suffix);
1171     if (slot_data->ab_suffix == NULL) {
1172       ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1173       goto fail;
1174     }
1175
1176     /* If verification is disabled, we are done ... we specifically
1177      * don't want to add any androidboot.* options since verification
1178      * is disabled.
1179      */
1180     if (toplevel_vbmeta.flags & AVB_VBMETA_IMAGE_FLAGS_VERIFICATION_DISABLED) {
1181       /* Since verification is disabled we didn't process any
1182        * descriptors and thus there's no cmdline... so set root= such
1183        * that the system partition is mounted.
1184        */
1185       avb_assert(slot_data->cmdline == NULL);
1186       slot_data->cmdline =
1187           avb_strdup("root=PARTUUID=$(ANDROID_SYSTEM_PARTUUID)");
1188       if (slot_data->cmdline == NULL) {
1189         ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1190         goto fail;
1191       }
1192     } else {
1193       /* Add options - any failure in avb_append_options() is either an
1194        * I/O or OOM error.
1195        */
1196       AvbSlotVerifyResult sub_ret = avb_append_options(ops,
1197                                                        slot_data,
1198                                                        &toplevel_vbmeta,
1199                                                        algorithm_type,
1200                                                        hashtree_error_mode);
1201       if (sub_ret != AVB_SLOT_VERIFY_RESULT_OK) {
1202         ret = sub_ret;
1203         goto fail;
1204       }
1205     }
1206
1207     /* Substitute $(ANDROID_SYSTEM_PARTUUID) and friends. */
1208     if (slot_data->cmdline != NULL) {
1209       char* new_cmdline;
1210       new_cmdline = avb_sub_cmdline(ops,
1211                                     slot_data->cmdline,
1212                                     ab_suffix,
1213                                     using_boot_for_vbmeta,
1214                                     additional_cmdline_subst);
1215       if (new_cmdline != slot_data->cmdline) {
1216         if (new_cmdline == NULL) {
1217           ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;
1218           goto fail;
1219         }
1220         avb_free(slot_data->cmdline);
1221         slot_data->cmdline = new_cmdline;
1222       }
1223     }
1224
1225     if (out_data != NULL) {
1226       *out_data = slot_data;
1227     } else {
1228       avb_slot_verify_data_free(slot_data);
1229     }
1230   }
1231
1232   avb_free_cmdline_subst_list(additional_cmdline_subst);
1233   additional_cmdline_subst = NULL;
1234
1235   if (!allow_verification_error) {
1236     avb_assert(ret == AVB_SLOT_VERIFY_RESULT_OK);
1237   }
1238
1239   return ret;
1240
1241 fail:
1242   if (slot_data != NULL) {
1243     avb_slot_verify_data_free(slot_data);
1244   }
1245   if (additional_cmdline_subst != NULL) {
1246     avb_free_cmdline_subst_list(additional_cmdline_subst);
1247   }
1248   return ret;
1249 }
1250
1251 void avb_slot_verify_data_free(AvbSlotVerifyData* data) {
1252   if (data->ab_suffix != NULL) {
1253     avb_free(data->ab_suffix);
1254   }
1255   if (data->cmdline != NULL) {
1256     avb_free(data->cmdline);
1257   }
1258   if (data->vbmeta_images != NULL) {
1259     size_t n;
1260     for (n = 0; n < data->num_vbmeta_images; n++) {
1261       AvbVBMetaData* vbmeta_image = &data->vbmeta_images[n];
1262       if (vbmeta_image->partition_name != NULL) {
1263         avb_free(vbmeta_image->partition_name);
1264       }
1265       if (vbmeta_image->vbmeta_data != NULL) {
1266         avb_free(vbmeta_image->vbmeta_data);
1267       }
1268     }
1269     avb_free(data->vbmeta_images);
1270   }
1271   if (data->loaded_partitions != NULL) {
1272     size_t n;
1273     for (n = 0; n < data->num_loaded_partitions; n++) {
1274       AvbPartitionData* loaded_partition = &data->loaded_partitions[n];
1275       if (loaded_partition->partition_name != NULL) {
1276         avb_free(loaded_partition->partition_name);
1277       }
1278       if (loaded_partition->data != NULL && !loaded_partition->preloaded) {
1279         avb_free(loaded_partition->data);
1280       }
1281     }
1282     avb_free(data->loaded_partitions);
1283   }
1284   avb_free(data);
1285 }
1286
1287 const char* avb_slot_verify_result_to_string(AvbSlotVerifyResult result) {
1288   const char* ret = NULL;
1289
1290   switch (result) {
1291     case AVB_SLOT_VERIFY_RESULT_OK:
1292       ret = "OK";
1293       break;
1294     case AVB_SLOT_VERIFY_RESULT_ERROR_OOM:
1295       ret = "ERROR_OOM";
1296       break;
1297     case AVB_SLOT_VERIFY_RESULT_ERROR_IO:
1298       ret = "ERROR_IO";
1299       break;
1300     case AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION:
1301       ret = "ERROR_VERIFICATION";
1302       break;
1303     case AVB_SLOT_VERIFY_RESULT_ERROR_ROLLBACK_INDEX:
1304       ret = "ERROR_ROLLBACK_INDEX";
1305       break;
1306     case AVB_SLOT_VERIFY_RESULT_ERROR_PUBLIC_KEY_REJECTED:
1307       ret = "ERROR_PUBLIC_KEY_REJECTED";
1308       break;
1309     case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA:
1310       ret = "ERROR_INVALID_METADATA";
1311       break;
1312     case AVB_SLOT_VERIFY_RESULT_ERROR_UNSUPPORTED_VERSION:
1313       ret = "ERROR_UNSUPPORTED_VERSION";
1314       break;
1315     case AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_ARGUMENT:
1316       ret = "ERROR_INVALID_ARGUMENT";
1317       break;
1318       /* Do not add a 'default:' case here because of -Wswitch. */
1319   }
1320
1321   if (ret == NULL) {
1322     avb_error("Unknown AvbSlotVerifyResult value.\n");
1323     ret = "(unknown)";
1324   }
1325
1326   return ret;
1327 }
1328
1329 void avb_slot_verify_data_calculate_vbmeta_digest(AvbSlotVerifyData* data,
1330                                                   AvbDigestType digest_type,
1331                                                   uint8_t* out_digest) {
1332   bool ret = false;
1333   size_t n;
1334
1335   switch (digest_type) {
1336     case AVB_DIGEST_TYPE_SHA256: {
1337       AvbSHA256Ctx ctx;
1338       avb_sha256_init(&ctx);
1339       for (n = 0; n < data->num_vbmeta_images; n++) {
1340         avb_sha256_update(&ctx,
1341                           data->vbmeta_images[n].vbmeta_data,
1342                           data->vbmeta_images[n].vbmeta_size);
1343       }
1344       avb_memcpy(out_digest, avb_sha256_final(&ctx), AVB_SHA256_DIGEST_SIZE);
1345       ret = true;
1346     } break;
1347
1348     case AVB_DIGEST_TYPE_SHA512: {
1349       AvbSHA512Ctx ctx;
1350       avb_sha512_init(&ctx);
1351       for (n = 0; n < data->num_vbmeta_images; n++) {
1352         avb_sha512_update(&ctx,
1353                           data->vbmeta_images[n].vbmeta_data,
1354                           data->vbmeta_images[n].vbmeta_size);
1355       }
1356       avb_memcpy(out_digest, avb_sha512_final(&ctx), AVB_SHA512_DIGEST_SIZE);
1357       ret = true;
1358     } break;
1359
1360       /* Do not add a 'default:' case here because of -Wswitch. */
1361   }
1362
1363   if (!ret) {
1364     avb_fatal("Unknown digest type");
1365   }
1366 }