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