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_test.h"
17
18 #include <chrono>
19 #include <condition_variable>
20 #include <gtest/gtest.h>
21 #include <iostream>
22 #include <mutex>
23 #include <thread>
24
25 #include "file_ex.h"
26 #include "nativetoken_kit.h"
27 #include "securec.h"
28 #include "token_setproc.h"
29
30 #include "device_security_defines.h"
31 #include "device_security_info.h"
32 #include "device_security_level_defines.h"
33 #include "dslm_core_defines.h"
34 #include "dslm_core_process.h"
35 #include "dslm_credential.h"
36 #include "dslm_crypto.h"
37 #include "dslm_device_list.h"
38 #include "dslm_fsm_process.h"
39 #include "dslm_hievent.h"
40 #include "dslm_inner_process.h"
41 #include "dslm_messenger_wrapper.h"
42 #include "dslm_msg_interface_mock.h"
43 #include "dslm_msg_serialize.h"
44 #include "dslm_msg_utils.h"
45 #include "dslm_ohos_request.h"
46 #include "dslm_ohos_verify.h"
47 #include "dslm_request_callback_mock.h"
48 #include "utils_datetime.h"
49 #include "utils_mem.h"
50
51 using namespace std;
52 using namespace std::chrono;
53 using namespace testing;
54 using namespace testing::ext;
55
56 // for testing
57 extern "C" {
58 extern bool CheckMessage(const uint8_t *msg, uint32_t length);
59 extern void DoTimerProcess(TimerProc callback, const void *context);
60 }
61
62 namespace OHOS {
63 namespace Security {
64 namespace DslmUnitTest {
SetUpTestCase()65 void DslmTest::SetUpTestCase()
66 {
67 // modify the device's systime to ensure that the certificate verification passes
68 constexpr time_t yearTimeLeast = 1640966400;
69 constexpr time_t yearTimeValid = 1648518888;
70 struct timeval timeVal = {0};
71 gettimeofday(&timeVal, nullptr);
72 if (timeVal.tv_sec <= yearTimeLeast) {
73 timeVal.tv_sec = yearTimeValid;
74 settimeofday(&timeVal, nullptr);
75 }
76
77 static const char *acls[] = {"ACCESS_IDS"};
78 static const char *perms[] = {
79 "ohos.permission.PLACE_CALL",
80 "ohos.permission.ACCESS_IDS",
81 };
82 uint64_t tokenId;
83 NativeTokenInfoParams infoInstance = {
84 .dcapsNum = 0,
85 .permsNum = 2,
86 .aclsNum = 1,
87 .dcaps = nullptr,
88 .perms = perms,
89 .acls = acls,
90 .processName = "dslm_service",
91 .aplStr = "system_core",
92 };
93 tokenId = GetAccessTokenId(&infoInstance);
94 SetSelfTokenID(tokenId);
95 SaveStringToFile("/sys/fs/selinux/enforce", "0");
96 }
TearDownTestCase()97 void DslmTest::TearDownTestCase()
98 {
99 SaveStringToFile("/sys/fs/selinux/enforce", "1");
100 }
SetUp()101 void DslmTest::SetUp()
102 {
103 }
TearDown()104 void DslmTest::TearDown()
105 {
106 }
107
BlockCheckDeviceStatus(const DeviceIdentify * device,uint32_t status,uint64_t millisec)108 static void BlockCheckDeviceStatus(const DeviceIdentify *device, uint32_t status, uint64_t millisec)
109 {
110 static int sleepTick = 10;
111 uint64_t cnt = millisec / static_cast<uint64_t>(sleepTick) + 1;
112 do {
113 const DslmDeviceInfo *info = GetDslmDeviceInfo(device);
114 if (info == nullptr) {
115 continue;
116 }
117 if (info->machine.currState == status) {
118 break;
119 }
120 if (cnt == 0) {
121 break;
122 }
123 this_thread::sleep_for(milliseconds(sleepTick));
124 cnt--;
125 } while (true);
126 }
127
128 HWTEST_F(DslmTest, BuildDeviceSecInfoRequest_case1, TestSize.Level0)
129 {
130 uint64_t random = 0x0807060504030201;
131 MessageBuff *msg = nullptr;
132 // 0d196608 = 0x030000
133 const char *except =
134 "{\"message\":1,\"payload\":{\"version\":196608,\"challenge\":\"0102030405060708\",\"support\":[3000,2000]}}";
135 int32_t ret = BuildDeviceSecInfoRequest(random, &msg);
136 ASSERT_EQ(0, ret);
137 EXPECT_STREQ(except, (const char *)msg->buff);
138 FreeMessageBuff(msg);
139 }
140
141 HWTEST_F(DslmTest, BuildDeviceSecInfoRequest_case2, TestSize.Level0)
142 {
143 uint64_t random = 0x0807060504030201;
144 MessageBuff **msg = nullptr;
145 int32_t ret = BuildDeviceSecInfoRequest(random, msg);
146 ASSERT_EQ(ERR_INVALID_PARA, ret);
147 }
148
149 HWTEST_F(DslmTest, BuildDeviceSecInfoRequest_case3, TestSize.Level0)
150 {
151 uint64_t random = 0x0807060504030201;
152 const char *message = "{\"mege\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
153 uint32_t messageLen = strlen(message) + 1;
154 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
155 MessageBuff *msg_ptr = &msg;
156
157 int32_t ret = BuildDeviceSecInfoRequest(random, &msg_ptr);
158 ASSERT_EQ(ERR_INVALID_PARA, ret);
159 }
160
161 HWTEST_F(DslmTest, BuildDeviceSecInfoResponse_case1, TestSize.Level0)
162 {
163 uint64_t random = 0x0807060504030201;
164 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
165 DslmCredBuff cred = {(CredType)3, 9, info};
166
167 // 0d196608 = 0x030000
168 const char *except = "{\"message\":2,\"payload\":{\"version\":196608,\"type\":3,\"challenge\":\"0102030405060708\","
169 "\"info\":\"YWJjZAEDBQcJ\"}}";
170
171 MessageBuff *msg = nullptr;
172 int32_t ret = BuildDeviceSecInfoResponse(random, (DslmCredBuff *)&cred, &msg);
173 ASSERT_EQ(0, ret);
174
175 EXPECT_STREQ(except, (const char *)msg->buff);
176 FreeMessageBuff(msg);
177 }
178
179 HWTEST_F(DslmTest, BuildDeviceSecInfoResponse_case2, TestSize.Level0)
180 {
181 uint64_t random = 0x0807060504030201;
182 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
183 DslmCredBuff cred = {(CredType)3, 9, info};
184
185 {
186 MessageBuff **msg = nullptr;
187
188 int32_t ret = BuildDeviceSecInfoResponse(random, (DslmCredBuff *)&cred, msg);
189 ASSERT_EQ(ERR_INVALID_PARA, ret);
190 }
191
192 {
193 MessageBuff msg;
194 memset_s(&msg, sizeof(MessageBuff), 0, sizeof(MessageBuff));
195 MessageBuff *msgPtr = &msg;
196
197 int32_t ret = BuildDeviceSecInfoResponse(random, (DslmCredBuff *)&cred, &msgPtr);
198 ASSERT_EQ(ERR_INVALID_PARA, ret);
199 }
200 }
201
202 HWTEST_F(DslmTest, ParseMessage_case1, TestSize.Level0)
203 {
204 const char *message = "{\"message\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
205 const char *except = "{\"version\":131072,\"challenge\":\"0102030405060708\"}";
206
207 uint32_t messageLen = strlen(message) + 1;
208 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
209
210 MessagePacket *packet = ParseMessage(&msg);
211 ASSERT_NE(nullptr, packet);
212
213 EXPECT_EQ(1U, packet->type);
214 EXPECT_STREQ(except, (const char *)packet->payload);
215
216 FreeMessagePacket(packet);
217 }
218
219 HWTEST_F(DslmTest, ParseMessage_case2, TestSize.Level0)
220 {
221 const char *message = "{\"mege\":1,\"payload\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
222
223 uint32_t messageLen = strlen(message) + 1;
224 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
225
226 MessagePacket *packet = ParseMessage(&msg);
227 EXPECT_EQ(nullptr, packet);
228 FreeMessagePacket(packet);
229 }
230
231 HWTEST_F(DslmTest, ParseMessage_case3, TestSize.Level0)
232 {
233 const char *message = "{\"message\":1,\"pay\":{\"version\":131072,\"challenge\":\"0102030405060708\"}}";
234
235 uint32_t messageLen = strlen(message) + 1;
236 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
237
238 MessagePacket *packet = ParseMessage(&msg);
239 EXPECT_EQ(nullptr, packet);
240 FreeMessagePacket(packet);
241 }
242
243 HWTEST_F(DslmTest, ParseMessage_case4, TestSize.Level0)
244 {
245 const MessageBuff *buff = nullptr;
246 EXPECT_EQ(nullptr, ParseMessage(buff));
247 }
248
249 HWTEST_F(DslmTest, ParseMessage_case5, TestSize.Level0)
250 {
251 uint8_t *message = nullptr;
252 uint32_t messageLen = 0;
253 MessageBuff msg = {.length = messageLen, .buff = message};
254
255 EXPECT_EQ(nullptr, ParseMessage(&msg));
256 }
257
258 HWTEST_F(DslmTest, ParseMessage_case6, TestSize.Level0)
259 {
260 uint8_t message[] = {'1', '2'};
261 uint32_t messageLen = 2;
262 MessageBuff msg = {.length = messageLen, .buff = message};
263 EXPECT_EQ(nullptr, ParseMessage(&msg));
264 }
265
266 HWTEST_F(DslmTest, ParseMessage_case7, TestSize.Level0)
267 {
268 uint8_t message[] = {1, 2, 0};
269 uint32_t messageLen = 3;
270 MessageBuff msg = {.length = messageLen, .buff = message};
271 EXPECT_EQ(nullptr, ParseMessage(&msg));
272 }
273
274 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case1, TestSize.Level0)
275 {
276 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\"}";
277
278 uint32_t messageLen = strlen(message) + 1;
279 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
280
281 RequestObject obj;
282 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
283
284 // 3351057 = 0x332211
285 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
286 EXPECT_EQ(0, ret);
287
288 EXPECT_EQ(0x332211U, obj.version);
289 EXPECT_EQ(0x0d0c0b0a04030201UL, obj.challenge);
290 EXPECT_EQ(0U, obj.arraySize);
291 }
292
293 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case2, TestSize.Level0)
294 {
295 const char *message = "{\"version\":3351057,\"challenge\":\"z\"}";
296
297 uint32_t messageLen = strlen(message) + 1;
298 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
299
300 RequestObject obj;
301 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
302
303 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
304 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
305 }
306
307 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case3, TestSize.Level0)
308 {
309 const char *message = "{\"version\":3351057,\"challenge\":1}";
310
311 uint32_t messageLen = strlen(message) + 1;
312 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
313
314 RequestObject obj;
315 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
316 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
317 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
318 }
319
320 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case4, TestSize.Level0)
321 {
322 const char *message = "{\"version\":3351057,\"challssenge\":\"z\"}";
323
324 uint32_t messageLen = strlen(message) + 1;
325 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
326
327 RequestObject obj;
328 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
329 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
330 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
331 }
332
333 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case5, TestSize.Level0)
334 {
335 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\",\"support\":[33,44,55]}";
336
337 uint32_t messageLen = strlen(message) + 1;
338 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
339
340 RequestObject obj;
341 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
342
343 // 3351057 = 0x332211
344 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
345 EXPECT_EQ(static_cast<int32_t>(0), ret);
346 EXPECT_EQ(0x332211U, obj.version);
347 EXPECT_EQ(0x0d0c0b0a04030201U, obj.challenge);
348 // add support
349 EXPECT_EQ(3U, obj.arraySize);
350 EXPECT_EQ(33U, obj.credArray[0]);
351 EXPECT_EQ(44U, obj.credArray[1]);
352 EXPECT_EQ(55U, obj.credArray[2]);
353 }
354
355 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case6, TestSize.Level0)
356 {
357 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\",\"support\":[]}";
358
359 uint32_t messageLen = strlen(message) + 1;
360 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
361
362 RequestObject obj;
363 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
364
365 // 3351057 = 0x332211
366 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
367 EXPECT_EQ(0, ret);
368 EXPECT_EQ(0x332211U, obj.version);
369 EXPECT_EQ(0x0d0c0b0a04030201U, obj.challenge);
370 // add support
371 EXPECT_EQ(0U, obj.arraySize);
372 }
373
374 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case7, TestSize.Level0)
375 {
376 const char *message = "{\"version\":3351057,\"challenge\":\"010203040a0b0c0d\",\"support\":[]}";
377 uint32_t messageLen = strlen(message) + 1;
378 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
379
380 RequestObject obj;
381 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
382
383 {
384 int32_t ret = ParseDeviceSecInfoRequest(nullptr, &obj);
385 EXPECT_EQ(ERR_INVALID_PARA, ret);
386 }
387
388 {
389 int32_t ret = ParseDeviceSecInfoRequest(&msg, nullptr);
390 EXPECT_EQ(ERR_INVALID_PARA, ret);
391 }
392
393 {
394 int32_t ret = ParseDeviceSecInfoRequest(nullptr, &obj);
395 EXPECT_EQ(ERR_INVALID_PARA, ret);
396 }
397
398 {
399 msg.buff = nullptr;
400 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
401 EXPECT_EQ(ERR_INVALID_PARA, ret);
402 }
403 }
404
405 HWTEST_F(DslmTest, ParseDeviceSecInfoRequest_case8, TestSize.Level0)
406 {
407 const char *message = "{\"version\":3351057,\"challenge}";
408
409 uint32_t messageLen = strlen(message) + 1;
410 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
411
412 RequestObject obj;
413 (void)memset_s(&obj, sizeof(RequestObject), 0, sizeof(RequestObject));
414
415 // 3351057 = 0x332211
416 int32_t ret = ParseDeviceSecInfoRequest(&msg, &obj);
417 EXPECT_EQ(ERR_INVALID_PARA, ret);
418 }
419
420 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case1, TestSize.Level0)
421 {
422 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
423 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
424
425 uint32_t messageLen = strlen(message) + 1;
426 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
427
428 uint64_t challenge;
429 uint32_t version;
430 DslmCredBuff *cred = nullptr;
431
432 // 131072 = 0x020000
433 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
434 EXPECT_EQ(0, ret);
435 EXPECT_EQ(0x020000U, version);
436
437 EXPECT_EQ(0xE2C4D353EE211F3CUL, challenge);
438
439 const char *except = "JADE-AL00:87AD28D3B1B...";
440 EXPECT_NE(nullptr, cred);
441 EXPECT_EQ(2U, cred->type);
442 EXPECT_EQ(strlen(except), cred->credLen);
443 EXPECT_EQ(0, strncmp(except, (const char *)cred->credVal, cred->credLen));
444 DestroyDslmCred(cred);
445 }
446
447 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case2, TestSize.Level0)
448 {
449 const char *message = "{\"version\":3351057,\"challssenge\":\"z\"}";
450
451 uint32_t messageLen = strlen(message) + 1;
452 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
453
454 uint64_t challenge;
455 uint32_t ver;
456 DslmCredBuff *cred = nullptr;
457
458 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, &cred);
459 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
460 }
461
462 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case3, TestSize.Level0)
463 {
464 const char *message =
465 "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"infod\":\"JADE-AL00:87AD28D3B1B...\"}";
466
467 uint32_t messageLen = strlen(message) + 1;
468 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
469
470 uint64_t challenge;
471 uint32_t ver;
472 DslmCredBuff *cred = nullptr;
473
474 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, &cred);
475 EXPECT_EQ(ERR_NO_CRED, ret);
476 }
477
478 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case4, TestSize.Level0)
479 {
480 const char *message =
481 "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"infod\":\"JADE-AL00:87AD28D3B1B...\"}";
482
483 uint32_t messageLen = strlen(message) + 1;
484 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
485
486 uint64_t challenge;
487 uint32_t ver;
488 DslmCredBuff **cred = nullptr;
489
490 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, cred);
491 EXPECT_EQ(ERR_INVALID_PARA, ret);
492 }
493
494 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case5, TestSize.Level0)
495 {
496 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
497 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
498
499 uint32_t messageLen = strlen(message) + 1;
500 // msg has null buff
501 MessageBuff msg = {.length = messageLen, .buff = nullptr};
502
503 uint64_t challenge;
504 uint32_t version;
505 DslmCredBuff *cred = nullptr;
506
507 // 131072 = 0x020000
508 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
509 EXPECT_EQ(ERR_INVALID_PARA, ret);
510 }
511
512 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case6, TestSize.Level0)
513 {
514 int32_t ret;
515 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
516 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
517 uint32_t messageLen = strlen(message) + 1;
518 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
519
520 uint64_t challenge;
521 uint32_t ver;
522 DslmCredBuff cred;
523 memset_s(&cred, sizeof(DslmCredBuff), 0, sizeof(DslmCredBuff));
524 DslmCredBuff *credPtr = &cred;
525
526 {
527 // malformed inputs
528 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, nullptr);
529 EXPECT_EQ(ERR_INVALID_PARA, ret);
530 }
531
532 {
533 // malformed inputs, credPtr != nullptr
534 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &ver, &credPtr);
535 EXPECT_EQ(ERR_INVALID_PARA, ret);
536 }
537 }
538
539 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case7, TestSize.Level0)
540 {
541 int32_t ret;
542 uint64_t challenge;
543 uint32_t version;
544 DslmCredBuff *cred = nullptr;
545
546 {
547 // malformed challenge
548 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2A\",\"type\":2,\"info\":"
549 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
550 uint32_t messageLen = strlen(message) + 1;
551 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
552
553 // 131072 = 0x020000
554 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
555 EXPECT_EQ(ERR_NO_CHALLENGE, ret);
556 }
557
558 {
559 // malformed json
560 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"infod}";
561 uint32_t messageLen = strlen(message) + 1;
562 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
563
564 ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
565 EXPECT_EQ(ERR_INVALID_PARA, ret);
566 }
567 }
568
569 HWTEST_F(DslmTest, ParseDeviceSecInfoResponse_case8, TestSize.Level0)
570 {
571 // malformed info field
572 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
573 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4ux\"}";
574
575 uint32_t messageLen = strlen(message) + 1;
576 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
577
578 uint64_t challenge;
579 uint32_t version;
580 DslmCredBuff *cred = nullptr;
581
582 // 131072 = 0x020000
583 int32_t ret = ParseDeviceSecInfoResponse(&msg, &challenge, &version, &cred);
584 EXPECT_EQ(ERR_NO_CRED, ret);
585 }
586
587 HWTEST_F(DslmTest, RandomValue_case1, TestSize.Level0)
588 {
589 RandomValue rand1 = {0, {0}};
590 (void)memset_s(&rand1, sizeof(RandomValue), 0, sizeof(RandomValue));
591 GenerateRandom(&rand1, sizeof(uint64_t));
592
593 RandomValue rand2 = {0, {0}};
594 (void)memset_s(&rand2, sizeof(RandomValue), 0, sizeof(RandomValue));
595 GenerateRandom(&rand2, sizeof(uint64_t));
596
597 EXPECT_EQ(sizeof(uint64_t), rand1.length);
598 EXPECT_EQ(sizeof(uint64_t), rand2.length);
599
600 EXPECT_GT(rand1.value[0] + rand1.value[1] + rand1.value[2] + rand1.value[3], 0);
601 EXPECT_EQ(rand1.value[31] + rand1.value[30] + rand1.value[29] + rand1.value[28], 0);
602 EXPECT_NE(0, memcmp(rand1.value, rand2.value, sizeof(uint64_t)));
603 }
604
605 HWTEST_F(DslmTest, RandomValue_case2, TestSize.Level0)
606 {
607 RandomValue rand = {0, {0}};
608 (void)memset_s(&rand, sizeof(RandomValue), 0, sizeof(RandomValue));
609
610 GenerateRandom(&rand, 1024);
611 EXPECT_EQ(static_cast<uint32_t>(RANDOM_MAX_LEN), rand.length);
612
613 GenerateRandom(nullptr, 1024);
614 }
615
616 HWTEST_F(DslmTest, GetMillisecondSinceBoot_case1, TestSize.Level0)
617 {
618 uint64_t tick = 100;
619 uint64_t start = GetMillisecondSinceBoot();
620 EXPECT_GT(start, 0U);
621 this_thread::sleep_for(milliseconds(tick));
622 uint64_t end = GetMillisecondSinceBoot();
623 EXPECT_GT(end, 0U);
624
625 EXPECT_GT(end - start, tick - 10);
626 EXPECT_LT(end - start, tick + 10);
627 }
628
629 HWTEST_F(DslmTest, GetMillisecondSince1970_case1, TestSize.Level0)
630 {
631 uint64_t tick = 100;
632 uint64_t start = GetMillisecondSince1970();
633 EXPECT_GT(start, 0U);
634 this_thread::sleep_for(milliseconds(tick));
635 uint64_t end = GetMillisecondSince1970();
636 EXPECT_GT(end, 0U);
637
638 EXPECT_GT(end - start, tick - 10);
639 EXPECT_LT(end - start, tick + 10);
640 }
641
642 HWTEST_F(DslmTest, GetDateTime_case1, TestSize.Level0)
643 {
644 {
645 DateTime date;
646 EXPECT_TRUE(GetDateTimeByMillisecondSince1970(GetMillisecondSince1970(), &date));
647 }
648 {
649 DateTime date;
650 EXPECT_TRUE(GetDateTimeByMillisecondSinceBoot(GetMillisecondSinceBoot(), &date));
651 }
652 }
653
654 HWTEST_F(DslmTest, InitDslmCredentialFunctions_case1, TestSize.Level0)
655 {
656 bool ret = InitDslmCredentialFunctions(NULL);
657 EXPECT_EQ(false, ret);
658 }
659
660 HWTEST_F(DslmTest, OhosDslmCred_case1, TestSize.Level0)
661 {
662 const DeviceIdentify identify = {DEVICE_ID_MAX_LEN, {0}};
663 RequestObject object;
664
665 object.arraySize = 1;
666 object.credArray[0] = CRED_TYPE_STANDARD;
667 object.challenge = 0x1234567812345678;
668 object.version = 0x112234;
669
670 DslmCredBuff *cred = nullptr;
671
672 int32_t ret = DefaultRequestDslmCred(&identify, &object, &cred);
673 ASSERT_EQ(SUCCESS, static_cast<int32_t>(ret));
674
675 DslmCredInfo info;
676 (void)memset_s(&info, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
677
678 ret = DefaultVerifyDslmCred(&identify, object.challenge, cred, &info);
679 EXPECT_EQ(SUCCESS, ret);
680 EXPECT_GE(info.credLevel, 1U);
681
682 DestroyDslmCred(cred);
683 }
684
685 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case1, TestSize.Level0)
686 {
687 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
688
689 const RequestOption option = {
690 .challenge = 0xffffffffffffffff,
691 .timeout = 2,
692 };
693
694 {
695 uint32_t cookie = 1234;
696 DslmRequestCallbackMock mockCallback;
697 EXPECT_CALL(mockCallback, RequestCallback(_, _, _)).Times(Exactly(0));
698 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
699 EXPECT_EQ(static_cast<int32_t>(ret), ERR_MSG_NOT_INIT);
700 }
701
702 {
703 uint32_t cookie = 5678;
704 DslmMsgInterfaceMock mockMsg;
705 DslmRequestCallbackMock mockCallback;
706 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
707 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
708 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(false));
709 EXPECT_CALL(mockCallback, RequestCallback(_, _, _)).Times(Exactly(0));
710 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
711 EXPECT_EQ(static_cast<int32_t>(ret), ERR_NOEXIST_DEVICE);
712
713 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(AtLeast(2));
714 mockMsg.MakeMsgLoopback();
715 mockMsg.MakeDeviceOnline(&device);
716 BlockCheckDeviceStatus(&device, STATE_SUCCESS, 10000);
717 mockMsg.MakeDeviceOffline(&device);
718 }
719 }
720
721 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case2, TestSize.Level0)
722 {
723 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
724
725 const RequestOption option = {
726 .challenge = 0xffffffffffffffff,
727 .timeout = 2,
728 };
729
730 {
731 uint32_t cookie = 0xabcd;
732 DslmMsgInterfaceMock mockMsg;
733 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
734 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
735 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
736 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(0));
737 DslmRequestCallbackMock mockCallback;
__anon2fe9fe530102(const DslmCallbackInfo *info) 738 auto isRightLevel = [](const DslmCallbackInfo *info) { return info->level >= 1; };
739 EXPECT_CALL(mockCallback, RequestCallback(cookie, 0, Truly(isRightLevel))).Times(Exactly(1));
740
741 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
742 EXPECT_EQ(ret, 0);
743 mockMsg.MakeDeviceOffline(&device);
744 }
745
746 {
747 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0, 'b', 'c', 'd', 'e', 'f', 'g'}};
748 uint32_t cookie = 0xabcd;
749 DslmMsgInterfaceMock mockMsg;
750 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
751 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
752 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(0));
753 DslmRequestCallbackMock mockCallback;
__anon2fe9fe530202(const DslmCallbackInfo *info) 754 auto isRightLevel = [](const DslmCallbackInfo *info) { return info->level >= 1; };
755 EXPECT_CALL(mockCallback, RequestCallback(cookie, 0, Truly(isRightLevel))).Times(Exactly(1));
756
757 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
758 EXPECT_EQ(ret, 0);
759 mockMsg.MakeDeviceOffline(&device);
760 }
761 }
762
763 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case3, TestSize.Level0)
764 {
765 constexpr uint32_t maxNotifySize = 64;
766
767 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a'}};
768 const RequestOption option = {
769 .challenge = 0xffabcdffffffffee,
770 .timeout = 2,
771 .extra = 0,
772 };
773
774 DslmMsgInterfaceMock mockMsg;
775 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
776 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
777 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
__anon2fe9fe530302(const uint8_t *message) 778 auto isSendRequestOut = [](const uint8_t *message) {
779 const char *prefix = "{\"message\":1,\"payload\":{\"version\":196608,\"challenge\":\"";
780 const string msg = string(static_cast<const char *>(static_cast<const void *>(message)));
781 EXPECT_EQ(msg.rfind(prefix, 0), 0U);
782 return true;
783 };
784
785 uint32_t cookie = 0x4567;
786 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, Truly(isSendRequestOut), _)).Times(Exactly(1)).WillRepeatedly(Return(true));
787
788 DslmDeviceInfo *info = CreatOrGetDslmDeviceInfo(&device);
789 ASSERT_NE(info, nullptr);
790
791 EXPECT_EQ(info->notifyListSize, 0U);
792
793 DslmRequestCallbackMock callback;
794 EXPECT_CALL(callback, RequestCallback(cookie, Ne(0U), Ne(nullptr))).Times(Exactly(maxNotifySize));
795 for (uint32_t i = 1; i <= maxNotifySize; i++) {
796 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
797 EXPECT_EQ(static_cast<uint32_t>(ret), 0U);
798 EXPECT_EQ(info->notifyListSize, i);
799 EXPECT_EQ(info->historyListSize, 0U);
800 }
801 for (uint32_t i = 1; i <= maxNotifySize; i++) {
802 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, DslmRequestCallbackMock::MockedCallback);
803 EXPECT_EQ(static_cast<uint32_t>(ret), ERR_SA_BUSY);
804 EXPECT_EQ(info->notifyListSize, maxNotifySize);
805 EXPECT_EQ(info->historyListSize, 0U);
806 }
807 mockMsg.MakeDeviceOffline(&device);
808
809 EXPECT_EQ(info->notifyListSize, 0U);
810 EXPECT_EQ(info->historyListSize, 30U); // 30 is the max history list size
811 }
812
813 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case4, TestSize.Level0)
814 {
815 DslmMsgInterfaceMock mockMsg;
816 DslmRequestCallbackMock mockCallback;
817
818 EXPECT_CALL(mockMsg, IsMessengerReady(_)).Times(AtLeast(1));
819 EXPECT_CALL(mockMsg, GetDeviceOnlineStatus(_, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
820 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(AtLeast(1)).WillRepeatedly(Return(true));
821 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
822
823 mutex mtx;
824 condition_variable cv;
825 int32_t cnt = 0;
826 const time_point<system_clock> start = system_clock::now();
827 const int32_t reqTimes = 3;
828
829 uint32_t cookies[] = {0, 0x1234, 0x5678, 0xabcd};
830 uint32_t timeouts[] = {0, 1, 3, 5};
831
__anon2fe9fe530402(uint32_t cookie) 832 auto checkCookie = [&mtx, &cv, &cnt, &start, &cookies, &timeouts](uint32_t cookie) {
833 unique_lock<mutex> lck(mtx);
834 cnt++;
835 cv.notify_one();
836 time_point<system_clock> curr = system_clock::now();
837 auto cost = duration_cast<seconds>(curr - start).count();
838 EXPECT_EQ(cookie, cookies[cnt]);
839 EXPECT_EQ(cost, timeouts[cnt]);
840 return true;
841 };
842
843 EXPECT_CALL(mockCallback, RequestCallback(Truly(checkCookie), ERR_TIMEOUT, _)).Times(Exactly(3));
844
845 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
846 RequestOption option;
847 for (int i = 1; i <= reqTimes; i++) {
848 option.timeout = timeouts[i];
849 int32_t ret =
850 OnRequestDeviceSecLevelInfo(&device, &option, i, cookies[i], DslmRequestCallbackMock::MockedCallback);
851 EXPECT_EQ(static_cast<uint32_t>(ret), 0U);
852 }
853
854 unique_lock<mutex> lck(mtx);
__anon2fe9fe530502() 855 cv.wait(lck, [&cnt]() { return (cnt == reqTimes); });
856 mockMsg.MakeDeviceOffline(&device);
857 }
858
859 HWTEST_F(DslmTest, OnRequestDeviceSecLevelInfo_case5, TestSize.Level0)
860 {
861 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
862 const RequestOption option = {
863 .challenge = 0xffabcdffffffffee,
864 .timeout = 2,
865 .extra = 0,
866 };
867 uint32_t cookie = 1234;
868
869 int32_t ret = OnRequestDeviceSecLevelInfo(&device, &option, 0, cookie, nullptr);
870 EXPECT_EQ(ERR_INVALID_PARA, ret);
871 }
872
873 HWTEST_F(DslmTest, OnPeerMsgRequestInfoReceived_case1, TestSize.Level0)
874 {
875 const char *input = "{\"version\":65536,\"challenge\":\"0102030405060708\"}";
876 uint32_t len = strlen(input) + 1;
877
878 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'}};
879
880 DslmMsgInterfaceMock mockMsg;
881
__anon2fe9fe530602(const uint8_t *message) 882 auto isSendResponseOut = [](const uint8_t *message) {
883 const string msg = string(static_cast<const char *>(static_cast<const void *>(message)));
884 EXPECT_EQ(msg.find("{\"message\":2,\"payload\":{"), 0U);
885 EXPECT_GT(msg.find("\"version\":"), 0U);
886 EXPECT_GT(msg.find("\"challenge\":"), 0U);
887 EXPECT_GT(msg.find("\"type\":"), 0U);
888 EXPECT_GT(msg.find("\"info\":"), 0U);
889 return true;
890 };
891
892 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, Truly(isSendResponseOut), _)).Times(Exactly(1));
893
894 int32_t ret = OnPeerMsgRequestInfoReceived(&device, (const uint8_t *)input, len);
895 EXPECT_EQ(0, static_cast<int32_t>(ret));
896 }
897
898 HWTEST_F(DslmTest, OnPeerMsgRequestInfoReceived_case2, TestSize.Level0)
899 {
900 const DeviceIdentify *device = nullptr;
901 const char *input = "{\"version\":65536,\"challenge\":\"0102030405060708\"}";
902 uint32_t len = strlen(input) + 1;
903
904 int32_t ret = OnPeerMsgRequestInfoReceived(device, (const uint8_t *)input, len);
905 EXPECT_EQ(ERR_INVALID_PARA, ret);
906 }
907
908 HWTEST_F(DslmTest, OnPeerMsgResponseInfoReceived_case1, TestSize.Level0)
909 {
910 const char *input = "{\"version\":65536,\"type\":0,\"challenge\":\"EEFFFFFFFFCDABFF\",\"info\":"
911 "\"MDAwMTAyMDMwNDA1MDYwNzA4MDkwQTBCMEMwRDBFMEYxMDExMTIxMzE0MTUxNkFBQkJDQ0RE\"}";
912 uint32_t len = strlen(input) + 1;
913
914 DeviceIdentify device = {8, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
915
916 int32_t ret = OnPeerMsgResponseInfoReceived(&device, (const uint8_t *)input, len);
917 EXPECT_EQ(ERR_NOEXIST_DEVICE, static_cast<int32_t>(ret));
918 }
919
920 HWTEST_F(DslmTest, OnPeerMsgResponseInfoReceived_case2, TestSize.Level0)
921 {
922 const DeviceIdentify *device = nullptr;
923 const char *input = "{\"version\":65536,\"challenge\":\"0102030405060708\"}";
924 uint32_t len = strlen(input) + 1;
925
926 int32_t ret = OnPeerMsgResponseInfoReceived(device, (const uint8_t *)input, len);
927 EXPECT_EQ(ERR_INVALID_PARA, ret);
928 }
929
930 HWTEST_F(DslmTest, InitSelfDeviceSecureLevel_case1, TestSize.Level0)
931 {
932 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i'}};
933 DslmDeviceInfo *info = GetDslmDeviceInfo(&device);
934 EXPECT_EQ(nullptr, info);
935
936 DslmMsgInterfaceMock mockMsg;
937 mockMsg.MakeSelfDeviceId(&device);
938 mockMsg.MakeMsgLoopback();
939 EXPECT_CALL(mockMsg, GetSelfDeviceIdentify(_, _, _)).Times(AtLeast(1));
940 InitSelfDeviceSecureLevel();
941
942 info = GetDslmDeviceInfo(&device);
943 ASSERT_NE(nullptr, info);
944 EXPECT_GE(info->credInfo.credLevel, 1U);
945 mockMsg.MakeDeviceOffline(&device);
946 }
947
948 HWTEST_F(DslmTest, InitSelfDeviceSecureLevel_case2, TestSize.Level0)
949 {
950 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x', 'x'}};
951
952 DslmDeviceInfo *info = GetDslmDeviceInfo(&device);
953 EXPECT_EQ(nullptr, info);
954
955 DslmMsgInterfaceMock mockMsg;
956 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(6));
957 mockMsg.MakeDeviceOnline(&device);
958
959 info = GetDslmDeviceInfo(&device);
960 ASSERT_NE(nullptr, info);
961 EXPECT_EQ(1U, info->queryTimes);
962 EXPECT_EQ(STATE_WAITING_CRED_RSP, info->machine.currState);
963
964 BlockCheckDeviceStatus(&device, STATE_SUCCESS, 5000);
965 EXPECT_EQ(STATE_FAILED, info->machine.currState);
966 EXPECT_LT(5U, info->queryTimes);
967 mockMsg.MakeDeviceOffline(&device);
968 }
969
970 HWTEST_F(DslmTest, InnerKitsTest_case1, TestSize.Level0)
971 {
972 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
973
974 DeviceSecurityInfo *info = nullptr;
975 int32_t ret = RequestDeviceSecurityInfo(&device, nullptr, &info);
976 EXPECT_EQ(ret, 0);
977 int32_t level = 0;
978 ret = GetDeviceSecurityLevelValue(info, &level);
979 FreeDeviceSecurityInfo(info);
980 EXPECT_EQ(ret, 0);
981 EXPECT_GE(level, 1);
982 }
983
984 static int32_t g_cnt = 0;
985 static mutex g_mtx;
986 static condition_variable g_cv;
987
TestDeviceSecurityInfoCallback(const DeviceIdentify * identify,struct DeviceSecurityInfo * info)988 void TestDeviceSecurityInfoCallback(const DeviceIdentify *identify, struct DeviceSecurityInfo *info)
989 {
990 unique_lock<mutex> lck(g_mtx);
991 int32_t level = 0;
992 int32_t ret = GetDeviceSecurityLevelValue(info, &level);
993 FreeDeviceSecurityInfo(info);
994 EXPECT_EQ(ret, 0);
995 EXPECT_GE(level, 1);
996 g_cnt++;
997 g_cv.notify_one();
998 }
999
1000 HWTEST_F(DslmTest, InnerKitsTest_case2, TestSize.Level0)
1001 {
1002 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
1003
1004 g_cnt = 0;
1005 int ret = RequestDeviceSecurityInfoAsync(&device, nullptr, TestDeviceSecurityInfoCallback);
1006 EXPECT_EQ(ret, 0);
1007
1008 ret = RequestDeviceSecurityInfoAsync(&device, nullptr, TestDeviceSecurityInfoCallback);
1009 EXPECT_EQ(ret, 0);
1010
1011 ret = RequestDeviceSecurityInfoAsync(&device, nullptr, TestDeviceSecurityInfoCallback);
1012 EXPECT_EQ(ret, 0);
1013
1014 unique_lock<mutex> lck(g_mtx);
__anon2fe9fe530702() 1015 g_cv.wait_for(lck, std::chrono::milliseconds(2000), []() { return (g_cnt == 3); });
1016 EXPECT_EQ(g_cnt, 3);
1017 }
1018
1019 HWTEST_F(DslmTest, InnerKitsTest_case3, TestSize.Level0)
1020 {
1021 DeviceIdentify device = {DEVICE_ID_MAX_LEN, {0}};
1022 (void)memset_s(device.identity, DEVICE_ID_MAX_LEN, 'F', DEVICE_ID_MAX_LEN);
1023 DeviceSecurityInfo *info = nullptr;
1024 int32_t ret = RequestDeviceSecurityInfo(&device, nullptr, &info);
1025 EXPECT_EQ(ret, ERR_NOEXIST_DEVICE);
1026 }
1027
1028 HWTEST_F(DslmTest, GetSupportedCredTypes_case1, TestSize.Level0)
1029 {
1030 int32_t ret = GetSupportedCredTypes(nullptr, 0);
1031 EXPECT_EQ(0, ret);
1032 }
1033
1034 /**
1035 * @tc.name: GetSupportedCredTypes_case2
1036 * @tc.desc: function GetSupportedCredTypes with malformed inputs
1037 * @tc.type: FUNC
1038 * @tc.require: issueNumber
1039 */
1040 HWTEST_F(DslmTest, GetSupportedCredTypes_case2, TestSize.Level0)
1041 {
1042 int32_t ret;
1043 CredType list[] = {CRED_TYPE_MINI, CRED_TYPE_SMALL, CRED_TYPE_STANDARD, CRED_TYPE_LARGE};
1044 ret = GetSupportedCredTypes(list, 2);
1045 EXPECT_EQ(2, ret);
1046 }
1047
1048 HWTEST_F(DslmTest, CreateDslmCred_case1, TestSize.Level0)
1049 {
1050 CredType type = CRED_TYPE_STANDARD;
1051
1052 EXPECT_EQ(nullptr, CreateDslmCred(type, 0, nullptr));
1053 }
1054
1055 HWTEST_F(DslmTest, CheckAndGenerateChallenge_case1, TestSize.Level0)
1056 {
1057 DslmDeviceInfo device;
1058 (void)memset_s(&device, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1059
1060 {
1061 int32_t ret = CheckAndGenerateChallenge(nullptr);
1062 EXPECT_EQ(ERR_INVALID_PARA, ret);
1063 }
1064
1065 {
1066 int32_t ret = CheckAndGenerateChallenge(&device);
1067 EXPECT_EQ(SUCCESS, ret);
1068 }
1069 }
1070
1071 HWTEST_F(DslmTest, CheckAndGenerateChallenge_case2, TestSize.Level0)
1072 {
1073 DslmDeviceInfo device;
1074 (void)memset_s(&device, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1075
1076 {
1077 device.nonceTimeStamp = 0xFFFFFFFFFFFFFFFF;
1078 int32_t ret = CheckAndGenerateChallenge(&device);
1079 EXPECT_EQ(SUCCESS, ret);
1080 }
1081
1082 {
1083 device.nonceTimeStamp = GetMillisecondSinceBoot();
1084 int32_t ret = CheckAndGenerateChallenge(&device);
1085 EXPECT_EQ(SUCCESS, ret);
1086 }
1087
1088 {
1089 device.nonceTimeStamp = GetMillisecondSinceBoot();
1090 device.nonce = 1;
1091 int32_t ret = CheckAndGenerateChallenge(&device);
1092 EXPECT_EQ(SUCCESS, ret);
1093 }
1094 }
1095
1096 HWTEST_F(DslmTest, SendDeviceInfoRequest_case1, TestSize.Level0)
1097 {
1098 DslmDeviceInfo *device = nullptr;
1099
1100 int32_t ret = SendDeviceInfoRequest(device);
1101 EXPECT_EQ(ERR_INVALID_PARA, ret);
1102 }
1103
1104 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case1, TestSize.Level0)
1105 {
1106 DslmDeviceInfo *device = nullptr;
1107
1108 int32_t ret = VerifyDeviceInfoResponse(device, NULL);
1109 EXPECT_EQ(ERR_INVALID_PARA, ret);
1110 }
1111
1112 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case2, TestSize.Level0)
1113 {
1114 MessageBuff msg = {.length = 0, .buff = nullptr};
1115 DslmDeviceInfo device;
1116 (void)memset_s(&device, sizeof(device), 0, sizeof(device));
1117
1118 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1119 EXPECT_EQ(ERR_INVALID_PARA, ret);
1120 }
1121
1122 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case3, TestSize.Level0)
1123 {
1124 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
1125 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
1126 uint32_t messageLen = strlen(message) + 1;
1127 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
1128
1129 DslmDeviceInfo device;
1130 (void)memset_s(&device, sizeof(device), 0, sizeof(device));
1131
1132 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1133 EXPECT_EQ(ERR_CHALLENGE_ERR, ret);
1134 }
1135
1136 HWTEST_F(DslmTest, VerifyDeviceInfoResponse_case4, TestSize.Level0)
1137 {
1138 DslmDeviceInfo device;
1139 memset_s(&device, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1140 device.nonce = 0xE2C4D353EE211F3C;
1141 const char *message = "{\"version\":131072,\"challenge\":\"3C1F21EE53D3C4E2\",\"type\":2,\"info\":"
1142 "\"SkFERS1BTDAwOjg3QUQyOEQzQjFCLi4u\"}";
1143 uint32_t messageLen = strlen(message) + 1;
1144 MessageBuff msg = {.length = messageLen, .buff = (uint8_t *)message};
1145
1146 {
1147 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1148 EXPECT_EQ(ERR_CHALLENGE_ERR, ret);
1149 }
1150
1151 {
1152 device.nonceTimeStamp = 0xFFFFFFFFFFFFFFFF;
1153 int32_t ret = VerifyDeviceInfoResponse(&device, &msg);
1154 EXPECT_EQ(ERR_CHALLENGE_ERR, ret);
1155 }
1156 }
1157
1158 HWTEST_F(DslmTest, GetDslmDeviceInfo_case1, TestSize.Level0)
1159 {
1160 DeviceIdentify *device = nullptr;
1161
1162 EXPECT_EQ(nullptr, GetDslmDeviceInfo(device));
1163 }
1164
1165 HWTEST_F(DslmTest, CreatOrGetDslmDeviceInfo_case1, TestSize.Level0)
1166 {
1167 DeviceIdentify *device = nullptr;
1168
1169 EXPECT_EQ(nullptr, CreatOrGetDslmDeviceInfo(device));
1170 }
1171
1172 HWTEST_F(DslmTest, CreatOrGetDslmDeviceInfo_case2, TestSize.Level0)
1173 {
1174 DeviceIdentify device = {.length = DEVICE_ID_MAX_LEN - 1};
1175
1176 EXPECT_EQ(nullptr, CreatOrGetDslmDeviceInfo(&device));
1177 }
1178
1179 HWTEST_F(DslmTest, IsSameDevice_case1, TestSize.Level0)
1180 {
1181 DeviceIdentify *device_first = nullptr;
1182 DeviceIdentify device_second;
1183 (void)memset_s(&device_second, sizeof(device_second), 0, sizeof(device_second));
1184
1185 EXPECT_EQ(false, IsSameDevice(device_first, &device_second));
1186 }
1187
1188 HWTEST_F(DslmTest, GetCurrentMachineState_case1, TestSize.Level0)
1189 {
1190 DslmDeviceInfo *info = nullptr;
1191 uint32_t ret = GetCurrentMachineState(info);
1192 EXPECT_EQ(STATE_FAILED, ret);
1193 }
1194
1195 HWTEST_F(DslmTest, OnMsgSendResultNotifier_case1, TestSize.Level0)
1196 {
1197 DeviceIdentify identify = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1198 uint64_t transNo = 0;
1199 uint32_t result = ERR_DEFAULT;
1200
1201 {
1202 uint32_t ret = OnMsgSendResultNotifier(&identify, transNo, result);
1203 EXPECT_EQ(SUCCESS, ret);
1204 }
1205
1206 {
1207 uint32_t ret = OnMsgSendResultNotifier(nullptr, transNo, result);
1208 EXPECT_EQ(SUCCESS, ret);
1209 }
1210 }
1211
1212 HWTEST_F(DslmTest, OnPeerStatusReceiver_case1, TestSize.Level0)
1213 {
1214 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1215 uint32_t status = 1234;
1216 uint32_t devType = 0;
1217
1218 int32_t ret = OnPeerStatusReceiver(&device, status, devType);
1219 EXPECT_EQ(SUCCESS, ret);
1220 }
1221
1222 HWTEST_F(DslmTest, InitDslmProcess_case1, TestSize.Level0)
1223 {
1224 EXPECT_EQ(false, InitDslmProcess());
1225 }
1226
1227 HWTEST_F(DslmTest, DeinitDslmProcess_case1, TestSize.Level0)
1228 {
1229 EXPECT_EQ(true, DeinitDslmProcess());
1230 }
1231
1232 // dslm_ohos_verify.c
1233 HWTEST_F(DslmTest, VerifyOhosDslmCred_case1, TestSize.Level0)
1234 {
1235 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1236 uint64_t challenge = 0x1234;
1237 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
1238 DslmCredBuff cred = {CRED_TYPE_STANDARD, 9, info};
1239 DslmCredInfo *credInfo = nullptr;
1240
1241 int32_t ret = VerifyOhosDslmCred(&device, challenge, &cred, credInfo);
1242 EXPECT_EQ(ERR_INVALID_PARA, ret);
1243 }
1244
1245 HWTEST_F(DslmTest, VerifyOhosDslmCred_case2, TestSize.Level0)
1246 {
1247 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1248 uint64_t challenge = 0x1234;
1249 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
1250 DslmCredBuff cred = {CRED_TYPE_LARGE, 9, info};
1251 DslmCredInfo credInfo;
1252 (void)memset_s(&credInfo, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
1253
1254 int32_t ret = VerifyOhosDslmCred(&device, challenge, &cred, &credInfo);
1255 EXPECT_EQ(ERR_INVALID_PARA, ret);
1256 }
1257
1258 HWTEST_F(DslmTest, VerifyOhosDslmCred_case3, TestSize.Level0)
1259 {
1260 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'a', 'b'}};
1261 uint64_t challenge = 0x1234;
1262 uint8_t info[] = {'a', 'b', 'c', 'd', 1, 3, 5, 7, 9};
1263 DslmCredBuff cred = {CRED_TYPE_SMALL, 9, info};
1264 DslmCredInfo credInfo;
1265 (void)memset_s(&credInfo, sizeof(DslmCredInfo), 0, sizeof(DslmCredInfo));
1266
1267 int32_t ret = VerifyOhosDslmCred(&device, challenge, &cred, &credInfo);
1268 EXPECT_EQ(ERR_PARSE_CLOUD_CRED_DATA, ret);
1269 }
1270
1271 // dslm_ohos_request.c
1272
1273 // 2nd param of GetCredFromCurrentDevice() is 0
1274 HWTEST_F(DslmTest, GetCredFromCurrentDevice_case1, TestSize.Level0)
1275 {
1276 char cred[] = "test";
1277 uint32_t len = 0;
1278
1279 int32_t ret = GetCredFromCurrentDevice(cred, len);
1280 EXPECT_EQ(ERR_INVALID_PARA, ret);
1281 }
1282
1283 /**
1284 * @tc.name: GetPeerDeviceOnlineStatus_case1
1285 * @tc.desc: function GetPeerDeviceOnlineStatus when g_messenger is NULL
1286 * @tc.type: FUNC
1287 * @tc.require: issueNumber
1288 */
1289 HWTEST_F(DslmTest, GetPeerDeviceOnlineStatus_case1, TestSize.Level0)
1290 {
1291 EXPECT_EQ(false, GetPeerDeviceOnlineStatus(nullptr, nullptr));
1292 }
1293
1294 /**
1295 * @tc.name: GetPeerDeviceOnlineStatus_case2
1296 * @tc.desc: function GetPeerDeviceOnlineStatus with null input
1297 * @tc.type: FUNC
1298 * @tc.require: issueNumber
1299 */
1300 HWTEST_F(DslmTest, GetPeerDeviceOnlineStatus_case2, TestSize.Level0)
1301 {
1302 DslmMsgInterfaceMock mockMsg;
1303 EXPECT_EQ(false, GetPeerDeviceOnlineStatus(nullptr, nullptr));
1304 }
1305
1306 /**
1307 * @tc.name: GetSelfDevice_case1
1308 * @tc.desc: function GetSelfDevice with null input
1309 * @tc.type: FUNC
1310 * @tc.require: issueNumber
1311 */
1312 HWTEST_F(DslmTest, GetSelfDevice_case1, TestSize.Level0)
1313 {
1314 (void)GetSelfDevice(nullptr);
1315 }
1316
1317 /**
1318 * @tc.name: DeinitMessenger_case1
1319 * @tc.desc: function DeinitMessenger when g_messenger is NULL
1320 * @tc.type: FUNC
1321 * @tc.require: issueNumber
1322 */
1323 HWTEST_F(DslmTest, DeinitMessenger_case1, TestSize.Level0)
1324 {
1325 DslmMsgInterfaceMock mockMsg;
1326
1327 uint32_t ret = DeinitMessenger();
1328 EXPECT_EQ(SUCCESS, ret);
1329 }
1330
1331 /**
1332 * @tc.name: DeinitMessenger_case2
1333 * @tc.desc: function DeinitMessenger when g_messenger is not NULL
1334 * @tc.type: FUNC
1335 * @tc.require: issueNumber
1336 */
1337 HWTEST_F(DslmTest, DeinitMessenger_case2, TestSize.Level0)
1338 {
1339 uint32_t ret = DeinitMessenger();
1340 EXPECT_EQ(SUCCESS, ret);
1341 }
1342
1343 /**
1344 * @tc.name: SendMsgToDevice_case1
1345 * @tc.desc: function SendMsgToDevice when g_messenger is NULL
1346 * @tc.type: FUNC
1347 * @tc.require: issueNumber
1348 */
1349 HWTEST_F(DslmTest, SendMsgToDevice_case1, TestSize.Level0)
1350 {
1351 DslmMsgInterfaceMock mockMsg;
1352 uint64_t transNo = 0xfe;
1353 const DeviceIdentify devId = {DEVICE_ID_MAX_LEN, {0}};
1354 const uint8_t msg[] = {'1', '2'};
1355 uint32_t msgLen = 2;
1356
1357 mockMsg.~DslmMsgInterfaceMock();
1358 EXPECT_CALL(mockMsg, SendMsgTo(_, _, _, _, _)).Times(Exactly(0));
1359
1360 SendMsgToDevice(transNo, &devId, msg, msgLen);
1361 }
1362
1363 /**
1364 * @tc.name: CheckMessage_case1
1365 * @tc.desc: function CheckMessage when malformed input,
1366 * msg contains non ASCII item.
1367 * @tc.type: FUNC
1368 * @tc.require: issueNumber
1369 */
1370 HWTEST_F(DslmTest, CheckMessage_case1, TestSize.Level0)
1371 {
1372 const uint8_t msg[] = {'1', 0x8f, '\0'};
1373 uint32_t msgLen = 3;
1374
1375 EXPECT_EQ(false, CheckMessage(msg, msgLen));
1376 }
1377
1378 // just for coverage
1379 /**
1380 * @tc.name: FreeMessagePacket_case1
1381 * @tc.desc: function FreeMessagePacket when packet->payload is NULL
1382 * @tc.type: FUNC
1383 * @tc.require: issueNumber
1384 */
1385 HWTEST_F(DslmTest, FreeMessagePacket_case1, TestSize.Level0)
1386 {
1387 MessagePacket *packet = (MessagePacket *)MALLOC(sizeof(MessagePacket));
1388 ASSERT_NE(nullptr, packet);
1389 (void)memset_s(packet, sizeof(MessagePacket), 0, sizeof(MessagePacket));
1390
1391 FreeMessagePacket(packet);
1392 }
1393
1394 // just for coverage
1395 /**
1396 * @tc.name: FreeMessageBuff_case1
1397 * @tc.desc: function FreeMessageBuff with null input
1398 * @tc.type: FUNC
1399 * @tc.require: issueNumber
1400 */
1401 HWTEST_F(DslmTest, FreeMessageBuff_case1, TestSize.Level0)
1402 {
1403 MessageBuff *buff = nullptr;
1404
1405 FreeMessageBuff(buff);
1406 }
1407
1408 // just for coverage
1409 /**
1410 * @tc.name: FreeMessageBuff_case2
1411 * @tc.desc: function FreeMessageBuff when buff->buff is NULL
1412 * @tc.type: FUNC
1413 * @tc.require: issueNumber
1414 */
1415 HWTEST_F(DslmTest, FreeMessageBuff_case2, TestSize.Level0)
1416 {
1417 MessageBuff *buff = (MessageBuff *)MALLOC(sizeof(MessageBuff));
1418 ASSERT_NE(nullptr, buff);
1419 memset_s(buff, sizeof(MessageBuff), 0, sizeof(MessageBuff));
1420
1421 FreeMessageBuff(buff);
1422 }
1423
dummyDump(const DslmDeviceInfo * info,int32_t fd)1424 static void dummyDump(const DslmDeviceInfo *info, int32_t fd)
1425 {
1426 (void)info;
1427 (void)fd;
1428 }
1429
1430 HWTEST_F(DslmTest, ForEachDeviceDump_case1, TestSize.Level0)
1431 {
1432 ForEachDeviceDump(nullptr, 0);
1433 ForEachDeviceDump(dummyDump, 0);
1434 InitDslmStateMachine(nullptr);
1435 ScheduleDslmStateMachine(nullptr, 0, nullptr);
1436 }
1437
1438 /**
1439 * @tc.name: DestroyDslmCred_case1
1440 * @tc.desc: function DestroyDslmCred with malformed inputs
1441 * @tc.type: FUNC
1442 * @tc.require: issueNumber
1443 */
1444 HWTEST_F(DslmTest, DestroyDslmCred_case1, TestSize.Level0)
1445 {
1446 DslmCredBuff *cred = (DslmCredBuff *)MALLOC(sizeof(DslmCredBuff));
1447 cred->type = (CredType)3;
1448 cred->credLen = 9;
1449 cred->credVal = nullptr;
1450
1451 DestroyDslmCred(nullptr);
1452 DestroyDslmCred(cred);
1453 }
1454
1455 /**
1456 * @tc.name: ReportHiEventAppInvoke_case1
1457 * @tc.desc: function ReportHiEventAppInvoke with malformed inputs
1458 * @tc.type: FUNC
1459 * @tc.require: issueNumber
1460 */
1461 HWTEST_F(DslmTest, ReportHiEventAppInvoke_case1, TestSize.Level0)
1462 {
1463 DslmDeviceInfo info;
1464 (void)memset_s(&info, sizeof(DslmDeviceInfo), 0, sizeof(DslmDeviceInfo));
1465 info.lastRequestTime = 10U;
1466 ReportHiEventInfoSync(nullptr);
1467 ReportHiEventInfoSync(&info);
1468 ReportHiEventAppInvoke(nullptr);
1469 }
1470
1471 /**
1472 * @tc.name: GetDeviceSecurityLevelValue_case1
1473 * @tc.desc: function GetDeviceSecurityLevelValue with malformed inputs
1474 * @tc.type: FUNC
1475 * @tc.require: issueNumber
1476 */
1477 HWTEST_F(DslmTest, GetDeviceSecurityLevelValue_case1, TestSize.Level0)
1478 {
1479 int32_t ret;
1480 int32_t level = 0;
1481 DeviceSecurityInfo info = {.magicNum = 0xcd, .result = 0, .level = 0};
1482
1483 ret = GetDeviceSecurityLevelValue(nullptr, &level);
1484 EXPECT_EQ(ERR_INVALID_PARA, ret);
1485
1486 ret = GetDeviceSecurityLevelValue(&info, nullptr);
1487 EXPECT_EQ(ERR_INVALID_PARA, ret);
1488 }
1489
1490 /**
1491 * @tc.name: RequestDeviceSecurityInfoAsync_case1
1492 * @tc.desc: function RequestDeviceSecurityInfoAsync with malformed inputs
1493 * @tc.type: FUNC
1494 * @tc.require: issueNumber
1495 */
1496 HWTEST_F(DslmTest, RequestDeviceSecurityInfoAsync_case1, TestSize.Level0)
1497 {
1498 int32_t ret;
1499 const DeviceIdentify device = {DEVICE_ID_MAX_LEN, {'a', 'b', 'c', 'd', 'e', 'f', 'g'}};
1500 RequestOption opt = {.challenge = 0xcd, .timeout = 400, .extra = 0};
__anon2fe9fe530802(const DeviceIdentify *identify, struct DeviceSecurityInfo *info) 1501 auto callback = [](const DeviceIdentify *identify, struct DeviceSecurityInfo *info) { return; };
1502
1503 ret = RequestDeviceSecurityInfoAsync(nullptr, &opt, callback);
1504 EXPECT_EQ(ERR_INVALID_PARA, ret);
1505
1506 ret = RequestDeviceSecurityInfoAsync(&device, &opt, nullptr);
1507 EXPECT_EQ(ERR_INVALID_PARA, ret);
1508
1509 // malformed option->timeout > MAX_KEEP_LEN
1510 ret = RequestDeviceSecurityInfoAsync(&device, &opt, callback);
1511 EXPECT_EQ(ERR_INVALID_PARA, ret);
1512 }
1513 } // namespace DslmUnitTest
1514 } // namespace Security
1515 } // namespace OHOS