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 #include <openssl/x509v3.h>
18
19 #include "cf_adapter_extension_openssl.h"
20 #include "cf_test_common.h"
21 #include "cf_magic.h"
22 #include "cf_memory.h"
23 #include "cf_result.h"
24 #include "cf_test_data.h"
25
26 using namespace testing::ext;
27 using namespace CertframeworkTest;
28 using namespace CertframeworkTestData;
29
30 namespace {
31 CfEncodingBlob g_extension[] = {
32 { const_cast<uint8_t *>(g_extensionData01), sizeof(g_extensionData01), CF_FORMAT_DER },
33 { const_cast<uint8_t *>(g_extensionData02), sizeof(g_extensionData02), CF_FORMAT_DER },
34 { const_cast<uint8_t *>(g_extensionData03), sizeof(g_extensionData03), CF_FORMAT_DER },
35 { const_cast<uint8_t *>(g_extensionTaintedData), sizeof(g_extensionTaintedData), CF_FORMAT_DER },
36 };
37
38 class CfAdapterExtensionTest : 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 CfAdapterExtensionTest::SetUpTestCase(void)
50 {
51 }
52
TearDownTestCase(void)53 void CfAdapterExtensionTest::TearDownTestCase(void)
54 {
55 }
56
SetUp()57 void CfAdapterExtensionTest::SetUp()
58 {
59 }
60
TearDown()61 void CfAdapterExtensionTest::TearDown()
62 {
63 }
64
65 /**
66 * @tc.name: OpensslCreateExtensionTest001
67 * @tc.desc: Test CertFramework adapter create extension object interface base function
68 * @tc.type: FUNC
69 * @tc.require: AR000HS2SC /SR000HS2SB
70 */
71 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest001, TestSize.Level0)
72 {
73 CfBase *extsObj001 = nullptr;
74 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &extsObj001);
75 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
76
77 CfOpensslDestoryExtension(&extsObj001);
78 }
79
80 /**
81 * @tc.name: OpensslCreateExtensionTest002
82 * @tc.desc: Test CertFramework adapter create extension object interface Abnormal function
83 * @tc.type: FUNC
84 * @tc.require: AR000HS2SC /SR000HS2SB
85 */
86 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest002, TestSize.Level0)
87 {
88 CfBase *extsObj002 = nullptr;
89 CfEncodingBlob *invalidExts = nullptr; /* exts blob is null */
90 int32_t ret = CfOpensslCreateExtension(invalidExts, &extsObj002);
91 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
92 "Abnormal adapter create extension object test failed, recode:" << ret;
93 }
94
95 /**
96 * @tc.name: OpensslCreateExtensionTest003
97 * @tc.desc: Test CertFramework adapter create extension object interface Abnormal function
98 * @tc.type: FUNC
99 * @tc.require: AR000HS2SC /SR000HS2SB
100 */
101 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest003, TestSize.Level0)
102 {
103 CfBase *extsObj003 = nullptr;
104 CfEncodingBlob invalidExts = { nullptr, 10, CF_FORMAT_DER }; /* exts data is null */
105 int32_t ret = CfOpensslCreateExtension(&invalidExts, &extsObj003);
106 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
107 "Abnormal adapter create extension object test failed, recode:" << ret;
108 }
109
110 /**
111 * @tc.name: OpensslCreateExtensionTest004
112 * @tc.desc: Test CertFramework adapter create extension object interface Abnormal function
113 * @tc.type: FUNC
114 * @tc.require: AR000HS2SC /SR000HS2SB
115 */
116 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest004, TestSize.Level0)
117 {
118 CfBase *extsObj004 = nullptr;
119 CfEncodingBlob invalidExts = { const_cast<uint8_t *>(g_extensionData01), 0, CF_FORMAT_DER }; /* exts size is 0 */
120 int32_t ret = CfOpensslCreateExtension(&invalidExts, &extsObj004);
121 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
122 "Abnormal adapter create extension object test failed, recode:" << ret;
123 }
124
125 /**
126 * @tc.name: OpensslCreateExtensionTest005
127 * @tc.desc: Test CertFramework adapter create extension object interface Abnormal function
128 * @tc.type: FUNC
129 * @tc.require: AR000HS2SC /SR000HS2SB
130 */
131 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest005, TestSize.Level0)
132 {
133 int32_t ret = CfOpensslCreateExtension(&g_extension[0], nullptr); /* object is null */
134 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
135 "Abnormal adapter create extension object test failed, recode:" << ret;
136 }
137
138 /**
139 * @tc.name: OpensslCreateExtensionTest006
140 * @tc.desc: Test CertFramework adapter create extension object interface Abnormal function
141 * @tc.type: FUNC
142 * @tc.require: AR000HS2SC /SR000HS2SB
143 */
144 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest006, TestSize.Level0)
145 {
146 CfBase *extsObj005 = nullptr;
147 /* exts size don't match exts data */
148 CfEncodingBlob invalidExts = {
149 const_cast<uint8_t *>(g_extensionData01),
150 sizeof(g_extensionData01) - 1,
151 CF_FORMAT_DER
152 };
153 int32_t ret = CfOpensslCreateExtension(&invalidExts, &extsObj005);
154 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal adapter create extension object test failed, recode:" << ret;
155 }
156
157 /**
158 * @tc.name: OpensslCreateExtensionTest007
159 * @tc.desc: Test CertFramework adapter create and destory extension object interface performance
160 * @tc.type: FUNC
161 * @tc.require: AR000HS2SC /SR000HS2SB
162 */
163 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest007, TestSize.Level0)
164 {
165 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
166 CfBase *extsObj006 = nullptr;
167 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &extsObj006);
168 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
169 CfOpensslDestoryExtension(&extsObj006);
170 }
171 }
172
173 /**
174 * @tc.name: OpensslCreateExtensionTest008
175 * @tc.desc: Test CertFramework adapter create extension object interface abnormal function
176 * @tc.type: FUNC
177 * @tc.require: AR000HS2SC /SR000HS2SB
178 */
179 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest008, TestSize.Level0)
180 {
181 CfBase *extsObj007 = nullptr;
182 int32_t ret = CfOpensslCreateExtension(&g_extension[3], &extsObj007); /* tainted extension data */
183 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Normal adapter create extension object test failed, recode:" << ret;
184 }
185
186 /**
187 * @tc.name: OpensslCreateExtensionTest009
188 * @tc.desc: Test CertFramework adapter create extension object interface Abnormal function
189 * @tc.type: FUNC
190 * @tc.require: AR000HS2SC /SR000HS2SB
191 */
192 HWTEST_F(CfAdapterExtensionTest, OpensslCreateExtensionTest009, TestSize.Level0)
193 {
194 CfBase *extsObj008 = nullptr;
195 /* exts size beyond max */
196 CfEncodingBlob invalidExts = { const_cast<uint8_t *>(g_extensionData01), MAX_LEN_EXTENSIONS + 1, CF_FORMAT_DER };
197 int32_t ret = CfOpensslCreateExtension(&invalidExts, &extsObj008);
198 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal adapter create extension object test failed, recode:" << ret;
199
200 extsObj008 = nullptr;
201 invalidExts.len = MAX_LEN_EXTENSIONS; /* exts size equal max */
202 ret = CfOpensslCreateExtension(&invalidExts, &extsObj008);
203 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal adapter create extension object test failed, recode:" << ret;
204 }
205
206 /**
207 * @tc.name: OpensslDestoryExtensionTest001
208 * @tc.desc: Test CertFramework adapter destory extension object interface Abnormal function
209 * @tc.type: FUNC
210 * @tc.require: AR000HS2SC /SR000HS2SB
211 */
212 HWTEST_F(CfAdapterExtensionTest, OpensslDestoryExtensionTest001, TestSize.Level0)
213 {
214 CfOpensslDestoryExtension(nullptr); /* object is null */
215 CfBase *obj001 = nullptr;
216 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &obj001);
217 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
218
219 obj001->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT); /* object type error */
220 CfOpensslDestoryExtension(&obj001);
221
222 obj001->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION); /* normal case */
223 CfOpensslDestoryExtension(&obj001);
224 }
225
226 /**
227 * @tc.name: OpensslGetOidsTest001
228 * @tc.desc: Test CertFramework adapter extension object get all oids interface base function
229 * @tc.type: FUNC
230 * @tc.require: AR000HS2SC /SR000HS2SB
231 */
232 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest001, TestSize.Level0)
233 {
234 CfBase *object001 = nullptr;
235 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &object001);
236 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
237
238 CfBlobArray outArray = { nullptr, 0 };
239 ret = CfOpensslGetOids(object001, CF_EXT_TYPE_ALL_OIDS, &outArray);
240 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get all oids test failed, recode:" << ret;
241
242 EXPECT_EQ(true, CompareOidArray(&outArray, &g_expectAllOidArray)) << "The all oids obtained does not match";
243 FreeCfBlobArray(outArray.data, outArray.count);
244
245 CfOpensslDestoryExtension(&object001);
246 }
247
248 /**
249 * @tc.name: OpensslGetOidsTest002
250 * @tc.desc: Test CertFramework adapter extension object get critical oids interface base function
251 * @tc.type: FUNC
252 * @tc.require: AR000HS2SC /SR000HS2SB
253 */
254 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest002, TestSize.Level0)
255 {
256 CfBase *object002 = nullptr;
257 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &object002);
258 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
259
260 CfBlobArray outArray = { nullptr, 0 };
261 ret = CfOpensslGetOids(object002, CF_EXT_TYPE_CRITICAL_OIDS, &outArray);
262 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get critical oids test failed, recode:" << ret;
263
264 EXPECT_EQ(true, CompareOidArray(&outArray, &g_expectCritOidArray)) << "The critical oids obtained does not match";
265 FreeCfBlobArray(outArray.data, outArray.count);
266
267 CfOpensslDestoryExtension(&object002);
268 }
269
270 /**
271 * @tc.name: OpensslGetOidsTest003
272 * @tc.desc: Test CertFramework adapter extension object get uncritical oids interface base function
273 * @tc.type: FUNC
274 * @tc.require: AR000HS2SC /SR000HS2SB
275 */
276 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest003, TestSize.Level0)
277 {
278 CfBase *object003 = nullptr;
279 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &object003);
280 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
281
282 CfBlobArray outArray = { nullptr, 0 };
283 ret = CfOpensslGetOids(object003, CF_EXT_TYPE_UNCRITICAL_OIDS, &outArray);
284 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get uncritical oids test failed, recode:" << ret;
285
286 EXPECT_EQ(true, CompareOidArray(&outArray, &g_expectUncritOidArray)) <<
287 "The uncritical oids obtained does not match";
288 FreeCfBlobArray(outArray.data, outArray.count);
289
290 CfOpensslDestoryExtension(&object003);
291 }
292
293 /**
294 * @tc.name: OpensslGetOidsTest004
295 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
296 * @tc.type: FUNC
297 * @tc.require: AR000HS2SC /SR000HS2SB
298 */
299 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest004, TestSize.Level0)
300 {
301 CfBlobArray outArray = { nullptr, 0 };
302 int32_t ret = CfOpensslGetOids(nullptr, CF_EXT_TYPE_ALL_OIDS, &outArray); /* object is null */
303 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal exts object get all oids test failed, recode:" << ret;
304 }
305
306 /**
307 * @tc.name: OpensslGetOidsTest005
308 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
309 * @tc.type: FUNC
310 * @tc.require: AR000HS2SC /SR000HS2SB
311 */
312 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest005, TestSize.Level0)
313 {
314 CfBase object005 = { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) };
315 int32_t ret = CfOpensslGetOids(&object005, CF_EXT_TYPE_ALL_OIDS, nullptr); /* out is null */
316 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal exts object get all oids test failed, recode:" << ret;
317 }
318
319 /**
320 * @tc.name: OpensslGetOidsTest006
321 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
322 * @tc.type: FUNC
323 * @tc.require: AR000HS2SC /SR000HS2SB
324 */
325 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest006, TestSize.Level0)
326 {
327 CfOpensslExtensionObj exts = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT) }, nullptr };
328 CfBase *object006 = &exts.base; /* object type is error */
329 CfBlobArray outArray = { nullptr, 0 };
330 int32_t ret = CfOpensslGetOids(object006, CF_EXT_TYPE_ALL_OIDS, &outArray);
331 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal exts object get all oids test failed, recode:" << ret;
332 }
333
334 /**
335 * @tc.name: OpensslGetOidsTest007
336 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
337 * @tc.type: FUNC
338 * @tc.require: AR000HS2SC /SR000HS2SB
339 */
340 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest007, TestSize.Level0)
341 {
342 CfOpensslExtensionObj exts = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
343 CfBase *object007 = &exts.base; /* exts is null */
344 CfBlobArray outArray = { nullptr, 0 };
345 int32_t ret = CfOpensslGetOids(object007, CF_EXT_TYPE_ALL_OIDS, &outArray);
346 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Abnormal exts object get all oids test failed, recode:" << ret;
347 }
348
349 /**
350 * @tc.name: OpensslGetOidsTest008
351 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
352 * @tc.type: FUNC
353 * @tc.require: AR000HS2SC /SR000HS2SB
354 */
355 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest008, TestSize.Level0)
356 {
357 CfOpensslExtensionObj exts = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
358 CfBase *object008 = &exts.base;
359 CfBlobArray outArray = { nullptr, 0 };
360
361 X509_EXTENSIONS *tmpExts008 = sk_X509_EXTENSION_new_null();
362 sk_X509_EXTENSION_zero(tmpExts008);
363 exts.exts = tmpExts008; /* exts is exist but no extension member */
364 int32_t ret = CfOpensslGetOids(object008, CF_EXT_TYPE_ALL_OIDS, &outArray);
365 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal exts object get all oids test failed, recode:" << ret;
366
367 sk_X509_EXTENSION_pop_free(tmpExts008, X509_EXTENSION_free);
368 }
369
370 /**
371 * @tc.name: OpensslGetOidsTest009
372 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
373 * @tc.type: FUNC
374 * @tc.require: AR000HS2SC /SR000HS2SB
375 */
376 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest009, TestSize.Level0)
377 {
378 CfOpensslExtensionObj exts = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
379 CfBase *object009 = &exts.base;
380 CfBlobArray outArray = { nullptr, 0 };
381
382 X509_EXTENSIONS *tmpExts009 = sk_X509_EXTENSION_new_null();
383 exts.exts = tmpExts009;
384 sk_X509_EXTENSION_zero(tmpExts009);
385 (void)sk_X509_EXTENSION_push(tmpExts009, nullptr); /* exts has one extension member, but data is null */
386 int32_t ret = CfOpensslGetOids(object009, CF_EXT_TYPE_ALL_OIDS, &outArray);
387 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal exts object get all oids test failed, recode:" << ret;
388
389 sk_X509_EXTENSION_pop_free(tmpExts009, X509_EXTENSION_free);
390 }
391
392 /**
393 * @tc.name: OpensslGetOidsTest010
394 * @tc.desc: Test CertFramework adapter extension object get oids interface Abnormal function
395 * @tc.type: FUNC
396 * @tc.require: AR000HS2SC /SR000HS2SB
397 */
398 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest010, TestSize.Level0)
399 {
400 CfBase *object010 = nullptr;
401 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &object010);
402 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
403
404 CfBlobArray outArray = { nullptr, 0 };
405 /* extension type is undefined */
406 ret = CfOpensslGetOids(object010, static_cast<CfExtensionOidType>(INT_MAX), &outArray);
407 EXPECT_EQ(ret, CF_INVALID_PARAMS) << "Normal adapter exts object get oids test failed, recode:" << ret;
408
409 CfOpensslDestoryExtension(&object010);
410 }
411
412 /**
413 * @tc.name: OpensslGetOidsTest011
414 * @tc.desc: Test CertFramework adapter extension object get oids interface performance
415 * @tc.type: FUNC
416 * @tc.require: AR000HS2SC /SR000HS2SB
417 */
418 HWTEST_F(CfAdapterExtensionTest, OpensslGetOidsTest011, TestSize.Level0)
419 {
420 CfBase *object011 = nullptr;
421 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &object011);
422 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
423
424 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
425 CfBlobArray outArray = { nullptr, 0 };
426
427 ret = CfOpensslGetOids(object011, CF_EXT_TYPE_ALL_OIDS, &outArray);
428 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter exts object get all oids test failed, recode:" << ret;
429 EXPECT_EQ(true, CompareOidArray(&outArray, &g_expectAllOidArray)) << "The all oids obtained does not match";
430 FreeCfBlobArray(outArray.data, outArray.count);
431
432 ret = CfOpensslGetOids(object011, CF_EXT_TYPE_CRITICAL_OIDS, &outArray);
433 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter exts object get critical oids test failed, recode:" << ret;
434 EXPECT_EQ(true, CompareOidArray(&outArray, &g_expectCritOidArray)) <<
435 "The critical oids obtained does not match";
436 FreeCfBlobArray(outArray.data, outArray.count);
437
438 ret = CfOpensslGetOids(object011, CF_EXT_TYPE_UNCRITICAL_OIDS, &outArray);
439 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter exts object get uncritical oids test failed, recode:" << ret;
440 EXPECT_EQ(true, CompareOidArray(&outArray, &g_expectUncritOidArray)) <<
441 "The uncritical oids obtained does not match";
442 FreeCfBlobArray(outArray.data, outArray.count);
443 }
444
445 CfOpensslDestoryExtension(&object011);
446 }
447
448 /**
449 * @tc.name: OpensslGetEntryTest001
450 * @tc.desc: Test CertFramework adapter extension object get entry interface base function
451 * @tc.type: FUNC
452 * @tc.require: AR000HS2SC /SR000HS2SB
453 */
454 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest001, TestSize.Level0)
455 {
456 CfBase *obj001 = nullptr;
457 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj001);
458 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
459
460 char oidStr[] = "2.5.29.19";
461 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
462 CfBlob outBlob = { 0, nullptr };
463 ret = CfOpensslGetEntry(obj001, CF_EXT_ENTRY_TYPE_ENTRY, &oid, &outBlob);
464 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get entry test failed, recode:" << ret;
465 EXPECT_EQ(true, CompareBlob(&outBlob, &g_extensionEntryBlob01)) <<
466 "Normal adapter extension object get entry test failed, get outBlob faield";
467 CF_FREE_BLOB(outBlob);
468
469 CfOpensslDestoryExtension(&obj001);
470 }
471
472 /**
473 * @tc.name: OpensslGetEntryTest002
474 * @tc.desc: Test CertFramework adapter extension object get entry crirical interface base function
475 * @tc.type: FUNC
476 * @tc.require: AR000HS2SC /SR000HS2SB
477 */
478 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest002, TestSize.Level0)
479 {
480 CfBase *obj002 = nullptr;
481 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj002);
482 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
483
484 char oidStr[] = "2.5.29.19";
485 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
486 CfBlob outBlob = { 0, nullptr };
487 ret = CfOpensslGetEntry(obj002, CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL, &oid, &outBlob);
488 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get entry crirical test failed, recode:" << ret;
489 EXPECT_EQ(true, CompareBlob(&outBlob, &g_extensionEntryCriticalBlob01)) <<
490 "Normal adapter extension object get entry test failed, get outBlob faield";
491 CF_FREE_BLOB(outBlob);
492
493 CfOpensslDestoryExtension(&obj002);
494 }
495
496 /**
497 * @tc.name: OpensslGetEntryTest003
498 * @tc.desc: Test CertFramework adapter extension object get entry value interface base function
499 * @tc.type: FUNC
500 * @tc.require: AR000HS2SC /SR000HS2SB
501 */
502 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest003, TestSize.Level0)
503 {
504 CfBase *obj003 = nullptr;
505 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj003);
506 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
507
508 char oidStr[] = "2.5.29.19";
509 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
510 CfBlob outBlob = { 0, nullptr };
511 ret = CfOpensslGetEntry(obj003, CF_EXT_ENTRY_TYPE_ENTRY_VALUE, &oid, &outBlob);
512 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get entry value test failed, recode:" << ret;
513 EXPECT_EQ(true, CompareBlob(&outBlob, &g_extensionEntryValueBlob01)) <<
514 "Normal adapter extension object get entry test failed, get outBlob faield";
515 CF_FREE_BLOB(outBlob);
516
517 CfOpensslDestoryExtension(&obj003);
518 }
519
520 /**
521 * @tc.name: OpensslGetEntryTest004
522 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
523 * @tc.type: FUNC
524 * @tc.require: AR000HS2SC /SR000HS2SB
525 */
526 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest004, TestSize.Level0)
527 {
528 char oidStr[] = "2.5.29.19";
529 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
530 CfBlob outBlob = { 0, nullptr };
531
532 // the object is abnormal param
533 int32_t ret = CfOpensslGetEntry(nullptr, CF_EXT_ENTRY_TYPE_ENTRY, &oid, &outBlob); /* object is null */
534 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
535 "Abnormal adapter extension object get entry test failed, recode:" << ret;
536 }
537
538 /**
539 * @tc.name: OpensslGetEntryTest005
540 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
541 * @tc.type: FUNC
542 * @tc.require: AR000HS2SC /SR000HS2SB
543 */
544 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest005, TestSize.Level0)
545 {
546 CfBase *obj005 = nullptr;
547 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj005);
548 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
549
550 char oidStr[] = "2.5.29.19";
551 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
552 CfBlob outBlob = { 0, nullptr };
553
554 unsigned long correctType = obj005->type;
555 obj005->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT); /* object type error */
556 ret = CfOpensslGetEntry(obj005, CF_EXT_ENTRY_TYPE_ENTRY, &oid, &outBlob);
557 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
558 "Abnormal adapter extension object get entry test failed, recode:" << ret;
559
560 obj005->type = correctType;
561 CfOpensslDestoryExtension(&obj005);
562 }
563
564 /**
565 * @tc.name: OpensslGetEntryTest006
566 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
567 * @tc.type: FUNC
568 * @tc.require: AR000HS2SC /SR000HS2SB
569 */
570 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest006, TestSize.Level0)
571 {
572 CfBase *obj006 = nullptr;
573 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj006);
574 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
575
576 char oidStr[] = "2.5.29.19";
577 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
578 CfBlob outBlob = { 0, nullptr };
579
580
581 CfOpensslExtensionObj *extsObj = (CfOpensslExtensionObj *)obj006;
582 X509_EXTENSIONS *correctExts = extsObj->exts;
583 extsObj->exts = nullptr; /* exts data is nullptr */
584 ret = CfOpensslGetEntry(obj006, CF_EXT_ENTRY_TYPE_ENTRY, &oid, &outBlob);
585 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
586 "Abnormal adapter extension object get entry test failed, recode:" << ret;
587
588 extsObj->exts = correctExts;
589 CfOpensslDestoryExtension(&obj006);
590 }
591
592 /**
593 * @tc.name: OpensslGetEntryTest007
594 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
595 * @tc.type: FUNC
596 * @tc.require: AR000HS2SC /SR000HS2SB
597 */
598 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest007, TestSize.Level0)
599 {
600 char oidStr[] = "2.5.29.19";
601 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
602 CfBlob outBlob = { 0, nullptr };
603
604 CfOpensslExtensionObj exts007 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
605 X509_EXTENSIONS *tmpExts007 = sk_X509_EXTENSION_new_null();
606 exts007.exts = tmpExts007; /* exts is exist but no extension member */
607 sk_X509_EXTENSION_zero(tmpExts007);
608 int32_t ret = CfOpensslGetEntry(&(exts007.base), CF_EXT_ENTRY_TYPE_ENTRY, &oid, &outBlob);
609 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) <<
610 "Abnormal adapter extension object get entry test failed, recode:" << ret;
611
612 sk_X509_EXTENSION_pop_free(tmpExts007, X509_EXTENSION_free);
613 }
614
615 /**
616 * @tc.name: OpensslGetEntryTest008
617 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
618 * @tc.type: FUNC
619 * @tc.require: AR000HS2SC /SR000HS2SB
620 */
621 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest008, TestSize.Level0)
622 {
623 char oidStr[] = "2.5.29.19";
624 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
625 CfBlob outBlob = { 0, nullptr };
626
627 CfOpensslExtensionObj exts008 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
628 X509_EXTENSIONS *tmpExts008 = sk_X509_EXTENSION_new_null();
629 exts008.exts = tmpExts008;
630 sk_X509_EXTENSION_zero(tmpExts008);
631 (void)sk_X509_EXTENSION_push(tmpExts008, nullptr); /* exts has one extension member, but data is null */
632 int32_t ret = CfOpensslGetEntry(&(exts008.base), CF_EXT_ENTRY_TYPE_ENTRY, &oid, &outBlob);
633 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) <<
634 "Abnormal adapter extension object get entry test5 failed, recode:" << ret;
635
636 sk_X509_EXTENSION_pop_free(tmpExts008, X509_EXTENSION_free);
637 }
638
639 /**
640 * @tc.name: OpensslGetEntryTest008
641 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
642 * @tc.type: FUNC
643 * @tc.require: AR000HS2SC /SR000HS2SB
644 */
645 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest009, TestSize.Level0)
646 {
647 CfBase *obj009 = nullptr;
648 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj009);
649 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
650
651 char oidStr[] = "2.5.29.19";
652 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
653 CfBlob outBlob = { 0, nullptr };
654
655 CfExtensionEntryType errorType = static_cast<CfExtensionEntryType>(INT_MAX);
656 ret = CfOpensslGetEntry(obj009, errorType, &oid, &outBlob); /* type is error */
657 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
658 "Abnormal adapter extension object get entry test failed, recode:" << ret;
659
660 CfOpensslDestoryExtension(&obj009);
661 }
662
663 /**
664 * @tc.name: OpensslGetEntryTest010
665 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
666 * @tc.type: FUNC
667 * @tc.require: AR000HS2SC /SR000HS2SB
668 */
669 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest010, TestSize.Level0)
670 {
671 CfBase *obj010 = nullptr;
672 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj010);
673 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
674
675 CfBlob outBlob = { 0, nullptr };
676 // the oid is abnormal param
677 ret = CfOpensslGetEntry(nullptr, CF_EXT_ENTRY_TYPE_ENTRY, nullptr, &outBlob); /* oid is null */
678 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
679 "Abnormal adapter extension object get entry test1 failed, recode:" << ret;
680
681 char oidStr[] = "2.5.29.19";
682 char oidErrStr1[] = "errorFormatData";
683 char oidErrStr2[] = "2.5.29.20";
684 CfBlob errorOidArray[] = {
685 { strlen(oidStr), nullptr }, /* oid data is null */
686 { 0, reinterpret_cast<uint8_t *>(oidStr) }, /* the size of oid data is 0 */
687 { MAX_LEN_OID + 1, reinterpret_cast<uint8_t *>(oidStr) }, /* the size of oid data is too larger */
688 { strlen(oidErrStr1), reinterpret_cast<uint8_t *>(oidErrStr1) }, /* oid data is wrong */
689 { strlen(oidErrStr2), reinterpret_cast<uint8_t *>(oidErrStr2) }, /* oid data is no include in exts */
690 };
691 int32_t expectRet[] = { CF_INVALID_PARAMS, CF_INVALID_PARAMS, CF_INVALID_PARAMS,
692 CF_INVALID_PARAMS, CF_NOT_EXIST };
693 for (uint32_t i = 0; i < sizeof(errorOidArray) / sizeof(errorOidArray[0]); ++i) {
694 CfBlob tmpOutBlob = { 0, nullptr };
695 ret = CfOpensslGetEntry(obj010, CF_EXT_ENTRY_TYPE_ENTRY, &(errorOidArray[i]), &tmpOutBlob);
696 EXPECT_EQ(ret, expectRet[i]) <<
697 "Abnormal adapter extension object get entry test2 failed, index:," << i << " retcode:" << ret;
698 }
699
700 CfOpensslDestoryExtension(&obj010);
701 }
702
703 /**
704 * @tc.name: OpensslGetEntryTest011
705 * @tc.desc: Test CertFramework adapter extension object get entry interface Abnormal function
706 * @tc.type: FUNC
707 * @tc.require: AR000HS2SC /SR000HS2SB
708 */
709 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest011, TestSize.Level0)
710 {
711 CfBase *obj011 = nullptr;
712 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj011);
713 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
714
715 char oidStr[] = "2.5.29.19";
716 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
717 ret = CfOpensslGetEntry(obj011, CF_EXT_ENTRY_TYPE_ENTRY_VALUE, &oid, nullptr); /* outBlob is null */
718 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
719 "Abnormal adapter extension object get entry test failed, recode:" << ret;
720
721 CfOpensslDestoryExtension(&obj011);
722 }
723
724 /**
725 * @tc.name: OpensslGetEntryTest012
726 * @tc.desc: Test CertFramework adapter extension object get entry interface performance
727 * @tc.type: FUNC
728 * @tc.require: AR000HS2SC /SR000HS2SB
729 */
730 HWTEST_F(CfAdapterExtensionTest, OpensslGetEntryTest012, TestSize.Level0)
731 {
732 CfBase *obj012 = nullptr;
733 int32_t ret = CfOpensslCreateExtension(&g_extension[0], &obj012);
734 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
735
736 char oidStr[] = "2.5.29.19";
737 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
738 CfExtensionEntryType typeArray[] = {
739 CF_EXT_ENTRY_TYPE_ENTRY,
740 CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL,
741 CF_EXT_ENTRY_TYPE_ENTRY_VALUE,
742 };
743
744 for (uint32_t i = 0; i < sizeof(typeArray) / sizeof(typeArray[0]); ++i) {
745 for (uint32_t j = 0; j < PERFORMANCE_COUNT; ++j) { /* run 1000 times */
746 CfBlob outBlob = { 0, nullptr };
747 ret = CfOpensslGetEntry(obj012, typeArray[i], &oid, &outBlob);
748 EXPECT_EQ(ret, CF_SUCCESS) <<
749 "Normal adapter extension object get entry test failed, index:," << i << "recode:" << ret;
750 CF_FREE_BLOB(outBlob);
751 }
752 }
753
754 CfOpensslDestoryExtension(&obj012);
755 }
756
757 /**
758 * @tc.name: OpensslCheckCATest001
759 * @tc.desc: Test CertFramework adapter extension object check CA interface base function
760 * @tc.type: FUNC
761 * @tc.require: AR000HS2SC /SR000HS2SB
762 */
763 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest001, TestSize.Level0)
764 {
765 CfEncodingBlob extsArray[] = { g_extension[0], g_extension[1], g_extension[2] };
766 int32_t expectPathLenArray[] = {
767 BASIC_CONSTRAINTS_PATHLEN_NO_LIMIT, BASIC_CONSTRAINTS_PATHLEN_NO_LIMIT, 2 /* the 2 is the expect length */
768 };
769
770 for (uint32_t i = 0; i < sizeof(extsArray) / sizeof(extsArray[0]); ++i) {
771 CfBase *extsObj001 = nullptr;
772 int32_t ret = CfOpensslCreateExtension(&extsArray[i], &extsObj001);
773 EXPECT_EQ(ret, CF_SUCCESS) <<
774 "Normal adapter create extension object test1 failed, index:" << i << ", ret:" << ret;
775
776 int32_t pathLen = 0;
777 ret = CfOpensslCheckCA(extsObj001, &pathLen);
778 EXPECT_EQ(ret, CF_SUCCESS) <<
779 "Normal adapter extension object check CA test2 failed, index:" << i << ", ret:" << ret;
780 EXPECT_EQ(pathLen, expectPathLenArray[i]) <<
781 "Normal adapter extension object check CA test2 failed, index:" << i << ", pathLen:" << pathLen;
782 CfOpensslDestoryExtension(&extsObj001);
783 }
784 }
785
786 /**
787 * @tc.name: OpensslCheckCATest002
788 * @tc.desc: Test CertFramework adapter extension object check CA interface base function
789 * @tc.type: FUNC
790 * @tc.require: AR000HS2SC /SR000HS2SB
791 */
792 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest002, TestSize.Level0)
793 {
794 int32_t pathLen = 0;
795 CfOpensslExtensionObj exts002 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
796 X509_EXTENSIONS *tmpExts002 = sk_X509_EXTENSION_new_null();
797 sk_X509_EXTENSION_zero(tmpExts002);
798 exts002.exts = tmpExts002;
799
800 uint8_t data[] = "1"; // the length of keyUsage is 1 and can pass no CA check
801 ASN1_BIT_STRING bitStr = { strlen(reinterpret_cast<char *>(data)), V_ASN1_BIT_STRING, data, 0 };
802 X509_EXTENSION *keyUsageExt = X509V3_EXT_i2d(NID_key_usage, 0, reinterpret_cast<void *>(&bitStr));
803
804 (void)sk_X509_EXTENSION_push(tmpExts002, keyUsageExt);
805 int32_t ret = CfOpensslCheckCA(&(exts002.base), &pathLen);
806 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object check CA test failed, recode:" << ret;
807 EXPECT_EQ(pathLen, BASIC_CONSTRAINTS_NO_CA) << "Normal test failed, not get the expected return value.";
808 (void)sk_X509_EXTENSION_pop(tmpExts002);
809 X509_EXTENSION_free(keyUsageExt);
810
811 sk_X509_EXTENSION_pop_free(tmpExts002, X509_EXTENSION_free);
812 }
813
814 /**
815 * @tc.name: OpensslCheckCATest003
816 * @tc.desc: Test CertFramework adapter extension object check CA interface base function
817 * @tc.type: FUNC
818 * @tc.require: AR000HS2SC /SR000HS2SB
819 */
820 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest003, TestSize.Level0)
821 {
822 int32_t pathLen = 0;
823 CfOpensslExtensionObj exts003 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
824 X509_EXTENSIONS *tmpExts003 = sk_X509_EXTENSION_new_null();
825 sk_X509_EXTENSION_zero(tmpExts003);
826 exts003.exts = tmpExts003;
827
828 uint8_t data[] = "test"; // the length of keyUsage is over 1 and can pass CA check
829 ASN1_BIT_STRING bitStr = { strlen(reinterpret_cast<char *>(data)), V_ASN1_BIT_STRING, data, 0 };
830 X509_EXTENSION *keyUsageExt = X509V3_EXT_i2d(NID_key_usage, 0, reinterpret_cast<void *>(&bitStr));
831 (void)sk_X509_EXTENSION_push(tmpExts003, keyUsageExt);
832
833 BASIC_CONSTRAINTS basic = { .ca = 0, .pathlen = nullptr }; // the 0 indicates that it is a CA
834 X509_EXTENSION *basicConExt = X509V3_EXT_i2d(NID_basic_constraints, 0, reinterpret_cast<void *>(&basic));
835 (void)sk_X509_EXTENSION_push(tmpExts003, basicConExt);
836
837 int32_t ret = CfOpensslCheckCA(&(exts003.base), &pathLen);
838 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object check CA test failed, recode:" << ret;
839 EXPECT_EQ(pathLen, BASIC_CONSTRAINTS_NO_CA) << "Normal test failed, not get the expected return value.";
840
841 (void)sk_X509_EXTENSION_pop(tmpExts003);
842 (void)sk_X509_EXTENSION_pop(tmpExts003);
843 X509_EXTENSION_free(basicConExt);
844 X509_EXTENSION_free(keyUsageExt);
845 sk_X509_EXTENSION_pop_free(tmpExts003, X509_EXTENSION_free);
846 }
847
848 /**
849 * @tc.name: OpensslCheckCATest004
850 * @tc.desc: Test CertFramework adapter extension object check CA interface base function
851 * @tc.type: FUNC
852 * @tc.require: AR000HS2SC /SR000HS2SB
853 */
854 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest004, TestSize.Level0)
855 {
856 int32_t pathLen = 0;
857 CfOpensslExtensionObj exts004 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
858 X509_EXTENSIONS *tmpExts004 = sk_X509_EXTENSION_new_null();
859 sk_X509_EXTENSION_zero(tmpExts004);
860 exts004.exts = tmpExts004;
861
862 uint8_t data2[] = "test"; // the length of keyUsage is over 1 and can pass CA check
863 ASN1_BIT_STRING bitStr = { strlen(reinterpret_cast<char *>(data2)), V_ASN1_BIT_STRING, data2, 0 };
864 X509_EXTENSION *keyUsageExt = X509V3_EXT_i2d(NID_key_usage, 0, reinterpret_cast<void *>(&bitStr));
865 (void)sk_X509_EXTENSION_push(tmpExts004, keyUsageExt);
866
867 BASIC_CONSTRAINTS basic = { .ca = 1, .pathlen = nullptr }; // the 1 indicates that it is a CA
868 X509_EXTENSION *basicConExt = X509V3_EXT_i2d(NID_basic_constraints, 0, reinterpret_cast<void *>(&basic));
869 (void)sk_X509_EXTENSION_push(tmpExts004, basicConExt);
870
871 int32_t ret = CfOpensslCheckCA(&(exts004.base), &pathLen);
872 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object check CA test failed, recode:" << ret;
873 EXPECT_EQ(pathLen, BASIC_CONSTRAINTS_PATHLEN_NO_LIMIT) <<
874 "Normal test failed, not get the expected return value.";
875
876 (void)sk_X509_EXTENSION_pop(tmpExts004);
877 (void)sk_X509_EXTENSION_pop(tmpExts004);
878 X509_EXTENSION_free(basicConExt);
879 X509_EXTENSION_free(keyUsageExt);
880 sk_X509_EXTENSION_pop_free(tmpExts004, X509_EXTENSION_free);
881 }
882
883 /**
884 * @tc.name: OpensslCheckCATest005
885 * @tc.desc: Test CertFramework adapter extension object check CA interface Abnormal function
886 * @tc.type: FUNC
887 * @tc.require: AR000HS2SC /SR000HS2SB
888 */
889 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest005, TestSize.Level0)
890 {
891 int32_t pathLen = 0;
892 int32_t ret = CfOpensslCheckCA(nullptr, &pathLen); /* object is null */
893 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
894 "Abnormal adapter extension object check CA test failed, recode:" << ret;
895 }
896
897 /**
898 * @tc.name: OpensslCheckCATest006
899 * @tc.desc: Test CertFramework adapter extension object check CA interface Abnormal function
900 * @tc.type: FUNC
901 * @tc.require: AR000HS2SC /SR000HS2SB
902 */
903 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest006, TestSize.Level0)
904 {
905 CfBase *extsObj006 = nullptr;
906 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &extsObj006);
907 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
908
909 int32_t pathLen = 0;
910 unsigned long correctType = extsObj006->type;
911 extsObj006->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT); /* object type error */
912 ret = CfOpensslCheckCA(extsObj006, &pathLen);
913 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
914 "Abnormal adapter extension object check CA test failed, recode:" << ret;
915
916 extsObj006->type = correctType;
917 CfOpensslDestoryExtension(&extsObj006);
918 }
919
920 /**
921 * @tc.name: OpensslCheckCATest007
922 * @tc.desc: Test CertFramework adapter extension object check CA interface Abnormal function
923 * @tc.type: FUNC
924 * @tc.require: AR000HS2SC /SR000HS2SB
925 */
926 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest007, TestSize.Level0)
927 {
928 int32_t pathLen = 0;
929 /* exts data is nullptr */
930 CfOpensslExtensionObj exts007 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
931 int32_t ret = CfOpensslCheckCA(&(exts007.base), &pathLen);
932 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
933 "Abnormal adapter extension object check CA test failed, recode:" << ret;
934 }
935
936 /**
937 * @tc.name: OpensslCheckCATest008
938 * @tc.desc: Test CertFramework adapter extension object check CA interface Abnormal function
939 * @tc.type: FUNC
940 * @tc.require: AR000HS2SC /SR000HS2SB
941 */
942 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest008, TestSize.Level0)
943 {
944 int32_t pathLen = 0;
945 CfOpensslExtensionObj exts008 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
946
947 X509_EXTENSIONS *tmpExts008 = sk_X509_EXTENSION_new_null();
948 sk_X509_EXTENSION_zero(tmpExts008);
949 exts008.exts = tmpExts008; /* exts is exist but no extension member */
950 int32_t ret = CfOpensslCheckCA(&(exts008.base), &pathLen);
951 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) << "Abnormal adapter extension object check CA test failed, recode:" << ret;
952
953 sk_X509_EXTENSION_pop_free(tmpExts008, X509_EXTENSION_free);
954 }
955
956 /**
957 * @tc.name: OpensslCheckCATest009
958 * @tc.desc: Test CertFramework adapter extension object check CA interface Abnormal function
959 * @tc.type: FUNC
960 * @tc.require: AR000HS2SC /SR000HS2SB
961 */
962 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest009, TestSize.Level0)
963 {
964 int32_t pathLen = 0;
965 CfOpensslExtensionObj exts009 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
966 X509_EXTENSIONS *tmpExts009 = sk_X509_EXTENSION_new_null();
967 sk_X509_EXTENSION_zero(tmpExts009);
968 exts009.exts = tmpExts009;
969
970 uint8_t data[] = "test"; // the length of keyUsage is over 1 and can pass CA check, but no basic constraints
971 ASN1_BIT_STRING bitStr = { strlen(reinterpret_cast<char *>(data)), V_ASN1_BIT_STRING, data, 0 };
972 X509_EXTENSION *keyUsageExt = X509V3_EXT_i2d(NID_key_usage, 0, reinterpret_cast<void *>(&bitStr));
973
974 (void)sk_X509_EXTENSION_push(tmpExts009, keyUsageExt);
975 int32_t ret = CfOpensslCheckCA(&(exts009.base), &pathLen);
976 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) <<
977 "Abnormal adapter extension object check CA test4 failed, recode:" << ret;
978 (void)sk_X509_EXTENSION_pop(tmpExts009);
979 X509_EXTENSION_free(keyUsageExt);
980
981 sk_X509_EXTENSION_pop_free(tmpExts009, X509_EXTENSION_free);
982 }
983
984 /**
985 * @tc.name: OpensslCheckCATest010
986 * @tc.desc: Test CertFramework adapter extension object check CA interface Abnormal function
987 * @tc.type: FUNC
988 * @tc.require: AR000HS2SC /SR000HS2SB
989 */
990 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest010, TestSize.Level0)
991 {
992 CfOpensslExtensionObj exts010 = { { CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_EXTENSION) }, nullptr };
993 int32_t ret = CfOpensslCheckCA(&(exts010.base), nullptr); /* pathLen is null */
994 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
995 "Abnormal adapter extension object check CA test failed, recode:" << ret;
996 }
997
998 /**
999 * @tc.name: OpensslCheckCATest011
1000 * @tc.desc: Test CertFramework adapter extension object check CA interface performance
1001 * @tc.type: FUNC
1002 * @tc.require: AR000HS2SC /SR000HS2SB
1003 */
1004 HWTEST_F(CfAdapterExtensionTest, OpensslCheckCATest011, TestSize.Level0)
1005 {
1006 CfBase *extsObj011 = nullptr;
1007 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &extsObj011);
1008 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1009
1010 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
1011 int32_t pathLen = 0;
1012 ret = CfOpensslCheckCA(extsObj011, &pathLen);
1013 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object check CA test failed, recode:" << ret;
1014 }
1015
1016 CfOpensslDestoryExtension(&extsObj011);
1017 }
1018
1019 /**
1020 * @tc.name: OpensslGetExtensionItemTest001
1021 * @tc.desc: Test CertFramework adapter extension object get extension item interface base function
1022 * @tc.type: FUNC
1023 * @tc.require: AR000HS2SC /SR000HS2SB
1024 */
1025 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest001, TestSize.Level0)
1026 {
1027 CfBase *obj001 = nullptr;
1028 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj001);
1029 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1030
1031 CfBlob blob = {g_extension[1].len, g_extension[1].data};
1032 CfBlob outBlob = { 0, nullptr };
1033 ret = CfOpensslGetExtensionItem(obj001, CF_ITEM_ENCODED, &outBlob);
1034 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter extension object get extension encoded test failed, recode:" << ret;
1035 EXPECT_EQ(true, CompareBlob(&outBlob, &blob)) <<
1036 "Normal adapter extension object get extension encoded test failed, get outBlob faield";
1037 CF_FREE_BLOB(outBlob);
1038 CfOpensslDestoryExtension(&obj001);
1039 }
1040
1041 /**
1042 * @tc.name: OpensslGetExtensionItemTest002
1043 * @tc.desc: Test CertFramework adapter extension object get extension item interface Abnormal function
1044 * @tc.type: FUNC
1045 * @tc.require: AR000HS2SC /SR000HS2SB
1046 */
1047 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest002, TestSize.Level0)
1048 {
1049 CfBase *obj002 = nullptr;
1050 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj002);
1051 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1052
1053 CfBlob outBlob = { 0, nullptr };
1054 ret = CfOpensslGetExtensionItem(obj002, CF_ITEM_PUBLIC_KEY, &outBlob); /* id is invalid */
1055 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1056 "Abnormal adapter extension object get extension encoded test failed, recode:" << ret;
1057
1058 CF_FREE_BLOB(outBlob);
1059 CfOpensslDestoryExtension(&obj002);
1060 }
1061
1062 /**
1063 * @tc.name: OpensslGetExtensionItemTest003
1064 * @tc.desc: Test CertFramework adapter extension object get extension item interface Abnormal function
1065 * @tc.type: FUNC
1066 * @tc.require: AR000HS2SC /SR000HS2SB
1067 */
1068 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest003, TestSize.Level0)
1069 {
1070 CfBase *obj003 = nullptr;
1071 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj003);
1072 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1073
1074 ret = CfOpensslGetExtensionItem(obj003, CF_ITEM_ENCODED, nullptr); /* outBlob is null */
1075 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1076 "Abnormal adapter extension object get extension encoded test failed, recode:" << ret;
1077
1078 CfOpensslDestoryExtension(&obj003);
1079 }
1080
1081 /**
1082 * @tc.name: OpensslGetExtensionItemTest004
1083 * @tc.desc: Test CertFramework adapter extension object get extension item interface Abnormal function
1084 * @tc.type: FUNC
1085 * @tc.require: AR000HS2SC /SR000HS2SB
1086 */
1087 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest004, TestSize.Level0)
1088 {
1089 CfBlob outBlob = { 0, nullptr };
1090 int32_t ret = CfOpensslGetExtensionItem(nullptr, CF_ITEM_ENCODED, &outBlob); /* object is null */
1091 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1092 "Abnormal adapter extension object get extension encoded test failed, recode:" << ret;
1093 CF_FREE_BLOB(outBlob);
1094 }
1095
1096 /**
1097 * @tc.name: OpensslGetExtensionItemTest005
1098 * @tc.desc: Test CertFramework adapter extension object get extension item interface Abnormal function
1099 * @tc.type: FUNC
1100 * @tc.require: AR000HS2SC /SR000HS2SB
1101 */
1102 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest005, TestSize.Level0)
1103 {
1104 CfBase *obj005 = nullptr;
1105 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj005);
1106 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1107
1108 unsigned long correctType = obj005->type;
1109 obj005->type = CF_MAGIC(CF_MAGIC_TYPE_ADAPTER_RESOURCE, CF_OBJ_TYPE_CERT); /* object type error */
1110
1111 CfBlob outBlob = { 0, nullptr };
1112 ret = CfOpensslGetExtensionItem(obj005, CF_ITEM_ENCODED, &outBlob);
1113 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1114 "Abnormal adapter extension object get extension encoded test failed, recode:" << ret;
1115
1116 CF_FREE_BLOB(outBlob);
1117 obj005->type = correctType;
1118 CfOpensslDestoryExtension(&obj005);
1119 }
1120
1121 /**
1122 * @tc.name: OpensslGetExtensionItemTest006
1123 * @tc.desc: Test CertFramework adapter extension object get extension item interface Abnormal function
1124 * @tc.type: FUNC
1125 * @tc.require: AR000HS2SC /SR000HS2SB
1126 */
1127 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest006, TestSize.Level0)
1128 {
1129 CfBase *obj006 = nullptr;
1130 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj006);
1131 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1132
1133 CfOpensslExtensionObj *extsObj = (CfOpensslExtensionObj *)obj006;
1134 X509_EXTENSIONS *exts = extsObj->exts;
1135 extsObj->exts = nullptr; /* exts is null */
1136
1137 CfBlob outBlob = { 0, nullptr };
1138 ret = CfOpensslGetExtensionItem(obj006, CF_ITEM_ENCODED, &outBlob);
1139 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1140 "Abnormal adapter extension object get extension encoded test failed, recode:" << ret;
1141
1142 CF_FREE_BLOB(outBlob);
1143 extsObj->exts = exts;
1144 CfOpensslDestoryExtension(&obj006);
1145 }
1146
1147 /**
1148 * @tc.name: OpensslGetExtensionItemTest007
1149 * @tc.desc: Test CertFramework adapter extension object get extension item interface performance
1150 * @tc.type: FUNC
1151 * @tc.require: AR000HS2SC /SR000HS2SB
1152 */
1153 HWTEST_F(CfAdapterExtensionTest, OpensslGetExtensionItemTest007, TestSize.Level0)
1154 {
1155 CfBase *obj007 = nullptr;
1156 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj007);
1157 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, recode:" << ret;
1158
1159 CfBlob blob = {g_extension[1].len, g_extension[1].data};
1160
1161 for (uint32_t i = 0; i < PERFORMANCE_COUNT; ++i) { /* run 1000 times */
1162 CfBlob outBlob = { 0, nullptr };
1163 ret = CfOpensslGetExtensionItem(obj007, CF_ITEM_ENCODED, &outBlob);
1164 EXPECT_EQ(ret, CF_SUCCESS) <<
1165 "Normal adapter extension object get extension encoded test failed, recode:" << ret;
1166 EXPECT_EQ(true, CompareBlob(&outBlob, &blob)) <<
1167 "Normal adapter extension object get extension encoded test failed, get outBlob faield";
1168 CF_FREE_BLOB(outBlob);
1169 }
1170
1171 CfOpensslDestoryExtension(&obj007);
1172 }
1173
1174 /**
1175 * @tc.name: OpensslHasUnsupportedCriticalExtensionTest001
1176 * @tc.desc: Test CertFramework adapter extension object has unsupported critical extension interface Abnormal function
1177 * @tc.type: FUNC
1178 * @tc.require: AR000HS2SC /SR000HS2SB
1179 */
1180 HWTEST_F(CfAdapterExtensionTest, OpensslHasUnsupportedCriticalExtensionTest001, TestSize.Level0)
1181 {
1182 CfBase *obj001 = nullptr;
1183 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj001);
1184 bool bRet = false;
1185 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, retcode:" << ret;
1186
1187 ret = CfOpensslHasUnsupportedCriticalExtension(nullptr, &bRet);
1188 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1189 "Abnormal adapter extension object has unsupported critical extension test failed, recode:" << ret;
1190
1191 CfOpensslDestoryExtension(&obj001);
1192 }
1193
1194 /**
1195 * @tc.name: OpensslHasUnsupportedCriticalExtensionTest002
1196 * @tc.desc: Test CertFramework adapter extension object has unsupported critical extension interface Abnormal function
1197 * @tc.type: FUNC
1198 * @tc.require: AR000HS2SC /SR000HS2SB
1199 */
1200 HWTEST_F(CfAdapterExtensionTest, OpensslHasUnsupportedCriticalExtensionTest002, TestSize.Level0)
1201 {
1202 CfBase *obj002 = nullptr;
1203 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &obj002);
1204 bool bRet = false;
1205 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, rectode:" << ret;
1206
1207 CfOpensslExtensionObj *extsObj = (CfOpensslExtensionObj *)obj002;
1208 X509_EXTENSIONS *exts = extsObj->exts;
1209
1210 uint8_t data[] = "test";
1211 ASN1_BIT_STRING bitStr = { strlen(reinterpret_cast<char *>(data)), V_ASN1_BIT_STRING, data, 0 };
1212 X509_EXTENSION *netscapeCommentExt = X509V3_EXT_i2d(NID_netscape_comment, 1, reinterpret_cast<void *>(&bitStr));
1213
1214 (void)sk_X509_EXTENSION_push(exts, netscapeCommentExt);
1215
1216 ret = CfOpensslHasUnsupportedCriticalExtension(obj002, &bRet);
1217 EXPECT_EQ(ret, CF_SUCCESS) <<
1218 "Abnormal adapter extension object has unsupported critical extension test failed, retcode:" << ret;
1219 EXPECT_EQ(bRet, true);
1220
1221 (void)sk_X509_EXTENSION_pop(exts);
1222 X509_EXTENSION_free(netscapeCommentExt);
1223 CfOpensslDestoryExtension(&obj002);
1224 }
1225
1226 /**
1227 * @tc.name: OpensslHasUnsupportedCriticalExtensionTest003
1228 * @tc.desc: Test CertFramework adapter extension object has unsupported critical extension interface Abnormal function
1229 * @tc.type: FUNC
1230 * @tc.require: AR000HS2SC /SR000HS2SB
1231 */
1232 HWTEST_F(CfAdapterExtensionTest, OpensslHasUnsupportedCriticalExtensionTest003, TestSize.Level0)
1233 {
1234 CfBase *obj003 = nullptr;
1235 int32_t ret = CfOpensslCreateExtension(&g_extension[1], &obj003);
1236 bool bRet = false;
1237 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, retcode:" << ret;
1238
1239 CfOpensslExtensionObj *extsObj = (CfOpensslExtensionObj *)obj003;
1240 X509_EXTENSIONS *exts = extsObj->exts;
1241 extsObj->exts = nullptr; /* exts is null */
1242
1243 ret = CfOpensslHasUnsupportedCriticalExtension(obj003, &bRet);
1244 EXPECT_EQ(ret, CF_INVALID_PARAMS) <<
1245 "Abnormal adapter extension object has unsupported critical extension test failed, retcode:" << ret;
1246 EXPECT_EQ(bRet, false);
1247
1248 extsObj->exts = exts;
1249 CfOpensslDestoryExtension(&obj003);
1250 }
1251
1252 /**
1253 * @tc.name: OpensslHasUnsupportedCriticalExtensionTest004
1254 * @tc.desc: Test CertFramework adapter extension object has unsupported critical extension,
1255 * While the extension number is more than MAX_COUNT_OID.
1256 * @tc.type: FUNC
1257 * @tc.require: AR000HS2SC /SR000HS2SB
1258 */
1259 HWTEST_F(CfAdapterExtensionTest, OpensslHasUnsupportedCriticalExtensionTest004, TestSize.Level0)
1260 {
1261 CfBase *obj004 = nullptr;
1262 int32_t ret = CfOpensslCreateExtension(&g_extension[2], &obj004);
1263 bool bRet = false;
1264 EXPECT_EQ(ret, CF_SUCCESS) << "Normal adapter create extension object test failed, rectode:" << ret;
1265
1266 CfOpensslExtensionObj *extsObj = (CfOpensslExtensionObj *)obj004;
1267 X509_EXTENSIONS *exts = extsObj->exts;
1268
1269 for (int index = 0; index < MAX_COUNT_OID + 1; index++) {
1270 string data = "test" + std::to_string(index);
1271 ASN1_BIT_STRING bitStr = { data.length(), V_ASN1_BIT_STRING,
1272 const_cast<unsigned char *>(reinterpret_cast<const unsigned char *>(data.c_str())), 0 };
1273 X509_EXTENSION *netscapeCommentExt = X509V3_EXT_i2d(NID_netscape_comment, 1, reinterpret_cast<void *>(&bitStr));
1274
1275 (void)sk_X509_EXTENSION_push(exts, netscapeCommentExt);
1276 }
1277
1278 ret = CfOpensslHasUnsupportedCriticalExtension(obj004, &bRet);
1279 EXPECT_EQ(ret, CF_ERR_CRYPTO_OPERATION) <<
1280 "Abnormal adapter extension object has unsupported critical extension test failed, retcode:" << ret;
1281
1282 (void)sk_X509_EXTENSION_pop_free(exts, X509_EXTENSION_free);
1283 extsObj->exts = nullptr;
1284 CfOpensslDestoryExtension(&obj004);
1285 }
1286 }