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