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 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
204 CfBase *pemObj = nullptr;
205 int32_t ret = CfOpensslCreateCert(&g_cert[0], &pemObj);
206 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
207 CfOpensslDestoryCert(&pemObj);
208 }
209 }
210
211 /**
212 * @tc.name: OpensslCreateCertTest010
213 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
214 * @tc.type: FUNC
215 * @tc.require: AR000HS2RB /SR000HS2Q1
216 */
217 HWTEST_F(CfAdapterCertTest, OpensslCreateCertTest010, TestSize.Level0)
218 {
219 CfBase *obj010 = nullptr;
220 /* cert size don't match cert data */
221 CfEncodingBlob invalCert010 = { const_cast<uint8_t *>(g_certData01), sizeof(g_certData01) - 1, CF_FORMAT_DER };
222 int32_t ret = CfOpensslCreateCert(&invalCert010, &obj010);
223 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal adapter create cert object test failed, recode:" << ret;
224 }
225
226 /**
227 * @tc.name: OpensslDestoryCertTest001
228 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
229 * @tc.type: FUNC
230 * @tc.require: AR000HS2RB /SR000HS2Q1
231 */
232 HWTEST_F(CfAdapterCertTest, OpensslDestoryCertTest001, TestSize.Level0)
233 {
234 CfBase **obj006 = nullptr; /* object is nullptr */
235 CfOpensslDestoryCert(obj006);
236 }
237
238 /**
239 * @tc.name: OpensslDestoryCertTest002
240 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
241 * @tc.type: FUNC
242 * @tc.require: AR000HS2RB /SR000HS2Q1
243 */
244 HWTEST_F(CfAdapterCertTest, OpensslDestoryCertTest002, TestSize.Level0)
245 {
246 CfBase *obj007 = nullptr; /* *object is nullptr */
247 CfOpensslDestoryCert(&obj007);
248 }
249
250 /**
251 * @tc.name: OpensslDestoryCertTest003
252 * @tc.desc: Test CertFramework adapter create cert object interface Abnormal function
253 * @tc.type: FUNC
254 * @tc.require: AR000HS2RB /SR000HS2Q1
255 */
256 HWTEST_F(CfAdapterCertTest, OpensslDestoryCertTest003, TestSize.Level0)
257 {
258 CfBase *obj008 = nullptr;
259 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj008);
260 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
261
262 obj008->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION); /* object type error */
263 CfOpensslDestoryCert(&obj008);
264
265 obj008->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT); /* normal case */
266 CfOpensslDestoryCert(&obj008);
267 }
268
269 /**
270 * @tc.name: OpensslDestoryCertTest004
271 * @tc.desc: X509Cert is nullptr
272 * @tc.type: FUNC
273 * @tc.require: AR000HS2RB /SR000HS2Q1
274 */
275 HWTEST_F(CfAdapterCertTest, OpensslDestoryCertTest004, TestSize.Level0)
276 {
277 CfBase *obj004 = nullptr;
278 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj004);
279 ASSERT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
280
281 CfOpensslCertObj *certObj = reinterpret_cast<CfOpensslCertObj *>(obj004);
282 X509 *tmp = certObj->x509Cert;
283 X509_free(tmp);
284
285 certObj->x509Cert = nullptr;
286 CfOpensslDestoryCert(&obj004);
287 }
288
289 /**
290 * @tc.name: OpensslGetCertItemTest001
291 * @tc.desc: Test CertFramework adapter get der cert extension interface base function
292 * @tc.type: FUNC
293 * @tc.require: AR000HS2RB /SR000HS2Q1
294 */
295 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest001, TestSize.Level0)
296 {
297 CfBase *obj001 = nullptr;
298 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj001); /* der format cert input */
299 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
300
301 CfBlob extBlob001 = { 0, nullptr };
302 ret = CfOpensslGetCertItem(obj001, CF_ITEM_EXTENSIONS, &extBlob001);
303 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter pem get cert extension test failed, recode:" << ret;
304
305 EXPECT_EQ(extBlob001.size, g_certExtension[0].size) << "The size of extension is wrong, test faield";
306 ret = memcmp(extBlob001.data, g_certExtension[0].data, extBlob001.size);
307 EXPECT_EQ(ret, 0) << "The data of extension is wrong, test faield";
308
309 CF_FREE_BLOB(extBlob001);
310 CfOpensslDestoryCert(&obj001);
311 }
312
313 /**
314 * @tc.name: OpensslGetCertItemTest002
315 * @tc.desc: Test CertFramework adapter get pem cert extension interface base function
316 * @tc.type: FUNC
317 * @tc.require: AR000HS2RB /SR000HS2Q1
318 */
319 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest002, TestSize.Level0)
320 {
321 CfBase *obj002 = nullptr;
322 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj002); /* pem format cert input */
323 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
324
325 CfBlob extBlob002 = { 0, nullptr };
326 ret = CfOpensslGetCertItem(obj002, CF_ITEM_EXTENSIONS, &extBlob002);
327 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert extension test failed, recode:" << ret;
328
329 EXPECT_EQ(extBlob002.size, g_certExtension[1].size) << "The size of extension is wrong, test faield";
330 ret = memcmp(extBlob002.data, g_certExtension[1].data, extBlob002.size);
331 EXPECT_EQ(ret, 0) << "The data of extension is wrong, test faield";
332
333 CF_FREE_BLOB(extBlob002);
334 CfOpensslDestoryCert(&obj002);
335 }
336
337 /**
338 * @tc.name: OpensslGetCertItemTest003
339 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
340 * @tc.type: FUNC
341 * @tc.require: AR000HS2RB /SR000HS2Q1
342 */
343 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest003, TestSize.Level0)
344 {
345 CfBase *obj003 = nullptr;
346 CfBlob extBlob003 = { 0, nullptr };
347 int32_t ret = CfOpensslGetCertItem(obj003, CF_ITEM_EXTENSIONS, &extBlob003); /* object is nullptr */
348 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
349 }
350
351 /**
352 * @tc.name: OpensslGetCertItemTest004
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, OpensslGetCertItemTest004, TestSize.Level0)
358 {
359 CfBase *certObj004 = nullptr;
360 int32_t ret = CfOpensslCreateCert(&g_cert[0], &certObj004); /* der format cert input */
361 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
362
363 certObj004->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CRL); /* the type is invalid */
364
365 CfBlob extBlob004 = { 0, nullptr };
366 ret = CfOpensslGetCertItem(certObj004, CF_ITEM_EXTENSIONS, &extBlob004);
367 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
368
369 certObj004->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT);
370 CfOpensslDestoryCert(&certObj004);
371 }
372
373 /**
374 * @tc.name: OpensslGetCertItemTest005
375 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
376 * @tc.type: FUNC
377 * @tc.require: AR000HS2RB /SR000HS2Q1
378 */
379 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest005, TestSize.Level0)
380 {
381 /* the x509 is nullptr */
382 const CfOpensslCertObj certObj005 = { {CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT)}, nullptr };
383 CfBlob extBlob005 = { 0, nullptr };
384 int32_t ret = CfOpensslGetCertItem(&(certObj005.base), CF_ITEM_EXTENSIONS, &extBlob005);
385 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
386 }
387
388 /**s
389 * @tc.name: OpensslGetCertItemTest006
390 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
391 * @tc.type: FUNC
392 * @tc.require: AR000HS2RB /SR000HS2Q1
393 */
394 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest006, TestSize.Level0)
395 {
396 CfBase *certObj006 = nullptr;
397 int32_t ret = CfOpensslCreateCert(&g_cert[0], &certObj006); /* der format cert input */
398 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
399
400 CfBlob extBlob006 = { 0, nullptr };
401 ret = CfOpensslGetCertItem(certObj006, CF_ITEM_INVALID, &extBlob006); /* the id is invalid */
402 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
403
404 CfOpensslDestoryCert(&certObj006);
405 }
406
407 /**
408 * @tc.name: OpensslGetCertItemTest007
409 * @tc.desc: Test CertFramework adapter get cert item interface Abnormal function
410 * @tc.type: FUNC
411 * @tc.require: AR000HS2RB /SR000HS2Q1
412 */
413 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest007, TestSize.Level0)
414 {
415 CfBase *certObj007 = nullptr;
416 int32_t ret = CfOpensslCreateCert(&g_cert[0], &certObj007); /* der format cert input */
417 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
418
419 ret = CfOpensslGetCertItem(certObj007, CF_ITEM_EXTENSIONS, nullptr); /* the outBlob is nullptr */
420 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter get cert item test failed, recode:" << ret;
421
422 CfOpensslDestoryCert(&certObj007);
423 }
424
425 /**
426 * @tc.name: OpensslGetCertItemTest008
427 * @tc.desc: Test CertFramework adapter get cert extension interface performance
428 * @tc.type: FUNC
429 * @tc.require: AR000HS2RB /SR000HS2Q1
430 */
431 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest008, TestSize.Level0)
432 {
433 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
434 for (uint32_t j = 0; j < sizeof(g_cert) / sizeof(g_cert[0]); j++) {
435 CfBase *certObj008 = nullptr;
436 int32_t ret = CfOpensslCreateCert(&g_cert[j], &certObj008);
437 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed,"
438 "index:" << j << " ,recode:" << ret;
439
440 CfBlob extBlob008 = { 0, nullptr };
441 ret = CfOpensslGetCertItem(certObj008, CF_ITEM_EXTENSIONS, &extBlob008);
442 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get cert extension test failed,"
443 "index:" << j << " ,recode:" << ret;
444
445 EXPECT_EQ(extBlob008.size, g_certExtension[j].size) << "The size is wrong, test faield, index = " << j;
446 ret = memcmp(extBlob008.data, g_certExtension[j].data, extBlob008.size);
447 EXPECT_EQ(ret, 0) << "The data of extension is wrong, test faield, index = " << j;
448
449 CF_FREE_BLOB(extBlob008);
450 CfOpensslDestoryCert(&certObj008);
451 }
452 }
453 }
454
455 /**
456 * @tc.name: OpensslGetCertItemTest009
457 * @tc.desc: Test CertFramework adapter get pem cert issuerUID interface base function
458 * @tc.type: FUNC
459 * @tc.require: AR000HS2RB /SR000HS2Q1
460 */
461 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest009, TestSize.Level0)
462 {
463 CfBase *obj009 = nullptr;
464 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj009); /* der format cert with issuerUID input */
465 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
466
467 CfBlob extBlob009 = { 0, nullptr };
468 ret = CfOpensslGetCertItem(obj009, CF_ITEM_ISSUER_UNIQUE_ID, &extBlob009);
469 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert issuerUID test failed, recode:" << ret;
470
471 EXPECT_EQ(extBlob009.size, sizeof(g_certData01IssuerUID)) << "The size of issuerUID is wrong, test faield";
472 ret = memcmp(extBlob009.data, g_certData01IssuerUID, extBlob009.size);
473 EXPECT_EQ(ret, 0) << "The data of issuerUID is wrong, test faield";
474
475 CF_FREE_BLOB(extBlob009);
476 CfOpensslDestoryCert(&obj009);
477 }
478
479 /**
480 * @tc.name: OpensslGetCertItemTest010
481 * @tc.desc: Test CertFramework adapter get cert issuerUID interface Abnormal function
482 * @tc.type: FUNC
483 * @tc.require: AR000HS2RB /SR000HS2Q1
484 */
485 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest010, TestSize.Level0)
486 {
487 CfBase *obj010 = nullptr;
488 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj010); /* pem format cert without issuerUID input */
489 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
490
491 CfBlob extBlob010 = { 0, nullptr };
492 ret = CfOpensslGetCertItem(obj010, CF_ITEM_ISSUER_UNIQUE_ID, &extBlob010);
493 EXPECT_EQ(ret, CF_NOT_EXIST) << "Abnormal adapter get cert issuerUID test failed, recode:" << ret;
494
495 CfOpensslDestoryCert(&obj010);
496 }
497
498 /**
499 * @tc.name: OpensslGetCertItemTest011
500 * @tc.desc: Test CertFramework adapter get cert issuerUID interface performance
501 * @tc.type: FUNC
502 * @tc.require: AR000HS2RB /SR000HS2Q1
503 */
504 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest011, TestSize.Level0)
505 {
506 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
507 CfBase *obj011 = nullptr;
508 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj011); /* der format cert with issuerUID input */
509 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
510
511 CfBlob extBlob011 = { 0, nullptr };
512 ret = CfOpensslGetCertItem(obj011, CF_ITEM_ISSUER_UNIQUE_ID, &extBlob011);
513 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert issuerUID test failed, recode:" << ret;
514
515 EXPECT_EQ(extBlob011.size, sizeof(g_certData01IssuerUID)) << "The size of issuerUID is wrong, test faield";
516 ret = memcmp(extBlob011.data, g_certData01IssuerUID, extBlob011.size);
517 EXPECT_EQ(ret, 0) << "The data of issuerUID is wrong, test faield";
518
519 CF_FREE_BLOB(extBlob011);
520 CfOpensslDestoryCert(&obj011);
521 }
522 }
523
524 /**
525 * @tc.name: OpensslGetCertItemTest012
526 * @tc.desc: Test CertFramework adapter get pem cert subjectUID interface base function
527 * @tc.type: FUNC
528 * @tc.require: AR000HS2RB /SR000HS2Q1
529 */
530 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest012, TestSize.Level0)
531 {
532 CfBase *obj012 = nullptr;
533 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj012); /* Der format cert with subjectUID input */
534 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
535
536 CfBlob extBlob012 = { 0, nullptr };
537 ret = CfOpensslGetCertItem(obj012, CF_ITEM_SUBJECT_UNIQUE_ID, &extBlob012);
538 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert subjectUID test failed, recode:" << ret;
539
540 EXPECT_EQ(extBlob012.size, sizeof(g_certData01SubjectUID)) << "The size of subjectUID is wrong, test faield";
541 ret = memcmp(extBlob012.data, g_certData01SubjectUID, extBlob012.size);
542 EXPECT_EQ(ret, 0) << "The data of subjectUID is wrong, test faield";
543
544 CF_FREE_BLOB(extBlob012);
545 CfOpensslDestoryCert(&obj012);
546 }
547
548 /**
549 * @tc.name: OpensslGetCertItemTest013
550 * @tc.desc: Test CertFramework adapter get cert subjectUID interface Abnormal function
551 * @tc.type: FUNC
552 * @tc.require: AR000HS2RB /SR000HS2Q1
553 */
554 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest013, TestSize.Level0)
555 {
556 CfBase *obj013 = nullptr;
557 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj013); /* pem format cert without subjectUID input */
558 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
559
560 CfBlob extBlob013 = { 0, nullptr };
561 ret = CfOpensslGetCertItem(obj013, CF_ITEM_SUBJECT_UNIQUE_ID, &extBlob013);
562 EXPECT_EQ(ret, CF_NOT_EXIST) << "Abnormal adapter get cert subjectUID test failed, recode:" << ret;
563
564 CfOpensslDestoryCert(&obj013);
565 }
566
567 /**
568 * @tc.name: OpensslGetCertItemTest014
569 * @tc.desc: Test CertFramework adapter get cert subjectUID interface performance
570 * @tc.type: FUNC
571 * @tc.require: AR000HS2RB /SR000HS2Q1
572 */
573 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest014, TestSize.Level0)
574 {
575 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
576 CfBase *obj014 = nullptr;
577 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj014); /* Der format cert with subjectUID input */
578 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
579
580 CfBlob extBlob014 = { 0, nullptr };
581 ret = CfOpensslGetCertItem(obj014, CF_ITEM_SUBJECT_UNIQUE_ID, &extBlob014);
582 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert subjectUID test failed, recode:" << ret;
583
584 EXPECT_EQ(extBlob014.size, sizeof(g_certData01SubjectUID)) << "The size of subjectUID is wrong, test faield";
585 ret = memcmp(extBlob014.data, g_certData01SubjectUID, extBlob014.size);
586 EXPECT_EQ(ret, 0) << "The data of subjectUID is wrong, test faield";
587
588 CF_FREE_BLOB(extBlob014);
589 CfOpensslDestoryCert(&obj014);
590 }
591 }
592
593 /**
594 * @tc.name: OpensslGetCertItemTest015
595 * @tc.desc: Test CertFramework adapter get der cert TBS interface base function
596 * @tc.type: FUNC
597 * @tc.require: AR000HS2RB /SR000HS2Q1
598 */
599 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest015, TestSize.Level0)
600 {
601 CfBase *obj015 = nullptr;
602 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj015); /* der format cert input */
603 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
604
605 CfBlob extBlob015 = { 0, nullptr };
606 ret = CfOpensslGetCertItem(obj015, CF_ITEM_TBS, &extBlob015);
607 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get der cert TBS test failed, recode:" << ret;
608
609 EXPECT_EQ(extBlob015.size, g_certTBS[0].size) << "The size of TBS is wrong, test faield";
610 ret = memcmp(extBlob015.data, g_certTBS[0].data, extBlob015.size);
611 EXPECT_EQ(ret, 0) << "The data of TBS is wrong, test faield";
612
613 CF_FREE_BLOB(extBlob015);
614 CfOpensslDestoryCert(&obj015);
615 }
616
617 /**
618 * @tc.name: OpensslGetCertItemTest016
619 * @tc.desc: Test CertFramework adapter get pem cert TBS interface base function
620 * @tc.type: FUNC
621 * @tc.require: AR000HS2RB /SR000HS2Q1
622 */
623 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest016, TestSize.Level0)
624 {
625 CfBase *obj016 = nullptr;
626 int32_t ret = CfOpensslCreateCert(&g_cert[1], &obj016); /* pem format cert input */
627 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
628
629 CfBlob extBlob016 = { 0, nullptr };
630 ret = CfOpensslGetCertItem(obj016, CF_ITEM_TBS, &extBlob016);
631 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get pem cert TBS test failed, recode:" << ret;
632
633 EXPECT_EQ(extBlob016.size, g_certTBS[1].size) << "The size of TBS is wrong, test faield";
634 ret = memcmp(extBlob016.data, g_certTBS[1].data, extBlob016.size);
635 EXPECT_EQ(ret, 0) << "The data of TBS is wrong, test faield";
636
637 CF_FREE_BLOB(extBlob016);
638 CfOpensslDestoryCert(&obj016);
639 }
640
641 /**
642 * @tc.name: OpensslGetCertItemTest017
643 * @tc.desc: Test CertFramework adapter get cert TBS interface performance
644 * @tc.type: FUNC
645 * @tc.require: AR000HS2RB /SR000HS2Q1
646 */
647 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest017, TestSize.Level0)
648 {
649 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
650 for (uint32_t j = 0; j < sizeof(g_cert) / sizeof(g_cert[0]); j++) {
651 CfBase *certObj017 = nullptr;
652 int32_t ret = CfOpensslCreateCert(&g_cert[j], &certObj017);
653 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed,"
654 "index:" << j << " ,recode:" << ret;
655
656 CfBlob extBlob017 = { 0, nullptr };
657 ret = CfOpensslGetCertItem(certObj017, CF_ITEM_TBS, &extBlob017);
658 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get cert TBS test failed,"
659 "index:" << j << " ,recode:" << ret;
660
661 EXPECT_EQ(extBlob017.size, g_certTBS[j].size) << "The size is wrong, test faield, index = " << j;
662 ret = memcmp(extBlob017.data, g_certTBS[j].data, extBlob017.size);
663 EXPECT_EQ(ret, 0) << "The data of TBS is wrong, test faield, index = " << j;
664
665 CF_FREE_BLOB(extBlob017);
666 CfOpensslDestoryCert(&certObj017);
667 }
668 }
669 }
670
671 /**
672 * @tc.name: OpensslGetCertItemTest018
673 * @tc.desc: Test CertFramework adapter get cert public key
674 * @tc.type: FUNC
675 * @tc.require: AR000HS2RB /SR000HS2Q1
676 */
677 HWTEST_F(CfAdapterCertTest, OpensslGetCertItemTest018, TestSize.Level0)
678 {
679 CfBase *obj018 = nullptr;
680 int32_t ret = CfOpensslCreateCert(&g_cert[0], &obj018);
681 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create cert object test failed, recode:" << ret;
682
683 CfBlob outBlob018 = { 0, nullptr };
684 ret = CfOpensslGetCertItem(obj018, CF_ITEM_PUBLIC_KEY, &outBlob018);
685 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter get public key test failed, recode:" << ret;
686
687 CfBlob pubKey = { sizeof(g_certData01PubKey), const_cast<uint8_t *>(g_certData01PubKey) };
688 EXPECT_EQ(CompareBlob(&outBlob018, &pubKey), true);
689
690 CfFree(outBlob018.data);
691 CfOpensslDestoryCert(&obj018);
692 }
693 }
694