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