test/fake_avb_ops.h - platform/external/avb - Git at Google

 /*
  * 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_ */
	/*
	* 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_ */