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