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], ¶mSet->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 case CF_CHECK_TYPE_EXT_CA:
192 EXPECT_EQ(CompareCheckResult(outParamSet), true);
193 break;
194 default:
195 break;
196 }
197 CfFreeParamSet(&outParamSet);
198 }
199
200 /**
201 * @tc.name: CfExtensionTest001
202 * @tc.desc: get encoded
203 * @tc.type: FUNC
204 * @tc.require: AR000HS2SC /SR000HS2SB
205 */
206 HWTEST_F(CfExtensionTest, CfExtensionTest001, TestSize.Level0)
207 {
208 CfParam params[] = {
209 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
210 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_ITEM_ENCODED },
211 };
212 ExtensionTest(CF_GET_TYPE_EXT_ITEM, CF_ITEM_ENCODED, params, sizeof(params) / sizeof(CfParam));
213 }
214
215 /**
216 * @tc.name: CfExtensionTest002
217 * @tc.desc: get oids all
218 * @tc.type: FUNC
219 * @tc.require: AR000HS2SC /SR000HS2SB
220 */
221 HWTEST_F(CfExtensionTest, CfExtensionTest002, TestSize.Level0)
222 {
223 CfParam params[] = {
224 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
225 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_TYPE_ALL_OIDS },
226 };
227 ExtensionTest(CF_GET_TYPE_EXT_OIDS, CF_EXT_TYPE_ALL_OIDS, params, sizeof(params) / sizeof(CfParam));
228 }
229
230 /**
231 * @tc.name: CfExtensionTest003
232 * @tc.desc: get oids critical
233 * @tc.type: FUNC
234 * @tc.require: AR000HS2SC /SR000HS2SB
235 */
236 HWTEST_F(CfExtensionTest, CfExtensionTest003, TestSize.Level0)
237 {
238 CfParam params[] = {
239 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
240 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_TYPE_CRITICAL_OIDS },
241 };
242 ExtensionTest(CF_GET_TYPE_EXT_OIDS, CF_EXT_TYPE_CRITICAL_OIDS, params, sizeof(params) / sizeof(CfParam));
243 }
244
245 /**
246 * @tc.name: CfExtensionTest004
247 * @tc.desc: get oids uncritical
248 * @tc.type: FUNC
249 * @tc.require: AR000HS2SC /SR000HS2SB
250 */
251 HWTEST_F(CfExtensionTest, CfExtensionTest004, TestSize.Level0)
252 {
253 CfParam params[] = {
254 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
255 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_TYPE_UNCRITICAL_OIDS },
256 };
257 ExtensionTest(CF_GET_TYPE_EXT_OIDS, CF_EXT_TYPE_UNCRITICAL_OIDS, params, sizeof(params) / sizeof(CfParam));
258 }
259
260 /**
261 * @tc.name: CfExtensionTest005
262 * @tc.desc: get entry
263 * @tc.type: FUNC
264 * @tc.require: AR000HS2SC /SR000HS2SB
265 */
266 HWTEST_F(CfExtensionTest, CfExtensionTest005, TestSize.Level0)
267 {
268 char oidStr[] = "2.5.29.19";
269 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
270
271 CfParam params[] = {
272 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
273 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY },
274 { .tag = CF_TAG_PARAM1_BUFFER, .blob = oid },
275 };
276 ExtensionTest(CF_GET_TYPE_EXT_ENTRY, CF_EXT_ENTRY_TYPE_ENTRY, params, sizeof(params) / sizeof(CfParam));
277 }
278
279 /**
280 * @tc.name: CfExtensionTest006
281 * @tc.desc: get entry's critical
282 * @tc.type: FUNC
283 * @tc.require: AR000HS2SC /SR000HS2SB
284 */
285 HWTEST_F(CfExtensionTest, CfExtensionTest006, TestSize.Level0)
286 {
287 char oidStr[] = "2.5.29.19";
288 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
289
290 CfParam params[] = {
291 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
292 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL },
293 { .tag = CF_TAG_PARAM1_BUFFER, .blob = oid },
294 };
295 ExtensionTest(CF_GET_TYPE_EXT_ENTRY, CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL, params, sizeof(params) / sizeof(CfParam));
296 }
297
298 /**
299 * @tc.name: CfExtensionTest007
300 * @tc.desc: get entry's value
301 * @tc.type: FUNC
302 * @tc.require: AR000HS2SC /SR000HS2SB
303 */
304 HWTEST_F(CfExtensionTest, CfExtensionTest007, TestSize.Level0)
305 {
306 char oidStr[] = "2.5.29.19";
307 CfBlob oid = { strlen(oidStr), reinterpret_cast<uint8_t *>(oidStr) };
308
309 CfParam params[] = {
310 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
311 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY_VALUE },
312 { .tag = CF_TAG_PARAM1_BUFFER, .blob = oid },
313 };
314 ExtensionTest(CF_GET_TYPE_EXT_ENTRY, CF_EXT_ENTRY_TYPE_ENTRY_VALUE, params, sizeof(params) / sizeof(CfParam));
315 }
316
317 /**
318 * @tc.name: CfExtensionTest008
319 * @tc.desc: check ca
320 * @tc.type: FUNC
321 * @tc.require: AR000HS2SC /SR000HS2SB
322 */
323 HWTEST_F(CfExtensionTest, CfExtensionTest008, TestSize.Level0)
324 {
325 CfParam params[] = {
326 { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_CA },
327 };
328 ExtensionTest(CF_CHECK_TYPE_EXT_CA, 0, params, sizeof(params) / sizeof(CfParam));
329 }
330
331 /**
332 * @tc.name: CfExtensionTest009
333 * @tc.desc: create object
334 * @tc.type: FUNC
335 * @tc.require: AR000HS2SC /SR000HS2SB
336 */
337 HWTEST_F(CfExtensionTest, CfExtensionTest009, TestSize.Level0)
338 {
339 CfObject *object = nullptr;
340 int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0], &object);
341 ASSERT_EQ(ret, CF_SUCCESS);
342
343 object->destroy(&object);
344 }
345
346 /**
347 * @tc.name: CfExtensionTest010
348 * @tc.desc: CfCreate: in's data is invalid create failed
349 * @tc.type: FUNC
350 * @tc.require: AR000HS2SC /SR000HS2SB
351 */
352 HWTEST_F(CfExtensionTest, CfExtensionTest010, TestSize.Level0)
353 {
354 CfObject *object = nullptr;
355 uint8_t invalidData[] = { 0x30, 0x33, 0x44, 0x55, }; /* in's data is invalid create failed */
356 CfEncodingBlob cert = { invalidData, sizeof(invalidData), CF_FORMAT_DER };
357 int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
358 EXPECT_NE(ret, CF_SUCCESS);
359 }
360
361 /**
362 * @tc.name: CfExtensionTest012
363 * @tc.desc: CfCreate:in's data is nullptr
364 * @tc.type: FUNC
365 * @tc.require: AR000HS2SC /SR000HS2SB
366 */
367 HWTEST_F(CfExtensionTest, CfExtensionTest011, TestSize.Level0)
368 {
369 CfObject *object = nullptr;
370 uint8_t invalidData[] = { 0x30, 0x11, 0x22, 0x33, };
371 CfEncodingBlob cert = { nullptr, sizeof(invalidData), CF_FORMAT_DER }; /* in's data is nullptr */
372 int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
373 EXPECT_NE(ret, CF_SUCCESS);
374 }
375
376 /**
377 * @tc.name: CfExtensionTest013
378 * @tc.desc: CfCreate:in's size is 0
379 * @tc.type: FUNC
380 * @tc.require: AR000HS2SC /SR000HS2SB
381 */
382 HWTEST_F(CfExtensionTest, CfExtensionTest012, TestSize.Level0)
383 {
384 CfObject *object = nullptr;
385 uint8_t invalidData[] = { 0x30, 0x01, 0x02, 0x03, };
386 CfEncodingBlob cert = { invalidData, 0, CF_FORMAT_DER }; /* in's size is 0 */
387 int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
388 EXPECT_NE(ret, CF_SUCCESS);
389 }
390
391 /**
392 * @tc.name: CfExtensionTest013
393 * @tc.desc: CfCreate:in's encodingFormat invalid
394 * @tc.type: FUNC
395 * @tc.require: AR000HS2SC /SR000HS2SB
396 */
397 HWTEST_F(CfExtensionTest, CfExtensionTest013, TestSize.Level0)
398 {
399 CfObject *object = nullptr;
400 CfEncodingBlob cert = { const_cast<uint8_t *>(g_extensionData03), sizeof(g_extensionData03), CF_FORMAT_PEM };
401 int32_t ret = CfCreate(CF_OBJ_TYPE_EXTENSION, &cert, &object);
402 EXPECT_NE(ret, CF_SUCCESS);
403 }
404
405 /**
406 * @tc.name: CfExtensionTest014
407 * @tc.desc: ->check: inParamSet not set CF_TAG_CHECK_TYPE
408 * @tc.type: FUNC
409 * @tc.require: AR000HS2SC /SR000HS2SB
410 */
411 HWTEST_F(CfExtensionTest, CfExtensionTest014, TestSize.Level0)
412 {
413 CfParam params[] = { /* not set CF_TAG_CHECK_TYPE */
414 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
415 };
416
417 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
418 params, sizeof(params) / sizeof(CfParam), OP_TYPE_CHECK);
419 EXPECT_EQ(ret, CF_SUCCESS);
420 }
421
422 /**
423 * @tc.name: CfExtensionTest015
424 * @tc.desc: ->check: inParamSet‘s CF_TAG_CHECK_TYPE is not CF_CHECK_TYPE_EXT_CA
425 * @tc.type: FUNC
426 * @tc.require: AR000HS2SC /SR000HS2SB
427 */
428 HWTEST_F(CfExtensionTest, CfExtensionTest015, TestSize.Level0)
429 {
430 CfParam params[] = { /* CF_TAG_CHECK_TYPE is not CF_CHECK_TYPE_EXT_CA */
431 { .tag = CF_TAG_CHECK_TYPE, .int32Param = 0xff },
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: CfExtensionTest016
441 * @tc.desc: ->check: adapter return error g_extDataNoKeyUsage
442 * @tc.type: FUNC
443 * @tc.require: AR000HS2SC /SR000HS2SB
444 */
445 HWTEST_F(CfExtensionTest, CfExtensionTest016, TestSize.Level0)
446 {
447 CfParam params[] = {
448 { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_CA },
449 };
450
451 /* ext data not has keyusage */
452 CfEncodingBlob blob = {
453 const_cast<uint8_t *>(g_extDataNoKeyUsage), sizeof(g_extDataNoKeyUsage), CF_FORMAT_DER
454 };
455 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &blob, params, sizeof(params) / sizeof(CfParam), OP_TYPE_CHECK);
456 EXPECT_EQ(ret, CF_SUCCESS);
457 }
458
459 /**
460 * @tc.name: CfExtensionTest017
461 * @tc.desc: ->get: inParamSet not set CF_TAG_GET_TYPE
462 * @tc.type: FUNC
463 * @tc.require: AR000HS2SC /SR000HS2SB
464 */
465 HWTEST_F(CfExtensionTest, CfExtensionTest017, TestSize.Level0)
466 {
467 CfParam params[] = { /* not set CF_TAG_GET_TYPE */
468 { .tag = CF_TAG_CHECK_TYPE, .int32Param = CF_CHECK_TYPE_EXT_CA },
469 };
470
471 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
472 params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
473 EXPECT_EQ(ret, CF_SUCCESS);
474 }
475
476 /**
477 * @tc.name: CfExtensionTest018
478 * @tc.desc: ->get: inParamSet's CF_TAG_GET_TYPE not valid
479 * @tc.type: FUNC
480 * @tc.require: AR000HS2SC /SR000HS2SB
481 */
482 HWTEST_F(CfExtensionTest, CfExtensionTest018, TestSize.Level0)
483 {
484 CfParam params[] = { /* CF_TAG_GET_TYPE not valid */
485 { .tag = CF_TAG_GET_TYPE, .int32Param = 0xff },
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: CfExtensionTest019
495 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ITEM, not set CF_TAG_PARAM0_INT32
496 * @tc.type: FUNC
497 * @tc.require: AR000HS2SC /SR000HS2SB
498 */
499 HWTEST_F(CfExtensionTest, CfExtensionTest019, TestSize.Level0)
500 {
501 CfParam params[] = { /* not set CF_TAG_PARAM0_INT32 */
502 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
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: CfExtensionTest020
512 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ITEM, CF_TAG_PARAM0_INT32 is invalid
513 * @tc.type: FUNC
514 * @tc.require: AR000HS2SC /SR000HS2SB
515 */
516 HWTEST_F(CfExtensionTest, CfExtensionTest020, TestSize.Level0)
517 {
518 CfParam params[] = {
519 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ITEM },
520 { .tag = CF_TAG_PARAM0_INT32, .int32Param = 0xff }, /* CF_TAG_PARAM0_INT32 is invalid */
521 };
522
523 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
524 params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
525 EXPECT_EQ(ret, CF_SUCCESS);
526 }
527
528 /**
529 * @tc.name: CfExtensionTest021
530 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_OIDS, not set CF_TAG_PARAM0_INT32
531 * @tc.type: FUNC
532 * @tc.require: AR000HS2SC /SR000HS2SB
533 */
534 HWTEST_F(CfExtensionTest, CfExtensionTest021, TestSize.Level0)
535 {
536 CfParam params[] = { /* not set CF_TAG_PARAM0_INT32 */
537 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
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: CfExtensionTest022
547 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_OIDS, CF_TAG_PARAM0_INT32 is invalid
548 * @tc.type: FUNC
549 * @tc.require: AR000HS2SC /SR000HS2SB
550 */
551 HWTEST_F(CfExtensionTest, CfExtensionTest022, TestSize.Level0)
552 {
553 CfParam params[] = {
554 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_OIDS },
555 { .tag = CF_TAG_PARAM0_INT32, .int32Param = 0xff }, /* CF_TAG_PARAM0_INT32 is invalid */
556 };
557
558 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
559 params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
560 EXPECT_EQ(ret, CF_SUCCESS);
561 }
562
563 /**
564 * @tc.name: CfExtensionTest023
565 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ENTRY, not set CF_TAG_PARAM0_INT32
566 * @tc.type: FUNC
567 * @tc.require: AR000HS2SC /SR000HS2SB
568 */
569 HWTEST_F(CfExtensionTest, CfExtensionTest023, TestSize.Level0)
570 {
571 CfParam params[] = { /* not set CF_TAG_PARAM0_INT32 */
572 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
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: CfExtensionTest024
582 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ENTRY, not set CF_TAG_PARAM1_BUFFER
583 * @tc.type: FUNC
584 * @tc.require: AR000HS2SC /SR000HS2SB
585 */
586 HWTEST_F(CfExtensionTest, CfExtensionTest024, TestSize.Level0)
587 {
588 CfParam params[] = { /* not set CF_TAG_PARAM1_BUFFER */
589 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
590 { .tag = CF_TAG_PARAM0_INT32, .int32Param = CF_EXT_ENTRY_TYPE_ENTRY_CRITICAL },
591 };
592
593 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
594 params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
595 EXPECT_EQ(ret, CF_SUCCESS);
596 }
597
598 /**
599 * @tc.name: CfExtensionTest025
600 * @tc.desc: ->get: inParamSet's type is CF_GET_TYPE_EXT_ENTRY, CF_TAG_PARAM0_INT32 is invalid
601 * @tc.type: FUNC
602 * @tc.require: AR000HS2SC /SR000HS2SB
603 */
604 HWTEST_F(CfExtensionTest, CfExtensionTest025, TestSize.Level0)
605 {
606 uint8_t oidData[] = "2.5.29.19";
607 CfBlob oidBlob = { sizeof(oidData), oidData };
608 CfParam params[] = {
609 { .tag = CF_TAG_GET_TYPE, .int32Param = CF_GET_TYPE_EXT_ENTRY },
610 { .tag = CF_TAG_PARAM0_INT32, .int32Param = 0xff }, /* CF_TAG_PARAM0_INT32 is invalid */
611 { .tag = CF_TAG_PARAM1_BUFFER, .blob = oidBlob },
612 };
613
614 int32_t ret = AbnormalTest(CF_OBJ_TYPE_EXTENSION, &g_extensionBlob[0],
615 params, sizeof(params) / sizeof(CfParam), OP_TYPE_GET);
616 EXPECT_EQ(ret, CF_SUCCESS);
617 }
618 }
619