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
16 #include <gtest/gtest.h>
17
18 #include "cf_adapter_cert_openssl.h"
19 #include "cf_test_common.h"
20 #include "cf_magic.h"
21 #include "cf_memory.h"
22 #include "cf_result.h"
23 #include "cf_test_data.h"
24
25 using namespace testing::ext;
26 using namespace CertframeworkTest;
27 using namespace CertframeworkTestData;
28
29 namespace {
30 CfEncodingBlob g_cert[] = {
31 { const_cast<uint8_t *>(g_certData01), sizeof(g_certData01), CF_FORMAT_DER },
32 { reinterpret_cast<uint8_t *>(g_certData02), strlen(g_certData02) + 1, CF_FORMAT_PEM }
33 };
34
35 CfBlob g_certExtension[] = {
36 { sizeof(g_extensionData01), const_cast<uint8_t *>(g_extensionData01) },
37 { sizeof(g_certData02Extension), const_cast<uint8_t *>(g_certData02Extension) },
38 };
39
40 CfBlob g_certTBS[] = {
41 { sizeof(g_certData01TBS), const_cast<uint8_t *>(g_certData01TBS) },
42 { sizeof(g_certData02TBS), const_cast<uint8_t *>(g_certData02TBS) },
43 };
44
45 class CfAdapterCertTest : public testing::Test {
46 public:
47 static void SetUpTestCase(void);
48
49 static void TearDownTestCase(void);
50
51 void SetUp();
52
53 void TearDown();
54 };
55
SetUpTestCase(void)56 void CfAdapterCertTest::SetUpTestCase(void)
57 {
58 }
59
TearDownTestCase(void)60 void CfAdapterCertTest::TearDownTestCase(void)
61 {
62 }
63
SetUp()64 void CfAdapterCertTest::SetUp()
65 {
66 }
67
TearDown()68 void CfAdapterCertTest::TearDown()
69 {
70 }
71
72 /**
73 * @tc.name: OpensslCreateCertTest001
74 * @tc.desc: Test CertFramework adapter create cert object interface base function
75 * @tc.type: FUNC
76 * @tc.require: AR000HS2RB /SR000HS2Q1
77 */
78 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest001, TestSize.Level0)
79 {
80 CfBase *derObj = nullptr; /* der format cert object */
81 int32_t ret = CfOpensslCreateCert(&g_cert[0], &derObj);
82 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
83
84 CfOpensslDestoryCert(&derObj);
85 }
86
87 /**
88 * @tc.name: OpensslCreateCertTest002
89 * @tc.desc: Test CertFramework adapter create cert object interface base function
90 * @tc.type: FUNC
91 * @tc.require: AR000HS2RB /SR000HS2Q1
92 */
93 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest002, TestSize.Level0)
94 {
95 CfBase *pemObj = nullptr; /* pem format cert object */
96 int32_t ret = CfOpensslCreateCert(&g_cert[1], &pemObj);
97 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
98
99 CfOpensslDestoryCert(&pemObj);
100 }
101
102 /**
103 * @tc.name: OpensslCreateCertTest003
104 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
105 * @tc.type: FUNC
106 * @tc.require: AR000HS2RB /SR000HS2Q1
107 */
108 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest003, TestSize.Level0)
109 {
110 CfBase *obj001 = nullptr;
111 CfEncodingBlob *invalCert001 = nullptr; /* cert blob is nullptr */
112 int32_t ret = CfOpensslCreateCert(invalCert001, &obj001);
113 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create cert object test failed, recode:" << ret;
114 }
115
116 /**
117 * @tc.name: OpensslCreateCertTest004
118 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
119 * @tc.type: FUNC
120 * @tc.require: AR000HS2RB /SR000HS2Q1
121 */
122 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest004, TestSize.Level0)
123 {
124 CfBase *obj002 = nullptr;
125 CfEncodingBlob invalCert002 = { nullptr, 20, CF_FORMAT_DER }; /* cert data is nullptr */
126 int32_t ret = CfOpensslCreateCert(&invalCert002, &obj002);
127 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create cert object test failed, recode:" << ret;
128 }
129
130 /**
131 * @tc.name: OpensslCreateCertTest005
132 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
133 * @tc.type: FUNC
134 * @tc.require: AR000HS2RB /SR000HS2Q1
135 */
136 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest005, TestSize.Level0)
137 {
138 CfBase *obj003 = nullptr;
139 CfEncodingBlob invalCert003 = { const_cast<uint8_t *>(g_certData01), 0, CF_FORMAT_DER }; /* cert size is 0 */
140 int32_t ret = CfOpensslCreateCert(&invalCert003, &obj003);
141 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create cert object test failed, recode:" << ret;
142 }
143
144 /**
145 * @tc.name: OpensslCreateCertTest006
146 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
147 * @tc.type: FUNC
148 * @tc.require: AR000HS2RB /SR000HS2Q1
149 */
150 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest006, TestSize.Level0)
151 {
152 CfBase *obj004 = nullptr;
153 /* cert format is invalid */
154 CfEncodingBlob invalCert004 = {
155 const_cast<uint8_t *>(g_certData03),
156 sizeof(g_certData03),
157 static_cast<enum CfEncodingFormat>(CF_FORMAT_PEM + 1)
158 };
159 int32_t ret = CfOpensslCreateCert(&invalCert004, &obj004);
160 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create cert object test failed, recode:" << ret;
161 }
162
163 /**
164 * @tc.name: OpensslCreateCertTest007
165 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
166 * @tc.type: FUNC
167 * @tc.require: AR000HS2RB /SR000HS2Q1
168 */
169 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest007, TestSize.Level0)
170 {
171 CfBase *obj005 = nullptr;
172 /* cert size beyond max */
173 CfEncodingBlob invalCert005 = { const_cast<uint8_t *>(g_certData03), MAX_LEN_CERTIFICATE + 1, CF_FORMAT_DER };
174 int32_t ret = CfOpensslCreateCert(&invalCert005, &obj005);
175 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create cert object test failed, recode:" << ret;
176
177 obj005 = nullptr;
178 invalCert005.len = MAX_LEN_CERTIFICATE; /* cert size equal max */
179 ret = CfOpensslCreateCert(&invalCert005, &obj005);
180 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal adapter create cert object test failed, recode:" << ret;
181 }
182
183 /**
184 * @tc.name: OpensslCreateCertTest008
185 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
186 * @tc.type: FUNC
187 * @tc.require: AR000HS2RB /SR000HS2Q1
188 */
189 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest008, TestSize.Level0)
190 {
191 int32_t ret = CfOpensslCreateCert(&g_cert[1], nullptr); /* object is nullptr */
192 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create cert object test failed, recode:" << ret;
193 }
194
195 /**
196 * @tc.name: OpensslCreateCertTest009
197 * @tc.desc: Test CertFramework adapter create and destory cert object interface performance
198 * @tc.type: FUNC
199 * @tc.require: AR000HS2RB /SR000HS2Q1
200 */
201 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest009, TestSize.Level0)
202 {
203 CfBase **obj006 = nullptr; /* object is nullptr */
204 CfOpensslDestoryCert(obj006);
205 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
206 CfBase *pemObj = nullptr;
207 int32_t ret = CfOpensslCreateCert(&g_cert[0], &pemObj);
208 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
209 CfOpensslDestoryCert(&pemObj);
210 }
211 }
212
213 /**
214 * @tc.name: OpensslCreateCertTest010
215 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
216 * @tc.type: FUNC
217 * @tc.require: AR000HS2RB /SR000HS2Q1
218 */
219 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest010, TestSize.Level0)
220 {
221 CfBase *obj010 = nullptr;
222 /* cert size don't match cert data */
223 CfEncodingBlob invalCert010 = { const_cast<uint8_t *>(g_certData01), sizeof(g_certData01) - 1, CF_FORMAT_DER };
224 int32_t ret = CfOpensslCreateCert(&invalCert010, &obj010);
225 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal adapter create cert object test failed, recode:" << ret;
226 }
227
228 /**
229 * @tc.name: OpensslDestoryCertTest003
230 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
231 * @tc.type: FUNC
232 * @tc.require: AR000HS2RB /SR000HS2Q1
233 */
234 HWTEST_F(CfAdapterCertTest, OpensslDestoryCertTest003, TestSize.Level0)
235 {
236 CfBase *obj008 = nullptr;
237 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj008);
238 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
239
240 obj008->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION); /* object type error */
241 CfOpensslDestoryCert(&obj008);
242
243 obj008->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT); /* normal case */
244 CfOpensslDestoryCert(&obj008);
245 }
246
247 /**
248 * @tc.name: OpensslDestoryCertTest004
249 * @tc.desc: X509Cert is nullptr
250 * @tc.type: FUNC
251 * @tc.require: AR000HS2RB /SR000HS2Q1
252 */
253 HWTEST_F(CfAdapterCertTest, OpensslDestoryCertTest004, TestSize.Level0)
254 {
255 CfBase *obj004 = nullptr;
256 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj004);
257 ASSERT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
258
259 CfOpensslCertObj *certObj = reinterpret_cast<CfOpensslCertObj *>(obj004);
260 X509 *tmp = certObj->x509Cert;
261 X509_free(tmp);
262
263 certObj->x509Cert = nullptr;
264 CfOpensslDestoryCert(&obj004);
265 }
266
267 /**
268 * @tc.name: OpensslGetCertItemTest001
269 * @tc.desc: Test CertFramework adapter get der cert extension interface base function
270 * @tc.type: FUNC
271 * @tc.require: AR000HS2RB /SR000HS2Q1
272 */
273 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest001, TestSize.Level0)
274 {
275 CfBase *obj001 = nullptr;
276 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj001); /* der format cert input */
277 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
278
279 CfBlob extBlob001 = { 0, nullptr };
280 ret = CfOpensslGetCertItem(obj001, CF_ITEM_EXTENSIONS, &extBlob001);
281 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter pem get cert extension test failed, recode:" << ret;
282
283 EXPECT_EQ(extBlob001.size, g_certExtension[0].size) << "The size of extension is wrong, test faield";
284 ret = memcmp(extBlob001.data, g_certExtension[0].data, extBlob001.size);
285 EXPECT_EQ(ret, 0) << "The data of extension is wrong, test faield";
286
287 CF_FREE_BLOB(extBlob001);
288 CfOpensslDestoryCert(&obj001);
289 }
290
291 /**
292 * @tc.name: OpensslGetCertItemTest002
293 * @tc.desc: Test CertFramework adapter get pem cert extension interface base function
294 * @tc.type: FUNC
295 * @tc.require: AR000HS2RB /SR000HS2Q1
296 */
297 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest002, TestSize.Level0)
298 {
299 CfBase *obj002 = nullptr;
300 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj002); /* pem format cert input */
301 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
302
303 CfBlob extBlob002 = { 0, nullptr };
304 ret = CfOpensslGetCertItem(obj002, CF_ITEM_EXTENSIONS, &extBlob002);
305 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert extension test failed, recode:" << ret;
306
307 EXPECT_EQ(extBlob002.size, g_certExtension[1].size) << "The size of extension is wrong, test faield";
308 ret = memcmp(extBlob002.data, g_certExtension[1].data, extBlob002.size);
309 EXPECT_EQ(ret, 0) << "The data of extension is wrong, test faield";
310
311 CF_FREE_BLOB(extBlob002);
312 CfOpensslDestoryCert(&obj002);
313 }
314
315 /**
316 * @tc.name: OpensslGetCertItemTest003
317 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
318 * @tc.type: FUNC
319 * @tc.require: AR000HS2RB /SR000HS2Q1
320 */
321 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest003, TestSize.Level0)
322 {
323 CfBase *obj003 = nullptr;
324 CfBlob extBlob003 = { 0, nullptr };
325 int32_t ret = CfOpensslGetCertItem(obj003, CF_ITEM_EXTENSIONS, &extBlob003); /* object is nullptr */
326 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
327 }
328
329 /**
330 * @tc.name: OpensslGetCertItemTest004
331 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
332 * @tc.type: FUNC
333 * @tc.require: AR000HS2RB /SR000HS2Q1
334 */
335 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest004, TestSize.Level0)
336 {
337 CfBase *certObj004 = nullptr;
338 int32_t ret = CfOpensslCreateCert(&g_cert[0], &certObj004); /* der format cert input */
339 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
340
341 certObj004->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CRL); /* the type is invalid */
342
343 CfBlob extBlob004 = { 0, nullptr };
344 ret = CfOpensslGetCertItem(certObj004, CF_ITEM_EXTENSIONS, &extBlob004);
345 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
346
347 certObj004->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT);
348 CfOpensslDestoryCert(&certObj004);
349 }
350
351 /**
352 * @tc.name: OpensslGetCertItemTest005
353 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
354 * @tc.type: FUNC
355 * @tc.require: AR000HS2RB /SR000HS2Q1
356 */
357 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest005, TestSize.Level0)
358 {
359 /* the x509 is nullptr */
360 const CfOpensslCertObj certObj005 = { {CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT)}, nullptr };
361 CfBlob extBlob005 = { 0, nullptr };
362 int32_t ret = CfOpensslGetCertItem(&(certObj005.base), CF_ITEM_EXTENSIONS, &extBlob005);
363 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
364 }
365
366 /**s
367 * @tc.name: OpensslGetCertItemTest006
368 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
369 * @tc.type: FUNC
370 * @tc.require: AR000HS2RB /SR000HS2Q1
371 */
372 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest006, TestSize.Level0)
373 {
374 CfBase *certObj006 = nullptr;
375 int32_t ret = CfOpensslCreateCert(&g_cert[0], &certObj006); /* der format cert input */
376 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
377
378 CfBlob extBlob006 = { 0, nullptr };
379 ret = CfOpensslGetCertItem(certObj006, CF_ITEM_INVALID, &extBlob006); /* the id is invalid */
380 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
381
382 CfOpensslDestoryCert(&certObj006);
383 }
384
385 /**
386 * @tc.name: OpensslGetCertItemTest007
387 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
388 * @tc.type: FUNC
389 * @tc.require: AR000HS2RB /SR000HS2Q1
390 */
391 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest007, TestSize.Level0)
392 {
393 CfBase *certObj007 = nullptr;
394 int32_t ret = CfOpensslCreateCert(&g_cert[0], &certObj007); /* der format cert input */
395 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
396
397 ret = CfOpensslGetCertItem(certObj007, CF_ITEM_EXTENSIONS, nullptr); /* the outBlob is nullptr */
398 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
399
400 CfOpensslDestoryCert(&certObj007);
401 }
402
403 /**
404 * @tc.name: OpensslGetCertItemTest008
405 * @tc.desc: Test CertFramework adapter get cert extension interface performance
406 * @tc.type: FUNC
407 * @tc.require: AR000HS2RB /SR000HS2Q1
408 */
409 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest008, TestSize.Level0)
410 {
411 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
412 for (uint32_t j = 0; j < sizeof(g_cert) / sizeof(g_cert[0]); j++) {
413 CfBase *certObj008 = nullptr;
414 int32_t ret = CfOpensslCreateCert(&g_cert[j], &certObj008);
415 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed,"
416 "index:" << j << " ,recode:" << ret;
417
418 CfBlob extBlob008 = { 0, nullptr };
419 ret = CfOpensslGetCertItem(certObj008, CF_ITEM_EXTENSIONS, &extBlob008);
420 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get cert extension test failed,"
421 "index:" << j << " ,recode:" << ret;
422
423 EXPECT_EQ(extBlob008.size, g_certExtension[j].size) << "The size is wrong, test faield, index = " << j;
424 ret = memcmp(extBlob008.data, g_certExtension[j].data, extBlob008.size);
425 EXPECT_EQ(ret, 0) << "The data of extension is wrong, test faield, index = " << j;
426
427 CF_FREE_BLOB(extBlob008);
428 CfOpensslDestoryCert(&certObj008);
429 }
430 }
431 }
432
433 /**
434 * @tc.name: OpensslGetCertItemTest009
435 * @tc.desc: Test CertFramework adapter get pem cert issuerUID interface base function
436 * @tc.type: FUNC
437 * @tc.require: AR000HS2RB /SR000HS2Q1
438 */
439 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest009, TestSize.Level0)
440 {
441 CfBase *obj009 = nullptr;
442 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj009); /* der format cert with issuerUID input */
443 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
444
445 CfBlob extBlob009 = { 0, nullptr };
446 ret = CfOpensslGetCertItem(obj009, CF_ITEM_ISSUER_UNIQUE_ID, &extBlob009);
447 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert issuerUID test failed, recode:" << ret;
448
449 EXPECT_EQ(extBlob009.size, sizeof(g_certData01IssuerUID)) << "The size of issuerUID is wrong, test faield";
450 ret = memcmp(extBlob009.data, g_certData01IssuerUID, extBlob009.size);
451 EXPECT_EQ(ret, 0) << "The data of issuerUID is wrong, test faield";
452
453 CF_FREE_BLOB(extBlob009);
454 CfOpensslDestoryCert(&obj009);
455 }
456
457 /**
458 * @tc.name: OpensslGetCertItemTest010
459 * @tc.desc: Test CertFramework adapter get cert issuerUID interface Abnormal function
460 * @tc.type: FUNC
461 * @tc.require: AR000HS2RB /SR000HS2Q1
462 */
463 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest010, TestSize.Level0)
464 {
465 CfBase *obj010 = nullptr;
466 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj010); /* pem format cert without issuerUID input */
467 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
468
469 CfBlob extBlob010 = { 0, nullptr };
470 ret = CfOpensslGetCertItem(obj010, CF_ITEM_ISSUER_UNIQUE_ID, &extBlob010);
471 EXPECT_EQ(ret, CF_NOT_EXIST) << "Abnormal adapter get cert issuerUID test failed, recode:" << ret;
472
473 CfOpensslDestoryCert(&obj010);
474 }
475
476 /**
477 * @tc.name: OpensslGetCertItemTest011
478 * @tc.desc: Test CertFramework adapter get cert issuerUID interface performance
479 * @tc.type: FUNC
480 * @tc.require: AR000HS2RB /SR000HS2Q1
481 */
482 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest011, TestSize.Level0)
483 {
484 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
485 CfBase *obj011 = nullptr;
486 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj011); /* der format cert with issuerUID input */
487 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
488
489 CfBlob extBlob011 = { 0, nullptr };
490 ret = CfOpensslGetCertItem(obj011, CF_ITEM_ISSUER_UNIQUE_ID, &extBlob011);
491 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert issuerUID test failed, recode:" << ret;
492
493 EXPECT_EQ(extBlob011.size, sizeof(g_certData01IssuerUID)) << "The size of issuerUID is wrong, test faield";
494 ret = memcmp(extBlob011.data, g_certData01IssuerUID, extBlob011.size);
495 EXPECT_EQ(ret, 0) << "The data of issuerUID is wrong, test faield";
496
497 CF_FREE_BLOB(extBlob011);
498 CfOpensslDestoryCert(&obj011);
499 }
500 }
501
502 /**
503 * @tc.name: OpensslGetCertItemTest012
504 * @tc.desc: Test CertFramework adapter get pem cert subjectUID interface base function
505 * @tc.type: FUNC
506 * @tc.require: AR000HS2RB /SR000HS2Q1
507 */
508 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest012, TestSize.Level0)
509 {
510 CfBase *obj012 = nullptr;
511 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj012); /* Der format cert with subjectUID input */
512 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
513
514 CfBlob extBlob012 = { 0, nullptr };
515 ret = CfOpensslGetCertItem(obj012, CF_ITEM_SUBJECT_UNIQUE_ID, &extBlob012);
516 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert subjectUID test failed, recode:" << ret;
517
518 EXPECT_EQ(extBlob012.size, sizeof(g_certData01SubjectUID)) << "The size of subjectUID is wrong, test faield";
519 ret = memcmp(extBlob012.data, g_certData01SubjectUID, extBlob012.size);
520 EXPECT_EQ(ret, 0) << "The data of subjectUID is wrong, test faield";
521
522 CF_FREE_BLOB(extBlob012);
523 CfOpensslDestoryCert(&obj012);
524 }
525
526 /**
527 * @tc.name: OpensslGetCertItemTest013
528 * @tc.desc: Test CertFramework adapter get cert subjectUID interface Abnormal function
529 * @tc.type: FUNC
530 * @tc.require: AR000HS2RB /SR000HS2Q1
531 */
532 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest013, TestSize.Level0)
533 {
534 CfBase *obj013 = nullptr;
535 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj013); /* pem format cert without subjectUID input */
536 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
537
538 CfBlob extBlob013 = { 0, nullptr };
539 ret = CfOpensslGetCertItem(obj013, CF_ITEM_SUBJECT_UNIQUE_ID, &extBlob013);
540 EXPECT_EQ(ret, CF_NOT_EXIST) << "Abnormal adapter get cert subjectUID test failed, recode:" << ret;
541
542 CfOpensslDestoryCert(&obj013);
543 }
544
545 /**
546 * @tc.name: OpensslGetCertItemTest014
547 * @tc.desc: Test CertFramework adapter get cert subjectUID interface performance
548 * @tc.type: FUNC
549 * @tc.require: AR000HS2RB /SR000HS2Q1
550 */
551 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest014, TestSize.Level0)
552 {
553 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
554 CfBase *obj014 = nullptr;
555 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj014); /* Der format cert with subjectUID input */
556 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
557
558 CfBlob extBlob014 = { 0, nullptr };
559 ret = CfOpensslGetCertItem(obj014, CF_ITEM_SUBJECT_UNIQUE_ID, &extBlob014);
560 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert subjectUID test failed, recode:" << ret;
561
562 EXPECT_EQ(extBlob014.size, sizeof(g_certData01SubjectUID)) << "The size of subjectUID is wrong, test faield";
563 ret = memcmp(extBlob014.data, g_certData01SubjectUID, extBlob014.size);
564 EXPECT_EQ(ret, 0) << "The data of subjectUID is wrong, test faield";
565
566 CF_FREE_BLOB(extBlob014);
567 CfOpensslDestoryCert(&obj014);
568 }
569 }
570
571 /**
572 * @tc.name: OpensslGetCertItemTest015
573 * @tc.desc: Test CertFramework adapter get der cert TBS interface base function
574 * @tc.type: FUNC
575 * @tc.require: AR000HS2RB /SR000HS2Q1
576 */
577 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest015, TestSize.Level0)
578 {
579 CfBase *obj015 = nullptr;
580 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj015); /* der format cert input */
581 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
582
583 CfBlob extBlob015 = { 0, nullptr };
584 ret = CfOpensslGetCertItem(obj015, CF_ITEM_TBS, &extBlob015);
585 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert TBS test failed, recode:" << ret;
586
587 EXPECT_EQ(extBlob015.size, g_certTBS[0].size) << "The size of TBS is wrong, test faield";
588 ret = memcmp(extBlob015.data, g_certTBS[0].data, extBlob015.size);
589 EXPECT_EQ(ret, 0) << "The data of TBS is wrong, test faield";
590
591 CF_FREE_BLOB(extBlob015);
592 CfOpensslDestoryCert(&obj015);
593 }
594
595 /**
596 * @tc.name: OpensslGetCertItemTest016
597 * @tc.desc: Test CertFramework adapter get pem cert TBS interface base function
598 * @tc.type: FUNC
599 * @tc.require: AR000HS2RB /SR000HS2Q1
600 */
601 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest016, TestSize.Level0)
602 {
603 CfBase *obj016 = nullptr;
604 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj016); /* pem format cert input */
605 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
606
607 CfBlob extBlob016 = { 0, nullptr };
608 ret = CfOpensslGetCertItem(obj016, CF_ITEM_TBS, &extBlob016);
609 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get pem cert TBS test failed, recode:" << ret;
610
611 EXPECT_EQ(extBlob016.size, g_certTBS[1].size) << "The size of TBS is wrong, test faield";
612 ret = memcmp(extBlob016.data, g_certTBS[1].data, extBlob016.size);
613 EXPECT_EQ(ret, 0) << "The data of TBS is wrong, test faield";
614
615 CF_FREE_BLOB(extBlob016);
616 CfOpensslDestoryCert(&obj016);
617 }
618
619 /**
620 * @tc.name: OpensslGetCertItemTest017
621 * @tc.desc: Test CertFramework adapter get cert TBS interface performance
622 * @tc.type: FUNC
623 * @tc.require: AR000HS2RB /SR000HS2Q1
624 */
625 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest017, TestSize.Level0)
626 {
627 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
628 for (uint32_t j = 0; j < sizeof(g_cert) / sizeof(g_cert[0]); j++) {
629 CfBase *certObj017 = nullptr;
630 int32_t ret = CfOpensslCreateCert(&g_cert[j], &certObj017);
631 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed,"
632 "index:" << j << " ,recode:" << ret;
633
634 CfBlob extBlob017 = { 0, nullptr };
635 ret = CfOpensslGetCertItem(certObj017, CF_ITEM_TBS, &extBlob017);
636 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get cert TBS test failed,"
637 "index:" << j << " ,recode:" << ret;
638
639 EXPECT_EQ(extBlob017.size, g_certTBS[j].size) << "The size is wrong, test faield, index = " << j;
640 ret = memcmp(extBlob017.data, g_certTBS[j].data, extBlob017.size);
641 EXPECT_EQ(ret, 0) << "The data of TBS is wrong, test faield, index = " << j;
642
643 CF_FREE_BLOB(extBlob017);
644 CfOpensslDestoryCert(&certObj017);
645 }
646 }
647 }
648
649 /**
650 * @tc.name: OpensslGetCertItemTest018
651 * @tc.desc: Test CertFramework adapter get cert public key
652 * @tc.type: FUNC
653 * @tc.require: AR000HS2RB /SR000HS2Q1
654 */
655 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest018, TestSize.Level0)
656 {
657 CfBase *obj018 = nullptr;
658 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj018);
659 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
660
661 CfBlob outBlob018 = { 0, nullptr };
662 ret = CfOpensslGetCertItem(obj018, CF_ITEM_PUBLIC_KEY, &outBlob018);
663 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get public key test failed, recode:" << ret;
664
665 CfBlob pubKey = { sizeof(g_certData01PubKey), const_cast<uint8_t *>(g_certData01PubKey) };
666 EXPECT_EQ(CompareBlob(&outBlob018, &pubKey), true);
667
668 CfFree(outBlob018.data);
669 CfOpensslDestoryCert(&obj018);
670 }
671 }
672