1 /*
2 * Copyright (C) 2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #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 CryptoSM3MacTest : 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 SM3_LEN = 32;
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 CryptoSM3MacTest::SetUpTestCase() {}
TearDownTestCase()60 void CryptoSM3MacTest::TearDownTestCase() {}
61
SetUp()62 void CryptoSM3MacTest::SetUp() // add init here, this will be called before test.
63 {
64 }
65
TearDown()66 void CryptoSM3MacTest::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(CryptoSM3MacTest, CryptoFrameworkHmacSM3CreateTest001, TestSize.Level0)
79 {
80 HcfHmacParamsSpec params = {};
81 params.base.algName = "HMAC";
82 params.mdName = "SM3";
83 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, nullptr);
84 EXPECT_NE(ret, HCF_SUCCESS);
85 }
86
87 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoSuppTest001, TestSize.Level0)
88 {
89 // create a SM3 obj
90 HcfMac *macObj = nullptr;
91 HcfHmacParamsSpec params = {};
92 params.base.algName = "HMAC";
93 params.mdName = "SM3";
94 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
95 ASSERT_EQ(ret, HCF_SUCCESS);
96 EXPECT_NE(macObj, nullptr);
97 HcfObjDestroy(macObj);
98 }
99
100 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoSuppTest002, TestSize.Level0)
101 {
102 // create a SM3 obj
103 HcfMac *macObj = nullptr;
104 HcfHmacParamsSpec params = {};
105 params.base.algName = "HMAC";
106 params.mdName = "SM3";
107 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
108 EXPECT_EQ(ret, HCF_SUCCESS);
109 EXPECT_NE(macObj, nullptr);
110 HcfObjDestroy(macObj);
111 }
112
113 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoSuppTest003, TestSize.Level0)
114 {
115 // create a SM3 obj
116 HcfMac *macObj = nullptr;
117 HcfResult ret = HcfMacCreate(nullptr, &macObj);
118 EXPECT_NE(ret, HCF_SUCCESS);
119 EXPECT_EQ(macObj, nullptr);
120 }
121
122 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoNameTest001, TestSize.Level0)
123 {
124 // create a SM3 obj
125 HcfMac *macObj = nullptr;
126 HcfHmacParamsSpec params = {};
127 params.base.algName = "HMAC";
128 params.mdName = "SM3";
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(CryptoSM3MacTest, CryptoFrameworkHmacSM3InitTest001, TestSize.Level0)
140 {
141 // create a SM3 obj
142 HcfMac *macObj = nullptr;
143 HcfHmacParamsSpec params = {};
144 params.base.algName = "HMAC";
145 params.mdName = "SM3";
146 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
147 ASSERT_EQ(ret, HCF_SUCCESS);
148 // set a nullptr key
149 HcfSymKey *key = nullptr;
150 // test api functions
151 ret = macObj->init(macObj, key);
152 EXPECT_NE(ret, HCF_SUCCESS);
153 HcfObjDestroy(macObj);
154 }
155
156 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3InitTest002, TestSize.Level0)
157 {
158 // create a SM3 obj
159 HcfMac *macObj = nullptr;
160 HcfHmacParamsSpec params = {};
161 params.base.algName = "HMAC";
162 params.mdName = "SM3";
163 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
164 ASSERT_EQ(ret, HCF_SUCCESS);
165 // create a symKey generator
166 HcfSymKeyGenerator *generator = nullptr;
167 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
168 ASSERT_EQ(ret, HCF_SUCCESS);
169 // get sym key from preset keyBlob
170 uint8_t testKey[] = "abcdefghijklmnop";
171 uint32_t testKeyLen = 16;
172 HcfSymKey *key = nullptr;
173 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
174 generator->convertSymKey(generator, &keyMaterialBlob, &key);
175 // test api functions
176 ret = macObj->init(macObj, key);
177 EXPECT_EQ(ret, HCF_SUCCESS);
178 HcfObjDestroy(macObj);
179 HcfObjDestroy(key);
180 HcfObjDestroy(generator);
181 }
182
183 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3UpdateTest001, TestSize.Level0)
184 {
185 // create a SM3 obj
186 HcfMac *macObj = nullptr;
187 HcfHmacParamsSpec params = {};
188 params.base.algName = "HMAC";
189 params.mdName = "SM3";
190 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
191 ASSERT_EQ(ret, HCF_SUCCESS);
192 // set input and output buf
193 uint8_t testData[] = "My test data";
194 // define input and output data in blob form
195 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
196 // test api functions
197 ret = macObj->update(macObj, &inBlob);
198 EXPECT_NE(ret, HCF_SUCCESS);
199 HcfObjDestroy(macObj);
200 }
201
202 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3UpdateTest002, TestSize.Level0)
203 {
204 // create a SM3 obj
205 HcfMac *macObj = nullptr;
206 HcfHmacParamsSpec params = {};
207 params.base.algName = "HMAC";
208 params.mdName = "SM3";
209 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
210 ASSERT_EQ(ret, HCF_SUCCESS);
211 // cteate key generator and set key text
212 HcfSymKeyGenerator *generator = nullptr;
213 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
214 ASSERT_EQ(ret, HCF_SUCCESS);
215 // get sym key from preset keyBlob
216 uint8_t testKey[] = "abcdefghijklmnop";
217 uint32_t testKeyLen = 16;
218 HcfSymKey *key = nullptr;
219 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
220 generator->convertSymKey(generator, &keyMaterialBlob, &key);
221 // define input and output data in blob form
222 HcfBlob *inBlob = nullptr;
223 // test api functions
224 ret = macObj->init(macObj, key);
225 EXPECT_EQ(ret, HCF_SUCCESS);
226 ret = macObj->update(macObj, inBlob);
227 EXPECT_NE(ret, HCF_SUCCESS);
228 HcfObjDestroy(macObj);
229 HcfObjDestroy(key);
230 HcfObjDestroy(generator);
231 }
232
233 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3UpdateTest003, TestSize.Level0)
234 {
235 // create a API obj with SM3
236 HcfMac *macObj = nullptr;
237 HcfHmacParamsSpec params = {};
238 params.base.algName = "HMAC";
239 params.mdName = "SM3";
240 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
241 ASSERT_EQ(ret, HCF_SUCCESS);
242 // cteate key generator and set key text
243 HcfSymKeyGenerator *generator = nullptr;
244 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
245 ASSERT_EQ(ret, HCF_SUCCESS);
246 // get sym key from preset keyBlob
247 uint8_t testKey[] = "abcdefghijklmnop";
248 uint32_t testKeyLen = 16;
249 HcfSymKey *key = nullptr;
250 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
251 generator->convertSymKey(generator, &keyMaterialBlob, &key);
252 // set input and output buf
253 uint8_t testData[] = "My test data";
254 // define input and output data in blob form
255 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
256 // test api functions
257 ret = macObj->init(macObj, key);
258 EXPECT_EQ(ret, HCF_SUCCESS);
259 ret = macObj->update(macObj, &inBlob);
260 EXPECT_EQ(ret, HCF_SUCCESS);
261 HcfObjDestroy(macObj);
262 HcfObjDestroy(key);
263 HcfObjDestroy(generator);
264 }
265
266 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3DoFinalTest001, TestSize.Level0)
267 {
268 // create a SM3 obj
269 HcfMac *macObj = nullptr;
270 HcfHmacParamsSpec params = {};
271 params.base.algName = "HMAC";
272 params.mdName = "SM3";
273 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
274 ASSERT_EQ(ret, HCF_SUCCESS);
275 // set input and output buf
276 HcfBlob outBlob = { .data = nullptr, .len = 0 };
277 // test api functions
278 ret = macObj->doFinal(macObj, &outBlob);
279 EXPECT_NE(ret, HCF_SUCCESS);
280 // destroy the API obj and blob data
281 HcfObjDestroy(macObj);
282 }
283
284 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3DoFinalTest002, TestSize.Level0)
285 {
286 // create a SM3 obj
287 HcfMac *macObj = nullptr;
288 HcfHmacParamsSpec params = {};
289 params.base.algName = "HMAC";
290 params.mdName = "SM3";
291 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
292 ASSERT_EQ(ret, HCF_SUCCESS);
293 // cteate key generator and set key text
294 HcfSymKeyGenerator *generator = nullptr;
295 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
296 ASSERT_EQ(ret, HCF_SUCCESS);
297 // get sym key from preset keyBlob
298 uint8_t testKey[] = "abcdefghijklmnop";
299 uint32_t testKeyLen = 16;
300 HcfSymKey *key = nullptr;
301 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
302 generator->convertSymKey(generator, &keyMaterialBlob, &key);
303 printf("get symkey finish");
304 // set input and output buf
305 HcfBlob outBlob = { .data = nullptr, .len = 0 };
306 // test api functions
307 ret = macObj->init(macObj, key);
308 EXPECT_EQ(ret, HCF_SUCCESS);
309 printf("test init finish");
310 ret = macObj->doFinal(macObj, &outBlob);
311 EXPECT_EQ(ret, HCF_SUCCESS);
312 printf("test dofinal finish");
313 PrintfBlobInHex(outBlob.data, outBlob.len);
314 // destroy the API obj and blob data
315 HcfBlobDataClearAndFree(&outBlob);
316 printf("HcfBlobDataClearAndFree finish");
317 HcfObjDestroy(macObj);
318 printf("HcfObjDestroy macObj finish");
319 HcfObjDestroy(key);
320 printf("HcfObjDestroy key finish");
321 HcfObjDestroy(generator);
322 printf("test finish");
323 }
324
325 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3DoFinalTest003, TestSize.Level0)
326 {
327 // create a SM3 obj
328 HcfMac *macObj = nullptr;
329 HcfHmacParamsSpec params = {};
330 params.base.algName = "HMAC";
331 params.mdName = "SM3";
332 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
333 ASSERT_EQ(ret, HCF_SUCCESS);
334 // cteate key generator
335 HcfSymKeyGenerator *generator = nullptr;
336 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
337 ASSERT_EQ(ret, HCF_SUCCESS);
338 // get sym key from preset keyBlob
339 uint8_t testKey[] = "abcdefghijklmnop";
340 uint32_t testKeyLen = 16;
341 HcfSymKey *key = nullptr;
342 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
343 generator->convertSymKey(generator, &keyMaterialBlob, &key);
344 // set input and output buf
345 uint8_t testData[] = "My test data";
346 // define input and output data in blob form
347 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
348 HcfBlob outBlob = { .data = nullptr, .len = 0 };
349 // test api functions
350 ret = macObj->init(macObj, key);
351 EXPECT_EQ(ret, HCF_SUCCESS);
352 ret = macObj->update(macObj, &inBlob);
353 EXPECT_EQ(ret, HCF_SUCCESS);
354 ret = macObj->doFinal(macObj, &outBlob);
355 EXPECT_EQ(ret, HCF_SUCCESS);
356 // destroy the API obj and blob data
357 HcfBlobDataClearAndFree(&outBlob);
358 HcfObjDestroy(macObj);
359 HcfObjDestroy(key);
360 HcfObjDestroy(generator);
361 }
362
363 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3DoFinalTest004, TestSize.Level0)
364 {
365 // create a SM3 obj
366 HcfMac *macObj = nullptr;
367 HcfHmacParamsSpec params = {};
368 params.base.algName = "HMAC";
369 params.mdName = "SM3";
370 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
371 ASSERT_EQ(ret, HCF_SUCCESS);
372 // cteate key generator
373 HcfSymKeyGenerator *generator = nullptr;
374 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
375 ASSERT_EQ(ret, HCF_SUCCESS);
376 // get sym key from preset keyBlob
377 uint8_t testKey[] = "abcdefghijklmnop";
378 uint32_t testKeyLen = 16;
379 HcfSymKey *key = nullptr;
380 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
381 generator->convertSymKey(generator, &keyMaterialBlob, &key);
382 // define input and output data in blob form
383 HcfBlob inBlob = {0};
384 inBlob.data = reinterpret_cast<uint8_t *>(g_testBigData);
385 inBlob.len = strnlen(g_testBigData, MAX_MAC_BLOB_LEN);
386 HcfBlob outBlob = { .data = nullptr, .len = 0 };
387 // test api functions
388 ret = macObj->init(macObj, key);
389 EXPECT_EQ(ret, HCF_SUCCESS);
390 ret = macObj->update(macObj, &inBlob);
391 EXPECT_EQ(ret, HCF_SUCCESS);
392 ret = macObj->doFinal(macObj, &outBlob);
393 EXPECT_EQ(ret, HCF_SUCCESS);
394 PrintfBlobInHex(outBlob.data, outBlob.len);
395 // destroy the API obj and blob data
396 HcfBlobDataClearAndFree(&outBlob);
397 HcfObjDestroy(macObj);
398 HcfObjDestroy(key);
399 HcfObjDestroy(generator);
400 }
401
402 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3LenTest001, TestSize.Level0)
403 {
404 // create a SM3 obj
405 HcfMac *macObj = nullptr;
406 HcfHmacParamsSpec params = {};
407 params.base.algName = "HMAC";
408 params.mdName = "SM3";
409 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
410 ASSERT_EQ(ret, HCF_SUCCESS);
411 // test api functions
412 uint32_t len = macObj->getMacLength(macObj);
413 EXPECT_EQ(len, INVALID_LEN);
414 HcfObjDestroy(macObj);
415 }
416
417 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3LenTest002, TestSize.Level0)
418 {
419 // create a SM3 obj
420 HcfMac *macObj = nullptr;
421 HcfHmacParamsSpec params = {};
422 params.base.algName = "HMAC";
423 params.mdName = "SM3";
424 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
425 ASSERT_EQ(ret, HCF_SUCCESS);
426 // cteate key generator
427 HcfSymKeyGenerator *generator = nullptr;
428 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
429 ASSERT_EQ(ret, HCF_SUCCESS);
430 // get sym key from preset keyBlob
431 uint8_t testKey[] = "abcdefghijklmnop";
432 uint32_t testKeyLen = 16;
433 HcfSymKey *key = nullptr;
434 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
435 generator->convertSymKey(generator, &keyMaterialBlob, &key);
436 // test api functions
437 ret = macObj->init(macObj, key);
438 EXPECT_EQ(ret, HCF_SUCCESS);
439 uint32_t len = macObj->getMacLength(macObj);
440 EXPECT_EQ(len, SM3_LEN);
441 HcfObjDestroy(macObj);
442 HcfObjDestroy(key);
443 HcfObjDestroy(generator);
444 }
445
446 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoTest001, TestSize.Level0)
447 {
448 // create a SM3 obj
449 HcfMac *macObj = nullptr;
450 HcfHmacParamsSpec params = {};
451 params.base.algName = "HMAC";
452 params.mdName = "SM3";
453 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
454 ASSERT_EQ(ret, HCF_SUCCESS);
455 // create a symKey generator
456 HcfSymKeyGenerator *generator = nullptr;
457 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
458 ASSERT_EQ(ret, HCF_SUCCESS);
459 // set key data and convert it to key obj
460 uint8_t testKey[] = "abcdefghijklmnop";
461 uint32_t testKeyLen = 16;
462 HcfSymKey *key = nullptr;
463 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
464 generator->convertSymKey(generator, &keyMaterialBlob, &key);
465 // set input and output blob
466 uint8_t testData[] = "My test data";
467 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
468 HcfBlob outBlob = { .data = nullptr, .len = 0 };
469 // test api funcitons
470 ret = macObj->init(macObj, key);
471 EXPECT_EQ(ret, HCF_SUCCESS);
472 ret = macObj->update(macObj, &inBlob);
473 EXPECT_EQ(ret, HCF_SUCCESS);
474 ret = macObj->doFinal(macObj, &outBlob);
475 EXPECT_EQ(ret, HCF_SUCCESS);
476 uint32_t len = macObj->getMacLength(macObj);
477 EXPECT_EQ(len, SM3_LEN);
478 // destroy the API obj and blob data
479 HcfBlobDataClearAndFree(&outBlob);
480 HcfObjDestroy(macObj);
481 HcfObjDestroy(key);
482 HcfObjDestroy(generator);
483 }
484
485 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoTest002, TestSize.Level0)
486 {
487 // create a SM3 obj
488 HcfMac *macObj = nullptr;
489 HcfHmacParamsSpec params = {};
490 params.base.algName = "HMAC";
491 params.mdName = "SM3";
492 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
493 ASSERT_EQ(ret, HCF_SUCCESS);
494 // create a symKey generator
495 HcfSymKeyGenerator *generator = nullptr;
496 ret = HcfSymKeyGeneratorCreate("AES192", &generator);
497 ASSERT_EQ(ret, HCF_SUCCESS);
498 // set key data and convert it to key obj
499 HcfSymKey *key = nullptr;
500 generator->generateSymKey(generator, &key);
501 // set input and output blob
502 uint8_t testData[] = "My test data";
503 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
504 HcfBlob outBlob = { .data = nullptr, .len = 0 };
505 // test api funcitons
506 ret = macObj->init(macObj, key);
507 EXPECT_EQ(ret, HCF_SUCCESS);
508 ret = macObj->update(macObj, &inBlob);
509 EXPECT_EQ(ret, HCF_SUCCESS);
510 ret = macObj->doFinal(macObj, &outBlob);
511 EXPECT_EQ(ret, HCF_SUCCESS);
512 uint32_t len = macObj->getMacLength(macObj);
513 EXPECT_EQ(len, SM3_LEN);
514 // destroy the API obj and blob data
515 HcfBlobDataClearAndFree(&outBlob);
516 HcfObjDestroy(macObj);
517 HcfObjDestroy(key);
518 HcfObjDestroy(generator);
519 }
520
521 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoTest003, TestSize.Level0)
522 {
523 // create a SM3 obj
524 HcfMac *macObj = nullptr;
525 HcfHmacParamsSpec params = {};
526 params.base.algName = "HMAC";
527 params.mdName = "SM3";
528 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
529 ASSERT_EQ(ret, HCF_SUCCESS);
530 // create a symKey generator
531 HcfSymKeyGenerator *generator = nullptr;
532 ret = HcfSymKeyGeneratorCreate("AES256", &generator);
533 ASSERT_EQ(ret, HCF_SUCCESS);
534 // set key data and convert it to key obj
535 HcfSymKey *key = nullptr;
536 generator->generateSymKey(generator, &key);
537 // set input and output blob
538 uint8_t testData[] = "My test data";
539 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
540 HcfBlob outBlob = { .data = nullptr, .len = 0 };
541 // test api funcitons
542 ret = macObj->init(macObj, key);
543 EXPECT_EQ(ret, HCF_SUCCESS);
544 ret = macObj->update(macObj, &inBlob);
545 EXPECT_EQ(ret, HCF_SUCCESS);
546 ret = macObj->doFinal(macObj, &outBlob);
547 EXPECT_EQ(ret, HCF_SUCCESS);
548 uint32_t len = macObj->getMacLength(macObj);
549 EXPECT_EQ(len, SM3_LEN);
550 // destroy the API obj and blob data
551 HcfBlobDataClearAndFree(&outBlob);
552 HcfObjDestroy(macObj);
553 HcfObjDestroy(key);
554 HcfObjDestroy(generator);
555 }
556
557 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoTest004, TestSize.Level0)
558 {
559 // create a SM3 obj
560 HcfMac *macObj = nullptr;
561 HcfHmacParamsSpec params = {};
562 params.base.algName = "HMAC";
563 params.mdName = "SM3";
564 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
565 ASSERT_EQ(ret, HCF_SUCCESS);
566 // create a symKey generator
567 HcfSymKeyGenerator *generator = nullptr;
568 ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
569 ASSERT_EQ(ret, HCF_SUCCESS);
570 // set key data and convert it to key obj
571 HcfSymKey *key = nullptr;
572 generator->generateSymKey(generator, &key);
573 // set input and output blob
574 uint8_t testData[] = "My test data";
575 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
576 HcfBlob outBlob = { .data = nullptr, .len = 0 };
577 // test api funcitons
578 ret = macObj->init(macObj, key);
579 EXPECT_EQ(ret, HCF_SUCCESS);
580 ret = macObj->update(macObj, &inBlob);
581 EXPECT_EQ(ret, HCF_SUCCESS);
582 ret = macObj->doFinal(macObj, &outBlob);
583 EXPECT_EQ(ret, HCF_SUCCESS);
584 uint32_t len = macObj->getMacLength(macObj);
585 EXPECT_EQ(len, SM3_LEN);
586 // destroy the API obj and blob data
587 HcfBlobDataClearAndFree(&outBlob);
588 HcfObjDestroy(macObj);
589 HcfObjDestroy(key);
590 HcfObjDestroy(generator);
591 }
592
593 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoTest005, TestSize.Level0)
594 {
595 // create a SM3 obj
596 HcfMac *macObj = nullptr;
597 HcfHmacParamsSpec params = {};
598 params.base.algName = "HMAC";
599 params.mdName = "SM3";
600 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
601 ASSERT_EQ(ret, HCF_SUCCESS);
602 // create a symKey generator
603 HcfSymKeyGenerator *generator = nullptr;
604 ret = HcfSymKeyGeneratorCreate("SM4_128", &generator);
605 ASSERT_EQ(ret, HCF_SUCCESS);
606 // set key data and convert it to key obj
607 HcfSymKey *key = nullptr;
608 generator->generateSymKey(generator, &key);
609 // set input and output blob
610 uint8_t testData[] = "My test data";
611 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
612 HcfBlob outBlob = {.data = nullptr, .len = 0};
613 // test api funcitons
614 ret = macObj->init(macObj, key);
615 EXPECT_EQ(ret, HCF_SUCCESS);
616 ret = macObj->update(macObj, &inBlob);
617 EXPECT_EQ(ret, HCF_SUCCESS);
618 ret = macObj->doFinal(macObj, &outBlob);
619 EXPECT_EQ(ret, HCF_SUCCESS);
620 uint32_t len = macObj->getMacLength(macObj);
621 EXPECT_EQ(len, SM3_LEN);
622 // destroy the API obj and blob data
623 HcfBlobDataClearAndFree(&outBlob);
624 HcfObjDestroy(macObj);
625 HcfObjDestroy(key);
626 HcfObjDestroy(generator);
627 }
628
629 HWTEST_F(CryptoSM3MacTest, CryptoFrameworkHmacSM3AlgoTest006, TestSize.Level0)
630 {
631 HcfMac *macObj = nullptr;
632 HcfHmacParamsSpec params = {};
633 params.base.algName = "HMAC";
634 params.mdName = "SM3";
635 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
636 ASSERT_EQ(ret, HCF_SUCCESS);
637 // create a symKey generator
638 HcfSymKeyGenerator *generator = nullptr;
639 ret = HcfSymKeyGeneratorCreate("HMAC|SM3", &generator);
640 ASSERT_EQ(ret, HCF_SUCCESS);
641 // set key data and convert it to key obj
642 HcfSymKey *key = nullptr;
643 generator->generateSymKey(generator, &key);
644 // set input and output blob
645 uint8_t testData[] = "My test data";
646 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
647 HcfBlob outBlob = {.data = nullptr, .len = 0};
648 // test api funcitons
649 ret = macObj->init(macObj, key);
650 EXPECT_EQ(ret, HCF_SUCCESS);
651 ret = macObj->update(macObj, &inBlob);
652 EXPECT_EQ(ret, HCF_SUCCESS);
653 ret = macObj->doFinal(macObj, &outBlob);
654 EXPECT_EQ(ret, HCF_SUCCESS);
655 uint32_t len = macObj->getMacLength(macObj);
656 EXPECT_EQ(len, SM3_LEN);
657 // destroy the API obj and blob data
658 HcfBlobDataClearAndFree(&outBlob);
659 HcfObjDestroy(macObj);
660 HcfObjDestroy(key);
661 HcfObjDestroy(generator);
662 }
663
GetInvalidMacSm3Class(void)664 static const char *GetInvalidMacSm3Class(void)
665 {
666 return "INVALID_MAC_CLASS";
667 }
668
669 HWTEST_F(CryptoSM3MacTest, InvalidInputMacSM3Test001, TestSize.Level0)
670 {
671 HcfHmacParamsSpec params = {};
672 params.base.algName = "HMAC";
673 params.mdName = "SM3";
674 HcfResult ret = OpensslHmacSpiCreate((HcfMacParamsSpec *)¶ms, nullptr);
675 EXPECT_NE(ret, HCF_SUCCESS);
676 HcfMacSpi *spiObj = nullptr;
677 ret = OpensslHmacSpiCreate(nullptr, &spiObj);
678 EXPECT_NE(ret, HCF_SUCCESS);
679 }
680
681 HWTEST_F(CryptoSM3MacTest, NullParamMacSM3Test001, TestSize.Level0)
682 {
683 HcfMac *macObj = nullptr;
684 HcfHmacParamsSpec params = {};
685 params.base.algName = "HMAC";
686 params.mdName = "SM3";
687 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
688 ASSERT_EQ(ret, HCF_SUCCESS);
689 ret = macObj->init(nullptr, nullptr);
690 EXPECT_NE(ret, HCF_SUCCESS);
691 ret = macObj->update(nullptr, nullptr);
692 EXPECT_NE(ret, HCF_SUCCESS);
693 ret = macObj->doFinal(nullptr, nullptr);
694 EXPECT_NE(ret, HCF_SUCCESS);
695 uint32_t len = macObj->getMacLength(nullptr);
696 EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
697 const char *algoName = macObj->getAlgoName(nullptr);
698 EXPECT_EQ(algoName, nullptr);
699 macObj->base.destroy(nullptr);
700 HcfObjDestroy(macObj);
701 }
702
703 HWTEST_F(CryptoSM3MacTest, InvalidFrameworkClassMacSM3Test001, TestSize.Level0)
704 {
705 HcfMac *macObj = nullptr;
706 HcfHmacParamsSpec params = {};
707 params.base.algName = "HMAC";
708 params.mdName = "SM3";
709 HcfResult ret = HcfMacCreate((HcfMacParamsSpec *)¶ms, &macObj);
710 ASSERT_EQ(ret, HCF_SUCCESS);
711 HcfMac invalidMacObj = {{0}};
712 invalidMacObj.base.getClass = GetInvalidMacSm3Class;
713 HcfSymKeyGenerator *generator = nullptr;
714 ret = HcfSymKeyGeneratorCreate("AES128", &generator);
715 ASSERT_EQ(ret, HCF_SUCCESS);
716 uint8_t testKey[] = "abcdefghijklmnop";
717 uint32_t testKeyLen = sizeof(testKey) / sizeof(testKey[0]);
718 HcfSymKey *key = nullptr;
719 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
720 generator->convertSymKey(generator, &keyMaterialBlob, &key);
721 uint8_t testData[] = "My test data";
722 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
723 HcfBlob outBlob = { .data = nullptr, .len = 0 };
724 ret = macObj->init(&invalidMacObj, key);
725 EXPECT_NE(ret, HCF_SUCCESS);
726 ret = macObj->update(&invalidMacObj, &inBlob);
727 EXPECT_NE(ret, HCF_SUCCESS);
728 ret = macObj->doFinal(&invalidMacObj, &outBlob);
729 EXPECT_NE(ret, HCF_SUCCESS);
730 uint32_t len = macObj->getMacLength(&invalidMacObj);
731 EXPECT_EQ(len, HCF_OPENSSL_INVALID_MAC_LEN);
732 const char *algoName = macObj->getAlgoName(&invalidMacObj);
733 EXPECT_EQ(algoName, nullptr);
734 HcfBlobDataClearAndFree(&outBlob);
735 macObj->base.destroy(&(invalidMacObj.base));
736 HcfObjDestroy(macObj);
737 HcfObjDestroy(key);
738 HcfObjDestroy(generator);
739 }
740
741 HWTEST_F(CryptoSM3MacTest, InvalidSpiClassMacSM3Test001, TestSize.Level0)
742 {
743 HcfMacSpi *spiObj = nullptr;
744 HcfMacSpi invalidSpi = {{0}};
745 invalidSpi.base.getClass = GetInvalidMacSm3Class;
746 // create a symKey generator
747 HcfSymKeyGenerator *generator = nullptr;
748 HcfResult ret = HcfSymKeyGeneratorCreate("AES128", &generator);
749 ASSERT_EQ(ret, HCF_SUCCESS);
750 // set key data and convert it to key obj
751 uint8_t testKey[] = "abcdefghijklmnop";
752 uint32_t testKeyLen = 16;
753 HcfSymKey *key = nullptr;
754 HcfBlob keyMaterialBlob = {.data = reinterpret_cast<uint8_t *>(testKey), .len = testKeyLen};
755 generator->convertSymKey(generator, &keyMaterialBlob, &key);
756 // set input and output blob
757 uint8_t testData[] = "My test data";
758 HcfBlob inBlob = {.data = reinterpret_cast<uint8_t *>(testData), .len = sizeof(testData)};
759 HcfBlob outBlob = { .data = nullptr, .len = 0 };
760 HcfHmacParamsSpec params = {};
761 params.base.algName = "HMAC";
762 params.mdName = "SM3";
763 ret = OpensslHmacSpiCreate((HcfMacParamsSpec *)¶ms, &spiObj);
764 EXPECT_EQ(ret, HCF_SUCCESS);
765 ASSERT_NE(spiObj, nullptr);
766 (void)spiObj->base.destroy(nullptr);
767 (void)spiObj->base.destroy(&(invalidSpi.base));
768 ret = spiObj->engineInitMac(&invalidSpi, key);
769 EXPECT_NE(ret, HCF_SUCCESS);
770 ret = spiObj->engineUpdateMac(&invalidSpi, &inBlob);
771 EXPECT_NE(ret, HCF_SUCCESS);
772 ret = spiObj->engineDoFinalMac(&invalidSpi, &outBlob);
773 EXPECT_NE(ret, HCF_SUCCESS);
774 uint32_t len = spiObj->engineGetMacLength(&invalidSpi);
775 EXPECT_EQ(len, INVALID_LEN);
776 HcfObjDestroy(spiObj);
777 HcfObjDestroy(key);
778 HcfObjDestroy(generator);
779 }
780 }
781