//
|
// Copyright (C) 2018 The Android Open Source Project
|
//
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
// you may not use this file except in compliance with the License.
|
// You may obtain a copy of the License at
|
//
|
// http://www.apache.org/licenses/LICENSE-2.0
|
//
|
// Unless required by applicable law or agreed to in writing, software
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
// See the License for the specific language governing permissions and
|
// limitations under the License.
|
//
|
|
#include "update_engine/payload_generator/payload_generation_config.h"
|
|
#include <base/logging.h>
|
#include <base/strings/string_number_conversions.h>
|
#include <base/strings/string_split.h>
|
#include <brillo/secure_blob.h>
|
#include <fec/io.h>
|
#include <libavb/libavb.h>
|
#include <verity/hash_tree_builder.h>
|
|
#include "update_engine/common/utils.h"
|
#include "update_engine/payload_consumer/verity_writer_android.h"
|
#include "update_engine/payload_generator/extent_ranges.h"
|
|
namespace chromeos_update_engine {
|
|
namespace {
|
bool AvbDescriptorCallback(const AvbDescriptor* descriptor, void* user_data) {
|
PartitionConfig* part = static_cast<PartitionConfig*>(user_data);
|
AvbDescriptor desc;
|
TEST_AND_RETURN_FALSE(
|
avb_descriptor_validate_and_byteswap(descriptor, &desc));
|
if (desc.tag != AVB_DESCRIPTOR_TAG_HASHTREE)
|
return true;
|
|
AvbHashtreeDescriptor hashtree;
|
TEST_AND_RETURN_FALSE(avb_hashtree_descriptor_validate_and_byteswap(
|
reinterpret_cast<const AvbHashtreeDescriptor*>(descriptor), &hashtree));
|
// We only support version 1 right now, will need to introduce a new
|
// payload minor version to support new dm verity version.
|
TEST_AND_RETURN_FALSE(hashtree.dm_verity_version == 1);
|
part->verity.hash_tree_algorithm =
|
reinterpret_cast<const char*>(hashtree.hash_algorithm);
|
|
const uint8_t* salt = reinterpret_cast<const uint8_t*>(descriptor) +
|
sizeof(AvbHashtreeDescriptor) +
|
hashtree.partition_name_len;
|
part->verity.hash_tree_salt.assign(salt, salt + hashtree.salt_len);
|
|
TEST_AND_RETURN_FALSE(hashtree.data_block_size ==
|
part->fs_interface->GetBlockSize());
|
part->verity.hash_tree_data_extent =
|
ExtentForBytes(hashtree.data_block_size, 0, hashtree.image_size);
|
|
TEST_AND_RETURN_FALSE(hashtree.hash_block_size ==
|
part->fs_interface->GetBlockSize());
|
part->verity.hash_tree_extent = ExtentForBytes(
|
hashtree.hash_block_size, hashtree.tree_offset, hashtree.tree_size);
|
|
part->verity.fec_data_extent =
|
ExtentForBytes(hashtree.data_block_size, 0, hashtree.fec_offset);
|
part->verity.fec_extent = ExtentForBytes(
|
hashtree.data_block_size, hashtree.fec_offset, hashtree.fec_size);
|
part->verity.fec_roots = hashtree.fec_num_roots;
|
return true;
|
}
|
|
// Generate hash tree and FEC based on the verity config and verify that it
|
// matches the hash tree and FEC stored in the image.
|
bool VerifyVerityConfig(const PartitionConfig& part) {
|
const size_t block_size = part.fs_interface->GetBlockSize();
|
if (part.verity.hash_tree_extent.num_blocks() != 0) {
|
auto hash_function =
|
HashTreeBuilder::HashFunction(part.verity.hash_tree_algorithm);
|
TEST_AND_RETURN_FALSE(hash_function != nullptr);
|
HashTreeBuilder hash_tree_builder(block_size, hash_function);
|
uint64_t data_size =
|
part.verity.hash_tree_data_extent.num_blocks() * block_size;
|
uint64_t tree_size = hash_tree_builder.CalculateSize(data_size);
|
TEST_AND_RETURN_FALSE(
|
tree_size == part.verity.hash_tree_extent.num_blocks() * block_size);
|
TEST_AND_RETURN_FALSE(
|
hash_tree_builder.Initialize(data_size, part.verity.hash_tree_salt));
|
|
brillo::Blob buffer;
|
for (uint64_t offset = part.verity.hash_tree_data_extent.start_block() *
|
block_size,
|
data_end = offset + data_size;
|
offset < data_end;) {
|
constexpr uint64_t kBufferSize = 1024 * 1024;
|
size_t bytes_to_read = std::min(kBufferSize, data_end - offset);
|
TEST_AND_RETURN_FALSE(
|
utils::ReadFileChunk(part.path, offset, bytes_to_read, &buffer));
|
TEST_AND_RETURN_FALSE(
|
hash_tree_builder.Update(buffer.data(), buffer.size()));
|
offset += buffer.size();
|
buffer.clear();
|
}
|
TEST_AND_RETURN_FALSE(hash_tree_builder.BuildHashTree());
|
TEST_AND_RETURN_FALSE(utils::ReadFileChunk(
|
part.path,
|
part.verity.hash_tree_extent.start_block() * block_size,
|
tree_size,
|
&buffer));
|
TEST_AND_RETURN_FALSE(hash_tree_builder.CheckHashTree(buffer));
|
}
|
|
if (part.verity.fec_extent.num_blocks() != 0) {
|
TEST_AND_RETURN_FALSE(VerityWriterAndroid::EncodeFEC(
|
part.path,
|
part.verity.fec_data_extent.start_block() * block_size,
|
part.verity.fec_data_extent.num_blocks() * block_size,
|
part.verity.fec_extent.start_block() * block_size,
|
part.verity.fec_extent.num_blocks() * block_size,
|
part.verity.fec_roots,
|
block_size,
|
true /* verify_mode */));
|
}
|
return true;
|
}
|
} // namespace
|
|
bool ImageConfig::LoadVerityConfig() {
|
for (PartitionConfig& part : partitions) {
|
// Parse AVB devices.
|
if (part.size > sizeof(AvbFooter)) {
|
uint64_t footer_offset = part.size - sizeof(AvbFooter);
|
brillo::Blob buffer;
|
TEST_AND_RETURN_FALSE(utils::ReadFileChunk(
|
part.path, footer_offset, sizeof(AvbFooter), &buffer));
|
if (memcmp(buffer.data(), AVB_FOOTER_MAGIC, AVB_FOOTER_MAGIC_LEN) == 0) {
|
LOG(INFO) << "Parsing verity config from AVB footer for " << part.name;
|
AvbFooter footer;
|
TEST_AND_RETURN_FALSE(avb_footer_validate_and_byteswap(
|
reinterpret_cast<const AvbFooter*>(buffer.data()), &footer));
|
buffer.clear();
|
|
TEST_AND_RETURN_FALSE(
|
footer.vbmeta_offset + sizeof(AvbVBMetaImageHeader) <= part.size);
|
TEST_AND_RETURN_FALSE(utils::ReadFileChunk(
|
part.path, footer.vbmeta_offset, footer.vbmeta_size, &buffer));
|
TEST_AND_RETURN_FALSE(avb_descriptor_foreach(
|
buffer.data(), buffer.size(), AvbDescriptorCallback, &part));
|
}
|
}
|
|
// Parse VB1.0 devices with FEC metadata, devices with hash tree without
|
// FEC will be skipped for now.
|
if (part.verity.IsEmpty() && part.size > FEC_BLOCKSIZE) {
|
brillo::Blob fec_metadata;
|
TEST_AND_RETURN_FALSE(utils::ReadFileChunk(part.path,
|
part.size - FEC_BLOCKSIZE,
|
sizeof(fec_header),
|
&fec_metadata));
|
const fec_header* header =
|
reinterpret_cast<const fec_header*>(fec_metadata.data());
|
if (header->magic == FEC_MAGIC) {
|
LOG(INFO)
|
<< "Parsing verity config from Verified Boot 1.0 metadata for "
|
<< part.name;
|
const size_t block_size = part.fs_interface->GetBlockSize();
|
// FEC_VERITY_DISABLE skips verifying verity hash tree, because we will
|
// verify it ourselves later.
|
fec::io fh(part.path, O_RDONLY, FEC_VERITY_DISABLE);
|
TEST_AND_RETURN_FALSE(fh);
|
fec_verity_metadata verity_data;
|
if (fh.get_verity_metadata(verity_data)) {
|
auto verity_table = base::SplitString(verity_data.table,
|
" ",
|
base::KEEP_WHITESPACE,
|
base::SPLIT_WANT_ALL);
|
TEST_AND_RETURN_FALSE(verity_table.size() == 10);
|
size_t data_block_size = 0;
|
TEST_AND_RETURN_FALSE(
|
base::StringToSizeT(verity_table[3], &data_block_size));
|
TEST_AND_RETURN_FALSE(block_size == data_block_size);
|
size_t hash_block_size = 0;
|
TEST_AND_RETURN_FALSE(
|
base::StringToSizeT(verity_table[4], &hash_block_size));
|
TEST_AND_RETURN_FALSE(block_size == hash_block_size);
|
uint64_t num_data_blocks = 0;
|
TEST_AND_RETURN_FALSE(
|
base::StringToUint64(verity_table[5], &num_data_blocks));
|
part.verity.hash_tree_data_extent =
|
ExtentForRange(0, num_data_blocks);
|
uint64_t hash_start_block = 0;
|
TEST_AND_RETURN_FALSE(
|
base::StringToUint64(verity_table[6], &hash_start_block));
|
part.verity.hash_tree_algorithm = verity_table[7];
|
TEST_AND_RETURN_FALSE(base::HexStringToBytes(
|
verity_table[9], &part.verity.hash_tree_salt));
|
auto hash_function =
|
HashTreeBuilder::HashFunction(part.verity.hash_tree_algorithm);
|
TEST_AND_RETURN_FALSE(hash_function != nullptr);
|
HashTreeBuilder hash_tree_builder(block_size, hash_function);
|
uint64_t tree_size =
|
hash_tree_builder.CalculateSize(num_data_blocks * block_size);
|
part.verity.hash_tree_extent =
|
ExtentForRange(hash_start_block, tree_size / block_size);
|
}
|
fec_ecc_metadata ecc_data;
|
if (fh.get_ecc_metadata(ecc_data) && ecc_data.valid) {
|
TEST_AND_RETURN_FALSE(block_size == FEC_BLOCKSIZE);
|
part.verity.fec_data_extent = ExtentForRange(0, ecc_data.blocks);
|
part.verity.fec_extent =
|
ExtentForBytes(block_size, ecc_data.start, header->fec_size);
|
part.verity.fec_roots = ecc_data.roots;
|
}
|
}
|
}
|
|
if (!part.verity.IsEmpty()) {
|
TEST_AND_RETURN_FALSE(VerifyVerityConfig(part));
|
}
|
}
|
return true;
|
}
|
|
} // namespace chromeos_update_engine
|
