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 <map>
30 #include <string>
31 
32 #include <libavb_ab/libavb_ab.h>
33 #include <libavb_atx/libavb_atx.h>
34 
35 namespace avb {
36 
37 // A delegate interface for ops callbacks. This allows tests to override default
38 // fake implementations.
39 class FakeAvbOpsDelegate {
40  public:
~FakeAvbOpsDelegate()41   virtual ~FakeAvbOpsDelegate() {}
42   virtual AvbIOResult read_from_partition(const char* partition,
43                                           int64_t offset,
44                                           size_t num_bytes,
45                                           void* buffer,
46                                           size_t* out_num_read) = 0;
47 
48   virtual AvbIOResult write_to_partition(const char* partition,
49                                          int64_t offset,
50                                          size_t num_bytes,
51                                          const void* buffer) = 0;
52 
53   virtual AvbIOResult validate_vbmeta_public_key(
54       AvbOps* ops,
55       const uint8_t* public_key_data,
56       size_t public_key_length,
57       const uint8_t* public_key_metadata,
58       size_t public_key_metadata_length,
59       bool* out_key_is_trusted) = 0;
60 
61   virtual AvbIOResult read_rollback_index(AvbOps* ops,
62                                           size_t rollback_index_slot,
63                                           uint64_t* out_rollback_index) = 0;
64 
65   virtual AvbIOResult write_rollback_index(AvbOps* ops,
66                                            size_t rollback_index_slot,
67                                            uint64_t rollback_index) = 0;
68 
69   virtual AvbIOResult read_is_device_unlocked(AvbOps* ops,
70                                               bool* out_is_device_unlocked) = 0;
71 
72   virtual AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
73                                                     const char* partition,
74                                                     char* guid_buf,
75                                                     size_t guid_buf_size) = 0;
76 
77   virtual AvbIOResult read_permanent_attributes(
78       AvbAtxPermanentAttributes* attributes) = 0;
79 
80   virtual AvbIOResult read_permanent_attributes_hash(
81       uint8_t hash[AVB_SHA256_DIGEST_SIZE]) = 0;
82 };
83 
84 // Provides fake implementations of AVB ops. All instances of this class must be
85 // created on the same thread.
86 class FakeAvbOps : public FakeAvbOpsDelegate {
87  public:
88   FakeAvbOps();
89   virtual ~FakeAvbOps();
90 
GetInstanceFromAvbOps(AvbOps * ops)91   static FakeAvbOps* GetInstanceFromAvbOps(AvbOps* ops) {
92     return reinterpret_cast<FakeAvbOps*>(ops->user_data);
93   }
GetInstanceFromAvbABOps(AvbABOps * ab_ops)94   static FakeAvbOps* GetInstanceFromAvbABOps(AvbABOps* ab_ops) {
95     return reinterpret_cast<FakeAvbOps*>(ab_ops->ops->user_data);
96   }
97 
avb_ops()98   AvbOps* avb_ops() {
99     return &avb_ops_;
100   }
101 
avb_ab_ops()102   AvbABOps* avb_ab_ops() {
103     return &avb_ab_ops_;
104   }
105 
avb_atx_ops()106   AvbAtxOps* avb_atx_ops() {
107     return &avb_atx_ops_;
108   }
109 
delegate()110   FakeAvbOpsDelegate* delegate() {
111     return delegate_;
112   }
113 
114   // Does not take ownership of |delegate|.
set_delegate(FakeAvbOpsDelegate * delegate)115   void set_delegate(FakeAvbOpsDelegate* delegate) {
116     delegate_ = delegate;
117   }
118 
set_partition_dir(const base::FilePath & partition_dir)119   void set_partition_dir(const base::FilePath& partition_dir) {
120     partition_dir_ = partition_dir;
121   }
122 
set_expected_public_key(const std::string & expected_public_key)123   void set_expected_public_key(const std::string& expected_public_key) {
124     expected_public_key_ = expected_public_key;
125   }
126 
set_expected_public_key_metadata(const std::string & expected_public_key_metadata)127   void set_expected_public_key_metadata(
128       const std::string& expected_public_key_metadata) {
129     expected_public_key_metadata_ = expected_public_key_metadata;
130   }
131 
set_stored_rollback_indexes(const std::map<size_t,uint64_t> & stored_rollback_indexes)132   void set_stored_rollback_indexes(
133       const std::map<size_t, uint64_t>& stored_rollback_indexes) {
134     stored_rollback_indexes_ = stored_rollback_indexes;
135   }
136 
get_stored_rollback_indexes()137   std::map<size_t, uint64_t> get_stored_rollback_indexes() {
138     return stored_rollback_indexes_;
139   }
140 
set_stored_is_device_unlocked(bool stored_is_device_unlocked)141   void set_stored_is_device_unlocked(bool stored_is_device_unlocked) {
142     stored_is_device_unlocked_ = stored_is_device_unlocked;
143   }
144 
set_permanent_attributes(const AvbAtxPermanentAttributes & attributes)145   void set_permanent_attributes(const AvbAtxPermanentAttributes& attributes) {
146     permanent_attributes_ = attributes;
147   }
148 
set_permanent_attributes_hash(const std::string & hash)149   void set_permanent_attributes_hash(const std::string& hash) {
150     permanent_attributes_hash_ = hash;
151   }
152 
153   // FakeAvbOpsDelegate methods.
154   AvbIOResult read_from_partition(const char* partition,
155                                   int64_t offset,
156                                   size_t num_bytes,
157                                   void* buffer,
158                                   size_t* out_num_read) override;
159 
160   AvbIOResult write_to_partition(const char* partition,
161                                  int64_t offset,
162                                  size_t num_bytes,
163                                  const void* buffer) override;
164 
165   AvbIOResult validate_vbmeta_public_key(AvbOps* ops,
166                                          const uint8_t* public_key_data,
167                                          size_t public_key_length,
168                                          const uint8_t* public_key_metadata,
169                                          size_t public_key_metadata_length,
170                                          bool* out_key_is_trusted) override;
171 
172   AvbIOResult read_rollback_index(AvbOps* ops,
173                                   size_t rollback_index_location,
174                                   uint64_t* out_rollback_index) override;
175 
176   AvbIOResult write_rollback_index(AvbOps* ops,
177                                    size_t rollback_index_location,
178                                    uint64_t rollback_index) override;
179 
180   AvbIOResult read_is_device_unlocked(AvbOps* ops,
181                                       bool* out_is_device_unlocked) override;
182 
183   AvbIOResult get_unique_guid_for_partition(AvbOps* ops,
184                                             const char* partition,
185                                             char* guid_buf,
186                                             size_t guid_buf_size) override;
187 
188   AvbIOResult read_permanent_attributes(
189       AvbAtxPermanentAttributes* attributes) override;
190 
191   AvbIOResult read_permanent_attributes_hash(
192       uint8_t hash[AVB_SHA256_DIGEST_SIZE]) override;
193 
194  private:
195   AvbOps avb_ops_;
196   AvbABOps avb_ab_ops_;
197   AvbAtxOps avb_atx_ops_;
198 
199   FakeAvbOpsDelegate* delegate_;
200 
201   base::FilePath partition_dir_;
202 
203   std::string expected_public_key_;
204   std::string expected_public_key_metadata_;
205 
206   std::map<size_t, uint64_t> stored_rollback_indexes_;
207 
208   bool stored_is_device_unlocked_;
209 
210   AvbAtxPermanentAttributes permanent_attributes_;
211   std::string permanent_attributes_hash_;
212 };
213 
214 }  // namespace avb
215 
216 #endif /* FAKE_AVB_OPS_H_ */
217