1 /*
2 * Copyright (C) 2025 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 <string>
18 #include "securec.h"
19
20 #include "mac.h"
21 #include "sym_key_generator.h"
22 #include "mac_openssl.h"
23 #include "mac_params.h"
24 #include "detailed_cmac_params.h"
25
26 #include "log.h"
27 #include "memory.h"
28
29 using namespace std;
30 using namespace testing::ext;
31
32 namespace {
33 class CryptoCmacTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 };
40
41 constexpr uint32_t MAX_MAC_BLOB_LEN = 5000;
42 constexpr uint32_t INVALID_LEN = 0;
43 constexpr uint32_t AES128_LEN = 16;
44
45 static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhjR\r\n"
46 "Yz8c2pNvJiCxyFwvLvWfPh2Y2eDAuxbdm2Dt4UzKJtNqEpNYKVZLiyH4a4MhR4BpFhvhJVHy2ALbYq2rW\r\n"
47 "LqJfNzA6v8kHNaFypNDMgX35kifyCiYkq85XUKDJCdewUzCZ2N8twC8Z9kL37K67bkL35VYFZSXyrNTdV\r\n"
48 "pB6kqPjwZYrjx5tXzMMgJW8ePqmAhZUVjtPGXTLVt8BUnaVRuWjD97xjS3VH9EwFeyrqJ46B92rkuGexY\r\n"
49 "cjXuvhHTnQNPbYfake7KMEWG2wgGLmZmjnakULhFgjt6TQhvCWMJAHYn8Zgczd3C3HkPrQgUXJgAiwf3r\r\n"
50 "jJbgbBpQkkbcfMBZZ3SSLe2J9jw6MkdEf3eBQX9rFVQSgBQgZ9KEW8XLb5kCTcyhRZPBbiHD4qQRyrwKT\r\n"
51 "mnGZqP5Aru6GDkhFk78jfjtk35HyB7AY7UZXkczRfVYAxa5Mk256MhAHkE3uAvPZTyY7N3qk9U7cLTrce\r\n"
52 "wJLH6wrymrMvQWgpvrBevMghnURZUcZAWUznDn56WnwGAzYAWmJqdXqAfcvgZwCFTjxdiaEZGpEyUrcS8\r\n"
53 "nr48ZeXS5aytz5Y7RnU5SxcHbgF8PerWVdftxmghPAvGkQ6f3dcXr9w9bbGqg5KJHyQCxabp8bjZpyFdb\r\n"
54 "VTq8DpQ6AJjxdjn8cuLTf9giGFxDjtQncicUdqP7YvVDr5AFgWc83cddyryVLZEBGAFfqbbKWF9KnPjRZ\r\n"
55 "AbuZ7SqrkxhQHu87Hxh3xHUHB8Lb3DGZ4vhnqaLnJBxFK8Ve4F2FfbgfHfQtALFDUWp6dSz8Hvdpj4CGw\r\n"
56 "FaSb8b5hTemaQRguYAqaUwJVvZ7G2AwkFnV9PHUngmybAFxg8HMAT3K7yAiQJWWqPxdGq8jXPAqZFNkGu\r\n"
57 "2mnJ5xfnY3z63PFk6TXU9Ga2YmHvtycXxwqMBEctQRa3zVWGVSrh3NF6jXa\r\n";
58
SetUpTestCase()59 void CryptoCmacTest::SetUpTestCase() {}
TearDownTestCase()60 void CryptoCmacTest::TearDownTestCase() {}
61
SetUp()62 void CryptoCmacTest::SetUp() // add init here, this will be called before test.
63 {
64 }
65
TearDown()66 void CryptoCmacTest::TearDown() // add destroy here, this will be called when test case done.
67 {
68 }
69
PrintfBlobInHex(uint8_t * data,size_t dataLen)70 static void PrintfBlobInHex(uint8_t *data, size_t dataLen)
71 {
72 for (size_t i = 0; i < dataLen; i++) {
73 printf("%02hhX", data[i]);
74 }
75 printf("\n");
76 }
77
78 HWTEST_F(CryptoCmacTest, CryptoCmacTest001, TestSize.Level0)
79 {
80 HcfCmacParamsSpec params = {};
81 params.base.algName = "CMAC";
82 params.cipherName = "AES128";
83
84 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, nullptr);
85 EXPECT_NE(ret, HCF_SUCCESS);
86 }
87
88 HWTEST_F(CryptoCmacTest, CryptoCmacTest002, TestSize.Level0)
89 {
90 HcfMac *macObj = nullptr;
91 HcfCmacParamsSpec params = {};
92 params.base.algName = "CMAC";
93 params.cipherName = "AES128";
94
95 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
96 ASSERT_EQ(ret, HCF_SUCCESS);
97 EXPECT_NE(macObj, nullptr);
98 HcfObjDestroy(macObj);
99 }
100
101 HWTEST_F(CryptoCmacTest, CryptoCmacTest003, TestSize.Level0)
102 {
103 HcfMac *macObj = nullptr;
104 HcfCmacParamsSpec params = {};
105 params.base.algName = "CMAC";
106 params.cipherName = "AES256";
107
108 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
109 EXPECT_EQ(ret, HCF_SUCCESS);
110 EXPECT_NE(macObj, nullptr);
111 HcfObjDestroy(macObj);
112 }
113
114 HWTEST_F(CryptoCmacTest, CryptoCmacTest004, TestSize.Level0)
115 {
116 HcfMac *macObj = nullptr;
117 HcfResult ret = HcfMacCreate(nullptr, &macObj);
118 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
119 EXPECT_EQ(macObj, nullptr);
120 }
121
122 HWTEST_F(CryptoCmacTest, CryptoCmacTest005, TestSize.Level0)
123 {
124 HcfMac *macObj = nullptr;
125 HcfCmacParamsSpec params = {};
126 params.base.algName = "CMAC";
127 params.cipherName = "AES128";
128
129 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
130 ASSERT_EQ(ret, HCF_SUCCESS);
131 EXPECT_NE(macObj, nullptr);
132 // test api functions
133 const char *algoName = macObj->getAlgoName(macObj);
134 int32_t cmpRes = strcmp(algoName, params.base.algName);
135 EXPECT_EQ(cmpRes, HCF_SUCCESS);
136 HcfObjDestroy(macObj);
137 }
138
139 HWTEST_F(CryptoCmacTest, CryptoCmacTest006, TestSize.Level0)
140 {
141 HcfMac *macObj = nullptr;
142 HcfCmacParamsSpec params = {};
143 params.base.algName = "CMAC";
144 params.cipherName = "AES128";
145 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
146 ASSERT_EQ(ret, HCF_SUCCESS);
147 // set a nullptr key
148 HcfSymKey *key = nullptr;
149 // test api functions
150 ret = macObj->init(macObj, key);
151 EXPECT_NE(ret, HCF_SUCCESS);
152 HcfObjDestroy(macObj);
153 }
154
155 HWTEST_F(CryptoCmacTest, CryptoCmacTest007, TestSize.Level0)
156 {
157 HcfMac *macObj = nullptr;
158 HcfCmacParamsSpec params = {};
159 params.base.algName = "CMAC";
160 params.cipherName = "AES128";
161 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
162 ASSERT_EQ(ret, HCF_SUCCESS);
163 // create a symKey generator
164 HcfSymKeyGenerator *generator = nullptr;
165 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
166 ASSERT_EQ(ret, HCF_SUCCESS);
167 // get sym key from preset keyBlob
168 uint8_t testKey[] = "abcdefghijklmnop";
169 uint32_t testKeyLen = 16;
170 HcfSymKey *key = nullptr;
171 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
172 generator->convertSymKey(generator, &keyMaterialBlob, &key);
173 // test api functions
174 ret = macObj->init(macObj, key);
175 EXPECT_EQ(ret, HCF_SUCCESS);
176 HcfObjDestroy(macObj);
177 HcfObjDestroy(key);
178 HcfObjDestroy(generator);
179 }
180
181 HWTEST_F(CryptoCmacTest, CryptoCmacTest008, TestSize.Level0)
182 {
183 HcfMac *macObj = nullptr;
184 HcfCmacParamsSpec params = {};
185 params.base.algName = "CMAC";
186 params.cipherName = "AES128";
187 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
188 ASSERT_EQ(ret, HCF_SUCCESS);
189 // set input and output buf
190 uint8_t testData[] = "My test data";
191 // define input and output data in blob form
192 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
193 // test api functions
194 ret = macObj->update(macObj, &inBlob);
195 EXPECT_NE(ret, HCF_SUCCESS);
196 HcfObjDestroy(macObj);
197 }
198
199 HWTEST_F(CryptoCmacTest, CryptoCmacTest009, TestSize.Level0)
200 {
201 HcfMac *macObj = nullptr;
202 HcfCmacParamsSpec params = {};
203 params.base.algName = "CMAC";
204 params.cipherName = "AES128";
205 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
206 ASSERT_EQ(ret, HCF_SUCCESS);
207 // cteate key generator and set key text
208 HcfSymKeyGenerator *generator = nullptr;
209 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
210 ASSERT_EQ(ret, HCF_SUCCESS);
211 // get sym key from preset keyBlob
212 uint8_t testKey[] = "abcdefghijklmnop";
213 uint32_t testKeyLen = 16;
214 HcfSymKey *key = nullptr;
215 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
216 generator->convertSymKey(generator, &keyMaterialBlob, &key);
217 // define input and output data in blob form
218 HcfBlob *inBlob = nullptr;
219 // test api functions
220 ret = macObj->init(macObj, key);
221 EXPECT_EQ(ret, HCF_SUCCESS);
222 ret = macObj->update(macObj, inBlob);
223 EXPECT_NE(ret, HCF_SUCCESS);
224 HcfObjDestroy(macObj);
225 HcfObjDestroy(key);
226 HcfObjDestroy(generator);
227 }
228
229 HWTEST_F(CryptoCmacTest, CryptoCmacTest010, TestSize.Level0)
230 {
231 HcfMac *macObj = nullptr;
232 HcfCmacParamsSpec params = {};
233 params.base.algName = "CMAC";
234 params.cipherName = "AES128";
235 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
236 ASSERT_EQ(ret, HCF_SUCCESS);
237 // cteate key generator and set key text
238 HcfSymKeyGenerator *generator = nullptr;
239 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
240 ASSERT_EQ(ret, HCF_SUCCESS);
241 // get sym key from preset keyBlob
242 uint8_t testKey[] = "abcdefghijklmnop";
243 uint32_t testKeyLen = 16;
244 HcfSymKey *key = nullptr;
245 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
246 generator->convertSymKey(generator, &keyMaterialBlob, &key);
247 // set input and output buf
248 uint8_t testData[] = "My test data";
249 // define input and output data in blob form
250 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
251 // test api functions
252 ret = macObj->init(macObj, key);
253 EXPECT_EQ(ret, HCF_SUCCESS);
254 ret = macObj->update(macObj, &inBlob);
255 EXPECT_EQ(ret, HCF_SUCCESS);
256 HcfObjDestroy(macObj);
257 HcfObjDestroy(key);
258 HcfObjDestroy(generator);
259 }
260
261 HWTEST_F(CryptoCmacTest, CryptoCmacTest012, TestSize.Level0)
262 {
263 HcfMac *macObj = nullptr;
264 HcfCmacParamsSpec params = {};
265 params.base.algName = "CMAC";
266 params.cipherName = "AES128";
267 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
268 ASSERT_EQ(ret, HCF_SUCCESS);
269 // cteate key generator and set key text
270 HcfSymKeyGenerator *generator = nullptr;
271 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
272 ASSERT_EQ(ret, HCF_SUCCESS);
273 // get sym key from preset keyBlob
274 uint8_t testKey[] = "abcdefghijklmnop";
275 uint32_t testKeyLen = 16;
276 HcfSymKey *key = nullptr;
277 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
278 generator->convertSymKey(generator, &keyMaterialBlob, &key);
279 printf("get symkey finish");
280 // set input and output buf
281 HcfBlob outBlob = { .data = nullptr, .len = 0 };
282 // test api functions
283 ret = macObj->init(macObj, key);
284 EXPECT_EQ(ret, HCF_SUCCESS);
285 printf("test init finish");
286 ret = macObj->doFinal(macObj, &outBlob);
287 EXPECT_EQ(ret, HCF_SUCCESS);
288 printf("test dofinal finish");
289 PrintfBlobInHex(outBlob.data, outBlob.len);
290 // destroy the API obj and blob data
291 HcfBlobDataClearAndFree(&outBlob);
292 printf("HcfBlobDataClearAndFree finish");
293 HcfObjDestroy(macObj);
294 printf("HcfObjDestroy macObj finish");
295 HcfObjDestroy(key);
296 printf("HcfObjDestroy key finish");
297 HcfObjDestroy(generator);
298 printf("test finish");
299 }
300
301 HWTEST_F(CryptoCmacTest, CryptoCmacTest013, TestSize.Level0)
302 {
303 HcfMac *macObj = nullptr;
304 HcfCmacParamsSpec params = {};
305 params.base.algName = "CMAC";
306 params.cipherName = "AES128";
307 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
308 ASSERT_EQ(ret, HCF_SUCCESS);
309 // cteate key generator
310 HcfSymKeyGenerator *generator = nullptr;
311 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
312 ASSERT_EQ(ret, HCF_SUCCESS);
313 // get sym key from preset keyBlob
314 uint8_t testKey[] = "abcdefghijklmnop";
315 uint32_t testKeyLen = 16;
316 HcfSymKey *key = nullptr;
317 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
318 generator->convertSymKey(generator, &keyMaterialBlob, &key);
319 // set input and output buf
320 uint8_t testData[] = "My test data";
321 // define input and output data in blob form
322 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
323 HcfBlob outBlob = { .data = nullptr, .len = 0 };
324 // test api functions
325 ret = macObj->init(macObj, key);
326 EXPECT_EQ(ret, HCF_SUCCESS);
327 ret = macObj->update(macObj, &inBlob);
328 EXPECT_EQ(ret, HCF_SUCCESS);
329 ret = macObj->doFinal(macObj, &outBlob);
330 EXPECT_EQ(ret, HCF_SUCCESS);
331 // destroy the API obj and blob data
332 HcfBlobDataClearAndFree(&outBlob);
333 HcfObjDestroy(macObj);
334 HcfObjDestroy(key);
335 HcfObjDestroy(generator);
336 }
337
338 HWTEST_F(CryptoCmacTest, CryptoCmacTest014, TestSize.Level0)
339 {
340 HcfMac *macObj = nullptr;
341 HcfCmacParamsSpec params = {};
342 params.base.algName = "CMAC";
343 params.cipherName = "AES128";
344 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
345 ASSERT_EQ(ret, HCF_SUCCESS);
346 // cteate key generator
347 HcfSymKeyGenerator *generator = nullptr;
348 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
349 ASSERT_EQ(ret, HCF_SUCCESS);
350 // get sym key from preset keyBlob
351 uint8_t testKey[] = "abcdefghijklmnop";
352 uint32_t testKeyLen = 16;
353 HcfSymKey *key = nullptr;
354 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
355 generator->convertSymKey(generator, &keyMaterialBlob, &key);
356 // define input and output data in blob form
357 HcfBlob inBlob = {0};
358 inBlob.data = reinterpret_cast<uint8_t *>(g_testBigData);
359 inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN);
360 HcfBlob outBlob = { .data = nullptr, .len = 0 };
361 // test api functions
362 ret = macObj->init(macObj, key);
363 EXPECT_EQ(ret, HCF_SUCCESS);
364 ret = macObj->update(macObj, &inBlob);
365 EXPECT_EQ(ret, HCF_SUCCESS);
366 ret = macObj->doFinal(macObj, &outBlob);
367 EXPECT_EQ(ret, HCF_SUCCESS);
368 PrintfBlobInHex(outBlob.data, outBlob.len);
369 // destroy the API obj and blob data
370 HcfBlobDataClearAndFree(&outBlob);
371 HcfObjDestroy(macObj);
372 HcfObjDestroy(key);
373 HcfObjDestroy(generator);
374 }
375
376 HWTEST_F(CryptoCmacTest, CryptoCmacTest016, TestSize.Level0)
377 {
378 HcfMac *macObj = nullptr;
379 HcfCmacParamsSpec params = {};
380 params.base.algName = "CMAC";
381 params.cipherName = "AES128";
382 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
383 ASSERT_EQ(ret, HCF_SUCCESS);
384 // cteate key generator
385 HcfSymKeyGenerator *generator = nullptr;
386 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
387 ASSERT_EQ(ret, HCF_SUCCESS);
388 // get sym key from preset keyBlob
389 uint8_t testKey[] = "abcdefghijklmnop";
390 uint32_t testKeyLen = 16;
391 HcfSymKey *key = nullptr;
392 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
393 generator->convertSymKey(generator, &keyMaterialBlob, &key);
394 // test api functions
395 ret = macObj->init(macObj, key);
396 EXPECT_EQ(ret, HCF_SUCCESS);
397 uint32_t len = macObj->getMacLength(macObj);
398 EXPECT_EQ(len, AES128_LEN);
399 HcfObjDestroy(macObj);
400 HcfObjDestroy(key);
401 HcfObjDestroy(generator);
402 }
403
404 HWTEST_F(CryptoCmacTest, CryptoCmacTest017, TestSize.Level0)
405 {
406 HcfMac *macObj = nullptr;
407 HcfCmacParamsSpec params = {};
408 params.base.algName = "CMAC";
409 params.cipherName = "AES128";
410 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
411 EXPECT_EQ(ret, HCF_SUCCESS);
412 // create a symKey generator
413 HcfSymKeyGenerator *generator = nullptr;
414 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
415 EXPECT_EQ(ret, HCF_SUCCESS);
416 // set key data and convert it to key obj
417 uint8_t testKey[] = "abcdefghijklmnop";
418 uint32_t testKeyLen = 16;
419 HcfSymKey *key = nullptr;
420 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
421 generator->convertSymKey(generator, &keyMaterialBlob, &key);
422 // set input and output blob
423 uint8_t testData[] = "My test data";
424 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
425 HcfBlob outBlob = { .data = nullptr, .len = 0 };
426 // test api funcitons
427 ret = macObj->init(macObj, key);
428 EXPECT_EQ(ret, HCF_SUCCESS);
429 ret = macObj->update(macObj, &inBlob);
430 EXPECT_EQ(ret, HCF_SUCCESS);
431 ret = macObj->doFinal(macObj, &outBlob);
432 EXPECT_EQ(ret, HCF_SUCCESS);
433 uint32_t len = macObj->getMacLength(macObj);
434 EXPECT_EQ(len, AES128_LEN);
435 // destroy the API obj and blob data
436 HcfBlobDataClearAndFree(&outBlob);
437 HcfObjDestroy(macObj);
438 HcfObjDestroy(key);
439 HcfObjDestroy(generator);
440 }
441
442 HWTEST_F(CryptoCmacTest, CryptoCmacTest018, TestSize.Level0)
443 {
444 HcfMac *macObj = nullptr;
445 HcfCmacParamsSpec params = {};
446 params.base.algName = "CMAC";
447 params.cipherName = "AES128";
448 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
449 EXPECT_EQ(ret, HCF_SUCCESS);
450 // create a symKey generator
451 HcfSymKeyGenerator *generator = nullptr;
452 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
453 EXPECT_EQ(ret, HCF_SUCCESS);
454 HcfSymKey *key = nullptr;
455 generator->generateSymKey(generator, &key);
456 // set input and output blob
457 uint8_t testData[] = "My test data";
458 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
459 HcfBlob outBlob = { .data = nullptr, .len = 0 };
460 // test api funcitons
461 ret = macObj->init(macObj, key);
462 EXPECT_EQ(ret, HCF_SUCCESS);
463 ret = macObj->update(macObj, &inBlob);
464 EXPECT_EQ(ret, HCF_SUCCESS);
465 ret = macObj->doFinal(macObj, &outBlob);
466 EXPECT_EQ(ret, HCF_SUCCESS);
467 uint32_t len = macObj->getMacLength(macObj);
468 EXPECT_EQ(len, AES128_LEN);
469 // destroy the API obj and blob data
470 HcfBlobDataClearAndFree(&outBlob);
471 HcfObjDestroy(macObj);
472 HcfObjDestroy(key);
473 HcfObjDestroy(generator);
474 }
475
GetInvalidMacClass(void)476 static const char *GetInvalidMacClass(void)
477 {
478 return "INVALID_MAC_CLASS";
479 }
480
481 HWTEST_F(CryptoCmacTest, CryptoCmacTest019, TestSize.Level0)
482 {
483 HcfCmacParamsSpec params = {};
484 params.base.algName = "CMAC";
485 params.cipherName = "SHA256";
486 HcfResult ret = OpensslHmacSpiCreate((HcfMacParamsSpec *)¶ms, nullptr);
487 EXPECT_NE(ret, HCF_SUCCESS);
488 HcfMacSpi *spiObj = nullptr;
489 ret = OpensslHmacSpiCreate(nullptr, &spiObj);
490 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
491 }
492
493 HWTEST_F(CryptoCmacTest, CryptoCmacTest021, TestSize.Level0)
494 {
495 HcfMac *macObj = nullptr;
496 HcfCmacParamsSpec params = {};
497 params.base.algName = "CMAC";
498 params.cipherName = "AES128";
499 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
500 ASSERT_EQ(ret, HCF_SUCCESS);
501 HcfMac invalidMacObj = {{0}};
502 invalidMacObj.base.getClass = GetInvalidMacClass;
503 HcfSymKeyGenerator *generator = nullptr;
504 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
505 ASSERT_EQ(ret, HCF_SUCCESS);
506 uint8_t testKey[] = "abcdefghijklmnop";
507 uint32_t testKeyLen = sizeof(testKey) / sizeof(testKey[0]);
508 HcfSymKey *key = nullptr;
509 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
510 generator->convertSymKey(generator, &keyMaterialBlob, &key);
511 uint8_t testData[] = "My test data";
512 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
513 HcfBlob outBlob = { .data = nullptr, .len = 0 };
514 ret = macObj->init(&invalidMacObj, key);
515 EXPECT_NE(ret, HCF_SUCCESS);
516 ret = macObj->update(&invalidMacObj, &inBlob);
517 EXPECT_NE(ret, HCF_SUCCESS);
518 ret = macObj->doFinal(&invalidMacObj, &outBlob);
519 EXPECT_NE(ret, HCF_SUCCESS);
520 uint32_t len = macObj->getMacLength(&invalidMacObj);
521 EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
522 const char *algoName = macObj->getAlgoName(&invalidMacObj);
523 EXPECT_EQ(algoName, nullptr);
524 HcfBlobDataClearAndFree(&outBlob);
525 macObj->base.destroy(&(invalidMacObj.base));
526 HcfObjDestroy(macObj);
527 HcfObjDestroy(key);
528 HcfObjDestroy(generator);
529 }
530
531 HWTEST_F(CryptoCmacTest, CryptoCmacTest022, TestSize.Level0)
532 {
533 HcfMacSpi *spiObj = nullptr;
534 HcfMacSpi invalidSpi = {{0}};
535 invalidSpi.base.getClass = GetInvalidMacClass;
536 // create a symKey generator
537 HcfSymKeyGenerator *generator = nullptr;
538 HcfResult ret = HcfSymKeyGeneratorCreate("AES128", &generator);
539 ASSERT_EQ(ret, HCF_SUCCESS);
540 // set key data and convert it to key obj
541 uint8_t testKey[] = "abcdefghijklmnop";
542 uint32_t testKeyLen = 16;
543 HcfSymKey *key = nullptr;
544 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
545 generator->convertSymKey(generator, &keyMaterialBlob, &key);
546 // set input and output blob
547 uint8_t testData[] = "My test data";
548 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
549 HcfBlob outBlob = { .data = nullptr, .len = 0 };
550
551 HcfCmacParamsSpec params = {};
552 params.base.algName = "CMAC";
553 params.cipherName = "AES128";
554 ret = OpensslHmacSpiCreate((HcfMacParamsSpec *)¶ms, &spiObj);
555 EXPECT_EQ(ret, HCF_SUCCESS);
556 ASSERT_NE(spiObj, nullptr);
557 (void)spiObj->base.destroy(nullptr);
558 (void)spiObj->base.destroy(&(invalidSpi.base));
559 ret = spiObj->engineInitMac(&invalidSpi, key);
560 EXPECT_NE(ret, HCF_SUCCESS);
561 ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob);
562 EXPECT_NE(ret, HCF_SUCCESS);
563 ret = spiObj->engineDoFinalMac(&invalidSpi, &outBlob);
564 EXPECT_NE(ret, HCF_SUCCESS);
565 uint32_t len = spiObj->engineGetMacLength(&invalidSpi);
566 EXPECT_EQ(len, INVALID_LEN);
567 HcfObjDestroy(spiObj);
568 HcfObjDestroy(key);
569 HcfObjDestroy(generator);
570 }
571
572 }