1 /*
2  * Copyright (c) 2023 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 
18 #include "cf_type.h"
19 
20 #include "cf_api.h"
21 #include "cf_param.h"
22 #include "cf_result.h"
23 
24 #include "cf_test_data.h"
25 #include "cf_test_common.h"
26 #include "cf_test_sdk_common.h"
27 
28 using namespace testing::ext;
29 using namespace CertframeworkTestData;
30 using namespace CertframeworkTest;
31 using namespace CertframeworkSdkTest;
32 
33 namespace {
34 class CfExtensionTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37 
38     static void TearDownTestCase(void);
39 
40     void SetUp();
41 
42     void TearDown();
43 };
44 
SetUpTestCase(void)45 void CfExtensionTest::SetUpTestCase(void)
46 {
47 }
48 
TearDownTestCase(void)49 void CfExtensionTest::TearDownTestCase(void)
50 {
51 }
52 
SetUp()53 void CfExtensionTest::SetUp()
54 {
55 }
56 
TearDown()57 void CfExtensionTest::TearDown()
58 {
59 }
60 
61 const static CfEncodingBlob g_extensionBlob[] = {
62     { const_cast<uint8_t *>(g_extensionData03), sizeof(g_extensionData03), CF_FORMAT_DER }
63 };
64 
65 const static CfBlob g_extEncoded = { sizeof(g_extensionData03), const_cast<uint8_t *>(g_extensionData03) };
66 const static int32_t g_expectPathLen = 2;
67 
CheckAndGetParam(CfTagType type,CfTag typeTag,const CfParamSet * paramSet,CfParam ** param)68 static int32_t CheckAndGetParam(CfTagType type, CfTag typeTag, const CfParamSet *paramSet, CfParam **param)
69 {
70     CfParam *resultTypeParam = NULL;
71     int32_t ret = CfGetParam(paramSet, CF_TAG_RESULT_TYPE, &resultTypeParam);
72     if (ret != CF_SUCCESS) {
73         printf("ext: get CF_TAG_RESULT_TYPE failed.\n");
74         return ret;
75     }
76 
77     if (resultTypeParam->int32Param != type) {
78         printf("ext: result type is not CF_TAG_TYPE_BYTES.\n");
79         return CF_INVALID_PARAMS;
80     }
81 
82     ret = CfGetParam(paramSet, typeTag, param);
83     if (ret != CF_SUCCESS) {
84         printf("ext: get CF_TAG_RESULT_BYTES from out failed.\n");
85         return ret;
86     }
87 
88     return CF_SUCCESS;
89 }
90 
CompareItemResult(const CfParamSet * paramSet)91 static bool CompareItemResult(const CfParamSet *paramSet)
92 {
93     CfParam *resultParam = NULL;
94     int32_t ret = CheckAndGetParam(CF_TAG_TYPE_BYTES, CF_TAG_RESULT_BYTES, paramSet, &resultParam);
95     if (ret != CF_SUCCESS) {
96         return false;
97     }
98     return CompareBlob(&resultParam->blob, &g_extEncoded);
99 }
100 
CompareArray(const CfBlobArray * array,const CfParamSet * paramSet)101 static bool CompareArray(const CfBlobArray *array, const CfParamSet *paramSet)
102 {
103     if (array->count != paramSet->paramsCnt - 1) { /* paramSet has 1 result type param */
104         printf("count not equal.\n");
105         return false;
106     }
107 
108     for (uint32_t i = 0; i < array->count; i++) {
109         if (paramSet->params[i + 1].tag != CF_TAG_RESULT_BYTES) {
110             printf("tag not bytes.\n");
111             return false;
112         }
113         if (CompareBlob(&array->data[i], &paramSet->params[i + 1].blob) != true) {
114             printf("blob data not equal.\n");
115             return false;
116         }
117     }
118     return true;
119 }
120 
CompareOidsResult(int32_t typeValue,const CfParamSet * paramSet)121 static bool CompareOidsResult(int32_t typeValue, const CfParamSet *paramSet)
122 {
123     CfParam *resultParam = NULL;
124     int32_t ret = CheckAndGetParam(CF_TAG_TYPE_BYTES, CF_TAG_RESULT_BYTES, paramSet, &resultParam);
125     if (ret != CF_SUCCESS) {
126         return false;
127     }
128 
129     switch (typeValue) {
130         case CF_EXT_TYPE_ALL_OIDS:
131             return CompareArray(&g_expectAllOidArray, paramSet);
132         case CF_EXT_TYPE_CRITICAL_OIDS:
133             return CompareArray(&g_expectCritOidArray, paramSet);
134         case CF_EXT_TYPE_UNCRITICAL_OIDS:
135             return CompareArray(&g_expectUncritOidArray, paramSet);
136         default:
137             return false;
138     }
139 }
140 
CompareEntryResult(int32_t typeValue,const CfParamSet * paramSet)141 static bool CompareEntryResult(int32_t typeValue, const CfParamSet *paramSet)
142 {
143     CfParam *resultParam = NULL;
144     int32_t ret = CheckAndGetParam(CF_TAG_TYPE_BYTES, CF_TAG_RESULT_BYTES, paramSet, &resultParam);
145     if (ret != CF_SUCCESS) {
146         return false;
147     }
148 
149     switch (typeValue) {
150         case CF_EXT_ENTRY_TYPE_ENTRY:
151             return CompareBlob(&resultParam->blob, &g_extensionEntryBlob03);
152         case CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL:
153             return CompareBlob(&resultParam->blob, &g_extensionEntryCriticalBlob03);
154         case CF_EXT_ENTRY_TYPE_ENTRY_VALUE:
155             return CompareBlob(&resultParam->blob, &g_extensionEntryValueBlob03);
156         default:
157             return false;
158     }
159 }
160 
CompareCheckResult(const CfParamSet * paramSet)161 static bool CompareCheckResult(const CfParamSet *paramSet)
162 {
163     CfParam *resultParam = NULL;
164     int32_t ret = CheckAndGetParam(CF_TAG_TYPE_INT, CF_TAG_RESULT_INT, paramSet, &resultParam);
165     if (ret != CF_SUCCESS) {
166         return false;
167     }
168     return (resultParam->int32Param == g_expectPathLen);
169 }
170 
ExtensionTest(int32_t type,int32_t typeValue,const CfParam * params,uint32_t cnt)171 static void ExtensionTest(int32_t type, int32_t typeValue, const CfParam *params, uint32_t cnt)
172 {
173     CfParamSet *outParamSet = nullptr;
174     int32_t ret = CommonTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0], params, cnt, &outParamSet);
175     EXPECT_EQ(ret, CF_SUCCESS);
176 
177 #ifdef TEST_PRINT_DATA
178     (void)GetOutValue(outParamSet);
179 #endif
180 
181     switch (type) {
182         case CF_GET_TYPE_EXT_ITEM:
183             EXPECT_EQ(CompareItemResult(outParamSet), true);
184             break;
185         case CF_GET_TYPE_EXT_OIDS:
186             EXPECT_EQ(CompareOidsResult(typeValue, outParamSet), true);
187             break;
188         case CF_GET_TYPE_EXT_ENTRY:
189             EXPECT_EQ(CompareEntryResult(typeValue, outParamSet), true);
190             break;
191         default:
192             break;
193     }
194     CfFreeParamSet(&outParamSet);
195 }
196 
ExtensionCheckTest(int32_t type,int32_t typeValue,const CfParam * params,uint32_t cnt)197 static void ExtensionCheckTest(int32_t type, int32_t typeValue, const CfParam *params, uint32_t cnt)
198 {
199     CfParamSet *outParamSet = nullptr;
200     int32_t ret = CommonTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0], params, cnt, &outParamSet);
201     EXPECT_EQ(ret, CF_SUCCESS);
202 
203 #ifdef TEST_PRINT_DATA
204     (void)GetOutValue(outParamSet);
205 #endif
206 
207     switch (type) {
208         case CF_CHECK_TYPE_EXT_CA:
209             EXPECT_EQ(CompareCheckResult(outParamSet), true);
210             break;
211         default:
212             break;
213     }
214     CfFreeParamSet(&outParamSet);
215 }
216 
217 /**
218  * @tc.name: CfExtensionTest001
219  * @tc.desc: get encoded
220  * @tc.type: FUNC
221  * @tc.require: AR000HS2SC /SR000HS2SB
222  */
223 HWTEST_F(CfExtensionTest, CfExtensionTest001, TestSize.Level0)
224 {
225     CfParam params[] = {
226         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
227         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_ITEM_ENCODED },
228     };
229     ExtensionTest(CF_GET_TYPE_EXT_ITEM, CF_ITEM_ENCODED, params, sizeof(params) / sizeof(CfParam));
230 }
231 
232 /**
233  * @tc.name: CfExtensionTest002
234  * @tc.desc: get oids all
235  * @tc.type: FUNC
236  * @tc.require: AR000HS2SC /SR000HS2SB
237  */
238 HWTEST_F(CfExtensionTest, CfExtensionTest002, TestSize.Level0)
239 {
240     CfParam params[] = {
241         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
242         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_TYPE_ALL_OIDS },
243     };
244     ExtensionTest(CF_GET_TYPE_EXT_OIDS, CF_EXT_TYPE_ALL_OIDS, params, sizeof(params) / sizeof(CfParam));
245 }
246 
247 /**
248  * @tc.name: CfExtensionTest003
249  * @tc.desc: get oids critical
250  * @tc.type: FUNC
251  * @tc.require: AR000HS2SC /SR000HS2SB
252  */
253 HWTEST_F(CfExtensionTest, CfExtensionTest003, TestSize.Level0)
254 {
255     CfParam params[] = {
256         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
257         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_TYPE_CRITICAL_OIDS },
258     };
259     ExtensionTest(CF_GET_TYPE_EXT_OIDS, CF_EXT_TYPE_CRITICAL_OIDS, params, sizeof(params) / sizeof(CfParam));
260 }
261 
262 /**
263  * @tc.name: CfExtensionTest004
264  * @tc.desc: get oids uncritical
265  * @tc.type: FUNC
266  * @tc.require: AR000HS2SC /SR000HS2SB
267  */
268 HWTEST_F(CfExtensionTest, CfExtensionTest004, TestSize.Level0)
269 {
270     CfParam params[] = {
271         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
272         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_TYPE_UNCRITICAL_OIDS },
273     };
274     ExtensionTest(CF_GET_TYPE_EXT_OIDS, CF_EXT_TYPE_UNCRITICAL_OIDS, params, sizeof(params) / sizeof(CfParam));
275 }
276 
277 /**
278  * @tc.name: CfExtensionTest005
279  * @tc.desc: get entry
280  * @tc.type: FUNC
281  * @tc.require: AR000HS2SC /SR000HS2SB
282  */
283 HWTEST_F(CfExtensionTest, CfExtensionTest005, TestSize.Level0)
284 {
285     char oidStr[] = "2.5.29.19";
286     CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
287 
288     CfParam params[] = {
289         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
290         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY },
291         { .tag = CF_TAG_PARAM1_BUFFER, .blob = oid },
292     };
293     ExtensionTest(CF_GET_TYPE_EXT_ENTRY, CF_EXT_ENTRY_TYPE_ENTRY, params, sizeof(params) / sizeof(CfParam));
294 }
295 
296 /**
297  * @tc.name: CfExtensionTest006
298  * @tc.desc: get entry's critical
299  * @tc.type: FUNC
300  * @tc.require: AR000HS2SC /SR000HS2SB
301  */
302 HWTEST_F(CfExtensionTest, CfExtensionTest006, TestSize.Level0)
303 {
304     char oidStr[] = "2.5.29.19";
305     CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
306 
307     CfParam params[] = {
308         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
309         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL },
310         { .tag = CF_TAG_PARAM1_BUFFER, .blob = oid },
311     };
312     ExtensionTest(CF_GET_TYPE_EXT_ENTRY, CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL, params, sizeof(params) / sizeof(CfParam));
313 }
314 
315 /**
316  * @tc.name: CfExtensionTest007
317  * @tc.desc: get entry's value
318  * @tc.type: FUNC
319  * @tc.require: AR000HS2SC /SR000HS2SB
320  */
321 HWTEST_F(CfExtensionTest, CfExtensionTest007, TestSize.Level0)
322 {
323     char oidStr[] = "2.5.29.19";
324     CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
325 
326     CfParam params[] = {
327         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
328         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY_VALUE },
329         { .tag = CF_TAG_PARAM1_BUFFER, .blob = oid },
330     };
331     ExtensionTest(CF_GET_TYPE_EXT_ENTRY, CF_EXT_ENTRY_TYPE_ENTRY_VALUE, params, sizeof(params) / sizeof(CfParam));
332 }
333 
334 /**
335  * @tc.name: CfExtensionTest008
336  * @tc.desc: check ca
337  * @tc.type: FUNC
338  * @tc.require: AR000HS2SC /SR000HS2SB
339  */
340 HWTEST_F(CfExtensionTest, CfExtensionTest008, TestSize.Level0)
341 {
342     CfParam params[] = {
343         { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_CA },
344     };
345     ExtensionCheckTest(CF_CHECK_TYPE_EXT_CA, 0, params, sizeof(params) / sizeof(CfParam));
346 }
347 
348 /**
349  * @tc.name: CfExtensionTest009
350  * @tc.desc: create object
351  * @tc.type: FUNC
352  * @tc.require: AR000HS2SC /SR000HS2SB
353  */
354 HWTEST_F(CfExtensionTest, CfExtensionTest009, TestSize.Level0)
355 {
356     CfObject *object = nullptr;
357     int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0], &object);
358     ASSERT_EQ(ret, CF_SUCCESS);
359 
360     object->destroy(&object);
361 }
362 
363 /**
364  * @tc.name: CfExtensionTest010
365  * @tc.desc: CfCreate: in's data is invalid create failed
366  * @tc.type: FUNC
367  * @tc.require: AR000HS2SC /SR000HS2SB
368  */
369 HWTEST_F(CfExtensionTest, CfExtensionTest010, TestSize.Level0)
370 {
371     CfObject *object = nullptr;
372     uint8_t invalidData[] = { 0x30, 0x33, 0x44, 0x55, }; /* in's data is invalid create failed */
373     CfEncodingBlob cert = { invalidData, sizeof(invalidData), CF_FORMAT_DER };
374     int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
375     EXPECT_NE(ret, CF_SUCCESS);
376 }
377 
378 /**
379  * @tc.name: CfExtensionTest012
380  * @tc.desc: CfCreate:in's data is nullptr
381  * @tc.type: FUNC
382  * @tc.require: AR000HS2SC /SR000HS2SB
383  */
384 HWTEST_F(CfExtensionTest, CfExtensionTest011, TestSize.Level0)
385 {
386     CfObject *object = nullptr;
387     uint8_t invalidData[] = { 0x30, 0x11, 0x22, 0x33, };
388     CfEncodingBlob cert = { nullptr, sizeof(invalidData), CF_FORMAT_DER }; /* in's data is nullptr */
389     int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
390     EXPECT_NE(ret, CF_SUCCESS);
391 }
392 
393 /**
394  * @tc.name: CfExtensionTest013
395  * @tc.desc: CfCreate:in's size is 0
396  * @tc.type: FUNC
397  * @tc.require: AR000HS2SC /SR000HS2SB
398  */
399 HWTEST_F(CfExtensionTest, CfExtensionTest012, TestSize.Level0)
400 {
401     CfObject *object = nullptr;
402     uint8_t invalidData[] = { 0x30, 0x01, 0x02, 0x03, };
403     CfEncodingBlob cert = { invalidData, 0, CF_FORMAT_DER }; /* in's size is 0 */
404     int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
405     EXPECT_NE(ret, CF_SUCCESS);
406 }
407 
408 /**
409  * @tc.name: CfExtensionTest013
410  * @tc.desc: CfCreate:in's encodingFormat invalid
411  * @tc.type: FUNC
412  * @tc.require: AR000HS2SC /SR000HS2SB
413  */
414 HWTEST_F(CfExtensionTest, CfExtensionTest013, TestSize.Level0)
415 {
416     CfObject *object = nullptr;
417     CfEncodingBlob cert = { const_cast<uint8_t *>(g_extensionData03), sizeof(g_extensionData03), CF_FORMAT_PEM };
418     int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
419     EXPECT_NE(ret, CF_SUCCESS);
420 }
421 
422 /**
423  * @tc.name: CfExtensionTest014
424  * @tc.desc: ->check: inParamSet not set CF_TAG_CHECK_TYPE
425  * @tc.type: FUNC
426  * @tc.require: AR000HS2SC /SR000HS2SB
427  */
428 HWTEST_F(CfExtensionTest, CfExtensionTest014, TestSize.Level0)
429 {
430     CfParam params[] = { /* not set CF_TAG_CHECK_TYPE */
431         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
432     };
433 
434     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
435         params, sizeof(params) / sizeof(CfParam), OP_TYPE_CHECK);
436     EXPECT_EQ(ret, CF_SUCCESS);
437 }
438 
439 /**
440  * @tc.name: CfExtensionTest015
441  * @tc.desc: ->check: inParamSet‘s CF_TAG_CHECK_TYPE is not CF_CHECK_TYPE_EXT_CA
442  * @tc.type: FUNC
443  * @tc.require: AR000HS2SC /SR000HS2SB
444  */
445 HWTEST_F(CfExtensionTest, CfExtensionTest015, TestSize.Level0)
446 {
447     CfParam params[] = { /* CF_TAG_CHECK_TYPE is not CF_CHECK_TYPE_EXT_CA */
448         { .tag = CF_TAG_CHECK_TYPE, .int32Param = 0xff },
449     };
450 
451     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
452         params, sizeof(params) / sizeof(CfParam), OP_TYPE_CHECK);
453     EXPECT_EQ(ret, CF_SUCCESS);
454 }
455 
456 /**
457  * @tc.name: CfExtensionTest016
458  * @tc.desc: ->check: adapter return error  g_extDataNoKeyUsage
459  * @tc.type: FUNC
460  * @tc.require: AR000HS2SC /SR000HS2SB
461  */
462 HWTEST_F(CfExtensionTest, CfExtensionTest016, TestSize.Level0)
463 {
464     CfParam params[] = {
465         { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_CA },
466     };
467 
468     /* ext data not has keyusage */
469     CfEncodingBlob blob = {
470         const_cast<uint8_t *>(g_extDataNoKeyUsage), sizeof(g_extDataNoKeyUsage), CF_FORMAT_DER
471     };
472     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &blob, params, sizeof(params) / sizeof(CfParam), OP_TYPE_CHECK);
473     EXPECT_EQ(ret, CF_SUCCESS);
474 }
475 
476 /**
477  * @tc.name: CfExtensionTest017
478  * @tc.desc: ->get: inParamSet not set CF_TAG_GET_TYPE
479  * @tc.type: FUNC
480  * @tc.require: AR000HS2SC /SR000HS2SB
481  */
482 HWTEST_F(CfExtensionTest, CfExtensionTest017, TestSize.Level0)
483 {
484     CfParam params[] = { /* not set CF_TAG_GET_TYPE */
485         { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_CA },
486     };
487 
488     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
489         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
490     EXPECT_EQ(ret, CF_SUCCESS);
491 }
492 
493 /**
494  * @tc.name: CfExtensionTest018
495  * @tc.desc: ->get: inParamSet's CF_TAG_GET_TYPE not valid
496  * @tc.type: FUNC
497  * @tc.require: AR000HS2SC /SR000HS2SB
498  */
499 HWTEST_F(CfExtensionTest, CfExtensionTest018, TestSize.Level0)
500 {
501     CfParam params[] = { /* CF_TAG_GET_TYPE not valid */
502         { .tag = CF_TAG_GET_TYPE, .int32Param = 0xff },
503     };
504 
505     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
506         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
507     EXPECT_EQ(ret, CF_SUCCESS);
508 }
509 
510 /**
511  * @tc.name: CfExtensionTest019
512  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ITEM, not set CF_TAG_PARAM0_INT32
513  * @tc.type: FUNC
514  * @tc.require: AR000HS2SC /SR000HS2SB
515  */
516 HWTEST_F(CfExtensionTest, CfExtensionTest019, TestSize.Level0)
517 {
518     CfParam params[] = { /* not set CF_TAG_PARAM0_INT32 */
519         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
520     };
521 
522     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
523         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
524     EXPECT_EQ(ret, CF_SUCCESS);
525 }
526 
527 /**
528  * @tc.name: CfExtensionTest020
529  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ITEM, CF_TAG_PARAM0_INT32 is invalid
530  * @tc.type: FUNC
531  * @tc.require: AR000HS2SC /SR000HS2SB
532  */
533 HWTEST_F(CfExtensionTest, CfExtensionTest020, TestSize.Level0)
534 {
535     CfParam params[] = {
536         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
537         { .tag = CF_TAG_PARAM0_INT32, .int32Param = 0xff }, /* CF_TAG_PARAM0_INT32 is invalid */
538     };
539 
540     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
541         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
542     EXPECT_EQ(ret, CF_SUCCESS);
543 }
544 
545 /**
546  * @tc.name: CfExtensionTest021
547  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_OIDS, not set CF_TAG_PARAM0_INT32
548  * @tc.type: FUNC
549  * @tc.require: AR000HS2SC /SR000HS2SB
550  */
551 HWTEST_F(CfExtensionTest, CfExtensionTest021, TestSize.Level0)
552 {
553     CfParam params[] = { /* not set CF_TAG_PARAM0_INT32 */
554         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
555     };
556 
557     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
558         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
559     EXPECT_EQ(ret, CF_SUCCESS);
560 }
561 
562 /**
563  * @tc.name: CfExtensionTest022
564  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_OIDS, CF_TAG_PARAM0_INT32 is invalid
565  * @tc.type: FUNC
566  * @tc.require: AR000HS2SC /SR000HS2SB
567  */
568 HWTEST_F(CfExtensionTest, CfExtensionTest022, TestSize.Level0)
569 {
570     CfParam params[] = {
571         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
572         { .tag = CF_TAG_PARAM0_INT32, .int32Param = 0xff }, /* CF_TAG_PARAM0_INT32 is invalid */
573     };
574 
575     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
576         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
577     EXPECT_EQ(ret, CF_SUCCESS);
578 }
579 
580 /**
581  * @tc.name: CfExtensionTest023
582  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ENTRY, not set CF_TAG_PARAM0_INT32
583  * @tc.type: FUNC
584  * @tc.require: AR000HS2SC /SR000HS2SB
585  */
586 HWTEST_F(CfExtensionTest, CfExtensionTest023, TestSize.Level0)
587 {
588     CfParam params[] = { /* not set CF_TAG_PARAM0_INT32 */
589         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
590     };
591 
592     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
593         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
594     EXPECT_EQ(ret, CF_SUCCESS);
595 }
596 
597 /**
598  * @tc.name: CfExtensionTest024
599  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ENTRY, not set CF_TAG_PARAM1_BUFFER
600  * @tc.type: FUNC
601  * @tc.require: AR000HS2SC /SR000HS2SB
602  */
603 HWTEST_F(CfExtensionTest, CfExtensionTest024, TestSize.Level0)
604 {
605     CfParam params[] = { /* not set CF_TAG_PARAM1_BUFFER */
606         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
607         { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL },
608     };
609 
610     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
611         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
612     EXPECT_EQ(ret, CF_SUCCESS);
613 }
614 
615 /**
616  * @tc.name: CfExtensionTest025
617  * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ENTRY, CF_TAG_PARAM0_INT32 is invalid
618  * @tc.type: FUNC
619  * @tc.require: AR000HS2SC /SR000HS2SB
620  */
621 HWTEST_F(CfExtensionTest, CfExtensionTest025, TestSize.Level0)
622 {
623     uint8_t oidData[] = "2.5.29.19";
624     CfBlob oidBlob = { sizeof(oidData), oidData };
625     CfParam params[] = {
626         { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
627         { .tag = CF_TAG_PARAM0_INT32, .int32Param = 0xff }, /* CF_TAG_PARAM0_INT32 is invalid */
628         { .tag = CF_TAG_PARAM1_BUFFER, .blob = oidBlob },
629     };
630 
631     int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
632         params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
633     EXPECT_EQ(ret, CF_SUCCESS);
634 }
635 /**
636  * @tc.name: CfExtensionTest026
637  * @tc.desc: check unsupport critical
638  * @tc.type: FUNC
639  * @tc.require: AR000HS2SC /SR000HS2SB
640  */
641 HWTEST_F(CfExtensionTest, CfExtensionTest026, TestSize.Level0)
642 {
643     CfParam params[] = {
644         { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_HAS_UN_SUPPORT },
645     };
646     ExtensionCheckTest(CF_CHECK_TYPE_EXT_HAS_UN_SUPPORT, 0, params, sizeof(params) / sizeof(CfParam));
647 }
648 }
649