1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include "attributes_test.h"
17 
18 #include <climits>
19 
20 #include "attributes.h"
21 
22 #include "iam_logger.h"
23 #include "securec.h"
24 
25 #define LOG_TAG "USER_AUTH_SA"
26 
27 namespace OHOS {
28 namespace UserIam {
29 namespace UserAuth {
30 using namespace testing;
31 using namespace testing::ext;
32 
SetUpTestCase()33 void AttributesTest::SetUpTestCase()
34 {
35 }
36 
TearDownTestCase()37 void AttributesTest::TearDownTestCase()
38 {
39 }
40 
SetUp()41 void AttributesTest::SetUp()
42 {
43 }
44 
TearDown()45 void AttributesTest::TearDown()
46 {
47 }
48 
49 HWTEST_F(AttributesTest, AttributesInit, TestSize.Level0)
50 {
51     Attributes attrs;
52     EXPECT_EQ(attrs.Serialize().size(), 0U);
53 }
54 
55 HWTEST_F(AttributesTest, AttributesSerialize, TestSize.Level0)
56 {
57     const std::vector<Attributes::AttributeKey> desired = {Attributes::ATTR_RESULT_CODE, Attributes::ATTR_SIGNATURE,
58         Attributes::ATTR_TEMPLATE_ID_LIST, Attributes::ATTR_REMAIN_TIMES, Attributes::ATTR_FREEZING_TIME,
59         Attributes::ATTR_SCHEDULE_ID, Attributes::ATTR_SCHEDULE_MODE};
60 
61     Attributes attrs;
62 
63     EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
64     EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_SIGNATURE, false));
65     EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_SCHEDULE_ID, UINT64_MAX));
66     EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, {1, 3, 5, 7, 9}));
67     EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_SCHEDULE_MODE, UINT32_MAX));
68     EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, {2, 4, 6, 8, 10}));
69     EXPECT_TRUE(attrs.SetStringValue(Attributes::ATTR_TEMPLATE_ID_LIST, "iam"));
70 
71     EXPECT_THAT(attrs.GetKeys(), ElementsAreArray(desired));
72     auto buff = attrs.Serialize();
73     Attributes attrs2(buff);
74     EXPECT_THAT(attrs2.GetKeys(), ElementsAreArray(desired));
75 
76     bool boolValue;
77     EXPECT_TRUE(attrs2.GetBoolValue(Attributes::ATTR_RESULT_CODE, boolValue));
78     EXPECT_EQ(boolValue, true);
79 
80     EXPECT_TRUE(attrs2.GetBoolValue(Attributes::ATTR_SIGNATURE, boolValue));
81     EXPECT_EQ(boolValue, false);
82 
83     uint64_t u64Value;
84     EXPECT_TRUE(attrs2.GetUint64Value(Attributes::ATTR_SCHEDULE_ID, u64Value));
85     EXPECT_EQ(u64Value, UINT64_MAX);
86 
87     std::vector<uint32_t> u32Vector;
88     EXPECT_TRUE(attrs2.GetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, u32Vector));
89     EXPECT_THAT(u32Vector, ElementsAre(1, 3, 5, 7, 9));
90 
91     uint32_t u32Value;
92     EXPECT_TRUE(attrs2.GetUint32Value(Attributes::ATTR_SCHEDULE_MODE, u32Value));
93     EXPECT_EQ(u32Value, UINT32_MAX);
94 
95     std::vector<uint64_t> u64Vector;
96     EXPECT_TRUE(attrs2.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, u64Vector));
97     EXPECT_THAT(u64Vector, ElementsAre(2, 4, 6, 8, 10));
98 
99     std::string str;
100     EXPECT_TRUE(attrs2.GetStringValue(Attributes::ATTR_TEMPLATE_ID_LIST, str));
101     EXPECT_EQ(str, "iam");
102 }
103 
104 HWTEST_F(AttributesTest, AttributesBoolValue, TestSize.Level0)
105 {
106     Attributes attrs;
107     EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
108     EXPECT_TRUE(attrs.SetBoolValue(Attributes::ATTR_SIGNATURE, false));
109 
110     bool value1;
111     bool value2;
112     EXPECT_TRUE(attrs.GetBoolValue(Attributes::ATTR_RESULT_CODE, value1));
113     EXPECT_TRUE(attrs.GetBoolValue(Attributes::ATTR_SIGNATURE, value2));
114     EXPECT_TRUE(value1);
115     EXPECT_FALSE(value2);
116 }
117 
118 HWTEST_F(AttributesTest, AttributesUint64Value, TestSize.Level0)
119 {
120     Attributes attrs;
121     EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_RESULT_CODE, UINT32_MAX));
122     EXPECT_TRUE(attrs.SetUint64Value(Attributes::ATTR_SIGNATURE, UINT64_MAX));
123 
124     uint64_t value1;
125     uint64_t value2;
126     EXPECT_TRUE(attrs.GetUint64Value(Attributes::ATTR_RESULT_CODE, value1));
127     EXPECT_TRUE(attrs.GetUint64Value(Attributes::ATTR_SIGNATURE, value2));
128     EXPECT_EQ(value1, UINT32_MAX);
129     EXPECT_EQ(value2, UINT64_MAX);
130 }
131 
132 HWTEST_F(AttributesTest, AttributesUint32Value, TestSize.Level0)
133 {
134     Attributes attrs;
135     EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_RESULT_CODE, UINT16_MAX));
136     EXPECT_TRUE(attrs.SetUint32Value(Attributes::ATTR_SIGNATURE, UINT32_MAX));
137 
138     uint32_t value1;
139     uint32_t value2;
140     EXPECT_TRUE(attrs.GetUint32Value(Attributes::ATTR_RESULT_CODE, value1));
141     EXPECT_TRUE(attrs.GetUint32Value(Attributes::ATTR_SIGNATURE, value2));
142     EXPECT_TRUE(value1 == UINT16_MAX);
143     EXPECT_TRUE(value2 == UINT32_MAX);
144 }
145 
146 HWTEST_F(AttributesTest, AttributesUint16Value, TestSize.Level0)
147 {
148     Attributes attrs;
149     EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_RESULT_CODE, UINT8_MAX));
150     EXPECT_TRUE(attrs.SetUint16Value(Attributes::ATTR_SIGNATURE, UINT16_MAX));
151 
152     uint16_t value1;
153     uint16_t value2;
154     EXPECT_TRUE(attrs.GetUint16Value(Attributes::ATTR_RESULT_CODE, value1));
155     EXPECT_TRUE(attrs.GetUint16Value(Attributes::ATTR_SIGNATURE, value2));
156     EXPECT_TRUE(value1 == UINT8_MAX);
157     EXPECT_TRUE(value2 == UINT16_MAX);
158 }
159 
160 HWTEST_F(AttributesTest, AttributesUint8Value, TestSize.Level0)
161 {
162     Attributes attrs;
163     EXPECT_TRUE(attrs.SetUint8Value(Attributes::ATTR_RESULT_CODE, 0));
164     EXPECT_TRUE(attrs.SetUint8Value(Attributes::ATTR_SIGNATURE, UINT8_MAX));
165 
166     uint8_t value1;
167     uint8_t value2;
168     EXPECT_TRUE(attrs.GetUint8Value(Attributes::ATTR_RESULT_CODE, value1));
169     EXPECT_TRUE(attrs.GetUint8Value(Attributes::ATTR_SIGNATURE, value2));
170     EXPECT_EQ(value1, 0);
171     EXPECT_EQ(value2, UINT8_MAX);
172 }
173 
174 HWTEST_F(AttributesTest, AttributesStringValue, TestSize.Level0)
175 {
176     Attributes attrs;
177     EXPECT_TRUE(attrs.SetStringValue(Attributes::ATTR_RESULT_CODE, "hello iam"));
178     EXPECT_TRUE(attrs.SetStringValue(Attributes::ATTR_SIGNATURE, ""));
179 
180     std::string value1;
181     std::string value2;
182     EXPECT_TRUE(attrs.GetStringValue(Attributes::ATTR_RESULT_CODE, value1));
183     EXPECT_TRUE(attrs.GetStringValue(Attributes::ATTR_SIGNATURE, value2));
184     EXPECT_EQ(value1, "hello iam");
185     EXPECT_EQ(value2, "");
186 }
187 
188 HWTEST_F(AttributesTest, AttributesUint64ByteArray, TestSize.Level0)
189 {
190     {
191         constexpr int SIZE = 8192;
192 
193         Attributes attrs;
194         std::vector<uint64_t> array;
195         array.reserve(SIZE);
196         for (int i = 0; i < SIZE; i++) {
197             array.push_back(UINT64_MAX - i);
198         }
199         EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
200 
201         std::vector<uint64_t> out;
202         EXPECT_TRUE(attrs.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
203         EXPECT_THAT(out, ElementsAreArray(array));
204     }
205 
206     {
207         Attributes attrs;
208         std::vector<uint64_t> array;
209         EXPECT_TRUE(attrs.SetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
210         EXPECT_TRUE(attrs.GetUint64ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
211         EXPECT_TRUE(array.empty());
212     }
213 }
214 
215 HWTEST_F(AttributesTest, AttributesUint32ByteArray, TestSize.Level0)
216 {
217     {
218         constexpr int SIZE = 8192;
219 
220         Attributes attrs;
221         std::vector<uint32_t> array;
222         array.reserve(SIZE);
223         for (int i = 0; i < SIZE; i++) {
224             array.push_back(UINT32_MAX - i);
225         }
226         EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
227 
228         std::vector<uint32_t> out;
229         EXPECT_TRUE(attrs.GetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
230         EXPECT_THAT(out, ElementsAreArray(array));
231     }
232     {
233         Attributes attrs;
234         std::vector<uint32_t> array;
235         EXPECT_TRUE(attrs.SetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
236 
237         EXPECT_TRUE(attrs.GetUint32ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
238         EXPECT_TRUE(array.empty());
239     }
240 }
241 
242 HWTEST_F(AttributesTest, AttributesUint16ByteArray, TestSize.Level0)
243 {
244     {
245         constexpr int SIZE = 8192;
246 
247         Attributes attrs;
248         std::vector<uint16_t> array;
249         array.reserve(SIZE);
250         for (int i = 0; i < SIZE; i++) {
251             array.push_back(UINT16_MAX - i);
252         }
253         EXPECT_TRUE(attrs.SetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
254 
255         std::vector<uint16_t> out;
256         EXPECT_TRUE(attrs.GetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
257         EXPECT_THAT(out, ElementsAreArray(array));
258     }
259     {
260         Attributes attrs;
261         std::vector<uint16_t> array;
262         EXPECT_TRUE(attrs.SetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
263 
264         EXPECT_TRUE(attrs.GetUint16ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
265         EXPECT_TRUE(array.empty());
266     }
267 }
268 
269 HWTEST_F(AttributesTest, AttributesUint8ByteArray, TestSize.Level0)
270 {
271     {
272         constexpr int SIZE = 8192;
273 
274         Attributes attrs;
275         std::vector<uint8_t> array;
276         array.reserve(SIZE);
277         for (int i = 0; i < SIZE; i++) {
278             array.push_back(i);
279         }
280         EXPECT_TRUE(attrs.SetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
281 
282         std::vector<uint8_t> out;
283         EXPECT_TRUE(attrs.GetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, out));
284         EXPECT_THAT(out, ElementsAreArray(array));
285     }
286     {
287         Attributes attrs;
288         std::vector<uint8_t> array;
289         EXPECT_TRUE(attrs.SetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
290 
291         EXPECT_TRUE(attrs.GetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, array));
292         EXPECT_TRUE(array.empty());
293     }
294 }
295 
296 HWTEST_F(AttributesTest, AttributesDeserializeMismatch, TestSize.Level0)
297 {
298     const std::vector<uint8_t> raw = {0, 0, 0, 0, 1, 0, 0, 0, 1, 2, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 5, 0,
299         0, 0, 7, 0, 0, 0, 9, 0, 0, 0, 3, 0, 0, 0, 40, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0,
300         0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0,
301         0, 255, 255, 255, 255, 6, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 7, 0, 0, 0, 4, 0, 0, 0,
302         105, 97, 109, 0};
303 
304     Attributes attrs(raw);
305     {
306         bool value;
307         EXPECT_FALSE(attrs.GetBoolValue(Attributes::ATTR_TEMPLATE_ID_LIST, value));
308     }
309     {
310         uint16_t value;
311         EXPECT_FALSE(attrs.GetUint16Value(Attributes::ATTR_TEMPLATE_ID_LIST, value));
312     }
313 }
314 
315 HWTEST_F(AttributesTest, AttributesEmptyArrays, TestSize.Level0)
316 {
317     Attributes attrs1;
318     bool value = true;
319     EXPECT_TRUE(attrs1.SetBoolValue(Attributes::ATTR_RESULT_CODE, value));
320 
321     std::vector<uint64_t> u64Vector;
322     EXPECT_TRUE(attrs1.SetUint64ArrayValue(Attributes::ATTR_SCHEDULE_ID, u64Vector));
323 
324     std::vector<uint32_t> u32Vector;
325     EXPECT_TRUE(attrs1.SetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, u32Vector));
326 
327     std::vector<uint16_t> u16Vector;
328     EXPECT_TRUE(attrs1.SetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, u16Vector));
329 
330     std::vector<uint8_t> u8Vector;
331     EXPECT_TRUE(attrs1.SetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, u8Vector));
332 
333     auto buff = attrs1.Serialize();
334     EXPECT_FALSE(buff.empty());
335     Attributes attrs2(buff);
336     EXPECT_TRUE(attrs1.GetBoolValue(Attributes::ATTR_RESULT_CODE, value));
337     EXPECT_TRUE(value);
338 
339     EXPECT_TRUE(attrs1.GetUint64ArrayValue(Attributes::ATTR_SCHEDULE_ID, u64Vector));
340     EXPECT_THAT(u64Vector, IsEmpty());
341 
342     EXPECT_TRUE(attrs1.GetUint32ArrayValue(Attributes::ATTR_REMAIN_TIMES, u32Vector));
343     EXPECT_THAT(u32Vector, IsEmpty());
344 
345     EXPECT_TRUE(attrs1.GetUint16ArrayValue(Attributes::ATTR_TEMPLATE_ID_LIST, u16Vector));
346     EXPECT_THAT(u16Vector, IsEmpty());
347 
348     EXPECT_TRUE(attrs1.GetUint8ArrayValue(Attributes::ATTR_FREEZING_TIME, u8Vector));
349     EXPECT_THAT(u8Vector, IsEmpty());
350 }
351 
352 HWTEST_F(AttributesTest, AttributesCopyAndMove, TestSize.Level0)
353 {
354     EXPECT_FALSE(std::is_copy_assignable<Attributes>::value);
355     EXPECT_FALSE(std::is_copy_constructible<Attributes>::value);
356 
357     const std::vector<uint8_t> raw = {0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 4, 0, 0, 0, 255,
358         255, 255, 255, 3, 0, 0, 0, 8, 0, 0, 0, 255, 255, 255, 255, 255, 255, 255, 255, 4, 0, 0, 0, 4, 0, 0, 0, 105, 97,
359         109, 0, 5, 0, 0, 0, 20, 0, 0, 0, 1, 0, 0, 0, 3, 0, 0, 0, 5, 0, 0, 0, 7, 0, 0, 0, 9, 0, 0, 0, 6, 0, 0, 0, 40, 0,
360         0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0,
361         0, 0, 0, 0, 0};
362     Attributes attrs1(raw);
363 
364     EXPECT_THAT(attrs1.Serialize(), ElementsAreArray(raw));
365 
366     Attributes attrs2 = std::move(attrs1);
367 
368     EXPECT_EQ(attrs1.Serialize().size(), 0U);
369     EXPECT_THAT(attrs2.Serialize(), ElementsAreArray(raw));
370 }
371 
372 HWTEST_F(AttributesTest, AttributesSetAndGetAttributesArray, TestSize.Level0)
373 {
374     Attributes attrs1;
375     Attributes attrs2;
376     EXPECT_TRUE(attrs1.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
377     EXPECT_TRUE(attrs1.SetBoolValue(Attributes::ATTR_SCHEDULE_ID, false));
378     EXPECT_TRUE(attrs2.SetBoolValue(Attributes::ATTR_RESULT_CODE, true));
379     EXPECT_TRUE(attrs2.SetBoolValue(Attributes::ATTR_SCHEDULE_ID, false));
380 
381     std::vector<Attributes> attrsArray;
382     attrsArray.push_back(Attributes(attrs1.Serialize()));
383     attrsArray.push_back(Attributes(attrs2.Serialize()));
384 
385     Attributes setAttrs;
386     EXPECT_TRUE(setAttrs.SetAttributesArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrsArray));
387 
388     std::vector<uint8_t> data = setAttrs.Serialize();
389     EXPECT_TRUE(data.size() > 0);
390 
391     Attributes getAttrs(data);
392     std::vector<Attributes> getAttrsArray;
393     EXPECT_TRUE(getAttrs.GetAttributesArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, getAttrsArray));
394 
395     ASSERT_EQ(getAttrsArray.size(), 2);
396     std::vector<uint8_t> serializedAttrs1 = attrs1.Serialize();
397     std::vector<uint8_t> serializedAttrs2 = attrs2.Serialize();
398 
399     std::vector<uint8_t> serializedOutAttrs1 = getAttrsArray[0].Serialize();
400     std::vector<uint8_t> serializedOutAttrs2 = getAttrsArray[1].Serialize();
401 
402     EXPECT_TRUE(serializedAttrs1 == serializedOutAttrs1);
403     EXPECT_TRUE(serializedAttrs2 == serializedOutAttrs2);
404 }
405 
406 HWTEST_F(AttributesTest, AttributesSetAndGetAttributesArray01, TestSize.Level0)
407 {
408     Attributes attrs1;
409     int64_t value1 = 1;
410     EXPECT_EQ(attrs1.SetInt64Value(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, value1), true);
411     EXPECT_EQ(attrs1.GetInt64Value(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, value1), true);
412     EXPECT_EQ(value1, 1);
413 
414     Attributes setAttrs;
415     EXPECT_EQ(setAttrs.SetAttributesValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrs1), true);
416     Attributes attrs2;
417     EXPECT_EQ(setAttrs.GetAttributesValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, attrs2), true);
418 
419     std::vector<int32_t> array1;
420     array1.push_back(1);
421     EXPECT_EQ(setAttrs.SetInt32ArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, array1), true);
422     std::vector<int32_t> array2;
423     EXPECT_EQ(setAttrs.GetInt32ArrayValue(Attributes::ATTR_EXECUTOR_REGISTER_INFO_LIST, array2), true);
424 }
425 } // namespace UserAuth
426 } // namespace UserIam
427 } // namespace OHOS
428