1 /*
2  * Copyright (C) 2023-2024 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 
24 #include "log.h"
25 #include "memory.h"
26 
27 using namespace std;
28 using namespace testing::ext;
29 
30 namespace {
31 class CryptoMacTest : public testing::Test {
32 public:
33     static void SetUpTestCase();
34     static void TearDownTestCase();
35     void SetUp();
36     void TearDown();
37 };
38 
39 constexpr uint32_t MAX_MAC_BLOB_LEN = 5000;
40 constexpr uint32_t INVALID_LEN = 0;
41 constexpr uint32_t SHA1_LEN = 20;
42 constexpr uint32_t SHA224_LEN = 28;
43 constexpr uint32_t SHA256_LEN = 32;
44 constexpr uint32_t SHA384_LEN = 48;
45 constexpr uint32_t SHA512_LEN = 64;
46 constexpr uint32_t MD5_LEN = 16;
47 
48 static char g_testBigData[] = "VqRH5dzdeeturr5zN5vE77DtqjV7kNKbDJqk4mNqyYRTXymhjR\r\n"
49 "Yz8c2pNvJiCxyFwvLvWfPh2Y2eDAuxbdm2Dt4UzKJtNqEpNYKVZLiyH4a4MhR4BpFhvhJVHy2ALbYq2rW\r\n"
50 "LqJfNzA6v8kHNaFypNDMgX35kifyCiYkq85XUKDJCdewUzCZ2N8twC8Z9kL37K67bkL35VYFZSXyrNTdV\r\n"
51 "pB6kqPjwZYrjx5tXzMMgJW8ePqmAhZUVjtPGXTLVt8BUnaVRuWjD97xjS3VH9EwFeyrqJ46B92rkuGexY\r\n"
52 "cjXuvhHTnQNPbYfake7KMEWG2wgGLmZmjnakULhFgjt6TQhvCWMJAHYn8Zgczd3C3HkPrQgUXJgAiwf3r\r\n"
53 "jJbgbBpQkkbcfMBZZ3SSLe2J9jw6MkdEf3eBQX9rFVQSgBQgZ9KEW8XLb5kCTcyhRZPBbiHD4qQRyrwKT\r\n"
54 "mnGZqP5Aru6GDkhFk78jfjtk35HyB7AY7UZXkczRfVYAxa5Mk256MhAHkE3uAvPZTyY7N3qk9U7cLTrce\r\n"
55 "wJLH6wrymrMvQWgpvrBevMghnURZUcZAWUznDn56WnwGAzYAWmJqdXqAfcvgZwCFTjxdiaEZGpEyUrcS8\r\n"
56 "nr48ZeXS5aytz5Y7RnU5SxcHbgF8PerWVdftxmghPAvGkQ6f3dcXr9w9bbGqg5KJHyQCxabp8bjZpyFdb\r\n"
57 "VTq8DpQ6AJjxdjn8cuLTf9giGFxDjtQncicUdqP7YvVDr5AFgWc83cddyryVLZEBGAFfqbbKWF9KnPjRZ\r\n"
58 "AbuZ7SqrkxhQHu87Hxh3xHUHB8Lb3DGZ4vhnqaLnJBxFK8Ve4F2FfbgfHfQtALFDUWp6dSz8Hvdpj4CGw\r\n"
59 "FaSb8b5hTemaQRguYAqaUwJVvZ7G2AwkFnV9PHUngmybAFxg8HMAT3K7yAiQJWWqPxdGq8jXPAqZFNkGu\r\n"
60 "2mnJ5xfnY3z63PFk6TXU9Ga2YmHvtycXxwqMBEctQRa3zVWGVSrh3NF6jXa\r\n";
61 
SetUpTestCase()62 void CryptoMacTest::SetUpTestCase() {}
TearDownTestCase()63 void CryptoMacTest::TearDownTestCase() {}
64 
SetUp()65 void CryptoMacTest::SetUp() // add init here, this will be called before test.
66 {
67 }
68 
TearDown()69 void CryptoMacTest::TearDown() // add destroy here, this will be called when test case done.
70 {
71 }
72 
PrintfBlobInHex(uint8_t * data,size_t dataLen)73 static void PrintfBlobInHex(uint8_t *data, size_t dataLen)
74 {
75     for (size_t i = 0; i < dataLen; i++) {
76         printf("%02hhX", data[i]);
77     }
78     printf("\n");
79 }
80 
81 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacCreateTest002, TestSize.Level0)
82 {
83     HcfResult ret = HcfMacCreate("SHA1", nullptr);
84     EXPECT_NE(ret, HCF_SUCCESS);
85 }
86 
87 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest001, TestSize.Level0)
88 {
89     // create a SHA obj
90     HcfMac *macObj = nullptr;
91     HcfResult ret = HcfMacCreate("SHA1", &macObj);
92     ASSERT_EQ(ret, HCF_SUCCESS);
93     EXPECT_NE(macObj, nullptr);
94     HcfObjDestroy(macObj);
95 }
96 
97 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest002, TestSize.Level0)
98 {
99     // create a SHA obj
100     HcfMac *macObj = nullptr;
101     HcfResult ret = HcfMacCreate("SHA3", &macObj);
102     EXPECT_NE(ret, HCF_SUCCESS);
103     EXPECT_EQ(macObj, nullptr);
104 }
105 
106 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoSuppTest003, TestSize.Level0)
107 {
108     // create a SHA obj
109     HcfMac *macObj = nullptr;
110     HcfResult ret = HcfMacCreate(nullptr, &macObj);
111     EXPECT_NE(ret, HCF_SUCCESS);
112     EXPECT_EQ(macObj, nullptr);
113 }
114 
115 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoNameTest001, TestSize.Level0)
116 {
117     // create a SHA obj
118     HcfMac *macObj = nullptr;
119     HcfResult ret = HcfMacCreate("SHA1", &macObj);
120     ASSERT_EQ(ret, HCF_SUCCESS);
121     EXPECT_NE(macObj, nullptr);
122     // test api functions
123     const char *algoName =  macObj->getAlgoName(macObj);
124     int32_t cmpRes = strcmp(algoName, "SHA1");
125     EXPECT_EQ(cmpRes, HCF_SUCCESS);
126     HcfObjDestroy(macObj);
127 }
128 
129 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest001, TestSize.Level0)
130 {
131     // create a SHA obj
132     HcfMac *macObj = nullptr;
133     HcfResult ret = HcfMacCreate("SHA1", &macObj);
134     ASSERT_EQ(ret, HCF_SUCCESS);
135     // set a nullptr key
136     HcfSymKey *key = nullptr;
137     // test api functions
138     ret = macObj->init(macObj, key);
139     EXPECT_NE(ret, HCF_SUCCESS);
140     HcfObjDestroy(macObj);
141 }
142 
143 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacInitTest002, TestSize.Level0)
144 {
145     // create a SHA obj
146     HcfMac *macObj = nullptr;
147     HcfResult ret = HcfMacCreate("SHA1", &macObj);
148     ASSERT_EQ(ret, HCF_SUCCESS);
149     // create a symKey generator
150     HcfSymKeyGenerator *generator = nullptr;
151     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
152     ASSERT_EQ(ret, HCF_SUCCESS);
153     // get sym key from preset keyBlob
154     uint8_t testKey[] = "abcdefghijklmnop";
155     uint32_t testKeyLen = 16;
156     HcfSymKey *key = nullptr;
157     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
158     generator->convertSymKey(generator, &keyMaterialBlob, &key);
159     // test api functions
160     ret = macObj->init(macObj, key);
161     EXPECT_EQ(ret, HCF_SUCCESS);
162     HcfObjDestroy(macObj);
163     HcfObjDestroy(key);
164     HcfObjDestroy(generator);
165 }
166 
167 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest001, TestSize.Level0)
168 {
169     // create a SHA1 obj
170     HcfMac *macObj = nullptr;
171     HcfResult ret = HcfMacCreate("SHA1", &macObj);
172     ASSERT_EQ(ret, HCF_SUCCESS);
173     // set input and output buf
174     uint8_t testData[] = "My test data";
175     // define input and output data in blob form
176     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
177     // test api functions
178     ret = macObj->update(macObj, &inBlob);
179     EXPECT_NE(ret, HCF_SUCCESS);
180     HcfObjDestroy(macObj);
181 }
182 
183 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest002, TestSize.Level0)
184 {
185     // create a SHA1 obj
186     HcfMac *macObj = nullptr;
187     HcfResult ret = HcfMacCreate("SHA1", &macObj);
188     ASSERT_EQ(ret, HCF_SUCCESS);
189     // cteate key generator and set key text
190     HcfSymKeyGenerator *generator = nullptr;
191     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
192     ASSERT_EQ(ret, HCF_SUCCESS);
193     // get sym key from preset keyBlob
194     uint8_t testKey[] = "abcdefghijklmnop";
195     uint32_t testKeyLen = 16;
196     HcfSymKey *key = nullptr;
197     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
198     generator->convertSymKey(generator, &keyMaterialBlob, &key);
199     // define input and output data in blob form
200     HcfBlob *inBlob = nullptr;
201     // test api functions
202     ret = macObj->init(macObj, key);
203     EXPECT_EQ(ret, HCF_SUCCESS);
204     ret = macObj->update(macObj, inBlob);
205     EXPECT_NE(ret, HCF_SUCCESS);
206     HcfObjDestroy(macObj);
207     HcfObjDestroy(key);
208     HcfObjDestroy(generator);
209 }
210 
211 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacUpdateTest003, TestSize.Level0)
212 {
213     // create a API obj with SHA1
214     HcfMac *macObj = nullptr;
215     HcfResult ret = HcfMacCreate("SHA1", &macObj);
216     ASSERT_EQ(ret, HCF_SUCCESS);
217     // cteate key generator and set key text
218     HcfSymKeyGenerator *generator = nullptr;
219     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
220     ASSERT_EQ(ret, HCF_SUCCESS);
221     // get sym key from preset keyBlob
222     uint8_t testKey[] = "abcdefghijklmnop";
223     uint32_t testKeyLen = 16;
224     HcfSymKey *key = nullptr;
225     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
226     generator->convertSymKey(generator, &keyMaterialBlob, &key);
227     // set input and output buf
228     uint8_t testData[] = "My test data";
229     // define input and output data in blob form
230     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
231     // test api functions
232     ret = macObj->init(macObj, key);
233     EXPECT_EQ(ret, HCF_SUCCESS);
234     ret = macObj->update(macObj, &inBlob);
235     EXPECT_EQ(ret, HCF_SUCCESS);
236     HcfObjDestroy(macObj);
237     HcfObjDestroy(key);
238     HcfObjDestroy(generator);
239 }
240 
241 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest001, TestSize.Level0)
242 {
243     // create a SHA1 obj
244     HcfMac *macObj = nullptr;
245     HcfResult ret = HcfMacCreate("SHA1", &macObj);
246     ASSERT_EQ(ret, HCF_SUCCESS);
247     // set input and output buf
248     HcfBlob outBlob = { .data = nullptr, .len = 0 };
249     // test api functions
250     ret = macObj->doFinal(macObj, &outBlob);
251     EXPECT_NE(ret, HCF_SUCCESS);
252     // destroy the API obj and blob data
253     HcfObjDestroy(macObj);
254 }
255 
256 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest002, TestSize.Level0)
257 {
258     // create a SHA1 obj
259     HcfMac *macObj = nullptr;
260     HcfResult ret = HcfMacCreate("SHA1", &macObj);
261     ASSERT_EQ(ret, HCF_SUCCESS);
262     // cteate key generator and set key text
263     HcfSymKeyGenerator *generator = nullptr;
264     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
265     ASSERT_EQ(ret, HCF_SUCCESS);
266     // get sym key from preset keyBlob
267     uint8_t testKey[] = "abcdefghijklmnop";
268     uint32_t testKeyLen = 16;
269     HcfSymKey *key = nullptr;
270     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
271     generator->convertSymKey(generator, &keyMaterialBlob, &key);
272     printf("get symkey finish");
273     // set input and output buf
274     HcfBlob outBlob = { .data = nullptr, .len = 0 };
275     // test api functions
276     ret = macObj->init(macObj, key);
277     EXPECT_EQ(ret, HCF_SUCCESS);
278     printf("test init finish");
279     ret = macObj->doFinal(macObj, &outBlob);
280     EXPECT_EQ(ret, HCF_SUCCESS);
281     printf("test dofinal finish");
282     PrintfBlobInHex(outBlob.data, outBlob.len);
283     // destroy the API obj and blob data
284     HcfBlobDataClearAndFree(&outBlob);
285     printf("HcfBlobDataClearAndFree finish");
286     HcfObjDestroy(macObj);
287     printf("HcfObjDestroy macObj finish");
288     HcfObjDestroy(key);
289     printf("HcfObjDestroy key finish");
290     HcfObjDestroy(generator);
291     printf("test finish");
292 }
293 
294 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest003, TestSize.Level0)
295 {
296     // create a SHA1 obj
297     HcfMac *macObj = nullptr;
298     HcfResult ret = HcfMacCreate("SHA1", &macObj);
299     ASSERT_EQ(ret, HCF_SUCCESS);
300     // cteate key generator
301     HcfSymKeyGenerator *generator = nullptr;
302     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
303     ASSERT_EQ(ret, HCF_SUCCESS);
304     // get sym key from preset keyBlob
305     uint8_t testKey[] = "abcdefghijklmnop";
306     uint32_t testKeyLen = 16;
307     HcfSymKey *key = nullptr;
308     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
309     generator->convertSymKey(generator, &keyMaterialBlob, &key);
310     // set input and output buf
311     uint8_t testData[] = "My test data";
312     // define input and output data in blob form
313     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
314     HcfBlob outBlob = { .data = nullptr, .len = 0 };
315     // test api functions
316     ret = macObj->init(macObj, key);
317     EXPECT_EQ(ret, HCF_SUCCESS);
318     ret = macObj->update(macObj, &inBlob);
319     EXPECT_EQ(ret, HCF_SUCCESS);
320     ret = macObj->doFinal(macObj, &outBlob);
321     EXPECT_EQ(ret, HCF_SUCCESS);
322     // destroy the API obj and blob data
323     HcfBlobDataClearAndFree(&outBlob);
324     HcfObjDestroy(macObj);
325     HcfObjDestroy(key);
326     HcfObjDestroy(generator);
327 }
328 
329 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacDoFinalTest004, TestSize.Level0)
330 {
331     // create a SHA1 obj
332     HcfMac *macObj = nullptr;
333     HcfResult ret = HcfMacCreate("SHA256", &macObj);
334     ASSERT_EQ(ret, HCF_SUCCESS);
335     // cteate key generator
336     HcfSymKeyGenerator *generator = nullptr;
337     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
338     ASSERT_EQ(ret, HCF_SUCCESS);
339     // get sym key from preset keyBlob
340     uint8_t testKey[] = "abcdefghijklmnop";
341     uint32_t testKeyLen = 16;
342     HcfSymKey *key = nullptr;
343     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
344     generator->convertSymKey(generator, &keyMaterialBlob, &key);
345     // define input and output data in blob form
346     HcfBlob inBlob = {0};
347     inBlob.data = reinterpret_cast<uint8_t *>(g_testBigData);
348     inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN);
349     HcfBlob outBlob = { .data = nullptr, .len = 0 };
350     // test api functions
351     ret = macObj->init(macObj, key);
352     EXPECT_EQ(ret, HCF_SUCCESS);
353     ret = macObj->update(macObj, &inBlob);
354     EXPECT_EQ(ret, HCF_SUCCESS);
355     ret = macObj->doFinal(macObj, &outBlob);
356     EXPECT_EQ(ret, HCF_SUCCESS);
357     PrintfBlobInHex(outBlob.data, outBlob.len);
358     // destroy the API obj and blob data
359     HcfBlobDataClearAndFree(&outBlob);
360     HcfObjDestroy(macObj);
361     HcfObjDestroy(key);
362     HcfObjDestroy(generator);
363 }
364 
365 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest001, TestSize.Level0)
366 {
367     // create a SHA1 obj
368     HcfMac *macObj = nullptr;
369     HcfResult ret = HcfMacCreate("SHA1", &macObj);
370     ASSERT_EQ(ret, HCF_SUCCESS);
371     // test api functions
372     uint32_t len = macObj->getMacLength(macObj);
373     EXPECT_EQ(len, INVALID_LEN);
374     HcfObjDestroy(macObj);
375 }
376 
377 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacLenTest002, TestSize.Level0)
378 {
379     // create a SHA1 obj
380     HcfMac *macObj = nullptr;
381     HcfResult ret = HcfMacCreate("SHA1", &macObj);
382     ASSERT_EQ(ret, HCF_SUCCESS);
383     // cteate key generator
384     HcfSymKeyGenerator *generator = nullptr;
385     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
386     ASSERT_EQ(ret, HCF_SUCCESS);
387     // get sym key from preset keyBlob
388     uint8_t testKey[] = "abcdefghijklmnop";
389     uint32_t testKeyLen = 16;
390     HcfSymKey *key = nullptr;
391     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
392     generator->convertSymKey(generator, &keyMaterialBlob, &key);
393     // test api functions
394     ret = macObj->init(macObj, key);
395     EXPECT_EQ(ret, HCF_SUCCESS);
396     uint32_t len = macObj->getMacLength(macObj);
397     EXPECT_EQ(len, SHA1_LEN);
398     HcfObjDestroy(macObj);
399     HcfObjDestroy(key);
400     HcfObjDestroy(generator);
401 }
402 
403 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest001, TestSize.Level0)
404 {
405     // create a SHA1 obj
406     HcfMac *macObj = nullptr;
407     HcfResult ret = HcfMacCreate("SHA1", &macObj);
408     ASSERT_EQ(ret, HCF_SUCCESS);
409     // create a symKey generator
410     HcfSymKeyGenerator *generator = nullptr;
411     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
412     ASSERT_EQ(ret, HCF_SUCCESS);
413     // set key data and convert it to key obj
414     uint8_t testKey[] = "abcdefghijklmnop";
415     uint32_t testKeyLen = 16;
416     HcfSymKey *key = nullptr;
417     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
418     generator->convertSymKey(generator, &keyMaterialBlob, &key);
419     // set input and output blob
420     uint8_t testData[] = "My test data";
421     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
422     HcfBlob outBlob = { .data = nullptr, .len = 0 };
423     // test api funcitons
424     ret = macObj->init(macObj, key);
425     EXPECT_EQ(ret, HCF_SUCCESS);
426     ret = macObj->update(macObj, &inBlob);
427     EXPECT_EQ(ret, HCF_SUCCESS);
428     ret = macObj->doFinal(macObj, &outBlob);
429     EXPECT_EQ(ret, HCF_SUCCESS);
430     uint32_t len = macObj->getMacLength(macObj);
431     EXPECT_EQ(len, SHA1_LEN);
432     // destroy the API obj and blob data
433     HcfBlobDataClearAndFree(&outBlob);
434     HcfObjDestroy(macObj);
435     HcfObjDestroy(key);
436     HcfObjDestroy(generator);
437 }
438 
439 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest002, TestSize.Level0)
440 {
441     // create a SHA1 obj
442     HcfMac *macObj = nullptr;
443     HcfResult ret = HcfMacCreate("SHA224", &macObj);
444     ASSERT_EQ(ret, HCF_SUCCESS);
445     // create a symKey generator
446     HcfSymKeyGenerator *generator = nullptr;
447     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
448     ASSERT_EQ(ret, HCF_SUCCESS);
449     // set key data and convert it to key obj
450     uint8_t testKey[] = "abcdefghijklmnop";
451     uint32_t testKeyLen = 16;
452     HcfSymKey *key = nullptr;
453     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
454     generator->convertSymKey(generator, &keyMaterialBlob, &key);
455     // set input and output blob
456     uint8_t testData[] = "My test data";
457     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
458     HcfBlob outBlob = { .data = nullptr, .len = 0 };
459     // test api funcitons
460     ret = macObj->init(macObj, key);
461     EXPECT_EQ(ret, HCF_SUCCESS);
462     ret = macObj->update(macObj, &inBlob);
463     EXPECT_EQ(ret, HCF_SUCCESS);
464     ret = macObj->doFinal(macObj, &outBlob);
465     EXPECT_EQ(ret, HCF_SUCCESS);
466     uint32_t len = macObj->getMacLength(macObj);
467     EXPECT_EQ(len, SHA224_LEN);
468     // destroy the API obj and blob data
469     HcfBlobDataClearAndFree(&outBlob);
470     HcfObjDestroy(macObj);
471     HcfObjDestroy(key);
472     HcfObjDestroy(generator);
473 }
474 
475 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest003, TestSize.Level0)
476 {
477     // create a SHA1 obj
478     HcfMac *macObj = nullptr;
479     HcfResult ret = HcfMacCreate("SHA256", &macObj);
480     ASSERT_EQ(ret, HCF_SUCCESS);
481     // create a symKey generator
482     HcfSymKeyGenerator *generator = nullptr;
483     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
484     ASSERT_EQ(ret, HCF_SUCCESS);
485     // set key data and convert it to key obj
486     uint8_t testKey[] = "abcdefghijklmnop";
487     uint32_t testKeyLen = 16;
488     HcfSymKey *key = nullptr;
489     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
490     generator->convertSymKey(generator, &keyMaterialBlob, &key);
491     // set input and output blob
492     uint8_t testData[] = "My test data";
493     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
494     HcfBlob outBlob = { .data = nullptr, .len = 0 };
495     // test api funcitons
496     ret = macObj->init(macObj, key);
497     EXPECT_EQ(ret, HCF_SUCCESS);
498     ret = macObj->update(macObj, &inBlob);
499     EXPECT_EQ(ret, HCF_SUCCESS);
500     ret = macObj->doFinal(macObj, &outBlob);
501     EXPECT_EQ(ret, HCF_SUCCESS);
502     uint32_t len = macObj->getMacLength(macObj);
503     EXPECT_EQ(len, SHA256_LEN);
504     // destroy the API obj and blob data
505     HcfBlobDataClearAndFree(&outBlob);
506     HcfObjDestroy(macObj);
507     HcfObjDestroy(key);
508     HcfObjDestroy(generator);
509 }
510 
511 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest004, TestSize.Level0)
512 {
513     // create a SHA1 obj
514     HcfMac *macObj = nullptr;
515     HcfResult ret = HcfMacCreate("SHA384", &macObj);
516     ASSERT_EQ(ret, HCF_SUCCESS);
517     // create a symKey generator
518     HcfSymKeyGenerator *generator = nullptr;
519     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
520     ASSERT_EQ(ret, HCF_SUCCESS);
521     // set key data and convert it to key obj
522     uint8_t testKey[] = "abcdefghijklmnop";
523     uint32_t testKeyLen = 16;
524     HcfSymKey *key = nullptr;
525     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
526     generator->convertSymKey(generator, &keyMaterialBlob, &key);
527     // set input and output blob
528     uint8_t testData[] = "My test data";
529     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
530     HcfBlob outBlob = { .data = nullptr, .len = 0 };
531     // test api funcitons
532     ret = macObj->init(macObj, key);
533     EXPECT_EQ(ret, HCF_SUCCESS);
534     ret = macObj->update(macObj, &inBlob);
535     EXPECT_EQ(ret, HCF_SUCCESS);
536     ret = macObj->doFinal(macObj, &outBlob);
537     EXPECT_EQ(ret, HCF_SUCCESS);
538     uint32_t len = macObj->getMacLength(macObj);
539     EXPECT_EQ(len, SHA384_LEN);
540     // destroy the API obj and blob data
541     HcfBlobDataClearAndFree(&outBlob);
542     HcfObjDestroy(macObj);
543     HcfObjDestroy(key);
544     HcfObjDestroy(generator);
545 }
546 
547 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest005, TestSize.Level0)
548 {
549     // create a SHA1 obj
550     HcfMac *macObj = nullptr;
551     HcfResult ret = HcfMacCreate("SHA512", &macObj);
552     ASSERT_EQ(ret, HCF_SUCCESS);
553     // create a symKey generator
554     HcfSymKeyGenerator *generator = nullptr;
555     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
556     ASSERT_EQ(ret, HCF_SUCCESS);
557     // set key data and convert it to key obj
558     uint8_t testKey[] = "abcdefghijklmnop";
559     uint32_t testKeyLen = 16;
560     HcfSymKey *key = nullptr;
561     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
562     generator->convertSymKey(generator, &keyMaterialBlob, &key);
563     // set input and output blob
564     uint8_t testData[] = "My test data";
565     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
566     HcfBlob outBlob = { .data = nullptr, .len = 0 };
567     // test api funcitons
568     ret = macObj->init(macObj, key);
569     EXPECT_EQ(ret, HCF_SUCCESS);
570     ret = macObj->update(macObj, &inBlob);
571     EXPECT_EQ(ret, HCF_SUCCESS);
572     ret = macObj->doFinal(macObj, &outBlob);
573     EXPECT_EQ(ret, HCF_SUCCESS);
574     uint32_t len = macObj->getMacLength(macObj);
575     EXPECT_EQ(len, SHA512_LEN);
576     // destroy the API obj and blob data
577     HcfBlobDataClearAndFree(&outBlob);
578     HcfObjDestroy(macObj);
579     HcfObjDestroy(key);
580     HcfObjDestroy(generator);
581 }
582 
583 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest006, TestSize.Level0)
584 {
585     HcfMac *macObj = nullptr;
586     HcfResult ret = HcfMacCreate("SHA256", &macObj);
587     EXPECT_EQ(ret, HCF_SUCCESS);
588     // create a symKey generator
589     HcfSymKeyGenerator *generator = nullptr;
590     ret = HcfSymKeyGeneratorCreate("HMAC", &generator);
591     EXPECT_EQ(ret, HCF_SUCCESS);
592     // set key data and convert it to key obj
593     uint8_t testKey[] = "abcdefghijklmnopabcdefghijklmnop";
594     uint32_t testKeyLen = 32;
595     HcfSymKey *key = nullptr;
596     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
597     generator->convertSymKey(generator, &keyMaterialBlob, &key);
598     // set input and output blob
599     uint8_t testData[] = "My test data";
600     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
601     HcfBlob outBlob = { .data = nullptr, .len = 0 };
602     // test api funcitons
603     ret = macObj->init(macObj, key);
604     EXPECT_EQ(ret, HCF_SUCCESS);
605     ret = macObj->update(macObj, &inBlob);
606     EXPECT_EQ(ret, HCF_SUCCESS);
607     ret = macObj->doFinal(macObj, &outBlob);
608     EXPECT_EQ(ret, HCF_SUCCESS);
609     uint32_t len = macObj->getMacLength(macObj);
610     EXPECT_EQ(len, SHA256_LEN);
611     // destroy the API obj and blob data
612     HcfBlobDataClearAndFree(&outBlob);
613     HcfObjDestroy(macObj);
614     HcfObjDestroy(key);
615     HcfObjDestroy(generator);
616 }
617 
618 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest007, TestSize.Level0)
619 {
620     HcfMac *macObj = nullptr;
621     HcfResult ret = HcfMacCreate("SHA1", &macObj);
622     EXPECT_EQ(ret, HCF_SUCCESS);
623     // create a symKey generator
624     HcfSymKeyGenerator *generator = nullptr;
625     ret = HcfSymKeyGeneratorCreate("HMAC|SHA1", &generator);
626     EXPECT_EQ(ret, HCF_SUCCESS);
627     HcfSymKey *key = nullptr;
628     generator->generateSymKey(generator, &key);
629     // set input and output blob
630     uint8_t testData[] = "My test data";
631     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
632     HcfBlob outBlob = { .data = nullptr, .len = 0 };
633     // test api funcitons
634     ret = macObj->init(macObj, key);
635     EXPECT_EQ(ret, HCF_SUCCESS);
636     ret = macObj->update(macObj, &inBlob);
637     EXPECT_EQ(ret, HCF_SUCCESS);
638     ret = macObj->doFinal(macObj, &outBlob);
639     EXPECT_EQ(ret, HCF_SUCCESS);
640     uint32_t len = macObj->getMacLength(macObj);
641     EXPECT_EQ(len, SHA1_LEN);
642     // destroy the API obj and blob data
643     HcfBlobDataClearAndFree(&outBlob);
644     HcfObjDestroy(macObj);
645     HcfObjDestroy(key);
646     HcfObjDestroy(generator);
647 }
648 
649 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest008, TestSize.Level0)
650 {
651     HcfMac *macObj = nullptr;
652     HcfResult ret = HcfMacCreate("SHA224", &macObj);
653     EXPECT_EQ(ret, HCF_SUCCESS);
654     // create a symKey generator
655     HcfSymKeyGenerator *generator = nullptr;
656     ret = HcfSymKeyGeneratorCreate("HMAC|SHA224", &generator);
657     EXPECT_EQ(ret, HCF_SUCCESS);
658     HcfSymKey *key = nullptr;
659     generator->generateSymKey(generator, &key);
660     // set input and output blob
661     uint8_t testData[] = "My test data";
662     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
663     HcfBlob outBlob = { .data = nullptr, .len = 0 };
664     // test api funcitons
665     ret = macObj->init(macObj, key);
666     EXPECT_EQ(ret, HCF_SUCCESS);
667     ret = macObj->update(macObj, &inBlob);
668     EXPECT_EQ(ret, HCF_SUCCESS);
669     ret = macObj->doFinal(macObj, &outBlob);
670     EXPECT_EQ(ret, HCF_SUCCESS);
671     uint32_t len = macObj->getMacLength(macObj);
672     EXPECT_EQ(len, SHA224_LEN);
673     // destroy the API obj and blob data
674     HcfBlobDataClearAndFree(&outBlob);
675     HcfObjDestroy(macObj);
676     HcfObjDestroy(key);
677     HcfObjDestroy(generator);
678 }
679 
680 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest009, TestSize.Level0)
681 {
682     HcfMac *macObj = nullptr;
683     HcfResult ret = HcfMacCreate("SHA256", &macObj);
684     EXPECT_EQ(ret, HCF_SUCCESS);
685     // create a symKey generator
686     HcfSymKeyGenerator *generator = nullptr;
687     ret = HcfSymKeyGeneratorCreate("HMAC|SHA256", &generator);
688     EXPECT_EQ(ret, HCF_SUCCESS);
689     HcfSymKey *key = nullptr;
690     generator->generateSymKey(generator, &key);
691     // set input and output blob
692     uint8_t testData[] = "My test data";
693     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
694     HcfBlob outBlob = { .data = nullptr, .len = 0 };
695     // test api funcitons
696     ret = macObj->init(macObj, key);
697     EXPECT_EQ(ret, HCF_SUCCESS);
698     ret = macObj->update(macObj, &inBlob);
699     EXPECT_EQ(ret, HCF_SUCCESS);
700     ret = macObj->doFinal(macObj, &outBlob);
701     EXPECT_EQ(ret, HCF_SUCCESS);
702     uint32_t len = macObj->getMacLength(macObj);
703     EXPECT_EQ(len, SHA256_LEN);
704     // destroy the API obj and blob data
705     HcfBlobDataClearAndFree(&outBlob);
706     HcfObjDestroy(macObj);
707     HcfObjDestroy(key);
708     HcfObjDestroy(generator);
709 }
710 
711 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest010, TestSize.Level0)
712 {
713     HcfMac *macObj = nullptr;
714     HcfResult ret = HcfMacCreate("SHA384", &macObj);
715     EXPECT_EQ(ret, HCF_SUCCESS);
716     // create a symKey generator
717     HcfSymKeyGenerator *generator = nullptr;
718     ret = HcfSymKeyGeneratorCreate("HMAC|SHA384", &generator);
719     EXPECT_EQ(ret, HCF_SUCCESS);
720     HcfSymKey *key = nullptr;
721     generator->generateSymKey(generator, &key);
722     // set input and output blob
723     uint8_t testData[] = "My test data";
724     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
725     HcfBlob outBlob = { .data = nullptr, .len = 0 };
726     // test api funcitons
727     ret = macObj->init(macObj, key);
728     EXPECT_EQ(ret, HCF_SUCCESS);
729     ret = macObj->update(macObj, &inBlob);
730     EXPECT_EQ(ret, HCF_SUCCESS);
731     ret = macObj->doFinal(macObj, &outBlob);
732     EXPECT_EQ(ret, HCF_SUCCESS);
733     uint32_t len = macObj->getMacLength(macObj);
734     EXPECT_EQ(len, SHA384_LEN);
735     // destroy the API obj and blob data
736     HcfBlobDataClearAndFree(&outBlob);
737     HcfObjDestroy(macObj);
738     HcfObjDestroy(key);
739     HcfObjDestroy(generator);
740 }
741 
742 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest011, TestSize.Level0)
743 {
744     HcfMac *macObj = nullptr;
745     HcfResult ret = HcfMacCreate("SHA512", &macObj);
746     EXPECT_EQ(ret, HCF_SUCCESS);
747     // create a symKey generator
748     HcfSymKeyGenerator *generator = nullptr;
749     ret = HcfSymKeyGeneratorCreate("HMAC|SHA512", &generator);
750     EXPECT_EQ(ret, HCF_SUCCESS);
751     HcfSymKey *key = nullptr;
752     generator->generateSymKey(generator, &key);
753     // set input and output blob
754     uint8_t testData[] = "My test data";
755     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
756     HcfBlob outBlob = { .data = nullptr, .len = 0 };
757     // test api funcitons
758     ret = macObj->init(macObj, key);
759     EXPECT_EQ(ret, HCF_SUCCESS);
760     ret = macObj->update(macObj, &inBlob);
761     EXPECT_EQ(ret, HCF_SUCCESS);
762     ret = macObj->doFinal(macObj, &outBlob);
763     EXPECT_EQ(ret, HCF_SUCCESS);
764     uint32_t len = macObj->getMacLength(macObj);
765     EXPECT_EQ(len, SHA512_LEN);
766     // destroy the API obj and blob data
767     HcfBlobDataClearAndFree(&outBlob);
768     HcfObjDestroy(macObj);
769     HcfObjDestroy(key);
770     HcfObjDestroy(generator);
771 }
772 
773 HWTEST_F(CryptoMacTest, InvalidHmacTest001, TestSize.Level0)
774 {
775     HcfSymKeyGenerator *generator = nullptr;
776     HcfResult ret = HcfSymKeyGeneratorCreate(nullptr, &generator);
777     EXPECT_NE(ret, HCF_SUCCESS);
778 
779     generator = nullptr;
780     ret = HcfSymKeyGeneratorCreate("HMACC|SHA256", &generator);
781     EXPECT_NE(ret, HCF_SUCCESS);
782 
783     generator = nullptr;
784     ret = HcfSymKeyGeneratorCreate("HMAC|SHA123", &generator);
785     EXPECT_NE(ret, HCF_SUCCESS);
786 
787     generator = nullptr;
788     ret = HcfSymKeyGeneratorCreate("HMAC|MD5", &generator);
789     EXPECT_EQ(ret, HCF_SUCCESS);
790 
791     HcfObjDestroy(generator);
792 }
793 
794 HWTEST_F(CryptoMacTest, InvalidHmacTest002, TestSize.Level0)
795 {
796     HcfSymKeyGenerator *generator = nullptr;
797     HcfResult ret = HcfSymKeyGeneratorCreate("HMAC|SHA256", &generator);
798     EXPECT_EQ(ret, HCF_SUCCESS);
799     // set key data and convert it to key obj
800     uint8_t testKey[] = "abcdefghijklmnop";
801     uint32_t testKeyLen = 16;
802     HcfSymKey *key = nullptr;
803     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
804     ret = generator->convertSymKey(generator, &keyMaterialBlob, &key);
805     EXPECT_NE(ret, HCF_SUCCESS);
806     // destroy the API obj and blob data
807     HcfObjDestroy(generator);
808 }
809 
GetInvalidMacClass(void)810 static const char *GetInvalidMacClass(void)
811 {
812     return "INVALID_MAC_CLASS";
813 }
814 
815 HWTEST_F(CryptoMacTest, InvalidInputMacTest001, TestSize.Level0)
816 {
817     HcfResult ret = OpensslMacSpiCreate("SHA256", nullptr);
818     EXPECT_NE(ret, HCF_SUCCESS);
819     HcfMacSpi *spiObj = nullptr;
820     ret = OpensslMacSpiCreate(nullptr, &spiObj);
821     EXPECT_NE(ret, HCF_SUCCESS);
822 }
823 
824 HWTEST_F(CryptoMacTest, NullParamMacTest001, TestSize.Level0)
825 {
826     HcfMac *macObj = nullptr;
827     HcfResult ret = HcfMacCreate("SHA256", &macObj);
828     ASSERT_EQ(ret, HCF_SUCCESS);
829     ret = macObj->init(nullptr, nullptr);
830     EXPECT_NE(ret, HCF_SUCCESS);
831     ret = macObj->update(nullptr, nullptr);
832     EXPECT_NE(ret, HCF_SUCCESS);
833     ret = macObj->doFinal(nullptr, nullptr);
834     EXPECT_NE(ret, HCF_SUCCESS);
835     uint32_t len = macObj->getMacLength(nullptr);
836     EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
837     const char *algoName = macObj->getAlgoName(nullptr);
838     EXPECT_EQ(algoName, nullptr);
839     macObj->base.destroy(nullptr);
840     HcfObjDestroy(macObj);
841 }
842 
843 HWTEST_F(CryptoMacTest, InvalidFrameworkClassMacTest001, TestSize.Level0)
844 {
845     HcfMac *macObj = nullptr;
846     HcfResult ret = HcfMacCreate("SHA256", &macObj);
847     ASSERT_EQ(ret, HCF_SUCCESS);
848     HcfMac invalidMacObj = {{0}};
849     invalidMacObj.base.getClass = GetInvalidMacClass;
850     HcfSymKeyGenerator *generator = nullptr;
851     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
852     ASSERT_EQ(ret, HCF_SUCCESS);
853     uint8_t testKey[] = "abcdefghijklmnop";
854     uint32_t testKeyLen = sizeof(testKey) / sizeof(testKey[0]);
855     HcfSymKey *key = nullptr;
856     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
857     generator->convertSymKey(generator, &keyMaterialBlob, &key);
858     uint8_t testData[] = "My test data";
859     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
860     HcfBlob outBlob = { .data = nullptr, .len = 0 };
861     ret = macObj->init(&invalidMacObj, key);
862     EXPECT_NE(ret, HCF_SUCCESS);
863     ret = macObj->update(&invalidMacObj, &inBlob);
864     EXPECT_NE(ret, HCF_SUCCESS);
865     ret = macObj->doFinal(&invalidMacObj, &outBlob);
866     EXPECT_NE(ret, HCF_SUCCESS);
867     uint32_t len = macObj->getMacLength(&invalidMacObj);
868     EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
869     const char *algoName = macObj->getAlgoName(&invalidMacObj);
870     EXPECT_EQ(algoName, nullptr);
871     HcfBlobDataClearAndFree(&outBlob);
872     macObj->base.destroy(&(invalidMacObj.base));
873     HcfObjDestroy(macObj);
874     HcfObjDestroy(key);
875     HcfObjDestroy(generator);
876 }
877 
878 HWTEST_F(CryptoMacTest, InvalidSpiClassMacTest001, TestSize.Level0)
879 {
880     HcfMacSpi *spiObj = nullptr;
881     HcfMacSpi invalidSpi = {{0}};
882     invalidSpi.base.getClass = GetInvalidMacClass;
883     // create a symKey generator
884     HcfSymKeyGenerator *generator = nullptr;
885     HcfResult ret = HcfSymKeyGeneratorCreate("AES128", &generator);
886     ASSERT_EQ(ret, HCF_SUCCESS);
887     // set key data and convert it to key obj
888     uint8_t testKey[] = "abcdefghijklmnop";
889     uint32_t testKeyLen = 16;
890     HcfSymKey *key = nullptr;
891     HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
892     generator->convertSymKey(generator, &keyMaterialBlob, &key);
893     // set input and output blob
894     uint8_t testData[] = "My test data";
895     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
896     HcfBlob outBlob = { .data = nullptr, .len = 0 };
897     ret = OpensslMacSpiCreate("SHA256", &spiObj);
898     EXPECT_EQ(ret, HCF_SUCCESS);
899     ASSERT_NE(spiObj, nullptr);
900     (void)spiObj->base.destroy(nullptr);
901     (void)spiObj->base.destroy(&(invalidSpi.base));
902     ret = spiObj->engineInitMac(&invalidSpi, key);
903     EXPECT_NE(ret, HCF_SUCCESS);
904     ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob);
905     EXPECT_NE(ret, HCF_SUCCESS);
906     ret = spiObj->engineDoFinalMac(&invalidSpi, &outBlob);
907     EXPECT_NE(ret, HCF_SUCCESS);
908     uint32_t len = spiObj->engineGetMacLength(&invalidSpi);
909     EXPECT_EQ(len, INVALID_LEN);
910     HcfObjDestroy(spiObj);
911     HcfObjDestroy(key);
912     HcfObjDestroy(generator);
913 }
914 
915 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacAlgoTest012, TestSize.Level0)
916 {
917     HcfMac *macObj = nullptr;
918     HcfResult ret = HcfMacCreate("MD5", &macObj);
919     EXPECT_EQ(ret, HCF_SUCCESS);
920     // create a symKey generator
921     HcfSymKeyGenerator *generator = nullptr;
922     ret = HcfSymKeyGeneratorCreate("HMAC|MD5", &generator);
923     EXPECT_EQ(ret, HCF_SUCCESS);
924     HcfSymKey *key = nullptr;
925     generator->generateSymKey(generator, &key);
926     // set input and output blob
927     uint8_t testData[] = "My test data";
928     HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
929     HcfBlob outBlob = { .data = nullptr, .len = 0 };
930     // test api funcitons
931     ret = macObj->init(macObj, key);
932     EXPECT_EQ(ret, HCF_SUCCESS);
933     ret = macObj->update(macObj, &inBlob);
934     EXPECT_EQ(ret, HCF_SUCCESS);
935     ret = macObj->doFinal(macObj, &outBlob);
936     EXPECT_EQ(ret, HCF_SUCCESS);
937     uint32_t len = macObj->getMacLength(macObj);
938     EXPECT_EQ(len, MD5_LEN);
939     // destroy the API obj and blob data
940     HcfBlobDataClearAndFree(&outBlob);
941     HcfObjDestroy(macObj);
942     HcfObjDestroy(key);
943     HcfObjDestroy(generator);
944 }
945 
TestCreateHmacKey(HcfSymKeyGenerator * generator,const char * hmacAlgName,int keyLen,const char * expectKeyAlgName)946 static void TestCreateHmacKey(HcfSymKeyGenerator *generator, const char *hmacAlgName, int keyLen,
947     const char *expectKeyAlgName)
948 {
949     HcfResult ret;
950     HcfSymKey *key = nullptr;
951     HcfBlob keyMaterialBlob = {0};
952 
953     if (strlen(hmacAlgName) != strlen("HMAC")) {
954         ret = generator->generateSymKey(generator, &key);
955         ASSERT_EQ(ret, HCF_SUCCESS);
956         EXPECT_STREQ(key->key.getAlgorithm(reinterpret_cast<HcfKey *>(key)), expectKeyAlgName);
957         HcfObjDestroy(key);
958         key = nullptr;
959     }
960 
961     keyMaterialBlob.len = keyLen;
962     keyMaterialBlob.data = reinterpret_cast<uint8_t *>(HcfMalloc(4096, 0)); // max keyLen is 4096
963     ASSERT_NE(keyMaterialBlob.data, nullptr);
964 
965     ret = generator->convertSymKey(generator, &keyMaterialBlob, &key);
966     HcfFree(keyMaterialBlob.data);
967     ASSERT_EQ(ret, HCF_SUCCESS);
968     EXPECT_STREQ(key->key.getAlgorithm(reinterpret_cast<HcfKey *>(key)), expectKeyAlgName);
969     HcfObjDestroy(key);
970 }
971 
TestHmacKeyAlgoName(const char * hmacAlgName,int keyLen,const char * expectKeyAlgName)972 static void TestHmacKeyAlgoName(const char *hmacAlgName, int keyLen, const char *expectKeyAlgName)
973 {
974     HcfResult ret;
975     HcfSymKeyGenerator *generator = nullptr;
976 
977     ret = HcfSymKeyGeneratorCreate(hmacAlgName, &generator);
978     ASSERT_EQ(ret, HCF_SUCCESS);
979 
980     TestCreateHmacKey(generator, hmacAlgName, keyLen, expectKeyAlgName);
981 
982     HcfObjDestroy(generator);
983 }
984 
985 HWTEST_F(CryptoMacTest, CryptoFrameworkHmacKeyAlgoNameTest001, TestSize.Level0)
986 {
987     TestHmacKeyAlgoName("HMAC|SHA1", 20, "HMAC160");
988     TestHmacKeyAlgoName("HMAC|SHA224", 28, "HMAC224");
989     TestHmacKeyAlgoName("HMAC|SHA256", 32, "HMAC256");
990     TestHmacKeyAlgoName("HMAC|SHA384", 48, "HMAC384");
991     TestHmacKeyAlgoName("HMAC|SHA512", 64, "HMAC512");
992     TestHmacKeyAlgoName("HMAC|SM3", 32, "HMAC256");
993     TestHmacKeyAlgoName("HMAC|MD5", 16, "HMAC128");
994 
995     TestHmacKeyAlgoName("HMAC", 1, "HMAC8");
996     TestHmacKeyAlgoName("HMAC", 2, "HMAC16");
997     TestHmacKeyAlgoName("HMAC", 128, "HMAC1024");
998     TestHmacKeyAlgoName("HMAC", 4096, "HMAC32768");
999 }
1000 
1001 }