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 "dslm_baselib_utils_test.h"
17
18 #include <gtest/gtest.h>
19
20 #include "file_ex.h"
21 #include "nativetoken_kit.h"
22 #include "securec.h"
23 #include "token_setproc.h"
24
25 #include "utils_base64.h"
26 #include "utils_datetime.h"
27 #include "utils_hexstring.h"
28 #include "utils_json.h"
29 #include "utils_mem.h"
30 #include "utils_state_machine.h"
31 #include "utils_timer.h"
32 #include "utils_tlv.h"
33
34 #define MAX_ENTRY 8
35 #define MAX_MALLOC_LEN (1 * 1024 * 1024)
36
37 using namespace std;
38 using namespace std::chrono;
39 using namespace testing;
40 using namespace testing::ext;
41
42 // for testing
43 extern "C" {
44 extern void DoTimerProcess(TimerProc callback, const void *context);
45 }
46
47 namespace OHOS {
48 namespace Security {
49 namespace DslmUnitTest {
SetUpTestCase()50 void DslmBaselibUtilsTest::SetUpTestCase()
51 {
52 }
TearDownTestCase()53 void DslmBaselibUtilsTest::TearDownTestCase()
54 {
55 }
SetUp()56 void DslmBaselibUtilsTest::SetUp()
57 {
58 }
TearDown()59 void DslmBaselibUtilsTest::TearDown()
60 {
61 }
62
63 /**
64 * @tc.name: Deserialize_case1
65 * @tc.desc: function Deserialize with malformed input
66 * @tc.type: FUNC
67 * @tc.require: issueNumber
68 */
69 HWTEST_F(DslmBaselibUtilsTest, Deserialize_case1, TestSize.Level0)
70 {
71 uint32_t cnt = 0;
72 TlvCommon tlvs[MAX_ENTRY];
73 // every entry has a sizeof(void *)-byte value
74 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
75
76 {
77 cnt = 0;
78 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
79 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
80
81 uint32_t ret = Deserialize(nullptr, sizeof(buff), &tlvs[0], MAX_ENTRY, &cnt);
82 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
83 }
84
85 {
86 // buff contains 10 entries which greater than MAX_ENTRY
87 int i;
88 // every entry has a sizeof(void *)-byte value
89 uint8_t buff[(MAX_ENTRY + 2) * sizeof(TlvCommon)] = {0};
90
91 cnt = 0;
92 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
93
94 for (i = 0; i < (MAX_ENTRY + 2); i++) {
95 TlvCommon *ptr = (TlvCommon *)buff + i;
96 ptr->tag = 0x105;
97 ptr->len = 4;
98 }
99
100 uint32_t ret = Deserialize(buff, sizeof(buff), &tlvs[0], MAX_ENTRY, &cnt);
101 EXPECT_EQ((uint32_t)TLV_ERR_BUFF_NO_ENOUGH, ret);
102 EXPECT_EQ(0U, cnt);
103 }
104 }
105
106 /**
107 * @tc.name: Deserialize_case2
108 * @tc.desc: function Deserialize with malformed input
109 * @tc.type: FUNC
110 * @tc.require: issueNumber
111 */
112 HWTEST_F(DslmBaselibUtilsTest, Deserialize_case2, TestSize.Level0)
113 {
114 int i;
115 uint32_t cnt = 0;
116 TlvCommon tlvs[MAX_ENTRY];
117 // every entry has a sizeof(void *)-byte value
118 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
119
120 // malformed tlv entry's len
121 cnt = 0;
122 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
123 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
124
125 for (i = 0; i < MAX_ENTRY; i++) {
126 TlvCommon *ptr = (TlvCommon *)buff + i;
127 ptr->tag = 0x105;
128 ptr->len = 0x100;
129 }
130
131 uint32_t ret = Deserialize(buff, sizeof(buff), &tlvs[0], MAX_ENTRY, &cnt);
132 EXPECT_EQ(0U, ret);
133 EXPECT_EQ(0U, cnt);
134 }
135
136 /**
137 * @tc.name: Serialize_case1
138 * @tc.desc: function Serialize with malformed input
139 * @tc.type: FUNC
140 * @tc.require: issueNumber
141 */
142 HWTEST_F(DslmBaselibUtilsTest, Serialize_case1, TestSize.Level0)
143 {
144 uint32_t size = 0;
145 int i = 0;
146 TlvCommon tlvs[MAX_ENTRY];
147 // every entry has a sizeof(void *)-byte value
148 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
149
150 {
151 size = 0;
152 uint32_t ret = Serialize(nullptr, MAX_ENTRY, buff, sizeof(buff), &size);
153 EXPECT_EQ((uint32_t)TLV_ERR_INVALID_PARA, ret);
154 }
155
156 {
157 // malformed max buffer size
158
159 size = 0;
160 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
161 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
162
163 for (i = 0; i < MAX_ENTRY; i++) {
164 TlvCommon *ptr = (TlvCommon *)tlvs + i;
165 ptr->tag = 0x105;
166 ptr->len = 4;
167 }
168
169 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, 1, &size);
170 EXPECT_EQ((uint32_t)TLV_ERR_BUFF_NO_ENOUGH, ret);
171 EXPECT_EQ(0U, size);
172 }
173 }
174
175 /**
176 * @tc.name: Serialize_case1
177 * @tc.desc: function Serialize with malformed input
178 * @tc.type: FUNC
179 * @tc.require: issueNumber
180 */
181 HWTEST_F(DslmBaselibUtilsTest, Serialize_case2, TestSize.Level0)
182 {
183 uint32_t size = 0;
184 int i = 0;
185 TlvCommon tlvs[MAX_ENTRY];
186 // every entry has a sizeof(void *)-byte value
187 uint8_t buff[MAX_ENTRY * sizeof(TlvCommon)] = {0};
188 {
189 // malformed tvl.len
190 size = 0;
191 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
192 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
193
194 for (i = 0; i < MAX_ENTRY; i++) {
195 TlvCommon *ptr = (TlvCommon *)tlvs + i;
196 ptr->tag = 0x105;
197 ptr->len = 0;
198 }
199
200 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, sizeof(buff), &size);
201 EXPECT_EQ(0U, ret);
202 // (TLV_TLV_HEAD_LEN + ptr->len) * MAX_ENTRY
203 EXPECT_EQ(32U, size);
204 }
205
206 {
207 // malformed tvl.value
208 size = 0;
209 (void)memset_s(&buff[0], sizeof(buff), 0, sizeof(buff));
210 (void)memset_s(&tlvs[0], sizeof(tlvs), 0, sizeof(tlvs));
211
212 for (i = 0; i < MAX_ENTRY; i++) {
213 TlvCommon *ptr = (TlvCommon *)tlvs + i;
214 ptr->tag = 0x105;
215 ptr->len = 4;
216 ptr->value = nullptr;
217 }
218
219 uint32_t ret = Serialize(tlvs, MAX_ENTRY, buff, sizeof(buff), &size);
220 EXPECT_EQ(0U, ret);
221 // (TLV_TLV_HEAD_LEN + ptr->len) * MAX_ENTRY
222 EXPECT_EQ(64U, size);
223 }
224 }
225
226 /**
227 * @tc.name: GetDateTimeByMillisecondSince1970_case1
228 * @tc.desc: function GetDateTimeByMillisecondSince1970 with malformed input
229 * @tc.type: FUNC
230 * @tc.require: issueNumber
231 */
232 HWTEST_F(DslmBaselibUtilsTest, GetDateTimeByMillisecondSince1970_case1, TestSize.Level0)
233 {
234 uint64_t input = 0;
235
236 {
237 EXPECT_EQ(false, GetDateTimeByMillisecondSince1970(input, nullptr));
238 EXPECT_EQ(false, GetDateTimeByMillisecondSinceBoot(input, nullptr));
239 }
240
241 {
242 DoTimerProcess(nullptr, nullptr);
243 }
244 }
245
246 /**
247 * @tc.name: Base64UrlDecodeApp_case1
248 * @tc.desc: function Base64UrlDecodeApp with malformed input
249 * @tc.type: FUNC
250 * @tc.require: issueNumber
251 */
252 HWTEST_F(DslmBaselibUtilsTest, Base64UrlDecodeApp_case1, TestSize.Level0)
253 {
254 uint8_t src[] = {'a', '-', '_', 'd', '\0'};
255 uint8_t *to = nullptr;
256
257 {
258 int32_t ret = Base64UrlDecodeApp(nullptr, &to);
259 EXPECT_EQ(0, ret);
260 }
261
262 {
263 int32_t ret = Base64UrlDecodeApp(src, &to);
264 ASSERT_NE(to, nullptr);
265
266 EXPECT_EQ(3, ret);
267 EXPECT_EQ('\xEF', to[1]);
268 EXPECT_EQ('\xDD', to[2]);
269 FREE(to);
270 }
271 }
272
273 /**
274 * @tc.name: Base64DecodeApp_case1
275 * @tc.desc: function Base64DecodeApp with malformed input
276 * @tc.type: FUNC
277 * @tc.require: issueNumber
278 */
279 HWTEST_F(DslmBaselibUtilsTest, Base64DecodeApp_case1, TestSize.Level0)
280 {
281 uint8_t *to = nullptr;
282
283 {
284 int32_t ret = Base64DecodeApp(nullptr, &to);
285 EXPECT_EQ(0, ret);
286 }
287
288 {
289 uint32_t maxStrLen = MAX_MALLOC_LEN / 3 * 4 + 10;
290 uint8_t *maxStr = (uint8_t *)MALLOC(sizeof(uint8_t) * maxStrLen);
291 ASSERT_NE(nullptr, maxStr);
292
293 memset_s(maxStr, maxStrLen - 1, 'c', maxStrLen - 1);
294
295 int32_t ret = Base64DecodeApp(maxStr, &to);
296 EXPECT_EQ(0, ret);
297 FREE(maxStr);
298 }
299 }
300
301 /**
302 * @tc.name: Base64EncodeApp_case1
303 * @tc.desc: function Base64EncodeApp with malformed input
304 * @tc.type: FUNC
305 * @tc.require: issueNumber
306 */
307 HWTEST_F(DslmBaselibUtilsTest, Base64EncodeApp_case1, TestSize.Level0)
308 {
309 uint8_t src[] = {'a', 'b', 'c', 'd', '\0'};
310
311 EXPECT_EQ(nullptr, Base64EncodeApp(nullptr, sizeof(src)));
312 EXPECT_EQ(nullptr, Base64EncodeApp(src, 0));
313
314 {
315 uint32_t maxStrLen = MAX_MALLOC_LEN / 4 * 3;
316 EXPECT_EQ(nullptr, Base64EncodeApp(src, maxStrLen));
317 }
318 }
319
320 /**
321 * @tc.name: InitStateMachine_case1
322 * @tc.desc: function InitStateMachine with malformed input
323 * @tc.type: FUNC
324 * @tc.require: issueNumber
325 */
326 HWTEST_F(DslmBaselibUtilsTest, InitStateMachine_case1, TestSize.Level0)
327 {
328 {
329 StateMachine *machine = nullptr;
330 uint32_t machineId = 0;
331 uint32_t initState = 0;
332
333 InitStateMachine(machine, machineId, initState);
334 EXPECT_EQ(nullptr, machine);
335 }
336
337 {
338 StateNode *node = nullptr;
339 uint32_t nodeCnt = 0;
340 StateMachine machine;
341 uint32_t event = 0;
342
343 ScheduleMachine(node, nodeCnt, &machine, event, nullptr);
344 EXPECT_EQ(nullptr, node);
345 }
346 }
347
348 /**
349 * @tc.name: DestroyJson_case1
350 * @tc.desc: function DslmDestroyJson with malformed input
351 * @tc.type: FUNC
352 * @tc.require: issueNumber
353 */
354 HWTEST_F(DslmBaselibUtilsTest, DestroyJson_case1, TestSize.Level0)
355 {
356 int32_t arr[10] = {0};
357 const char *field = "test";
358 const char *value = "add";
359
360 const char *str = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2}";
361 DslmJsonHandle handle = DslmCreateJson(str);
362
363 DslmDestroyJson(nullptr);
364 DslmAddFieldBoolToJson(nullptr, field, true);
365 DslmAddFieldIntToJson(nullptr, field, 0);
366 DslmAddFieldIntArrayToJson(nullptr, field, arr, sizeof(arr));
367 DslmAddFieldStringToJson(nullptr, field, value);
368 DslmAddFieldJsonToJson(handle, field, nullptr);
369
370 {
371 int32_t ret = DslmGetJsonFieldInt(nullptr, str);
372 EXPECT_EQ(-1, ret);
373
374 ret = DslmGetJsonFieldInt(handle, nullptr);
375 EXPECT_EQ(0, ret);
376 }
377
378 {
379 uint32_t ret = DslmGetJsonFieldIntArray(nullptr, str, arr, sizeof(arr));
380 EXPECT_EQ(0U, ret);
381 }
382
383 {
384 const char *ret = DslmGetJsonFieldString(nullptr, str);
385 EXPECT_EQ(nullptr, ret);
386 }
387
388 {
389 const char *ret = DslmGetJsonFieldString(handle, nullptr);
390 EXPECT_EQ(nullptr, ret);
391 }
392
393 EXPECT_EQ(false, DslmCompareJsonData(handle, nullptr, true));
394
395 FREE(handle);
396 }
397
398 /**
399 * @tc.name: GetJsonFieldInt_case1
400 * @tc.desc: function DslmGetJsonFieldInt with malformed input
401 * @tc.type: FUNC
402 * @tc.require: issueNumber
403 */
404 HWTEST_F(DslmBaselibUtilsTest, GetJsonFieldInt_case1, TestSize.Level0)
405 {
406 const char *str = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2}";
407 DslmJsonHandle handle = DslmCreateJson(str);
408
409 int32_t ret = DslmGetJsonFieldInt(handle, "challenge");
410 EXPECT_EQ(-1, ret);
411 FREE(handle);
412 }
413
414 /**
415 * @tc.name: GetJsonFieldIntArray_case1
416 * @tc.desc: function DslmGetJsonFieldIntArray with malformed input
417 * @tc.type: FUNC
418 * @tc.require: issueNumber
419 */
420 HWTEST_F(DslmBaselibUtilsTest, GetJsonFieldIntArray_case1, TestSize.Level0)
421 {
422 int32_t arr[5] = {0};
423 int32_t arrLen = sizeof(arr) / sizeof(arr[0]);
424 const char *str = "{\"version\":131072,\"challenge\":\"test challenge\",\"arr\":[\"3C1F21EE53D3C4E2\", \"elem2\", "
425 "3, 4, 5],\"type\":2}";
426 DslmJsonHandle handle = DslmCreateJson(str);
427
428 {
429 uint32_t ret = DslmGetJsonFieldIntArray(handle, "challenge", arr, arrLen);
430 EXPECT_EQ(0U, ret);
431 }
432
433 {
434 uint32_t ret = DslmGetJsonFieldIntArray(handle, "arr", arr, arrLen - 2);
435 EXPECT_EQ(1U, ret);
436 }
437
438 FREE(handle);
439 }
440
441 /**
442 * @tc.name: ByteToHexString_case1
443 * @tc.desc: function DslmByteToHexString with malformed input
444 * @tc.type: FUNC
445 * @tc.require: issueNumber
446 */
447 HWTEST_F(DslmBaselibUtilsTest, ByteToHexString_case1, TestSize.Level0)
448 {
449 const uint8_t hex[] = {0x1, 0xF, 0xE, 0x8, 0xA};
450 uint32_t hexLen = sizeof(hex);
451 uint8_t str[10] = {0};
452 uint32_t strLen = 10;
453
454 DslmByteToHexString(nullptr, 0, str, strLen);
455 EXPECT_EQ(0U, str[0]);
456
457 DslmByteToHexString(hex, hexLen, nullptr, 0);
458 EXPECT_EQ(0U, str[0]);
459
460 DslmByteToHexString(hex, hexLen, str, strLen - 1);
461 EXPECT_EQ(0U, str[0]);
462 }
463
464 /**
465 * @tc.name: HexStringToByte_case1
466 * @tc.desc: function DslmHexStringToByte with malformed input
467 * @tc.type: FUNC
468 * @tc.require: issueNumber
469 */
470 HWTEST_F(DslmBaselibUtilsTest, HexStringToByte_case1, TestSize.Level0)
471 {
472 uint32_t hexLen = 5;
473 uint32_t strLen = 10;
474 uint8_t hex[5] = {0};
475 char str[10] = {0};
476
477 {
478 int32_t ret = DslmHexStringToByte(nullptr, 0, hex, hexLen);
479 EXPECT_EQ(-1, ret);
480 EXPECT_EQ(0U, str[0]);
481 }
482
483 {
484 int32_t ret = DslmHexStringToByte(str, strLen, nullptr, 0);
485 EXPECT_EQ(-1, ret);
486 EXPECT_EQ(0U, str[0]);
487 }
488
489 {
490 int32_t ret = DslmHexStringToByte(str, strLen, hex, hexLen - 2);
491 EXPECT_EQ(-1, ret);
492 EXPECT_EQ(0U, str[0]);
493 }
494 }
495 } // namespace DslmUnitTest
496 } // namespace Security
497 } // namespace OHOS