1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Permission is hereby granted, free of charge, to any person 5 * obtaining a copy of this software and associated documentation 6 * files (the "Software"), to deal in the Software without 7 * restriction, including without limitation the rights to use, copy, 8 * modify, merge, publish, distribute, sublicense, and/or sell copies 9 * of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 */ 24 25 #ifndef FAKE_AVB_OPS_H_ 26 #define FAKE_AVB_OPS_H_ 27 28 #include <base/files/file_util.h> 29 #include <libavb_ab/libavb_ab.h> 30 #include <libavb_cert/libavb_cert.h> 31 32 #include <filesystem> 33 #include <map> 34 #include <set> 35 #include <string> 36 37 namespace avb { 38 39 // A delegate interface for ops callbacks. This allows tests to override default 40 // fake implementations. For convenience, test fixtures can inherit 41 // FakeAvbOpsDelegateWithDefaults and only override as needed. 42 class FakeAvbOpsDelegate { 43 public: ~FakeAvbOpsDelegate()44 virtual ~FakeAvbOpsDelegate() {} 45 virtual AvbIOResult read_from_partition(const char* partition, 46 int64_t offset, 47 size_t num_bytes, 48 void* buffer, 49 size_t* out_num_read) = 0; 50 51 virtual AvbIOResult get_preloaded_partition( 52 const char* partition, 53 size_t num_bytes, 54 uint8_t** out_pointer, 55 size_t* out_num_bytes_preloaded) = 0; 56 57 virtual AvbIOResult write_to_partition(const char* partition, 58 int64_t offset, 59 size_t num_bytes, 60 const void* buffer) = 0; 61 62 virtual AvbIOResult validate_vbmeta_public_key( 63 AvbOps* ops, 64 const uint8_t* public_key_data, 65 size_t public_key_length, 66 const uint8_t* public_key_metadata, 67 size_t public_key_metadata_length, 68 bool* out_key_is_trusted) = 0; 69 70 virtual AvbIOResult read_rollback_index(AvbOps* ops, 71 size_t rollback_index_slot, 72 uint64_t* out_rollback_index) = 0; 73 74 virtual AvbIOResult write_rollback_index(AvbOps* ops, 75 size_t rollback_index_slot, 76 uint64_t rollback_index) = 0; 77 78 virtual AvbIOResult read_is_device_unlocked(AvbOps* ops, 79 bool* out_is_device_unlocked) = 0; 80 81 virtual AvbIOResult get_unique_guid_for_partition(AvbOps* ops, 82 const char* partition, 83 char* guid_buf, 84 size_t guid_buf_size) = 0; 85 86 virtual AvbIOResult get_size_of_partition(AvbOps* ops, 87 const char* partition, 88 uint64_t* out_size) = 0; 89 90 virtual AvbIOResult read_persistent_value(const char* name, 91 size_t buffer_size, 92 uint8_t* out_buffer, 93 size_t* out_num_bytes_read) = 0; 94 95 virtual AvbIOResult write_persistent_value(const char* name, 96 size_t value_size, 97 const uint8_t* value) = 0; 98 99 virtual AvbIOResult validate_public_key_for_partition( 100 AvbOps* ops, 101 const char* partition, 102 const uint8_t* public_key_data, 103 size_t public_key_length, 104 const uint8_t* public_key_metadata, 105 size_t public_key_metadata_length, 106 bool* out_is_trusted, 107 uint32_t* out_rollback_index_location) = 0; 108 109 virtual AvbIOResult read_permanent_attributes( 110 AvbCertPermanentAttributes* attributes) = 0; 111 112 virtual AvbIOResult read_permanent_attributes_hash( 113 uint8_t hash[AVB_SHA256_DIGEST_SIZE]) = 0; 114 115 virtual void set_key_version(size_t rollback_index_location, 116 uint64_t key_version) = 0; 117 118 virtual AvbIOResult get_random(size_t num_bytes, uint8_t* output) = 0; 119 }; 120 121 // Provides fake implementations of AVB ops. All instances of this class must be 122 // created on the same thread. 123 class FakeAvbOps : public FakeAvbOpsDelegate { 124 public: 125 FakeAvbOps(); 126 virtual ~FakeAvbOps(); 127 GetInstanceFromAvbOps(AvbOps * ops)128 static FakeAvbOps* GetInstanceFromAvbOps(AvbOps* ops) { 129 return reinterpret_cast<FakeAvbOps*>(ops->user_data); 130 } GetInstanceFromAvbABOps(AvbABOps * ab_ops)131 static FakeAvbOps* GetInstanceFromAvbABOps(AvbABOps* ab_ops) { 132 return reinterpret_cast<FakeAvbOps*>(ab_ops->ops->user_data); 133 } 134 avb_ops()135 AvbOps* avb_ops() { 136 return &avb_ops_; 137 } 138 avb_ab_ops()139 AvbABOps* avb_ab_ops() { 140 return &avb_ab_ops_; 141 } 142 avb_cert_ops()143 AvbCertOps* avb_cert_ops() { 144 return &avb_cert_ops_; 145 } 146 delegate()147 FakeAvbOpsDelegate* delegate() { 148 return delegate_; 149 } 150 151 // Does not take ownership of |delegate|. set_delegate(FakeAvbOpsDelegate * delegate)152 void set_delegate(FakeAvbOpsDelegate* delegate) { 153 delegate_ = delegate; 154 } 155 set_partition_dir(const std::filesystem::path & partition_dir)156 void set_partition_dir(const std::filesystem::path& partition_dir) { 157 partition_dir_ = partition_dir; 158 } 159 set_expected_public_key(const std::string & expected_public_key)160 void set_expected_public_key(const std::string& expected_public_key) { 161 expected_public_key_ = expected_public_key; 162 } 163 set_expected_public_key_for_partition(const std::string & partition_name,const std::string & expected_public_key,uint32_t rollback_index_location)164 void set_expected_public_key_for_partition( 165 const std::string& partition_name, 166 const std::string& expected_public_key, 167 uint32_t rollback_index_location) { 168 expected_public_key_for_partition_map_[partition_name] = 169 expected_public_key; 170 rollback_index_location_for_partition_map_[partition_name] = 171 rollback_index_location; 172 } 173 set_expected_public_key_metadata(const std::string & expected_public_key_metadata)174 void set_expected_public_key_metadata( 175 const std::string& expected_public_key_metadata) { 176 expected_public_key_metadata_ = expected_public_key_metadata; 177 } 178 set_stored_rollback_indexes(const std::map<size_t,uint64_t> & stored_rollback_indexes)179 void set_stored_rollback_indexes( 180 const std::map<size_t, uint64_t>& stored_rollback_indexes) { 181 stored_rollback_indexes_ = stored_rollback_indexes; 182 } 183 get_stored_rollback_indexes()184 std::map<size_t, uint64_t> get_stored_rollback_indexes() { 185 return stored_rollback_indexes_; 186 } 187 get_verified_rollback_indexes()188 std::map<size_t, uint64_t> get_verified_rollback_indexes() { 189 return verified_rollback_indexes_; 190 } 191 set_stored_is_device_unlocked(bool stored_is_device_unlocked)192 void set_stored_is_device_unlocked(bool stored_is_device_unlocked) { 193 stored_is_device_unlocked_ = stored_is_device_unlocked; 194 } 195 set_permanent_attributes(const AvbCertPermanentAttributes & attributes)196 void set_permanent_attributes(const AvbCertPermanentAttributes& attributes) { 197 permanent_attributes_ = attributes; 198 } 199 set_permanent_attributes_hash(const std::string & hash)200 void set_permanent_attributes_hash(const std::string& hash) { 201 permanent_attributes_hash_ = hash; 202 } 203 204 // All AvbOps for partitions in the given set will fail with 205 // AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION. set_hidden_partitions(const std::set<std::string> & partitions)206 void set_hidden_partitions(const std::set<std::string>& partitions) { 207 hidden_partitions_ = partitions; 208 } 209 210 void enable_get_preloaded_partition(); 211 212 bool preload_partition(const std::string& partition, 213 const base::FilePath& path); 214 215 bool preload_preallocated_partition(const std::string& partition, 216 uint8_t* buffer, 217 size_t size); 218 219 // Gets the partition names that were passed to the 220 // read_from_partition() operation. 221 std::set<std::string> get_partition_names_read_from(); 222 223 // FakeAvbOpsDelegate methods. 224 AvbIOResult read_from_partition(const char* partition, 225 int64_t offset, 226 size_t num_bytes, 227 void* buffer, 228 size_t* out_num_read) override; 229 230 AvbIOResult get_preloaded_partition(const char* partition, 231 size_t num_bytes, 232 uint8_t** out_pointer, 233 size_t* out_num_bytes_preloaded) override; 234 235 AvbIOResult write_to_partition(const char* partition, 236 int64_t offset, 237 size_t num_bytes, 238 const void* buffer) override; 239 240 AvbIOResult validate_vbmeta_public_key(AvbOps* ops, 241 const uint8_t* public_key_data, 242 size_t public_key_length, 243 const uint8_t* public_key_metadata, 244 size_t public_key_metadata_length, 245 bool* out_key_is_trusted) override; 246 247 AvbIOResult read_rollback_index(AvbOps* ops, 248 size_t rollback_index_location, 249 uint64_t* out_rollback_index) override; 250 251 AvbIOResult write_rollback_index(AvbOps* ops, 252 size_t rollback_index_location, 253 uint64_t rollback_index) override; 254 255 AvbIOResult read_is_device_unlocked(AvbOps* ops, 256 bool* out_is_device_unlocked) override; 257 258 AvbIOResult get_unique_guid_for_partition(AvbOps* ops, 259 const char* partition, 260 char* guid_buf, 261 size_t guid_buf_size) override; 262 263 AvbIOResult get_size_of_partition(AvbOps* ops, 264 const char* partition, 265 uint64_t* out_size) override; 266 267 AvbIOResult read_persistent_value(const char* name, 268 size_t buffer_size, 269 uint8_t* out_buffer, 270 size_t* out_num_bytes_read) override; 271 272 AvbIOResult write_persistent_value(const char* name, 273 size_t value_size, 274 const uint8_t* value) override; 275 276 AvbIOResult validate_public_key_for_partition( 277 AvbOps* ops, 278 const char* partition, 279 const uint8_t* public_key_data, 280 size_t public_key_length, 281 const uint8_t* public_key_metadata, 282 size_t public_key_metadata_length, 283 bool* out_is_trusted, 284 uint32_t* out_rollback_index_location) override; 285 286 AvbIOResult read_permanent_attributes( 287 AvbCertPermanentAttributes* attributes) override; 288 289 AvbIOResult read_permanent_attributes_hash( 290 uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override; 291 292 void set_key_version(size_t rollback_index_location, 293 uint64_t key_version) override; 294 295 AvbIOResult get_random(size_t num_bytes, uint8_t* output) override; 296 297 private: 298 AvbOps avb_ops_; 299 AvbABOps avb_ab_ops_; 300 AvbCertOps avb_cert_ops_; 301 302 FakeAvbOpsDelegate* delegate_; 303 304 std::filesystem::path partition_dir_; 305 306 std::string expected_public_key_; 307 std::string expected_public_key_metadata_; 308 309 std::map<std::string, std::string> expected_public_key_for_partition_map_; 310 311 std::map<std::string, uint32_t> rollback_index_location_for_partition_map_; 312 313 std::map<size_t, uint64_t> stored_rollback_indexes_; 314 std::map<size_t, uint64_t> verified_rollback_indexes_; 315 316 bool stored_is_device_unlocked_; 317 318 AvbCertPermanentAttributes permanent_attributes_; 319 std::string permanent_attributes_hash_; 320 321 std::set<std::string> partition_names_read_from_; 322 std::map<std::string, uint8_t*> preloaded_partitions_; 323 std::map<std::string, std::pair<uint8_t*, size_t>> 324 preallocated_preloaded_partitions_; 325 std::set<std::string> hidden_partitions_; 326 327 std::map<std::string, std::string> stored_values_; 328 }; 329 330 // A delegate implementation that calls FakeAvbOps by default. 331 class FakeAvbOpsDelegateWithDefaults : public FakeAvbOpsDelegate { 332 public: read_from_partition(const char * partition,int64_t offset,size_t num_bytes,void * buffer,size_t * out_num_read)333 AvbIOResult read_from_partition(const char* partition, 334 int64_t offset, 335 size_t num_bytes, 336 void* buffer, 337 size_t* out_num_read) override { 338 return ops_.read_from_partition( 339 partition, offset, num_bytes, buffer, out_num_read); 340 } 341 get_preloaded_partition(const char * partition,size_t num_bytes,uint8_t ** out_pointer,size_t * out_num_bytes_preloaded)342 AvbIOResult get_preloaded_partition( 343 const char* partition, 344 size_t num_bytes, 345 uint8_t** out_pointer, 346 size_t* out_num_bytes_preloaded) override { 347 return ops_.get_preloaded_partition( 348 partition, num_bytes, out_pointer, out_num_bytes_preloaded); 349 } 350 write_to_partition(const char * partition,int64_t offset,size_t num_bytes,const void * buffer)351 AvbIOResult write_to_partition(const char* partition, 352 int64_t offset, 353 size_t num_bytes, 354 const void* buffer) override { 355 return ops_.write_to_partition(partition, offset, num_bytes, buffer); 356 } 357 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)358 AvbIOResult validate_vbmeta_public_key(AvbOps* ops, 359 const uint8_t* public_key_data, 360 size_t public_key_length, 361 const uint8_t* public_key_metadata, 362 size_t public_key_metadata_length, 363 bool* out_key_is_trusted) override { 364 return ops_.validate_vbmeta_public_key(ops, 365 public_key_data, 366 public_key_length, 367 public_key_metadata, 368 public_key_metadata_length, 369 out_key_is_trusted); 370 } 371 validate_public_key_for_partition(AvbOps * ops,const char * partition,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,uint32_t * out_rollback_index_location)372 AvbIOResult validate_public_key_for_partition( 373 AvbOps* ops, 374 const char* partition, 375 const uint8_t* public_key_data, 376 size_t public_key_length, 377 const uint8_t* public_key_metadata, 378 size_t public_key_metadata_length, 379 bool* out_key_is_trusted, 380 uint32_t* out_rollback_index_location) override { 381 return ops_.validate_public_key_for_partition(ops, 382 partition, 383 public_key_data, 384 public_key_length, 385 public_key_metadata, 386 public_key_metadata_length, 387 out_key_is_trusted, 388 out_rollback_index_location); 389 } 390 read_rollback_index(AvbOps * ops,size_t rollback_index_slot,uint64_t * out_rollback_index)391 AvbIOResult read_rollback_index(AvbOps* ops, 392 size_t rollback_index_slot, 393 uint64_t* out_rollback_index) override { 394 return ops_.read_rollback_index( 395 ops, rollback_index_slot, out_rollback_index); 396 } 397 write_rollback_index(AvbOps * ops,size_t rollback_index_slot,uint64_t rollback_index)398 AvbIOResult write_rollback_index(AvbOps* ops, 399 size_t rollback_index_slot, 400 uint64_t rollback_index) override { 401 return ops_.write_rollback_index(ops, rollback_index_slot, rollback_index); 402 } 403 read_is_device_unlocked(AvbOps * ops,bool * out_is_device_unlocked)404 AvbIOResult read_is_device_unlocked(AvbOps* ops, 405 bool* out_is_device_unlocked) override { 406 return ops_.read_is_device_unlocked(ops, out_is_device_unlocked); 407 } 408 get_unique_guid_for_partition(AvbOps * ops,const char * partition,char * guid_buf,size_t guid_buf_size)409 AvbIOResult get_unique_guid_for_partition(AvbOps* ops, 410 const char* partition, 411 char* guid_buf, 412 size_t guid_buf_size) override { 413 return ops_.get_unique_guid_for_partition( 414 ops, partition, guid_buf, guid_buf_size); 415 } 416 get_size_of_partition(AvbOps * ops,const char * partition,uint64_t * out_size)417 AvbIOResult get_size_of_partition(AvbOps* ops, 418 const char* partition, 419 uint64_t* out_size) override { 420 return ops_.get_size_of_partition(ops, partition, out_size); 421 } 422 read_persistent_value(const char * name,size_t buffer_size,uint8_t * out_buffer,size_t * out_num_bytes_read)423 AvbIOResult read_persistent_value(const char* name, 424 size_t buffer_size, 425 uint8_t* out_buffer, 426 size_t* out_num_bytes_read) override { 427 return ops_.read_persistent_value( 428 name, buffer_size, out_buffer, out_num_bytes_read); 429 } 430 write_persistent_value(const char * name,size_t value_size,const uint8_t * value)431 AvbIOResult write_persistent_value(const char* name, 432 size_t value_size, 433 const uint8_t* value) override { 434 return ops_.write_persistent_value(name, value_size, value); 435 } 436 read_permanent_attributes(AvbCertPermanentAttributes * attributes)437 AvbIOResult read_permanent_attributes( 438 AvbCertPermanentAttributes* attributes) override { 439 return ops_.read_permanent_attributes(attributes); 440 } 441 read_permanent_attributes_hash(uint8_t hash[AVB_SHA256_DIGEST_SIZE])442 AvbIOResult read_permanent_attributes_hash( 443 uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override { 444 return ops_.read_permanent_attributes_hash(hash); 445 } 446 set_key_version(size_t rollback_index_location,uint64_t key_version)447 void set_key_version(size_t rollback_index_location, 448 uint64_t key_version) override { 449 ops_.set_key_version(rollback_index_location, key_version); 450 } 451 get_random(size_t num_bytes,uint8_t * output)452 AvbIOResult get_random(size_t num_bytes, uint8_t* output) override { 453 return ops_.get_random(num_bytes, output); 454 } 455 456 protected: 457 FakeAvbOps ops_; 458 }; 459 460 } // namespace avb 461 462 #endif /* FAKE_AVB_OPS_H_ */ 463