/*
|
* Copyright (C) 2016 The Android Open Source Project
|
*
|
* Permission is hereby granted, free of charge, to any person
|
* obtaining a copy of this software and associated documentation
|
* files (the "Software"), to deal in the Software without
|
* restriction, including without limitation the rights to use, copy,
|
* modify, merge, publish, distribute, sublicense, and/or sell copies
|
* of the Software, and to permit persons to whom the Software is
|
* furnished to do so, subject to the following conditions:
|
*
|
* The above copyright notice and this permission notice shall be
|
* included in all copies or substantial portions of the Software.
|
*
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
* BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
* ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
* SOFTWARE.
|
*/
|
|
#ifndef FAKE_AVB_OPS_H_
|
#define FAKE_AVB_OPS_H_
|
|
#include <base/files/file_util.h>
|
#include <map>
|
#include <set>
|
#include <string>
|
|
#include <libavb_ab/libavb_ab.h>
|
#include <libavb_atx/libavb_atx.h>
|
|
namespace avb {
|
|
// A delegate interface for ops callbacks. This allows tests to override default
|
// fake implementations. For convenience, test fixtures can inherit
|
// FakeAvbOpsDelegateWithDefaults and only override as needed.
|
class FakeAvbOpsDelegate {
|
public:
|
virtual ~FakeAvbOpsDelegate() {}
|
virtual AvbIOResult read_from_partition(const char* partition,
|
int64_t offset,
|
size_t num_bytes,
|
void* buffer,
|
size_t* out_num_read) = 0;
|
|
virtual AvbIOResult get_preloaded_partition(
|
const char* partition,
|
size_t num_bytes,
|
uint8_t** out_pointer,
|
size_t* out_num_bytes_preloaded) = 0;
|
|
virtual AvbIOResult write_to_partition(const char* partition,
|
int64_t offset,
|
size_t num_bytes,
|
const void* buffer) = 0;
|
|
virtual AvbIOResult validate_vbmeta_public_key(
|
AvbOps* ops,
|
const uint8_t* public_key_data,
|
size_t public_key_length,
|
const uint8_t* public_key_metadata,
|
size_t public_key_metadata_length,
|
bool* out_key_is_trusted) = 0;
|
|
virtual AvbIOResult read_rollback_index(AvbOps* ops,
|
size_t rollback_index_slot,
|
uint64_t* out_rollback_index) = 0;
|
|
virtual AvbIOResult write_rollback_index(AvbOps* ops,
|
size_t rollback_index_slot,
|
uint64_t rollback_index) = 0;
|
|
virtual AvbIOResult read_is_device_unlocked(AvbOps* ops,
|
bool* out_is_device_unlocked) = 0;
|
|
virtual AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
|
const char* partition,
|
char* guid_buf,
|
size_t guid_buf_size) = 0;
|
|
virtual AvbIOResult get_size_of_partition(AvbOps* ops,
|
const char* partition,
|
uint64_t* out_size) = 0;
|
|
virtual AvbIOResult read_persistent_value(const char* name,
|
size_t buffer_size,
|
uint8_t* out_buffer,
|
size_t* out_num_bytes_read) = 0;
|
|
virtual AvbIOResult write_persistent_value(const char* name,
|
size_t value_size,
|
const uint8_t* value) = 0;
|
|
virtual AvbIOResult read_permanent_attributes(
|
AvbAtxPermanentAttributes* attributes) = 0;
|
|
virtual AvbIOResult read_permanent_attributes_hash(
|
uint8_t hash[AVB_SHA256_DIGEST_SIZE]) = 0;
|
|
virtual void set_key_version(size_t rollback_index_location,
|
uint64_t key_version) = 0;
|
|
virtual AvbIOResult get_random(size_t num_bytes, uint8_t* output) = 0;
|
};
|
|
// Provides fake implementations of AVB ops. All instances of this class must be
|
// created on the same thread.
|
class FakeAvbOps : public FakeAvbOpsDelegate {
|
public:
|
FakeAvbOps();
|
virtual ~FakeAvbOps();
|
|
static FakeAvbOps* GetInstanceFromAvbOps(AvbOps* ops) {
|
return reinterpret_cast<FakeAvbOps*>(ops->user_data);
|
}
|
static FakeAvbOps* GetInstanceFromAvbABOps(AvbABOps* ab_ops) {
|
return reinterpret_cast<FakeAvbOps*>(ab_ops->ops->user_data);
|
}
|
|
AvbOps* avb_ops() {
|
return &avb_ops_;
|
}
|
|
AvbABOps* avb_ab_ops() {
|
return &avb_ab_ops_;
|
}
|
|
AvbAtxOps* avb_atx_ops() {
|
return &avb_atx_ops_;
|
}
|
|
FakeAvbOpsDelegate* delegate() {
|
return delegate_;
|
}
|
|
// Does not take ownership of |delegate|.
|
void set_delegate(FakeAvbOpsDelegate* delegate) {
|
delegate_ = delegate;
|
}
|
|
void set_partition_dir(const base::FilePath& partition_dir) {
|
partition_dir_ = partition_dir;
|
}
|
|
void set_expected_public_key(const std::string& expected_public_key) {
|
expected_public_key_ = expected_public_key;
|
}
|
|
void set_expected_public_key_metadata(
|
const std::string& expected_public_key_metadata) {
|
expected_public_key_metadata_ = expected_public_key_metadata;
|
}
|
|
void set_stored_rollback_indexes(
|
const std::map<size_t, uint64_t>& stored_rollback_indexes) {
|
stored_rollback_indexes_ = stored_rollback_indexes;
|
}
|
|
std::map<size_t, uint64_t> get_stored_rollback_indexes() {
|
return stored_rollback_indexes_;
|
}
|
|
std::map<size_t, uint64_t> get_verified_rollback_indexes() {
|
return verified_rollback_indexes_;
|
}
|
|
void set_stored_is_device_unlocked(bool stored_is_device_unlocked) {
|
stored_is_device_unlocked_ = stored_is_device_unlocked;
|
}
|
|
void set_permanent_attributes(const AvbAtxPermanentAttributes& attributes) {
|
permanent_attributes_ = attributes;
|
}
|
|
void set_permanent_attributes_hash(const std::string& hash) {
|
permanent_attributes_hash_ = hash;
|
}
|
|
// All AvbOps for partitions in the given set will fail with
|
// AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION.
|
void set_hidden_partitions(const std::set<std::string>& partitions) {
|
hidden_partitions_ = partitions;
|
}
|
|
void enable_get_preloaded_partition();
|
|
bool preload_partition(const std::string& partition,
|
const base::FilePath& path);
|
|
// Gets the partition names that were passed to the
|
// read_from_partition() operation.
|
std::set<std::string> get_partition_names_read_from();
|
|
// FakeAvbOpsDelegate methods.
|
AvbIOResult read_from_partition(const char* partition,
|
int64_t offset,
|
size_t num_bytes,
|
void* buffer,
|
size_t* out_num_read) override;
|
|
AvbIOResult get_preloaded_partition(const char* partition,
|
size_t num_bytes,
|
uint8_t** out_pointer,
|
size_t* out_num_bytes_preloaded) override;
|
|
AvbIOResult write_to_partition(const char* partition,
|
int64_t offset,
|
size_t num_bytes,
|
const void* buffer) override;
|
|
AvbIOResult validate_vbmeta_public_key(AvbOps* ops,
|
const uint8_t* public_key_data,
|
size_t public_key_length,
|
const uint8_t* public_key_metadata,
|
size_t public_key_metadata_length,
|
bool* out_key_is_trusted) override;
|
|
AvbIOResult read_rollback_index(AvbOps* ops,
|
size_t rollback_index_location,
|
uint64_t* out_rollback_index) override;
|
|
AvbIOResult write_rollback_index(AvbOps* ops,
|
size_t rollback_index_location,
|
uint64_t rollback_index) override;
|
|
AvbIOResult read_is_device_unlocked(AvbOps* ops,
|
bool* out_is_device_unlocked) override;
|
|
AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
|
const char* partition,
|
char* guid_buf,
|
size_t guid_buf_size) override;
|
|
AvbIOResult get_size_of_partition(AvbOps* ops,
|
const char* partition,
|
uint64_t* out_size) override;
|
|
AvbIOResult read_persistent_value(const char* name,
|
size_t buffer_size,
|
uint8_t* out_buffer,
|
size_t* out_num_bytes_read) override;
|
|
AvbIOResult write_persistent_value(const char* name,
|
size_t value_size,
|
const uint8_t* value) override;
|
|
AvbIOResult read_permanent_attributes(
|
AvbAtxPermanentAttributes* attributes) override;
|
|
AvbIOResult read_permanent_attributes_hash(
|
uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override;
|
|
void set_key_version(size_t rollback_index_location,
|
uint64_t key_version) override;
|
|
AvbIOResult get_random(size_t num_bytes, uint8_t* output) override;
|
|
private:
|
AvbOps avb_ops_;
|
AvbABOps avb_ab_ops_;
|
AvbAtxOps avb_atx_ops_;
|
|
FakeAvbOpsDelegate* delegate_;
|
|
base::FilePath partition_dir_;
|
|
std::string expected_public_key_;
|
std::string expected_public_key_metadata_;
|
|
std::map<size_t, uint64_t> stored_rollback_indexes_;
|
std::map<size_t, uint64_t> verified_rollback_indexes_;
|
|
bool stored_is_device_unlocked_;
|
|
AvbAtxPermanentAttributes permanent_attributes_;
|
std::string permanent_attributes_hash_;
|
|
std::set<std::string> partition_names_read_from_;
|
std::map<std::string, uint8_t*> preloaded_partitions_;
|
std::set<std::string> hidden_partitions_;
|
|
std::map<std::string, std::string> stored_values_;
|
};
|
|
// A delegate implementation that calls FakeAvbOps by default.
|
class FakeAvbOpsDelegateWithDefaults : public FakeAvbOpsDelegate {
|
public:
|
AvbIOResult read_from_partition(const char* partition,
|
int64_t offset,
|
size_t num_bytes,
|
void* buffer,
|
size_t* out_num_read) override {
|
return ops_.read_from_partition(
|
partition, offset, num_bytes, buffer, out_num_read);
|
}
|
|
AvbIOResult get_preloaded_partition(
|
const char* partition,
|
size_t num_bytes,
|
uint8_t** out_pointer,
|
size_t* out_num_bytes_preloaded) override {
|
return ops_.get_preloaded_partition(
|
partition, num_bytes, out_pointer, out_num_bytes_preloaded);
|
}
|
|
AvbIOResult write_to_partition(const char* partition,
|
int64_t offset,
|
size_t num_bytes,
|
const void* buffer) override {
|
return ops_.write_to_partition(partition, offset, num_bytes, buffer);
|
}
|
|
AvbIOResult validate_vbmeta_public_key(AvbOps* ops,
|
const uint8_t* public_key_data,
|
size_t public_key_length,
|
const uint8_t* public_key_metadata,
|
size_t public_key_metadata_length,
|
bool* out_key_is_trusted) override {
|
return ops_.validate_vbmeta_public_key(ops,
|
public_key_data,
|
public_key_length,
|
public_key_metadata,
|
public_key_metadata_length,
|
out_key_is_trusted);
|
}
|
|
AvbIOResult read_rollback_index(AvbOps* ops,
|
size_t rollback_index_slot,
|
uint64_t* out_rollback_index) override {
|
return ops_.read_rollback_index(
|
ops, rollback_index_slot, out_rollback_index);
|
}
|
|
AvbIOResult write_rollback_index(AvbOps* ops,
|
size_t rollback_index_slot,
|
uint64_t rollback_index) override {
|
return ops_.write_rollback_index(ops, rollback_index_slot, rollback_index);
|
}
|
|
AvbIOResult read_is_device_unlocked(AvbOps* ops,
|
bool* out_is_device_unlocked) override {
|
return ops_.read_is_device_unlocked(ops, out_is_device_unlocked);
|
}
|
|
AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
|
const char* partition,
|
char* guid_buf,
|
size_t guid_buf_size) override {
|
return ops_.get_unique_guid_for_partition(
|
ops, partition, guid_buf, guid_buf_size);
|
}
|
|
AvbIOResult get_size_of_partition(AvbOps* ops,
|
const char* partition,
|
uint64_t* out_size) override {
|
return ops_.get_size_of_partition(ops, partition, out_size);
|
}
|
|
AvbIOResult read_persistent_value(const char* name,
|
size_t buffer_size,
|
uint8_t* out_buffer,
|
size_t* out_num_bytes_read) override {
|
return ops_.read_persistent_value(
|
name, buffer_size, out_buffer, out_num_bytes_read);
|
}
|
|
AvbIOResult write_persistent_value(const char* name,
|
size_t value_size,
|
const uint8_t* value) override {
|
return ops_.write_persistent_value(name, value_size, value);
|
}
|
|
AvbIOResult read_permanent_attributes(
|
AvbAtxPermanentAttributes* attributes) override {
|
return ops_.read_permanent_attributes(attributes);
|
}
|
|
AvbIOResult read_permanent_attributes_hash(
|
uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override {
|
return ops_.read_permanent_attributes_hash(hash);
|
}
|
|
void set_key_version(size_t rollback_index_location,
|
uint64_t key_version) override {
|
ops_.set_key_version(rollback_index_location, key_version);
|
}
|
|
AvbIOResult get_random(size_t num_bytes, uint8_t* output) override {
|
return ops_.get_random(num_bytes, output);
|
}
|
|
protected:
|
FakeAvbOps ops_;
|
};
|
|
} // namespace avb
|
|
#endif /* FAKE_AVB_OPS_H_ */
|
