• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 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 <fstream>
18 #include <iostream>
19 #include "securec.h"
20 
21 #include "aes_common.h"
22 #include "aes_openssl.h"
23 #include "blob.h"
24 #include "cipher.h"
25 #include "detailed_iv_params.h"
26 #include "detailed_gcm_params.h"
27 #include "detailed_ccm_params.h"
28 #include "log.h"
29 #include "memory.h"
30 #include "sym_common_defines.h"
31 #include "sym_key_generator.h"
32 
33 using namespace std;
34 using namespace testing::ext;
35 
36 namespace {
37 class CryptoAesCipherTest : public testing::Test {
38 public:
SetUpTestCase()39     static void SetUpTestCase() {};
TearDownTestCase()40     static void TearDownTestCase() {};
SetUp()41     void SetUp() {};
TearDown()42     void TearDown() {};
43 };
44 
45 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest001, TestSize.Level0)
46 {
47     HcfSymKeyGenerator *generator = nullptr;
48     HcfSymKey *key = nullptr;
49     const char *inputAlgoName = "AES128";
50     const char *generatorAlgoName = nullptr;
51 
52     int ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
53     ASSERT_EQ(ret, 0);
54 
55     ret = generator->generateSymKey(generator, &key);
56     ASSERT_EQ(ret, 0);
57 
58     generatorAlgoName = generator->getAlgoName(generator);
59     ASSERT_NE(generatorAlgoName, nullptr);
60     ASSERT_EQ(strcmp(generatorAlgoName, inputAlgoName), 0);
61 
62     HcfObjDestroy(key);
63     HcfObjDestroy(generator);
64 }
65 
66 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest002, TestSize.Level0)
67 {
68     HcfSymKeyGenerator *generator = nullptr;
69     const char *generatorAlgoName = nullptr;
70     const char *inputAlgoName = "AES128";
71 
72     int ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
73     ASSERT_EQ(ret, 0);
74 
75     generatorAlgoName = generator->getAlgoName(nullptr);
76     ASSERT_EQ(generatorAlgoName, nullptr);
77 
78     HcfObjDestroy(generator);
79 }
80 
81 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest003, TestSize.Level0)
82 {
83     HcfSymKeyGenerator *generator = nullptr;
84     HcfSymKey *key = nullptr;
85     const char *generatorAlgoName = nullptr;
86     const char *inputAlgoName = "AES128";
87 
88     int ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
89     ASSERT_EQ(ret, 0);
90 
91     ret = generator->generateSymKey(generator, &key);
92     ASSERT_EQ(ret, 0);
93 
94     generatorAlgoName = generator->getAlgoName(reinterpret_cast<HcfSymKeyGenerator *>(key));
95     ASSERT_EQ(generatorAlgoName, nullptr);
96 
97     HcfObjDestroy(key);
98     HcfObjDestroy(generator);
99 }
100 
101 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest004, TestSize.Level0)
102 {
103     HcfSymKey *key = nullptr;
104     const char *inputAlgoName = "AES128";
105     const char *keyAlgoName = nullptr;
106 
107     int ret = GenerateSymKey(inputAlgoName, &key);
108     ASSERT_EQ(ret, 0);
109 
110     keyAlgoName = key->key.getAlgorithm(&(key->key));
111     ASSERT_NE(keyAlgoName, nullptr);
112     ASSERT_EQ(strcmp(keyAlgoName, inputAlgoName), 0);
113 
114     HcfObjDestroy(key);
115 }
116 
117 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest005, TestSize.Level0)
118 {
119     HcfSymKey *key = nullptr;
120     const char *inputAlgoName = "AES128";
121     const char *keyAlgoName = nullptr;
122 
123     int ret = GenerateSymKey(inputAlgoName, &key);
124     ASSERT_EQ(ret, 0);
125 
126     keyAlgoName = key->key.getAlgorithm(nullptr);
127     ASSERT_EQ(keyAlgoName, nullptr);
128 
129     HcfObjDestroy(key);
130 }
131 
132 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest006, TestSize.Level0)
133 {
134     HcfSymKeyGenerator *generator = nullptr;
135     HcfSymKey *key = nullptr;
136     const char *inputAlgoName = "AES128";
137     const char *keyAlgoName = nullptr;
138 
139     int ret = HcfSymKeyGeneratorCreate(inputAlgoName, &generator);
140     ASSERT_EQ(ret, 0);
141 
142     ret = generator->generateSymKey(generator, &key);
143     ASSERT_EQ(ret, 0);
144 
145     keyAlgoName = key->key.getAlgorithm(reinterpret_cast<HcfKey *>(generator));
146     ASSERT_EQ(keyAlgoName, nullptr);
147 
148     HcfObjDestroy(key);
149     HcfObjDestroy(generator);
150 }
151 
152 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest007, TestSize.Level0)
153 {
154     HcfSymKey *key = nullptr;
155     const char *keyFormat = "PKCS#8";
156     const char *retFormat = nullptr;
157 
158     int ret = GenerateSymKey("AES128", &key);
159     ASSERT_EQ(ret, 0);
160 
161     retFormat = key->key.getFormat(&(key->key));
162     ASSERT_NE(retFormat, nullptr);
163     ASSERT_EQ(strcmp(retFormat, keyFormat), 0);
164 
165     HcfObjDestroy(key);
166 }
167 
168 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest008, TestSize.Level0)
169 {
170     HcfSymKey *key = nullptr;
171     const char *retFormat = nullptr;
172 
173     int ret = GenerateSymKey("AES128", &key);
174     ASSERT_EQ(ret, 0);
175 
176     retFormat = key->key.getFormat(nullptr);
177     ASSERT_EQ(retFormat, nullptr);
178 
179     HcfObjDestroy(key);
180 }
181 
182 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest009, TestSize.Level0)
183 {
184     HcfSymKeyGenerator *generator = nullptr;
185     HcfSymKey *key = nullptr;
186     const char *retFormat = nullptr;
187 
188     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
189     ASSERT_EQ(ret, 0);
190 
191     ret = generator->generateSymKey(generator, &key);
192     ASSERT_EQ(ret, 0);
193 
194     retFormat = key->key.getFormat(reinterpret_cast<HcfKey *>(generator));
195     ASSERT_EQ(retFormat, nullptr);
196 
197     HcfObjDestroy(key);
198     HcfObjDestroy(generator);
199 }
200 
201 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest010, TestSize.Level0)
202 {
203     HcfSymKeyGenerator *generator = nullptr;
204     HcfSymKey *key = nullptr;
205     HcfBlob encodedBlob = { 0 };
206     uint8_t keyMaterial[] = {
207         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
208         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
209     };
210     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
211 
212     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
213     ASSERT_EQ(ret, 0);
214 
215     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
216     ASSERT_EQ(ret, 0);
217 
218     ret = key->key.getEncoded(&(key->key), &encodedBlob);
219     ASSERT_EQ(ret, 0);
220 
221     ASSERT_EQ(encodedBlob.len, keyTmpBlob.len);
222     ASSERT_EQ(memcmp(encodedBlob.data, keyTmpBlob.data, keyTmpBlob.len), 0);
223 
224     HcfObjDestroy(key);
225     HcfObjDestroy(generator);
226     if (encodedBlob.data != nullptr) {
227         HcfFree(encodedBlob.data);
228         encodedBlob.data = nullptr;
229     }
230 }
231 
232 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest011, TestSize.Level0)
233 {
234     HcfSymKeyGenerator *generator = nullptr;
235     HcfSymKey *key = nullptr;
236     HcfBlob encodedBlob = { 0 };
237     uint8_t keyMaterial[] = {
238         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
239         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
240     };
241     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
242 
243     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
244     ASSERT_EQ(ret, 0);
245 
246     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
247     ASSERT_EQ(ret, 0);
248 
249     ret = key->key.getEncoded(nullptr, &encodedBlob);
250     ASSERT_NE(ret, 0);
251 
252     HcfObjDestroy(key);
253     HcfObjDestroy(generator);
254     if (encodedBlob.data != nullptr) {
255         HcfFree(encodedBlob.data);
256         encodedBlob.data = nullptr;
257     }
258 }
259 
260 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest012, TestSize.Level0)
261 {
262     HcfSymKeyGenerator *generator = nullptr;
263     HcfSymKey *key = nullptr;
264     HcfBlob encodedBlob = { 0 };
265     uint8_t keyMaterial[] = {
266         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
267         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
268     };
269     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
270 
271     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
272     ASSERT_EQ(ret, 0);
273 
274     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
275     ASSERT_EQ(ret, 0);
276 
277     ret = key->key.getEncoded(reinterpret_cast<HcfKey *>(generator), &encodedBlob);
278     ASSERT_NE(ret, 0);
279 
280     HcfObjDestroy(key);
281     HcfObjDestroy(generator);
282     if (encodedBlob.data != nullptr) {
283         HcfFree(encodedBlob.data);
284         encodedBlob.data = nullptr;
285     }
286 }
287 
288 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest013, TestSize.Level0)
289 {
290     HcfSymKeyGenerator *generator = nullptr;
291     HcfSymKey *key = nullptr;
292     HcfBlob encodedBlob = { 0 };
293     uint8_t keyMaterial[] = {
294         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
295         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
296     };
297     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
298     SymKeyImpl *impl = nullptr;
299     size_t tmpLen = 0;
300 
301     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
302     ASSERT_EQ(ret, 0);
303 
304     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
305     ASSERT_EQ(ret, 0);
306 
307     impl = reinterpret_cast<SymKeyImpl *>(key);
308     tmpLen = impl->keyMaterial.len;
309     impl->keyMaterial.len = 0;
310 
311     // key getEncoded
312     ret = key->key.getEncoded(&(key->key), &encodedBlob);
313     impl->keyMaterial.len = tmpLen;
314     ASSERT_NE(ret, 0);
315 
316     HcfObjDestroy(key);
317     HcfObjDestroy(generator);
318     if (encodedBlob.data != nullptr) {
319         HcfFree(encodedBlob.data);
320         encodedBlob.data = nullptr;
321     }
322 }
323 
324 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest014, TestSize.Level0)
325 {
326     HcfSymKeyGenerator *generator = nullptr;
327     HcfSymKey *key = nullptr;
328     HcfBlob encodedBlob = { 0 };
329     uint8_t keyMaterial[] = {
330         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
331         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
332     };
333     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
334 
335     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
336     ASSERT_EQ(ret, 0);
337 
338     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
339     ASSERT_EQ(ret, 0);
340 
341     key->clearMem(nullptr);
342 
343     ret = key->key.getEncoded(&(key->key), &encodedBlob);
344     ASSERT_EQ(ret, 0);
345     ASSERT_FALSE((encodedBlob.data == nullptr) || (encodedBlob.data[0] == '\0'));
346 
347     HcfObjDestroy(key);
348     HcfObjDestroy(generator);
349     if (encodedBlob.data != nullptr) {
350         HcfFree(encodedBlob.data);
351         encodedBlob.data = nullptr;
352     }
353 }
354 
355 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest015, TestSize.Level0)
356 {
357     HcfSymKeyGenerator *generator = nullptr;
358 
359     int ret = HcfSymKeyGeneratorCreate("RSA128", &generator);
360     ASSERT_NE(ret, 0);
361 
362     HcfObjDestroy(generator);
363 }
364 
365 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest016, TestSize.Level0)
366 {
367     HcfSymKeyGenerator *generator = nullptr;
368 
369     int ret = HcfSymKeyGeneratorCreate("RSA512", &generator);
370     ASSERT_NE(ret, 0);
371 
372     HcfObjDestroy(generator);
373 }
374 
375 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest017, TestSize.Level0)
376 {
377     HcfSymKeyGenerator *generator = nullptr;
378 
379     int ret = HcfSymKeyGeneratorCreate("", &generator);
380     ASSERT_NE(ret, 0);
381 
382     HcfObjDestroy(generator);
383 }
384 
385 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest018, TestSize.Level0)
386 {
387     HcfSymKeyGenerator *generator = nullptr;
388 
389     int ret = HcfSymKeyGeneratorCreate(nullptr, &generator);
390     ASSERT_NE(ret, 0);
391 
392     HcfObjDestroy(generator);
393 }
394 
395 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest019, TestSize.Level0)
396 {
397     HcfSymKeyGenerator *generator = nullptr;
398 
399     int ret = HcfSymKeyGeneratorSpiCreate(nullptr, nullptr);
400     ASSERT_NE(ret, 0);
401 
402     HcfObjDestroy(generator);
403 }
404 
405 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest020, TestSize.Level0)
406 {
407     HcfSymKeyGenerator *generator = nullptr;
408     HcfSymKey *key = nullptr;
409 
410     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
411     ASSERT_EQ(ret, 0);
412 
413     ret = generator->generateSymKey(nullptr, &key);
414     ASSERT_NE(ret, 0);
415 
416     HcfObjDestroy(key);
417     HcfObjDestroy(generator);
418 }
419 
420 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest021, TestSize.Level0)
421 {
422     HcfSymKeyGenerator *generator = nullptr;
423     HcfSymKey *key = nullptr;
424     uint8_t keyMaterial[] = {
425         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
426         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
427     };
428     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
429 
430     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
431     ASSERT_EQ(ret, 0);
432 
433     ret = generator->convertSymKey(nullptr, &keyTmpBlob, &key);
434     ASSERT_NE(ret, 0);
435 
436     HcfObjDestroy(key);
437     HcfObjDestroy(generator);
438 }
439 
440 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest022, TestSize.Level0)
441 {
442     HcfSymKeyGenerator *generator = nullptr;
443     HcfSymKey *key = nullptr;
444     uint8_t keyMaterial[] = {
445         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
446         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
447     };
448     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = 0 };
449 
450     int ret = HcfSymKeyGeneratorCreate("AES128", &generator);
451     ASSERT_EQ(ret, 0);
452 
453     ret = generator->convertSymKey(generator, &keyTmpBlob, &key);
454     ASSERT_NE(ret, 0);
455 
456     HcfObjDestroy(key);
457     HcfObjDestroy(generator);
458 }
459 
460 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest023, TestSize.Level0)
461 {
462     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
463     int cipherTextLen = CIPHER_TEXT_LEN;
464     HcfCipher *cipher = nullptr;
465     HcfSymKey *key = nullptr;
466 
467     int ret = GenerateSymKey("AES128", &key);
468     ASSERT_EQ(ret, 0);
469 
470     ret = HcfCipherCreate("AES128|NoPadding|PKCS5", &cipher);
471     ASSERT_EQ(ret, 0);
472 
473     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
474     ASSERT_EQ(ret, 0);
475 
476     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
477     ASSERT_EQ(ret, 0);
478 
479     HcfObjDestroy(key);
480     HcfObjDestroy(cipher);
481 }
482 
483 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest024, TestSize.Level0)
484 {
485     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
486     int cipherTextLen = CIPHER_TEXT_LEN;
487     HcfCipher *cipher = nullptr;
488     HcfSymKey *key = nullptr;
489 
490     int ret = GenerateSymKey("AES128", &key);
491     ASSERT_EQ(ret, 0);
492 
493     ret = HcfCipherCreate("AES128|PKCS5", &cipher);
494     ASSERT_EQ(ret, 0);
495 
496     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
497     ASSERT_EQ(ret, 0);
498 
499     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
500     ASSERT_EQ(ret, 0);
501 
502     HcfObjDestroy(key);
503     HcfObjDestroy(cipher);
504 }
505 
506 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest025, TestSize.Level0)
507 {
508     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
509     int cipherTextLen = CIPHER_TEXT_LEN;
510     HcfCipher *cipher = nullptr;
511     HcfSymKey *key = nullptr;
512 
513     int ret = GenerateSymKey("AES128", &key);
514     ASSERT_EQ(ret, 0);
515 
516     ret = HcfCipherCreate("AES128", &cipher);
517     ASSERT_EQ(ret, 0);
518 
519     ret = AesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
520     ASSERT_EQ(ret, 0);
521 
522     ret = AesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
523     ASSERT_EQ(ret, 0);
524 
525     HcfObjDestroy(key);
526     HcfObjDestroy(cipher);
527 }
528 
529 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest026, TestSize.Level0)
530 {
531     int ret = 0;
532     HcfCipher *cipher = nullptr;
533 
534     ret = HcfCipherCreate("", &cipher);
535     if (ret != 0) {
536         LOGE("HcfCipherCreate failed!");
537     }
538 
539     HcfObjDestroy(cipher);
540     EXPECT_NE(ret, 0);
541 }
542 
543 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest027, TestSize.Level0)
544 {
545     int ret = 0;
546     HcfCipher *cipher = nullptr;
547 
548     ret = HcfCipherCreate(nullptr, &cipher);
549     if (ret != 0) {
550         LOGE("HcfCipherCreate failed!");
551     }
552 
553     HcfObjDestroy(cipher);
554     EXPECT_NE(ret, 0);
555 }
556 
557 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest028, TestSize.Level0)
558 {
559     int ret = HcfCipherAesGeneratorSpiCreate(nullptr, nullptr);
560     if (ret != 0) {
561         LOGE("HcfCipherAesGeneratorSpiCreate failed!");
562     }
563     EXPECT_NE(ret, 0);
564 
565     HcfCipherGeneratorSpi *cipher = nullptr;
566     CipherAttr params = {
567         .algo = HCF_ALG_AES,
568         .mode = HCF_ALG_MODE_ECB,
569         .paddingMode = HCF_ALG_PADDING_PKCS5,
570     };
571     ret = HcfCipherAesGeneratorSpiCreate(&params, &cipher);
572     EXPECT_EQ(ret, HCF_SUCCESS);
573 
574     ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
575     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
576 
577     ret = cipher->update(nullptr, nullptr, nullptr);
578     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
579 
580     ret = cipher->doFinal(nullptr, nullptr, nullptr);
581     EXPECT_EQ(ret, HCF_INVALID_PARAMS);
582 
583     HcfBlob dataArray = { .data = nullptr, .len = 0 };
584     ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr);
585     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
586 
587     ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray);
588     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
589 
590     HcfBlob dataUint8 = { .data = nullptr, .len = 0 };
591     ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8);
592     EXPECT_EQ(ret, HCF_NOT_SUPPORT);
593 
594     (void)cipher->base.destroy(nullptr);
595 
596     HcfObjDestroy(cipher);
597     HcfBlobDataFree(&dataArray);
598 }
599 
600 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest029, TestSize.Level0)
601 {
602     HcfSymKeyGeneratorSpi *generator = nullptr;
603     HcfSymKey *key = nullptr;
604     SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE };
605 
606     int ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator);
607     ASSERT_EQ(ret, 0);
608 
609     ret = generator->engineGenerateSymmKey(nullptr, &key);
610     ASSERT_NE(ret, 0);
611 
612     HcfObjDestroy(key);
613     HcfObjDestroy(generator);
614 }
615 
616 HWTEST_F(CryptoAesCipherTest, CryptoAesCipherTest030, TestSize.Level0)
617 {
618     HcfSymKeyGeneratorSpi *generator = nullptr;
619     HcfSymKey *key = nullptr;
620     uint8_t keyMaterial[] = {
621         0xba, 0x3b, 0xc2, 0x71, 0x21, 0x1e, 0x30, 0x56,
622         0xad, 0x47, 0xfc, 0x5a, 0x46, 0x39, 0xee, 0x7c
623     };
624     HcfBlob keyTmpBlob = { .data = keyMaterial, .len = KEY_MATERIAL_LEN };
625     SymKeyAttr attr = { .algo = HCF_ALG_AES, .keySize = AES_KEY_SIZE };
626 
627     int ret = HcfSymKeyGeneratorSpiCreate(&attr, &generator);
628     ASSERT_EQ(ret, 0);
629 
630     ret = generator->engineConvertSymmKey(nullptr, &keyTmpBlob, &key);
631     ASSERT_NE(ret, 0);
632 
633     HcfObjDestroy(key);
634     HcfObjDestroy(generator);
635 }
636 }