1 /*
2 * Copyright (c) 2022-2025 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 <openssl/evp.h>
19 #include <openssl/x509.h>
20
21 #include "securec.h"
22
23 #include "cm_cert_data_part1_rsa.h"
24 #include "cm_module_cert_data.h"
25 #include "cm_pfx.h"
26 #include "cm_type.h"
27 #include "cm_x509.h"
28 #include "cm_cert_data_p7b.h"
29 #include "cm_cert_data_ed25519.h"
30 #include "cm_util.h"
31
32 using namespace testing::ext;
33 namespace {
34 static constexpr uint32_t STR_MAX_LEN = 10;
35
36 static constexpr uint32_t DEFAULT_SIZE = 1024;
37
38 class CmCertParseTest : public testing::Test {
39 public:
40 static void SetUpTestCase(void);
41
42 static void TearDownTestCase(void);
43
44 void SetUp();
45
46 void TearDown();
47 };
48
SetUpTestCase(void)49 void CmCertParseTest::SetUpTestCase(void)
50 {
51 }
52
TearDownTestCase(void)53 void CmCertParseTest::TearDownTestCase(void)
54 {
55 }
56
SetUp()57 void CmCertParseTest::SetUp()
58 {
59 }
60
TearDown()61 void CmCertParseTest::TearDown()
62 {
63 }
64
65 /**
66 * @tc.name: CmCertParseTest001
67 * @tc.desc: test InitCertContext certBuf nullptr
68 * @tc.type: FUNC
69 * @tc.require: AR000H0MIA /SR000H09NA
70 */
71 HWTEST_F(CmCertParseTest, CmCertParseTest001, TestSize.Level0)
72 {
73 X509 *x509 = InitCertContext(nullptr, 0);
74 EXPECT_EQ(x509, nullptr);
75 FreeCertContext(x509);
76 }
77
78 /**
79 * @tc.name: CmCertParseTest002
80 * @tc.desc: test InitCertContext size invalid
81 * @tc.type: FUNC
82 * @tc.require: AR000H0MIA /SR000H09NA
83 */
84 HWTEST_F(CmCertParseTest, CmCertParseTest002, TestSize.Level0)
85 {
86 uint8_t certBuf[] = "this is test for certBuf";
87 X509 *x509 = InitCertContext(certBuf, MAX_LEN_CERTIFICATE + 1);
88 EXPECT_EQ(x509, nullptr);
89 FreeCertContext(x509);
90 }
91
92 /**
93 * @tc.name: CmCertParseTest003
94 * @tc.desc: test InitCertContext cert buffer pem format invalid
95 * @tc.type: FUNC
96 * @tc.require: AR000H0MIA /SR000H09NA
97 */
98 HWTEST_F(CmCertParseTest, CmCertParseTest003, TestSize.Level0)
99 {
100 uint8_t certBuf[] = "this is test for certBuf";
101 certBuf[0] = '-';
102 X509 *x509 = InitCertContext(certBuf, sizeof(certBuf));
103 EXPECT_EQ(x509, nullptr);
104 FreeCertContext(x509);
105 }
106
107 /**
108 * @tc.name: CmCertParseTest004
109 * @tc.desc: test InitCertContext cert buffer der format invalid
110 * @tc.type: FUNC
111 * @tc.require: AR000H0MIA /SR000H09NA
112 */
113 HWTEST_F(CmCertParseTest, CmCertParseTest004, TestSize.Level0)
114 {
115 uint8_t certBuf[] = "this is test for certBuf";
116 certBuf[0] = ASN1_TAG_TYPE_SEQ;
117 X509 *x509 = InitCertContext(certBuf, sizeof(certBuf));
118 EXPECT_EQ(x509, nullptr);
119 FreeCertContext(x509);
120 }
121
122 /**
123 * @tc.name: CmCertParseTest005
124 * @tc.desc: test InitCertContext cert buffer not pem or der format
125 * @tc.type: FUNC
126 * @tc.require: AR000H0MIA /SR000H09NA
127 */
128 HWTEST_F(CmCertParseTest, CmCertParseTest005, TestSize.Level0)
129 {
130 uint8_t certBuf[] = "this is test for certBuf";
131 X509 *x509 = InitCertContext(certBuf, sizeof(certBuf));
132 EXPECT_EQ(x509, nullptr);
133 FreeCertContext(x509);
134 }
135
136 /**
137 * @tc.name: CmCertParseTest006
138 * @tc.desc: test GetX509SerialNumber x509 is nullptr
139 * @tc.type: FUNC
140 * @tc.require: AR000H0MIA /SR000H09NA
141 */
142 HWTEST_F(CmCertParseTest, CmCertParseTest006, TestSize.Level0)
143 {
144 char tmpSerialNumber[DEFAULT_SIZE] = {0};
145 int32_t ret = GetX509SerialNumber(nullptr, tmpSerialNumber, sizeof(tmpSerialNumber));
146 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
147 }
148
149 /**
150 * @tc.name: CmCertParseTest007
151 * @tc.desc: test GetX509SerialNumber outBuf is nullptr
152 * @tc.type: FUNC
153 * @tc.require: AR000H0MIA /SR000H09NA
154 */
155 HWTEST_F(CmCertParseTest, CmCertParseTest007, TestSize.Level0)
156 {
157 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
158 EXPECT_NE(x509, nullptr);
159
160 char tmpSerialNumber[DEFAULT_SIZE] = {0};
161 int32_t ret = GetX509SerialNumber(x509, nullptr, sizeof(tmpSerialNumber));
162 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
163
164 FreeCertContext(x509);
165 }
166
167 /**
168 * @tc.name: CmCertParseTest008
169 * @tc.desc: test GetX509SerialNumber outBufMaxSize is 0
170 * @tc.type: FUNC
171 * @tc.require: AR000H0MIA /SR000H09NA
172 */
173 HWTEST_F(CmCertParseTest, CmCertParseTest008, TestSize.Level0)
174 {
175 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
176 EXPECT_NE(x509, nullptr);
177
178 char tmpSerialNumber[DEFAULT_SIZE] = {0};
179 int32_t ret = GetX509SerialNumber(x509, tmpSerialNumber, 0);
180 EXPECT_EQ(ret, CMR_ERROR_BUFFER_TOO_SMALL);
181
182 FreeCertContext(x509);
183 }
184
185 /**
186 * @tc.name: CmCertParseTest009
187 * @tc.desc: test GetX509SubjectNameLongFormat outBufMaxSize is 0
188 * @tc.type: FUNC
189 * @tc.require: AR000H0MIA /SR000H09NA
190 */
191 HWTEST_F(CmCertParseTest, CmCertParseTest009, TestSize.Level0)
192 {
193 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
194 EXPECT_NE(x509, nullptr);
195
196 char tmpSubjectName[DEFAULT_SIZE] = {0};
197 int32_t ret = GetX509SubjectNameLongFormat(x509, tmpSubjectName, 0);
198 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
199
200 FreeCertContext(x509);
201 }
202
203 /**
204 * @tc.name: CmCertParseTest010
205 * @tc.desc: test GetX509SubjectNameLongFormat outBuf is nullptr
206 * @tc.type: FUNC
207 * @tc.require: AR000H0MIA /SR000H09NA
208 */
209 HWTEST_F(CmCertParseTest, CmCertParseTest010, TestSize.Level0)
210 {
211 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
212 EXPECT_NE(x509, nullptr);
213
214 char tmpSubjectName[DEFAULT_SIZE] = {0};
215 int32_t ret = GetX509SubjectNameLongFormat(x509, nullptr, sizeof(tmpSubjectName));
216 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
217
218 FreeCertContext(x509);
219 }
220
221 /**
222 * @tc.name: CmCertParseTest011
223 * @tc.desc: test GetX509SubjectNameLongFormat x509 is nullptr
224 * @tc.type: FUNC
225 * @tc.require: AR000H0MIA /SR000H09NA
226 */
227 HWTEST_F(CmCertParseTest, CmCertParseTest011, TestSize.Level0)
228 {
229 char tmpSubjectName[DEFAULT_SIZE] = {0};
230 int32_t ret = GetX509SubjectNameLongFormat(nullptr, tmpSubjectName, sizeof(tmpSubjectName));
231 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
232 }
233
234 /**
235 * @tc.name: CmCertParseTest012
236 * @tc.desc: test GetX509IssueNameLongFormat outBufMaxSize is 0
237 * @tc.type: FUNC
238 * @tc.require: AR000H0MIA /SR000H09NA
239 */
240 HWTEST_F(CmCertParseTest, CmCertParseTest012, TestSize.Level0)
241 {
242 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
243 EXPECT_NE(x509, nullptr);
244
245 char tmpIssueName[DEFAULT_SIZE] = {0};
246 int32_t ret = GetX509IssueNameLongFormat(x509, tmpIssueName, 0);
247 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
248
249 FreeCertContext(x509);
250 }
251
252 /**
253 * @tc.name: CmCertParseTest013
254 * @tc.desc: test GetX509IssueNameLongFormat outBuf is nullptr
255 * @tc.type: FUNC
256 * @tc.require: AR000H0MIA /SR000H09NA
257 */
258 HWTEST_F(CmCertParseTest, CmCertParseTest013, TestSize.Level0)
259 {
260 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
261 EXPECT_NE(x509, nullptr);
262
263 char tmpIssueName[DEFAULT_SIZE] = {0};
264 int32_t ret = GetX509IssueNameLongFormat(x509, nullptr, sizeof(tmpIssueName));
265 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
266
267 FreeCertContext(x509);
268 }
269
270 /**
271 * @tc.name: CmCertParseTest014
272 * @tc.desc: test GetX509IssueNameLongFormat x509 is nullptr
273 * @tc.type: FUNC
274 * @tc.require: AR000H0MIA /SR000H09NA
275 */
276 HWTEST_F(CmCertParseTest, CmCertParseTest014, TestSize.Level0)
277 {
278 char tmpIssueName[DEFAULT_SIZE] = {0};
279 int32_t ret = GetX509IssueNameLongFormat(nullptr, tmpIssueName, sizeof(tmpIssueName));
280 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
281 }
282
283 /**
284 * @tc.name: CmCertParseTest015
285 * @tc.desc: test GetX509NotBefore x509 is nullptr
286 * @tc.type: FUNC
287 * @tc.require: AR000H0MIA /SR000H09NA
288 */
289 HWTEST_F(CmCertParseTest, CmCertParseTest015, TestSize.Level0)
290 {
291 char tmpTimeOut[DEFAULT_SIZE] = {0};
292 int32_t ret = GetX509NotBefore(nullptr, tmpTimeOut, sizeof(tmpTimeOut));
293 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
294 }
295
296 /**
297 * @tc.name: CmCertParseTest016
298 * @tc.desc: test GetX509NotBefore size is 0
299 * @tc.type: FUNC
300 * @tc.require: AR000H0MIA /SR000H09NA
301 */
302 HWTEST_F(CmCertParseTest, CmCertParseTest016, TestSize.Level0)
303 {
304 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
305 EXPECT_NE(x509, nullptr);
306
307 char tmpTimeOut[DEFAULT_SIZE] = {0};
308 int32_t ret = GetX509NotBefore(x509, tmpTimeOut, 0);
309 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
310
311 FreeCertContext(x509);
312 }
313
314 /**
315 * @tc.name: CmCertParseTest017
316 * @tc.desc: test GetX509NotBefore outBuf is nullptr
317 * @tc.type: FUNC
318 * @tc.require: AR000H0MIA /SR000H09NA
319 */
320 HWTEST_F(CmCertParseTest, CmCertParseTest017, TestSize.Level0)
321 {
322 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
323 EXPECT_NE(x509, nullptr);
324
325 char tmpTimeOut[DEFAULT_SIZE] = {0};
326 int32_t ret = GetX509NotBefore(x509, nullptr, sizeof(tmpTimeOut));
327 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
328
329 FreeCertContext(x509);
330 }
331
332 /**
333 * @tc.name: CmCertParseTest018
334 * @tc.desc: test GetX509NotBefore size too small
335 * @tc.type: FUNC
336 * @tc.require: AR000H0MIA /SR000H09NA
337 */
338 HWTEST_F(CmCertParseTest, CmCertParseTest018, TestSize.Level0)
339 {
340 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
341 EXPECT_NE(x509, nullptr);
342
343 char tmpTimeOut[DEFAULT_SIZE] = {0};
344 int32_t ret = GetX509NotBefore(x509, tmpTimeOut, 1); /* buffer not enough */
345 EXPECT_EQ(ret, CMR_ERROR_BUFFER_TOO_SMALL);
346
347 FreeCertContext(x509);
348 }
349
350 /**
351 * @tc.name: CmCertParseTest019
352 * @tc.desc: test GetX509NotBefore x509 is invalid
353 * @tc.type: FUNC
354 * @tc.require: AR000H0MIA /SR000H09NA
355 */
356 HWTEST_F(CmCertParseTest, CmCertParseTest019, TestSize.Level0)
357 {
358 X509 *tempX509 = X509_new();
359 ASSERT_TRUE(tempX509 != nullptr);
360
361 char tmpTimeOut[DEFAULT_SIZE] = {0};
362 int32_t ret = GetX509NotBefore(tempX509, tmpTimeOut, sizeof(tmpTimeOut));
363 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT);
364
365 X509_free(tempX509);
366 }
367
368 /**
369 * @tc.name: CmCertParseTest020
370 * @tc.desc: test GetX509Fingerprint x509 is nullptr
371 * @tc.type: FUNC
372 * @tc.require: AR000H0MIA /SR000H09NA
373 */
374 HWTEST_F(CmCertParseTest, CmCertParseTest020, TestSize.Level0)
375 {
376 char tmpFinggerOut[DEFAULT_SIZE] = {0};
377 int32_t ret = GetX509Fingerprint(nullptr, tmpFinggerOut, sizeof(tmpFinggerOut));
378 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
379 }
380
381 /**
382 * @tc.name: CmCertParseTest021
383 * @tc.desc: test GetX509Fingerprint size too small
384 * @tc.type: FUNC
385 * @tc.require: AR000H0MIA /SR000H09NA
386 */
387 HWTEST_F(CmCertParseTest, CmCertParseTest021, TestSize.Level0)
388 {
389 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
390 EXPECT_NE(x509, nullptr);
391
392 char tmpFinggerOut[DEFAULT_SIZE] = {0};
393 int32_t ret = GetX509Fingerprint(x509, tmpFinggerOut, 1); /* buffer not enough */
394 EXPECT_EQ(ret, CMR_ERROR_BUFFER_TOO_SMALL);
395
396 FreeCertContext(x509);
397 }
398
399 /**
400 * @tc.name: CmCertParseTest022
401 * @tc.desc: test GetX509Fingerprint outBuf is nullptr
402 * @tc.type: FUNC
403 * @tc.require: AR000H0MIA /SR000H09NA
404 */
405 HWTEST_F(CmCertParseTest, CmCertParseTest022, TestSize.Level0)
406 {
407 X509 *x509 = InitCertContext(g_certData, sizeof(g_certData));
408 EXPECT_NE(x509, nullptr);
409
410 char tmpFinggerOut[DEFAULT_SIZE] = {0};
411 int32_t ret = GetX509Fingerprint(x509, nullptr, sizeof(tmpFinggerOut));
412 EXPECT_EQ(ret, CMR_ERROR_MEM_OPERATION_PRINT);
413
414 FreeCertContext(x509);
415 }
416
417 /**
418 * @tc.name: CmCertParseTest023
419 * @tc.desc: test CmParsePkcs12Cert normal testcase
420 * @tc.type: FUNC
421 * @tc.require: AR000H0MIA /SR000H09NA
422 */
423 HWTEST_F(CmCertParseTest, CmCertParseTest023, TestSize.Level0)
424 {
425 struct AppCert appCert;
426 (void)memset_s(&appCert, sizeof(struct AppCert), 0, sizeof(struct AppCert));
427 EVP_PKEY *pkey = nullptr;
428 struct CmBlob certInfo = { sizeof(g_rsa2048P12CertInfo), const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
429
430 X509 *cert = nullptr;
431 int32_t ret = CmParsePkcs12Cert(&certInfo, reinterpret_cast<char *>(const_cast<uint8_t *>(g_certPwd)),
432 &pkey, &appCert, &cert);
433 if (cert != nullptr) {
434 FreeCertContext(cert);
435 }
436 EXPECT_EQ(ret, CM_SUCCESS);
437
438 EVP_PKEY_free(pkey);
439 }
440
441 /**
442 * @tc.name: CmCertParseTest024
443 * @tc.desc: test CmParsePkcs12Cert p12Cert is nullptr
444 * @tc.type: FUNC
445 * @tc.require: AR000H0MIA /SR000H09NA
446 */
447 HWTEST_F(CmCertParseTest, CmCertParseTest024, TestSize.Level0)
448 {
449 struct AppCert appCert;
450 (void)memset_s(&appCert, sizeof(struct AppCert), 0, sizeof(struct AppCert));
451 EVP_PKEY *pkey = nullptr;
452
453 X509 *cert = nullptr;
454 int32_t ret = CmParsePkcs12Cert(nullptr, reinterpret_cast<char *>(const_cast<uint8_t *>(g_certPwd)),
455 &pkey, &appCert, &cert);
456 if (cert != nullptr) {
457 FreeCertContext(cert);
458 }
459 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT_APP_CERT);
460
461 EVP_PKEY_free(pkey);
462 }
463
464 /**
465 * @tc.name: CmCertParseTest025
466 * @tc.desc: test CmParsePkcs12Cert p12Cert data is nullptr
467 * @tc.type: FUNC
468 * @tc.require: AR000H0MIA /SR000H09NA
469 */
470 HWTEST_F(CmCertParseTest, CmCertParseTest025, TestSize.Level0)
471 {
472 struct AppCert appCert;
473 (void)memset_s(&appCert, sizeof(struct AppCert), 0, sizeof(struct AppCert));
474 EVP_PKEY *pkey = nullptr;
475 struct CmBlob certInfo = { sizeof(g_rsa2048P12CertInfo), nullptr };
476
477 X509 *cert = nullptr;
478 int32_t ret = CmParsePkcs12Cert(&certInfo, reinterpret_cast<char *>(const_cast<uint8_t *>(g_certPwd)),
479 &pkey, &appCert, &cert);
480 if (cert != nullptr) {
481 FreeCertContext(cert);
482 }
483 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT_APP_CERT);
484
485 EVP_PKEY_free(pkey);
486 }
487
488 /**
489 * @tc.name: CmCertParseTest026
490 * @tc.desc: test CmParsePkcs12Cert p12Cert size too big
491 * @tc.type: FUNC
492 * @tc.require: AR000H0MIA /SR000H09NA
493 */
494 HWTEST_F(CmCertParseTest, CmCertParseTest026, TestSize.Level0)
495 {
496 struct AppCert appCert;
497 (void)memset_s(&appCert, sizeof(struct AppCert), 0, sizeof(struct AppCert));
498 EVP_PKEY *pkey = nullptr;
499 struct CmBlob certInfo = { MAX_LEN_CERTIFICATE_CHAIN + 1, const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
500
501 X509 *cert = nullptr;
502 int32_t ret = CmParsePkcs12Cert(&certInfo, reinterpret_cast<char *>(const_cast<uint8_t *>(g_certPwd)),
503 &pkey, &appCert, &cert);
504 if (cert != nullptr) {
505 FreeCertContext(cert);
506 }
507 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT_APP_CERT);
508
509 EVP_PKEY_free(pkey);
510 }
511
512 /**
513 * @tc.name: CmCertParseTest027
514 * @tc.desc: test CmParsePkcs12Cert p12Cert invalid
515 * @tc.type: FUNC
516 * @tc.require: AR000H0MIA /SR000H09NA
517 */
518 HWTEST_F(CmCertParseTest, CmCertParseTest027, TestSize.Level0)
519 {
520 struct AppCert appCert;
521 (void)memset_s(&appCert, sizeof(struct AppCert), 0, sizeof(struct AppCert));
522 EVP_PKEY *pkey = nullptr;
523 uint8_t tempBuf[] = "this is for test error";
524 struct CmBlob certInfo = { sizeof(tempBuf), tempBuf };
525
526 X509 *cert = nullptr;
527 int32_t ret = CmParsePkcs12Cert(&certInfo, reinterpret_cast<char *>(const_cast<uint8_t *>(g_certPwd)),
528 &pkey, &appCert, &cert);
529 if (cert != nullptr) {
530 FreeCertContext(cert);
531 }
532 EXPECT_EQ(ret, CMR_ERROR_INVALID_CERT_FORMAT);
533
534 EVP_PKEY_free(pkey);
535 }
536
537 /**
538 * @tc.name: CmCertParseTest028
539 * @tc.desc: test CmParsePkcs12Cert pwd invalid
540 * @tc.type: FUNC
541 * @tc.require: AR000H0MIA /SR000H09NA
542 */
543 HWTEST_F(CmCertParseTest, CmCertParseTest028, TestSize.Level0)
544 {
545 struct AppCert appCert;
546 (void)memset_s(&appCert, sizeof(struct AppCert), 0, sizeof(struct AppCert));
547 EVP_PKEY *pkey = nullptr;
548 struct CmBlob certInfo = { sizeof(g_rsa2048P12CertInfo), const_cast<uint8_t *>(g_rsa2048P12CertInfo) };
549 char tempPwd[] = "this is for test error123";
550
551 X509 *cert = nullptr;
552 int32_t ret = CmParsePkcs12Cert(&certInfo, tempPwd, &pkey, &appCert, &cert);
553 if (cert != nullptr) {
554 FreeCertContext(cert);
555 }
556 EXPECT_EQ(ret, CMR_ERROR_PASSWORD_IS_ERR);
557
558 EVP_PKEY_free(pkey);
559 }
560
561 /**
562 * @tc.name: CmCertParseTest029
563 * @tc.desc: test init P7B format cert
564 * @tc.type: FUNC
565 * @tc.require: AR000H0MIA /SR000H09NA
566 */
567 HWTEST_F(CmCertParseTest, CmCertParseTest029, TestSize.Level0)
568 {
569 STACK_OF(X509) *certStack = InitCertStackContext(g_p7bUserCert.data, g_p7bUserCert.size);
570 EXPECT_NE(certStack, nullptr);
571 sk_X509_pop_free(certStack, X509_free);
572 }
573
574 /**
575 * @tc.name: CmCertParseTest030
576 * @tc.desc: test init P7B format cert
577 * @tc.type: FUNC
578 * @tc.require: AR000H0MIA /SR000H09NA
579 */
580 HWTEST_F(CmCertParseTest, CmCertParseTest030, TestSize.Level0)
581 {
582 STACK_OF(X509) *certStack = InitCertStackContext(g_p7bUserCertTooLongSubj.data, g_p7bUserCertTooLongSubj.size);
583 EXPECT_NE(certStack, nullptr);
584 sk_X509_pop_free(certStack, X509_free);
585 }
586
587 /**
588 * @tc.name: CmCertParseTest031
589 * @tc.desc: test init P7B format cert
590 * @tc.type: FUNC
591 * @tc.require: AR000H0MIA /SR000H09NA
592 */
593 HWTEST_F(CmCertParseTest, CmCertParseTest031, TestSize.Level0)
594 {
595 STACK_OF(X509) *certStack = InitCertStackContext(nullptr, 0);
596 EXPECT_EQ(certStack, nullptr);
597 sk_X509_pop_free(certStack, X509_free);
598 certStack = InitCertStackContext(g_p7bUserCertTooLongSubj.data, 0);
599 EXPECT_EQ(certStack, nullptr);
600 sk_X509_pop_free(certStack, X509_free);
601 certStack = InitCertStackContext(g_p7bUserCertTooLongSubj.data, MAX_LEN_CERTIFICATE_P7B + 1);
602 EXPECT_EQ(certStack, nullptr);
603 sk_X509_pop_free(certStack, X509_free);
604 certStack = InitCertStackContext(g_ed25519P12CertInfo, sizeof(g_ed25519P12CertInfo));
605 EXPECT_EQ(certStack, nullptr);
606 sk_X509_pop_free(certStack, X509_free);
607 }
608
609 /**
610 * @tc.name: CmCertParseTest032
611 * @tc.desc: test CmIsNumeric
612 * @tc.type: FUNC
613 * @tc.require: AR000H0MIA /SR000H09NA
614 */
615 HWTEST_F(CmCertParseTest, CmCertParseTest032, TestSize.Level0)
616 {
617 char str[] = "123";
618 int32_t ret = CmIsNumeric(nullptr, 0, nullptr);
619 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
620 ret = CmIsNumeric(str, 0, nullptr);
621 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
622 ret = CmIsNumeric(str, STR_MAX_LEN + 1, nullptr);
623 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
624 ret = CmIsNumeric(str, sizeof(str), nullptr);
625 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
626 uint32_t value = 0;
627 ret = CmIsNumeric(str, sizeof(str), &value);
628 EXPECT_EQ(ret, CM_SUCCESS);
629 ret = CmIsNumeric(str, sizeof(str) - 1, &value);
630 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
631 char errorStr[] = "123ab123";
632 ret = CmIsNumeric(errorStr, sizeof(errorStr), &value);
633 EXPECT_EQ(ret, CMR_ERROR_INVALID_ARGUMENT);
634 }
635 } // end of namespace
636