ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Fix-up coding style" am: 4a534ebc91

Browse source 
am: cfcaca92d1

Change-Id: Ib10ba26be56b2c520bb764d9e961e539f2444c1f
This commit is contained in:
Bowgo Tsai 2017-02-19 00:30:01 +00:00 • committed by android-build-merger
commit 13fc1463a9
8 changed files with 141 additions and 255 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
fs_mgr/.clang-format Symbolic link
View file

@ -0,0 +1 @@
../init/.clang-format

237
fs_mgr/fs_mgr_avb.cpp
View file

@ -51,14 +51,12 @@
"%u %s %s %u %u " \ "%u %s %s %u %u " \
"%" PRIu64 " %" PRIu64 " %s %s %s " "%" PRIu64 " %" PRIu64 " %s %s %s "
#define VERITY_TABLE_PARAMS(hashtree_desc, blk_device, digest, salt) \ #define VERITY_TABLE_PARAMS(hashtree_desc, blk_device, digest, salt) \
hashtree_desc.dm_verity_version, blk_device, blk_device, \ hashtree_desc.dm_verity_version, blk_device, blk_device, hashtree_desc.data_block_size, \
hashtree_desc.data_block_size, hashtree_desc.hash_block_size, \ hashtree_desc.hash_block_size, \
hashtree_desc.image_size / \ hashtree_desc.image_size / hashtree_desc.data_block_size, /* num_data_blocks. */ \
hashtree_desc.data_block_size, /* num_data_blocks. */ \ hashtree_desc.tree_offset / hashtree_desc.hash_block_size, /* hash_start_block. */ \
hashtree_desc.tree_offset / \ (char*)hashtree_desc.hash_algorithm, digest, salt
hashtree_desc.hash_block_size, /* hash_start_block. */ \
(char *)hashtree_desc.hash_algorithm, digest, salt
#define VERITY_TABLE_OPT_RESTART "restart_on_corruption" #define VERITY_TABLE_OPT_RESTART "restart_on_corruption"
#define VERITY_TABLE_OPT_IGNZERO "ignore_zero_blocks" #define VERITY_TABLE_OPT_IGNZERO "ignore_zero_blocks"
@ -67,32 +65,28 @@
* <#opt_params> ignore_zero_blocks restart_on_corruption * <#opt_params> ignore_zero_blocks restart_on_corruption
*/ */
#define VERITY_TABLE_OPT_DEFAULT_FORMAT "2 %s %s" #define VERITY_TABLE_OPT_DEFAULT_FORMAT "2 %s %s"
#define VERITY_TABLE_OPT_DEFAULT_PARAMS \ #define VERITY_TABLE_OPT_DEFAULT_PARAMS VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART
VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART
/* The FEC (forward error correction) format of dm-verity optional parameters: /* The FEC (forward error correction) format of dm-verity optional parameters:
* <#opt_params> use_fec_from_device <fec_dev> * <#opt_params> use_fec_from_device <fec_dev>
* fec_roots <num> fec_blocks <num> fec_start <offset> * fec_roots <num> fec_blocks <num> fec_start <offset>
* ignore_zero_blocks restart_on_corruption * ignore_zero_blocks restart_on_corruption
*/ */
#define VERITY_TABLE_OPT_FEC_FORMAT \ #define VERITY_TABLE_OPT_FEC_FORMAT \
"10 use_fec_from_device %s fec_roots %u fec_blocks %" PRIu64 \ "10 use_fec_from_device %s fec_roots %u fec_blocks %" PRIu64 " fec_start %" PRIu64 " %s %s"
" fec_start %" PRIu64 " %s %s"
/* Note that fec_blocks is the size that FEC covers, *not* the /* Note that fec_blocks is the size that FEC covers, *not* the
* size of the FEC data. Since we use FEC for everything up until * size of the FEC data. Since we use FEC for everything up until
* the FEC data, it's the same as the offset (fec_start). * the FEC data, it's the same as the offset (fec_start).
*/ */
#define VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device) \ #define VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device) \
blk_device, hashtree_desc.fec_num_roots, \ blk_device, hashtree_desc.fec_num_roots, \
hashtree_desc.fec_offset / \ hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_blocks */ \
hashtree_desc.data_block_size, /* fec_blocks */ \ hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_start */ \
hashtree_desc.fec_offset / \
hashtree_desc.data_block_size, /* fec_start */ \
VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART
AvbSlotVerifyData *fs_mgr_avb_verify_data = nullptr; AvbSlotVerifyData* fs_mgr_avb_verify_data = nullptr;
AvbOps *fs_mgr_avb_ops = nullptr; AvbOps* fs_mgr_avb_ops = nullptr;
enum HashAlgorithm { enum HashAlgorithm {
kInvalid = 0, kInvalid = 0,
@ -109,8 +103,7 @@ struct androidboot_vbmeta {
androidboot_vbmeta fs_mgr_vbmeta_prop; androidboot_vbmeta fs_mgr_vbmeta_prop;
static inline bool nibble_value(const char &c, uint8_t *value) static inline bool nibble_value(const char& c, uint8_t* value) {
{
FS_MGR_CHECK(value != nullptr); FS_MGR_CHECK(value != nullptr);
switch (c) { switch (c) {
@ -130,10 +123,7 @@ static inline bool nibble_value(const char &c, uint8_t *value)
return true; return true;
} }
static bool hex_to_bytes(uint8_t *bytes, static bool hex_to_bytes(uint8_t* bytes, size_t bytes_len, const std::string& hex) {
size_t bytes_len,
const std::string &hex)
{
FS_MGR_CHECK(bytes != nullptr); FS_MGR_CHECK(bytes != nullptr);
if (hex.size() % 2 != 0) { if (hex.size() % 2 != 0) {
@ -156,11 +146,10 @@ static bool hex_to_bytes(uint8_t *bytes,
return true; return true;
} }
static std::string bytes_to_hex(const uint8_t *bytes, size_t bytes_len) static std::string bytes_to_hex(const uint8_t* bytes, size_t bytes_len) {
{
FS_MGR_CHECK(bytes != nullptr); FS_MGR_CHECK(bytes != nullptr);
static const char *hex_digits = "0123456789abcdef"; static const char* hex_digits = "0123456789abcdef";
std::string hex; std::string hex;
for (size_t i = 0; i < bytes_len; i++) { for (size_t i = 0; i < bytes_len; i++) {
@ -170,8 +159,7 @@ static std::string bytes_to_hex(const uint8_t *bytes, size_t bytes_len)
return hex; return hex;
} }
static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop) static bool load_vbmeta_prop(androidboot_vbmeta* vbmeta_prop) {
{
FS_MGR_CHECK(vbmeta_prop != nullptr); FS_MGR_CHECK(vbmeta_prop != nullptr);
std::string cmdline; std::string cmdline;
@ -180,19 +168,17 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
std::string hash_alg; std::string hash_alg;
std::string digest; std::string digest;
for (const auto &entry : for (const auto& entry : android::base::Split(android::base::Trim(cmdline), " ")) {
android::base::Split(android::base::Trim(cmdline), " ")) {
std::vector<std::string> pieces = android::base::Split(entry, "="); std::vector<std::string> pieces = android::base::Split(entry, "=");
const std::string &key = pieces[0]; const std::string& key = pieces[0];
const std::string &value = pieces[1]; const std::string& value = pieces[1];
if (key == "androidboot.vbmeta.device_state") { if (key == "androidboot.vbmeta.device_state") {
vbmeta_prop->allow_verification_error = (value == "unlocked"); vbmeta_prop->allow_verification_error = (value == "unlocked");
} else if (key == "androidboot.vbmeta.hash_alg") { } else if (key == "androidboot.vbmeta.hash_alg") {
hash_alg = value; hash_alg = value;
} else if (key == "androidboot.vbmeta.size") { } else if (key == "androidboot.vbmeta.size") {
if (!android::base::ParseUint(value.c_str(), if (!android::base::ParseUint(value.c_str(), &vbmeta_prop->vbmeta_size)) {
&vbmeta_prop->vbmeta_size)) {
return false; return false;
} }
} else if (key == "androidboot.vbmeta.digest") { } else if (key == "androidboot.vbmeta.digest") {
@ -220,10 +206,8 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
return false; return false;
} }
if (!hex_to_bytes(vbmeta_prop->digest, sizeof(vbmeta_prop->digest), if (!hex_to_bytes(vbmeta_prop->digest, sizeof(vbmeta_prop->digest), digest)) {
digest)) { LERROR << "Hash digest contains non-hexidecimal character: " << digest.c_str();
LERROR << "Hash digest contains non-hexidecimal character: "
<< digest.c_str();
return false; return false;
} }
@ -231,9 +215,8 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
} }
template <typename Hasher> template <typename Hasher>
static std::pair<size_t, bool> verify_vbmeta_digest( static std::pair<size_t, bool> verify_vbmeta_digest(const AvbSlotVerifyData& verify_data,
const AvbSlotVerifyData &verify_data, const androidboot_vbmeta &vbmeta_prop) const androidboot_vbmeta& vbmeta_prop) {
{
size_t total_size = 0; size_t total_size = 0;
Hasher hasher; Hasher hasher;
for (size_t n = 0; n < verify_data.num_vbmeta_images; n++) { for (size_t n = 0; n < verify_data.num_vbmeta_images; n++) {
@ -242,15 +225,13 @@ static std::pair<size_t, bool> verify_vbmeta_digest(
total_size += verify_data.vbmeta_images[n].vbmeta_size; total_size += verify_data.vbmeta_images[n].vbmeta_size;
} }
bool matched = (memcmp(hasher.finalize(), vbmeta_prop.digest, bool matched = (memcmp(hasher.finalize(), vbmeta_prop.digest, Hasher::DIGEST_SIZE) == 0);
Hasher::DIGEST_SIZE) == 0);
return std::make_pair(total_size, matched); return std::make_pair(total_size, matched);
} }
static bool verify_vbmeta_images(const AvbSlotVerifyData &verify_data, static bool verify_vbmeta_images(const AvbSlotVerifyData& verify_data,
const androidboot_vbmeta &vbmeta_prop) const androidboot_vbmeta& vbmeta_prop) {
{
if (verify_data.num_vbmeta_images == 0) { if (verify_data.num_vbmeta_images == 0) {
LERROR << "No vbmeta images"; LERROR << "No vbmeta images";
return false; return false;
@ -281,23 +262,17 @@ static bool verify_vbmeta_images(const AvbSlotVerifyData &verify_data,
return true; return true;
} }
static bool hashtree_load_verity_table( static bool hashtree_load_verity_table(struct dm_ioctl* io, const std::string& dm_device_name,
struct dm_ioctl *io, int fd, const std::string& blk_device,
const std::string &dm_device_name, const AvbHashtreeDescriptor& hashtree_desc,
int fd, const std::string& salt, const std::string& root_digest) {
const std::string &blk_device,
const AvbHashtreeDescriptor &hashtree_desc,
const std::string &salt,
const std::string &root_digest)
{
fs_mgr_verity_ioctl_init(io, dm_device_name, DM_STATUS_TABLE_FLAG); fs_mgr_verity_ioctl_init(io, dm_device_name, DM_STATUS_TABLE_FLAG);
// The buffer consists of [dm_ioctl][dm_target_spec][verity_params]. // The buffer consists of [dm_ioctl][dm_target_spec][verity_params].
char *buffer = (char *)io; char* buffer = (char*)io;
// Builds the dm_target_spec arguments. // Builds the dm_target_spec arguments.
struct dm_target_spec *dm_target = struct dm_target_spec* dm_target = (struct dm_target_spec*)&buffer[sizeof(struct dm_ioctl)];
(struct dm_target_spec *)&buffer[sizeof(struct dm_ioctl)];
io->target_count = 1; io->target_count = 1;
dm_target->status = 0; dm_target->status = 0;
dm_target->sector_start = 0; dm_target->sector_start = 0;
@ -305,23 +280,19 @@ static bool hashtree_load_verity_table(
strcpy(dm_target->target_type, "verity"); strcpy(dm_target->target_type, "verity");
// Builds the verity params. // Builds the verity params.
char *verity_params = char* verity_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
size_t bufsize = DM_BUF_SIZE - (verity_params - buffer); size_t bufsize = DM_BUF_SIZE - (verity_params - buffer);
int res = 0; int res = 0;
if (hashtree_desc.fec_size > 0) { if (hashtree_desc.fec_size > 0) {
res = snprintf( res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT,
verity_params, bufsize, VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT, salt.c_str()),
VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device.c_str()));
root_digest.c_str(), salt.c_str()),
VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device.c_str()));
} else { } else {
res = snprintf(verity_params, bufsize, res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT,
VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT, VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), salt.c_str()),
root_digest.c_str(), salt.c_str()),
VERITY_TABLE_OPT_DEFAULT_PARAMS); VERITY_TABLE_OPT_DEFAULT_PARAMS);
} }
@ -334,7 +305,7 @@ static bool hashtree_load_verity_table(
// Sets ext target boundary. // Sets ext target boundary.
verity_params += strlen(verity_params) + 1; verity_params += strlen(verity_params) + 1;
verity_params = (char *)(((unsigned long)verity_params + 7) & ~7); verity_params = (char*)(((unsigned long)verity_params + 7) & ~7);
dm_target->next = verity_params - buffer; dm_target->next = verity_params - buffer;
// Sends the ioctl to load the verity table. // Sends the ioctl to load the verity table.
@ -346,11 +317,9 @@ static bool hashtree_load_verity_table(
return true; return true;
} }
static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry, static bool hashtree_dm_verity_setup(struct fstab_rec* fstab_entry,
const AvbHashtreeDescriptor &hashtree_desc, const AvbHashtreeDescriptor& hashtree_desc,
const std::string &salt, const std::string& salt, const std::string& root_digest) {
const std::string &root_digest)
{
// Gets the device mapper fd. // Gets the device mapper fd.
android::base::unique_fd fd(open("/dev/device-mapper", O_RDWR)); android::base::unique_fd fd(open("/dev/device-mapper", O_RDWR));
if (fd < 0) { if (fd < 0) {
@ -360,7 +329,7 @@ static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry,
// Creates the device. // Creates the device.
alignas(dm_ioctl) char buffer[DM_BUF_SIZE]; alignas(dm_ioctl) char buffer[DM_BUF_SIZE];
struct dm_ioctl *io = (struct dm_ioctl *)buffer; struct dm_ioctl* io = (struct dm_ioctl*)buffer;
const std::string mount_point(basename(fstab_entry->mount_point)); const std::string mount_point(basename(fstab_entry->mount_point));
if (!fs_mgr_create_verity_device(io, mount_point, fd)) { if (!fs_mgr_create_verity_device(io, mount_point, fd)) {
LERROR << "Couldn't create verity device!"; LERROR << "Couldn't create verity device!";
@ -375,8 +344,7 @@ static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry,
} }
// Loads the verity mapping table. // Loads the verity mapping table.
if (!hashtree_load_verity_table(io, mount_point, fd, if (!hashtree_load_verity_table(io, mount_point, fd, std::string(fstab_entry->blk_device),
std::string(fstab_entry->blk_device),
hashtree_desc, salt, root_digest)) { hashtree_desc, salt, root_digest)) {
LERROR << "Couldn't load verity table!"; LERROR << "Couldn't load verity table!";
return false; return false;
@ -403,24 +371,20 @@ static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry,
return true; return true;
} }
static bool get_hashtree_descriptor(const std::string &partition_name, static bool get_hashtree_descriptor(const std::string& partition_name,
const AvbSlotVerifyData &verify_data, const AvbSlotVerifyData& verify_data,
AvbHashtreeDescriptor *out_hashtree_desc, AvbHashtreeDescriptor* out_hashtree_desc, std::string* out_salt,
std::string *out_salt, std::string* out_digest) {
std::string *out_digest)
{
bool found = false; bool found = false;
const uint8_t *desc_partition_name; const uint8_t* desc_partition_name;
for (size_t i = 0; i < verify_data.num_vbmeta_images && !found; i++) { for (size_t i = 0; i < verify_data.num_vbmeta_images && !found; i++) {
// Get descriptors from vbmeta_images[i]. // Get descriptors from vbmeta_images[i].
size_t num_descriptors; size_t num_descriptors;
std::unique_ptr<const AvbDescriptor *[], decltype(&avb_free)> std::unique_ptr<const AvbDescriptor* [], decltype(&avb_free)> descriptors(
descriptors( avb_descriptor_get_all(verify_data.vbmeta_images[i].vbmeta_data,
avb_descriptor_get_all(verify_data.vbmeta_images[i].vbmeta_data, verify_data.vbmeta_images[i].vbmeta_size, &num_descriptors),
verify_data.vbmeta_images[i].vbmeta_size, avb_free);
&num_descriptors),
avb_free);
if (!descriptors || num_descriptors < 1) { if (!descriptors || num_descriptors < 1) {
continue; continue;
@ -428,12 +392,9 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
// Ensures that hashtree descriptor is either in /vbmeta or in // Ensures that hashtree descriptor is either in /vbmeta or in
// the same partition for verity setup. // the same partition for verity setup.
std::string vbmeta_partition_name( std::string vbmeta_partition_name(verify_data.vbmeta_images[i].partition_name);
verify_data.vbmeta_images[i].partition_name); if (vbmeta_partition_name != "vbmeta" && vbmeta_partition_name != partition_name) {
if (vbmeta_partition_name != "vbmeta" && LWARNING << "Skip vbmeta image at " << verify_data.vbmeta_images[i].partition_name
vbmeta_partition_name != partition_name) {
LWARNING << "Skip vbmeta image at "
<< verify_data.vbmeta_images[i].partition_name
<< " for partition: " << partition_name.c_str(); << " for partition: " << partition_name.c_str();
continue; continue;
} }
@ -445,21 +406,18 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
continue; continue;
} }
if (desc.tag == AVB_DESCRIPTOR_TAG_HASHTREE) { if (desc.tag == AVB_DESCRIPTOR_TAG_HASHTREE) {
desc_partition_name = (const uint8_t *)descriptors[j] + desc_partition_name =
sizeof(AvbHashtreeDescriptor); (const uint8_t*)descriptors[j] + sizeof(AvbHashtreeDescriptor);
if (!avb_hashtree_descriptor_validate_and_byteswap( if (!avb_hashtree_descriptor_validate_and_byteswap(
(AvbHashtreeDescriptor *)descriptors[j], (AvbHashtreeDescriptor*)descriptors[j], out_hashtree_desc)) {
out_hashtree_desc)) {
continue; continue;
} }
if (out_hashtree_desc->partition_name_len != if (out_hashtree_desc->partition_name_len != partition_name.length()) {
partition_name.length()) {
continue; continue;
} }
// Notes that desc_partition_name is not NUL-terminated. // Notes that desc_partition_name is not NUL-terminated.
std::string hashtree_partition_name( std::string hashtree_partition_name((const char*)desc_partition_name,
(const char *)desc_partition_name, out_hashtree_desc->partition_name_len);
out_hashtree_desc->partition_name_len);
if (hashtree_partition_name == partition_name) { if (hashtree_partition_name == partition_name) {
found = true; found = true;
} }
@ -472,18 +430,16 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
return false; return false;
} }
const uint8_t *desc_salt = const uint8_t* desc_salt = desc_partition_name + out_hashtree_desc->partition_name_len;
desc_partition_name + out_hashtree_desc->partition_name_len;
*out_salt = bytes_to_hex(desc_salt, out_hashtree_desc->salt_len); *out_salt = bytes_to_hex(desc_salt, out_hashtree_desc->salt_len);
const uint8_t *desc_digest = desc_salt + out_hashtree_desc->salt_len; const uint8_t* desc_digest = desc_salt + out_hashtree_desc->salt_len;
*out_digest = bytes_to_hex(desc_digest, out_hashtree_desc->root_digest_len); *out_digest = bytes_to_hex(desc_digest, out_hashtree_desc->root_digest_len);
return true; return true;
} }
static bool init_is_avb_used() static bool init_is_avb_used() {
{
// When AVB is used, boot loader should set androidboot.vbmeta.{hash_alg, // When AVB is used, boot loader should set androidboot.vbmeta.{hash_alg,
// size, digest} in kernel cmdline. They will then be imported by init // size, digest} in kernel cmdline. They will then be imported by init
// process to system properties: ro.boot.vbmeta.{hash_alg, size, digest}. // process to system properties: ro.boot.vbmeta.{hash_alg, size, digest}.
@ -493,8 +449,7 @@ static bool init_is_avb_used()
// be done in fs_mgr_load_vbmeta_images() and FS_MGR_SETUP_AVB_FAIL will // be done in fs_mgr_load_vbmeta_images() and FS_MGR_SETUP_AVB_FAIL will
// be returned when there is an error. // be returned when there is an error.
std::string hash_alg = std::string hash_alg = android::base::GetProperty("ro.boot.vbmeta.hash_alg", "");
android::base::GetProperty("ro.boot.vbmeta.hash_alg", "");
if (hash_alg == "sha256" || hash_alg == "sha512") { if (hash_alg == "sha256" || hash_alg == "sha512") {
return true; return true;
@ -503,14 +458,12 @@ static bool init_is_avb_used()
return false; return false;
} }
bool fs_mgr_is_avb_used() bool fs_mgr_is_avb_used() {
{
static bool result = init_is_avb_used(); static bool result = init_is_avb_used();
return result; return result;
} }
int fs_mgr_load_vbmeta_images(struct fstab *fstab) int fs_mgr_load_vbmeta_images(struct fstab* fstab) {
{
FS_MGR_CHECK(fstab != nullptr); FS_MGR_CHECK(fstab != nullptr);
// Gets the expected hash value of vbmeta images from // Gets the expected hash value of vbmeta images from
@ -529,12 +482,11 @@ int fs_mgr_load_vbmeta_images(struct fstab *fstab)
// Sets requested_partitions to nullptr as it's to copy the contents // Sets requested_partitions to nullptr as it's to copy the contents
// of HASH partitions into fs_mgr_avb_verify_data, which is not required as // of HASH partitions into fs_mgr_avb_verify_data, which is not required as
// fs_mgr only deals with HASHTREE partitions. // fs_mgr only deals with HASHTREE partitions.
const char *requested_partitions[] = {nullptr}; const char* requested_partitions[] = {nullptr};
const char *ab_suffix = const char* ab_suffix = android::base::GetProperty("ro.boot.slot_suffix", "").c_str();
android::base::GetProperty("ro.boot.slot_suffix", "").c_str(); AvbSlotVerifyResult verify_result =
AvbSlotVerifyResult verify_result = avb_slot_verify( avb_slot_verify(fs_mgr_avb_ops, requested_partitions, ab_suffix,
fs_mgr_avb_ops, requested_partitions, ab_suffix, fs_mgr_vbmeta_prop.allow_verification_error, &fs_mgr_avb_verify_data);
fs_mgr_vbmeta_prop.allow_verification_error, &fs_mgr_avb_verify_data);
// Only allow two verify results: // Only allow two verify results:
// - AVB_SLOT_VERIFY_RESULT_OK. // - AVB_SLOT_VERIFY_RESULT_OK.
@ -557,12 +509,11 @@ int fs_mgr_load_vbmeta_images(struct fstab *fstab)
// Checks whether FLAGS_HASHTREE_DISABLED is set. // Checks whether FLAGS_HASHTREE_DISABLED is set.
AvbVBMetaImageHeader vbmeta_header; AvbVBMetaImageHeader vbmeta_header;
avb_vbmeta_image_header_to_host_byte_order( avb_vbmeta_image_header_to_host_byte_order(
(AvbVBMetaImageHeader *)fs_mgr_avb_verify_data->vbmeta_images[0] (AvbVBMetaImageHeader*)fs_mgr_avb_verify_data->vbmeta_images[0].vbmeta_data,
.vbmeta_data,
&vbmeta_header); &vbmeta_header);
bool hashtree_disabled = ((AvbVBMetaImageFlags)vbmeta_header.flags & bool hashtree_disabled =
AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED); ((AvbVBMetaImageFlags)vbmeta_header.flags & AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED);
if (hashtree_disabled) { if (hashtree_disabled) {
return FS_MGR_SETUP_AVB_HASHTREE_DISABLED; return FS_MGR_SETUP_AVB_HASHTREE_DISABLED;
} }
@ -577,8 +528,7 @@ fail:
return FS_MGR_SETUP_AVB_FAIL; return FS_MGR_SETUP_AVB_FAIL;
} }
void fs_mgr_unload_vbmeta_images() void fs_mgr_unload_vbmeta_images() {
{
if (fs_mgr_avb_verify_data != nullptr) { if (fs_mgr_avb_verify_data != nullptr) {
avb_slot_verify_data_free(fs_mgr_avb_verify_data); avb_slot_verify_data_free(fs_mgr_avb_verify_data);
} }
@ -588,32 +538,27 @@ void fs_mgr_unload_vbmeta_images()
} }
} }
int fs_mgr_setup_avb(struct fstab_rec *fstab_entry) int fs_mgr_setup_avb(struct fstab_rec* fstab_entry) {
{ if (!fstab_entry || !fs_mgr_avb_verify_data || fs_mgr_avb_verify_data->num_vbmeta_images < 1) {
if (!fstab_entry || !fs_mgr_avb_verify_data ||
fs_mgr_avb_verify_data->num_vbmeta_images < 1) {
return FS_MGR_SETUP_AVB_FAIL; return FS_MGR_SETUP_AVB_FAIL;
} }
std::string partition_name(basename(fstab_entry->mount_point)); std::string partition_name(basename(fstab_entry->mount_point));
if (!avb_validate_utf8((const uint8_t *)partition_name.c_str(), if (!avb_validate_utf8((const uint8_t*)partition_name.c_str(), partition_name.length())) {
partition_name.length())) { LERROR << "Partition name: " << partition_name.c_str() << " is not valid UTF-8.";
LERROR << "Partition name: " << partition_name.c_str()
<< " is not valid UTF-8.";
return FS_MGR_SETUP_AVB_FAIL; return FS_MGR_SETUP_AVB_FAIL;
} }
AvbHashtreeDescriptor hashtree_descriptor; AvbHashtreeDescriptor hashtree_descriptor;
std::string salt; std::string salt;
std::string root_digest; std::string root_digest;
if (!get_hashtree_descriptor(partition_name, *fs_mgr_avb_verify_data, if (!get_hashtree_descriptor(partition_name, *fs_mgr_avb_verify_data, &hashtree_descriptor,
&hashtree_descriptor, &salt, &root_digest)) { &salt, &root_digest)) {
return FS_MGR_SETUP_AVB_FAIL; return FS_MGR_SETUP_AVB_FAIL;
} }
// Converts HASHTREE descriptor to verity_table_params. // Converts HASHTREE descriptor to verity_table_params.
if (!hashtree_dm_verity_setup(fstab_entry, hashtree_descriptor, salt, if (!hashtree_dm_verity_setup(fstab_entry, hashtree_descriptor, salt, root_digest)) {
root_digest)) {
return FS_MGR_SETUP_AVB_FAIL; return FS_MGR_SETUP_AVB_FAIL;
} }

69
fs_mgr/fs_mgr_avb_ops.cpp
View file

@ -39,15 +39,11 @@
#include "fs_mgr_avb_ops.h" #include "fs_mgr_avb_ops.h"
#include "fs_mgr_priv.h" #include "fs_mgr_priv.h"
static struct fstab *fs_mgr_fstab = nullptr; static struct fstab* fs_mgr_fstab = nullptr;
static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED, static AvbIOResult read_from_partition(AvbOps* ops ATTRIBUTE_UNUSED, const char* partition,
const char *partition, int64_t offset, size_t num_bytes, void* buffer,
int64_t offset, size_t* out_num_read) {
size_t num_bytes,
void *buffer,
size_t *out_num_read)
{
// The input |partition| name is with ab_suffix, e.g. system_a. // The input |partition| name is with ab_suffix, e.g. system_a.
// Slot suffix (e.g. _a) will be appended to the device file path // Slot suffix (e.g. _a) will be appended to the device file path
// for partitions having 'slotselect' optin in fstab file, but it // for partitions having 'slotselect' optin in fstab file, but it
@ -62,8 +58,7 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
// - /dev/block/platform/soc.0/7824900.sdhci/by-name/misc -> // - /dev/block/platform/soc.0/7824900.sdhci/by-name/misc ->
// - /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a // - /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a
struct fstab_rec *fstab_entry = struct fstab_rec* fstab_entry = fs_mgr_get_entry_for_mount_point(fs_mgr_fstab, "/misc");
fs_mgr_get_entry_for_mount_point(fs_mgr_fstab, "/misc");
if (fstab_entry == nullptr) { if (fstab_entry == nullptr) {
LERROR << "/misc mount point not found in fstab"; LERROR << "/misc mount point not found in fstab";
@ -86,8 +81,7 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
return AVB_IO_RESULT_ERROR_IO; return AVB_IO_RESULT_ERROR_IO;
} }
android::base::unique_fd fd( android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_CLOEXEC)));
if (fd < 0) { if (fd < 0) {
PERROR << "Failed to open " << path.c_str(); PERROR << "Failed to open " << path.c_str();
@ -112,12 +106,11 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
// On Linux, we never get partial reads from block devices (except // On Linux, we never get partial reads from block devices (except
// for EOF). // for EOF).
ssize_t num_read = ssize_t num_read = TEMP_FAILURE_RETRY(pread64(fd, buffer, num_bytes, offset));
TEMP_FAILURE_RETRY(pread64(fd, buffer, num_bytes, offset));
if (num_read < 0 || (size_t)num_read != num_bytes) { if (num_read < 0 || (size_t)num_read != num_bytes) {
PERROR << "Failed to read " << num_bytes << " bytes from " PERROR << "Failed to read " << num_bytes << " bytes from " << path.c_str() << " offset "
<< path.c_str() << " offset " << offset; << offset;
return AVB_IO_RESULT_ERROR_IO; return AVB_IO_RESULT_ERROR_IO;
} }
@ -128,11 +121,9 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
return AVB_IO_RESULT_OK; return AVB_IO_RESULT_OK;
} }
static AvbIOResult dummy_read_rollback_index(AvbOps *ops ATTRIBUTE_UNUSED, static AvbIOResult dummy_read_rollback_index(AvbOps* ops ATTRIBUTE_UNUSED,
size_t rollback_index_location size_t rollback_index_location ATTRIBUTE_UNUSED,
ATTRIBUTE_UNUSED, uint64_t* out_rollback_index) {
uint64_t *out_rollback_index)
{
// rollback_index has been checked in bootloader phase. // rollback_index has been checked in bootloader phase.
// In user-space, returns the smallest value 0 to pass the check. // In user-space, returns the smallest value 0 to pass the check.
*out_rollback_index = 0; *out_rollback_index = 0;
@ -140,13 +131,9 @@ static AvbIOResult dummy_read_rollback_index(AvbOps *ops ATTRIBUTE_UNUSED,
} }
static AvbIOResult dummy_validate_vbmeta_public_key( static AvbIOResult dummy_validate_vbmeta_public_key(
AvbOps *ops ATTRIBUTE_UNUSED, AvbOps* ops ATTRIBUTE_UNUSED, const uint8_t* public_key_data ATTRIBUTE_UNUSED,
const uint8_t *public_key_data ATTRIBUTE_UNUSED, size_t public_key_length ATTRIBUTE_UNUSED, const uint8_t* public_key_metadata ATTRIBUTE_UNUSED,
size_t public_key_length ATTRIBUTE_UNUSED, size_t public_key_metadata_length ATTRIBUTE_UNUSED, bool* out_is_trusted) {
const uint8_t *public_key_metadata ATTRIBUTE_UNUSED,
size_t public_key_metadata_length ATTRIBUTE_UNUSED,
bool *out_is_trusted)
{
// vbmeta public key has been checked in bootloader phase. // vbmeta public key has been checked in bootloader phase.
// In user-space, returns true to pass the check. // In user-space, returns true to pass the check.
// //
@ -158,9 +145,8 @@ static AvbIOResult dummy_validate_vbmeta_public_key(
return AVB_IO_RESULT_OK; return AVB_IO_RESULT_OK;
} }
static AvbIOResult dummy_read_is_device_unlocked(AvbOps *ops ATTRIBUTE_UNUSED, static AvbIOResult dummy_read_is_device_unlocked(AvbOps* ops ATTRIBUTE_UNUSED,
bool *out_is_unlocked) bool* out_is_unlocked) {
{
// The function is for bootloader to update the value into // The function is for bootloader to update the value into
// androidboot.vbmeta.device_state in kernel cmdline. // androidboot.vbmeta.device_state in kernel cmdline.
// In user-space, returns true as we don't need to update it anymore. // In user-space, returns true as we don't need to update it anymore.
@ -168,12 +154,9 @@ static AvbIOResult dummy_read_is_device_unlocked(AvbOps *ops ATTRIBUTE_UNUSED,
return AVB_IO_RESULT_OK; return AVB_IO_RESULT_OK;
} }
static AvbIOResult dummy_get_unique_guid_for_partition( static AvbIOResult dummy_get_unique_guid_for_partition(AvbOps* ops ATTRIBUTE_UNUSED,
AvbOps *ops ATTRIBUTE_UNUSED, const char* partition ATTRIBUTE_UNUSED,
const char *partition ATTRIBUTE_UNUSED, char* guid_buf, size_t guid_buf_size) {
char *guid_buf,
size_t guid_buf_size)
{
// The function is for bootloader to set the correct UUID // The function is for bootloader to set the correct UUID
// for a given partition in kernel cmdline. // for a given partition in kernel cmdline.
// In user-space, returns a faking one as we don't need to update // In user-space, returns a faking one as we don't need to update
@ -182,14 +165,13 @@ static AvbIOResult dummy_get_unique_guid_for_partition(
return AVB_IO_RESULT_OK; return AVB_IO_RESULT_OK;
} }
AvbOps *fs_mgr_dummy_avb_ops_new(struct fstab *fstab) AvbOps* fs_mgr_dummy_avb_ops_new(struct fstab* fstab) {
{ AvbOps* ops;
AvbOps *ops;
// Assigns the fstab to the static variable for later use. // Assigns the fstab to the static variable for later use.
fs_mgr_fstab = fstab; fs_mgr_fstab = fstab;
ops = (AvbOps *)calloc(1, sizeof(AvbOps)); ops = (AvbOps*)calloc(1, sizeof(AvbOps));
if (ops == nullptr) { if (ops == nullptr) {
LERROR << "Error allocating memory for AvbOps"; LERROR << "Error allocating memory for AvbOps";
return nullptr; return nullptr;
@ -207,7 +189,4 @@ AvbOps *fs_mgr_dummy_avb_ops_new(struct fstab *fstab)
return ops; return ops;
} }
void fs_mgr_dummy_avb_ops_free(AvbOps *ops) void fs_mgr_dummy_avb_ops_free(AvbOps* ops) { free(ops); }
{
free(ops);
}

4
fs_mgr/fs_mgr_avb_ops.h
View file

@ -49,10 +49,10 @@ __BEGIN_DECLS
* *
* Frees with fs_mgr_dummy_avb_ops_free(). * Frees with fs_mgr_dummy_avb_ops_free().
*/ */
AvbOps *fs_mgr_dummy_avb_ops_new(struct fstab *fstab); AvbOps* fs_mgr_dummy_avb_ops_new(struct fstab* fstab);
/* Frees an AvbOps instance previously allocated with fs_mgr_avb_ops_new(). */ /* Frees an AvbOps instance previously allocated with fs_mgr_avb_ops_new(). */
void fs_mgr_dummy_avb_ops_free(AvbOps *ops); void fs_mgr_dummy_avb_ops_free(AvbOps* ops);
__END_DECLS __END_DECLS

27
fs_mgr/fs_mgr_dm_ioctl.cpp
View file

@ -23,10 +23,7 @@
#include "fs_mgr_priv.h" #include "fs_mgr_priv.h"
#include "fs_mgr_priv_dm_ioctl.h" #include "fs_mgr_priv_dm_ioctl.h"
void fs_mgr_verity_ioctl_init(struct dm_ioctl *io, void fs_mgr_verity_ioctl_init(struct dm_ioctl* io, const std::string& name, unsigned flags) {
const std::string &name,
unsigned flags)
{
memset(io, 0, DM_BUF_SIZE); memset(io, 0, DM_BUF_SIZE);
io->data_size = DM_BUF_SIZE; io->data_size = DM_BUF_SIZE;
io->data_start = sizeof(struct dm_ioctl); io->data_start = sizeof(struct dm_ioctl);
@ -39,10 +36,7 @@ void fs_mgr_verity_ioctl_init(struct dm_ioctl *io,
} }
} }
bool fs_mgr_create_verity_device(struct dm_ioctl *io, bool fs_mgr_create_verity_device(struct dm_ioctl* io, const std::string& name, int fd) {
const std::string &name,
int fd)
{
fs_mgr_verity_ioctl_init(io, name, 1); fs_mgr_verity_ioctl_init(io, name, 1);
if (ioctl(fd, DM_DEV_CREATE, io)) { if (ioctl(fd, DM_DEV_CREATE, io)) {
PERROR << "Error creating device mapping"; PERROR << "Error creating device mapping";
@ -51,10 +45,7 @@ bool fs_mgr_create_verity_device(struct dm_ioctl *io,
return true; return true;
} }
bool fs_mgr_destroy_verity_device(struct dm_ioctl *io, bool fs_mgr_destroy_verity_device(struct dm_ioctl* io, const std::string& name, int fd) {
const std::string &name,
int fd)
{
fs_mgr_verity_ioctl_init(io, name, 0); fs_mgr_verity_ioctl_init(io, name, 0);
if (ioctl(fd, DM_DEV_REMOVE, io)) { if (ioctl(fd, DM_DEV_REMOVE, io)) {
PERROR << "Error removing device mapping"; PERROR << "Error removing device mapping";
@ -63,11 +54,8 @@ bool fs_mgr_destroy_verity_device(struct dm_ioctl *io,
return true; return true;
} }
bool fs_mgr_get_verity_device_name(struct dm_ioctl *io, bool fs_mgr_get_verity_device_name(struct dm_ioctl* io, const std::string& name, int fd,
const std::string &name, std::string* out_dev_name) {
int fd,
std::string *out_dev_name)
{
FS_MGR_CHECK(out_dev_name != nullptr); FS_MGR_CHECK(out_dev_name != nullptr);
fs_mgr_verity_ioctl_init(io, name, 0); fs_mgr_verity_ioctl_init(io, name, 0);
@ -82,10 +70,7 @@ bool fs_mgr_get_verity_device_name(struct dm_ioctl *io,
return true; return true;
} }
bool fs_mgr_resume_verity_table(struct dm_ioctl *io, bool fs_mgr_resume_verity_table(struct dm_ioctl* io, const std::string& name, int fd) {
const std::string &name,
int fd)
{
fs_mgr_verity_ioctl_init(io, name, 0); fs_mgr_verity_ioctl_init(io, name, 0);
if (ioctl(fd, DM_DEV_SUSPEND, io)) { if (ioctl(fd, DM_DEV_SUSPEND, io)) {
PERROR << "Error activating verity device"; PERROR << "Error activating verity device";

4
fs_mgr/fs_mgr_priv_avb.h
View file

@ -45,11 +45,11 @@ bool fs_mgr_is_avb_used();
* developers to make the filesystem writable to allow replacing * developers to make the filesystem writable to allow replacing
* binaries on the device. * binaries on the device.
*/ */
int fs_mgr_load_vbmeta_images(struct fstab *fstab); int fs_mgr_load_vbmeta_images(struct fstab* fstab);
void fs_mgr_unload_vbmeta_images(); void fs_mgr_unload_vbmeta_images();
int fs_mgr_setup_avb(struct fstab_rec *fstab_entry); int fs_mgr_setup_avb(struct fstab_rec* fstab_entry);
__END_DECLS __END_DECLS

24
fs_mgr/fs_mgr_priv_dm_ioctl.h
View file

@ -17,28 +17,18 @@
#ifndef __CORE_FS_MGR_PRIV_DM_IOCTL_H #ifndef __CORE_FS_MGR_PRIV_DM_IOCTL_H
#define __CORE_FS_MGR_PRIV_DM_IOCTL_H #define __CORE_FS_MGR_PRIV_DM_IOCTL_H
#include <string>
#include <linux/dm-ioctl.h> #include <linux/dm-ioctl.h>
#include <string>
void fs_mgr_verity_ioctl_init(struct dm_ioctl *io, void fs_mgr_verity_ioctl_init(struct dm_ioctl* io, const std::string& name, unsigned flags);
const std::string &name,
unsigned flags);
bool fs_mgr_create_verity_device(struct dm_ioctl *io, bool fs_mgr_create_verity_device(struct dm_ioctl* io, const std::string& name, int fd);
const std::string &name,
int fd);
bool fs_mgr_destroy_verity_device(struct dm_ioctl *io, bool fs_mgr_destroy_verity_device(struct dm_ioctl* io, const std::string& name, int fd);
const std::string &name,
int fd);
bool fs_mgr_get_verity_device_name(struct dm_ioctl *io, bool fs_mgr_get_verity_device_name(struct dm_ioctl* io, const std::string& name, int fd,
const std::string &name, std::string* out_dev_name);
int fd,
std::string *out_dev_name);
bool fs_mgr_resume_verity_table(struct dm_ioctl *io, bool fs_mgr_resume_verity_table(struct dm_ioctl* io, const std::string& name, int fd);
const std::string &name,
int fd);
#endif /* __CORE_FS_MGR_PRIV_DM_IOCTL_H */ #endif /* __CORE_FS_MGR_PRIV_DM_IOCTL_H */

30
fs_mgr/fs_mgr_priv_sha.h
View file

@ -19,8 +19,7 @@
#include <openssl/sha.h> #include <openssl/sha.h>
class SHA256Hasher class SHA256Hasher {
{
private: private:
SHA256_CTX sha256_ctx; SHA256_CTX sha256_ctx;
uint8_t hash[SHA256_DIGEST_LENGTH]; uint8_t hash[SHA256_DIGEST_LENGTH];
@ -28,25 +27,17 @@ class SHA256Hasher
public: public:
enum { DIGEST_SIZE = SHA256_DIGEST_LENGTH }; enum { DIGEST_SIZE = SHA256_DIGEST_LENGTH };
SHA256Hasher() SHA256Hasher() { SHA256_Init(&sha256_ctx); }
{
SHA256_Init(&sha256_ctx);
}
void update(const void *data, size_t data_size) void update(const void* data, size_t data_size) { SHA256_Update(&sha256_ctx, data, data_size); }
{
SHA256_Update(&sha256_ctx, data, data_size);
}
const uint8_t *finalize() const uint8_t* finalize() {
{
SHA256_Final(hash, &sha256_ctx); SHA256_Final(hash, &sha256_ctx);
return hash; return hash;
} }
}; };
class SHA512Hasher class SHA512Hasher {
{
private: private:
SHA512_CTX sha512_ctx; SHA512_CTX sha512_ctx;
uint8_t hash[SHA512_DIGEST_LENGTH]; uint8_t hash[SHA512_DIGEST_LENGTH];
@ -54,18 +45,13 @@ class SHA512Hasher
public: public:
enum { DIGEST_SIZE = SHA512_DIGEST_LENGTH }; enum { DIGEST_SIZE = SHA512_DIGEST_LENGTH };
SHA512Hasher() SHA512Hasher() { SHA512_Init(&sha512_ctx); }
{
SHA512_Init(&sha512_ctx);
}
void update(const uint8_t *data, size_t data_size) void update(const uint8_t* data, size_t data_size) {
{
SHA512_Update(&sha512_ctx, data, data_size); SHA512_Update(&sha512_ctx, data, data_size);
} }
const uint8_t *finalize() const uint8_t* finalize() {
{
SHA512_Final(hash, &sha512_ctx); SHA512_Final(hash, &sha512_ctx);
return hash; return hash;
} }