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 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
349 return;
350 }
351 int32_t 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 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
372 return;
373 }
374 int32_t 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 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
395 return;
396 }
397 int32_t 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 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
420 return;
421 }
422 int32_t 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 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
445 return;
446 }
447 int32_t 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 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
470 return;
471 }
472
473 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList);
474 EXPECT_NE(ret, CM_SUCCESS);
475 }
476
477 /**
478 * @tc.name: CmIpcClientTest020
479 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
480 * @tc.type: FUNC
481 * @tc.require: AR000H0MIA /SR000H09NA
482 */
483 HWTEST_F(CmLogTest, CmIpcClientTest020, TestSize.Level0)
484 {
485 struct CertAbstract abstract = { {0}, {0}, false, {0} };
486 struct CertList certificateList = { 1, &abstract };
487
488 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
489 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
490
491 /* uriLen invalid */
492 struct CertInfoLen infoLen = {
493 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME, true, 0, true, MAX_LEN_URI + 1, false, 0
494 };
495 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
496 return;
497 }
498 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList);
499 EXPECT_NE(ret, CM_SUCCESS);
500 }
501
502 /**
503 * @tc.name: CmIpcClientTest021
504 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
505 * @tc.type: FUNC
506 * @tc.require: AR000H0MIA /SR000H09NA
507 */
508 HWTEST_F(CmLogTest, CmIpcClientTest021, TestSize.Level0)
509 {
510 struct CertAbstract abstract = { {0}, {0}, false, {0} };
511 struct CertList certificateList = { 1, &abstract };
512
513 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
514 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
515
516 /* get aliasLen failed */
517 struct CertInfoLen infoLen = {
518 true, certificateList.certsCount, true, MAX_LEN_SUBJECT_NAME, true, 0, true, MAX_LEN_URI, false, 0
519 };
520 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
521 return;
522 }
523 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList);
524 EXPECT_NE(ret, CM_SUCCESS);
525 }
526
527 /**
528 * @tc.name: CmIpcClientTest022
529 * @tc.desc: TestIpcClient: CmCertificateListUnpackFromService
530 * @tc.type: FUNC
531 * @tc.require: AR000H0MIA /SR000H09NA
532 */
533 HWTEST_F(CmLogTest, CmIpcClientTest022, TestSize.Level0)
534 {
535 struct CertAbstract abstract = { {0}, {0}, false, {0} };
536 struct CertList certificateList = { 1, &abstract };
537
538 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
539 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
540
541 /* aliasLen invalid */
542 struct CertInfoLen infoLen = {
543 true, 1, true, MAX_LEN_SUBJECT_NAME, true, 0, true, MAX_LEN_URI, true, MAX_LEN_CERT_ALIAS + 1
544 };
545 if (ConstructBuf(&infoLen, &outData) != CM_SUCCESS) {
546 return;
547 }
548 int32_t ret = CmCertificateListUnpackFromService(&outData, &certificateList);
549 EXPECT_NE(ret, CM_SUCCESS);
550 }
551
552 /**
553 * @tc.name: CmIpcClientTest023
554 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
555 * @tc.type: FUNC
556 * @tc.require: AR000H0MIA /SR000H09NA
557 */
558 HWTEST_F(CmLogTest, CmIpcClientTest023, TestSize.Level0)
559 {
560 struct CertInfo certInfoStr;
561 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
562
563 uint8_t certInfoData[DEFAULT_SIZE] = {0};
564 certInfoStr.certInfo.size = 0; /* certInfo size invalid */
565 certInfoStr.certInfo.data = certInfoData;
566
567 uint8_t certUriData[] = "oh:t=ak;o=Test023;a=100;u=100";
568 struct CmBlob certUri = { sizeof(certUriData), certUriData };
569
570 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
571 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
572
573 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
574 EXPECT_NE(ret, CM_SUCCESS);
575 }
576
577 /**
578 * @tc.name: CmIpcClientTest024
579 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
580 * @tc.type: FUNC
581 * @tc.require: AR000H0MIA /SR000H09NA
582 */
583 HWTEST_F(CmLogTest, CmIpcClientTest024, TestSize.Level0)
584 {
585 struct CertInfo certInfoStr;
586 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
587
588 uint8_t certInfoData[DEFAULT_SIZE] = {0};
589 certInfoStr.certInfo.size = sizeof(certInfoData);
590 certInfoStr.certInfo.data = nullptr; /* certInfo data invalid */
591
592 uint8_t certUriData[] = "oh:t=ak;o=Test024;a=100;u=100";
593 struct CmBlob certUri = { sizeof(certUriData), certUriData };
594
595 uint8_t outDataBuf[DEFAULT_SIZE] = { 0 };
596 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
597
598 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
599 EXPECT_NE(ret, CM_SUCCESS);
600 }
601
602 /**
603 * @tc.name: CmIpcClientTest025
604 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
605 * @tc.type: FUNC
606 * @tc.require: AR000H0MIA /SR000H09NA
607 */
608 HWTEST_F(CmLogTest, CmIpcClientTest025, TestSize.Level0)
609 {
610 struct CertInfo certInfoStr;
611 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
612
613 uint8_t certInfoData[] = { 0x01, 0x02, 0x03 };
614 certInfoStr.certInfo.size = sizeof(certInfoData);
615 certInfoStr.certInfo.data = certInfoData;
616
617 uint8_t certUriData[] = "oh:t=ak;o=Test025;a=100;u=100";
618 struct CmBlob certUri = { sizeof(certUriData), certUriData };
619
620 uint8_t outDataBuf[] = { 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
621 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf }; /* copy certInfo data failed */
622
623 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
624 EXPECT_NE(ret, CM_SUCCESS);
625 }
626
627 /**
628 * @tc.name: CmIpcClientTest026
629 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
630 * @tc.type: FUNC
631 * @tc.require: AR000H0MIA /SR000H09NA
632 */
633 HWTEST_F(CmLogTest, CmIpcClientTest026, TestSize.Level0)
634 {
635 struct CertInfo certInfoStr;
636 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
637
638 uint8_t certInfoData[DEFAULT_SIZE] = {0};
639 certInfoStr.certInfo.size = sizeof(certInfoData);
640 certInfoStr.certInfo.data = certInfoData;
641
642 uint8_t certUriData[] = "oh:t=ak;o=Test026;a=100;u=100";
643 struct CmBlob certUri = { sizeof(certUriData), certUriData };
644
645 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
646 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf }; /* invalid certInfo */
647
648 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
649 EXPECT_NE(ret, CM_SUCCESS);
650 }
651
652 /**
653 * @tc.name: CmIpcClientTest027
654 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
655 * @tc.type: FUNC
656 * @tc.require: AR000H0MIA /SR000H09NA
657 */
658 HWTEST_F(CmLogTest, CmIpcClientTest027, TestSize.Level0)
659 {
660 struct CertInfo certInfoStr;
661 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
662
663 uint8_t certInfoData[DEFAULT_SIZE] = {0};
664 certInfoStr.certInfo.size = sizeof(certInfoData);
665 certInfoStr.certInfo.data = certInfoData;
666
667 uint8_t certUriData[] = "oh:t=ak;o=Test027;a=100;u=100";
668 struct CmBlob certUri = { sizeof(certUriData), certUriData };
669
670 uint8_t outDataBuf[] = { 0x01, 0x02, 0x03 }; /* invalid certInfo size */
671 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
672
673 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
674 EXPECT_NE(ret, CM_SUCCESS);
675 }
676
677 /**
678 * @tc.name: CmIpcClientTest028
679 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
680 * @tc.type: FUNC
681 * @tc.require: AR000H0MIA /SR000H09NA
682 */
683 HWTEST_F(CmLogTest, CmIpcClientTest028, TestSize.Level0)
684 {
685 struct CertInfo certInfoStr;
686 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
687
688 uint8_t certInfoData[DEFAULT_SIZE] = {0};
689 certInfoStr.certInfo.size = sizeof(certInfoData);
690 certInfoStr.certInfo.data = certInfoData;
691
692 uint8_t certUriData[] = "oh:t=ak;o=Test028;a=100;u=100";
693 struct CmBlob certUri = { sizeof(certUriData), certUriData };
694
695 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
696 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
697 struct CertInfoLen infoLen = { false, 0, false, 0, false, 0, false, 0, false, 0 }; /* get status failed */
698 if (ConstructCertBuf(&infoLen, &outData) != CM_SUCCESS) {
699 return;
700 }
701
702 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
703 EXPECT_NE(ret, CM_SUCCESS);
704 }
705
706 /**
707 * @tc.name: CmIpcClientTest029
708 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
709 * @tc.type: FUNC
710 * @tc.require: AR000H0MIA /SR000H09NA
711 */
712 HWTEST_F(CmLogTest, CmIpcClientTest029, TestSize.Level0)
713 {
714 struct CertInfo certInfoStr;
715 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
716
717 uint8_t certInfoData[DEFAULT_SIZE] = {0};
718 certInfoStr.certInfo.size = sizeof(certInfoData);
719 certInfoStr.certInfo.data = certInfoData;
720
721 uint8_t certUriData[] = "oh:t=ak;o=Test029;a=100;u=100";
722 struct CmBlob certUri = { sizeof(certUriData), certUriData };
723
724 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
725 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
726 struct CertInfoLen infoLen = { false, 0, false, 0, true, 0, false, 0, false, 0 }; /* get certAliasLen failed */
727 if (ConstructCertBuf(&infoLen, &outData) != CM_SUCCESS) {
728 return;
729 }
730
731 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
732 EXPECT_NE(ret, CM_SUCCESS);
733 }
734
735 /**
736 * @tc.name: CmIpcClientTest030
737 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
738 * @tc.type: FUNC
739 * @tc.require: AR000H0MIA /SR000H09NA
740 */
741 HWTEST_F(CmLogTest, CmIpcClientTest030, TestSize.Level0)
742 {
743 struct CertInfo certInfoStr;
744 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
745
746 uint8_t certInfoData[DEFAULT_SIZE] = {0};
747 certInfoStr.certInfo.size = sizeof(certInfoData);
748 certInfoStr.certInfo.data = certInfoData;
749
750 uint8_t certUriData[] = "oh:t=ak;o=Test030;a=100;u=100";
751 struct CmBlob certUri = { sizeof(certUriData), certUriData };
752
753 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
754 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
755
756 /* certAlias len invalid */
757 struct CertInfoLen infoLen = { false, 0, false, 0, true, 0, false, 0, true, MAX_LEN_CERT_ALIAS + 1 };
758 if (ConstructCertBuf(&infoLen, &outData) != CM_SUCCESS) {
759 return;
760 }
761
762 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
763 EXPECT_NE(ret, CM_SUCCESS);
764 }
765
766 /**
767 * @tc.name: CmIpcClientTest031
768 * @tc.desc: TestIpcClient: CmCertificateInfoUnpackFromService
769 * @tc.type: FUNC
770 * @tc.require: AR000H0MIA /SR000H09NA
771 */
772 HWTEST_F(CmLogTest, CmIpcClientTest031, TestSize.Level0)
773 {
774 struct CertInfo certInfoStr;
775 (void)memset_s(&certInfoStr, sizeof(certInfoStr), 0, sizeof(certInfoStr));
776
777 uint8_t certInfoData[DEFAULT_SIZE] = {0};
778 certInfoStr.certInfo.size = sizeof(certInfoData);
779 certInfoStr.certInfo.data = certInfoData;
780
781 uint8_t certUriData[MAX_LEN_URI + 1] = "oh:t=ak;o=Test031;a=100;u=100"; /* uri len invalid */
782 struct CmBlob certUri = { sizeof(certUriData), certUriData };
783
784 uint8_t outDataBuf[DEFAULT_SIZE] = {0};
785 struct CmBlob outData = { sizeof(outDataBuf), outDataBuf };
786 struct CertInfoLen infoLen = { false, 0, false, 0, true, 0, false, 0, true, MAX_LEN_CERT_ALIAS };
787 if (ConstructCertBuf(&infoLen, &outData) != CM_SUCCESS) {
788 return;
789 }
790
791 int32_t ret = CmCertificateInfoUnpackFromService(&outData, &certUri, &certInfoStr);
792 EXPECT_NE(ret, CM_SUCCESS);
793 }
794 }
795 // end of namespace
796