1 /*
2 * Copyright (C) 2023 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 #include <securec.h>
16 #include <gtest/gtest.h>
17 #include <pthread.h>
18
19 #include "devattest_log.h"
20 #include "attest_entry.h"
21 #include "attest_result_info.h"
22 #include "attest_type.h"
23 #include "attest_service_active.h"
24 #include "attest_service_auth.h"
25 #include "attest_service_challenge.h"
26 #include "attest_service_device.h"
27 #include "attest_service.h"
28 #include "attest_service_device.h"
29 #include "attest_security_token.h"
30 #include "attest_service_reset.h"
31 #include "attest_network.h"
32 #include "attest_adapter.h"
33 #include "devattest_errno.h"
34 #include "attest_utils.h"
35 #include "attest_tdd_mock_property.h"
36 #include "attest_tdd_mock_hal.h"
37 #include "attest_tdd_test.h"
38 #include "attest_tdd_mock_config.h"
39
40 using namespace testing::ext;
41 namespace OHOS {
42 namespace DevAttest {
43
44 static const int32_t ATTEST_GET_CHANLLEGE = 0;
45 static const int32_t ATTEST_RESET = 1;
46 static const int32_t ATTEST_ACTIVE = 2;
47 static const int32_t ATTEST_AUTH = 3;
48
49 static const char* ATTEST_REST_ERROR_EXPECT_RESULT = "15003";
50 static const char* ATTEST_RESET_EXPECT_CHAP = "39a9d04d41617162893c3312ceb030acac8d8bd0cc9fcebcab5402a43891341d";
51
52 class AttestTddTest : public testing::Test {
53 public:
54 static void SetUpTestCase(void);
55
56 static void TearDownTestCase(void);
57
58 void SetUp();
59
60 void TearDown();
61 };
62
SetUpTestCase(void)63 void AttestTddTest::SetUpTestCase(void)
64 {
65 }
66
TearDownTestCase(void)67 void AttestTddTest::TearDownTestCase(void)
68 {
69 }
70
SetUp()71 void AttestTddTest::SetUp()
72 {
73 }
74
TearDown()75 void AttestTddTest::TearDown()
76 {
77 }
78
79 /*
80 * @tc.name: TestInitSysData001
81 * @tc.desc: Test init system data.
82 * @tc.type: FUNC
83 */
84 HWTEST_F(AttestTddTest, TestInitSysData001, TestSize.Level1)
85 {
86 int32_t ret = InitSysData();
87 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
88 EXPECT_STREQ(StrdupDevInfo(VERSION_ID), ATTEST_MOCK_PROPERTY_VERSIONID);
89 EXPECT_STREQ(StrdupDevInfo(ROOT_HASH), ATTEST_MOCK_PROPERTY_HASH);
90 EXPECT_STREQ(StrdupDevInfo(DISPLAY_VERSION), ATTEST_MOCK_PROPERTY_SOFTWARE_VERSION);
91 EXPECT_STREQ(StrdupDevInfo(MANU_FACTURE), ATTEST_MOCK_PROPERTY_MANU);
92 EXPECT_STREQ(StrdupDevInfo(PRODUCT_MODEL), ATTEST_MOCK_PROPERTY_MODEL);
93 EXPECT_STREQ(StrdupDevInfo(BRAND), ATTEST_MOCK_PROPERTY_BRAND);
94 EXPECT_STREQ(StrdupDevInfo(SECURITY_PATCH_TAG), ATTEST_MOCK_PROPERTY_PATCH);
95 EXPECT_STREQ(StrdupDevInfo(UDID), ATTEST_MOCK_PROPERTY_UDID);
96 // 恢复环境
97 DestroySysData();
98 EXPECT_TRUE(StrdupDevInfo(VERSION_ID) == nullptr);
99 }
100
101 /*
102 * @tc.name: TestInitNetWork001
103 * @tc.desc: Test init network, result is success.
104 * @tc.type: FUNC
105 */
106 HWTEST_F(AttestTddTest, TestInitNetWork001, TestSize.Level1)
107 {
108 int ret = InitNetworkServerInfo();
109 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
110 ServerInfo* serverInfo = (ServerInfo*)g_attestNetworkList.head->data;
111 EXPECT_STREQ(serverInfo->hostName, ATTEST_MOCK_HAL_NETWORK_RESULT);
112 ReleaseList(&g_attestNetworkList);
113 }
114
115 /*
116 * @tc.name: TestInitNetWork002
117 * @tc.desc: Test init network, result is fail.
118 * @tc.type: FUNC
119 */
120 HWTEST_F(AttestTddTest, TestInitNetWork002, TestSize.Level1)
121 {
122 int ret = InitNetworkServerInfo();
123 EXPECT_TRUE(ret == DEVATTEST_FAIL);
124 ReleaseList(&g_attestNetworkList);
125 }
126
127 /*
128 * @tc.name: TestGetAuthStatus001
129 * @tc.desc: Test get authStatus.
130 * @tc.type: FUNC
131 */
132 HWTEST_F(AttestTddTest, TestGetAuthStatus001, TestSize.Level1)
133 {
134 int32_t ret = FlushAuthResult(ATTEST_MOCK_HAL_TICKET, ATTEST_MOCK_HAL_STATUS);
135 EXPECT_TRUE((ret == DEVATTEST_SUCCESS));
136 char *status = nullptr;
137 ret = GetAuthStatus(&status);
138 EXPECT_TRUE((ret == DEVATTEST_SUCCESS));
139 EXPECT_TRUE((status != nullptr));
140 if (status == nullptr) {
141 return;
142 }
143 EXPECT_STREQ(ATTEST_MOCK_HAL_STATUS, status);
144 free(status);
145 }
146
147 /*
148 * @tc.name: TestDecodeAuthStatus001
149 * @tc.desc: Test decode auth status.
150 * @tc.type: FUNC
151 */
152 HWTEST_F(AttestTddTest, TestDecodeAuthStatus001, TestSize.Level1)
153 {
154 char *status = nullptr;
155 int32_t ret = GetAuthStatus(&status);
156 EXPECT_TRUE((ret == DEVATTEST_SUCCESS));
157 AuthStatus* outStatus = CreateAuthStatus();
158 EXPECT_TRUE((outStatus != nullptr));
159 if (outStatus == nullptr) {
160 return;
161 }
162 ret = DecodeAuthStatus(status, outStatus);
163 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
164 SoftwareResultDetail* detail = outStatus->softwareResultDetail;
165 EXPECT_TRUE((outStatus->versionId != nullptr) && (outStatus->authType != nullptr) && (detail != nullptr));
166 if ((outStatus->versionId == nullptr) || (outStatus->authType == nullptr) || (detail == nullptr)) {
167 DestroyAuthStatus(&outStatus);
168 return;
169 }
170 EXPECT_TRUE(outStatus->hardwareResult == ATTEST_HARDWARE_RESULT);
171 EXPECT_STREQ(outStatus->authType, ATTEST_AUTH_TYPE);
172 EXPECT_TRUE(outStatus->expireTime == ATTEST_EXPIRE_TIME);
173 EXPECT_STREQ(outStatus->versionId, ATTEST_VERSION_ID);
174 EXPECT_TRUE(outStatus->softwareResult == ATTEST_SOFTWARE_RESULT);
175 DestroyAuthStatus(&outStatus);
176 }
177
178 /*
179 * @tc.name: TestCheckExpireTime001
180 * @tc.desc: Test check expire time.
181 * @tc.type: FUNC
182 */
183 HWTEST_F(AttestTddTest, TestCheckExpireTime001, TestSize.Level1)
184 {
185 AuthStatus* outStatus = CreateAuthStatus();
186 EXPECT_TRUE(outStatus != nullptr);
187 if (outStatus == nullptr) {
188 return;
189 }
190 outStatus->expireTime = 19673222;
191 uint64_t currentTime = 19673223;
192 int32_t ret = CheckExpireTime(outStatus, currentTime);
193 EXPECT_TRUE(ret != DEVATTEST_SUCCESS);
194 outStatus->expireTime = 19673222;
195 currentTime = 19673221;
196 ret = CheckExpireTime(outStatus, currentTime);
197 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
198 free(outStatus);
199 }
200
201 /*
202 * @tc.name: TestCheckAuthResult001
203 * @tc.desc: Test check auth result.
204 * @tc.type: FUNC
205 */
206 HWTEST_F(AttestTddTest, TestCheckAuthResult001, TestSize.Level1)
207 {
208 AuthStatus* outStatus = CreateAuthStatus();
209 EXPECT_TRUE(outStatus != nullptr);
210 if (outStatus == nullptr) {
211 return;
212 }
213 outStatus->hardwareResult = 1;
214 outStatus->softwareResult = 0;
215 int32_t ret = CheckAuthResult(outStatus);
216 EXPECT_TRUE(ret != DEVATTEST_SUCCESS);
217 outStatus->hardwareResult = 0;
218 ret = CheckAuthResult(outStatus);
219 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
220 free(outStatus);
221 }
222
GetAuthResult()223 static AuthResult *GetAuthResult()
224 {
225 AuthResult *authResult = CreateAuthResult();
226 if (authResult == nullptr) {
227 return nullptr;
228 }
229 int32_t ret = ParseAuthResultResp(ATTEST_AUTH_EXPECT_RESULT, authResult);
230 if (ret != DEVATTEST_SUCCESS) {
231 DestroyAuthResult(&authResult);
232 return nullptr;
233 }
234 return authResult;
235 }
236
TddGenMsg(int input)237 static DevicePacket* TddGenMsg(int input)
238 {
239 DevicePacket* reqMsg = nullptr;
240 int32_t ret = DEVATTEST_SUCCESS;
241 ChallengeResult challenge;
242 do {
243 if (input == ATTEST_CASE_RESET) {
244 challenge.challenge = (char*)ATTEST_RESET_CHAP;
245 challenge.currentTime = ATTEST_RESET_CHAP_TIME;
246 ret = GenResetMsg(&challenge, &reqMsg);
247 break;
248 }
249 if (input == ATTEST_CASE_AUTH) {
250 challenge.challenge = (char*)ATTEST_AUTH_CHAP;
251 challenge.currentTime = ATTEST_AUTH_CHAP_TIME;
252 ret = GenAuthMsg(&challenge, &reqMsg);
253 break;
254 }
255 if (input == ATTEST_CASE_ACTIVE) {
256 challenge.challenge = (char*)ATTEST_ACTIVE_CHAP;
257 challenge.currentTime = ATTEST_ACTIVE_CHAP_TIME;
258 AuthResult *authResult = GetAuthResult();
259 ret = GenActiveMsg(authResult, &challenge, &reqMsg);
260 break;
261 }
262 } while (0);
263 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
264 if (ret != DEVATTEST_SUCCESS) {
265 FREE_DEVICE_PACKET(reqMsg);
266 return nullptr;
267 }
268 return reqMsg;
269 }
270
271 /*
272 * @tc.name: TestGenResetMsg001
273 * @tc.desc: Test gen reset msg with stored token.
274 * @tc.type: FUNC
275 */
276 HWTEST_F(AttestTddTest, TestGenResetMsg001, TestSize.Level1)
277 {
278 AttestSetMockReadTokenRet(ATTEST_OK);
279 // 初始化参数
280 int32_t ret = InitSysData();
281 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
282
283 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_RESET);
284 EXPECT_TRUE((reqMsg != nullptr));
285 if (reqMsg == nullptr) {
286 DestroySysData();
287 return;
288 }
289 char *outToken = reqMsg->tokenInfo.token;
290 EXPECT_TRUE(outToken != nullptr);
291 if (outToken == nullptr) {
292 FREE_DEVICE_PACKET(reqMsg);
293 DestroySysData();
294 return;
295 }
296 EXPECT_TRUE(strcmp(ATTEST_RESET_GEN_TOKEN, outToken) == 0);
297 FREE_DEVICE_PACKET(reqMsg);
298 // 恢复环境
299 DestroySysData();
300 }
301
302 /*
303 * @tc.name: TestGenResetMsg002
304 * @tc.desc: Test gen reset msg without token.
305 * @tc.type: FUNC
306 */
307 HWTEST_F(AttestTddTest, TestGenResetMsg002, TestSize.Level1)
308 {
309 AttestSetMockReadTokenRet(TOKEN_UNPRESET);
310 // 初始化参数
311 int32_t ret = InitSysData();
312 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
313
314 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_RESET);
315 EXPECT_TRUE((reqMsg != nullptr));
316 if (reqMsg == nullptr) {
317 DestroySysData();
318 return;
319 }
320 char *outToken = reqMsg->tokenInfo.token;
321 EXPECT_TRUE(outToken != nullptr);
322 if (outToken == nullptr) {
323 FREE_DEVICE_PACKET(reqMsg);
324 DestroySysData();
325 return;
326 }
327 #if defined(__ATTEST_ENABLE_PRESET_TOKEN__)
328 EXPECT_TRUE(strcmp(ATTEST_RESET_GEN_ONLINE_TOKEN, outToken) == 0);
329
330 outToken = reqMsg->tokenInfo.uuid;
331 EXPECT_TRUE(outToken != nullptr);
332 if (outToken == nullptr) {
333 FREE_DEVICE_PACKET(reqMsg);
334 DestroySysData();
335 return;
336 }
337 EXPECT_TRUE(strcmp(ATTEST_RESET_GEN_ONLINE_TOKEN_ID, outToken) == 0);
338 #else
339 EXPECT_TRUE(strcmp(ATTEST_RESET_GEN_PRODUCT_TOKEN, outToken) == 0);
340 #endif
341 FREE_DEVICE_PACKET(reqMsg);
342 // 恢复环境
343 DestroySysData();
344 }
345
346 /*
347 * @tc.name: TestParseResetResult001
348 * @tc.desc: Test parse reset result，result is ok.
349 * @tc.type: FUNC
350 */
351 HWTEST_F(AttestTddTest, TestParseResetResult001, TestSize.Level1)
352 {
353 string input = "{\"errcode\":0}";
354 int32_t ret = ParseResetResult(input.c_str());
355 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
356 input = "{\"errcode\":\"-32s\"}";
357 ret = ParseResetResult(input.c_str());
358 EXPECT_TRUE((ret != DEVATTEST_SUCCESS));
359 }
360
361 /*
362 * @tc.name: TestGenAuthMsg001
363 * @tc.desc: Test gen auth msg.
364 * @tc.type: FUNC
365 */
366 HWTEST_F(AttestTddTest, TestGenAuthMsg001, TestSize.Level1)
367 {
368 AttestSetMockReadTokenRet(ATTEST_OK);
369 // 初始化参数
370 int32_t ret = InitSysData();
371 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
372
373 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_AUTH);
374 EXPECT_TRUE((reqMsg != nullptr));
375 if (reqMsg == nullptr) {
376 return;
377 }
378 char *outToken = reqMsg->tokenInfo.token;
379 EXPECT_TRUE(outToken != nullptr);
380 if (outToken == nullptr) {
381 FREE_DEVICE_PACKET(reqMsg);
382 return;
383 }
384 EXPECT_TRUE(strcmp(outToken, ATTEST_AUTH_GEN_TOKEN) == 0);
385 FREE_DEVICE_PACKET(reqMsg);
386 // 恢复环境
387 DestroySysData();
388 }
389
390 /*
391 * @tc.name: TestGenAuthMsg002
392 * @tc.desc: Test gen auth msg without token.
393 * @tc.type: FUNC
394 */
395 HWTEST_F(AttestTddTest, TestGenAuthMsg002, TestSize.Level1)
396 {
397 AttestSetMockReadTokenRet(TOKEN_UNPRESET);
398 // 初始化参数
399 int32_t ret = InitSysData();
400 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
401
402 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_AUTH);
403 EXPECT_TRUE((reqMsg != nullptr));
404 if (reqMsg == nullptr) {
405 return;
406 }
407 char *outToken = reqMsg->tokenInfo.token;
408 EXPECT_TRUE(outToken != nullptr);
409 if (outToken == nullptr) {
410 FREE_DEVICE_PACKET(reqMsg);
411 return;
412 }
413 #if defined(__ATTEST_ENABLE_PRESET_TOKEN__)
414 EXPECT_TRUE(strcmp(ATTEST_AUTH_GEN_ONLINE_TOKEN, outToken) == 0);
415 #else
416 EXPECT_TRUE(strcmp(ATTEST_AUTH_GEN_PRODUCT_TOKEN, outToken) == 0);
417 #endif
418 FREE_DEVICE_PACKET(reqMsg);
419 // 恢复环境
420 DestroySysData();
421 }
422
423 /*
424 * @tc.name: TestParseAuthResultResp001
425 * @tc.desc: Test parse auth result resp.
426 * @tc.type: FUNC
427 */
428 HWTEST_F(AttestTddTest, TestParseAuthResultResp001, TestSize.Level1)
429 {
430 AuthResult *authResult = GetAuthResult();
431 EXPECT_TRUE(authResult != nullptr);
432 if (authResult == nullptr) {
433 return;
434 }
435 EXPECT_TRUE((authResult->ticket != nullptr) && (authResult->tokenValue != nullptr) &&
436 (authResult->authStatus != nullptr));
437 if (authResult->ticket != nullptr) {
438 EXPECT_TRUE(strcmp(authResult->ticket, ATTEST_MOCK_HAL_TICKET) == 0);
439 }
440 DestroyAuthResult(&authResult);
441 }
442
443 /*
444 * @tc.name: TestGenActiveMsg001
445 * @tc.desc: Test gen active msg.
446 * @tc.type: FUNC
447 */
448 HWTEST_F(AttestTddTest, TestGenActiveMsg001, TestSize.Level1)
449 {
450 AttestSetMockReadTokenRet(ATTEST_OK);
451 // 初始化参数
452 int32_t ret = InitSysData();
453 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
454
455 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_ACTIVE);
456 EXPECT_TRUE((reqMsg != nullptr));
457 if (reqMsg == nullptr) {
458 return;
459 }
460 char *outToken = reqMsg->tokenInfo.token;
461 EXPECT_TRUE(outToken != nullptr);
462 if (outToken == nullptr) {
463 FREE_DEVICE_PACKET(reqMsg);
464 return;
465 }
466 EXPECT_TRUE(strcmp(outToken, ATTEST_ACTIVE_GEN_TOKEN) == 0);
467 FREE_DEVICE_PACKET(reqMsg);
468 // 恢复环境
469 DestroySysData();
470 }
471
472 /*
473 * @tc.name: TestGenActiveMsg002
474 * @tc.desc: Test gen auth msg without token.
475 * @tc.type: FUNC
476 */
477 HWTEST_F(AttestTddTest, TestGenActiveMsg002, TestSize.Level1)
478 {
479 AttestSetMockReadTokenRet(TOKEN_UNPRESET);
480 // 初始化参数
481 int32_t ret = InitSysData();
482 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
483
484 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_ACTIVE);
485 EXPECT_TRUE((reqMsg != nullptr));
486 if (reqMsg == nullptr) {
487 return;
488 }
489 char *outToken = reqMsg->tokenInfo.token;
490 EXPECT_TRUE(outToken != nullptr);
491 if (outToken == nullptr) {
492 FREE_DEVICE_PACKET(reqMsg);
493 return;
494 }
495 #if defined(__ATTEST_ENABLE_PRESET_TOKEN__)
496 EXPECT_TRUE(strcmp(ATTEST_ACTIVE_GEN_ONLINE_TOKEN, outToken) == 0);
497 #else
498 EXPECT_TRUE(strcmp(ATTEST_ACTIVE_GEN_PRODUCT_TOKEN, outToken) == 0);
499 #endif
500 FREE_DEVICE_PACKET(reqMsg);
501 // 恢复环境
502 DestroySysData();
503 }
504
505 /*
506 * @tc.name: TestParseActiveResult001
507 * @tc.desc: Test parse active result，result is ok.
508 * @tc.type: FUNC
509 */
510 HWTEST_F(AttestTddTest, TestParseActiveResult001, TestSize.Level1)
511 {
512 string input = "{\"errcode\":0}";
513 int32_t ret = ParseActiveResult(input.c_str());
514 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
515 input = "{\"errcode\":\"-32s\"}";
516 ret = ParseActiveResult(input.c_str());
517 EXPECT_TRUE((ret != DEVATTEST_SUCCESS));
518 }
519
520 /*
521 * @tc.name: TestGetChallenge001
522 * @tc.desc: Test get reset challenge.
523 * @tc.type: FUNC
524 */
525 HWTEST_F(AttestTddTest, TestGetChallenge001, TestSize.Level1)
526 {
527 // 初始化环境
528 int32_t ret = InitSysData();
529 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
530 (void)InitNetworkServerInfo();
531 (void)D2CConnect();
532
533 g_netType = ATTEST_GET_CHANLLEGE;
534 ChallengeResult* challenge = nullptr;
535 ret = GetChallenge(&challenge, ATTEST_ACTION_RESET);
536 EXPECT_TRUE(ret == ATTEST_OK);
537 EXPECT_TRUE(challenge != nullptr);
538 if (ret == ATTEST_OK && challenge != nullptr) {
539 EXPECT_TRUE(strcmp(ATTEST_RESET_EXPECT_CHAP, challenge->challenge) == 0);
540 FREE_CHALLENGE_RESULT(challenge);
541 }
542 // 恢复环境
543 DestroySysData();
544 EXPECT_TRUE(StrdupDevInfo(VERSION_ID) == nullptr);
545 }
546
547 /*
548 * @tc.name: TestSendResetMsg001
549 * @tc.desc: Test send reset msg.
550 * @tc.type: FUNC
551 */
552 HWTEST_F(AttestTddTest, TestSendResetMsg001, TestSize.Level1)
553 {
554 // 初始化环境
555 int32_t ret = InitSysData();
556 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
557 (void)InitNetworkServerInfo();
558 (void)D2CConnect();
559
560 g_netType = ATTEST_RESET;
561 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_RESET);
562 if (reqMsg == nullptr) {
563 return;
564 }
565 char* respMsg = nullptr;
566 ret = SendResetMsg(reqMsg, &respMsg);
567 EXPECT_TRUE((ret == ATTEST_OK) && (respMsg != nullptr));
568 FREE_DEVICE_PACKET(reqMsg);
569 if ((ret == ATTEST_OK) && (respMsg != nullptr)) {
570 EXPECT_TRUE(strstr(respMsg, ATTEST_REST_ERROR_EXPECT_RESULT) != nullptr);
571 free(respMsg);
572 }
573 // 恢复环境
574 DestroySysData();
575 EXPECT_TRUE(StrdupDevInfo(VERSION_ID) == nullptr);
576 }
577
578 /*
579 * @tc.name: TestSendActiveMsg001
580 * @tc.desc: Test send active msg.
581 * @tc.type: FUNC
582 */
583 HWTEST_F(AttestTddTest, TestSendActiveMsg001, TestSize.Level1)
584 {
585 // 初始化环境
586 int32_t ret = InitSysData();
587 EXPECT_TRUE(ret == DEVATTEST_SUCCESS);
588
589 (void)InitNetworkServerInfo();
590 (void)D2CConnect();
591
592 g_netType = ATTEST_ACTIVE;
593 DevicePacket* reqMsg = TddGenMsg(ATTEST_CASE_ACTIVE);
594 ASSERT_TRUE(reqMsg != nullptr);
595
596 char* respMsg = nullptr;
597 ret = SendActiveMsg(reqMsg, &respMsg);
598 EXPECT_TRUE((ret == ATTEST_OK) && (respMsg != nullptr));
599 FREE_DEVICE_PACKET(reqMsg);
600 if ((ret == ATTEST_OK) && (respMsg != nullptr)) {
601 const char* ATTEST_ACTIVE_EXPECT_RESULT = "{\"errcode\":0}";
602 EXPECT_TRUE(strcmp(ATTEST_ACTIVE_EXPECT_RESULT, respMsg) == 0);
603 free(respMsg);
604 }
605 // 恢复环境
606 DestroySysData();
607 EXPECT_TRUE(StrdupDevInfo(VERSION_ID) == nullptr);
608 }
609
610 /*
611 * @tc.name: TestQueryAttestStatus001
612 * @tc.desc: Test query attest status.
613 * @tc.type: FUNC
614 */
615 HWTEST_F(AttestTddTest, TestQueryAttestStatus001, TestSize.Level1)
616 {
617 AuthResult *authResult = GetAuthResult();
618 if (authResult == nullptr) {
619 return;
620 }
621 int32_t ret = FlushToken(authResult);
622 EXPECT_TRUE((ret == DEVATTEST_SUCCESS));
623 uint8_t authResultCode = ATTEST_RESULT_CODE;
624 AttestWriteAuthResultCode((char*)&authResultCode, 1);
625 AttestResultInfo attestResultInfo = { .softwareResultDetail = {-2, -2, -2, -2, -2} };
626 attestResultInfo.ticket = nullptr;
627 ret = EntryGetAttestStatus(&attestResultInfo);
628 EXPECT_TRUE((ret == ATTEST_OK) && (attestResultInfo.authResult == ATTEST_OK));
629 EXPECT_TRUE((attestResultInfo.ticket != nullptr));
630 if (attestResultInfo.ticket == nullptr) {
631 return;
632 }
633 EXPECT_TRUE(strcmp(attestResultInfo.ticket, ATTEST_MOCK_HAL_TICKET) == 0);
634 }
635 }
636 }