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 <gtest/gtest.h>
17
18 #include "cm_log.h"
19
20 #include "securec.h"
21
22 #include "cm_module_cert_data.h"
23 #include "cm_ipc_client_serialization.h"
24
25 using namespace testing::ext;
26 namespace {
27 static constexpr uint32_t DEFAULT_SIZE = 2048;
28 class CmLogTest : public testing::Test {
29 public:
30 static void SetUpTestCase(void);
31
32 static void TearDownTestCase(void);
33
34 void SetUp();
35
36 void TearDown();
37 };
38
SetUpTestCase(void)39 void CmLogTest::SetUpTestCase(void)
40 {
41 }
42
TearDownTestCase(void)43 void CmLogTest::TearDownTestCase(void)
44 {
45 }
46
SetUp()47 void CmLogTest::SetUp()
48 {
49 }
50
TearDown()51 void CmLogTest::TearDown()
52 {
53 }
54
55 struct CertInfoLen {
56 bool isCertCountValid;
57 uint32_t certCount;
58 bool isSubjectNameLenValid;
59 uint32_t subjectNameLen;
60 bool isStatusValid;
61 uint32_t status;
62 bool isUriLenValid;
63 uint32_t uriLen;
64 bool isAliasLenValid;
65 uint32_t aliasLen;
66 };
67
ConstructBuf(const struct CertInfoLen * input,struct CmBlob * outData)68 static int32_t ConstructBuf(const struct CertInfoLen *input, struct CmBlob *outData)
69 {
70 /* construct certCount */
71 uint32_t offset = 0;
72 if (!input->isCertCountValid) {
73 outData->size = sizeof(input->certCount) - 1;
74 return CM_SUCCESS;
75 }
76 if (memcpy_s(outData->data + offset, outData->size - offset, &input->certCount, sizeof(input->certCount)) != EOK) {
77 return CM_FAILURE;
78 }
79 offset += sizeof(input->certCount);
80
81 /* construct subjectName */
82 if (!input->isSubjectNameLenValid) {
83 outData->size = offset;
84 return CM_SUCCESS;
85 }
86 if (memcpy_s(outData->data + offset, outData->size - offset, &input->subjectNameLen,
87 sizeof(input->subjectNameLen)) != EOK) {
88 return CM_FAILURE;
89 }
90 offset += sizeof(input->subjectNameLen) + ALIGN_SIZE(input->subjectNameLen); /* len valid */
91
92 /* construct status */
93 if (!input->isStatusValid) {
94 outData->size = offset;
95 return CM_SUCCESS;
96 }
97 if (memcpy_s(outData->data + offset, outData->size - offset, &input->status, sizeof(input->status)) != EOK) {
98 return CM_FAILURE;
99 }
100 offset += sizeof(input->status);
101
102 /* construct uri */
103 if (!input->isUriLenValid) {
104 outData->size = offset;
105 return CM_SUCCESS;
106 }
107 if (memcpy_s(outData->data + offset, outData->size - offset, &input->uriLen, sizeof(input->uriLen)) != EOK) {
108 return CM_FAILURE;
109 }
110 offset += sizeof(input->uriLen) + ALIGN_SIZE(input->uriLen); /* len valid */
111
112 /* construct alias */
113 if (!input->isAliasLenValid) {
114 outData->size = offset;
115 return CM_SUCCESS;
116 }
117 if (memcpy_s(outData->data + offset, outData->size - offset, &input->aliasLen, sizeof(input->aliasLen)) != EOK) {
118 return CM_FAILURE;
119 }
120 offset += sizeof(input->aliasLen) + ALIGN_SIZE(input->aliasLen);
121 outData->size = offset;
122 return CM_SUCCESS;
123 }
124
ConstructCertBuf(const struct CertInfoLen * input,struct CmBlob * outBlob)125 static int32_t ConstructCertBuf(const struct CertInfoLen *input, struct CmBlob *outBlob)
126 {
127 /* copy certInfo data */
128 uint32_t offset = 0;
129 uint32_t certSize = sizeof(g_ed25519CaCert);
130 if (memcpy_s(outBlob->data + offset, outBlob->size - offset, &certSize, sizeof(certSize)) != EOK) {
131 return CM_FAILURE;
132 }
133 offset += sizeof(certSize);
134 if (memcpy_s(outBlob->data + offset, outBlob->size - offset, g_ed25519CaCert, sizeof(g_ed25519CaCert)) != EOK) {
135 return CM_FAILURE;
136 }
137 offset += ALIGN_SIZE(sizeof(g_ed25519CaCert));
138
139 /* copy status */
140 if (!input->isStatusValid) {
141 outBlob->size = offset;
142 return CM_SUCCESS;
143 }
144 if (memcpy_s(outBlob->data + offset, outBlob->size - offset, &input->status, sizeof(input->status)) != EOK) {
145 return CM_FAILURE;
146 }
147 offset += sizeof(input->status);
148
149 /* copy certAlias */
150 if (!input->isAliasLenValid) {
151 outBlob->size = offset;
152 return CM_SUCCESS;
153 }
154 if (memcpy_s(outBlob->data + offset, outBlob->size - offset, &input->aliasLen, sizeof(input->aliasLen)) != EOK) {
155 return CM_FAILURE;
156 }
157 offset += sizeof(input->aliasLen) + ALIGN_SIZE(input->aliasLen);
158 outBlob->size = offset;
159 return CM_SUCCESS;
160 }
161
162 /**
163 * @tc.name: CmIpcClientTest004
164 * @tc.desc: TestIpcClient: GetUint32FromBuffer
165 * @tc.type: FUNC
166 * @tc.require: AR000H0MIA /SR000H09NA
167 */
168 HWTEST_F(CmLogTest, CmIpcClientTest004, TestSize.Level0)
169 {
170 /* Test Log Warn */
171 CM_LOG_W("this is test for log");
172
173 /* Test Log ID INVALID */
174 CmLog(CM_LOG_LEVEL_D + 1, __func__, __LINE__, "this is test for default branch");
175
176 /* Test Log info length more than 512 */
177 CM_LOG_W("MoreThan512Bytes................................................"
178 "................................................................"
179 "................................................................"
180 "................................................................"
181 "................................................................"
182 "................................................................"
183 "................................................................"
184 "..................................................................");
185
186 uint8_t srcData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
187 struct CmBlob srcBlob = { sizeof(srcData), srcData };
188 uint32_t value = 0;
189 uint32_t srcOffset = sizeof(srcData) + 1; /* srcOffset invalid */
190 int32_t ret = GetUint32FromBuffer(&value, &srcBlob, &srcOffset);
191 EXPECT_NE(ret, CM_SUCCESS);
192 }
193
194 /**
195 * @tc.name: CmIpcClientTest05
196 * @tc.desc: TestIpcClient: GetUint32FromBuffer
197 * @tc.type: FUNC
198 * @tc.require: AR000H0MIA /SR000H09NA
199 */
200 HWTEST_F(CmLogTest, CmIpcClientTest005, TestSize.Level0)
201 {
202 uint8_t srcData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
203 struct CmBlob srcBlob = { sizeof(srcData), srcData };
204 uint32_t value = 0;
205 uint32_t srcOffset = sizeof(srcData) - 1; /* srcOffset invalid */
206 int32_t ret = GetUint32FromBuffer(&value, &srcBlob, &srcOffset);
207 EXPECT_NE(ret, CM_SUCCESS);
208 }
209
210 /**
211 * @tc.name: CmIpcClientTest006
212 * @tc.desc: TestIpcClient: CmGetBlobFromBuffer
213 * @tc.type: FUNC
214 * @tc.require: AR000H0MIA /SR000H09NA
215 */
216 HWTEST_F(CmLogTest, CmIpcClientTest006, TestSize.Level0)
217 {
218 uint8_t srcData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
219 struct CmBlob srcBlob = { sizeof(srcData), srcData };
220 struct CmBlob blob = { 0, nullptr };
221 uint32_t srcOffset = sizeof(srcData) + 1; /* srcOffset invalid */
222 int32_t ret = CmGetBlobFromBuffer(&blob, &srcBlob, &srcOffset);
223 EXPECT_NE(ret, CM_SUCCESS);
224 }
225
226 /**
227 * @tc.name: CmIpcClientTest007
228 * @tc.desc: TestIpcClient: CmGetBlobFromBuffer
229 * @tc.type: FUNC
230 * @tc.require: AR000H0MIA /SR000H09NA
231 */
232 HWTEST_F(CmLogTest, CmIpcClientTest007, TestSize.Level0)
233 {
234 uint8_t srcData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
235 struct CmBlob srcBlob = { sizeof(srcData), srcData };
236 struct CmBlob blob = { 0, nullptr };
237 uint32_t srcOffset = sizeof(srcData) - 1; /* srcOffset invalid */
238 int32_t ret = CmGetBlobFromBuffer(&blob, &srcBlob, &srcOffset);
239 EXPECT_NE(ret, CM_SUCCESS);
240 }
241
242 /**
243 * @tc.name: CmIpcClientTest008
244 * @tc.desc: TestIpcClient: CmGetBlobFromBuffer
245 * @tc.type: FUNC
246 * @tc.require: AR000H0MIA /SR000H09NA
247 */
248 HWTEST_F(CmLogTest, CmIpcClientTest008, TestSize.Level0)
249 {
250 uint8_t srcData[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
251 struct CmBlob srcBlob = { sizeof(srcData), srcData }; /* srcData first 4 bytes invalid */
252 struct CmBlob blob = { 0, nullptr };
253 uint32_t srcOffset = 0;
254 int32_t ret = CmGetBlobFromBuffer(&blob, &srcBlob, &srcOffset);
255 EXPECT_NE(ret, CM_SUCCESS);
256 }
257
258 /**
259 * @tc.name: CmIpcClientTest009
260 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
261 * @tc.type: FUNC
262 * @tc.require: AR000H0MIA /SR000H09NA
263 */
264 HWTEST_F(CmLogTest, CmIpcClientTest009, TestSize.Level0)
265 {
266 struct CertAbstract abstract = { {0}, {0}, false, {0} };
267 struct CertList certificateList = { 1, &abstract };
268 int32_t ret = CmCertificateListUnpackFromService(nullptr, &certificateList); /* outData invalid */
269 EXPECT_NE(ret, CM_SUCCESS);
270 }
271
272 /**
273 * @tc.name: CmIpcClientTest010
274 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
275 * @tc.type: FUNC
276 * @tc.require: AR000H0MIA /SR000H09NA
277 */
278 HWTEST_F(CmLogTest, CmIpcClientTest010, TestSize.Level0)
279 {
280 struct CmBlob outData = { 1, nullptr }; /* outData data invalid */
281 struct CertAbstract abstract = { {0}, {0}, false, {0} };
282 struct CertList certificateList = { 1, &abstract };
283 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList);
284 EXPECT_NE(ret, CM_SUCCESS);
285 }
286
287 /**
288 * @tc.name: CmIpcClientTest011
289 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
290 * @tc.type: FUNC
291 * @tc.require: AR000H0MIA /SR000H09NA
292 */
293 HWTEST_F(CmLogTest, CmIpcClientTest011, TestSize.Level0)
294 {
295 uint8_t outDataBuf[] = { 0xaa };
296 struct CmBlob outData = { 0, outDataBuf }; /* outData size invalid */
297 struct CertAbstract abstract = { {0}, {0}, false, {0} };
298 struct CertList certificateList = { 1, &abstract };
299 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList);
300 EXPECT_NE(ret, CM_SUCCESS);
301 }
302
303 /**
304 * @tc.name: CmIpcClientTest012
305 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
306 * @tc.type: FUNC
307 * @tc.require: AR000H0MIA /SR000H09NA
308 */
309 HWTEST_F(CmLogTest, CmIpcClientTest012, TestSize.Level0)
310 {
311 uint8_t outDataBuf[] = { 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
312 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
313 int32_t ret = CmCertificateListUnpackFromService(&outData, nullptr); /* certificateList invalid */
314 EXPECT_NE(ret, CM_SUCCESS);
315 }
316
317 /**
318 * @tc.name: CmIpcClientTest013
319 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
320 * @tc.type: FUNC
321 * @tc.require: AR000H0MIA /SR000H09NA
322 */
323 HWTEST_F(CmLogTest, CmIpcClientTest013, TestSize.Level0)
324 {
325 uint8_t outDataBuf[] = { 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff };
326 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
327 struct CertList certificateList = { 0, nullptr };
328 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList); /* abstract invalid */
329 EXPECT_NE(ret, CM_SUCCESS);
330 }
331
332 /**
333 * @tc.name: CmIpcClientTest014
334 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
335 * @tc.type: FUNC
336 * @tc.require: AR000H0MIA /SR000H09NA
337 */
338 HWTEST_F(CmLogTest, CmIpcClientTest014, TestSize.Level0)
339 {
340 struct CertAbstract abstract = { {0}, {0}, false, {0} };
341 struct CertList certificateList = { 1, &abstract };
342
343 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
344 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
345
346 /* get certCount failed */
347 struct CertInfoLen infoLen = { false, 0, false, 0, false, 0, false, 0, false, 0 };
348 int32_t ret = ConstructBuf(&infoLen, &outData);
349 ASSERT_EQ(ret, CM_SUCCESS);
350
351 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
352 EXPECT_NE(ret, CM_SUCCESS);
353 }
354
355 /**
356 * @tc.name: CmIpcClientTest015
357 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
358 * @tc.type: FUNC
359 * @tc.require: AR000H0MIA /SR000H09NA
360 */
361 HWTEST_F(CmLogTest, CmIpcClientTest015, TestSize.Level0)
362 {
363 struct CertAbstract abstract = { {0}, {0}, false, {0} };
364 struct CertList certificateList = { 1, &abstract };
365
366 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
367 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
368
369 /* certCount invalid */
370 struct CertInfoLen infoLen = { true, certificateList.certsCount + 1, false, 0, false, 0, false, 0, false, 0 };
371 int32_t ret = ConstructBuf(&infoLen, &outData);
372 ASSERT_EQ(ret, CM_SUCCESS);
373
374 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
375 EXPECT_NE(ret, CM_SUCCESS);
376 }
377
378 /**
379 * @tc.name: CmIpcClientTest016
380 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
381 * @tc.type: FUNC
382 * @tc.require: AR000H0MIA /SR000H09NA
383 */
384 HWTEST_F(CmLogTest, CmIpcClientTest016, TestSize.Level0)
385 {
386 struct CertAbstract abstract = { {0}, {0}, false, {0} };
387 struct CertList certificateList = { 1, &abstract };
388
389 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
390 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
391
392 /* get subjectNameLen failed */
393 struct CertInfoLen infoLen = { true, certificateList.certsCount, false, 0, false, 0, false, 0, false, 0 };
394 int32_t ret = ConstructBuf(&infoLen, &outData);
395 ASSERT_EQ(ret, CM_SUCCESS);
396
397 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
398 EXPECT_NE(ret, CM_SUCCESS);
399 }
400
401 /**
402 * @tc.name: CmIpcClientTest017
403 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
404 * @tc.type: FUNC
405 * @tc.require: AR000H0MIA /SR000H09NA
406 */
407 HWTEST_F(CmLogTest, CmIpcClientTest017, TestSize.Level0)
408 {
409 struct CertAbstract abstract = { {0}, {0}, false, {0} };
410 struct CertList certificateList = { 1, &abstract };
411
412 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
413 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
414
415 /* subjectNameLen invalid */
416 struct CertInfoLen infoLen = {
417 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME + 1, false, 0, false, 0, false, 0
418 };
419 int32_t ret = ConstructBuf(&infoLen, &outData);
420 ASSERT_EQ(ret, CM_SUCCESS);
421
422 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
423 EXPECT_NE(ret, CM_SUCCESS);
424 }
425
426 /**
427 * @tc.name: CmIpcClientTest018
428 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
429 * @tc.type: FUNC
430 * @tc.require: AR000H0MIA /SR000H09NA
431 */
432 HWTEST_F(CmLogTest, CmIpcClientTest018, TestSize.Level0)
433 {
434 struct CertAbstract abstract = { {0}, {0}, false, {0} };
435 struct CertList certificateList = { 1, &abstract };
436
437 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
438 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
439
440 /* get status failed */
441 struct CertInfoLen infoLen = {
442 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME, false, 0, false, 0, false, 0
443 };
444 int32_t ret = ConstructBuf(&infoLen, &outData);
445 ASSERT_EQ(ret, CM_SUCCESS);
446
447 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
448 EXPECT_NE(ret, CM_SUCCESS);
449 }
450
451 /**
452 * @tc.name: CmIpcClientTest019
453 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
454 * @tc.type: FUNC
455 * @tc.require: AR000H0MIA /SR000H09NA
456 */
457 HWTEST_F(CmLogTest, CmIpcClientTest019, TestSize.Level0)
458 {
459 struct CertAbstract abstract = { {0}, {0}, false, {0} };
460 struct CertList certificateList = { 1, &abstract };
461
462 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
463 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
464
465 /* get uriLen failed */
466 struct CertInfoLen infoLen = {
467 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME, true, 0, false, 0, false, 0
468 };
469 int32_t ret = ConstructBuf(&infoLen, &outData);
470 ASSERT_EQ(ret, CM_SUCCESS);
471
472 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
473 EXPECT_NE(ret, CM_SUCCESS);
474 }
475
476 /**
477 * @tc.name: CmIpcClientTest020
478 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
479 * @tc.type: FUNC
480 * @tc.require: AR000H0MIA /SR000H09NA
481 */
482 HWTEST_F(CmLogTest, CmIpcClientTest020, TestSize.Level0)
483 {
484 struct CertAbstract abstract = { {0}, {0}, false, {0} };
485 struct CertList certificateList = { 1, &abstract };
486
487 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
488 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
489
490 /* uriLen invalid */
491 struct CertInfoLen infoLen = {
492 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME, true, 0, true, MAX_LEN_URI + 1, false, 0
493 };
494 int32_t ret = ConstructBuf(&infoLen, &outData);
495 ASSERT_EQ(ret, CM_SUCCESS);
496
497 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
498 EXPECT_NE(ret, CM_SUCCESS);
499 }
500
501 /**
502 * @tc.name: CmIpcClientTest021
503 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
504 * @tc.type: FUNC
505 * @tc.require: AR000H0MIA /SR000H09NA
506 */
507 HWTEST_F(CmLogTest, CmIpcClientTest021, TestSize.Level0)
508 {
509 struct CertAbstract abstract = { {0}, {0}, false, {0} };
510 struct CertList certificateList = { 1, &abstract };
511
512 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
513 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
514
515 /* get aliasLen failed */
516 struct CertInfoLen infoLen = {
517 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME, true, 0, true, MAX_LEN_URI, false, 0
518 };
519 int32_t ret = ConstructBuf(&infoLen, &outData);
520 ASSERT_EQ(ret, CM_SUCCESS);
521
522 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
523 EXPECT_NE(ret, CM_SUCCESS);
524 }
525
526 /**
527 * @tc.name: CmIpcClientTest022
528 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
529 * @tc.type: FUNC
530 * @tc.require: AR000H0MIA /SR000H09NA
531 */
532 HWTEST_F(CmLogTest, CmIpcClientTest022, TestSize.Level0)
533 {
534 struct CertAbstract abstract = { {0}, {0}, false, {0} };
535 struct CertList certificateList = { 1, &abstract };
536
537 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
538 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
539
540 /* aliasLen invalid */
541 struct CertInfoLen infoLen = {
542 true, 1, true, MAX_LEN_SUBJECT_NAME, true, 0, true, MAX_LEN_URI, true, MAX_LEN_CERT_ALIAS + 1
543 };
544 int32_t ret = ConstructBuf(&infoLen, &outData);
545 ASSERT_EQ(ret, CM_SUCCESS);
546
547 ret = CmCertificateListUnpackFromService(&outData, &certificateList);
548 EXPECT_NE(ret, CM_SUCCESS);
549 }
550
551 /**
552 * @tc.name: CmIpcClientTest023
553 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
554 * @tc.type: FUNC
555 * @tc.require: AR000H0MIA /SR000H09NA
556 */
557 HWTEST_F(CmLogTest, CmIpcClientTest023, TestSize.Level0)
558 {
559 struct CertInfo certInfoStr;
560 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
561
562 uint8_t certInfoData[DEFAULT_SIZE] = {0};
563 certInfoStr.certInfo.size = 0; /* certInfo size invalid */
564 certInfoStr.certInfo.data = certInfoData;
565
566 uint8_t certUriData[] = "oh:t=ak;o=Test023;a=100;u=100";
567 struct CmBlob certUri = { sizeof(certUriData), certUriData };
568
569 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
570 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
571
572 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
573 EXPECT_NE(ret, CM_SUCCESS);
574 }
575
576 /**
577 * @tc.name: CmIpcClientTest024
578 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
579 * @tc.type: FUNC
580 * @tc.require: AR000H0MIA /SR000H09NA
581 */
582 HWTEST_F(CmLogTest, CmIpcClientTest024, TestSize.Level0)
583 {
584 struct CertInfo certInfoStr;
585 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
586
587 uint8_t certInfoData[DEFAULT_SIZE] = {0};
588 certInfoStr.certInfo.size = sizeof(certInfoData);
589 certInfoStr.certInfo.data = nullptr; /* certInfo data invalid */
590
591 uint8_t certUriData[] = "oh:t=ak;o=Test024;a=100;u=100";
592 struct CmBlob certUri = { sizeof(certUriData), certUriData };
593
594 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
595 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
596
597 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
598 EXPECT_NE(ret, CM_SUCCESS);
599 }
600
601 /**
602 * @tc.name: CmIpcClientTest025
603 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
604 * @tc.type: FUNC
605 * @tc.require: AR000H0MIA /SR000H09NA
606 */
607 HWTEST_F(CmLogTest, CmIpcClientTest025, TestSize.Level0)
608 {
609 struct CertInfo certInfoStr;
610 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
611
612 uint8_t certInfoData[] = { 0x01, 0x02, 0x03 };
613 certInfoStr.certInfo.size = sizeof(certInfoData);
614 certInfoStr.certInfo.data = certInfoData;
615
616 uint8_t certUriData[] = "oh:t=ak;o=Test025;a=100;u=100";
617 struct CmBlob certUri = { sizeof(certUriData), certUriData };
618
619 uint8_t outDataBuf[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
620 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf }; /* copy certInfo data failed */
621
622 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
623 EXPECT_NE(ret, CM_SUCCESS);
624 }
625
626 /**
627 * @tc.name: CmIpcClientTest026
628 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
629 * @tc.type: FUNC
630 * @tc.require: AR000H0MIA /SR000H09NA
631 */
632 HWTEST_F(CmLogTest, CmIpcClientTest026, TestSize.Level0)
633 {
634 struct CertInfo certInfoStr;
635 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
636
637 uint8_t certInfoData[DEFAULT_SIZE] = {0};
638 certInfoStr.certInfo.size = sizeof(certInfoData);
639 certInfoStr.certInfo.data = certInfoData;
640
641 uint8_t certUriData[] = "oh:t=ak;o=Test026;a=100;u=100";
642 struct CmBlob certUri = { sizeof(certUriData), certUriData };
643
644 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
645 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf }; /* invalid certInfo */
646
647 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
648 EXPECT_NE(ret, CM_SUCCESS);
649 }
650
651 /**
652 * @tc.name: CmIpcClientTest027
653 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
654 * @tc.type: FUNC
655 * @tc.require: AR000H0MIA /SR000H09NA
656 */
657 HWTEST_F(CmLogTest, CmIpcClientTest027, TestSize.Level0)
658 {
659 struct CertInfo certInfoStr;
660 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
661
662 uint8_t certInfoData[DEFAULT_SIZE] = {0};
663 certInfoStr.certInfo.size = sizeof(certInfoData);
664 certInfoStr.certInfo.data = certInfoData;
665
666 uint8_t certUriData[] = "oh:t=ak;o=Test027;a=100;u=100";
667 struct CmBlob certUri = { sizeof(certUriData), certUriData };
668
669 uint8_t outDataBuf[] = { 0x01, 0x02, 0x03 }; /* invalid certInfo size */
670 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
671
672 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
673 EXPECT_NE(ret, CM_SUCCESS);
674 }
675
676 /**
677 * @tc.name: CmIpcClientTest028
678 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
679 * @tc.type: FUNC
680 * @tc.require: AR000H0MIA /SR000H09NA
681 */
682 HWTEST_F(CmLogTest, CmIpcClientTest028, TestSize.Level0)
683 {
684 struct CertInfo certInfoStr;
685 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
686
687 uint8_t certInfoData[DEFAULT_SIZE] = {0};
688 certInfoStr.certInfo.size = sizeof(certInfoData);
689 certInfoStr.certInfo.data = certInfoData;
690
691 uint8_t certUriData[] = "oh:t=ak;o=Test028;a=100;u=100";
692 struct CmBlob certUri = { sizeof(certUriData), certUriData };
693
694 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
695 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
696 struct CertInfoLen infoLen = { false, 0, false, 0, false, 0, false, 0, false, 0 }; /* get status failed */
697 int32_t ret = ConstructCertBuf(&infoLen, &outData);
698 ASSERT_EQ(ret, CM_SUCCESS);
699
700 ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
701 EXPECT_NE(ret, CM_SUCCESS);
702 }
703
704 /**
705 * @tc.name: CmIpcClientTest029
706 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
707 * @tc.type: FUNC
708 * @tc.require: AR000H0MIA /SR000H09NA
709 */
710 HWTEST_F(CmLogTest, CmIpcClientTest029, TestSize.Level0)
711 {
712 struct CertInfo certInfoStr;
713 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
714
715 uint8_t certInfoData[DEFAULT_SIZE] = {0};
716 certInfoStr.certInfo.size = sizeof(certInfoData);
717 certInfoStr.certInfo.data = certInfoData;
718
719 uint8_t certUriData[] = "oh:t=ak;o=Test029;a=100;u=100";
720 struct CmBlob certUri = { sizeof(certUriData), certUriData };
721
722 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
723 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
724 struct CertInfoLen infoLen = { false, 0, false, 0, true, 0, false, 0, false, 0 }; /* get certAliasLen failed */
725 int32_t ret = ConstructCertBuf(&infoLen, &outData);
726 ASSERT_EQ(ret, CM_SUCCESS);
727
728 ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
729 EXPECT_NE(ret, CM_SUCCESS);
730 }
731
732 /**
733 * @tc.name: CmIpcClientTest030
734 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
735 * @tc.type: FUNC
736 * @tc.require: AR000H0MIA /SR000H09NA
737 */
738 HWTEST_F(CmLogTest, CmIpcClientTest030, TestSize.Level0)
739 {
740 struct CertInfo certInfoStr;
741 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
742
743 uint8_t certInfoData[DEFAULT_SIZE] = {0};
744 certInfoStr.certInfo.size = sizeof(certInfoData);
745 certInfoStr.certInfo.data = certInfoData;
746
747 uint8_t certUriData[] = "oh:t=ak;o=Test030;a=100;u=100";
748 struct CmBlob certUri = { sizeof(certUriData), certUriData };
749
750 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
751 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
752
753 /* certAlias len invalid */
754 struct CertInfoLen infoLen = { false, 0, false, 0, true, 0, false, 0, true, MAX_LEN_CERT_ALIAS + 1 };
755 int32_t ret = ConstructCertBuf(&infoLen, &outData);
756 ASSERT_EQ(ret, CM_SUCCESS);
757
758 ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
759 EXPECT_NE(ret, CM_SUCCESS);
760 }
761
762 /**
763 * @tc.name: CmIpcClientTest031
764 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
765 * @tc.type: FUNC
766 * @tc.require: AR000H0MIA /SR000H09NA
767 */
768 HWTEST_F(CmLogTest, CmIpcClientTest031, TestSize.Level0)
769 {
770 struct CertInfo certInfoStr;
771 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
772
773 uint8_t certInfoData[DEFAULT_SIZE] = {0};
774 certInfoStr.certInfo.size = sizeof(certInfoData);
775 certInfoStr.certInfo.data = certInfoData;
776
777 uint8_t certUriData[MAX_LEN_URI + 1] = "oh:t=ak;o=Test031;a=100;u=100"; /* uri len invalid */
778 struct CmBlob certUri = { sizeof(certUriData), certUriData };
779
780 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
781 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
782 struct CertInfoLen infoLen = { false, 0, false, 0, true, 0, false, 0, true, MAX_LEN_CERT_ALIAS };
783 int32_t ret = ConstructCertBuf(&infoLen, &outData);
784 ASSERT_EQ(ret, CM_SUCCESS);
785
786 ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
787 EXPECT_NE(ret, CM_SUCCESS);
788 }
789 }
790 // end of namespace
791