SQLMinimum libavb version:   1.0Header Block:             256 bytesAuthentication Block:     320 bytesAuxiliary Block:          1344 bytesPublic key (sha1):        xxxxxxxxxxxxxxxxxxba86e5364c66f4f2ea8aAlgorithm:                SHA256_RSA2048Rollback Index:           0Flags:                    0Rollback Index Location:  0Release String:           'avbtool 1.1.0'Descriptors:    Kernel Cmdline descriptor:      Flags:                 0      Kernel Cmdline:        xxxxxxxx1e34dfe7 2 restart_on_corruption ignore_zero_blocks"'    Hash descriptor:      Image Size:            6148096 bytes      Hash Algorithm:        sha256      Partition Name:        boot      Salt:                  xxxxxxxxxxxxxxxxxx284bf950defaea1c71e9642d99441eb6bdb6814xxxxxxx      Digest:                xxxxxxxxxxxxxxxxxx9f367d1b44a4ad0169dfe501034658393b31281xxxxxxx      Flags:                 0    Hashtree descriptor:      Version of dm-verity:  1      Image Size:            503840768 bytes      Tree Offset:           503840768      Tree Size:             0 bytes      Data Block Size:       4096 bytes      Hash Block Size:       4096 bytes      FEC num roots:         0      FEC offset:            0      FEC size:              0 bytes      Hash Algorithm:        sha1      Partition Name:        system      Salt:                  xxxxxxxxxxxxxx7e076c223f55x17a9c6a3d2xxa      Root Digest:           xxxxxxxxxxxxxx30562aaea487xa392b0564bxx8      Flags:                 0

C/* Binary format for header of the vbmeta image. * * The vbmeta image consists of three blocks: * *  +-----------------------------------------+ *  | Header data - fixed size                | *  +-----------------------------------------+ *  | Authentication data - variable size     | *  +-----------------------------------------+ *  | Auxiliary data - variable size          | *  +-----------------------------------------+ * * The "Header data" block is described by this struct and is always * |AVB_VBMETA_IMAGE_HEADER_SIZE| bytes long. * * The "Authentication data" block is |authentication_data_block_size| * bytes long and contains the hash and signature used to authenticate * the vbmeta image. The type of the hash and signature is defined by * the |algorithm_type| field. * * The "Auxiliary data" is |auxiliary_data_block_size| bytes long and * contains the auxiliary data including the public key used to make * the signature and descriptors. * * The public key is at offset |public_key_offset| with size * |public_key_size| in this block. The size of the public key data is * defined by the |algorithm_type| field. The format of the public key * data is described in the |AvbRSAPublicKeyHeader| struct. * * The descriptors starts at |descriptors_offset| from the beginning * of the "Auxiliary Data" block and take up |descriptors_size| * bytes. Each descriptor is stored as a |AvbDescriptor| with tag and * number of bytes following. The number of descriptors can be * determined by walking this data until |descriptors_size| is * exhausted. */ typedef struct AvbVBMetaImageHeader {  /*   0: Four bytes equal to "AVB0" (AVB_MAGIC). */  uint8_t magic[AVB_MAGIC_LEN];  /*   4: The major version of libavb required for this header. */  uint32_t required_libavb_version_major;  /*   8: The minor version of libavb required for this header. */  uint32_t required_libavb_version_minor;  /*  12: The size of the signature block. */  uint64_t authentication_data_block_size;  /*  20: The size of the auxiliary data block. */  uint64_t auxiliary_data_block_size;  /*  28: The verification algorithm used, see |AvbAlgorithmType| enum. */  uint32_t algorithm_type;  /*  32: Offset into the "Authentication data" block of hash data. */  uint64_t hash_offset;  /*  40: Length of the hash data. */  uint64_t hash_size;  /*  48: Offset into the "Authentication data" block of signature data. */  uint64_t signature_offset;  /*  56: Length of the signature data. */  uint64_t signature_size;  /*  64: Offset into the "Auxiliary data" block of public key data. */  uint64_t public_key_offset;  /*  72: Length of the public key data. */  uint64_t public_key_size;  /*  80: Offset into the "Auxiliary data" block of public key metadata. */  uint64_t public_key_metadata_offset;  /*  88: Length of the public key metadata. Must be set to zero if there   *  is no public key metadata.   */  uint64_t public_key_metadata_size;  /*  96: Offset into the "Auxiliary data" block of descriptor data. */  uint64_t descriptors_offset;  /* 104: Length of descriptor data. */  uint64_t descriptors_size;  /* 112: The rollback index which can be used to prevent rollback to   *  older versions.   */  uint64_t rollback_index;  /* 120: Flags from the AvbVBMetaImageFlags enumeration. This must be   * set to zero if the vbmeta image is not a top-level image.   */  uint32_t flags;  /* 124: The location of the rollback index defined in this header.   * Only valid for the main vbmeta. For chained partitions, the rollback   * index location must be specified in the AvbChainPartitionDescriptor   * and this value must be set to 0.   */  uint32_t rollback_index_location;  /* 128: The release string from avbtool, e.g. "avbtool 1.0.0" or   * "avbtool 1.0.0 xyz_board Git-234abde89". Is guaranteed to be NUL   * terminated. Applications must not make assumptions about how this   * string is formatted.   */  uint8_t release_string[AVB_RELEASE_STRING_SIZE];  /* 176: Padding to ensure struct is size AVB_VBMETA_IMAGE_HEADER_SIZE   * bytes. This must be set to zeroes.   */  uint8_t reserved[80];}

Cswitch (h.algorithm_type) {    case AVB_ALGORITHM_TYPE_SHA256_RSA2048:    case AVB_ALGORITHM_TYPE_SHA256_RSA4096:    case AVB_ALGORITHM_TYPE_SHA256_RSA8192:      avb_sha256_init(&sha256_ctx);      avb_sha256_update(&sha256_ctx, header_block, sizeof(AvbVBMetaImageHeader));      avb_sha256_update(&sha256_ctx, auxiliary_block, h.auxiliary_data_block_size);      computed_hash = avb_sha256_final(&sha256_ctx);      break;    case AVB_ALGORITHM_TYPE_SHA512_RSA2048:    case AVB_ALGORITHM_TYPE_SHA512_RSA4096:    case AVB_ALGORITHM_TYPE_SHA512_RSA8192:      avb_sha512_init(&sha512_ctx);      avb_sha512_update(&sha512_ctx, header_block, sizeof(AvbVBMetaImageHeader));      avb_sha512_update(&sha512_ctx, auxiliary_block, h.auxiliary_data_block_size);      computed_hash = avb_sha512_final(&sha512_ctx);      break;    default:      avb_error("Unknown algorithm.\n");      goto out;}if (avb_safe_memcmp(authentication_block + h.hash_offset,//认证块中hash的位置                      computed_hash,                      h.hash_size) != 0) {    avb_error("Hash does not match!\n");    ret = AVB_VBMETA_VERIFY_RESULT_HASH_MISMATCH;    goto out;  }  verification_result = avb_rsa_verify(                     auxiliary_block + h.public_key_offset,  // 公钥位置                     h.public_key_size,                      // 公钥大小                     authentication_block + h.signature_offset, // 签名位置                     h.signature_size,                       // 签名大小                     authentication_block + h.hash_offset,   // 哈希值位置                     h.hash_size,                            // 哈希大小                     algorithm->padding,                     // 填充算法                     algorithm->padding_len);                // 填充长度

Cbool avb_rsa_verify(const uint8_t* key,                    size_t key_num_bytes,                    const uint8_t* sig,                    size_t sig_num_bytes,                    const uint8_t* hash,                    size_t hash_num_bytes,                    const uint8_t* padding,                    size_t padding_num_bytes) {  uint8_t* buf = NULL;  IAvbKey* parsed_key = NULL;  bool success = false;  if (key == NULL || sig == NULL || hash == NULL || padding == NULL) {    avb_error("Invalid input.\n");    goto out;  }  parsed_key = iavb_parse_key_data(key, key_num_bytes);// 用于解析传入的公钥数据,将公钥从其原始格式转换为 IAvbKey 结构体  if (parsed_key == NULL) {    avb_error("Error parsing key.\n");    goto out;  }  //... 签名长度检查等  modpowF4(parsed_key, buf);//  /* Check padding bytes.   *   * Even though there are probably no timing issues here, we use   * avb_safe_memcmp() just to be on the safe side.   /  if (avb_safe_memcmp(buf, padding, padding_num_bytes)) {    avb_error("Padding check failed.\n");    goto out;  }*  /* Check hash. */  if (avb_safe_memcmp(buf + padding_num_bytes, hash, hash_num_bytes)) {    avb_error("Hash check failed.\n");    goto out;  }  success = true;out:  if (parsed_key != NULL) {    iavb_free_parsed_key(parsed_key);  }  if (buf != NULL) {    avb_free(buf);  }  return success;}

C/** * validate_vmbeta_public_key() - checks if the given public key used to sign * the vbmeta partition is trusted * * @ops: AvbOps, contains AVB ops handlers * @public_key_data: public key for verifying vbmeta partition signature * @public_key_length: length of public key * @public_key_metadata: * @public_key_metadata_length: * @out_key_is_trusted: * * @return: *      AVB_IO_RESULT_OK, if partition was found and read operation succeed */ static AvbIOResult validate_vbmeta_public_key(AvbOps *ops, const u8 *public_key_data, size_t public_key_length, const u8 *public_key_metadata, size_t public_key_metadata_length, bool *out_key_is_trusted){if (!public_key_length || !public_key_data || !out_key_is_trusted)return AVB_IO_RESULT_ERROR_IO;
*out_key_is_trusted = false;if (public_key_length != sizeof(avb_root_pub))return AVB_IO_RESULT_ERROR_IO;
if (memcmp(avb_root_pub, public_key_data, public_key_length) == 0)*out_key_is_trusted = true;
return AVB_IO_RESULT_OK;}

Cstatic AvbSlotVerifyResult load_and_verify_hash_partition(    AvbOps* ops,    const char* const* requested_partitions,    const char* ab_suffix,    bool allow_verification_error,    const AvbDescriptor* descriptor,    AvbSlotVerifyData* slot_data) {  AvbHashDescriptor hash_desc;  const uint8_t* desc_partition_name = NULL;  const uint8_t* desc_salt;  const uint8_t* desc_digest;  char part_name[AVB_PART_NAME_MAX_SIZE];  AvbSlotVerifyResult ret;  AvbIOResult io_ret;  uint8_t* image_buf = NULL;  bool image_preloaded = false;  uint8_t* digest;  size_t digest_len;  const char* found;  uint64_t image_size;  size_t expected_digest_len = 0;  uint8_t expected_digest_buf[AVB_SHA512_DIGEST_SIZE];  const uint8_t* expected_digest = NULL;  //...  // Although only one of the type might be used, we have to defined the  // structure here so that they would live outside the 'if/else' scope to be  // used later.  AvbSHA256Ctx sha256_ctx;  AvbSHA512Ctx sha512_ctx;  size_t image_size_to_hash = hash_desc.image_size;  // If we allow verification error and the whole partition is smaller than  // image size in hash descriptor, we just hash the whole partition.  if (image_size_to_hash > image_size) {    image_size_to_hash = image_size;  }  if (avb_strcmp((const char*)hash_desc.hash_algorithm, "sha256") == 0) {    avb_sha256_init(&sha256_ctx);    avb_sha256_update(&sha256_ctx, desc_salt, hash_desc.salt_len);    avb_sha256_update(&sha256_ctx, image_buf, image_size_to_hash);    digest = avb_sha256_final(&sha256_ctx);    digest_len = AVB_SHA256_DIGEST_SIZE;  } else if (avb_strcmp((const char*)hash_desc.hash_algorithm, "sha512") == 0) {    avb_sha512_init(&sha512_ctx);    avb_sha512_update(&sha512_ctx, desc_salt, hash_desc.salt_len);    avb_sha512_update(&sha512_ctx, image_buf, image_size_to_hash);    digest = avb_sha512_final(&sha512_ctx);    digest_len = AVB_SHA512_DIGEST_SIZE;  } else {    avb_error(part_name, ": Unsupported hash algorithm.\n");    ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;    goto out;  }  if (hash_desc.digest_len == 0) {    /* Expect a match to a persistent digest. */    avb_debug(part_name, ": No digest, using persistent digest.\n");    expected_digest_len = digest_len;    expected_digest = expected_digest_buf;    avb_assert(expected_digest_len <= sizeof(expected_digest_buf));    /* Pass |digest| as the |initial_digest| so devices not yet initialized get     * initialized to the current partition digest.     */    ret = read_persistent_digest(        ops, part_name, digest_len, digest, expected_digest_buf);    if (ret != AVB_SLOT_VERIFY_RESULT_OK) {      goto out;    }  } else {    /* Expect a match to the digest in the descriptor. */    expected_digest_len = hash_desc.digest_len;    expected_digest = desc_digest;  }  if (digest_len != expected_digest_len) {    avb_error(part_name, ": Digest in descriptor not of expected size.\n");    ret = AVB_SLOT_VERIFY_RESULT_ERROR_INVALID_METADATA;    goto out;  }  if (avb_safe_memcmp(digest, expected_digest, digest_len) != 0) {//比较计算出的哈希值与描述符中的预期哈希值。如果不匹配，则返回验证错误。    avb_error(part_name,              ": Hash of data does not match digest in descriptor.\n");    ret = AVB_SLOT_VERIFY_RESULT_ERROR_VERIFICATION;    goto out;  }  ret = AVB_SLOT_VERIFY_RESULT_OK;out:  /* If it worked and something was loaded, copy to slot_data. */  if ((ret == AVB_SLOT_VERIFY_RESULT_OK || result_should_continue(ret)) &&      image_buf != NULL) {    AvbPartitionData* loaded_partition;    if (slot_data->num_loaded_partitions == MAX_NUMBER_OF_LOADED_PARTITIONS) {      avb_error(part_name, ": Too many loaded partitions.\n");      ret = AVB_SLOT_VERIFY_RESULT_ERROR_OOM;      goto fail;    }    loaded_partition =        &slot_data->loaded_partitions[slot_data->num_loaded_partitions++];    loaded_partition->partition_name = avb_strdup(found);    loaded_partition->data_size = image_size;    loaded_partition->data = image_buf;    loaded_partition->preloaded = image_preloaded;    loaded_partition->verify_result = ret;    image_buf = NULL;  }fail:  if (image_buf != NULL && !image_preloaded) {    avb_free(image_buf);  }  return ret;}