1 /*
2 * Copyright (C) 2022 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 "securec.h"
18
19 #include "sym_key_generator.h"
20 #include "cipher.h"
21 #include "log.h"
22 #include "memory.h"
23 #include "detailed_iv_params.h"
24 #include "detailed_gcm_params.h"
25 #include "detailed_ccm_params.h"
26 #include "des_openssl.h"
27
28 using namespace std;
29 using namespace testing::ext;
30
31 namespace {
32 constexpr int32_t CIPHER_TEXT_LEN = 128;
33 constexpr int32_t DES_IV_LEN = 8;
34 constexpr int32_t PLAINTEXT_LEN = 13;
35
36 class Crypto3DesCipherTest : public testing::Test {
37 public:
38 static void SetUpTestCase();
39 static void TearDownTestCase();
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase()44 void Crypto3DesCipherTest::SetUpTestCase() {}
TearDownTestCase()45 void Crypto3DesCipherTest::TearDownTestCase() {}
46
SetUp()47 void Crypto3DesCipherTest::SetUp() // add init here, this will be called before test.
48 {
49 }
50
TearDown()51 void Crypto3DesCipherTest::TearDown() // add destroy here, this will be called when test case done.
52 {
53 }
54
Generate3DesSymKey(HcfSymKey ** key)55 static HcfResult Generate3DesSymKey(HcfSymKey **key)
56 {
57 HcfSymKeyGenerator *generator = nullptr;
58
59 HcfResult ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
60 if (ret != HCF_SUCCESS) {
61 LOGE("HcfSymKeyGeneratorCreate failed!");
62 return ret;
63 }
64
65 ret = generator->generateSymKey(generator, key);
66 if (ret != HCF_SUCCESS) {
67 LOGE("generateSymKey failed!");
68 }
69 HcfObjDestroy(generator);
70 return ret;
71 }
72
GenerateDesSymKey(HcfSymKey ** key)73 static HcfResult GenerateDesSymKey(HcfSymKey **key)
74 {
75 HcfSymKeyGenerator *generator = nullptr;
76
77 HcfResult ret = HcfSymKeyGeneratorCreate("DES64", &generator);
78 if (ret != HCF_SUCCESS) {
79 LOGE("HcfSymKeyGeneratorCreate failed!");
80 return ret;
81 }
82
83 ret = generator->generateSymKey(generator, key);
84 if (ret != HCF_SUCCESS) {
85 LOGE("generateSymKey failed!");
86 }
87 HcfObjDestroy(generator);
88 return ret;
89 }
90
DesEncrypt(HcfCipher * cipher,HcfSymKey * key,HcfParamsSpec * params,uint8_t * cipherText,int * cipherTextLen)91 static int32_t DesEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params,
92 uint8_t *cipherText, int *cipherTextLen)
93 {
94 uint8_t plainText[] = "this is test!";
95 HcfBlob input = {.data = (uint8_t *)plainText, .len = 13};
96 HcfBlob output = {};
97 int32_t maxLen = *cipherTextLen;
98 int32_t ret = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)key, params);
99 if (ret != 0) {
100 LOGE("init failed! %{public}d", ret);
101 return ret;
102 }
103
104 ret = cipher->update(cipher, &input, &output);
105 if (ret != 0) {
106 LOGE("update failed!");
107 return ret;
108 }
109 *cipherTextLen = output.len;
110 if (output.data != nullptr) {
111 if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) {
112 HcfBlobDataFree(&output);
113 return -1;
114 }
115 HcfBlobDataFree(&output);
116 }
117
118 ret = cipher->doFinal(cipher, nullptr, &output);
119 if (ret != 0) {
120 LOGE("doFinal failed!");
121 return ret;
122 }
123 if (output.data != nullptr) {
124 if (memcpy_s(cipherText + *cipherTextLen, maxLen - *cipherTextLen, output.data, output.len) != EOK) {
125 HcfBlobDataFree(&output);
126 return -1;
127 }
128 *cipherTextLen += output.len;
129 HcfBlobDataFree(&output);
130 }
131 return 0;
132 }
133
DesDecrypt(HcfCipher * cipher,HcfSymKey * key,HcfParamsSpec * params,uint8_t * cipherText,int cipherTextLen)134 static int32_t DesDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params,
135 uint8_t *cipherText, int cipherTextLen)
136 {
137 uint8_t plainText[] = "this is test!";
138 HcfBlob input = {.data = (uint8_t *)cipherText, .len = cipherTextLen};
139 HcfBlob output = {};
140 int32_t maxLen = cipherTextLen;
141 int32_t ret = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)key, params);
142 if (ret != 0) {
143 LOGE("init failed! %{public}d", ret);
144 return ret;
145 }
146
147 ret = cipher->update(cipher, &input, &output);
148 if (ret != 0) {
149 LOGE("update failed!");
150 return ret;
151 }
152 cipherTextLen = output.len;
153 if (output.data != nullptr) {
154 if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) {
155 HcfBlobDataFree(&output);
156 return -1;
157 }
158 HcfBlobDataFree(&output);
159 }
160
161 ret = cipher->doFinal(cipher, nullptr, &output);
162 if (ret != 0) {
163 LOGE("doFinal failed!");
164 return ret;
165 }
166 if (output.data != nullptr) {
167 if (memcpy_s(cipherText + cipherTextLen, maxLen - cipherTextLen, output.data, output.len) != EOK) {
168 HcfBlobDataFree(&output);
169 return -1;
170 }
171 cipherTextLen += output.len;
172 HcfBlobDataFree(&output);
173 }
174
175 if (cipherTextLen != sizeof(plainText) - 1) {
176 return -1;
177 }
178 return memcmp(cipherText, plainText, cipherTextLen);
179 }
180
DesNoUpdateEncrypt(HcfCipher * cipher,HcfSymKey * key,HcfParamsSpec * params,uint8_t * cipherText,int * cipherTextLen)181 static int32_t DesNoUpdateEncrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params,
182 uint8_t *cipherText, int *cipherTextLen)
183 {
184 uint8_t plainText[] = "this is test!";
185 HcfBlob input = {.data = (uint8_t *)plainText, .len = 13};
186 HcfBlob output = {};
187 int32_t maxLen = *cipherTextLen;
188 int32_t ret = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)key, params);
189 if (ret != 0) {
190 LOGE("init failed! %{public}d", ret);
191 return ret;
192 }
193
194 *cipherTextLen = 0;
195 ret = cipher->doFinal(cipher, &input, &output);
196 if (ret != 0) {
197 LOGE("doFinal failed!");
198 return ret;
199 }
200 if (output.data != nullptr) {
201 if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) {
202 HcfBlobDataFree(&output);
203 return -1;
204 }
205 *cipherTextLen += output.len;
206 HcfBlobDataFree(&output);
207 }
208 return 0;
209 }
210
DesNoUpdateDecrypt(HcfCipher * cipher,HcfSymKey * key,HcfParamsSpec * params,uint8_t * cipherText,int cipherTextLen)211 static int32_t DesNoUpdateDecrypt(HcfCipher *cipher, HcfSymKey *key, HcfParamsSpec *params,
212 uint8_t *cipherText, int cipherTextLen)
213 {
214 uint8_t plainText[] = "this is test!";
215 HcfBlob input = {.data = (uint8_t *)cipherText, .len = cipherTextLen};
216 HcfBlob output = {};
217 int32_t maxLen = cipherTextLen;
218 int32_t ret = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)key, params);
219 if (ret != 0) {
220 LOGE("init failed! %{public}d", ret);
221 return ret;
222 }
223
224 cipherTextLen = 0;
225 ret = cipher->doFinal(cipher, &input, &output);
226 if (ret != 0) {
227 LOGE("doFinal failed!");
228 return ret;
229 }
230 if (output.data != nullptr) {
231 if (memcpy_s(cipherText, maxLen, output.data, output.len) != EOK) {
232 HcfBlobDataFree(&output);
233 return -1;
234 }
235 cipherTextLen += output.len;
236 HcfBlobDataFree(&output);
237 }
238
239 if (cipherTextLen != sizeof(plainText) - 1) {
240 return -1;
241 }
242 return memcmp(cipherText, plainText, cipherTextLen);
243 }
244
245 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest001, TestSize.Level0)
246 {
247 uint8_t cipherText[128] = {0};
248 int cipherTextLen = 128;
249
250 HcfSymKeyGenerator *generator = nullptr;
251 HcfCipher *cipher = nullptr;
252 HcfSymKey *key = nullptr;
253
254 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
255 ASSERT_EQ(ret, 0);
256
257 ret = generator->generateSymKey(generator, &key);
258 ASSERT_EQ(ret, 0);
259
260 ret = HcfCipherCreate("3DES192|ECB|NoPadding", &cipher);
261 ASSERT_EQ(ret, 0);
262
263 ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
264 ASSERT_NE(ret, 0);
265
266 HcfObjDestroy((HcfObjectBase *)key);
267 HcfObjDestroy((HcfObjectBase *)cipher);
268 HcfObjDestroy((HcfObjectBase *)generator);
269 }
270
271 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest002, TestSize.Level0)
272 {
273 uint8_t cipherText[128] = {0};
274 int cipherTextLen = 128;
275
276 HcfSymKeyGenerator *generator = nullptr;
277 HcfCipher *cipher = nullptr;
278 HcfSymKey *key = nullptr;
279
280 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
281 ASSERT_EQ(ret, 0);
282
283 ret = generator->generateSymKey(generator, &key);
284 ASSERT_EQ(ret, 0);
285
286 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
287 ASSERT_EQ(ret, 0);
288
289 ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
290 ASSERT_EQ(ret, 0);
291
292 ret = DesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
293 ASSERT_EQ(ret, 0);
294
295 HcfObjDestroy((HcfObjectBase *)key);
296 HcfObjDestroy((HcfObjectBase *)cipher);
297 HcfObjDestroy((HcfObjectBase *)generator);
298 }
299
300 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest003, TestSize.Level0)
301 {
302 uint8_t cipherText[128] = {0};
303 int cipherTextLen = 128;
304
305 HcfSymKeyGenerator *generator = nullptr;
306 HcfCipher *cipher = nullptr;
307 HcfSymKey *key = nullptr;
308
309 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
310 ASSERT_EQ(ret, 0);
311
312 ret = generator->generateSymKey(generator, &key);
313 ASSERT_EQ(ret, 0);
314
315 ret = HcfCipherCreate("3DES192|ECB|PKCS7", &cipher);
316 ASSERT_EQ(ret, 0);
317
318 ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
319 ASSERT_EQ(ret, 0);
320
321 ret = DesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
322 ASSERT_EQ(ret, 0);
323
324 HcfObjDestroy((HcfObjectBase *)key);
325 HcfObjDestroy((HcfObjectBase *)cipher);
326 HcfObjDestroy((HcfObjectBase *)generator);
327 }
328
329 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest004, TestSize.Level0)
330 {
331 uint8_t cipherText[128] = {0};
332 int cipherTextLen = 128;
333
334 HcfSymKeyGenerator *generator = nullptr;
335 HcfCipher *cipher = nullptr;
336 HcfSymKey *key = nullptr;
337 uint8_t iv[8] = {0};
338 HcfIvParamsSpec ivSpec = {};
339 ivSpec.iv.data = iv;
340 ivSpec.iv.len = 8;
341
342 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
343 ASSERT_EQ(ret, 0);
344
345 ret = generator->generateSymKey(generator, &key);
346 ASSERT_EQ(ret, 0);
347
348 ret = HcfCipherCreate("3DES192|CBC|NoPadding", &cipher);
349 ASSERT_EQ(ret, 0);
350
351 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
352 ASSERT_NE(ret, 0);
353
354 HcfObjDestroy((HcfObjectBase *)key);
355 HcfObjDestroy((HcfObjectBase *)cipher);
356 HcfObjDestroy((HcfObjectBase *)generator);
357 }
358
359 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest005, TestSize.Level0)
360 {
361 uint8_t cipherText[128] = {0};
362 int cipherTextLen = 128;
363
364 HcfSymKeyGenerator *generator = nullptr;
365 HcfCipher *cipher = nullptr;
366 HcfSymKey *key = nullptr;
367 uint8_t iv[8] = {0};
368 HcfIvParamsSpec ivSpec = {};
369 ivSpec.iv.data = iv;
370 ivSpec.iv.len = 8;
371
372 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
373 ASSERT_EQ(ret, 0);
374
375 ret = generator->generateSymKey(generator, &key);
376 ASSERT_EQ(ret, 0);
377
378 ret = HcfCipherCreate("3DES192|CBC|PKCS5", &cipher);
379 ASSERT_EQ(ret, 0);
380
381 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
382 ASSERT_EQ(ret, 0);
383
384 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
385 ASSERT_EQ(ret, 0);
386
387 HcfObjDestroy((HcfObjectBase *)key);
388 HcfObjDestroy((HcfObjectBase *)cipher);
389 HcfObjDestroy((HcfObjectBase *)generator);
390 }
391
392 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest006, TestSize.Level0)
393 {
394 uint8_t cipherText[128] = {0};
395 int cipherTextLen = 128;
396
397 HcfSymKeyGenerator *generator = nullptr;
398 HcfCipher *cipher = nullptr;
399 HcfSymKey *key = nullptr;
400 uint8_t iv[8] = {0};
401 HcfIvParamsSpec ivSpec = {};
402 ivSpec.iv.data = iv;
403 ivSpec.iv.len = 8;
404
405 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
406 ASSERT_EQ(ret, 0);
407
408 ret = generator->generateSymKey(generator, &key);
409 ASSERT_EQ(ret, 0);
410
411 ret = HcfCipherCreate("3DES192|CBC|PKCS7", &cipher);
412 ASSERT_EQ(ret, 0);
413
414 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
415 ASSERT_EQ(ret, 0);
416
417 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
418 ASSERT_EQ(ret, 0);
419
420 HcfObjDestroy((HcfObjectBase *)key);
421 HcfObjDestroy((HcfObjectBase *)cipher);
422 HcfObjDestroy((HcfObjectBase *)generator);
423 }
424
425 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest007, TestSize.Level0)
426 {
427 uint8_t cipherText[128] = {0};
428 int cipherTextLen = 128;
429
430 HcfSymKeyGenerator *generator = nullptr;
431 HcfCipher *cipher = nullptr;
432 HcfSymKey *key = nullptr;
433 uint8_t iv[8] = {0};
434 HcfIvParamsSpec ivSpec = {};
435 ivSpec.iv.data = iv;
436 ivSpec.iv.len = 8;
437
438 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
439 ASSERT_EQ(ret, 0);
440
441 ret = generator->generateSymKey(generator, &key);
442 ASSERT_EQ(ret, 0);
443
444 ret = HcfCipherCreate("3DES192|OFB|NoPadding", &cipher);
445 ASSERT_EQ(ret, 0);
446
447 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
448 ASSERT_EQ(ret, 0);
449
450 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
451 ASSERT_EQ(ret, 0);
452
453 HcfObjDestroy((HcfObjectBase *)key);
454 HcfObjDestroy((HcfObjectBase *)cipher);
455 HcfObjDestroy((HcfObjectBase *)generator);
456 }
457
458 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest008, TestSize.Level0)
459 {
460 uint8_t cipherText[128] = {0};
461 int cipherTextLen = 128;
462
463 HcfSymKeyGenerator *generator = nullptr;
464 HcfCipher *cipher = nullptr;
465 HcfSymKey *key = nullptr;
466 uint8_t iv[8] = {0};
467 HcfIvParamsSpec ivSpec = {};
468 ivSpec.iv.data = iv;
469 ivSpec.iv.len = 8;
470
471 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
472 ASSERT_EQ(ret, 0);
473
474 ret = generator->generateSymKey(generator, &key);
475 ASSERT_EQ(ret, 0);
476
477 ret = HcfCipherCreate("3DES192|OFB|PKCS5", &cipher);
478 ASSERT_EQ(ret, 0);
479
480 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
481 ASSERT_EQ(ret, 0);
482
483 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
484 ASSERT_EQ(ret, 0);
485
486 HcfObjDestroy((HcfObjectBase *)key);
487 HcfObjDestroy((HcfObjectBase *)cipher);
488 HcfObjDestroy((HcfObjectBase *)generator);
489 }
490
491 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest009, TestSize.Level0)
492 {
493 uint8_t cipherText[128] = {0};
494 int cipherTextLen = 128;
495
496 HcfSymKeyGenerator *generator = nullptr;
497 HcfCipher *cipher = nullptr;
498 HcfSymKey *key = nullptr;
499 uint8_t iv[8] = {0};
500 HcfIvParamsSpec ivSpec = {};
501 ivSpec.iv.data = iv;
502 ivSpec.iv.len = 8;
503
504 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
505 ASSERT_EQ(ret, 0);
506
507 ret = generator->generateSymKey(generator, &key);
508 ASSERT_EQ(ret, 0);
509
510 ret = HcfCipherCreate("3DES192|OFB|PKCS7", &cipher);
511 ASSERT_EQ(ret, 0);
512
513 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
514 ASSERT_EQ(ret, 0);
515
516 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
517 ASSERT_EQ(ret, 0);
518
519 HcfObjDestroy((HcfObjectBase *)key);
520 HcfObjDestroy((HcfObjectBase *)cipher);
521 HcfObjDestroy((HcfObjectBase *)generator);
522 }
523
524 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest010, TestSize.Level0)
525 {
526 uint8_t cipherText[128] = {0};
527 int cipherTextLen = 128;
528
529 HcfSymKeyGenerator *generator = nullptr;
530 HcfCipher *cipher = nullptr;
531 HcfSymKey *key = nullptr;
532 uint8_t iv[8] = {0};
533 HcfIvParamsSpec ivSpec = {};
534 ivSpec.iv.data = iv;
535 ivSpec.iv.len = 8;
536
537 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
538 ASSERT_EQ(ret, 0);
539
540 ret = generator->generateSymKey(generator, &key);
541 ASSERT_EQ(ret, 0);
542
543 ret = HcfCipherCreate("3DES192|CFB|NoPadding", &cipher);
544 ASSERT_EQ(ret, 0);
545
546 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
547 ASSERT_EQ(ret, 0);
548
549 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
550 ASSERT_EQ(ret, 0);
551
552 HcfObjDestroy((HcfObjectBase *)key);
553 HcfObjDestroy((HcfObjectBase *)cipher);
554 HcfObjDestroy((HcfObjectBase *)generator);
555 }
556
557 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest011, TestSize.Level0)
558 {
559 uint8_t cipherText[128] = {0};
560 int cipherTextLen = 128;
561
562 HcfSymKeyGenerator *generator = nullptr;
563 HcfCipher *cipher = nullptr;
564 HcfSymKey *key = nullptr;
565 uint8_t iv[8] = {0};
566 HcfIvParamsSpec ivSpec = {};
567 ivSpec.iv.data = iv;
568 ivSpec.iv.len = 8;
569
570 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
571 ASSERT_EQ(ret, 0);
572
573 ret = generator->generateSymKey(generator, &key);
574 ASSERT_EQ(ret, 0);
575
576 ret = HcfCipherCreate("3DES192|CFB|PKCS5", &cipher);
577 ASSERT_EQ(ret, 0);
578
579 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
580 ASSERT_EQ(ret, 0);
581
582 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
583 ASSERT_EQ(ret, 0);
584
585 HcfObjDestroy((HcfObjectBase *)key);
586 HcfObjDestroy((HcfObjectBase *)cipher);
587 HcfObjDestroy((HcfObjectBase *)generator);
588 }
589
590 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest012, TestSize.Level0)
591 {
592 uint8_t cipherText[128] = {0};
593 int cipherTextLen = 128;
594
595 HcfSymKeyGenerator *generator = nullptr;
596 HcfCipher *cipher = nullptr;
597 HcfSymKey *key = nullptr;
598 uint8_t iv[8] = {0};
599 HcfIvParamsSpec ivSpec = {};
600 ivSpec.iv.data = iv;
601 ivSpec.iv.len = 8;
602
603 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
604 ASSERT_EQ(ret, 0);
605
606 ret = generator->generateSymKey(generator, &key);
607 ASSERT_EQ(ret, 0);
608
609 ret = HcfCipherCreate("3DES192|CFB|PKCS7", &cipher);
610 ASSERT_EQ(ret, 0);
611
612 ret = DesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
613 ASSERT_EQ(ret, 0);
614
615 ret = DesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
616 ASSERT_EQ(ret, 0);
617
618 HcfObjDestroy((HcfObjectBase *)key);
619 HcfObjDestroy((HcfObjectBase *)cipher);
620 HcfObjDestroy((HcfObjectBase *)generator);
621 }
622
623 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest013, TestSize.Level0)
624 {
625 uint8_t cipherText[128] = {0};
626 int cipherTextLen = 128;
627
628 HcfSymKeyGenerator *generator = nullptr;
629 HcfCipher *cipher = nullptr;
630 HcfSymKey *key = nullptr;
631
632 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
633 ASSERT_EQ(ret, 0);
634
635 ret = generator->generateSymKey(generator, &key);
636 ASSERT_EQ(ret, 0);
637
638 ret = HcfCipherCreate("3DES192|ECB|NoPadding", &cipher);
639 ASSERT_EQ(ret, 0);
640
641 ret = DesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
642 ASSERT_NE(ret, 0);
643
644 HcfObjDestroy((HcfObjectBase *)key);
645 HcfObjDestroy((HcfObjectBase *)cipher);
646 HcfObjDestroy((HcfObjectBase *)generator);
647 }
648
649 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest014, TestSize.Level0)
650 {
651 uint8_t cipherText[128] = {0};
652 int cipherTextLen = 128;
653
654 HcfSymKeyGenerator *generator = nullptr;
655 HcfCipher *cipher = nullptr;
656 HcfSymKey *key = nullptr;
657
658 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
659 ASSERT_EQ(ret, 0);
660
661 ret = generator->generateSymKey(generator, &key);
662 ASSERT_EQ(ret, 0);
663
664 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
665 ASSERT_EQ(ret, 0);
666
667 ret = DesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
668 ASSERT_EQ(ret, 0);
669
670 ret = DesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
671 ASSERT_EQ(ret, 0);
672
673 HcfObjDestroy((HcfObjectBase *)key);
674 HcfObjDestroy((HcfObjectBase *)cipher);
675 HcfObjDestroy((HcfObjectBase *)generator);
676 }
677
678 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest015, TestSize.Level0)
679 {
680 uint8_t cipherText[128] = {0};
681 int cipherTextLen = 128;
682
683 HcfSymKeyGenerator *generator = nullptr;
684 HcfCipher *cipher = nullptr;
685 HcfSymKey *key = nullptr;
686
687 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
688 ASSERT_EQ(ret, 0);
689
690 ret = generator->generateSymKey(generator, &key);
691 ASSERT_EQ(ret, 0);
692
693 ret = HcfCipherCreate("3DES192|ECB|PKCS7", &cipher);
694 ASSERT_EQ(ret, 0);
695
696 ret = DesNoUpdateEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
697 ASSERT_EQ(ret, 0);
698
699 ret = DesNoUpdateDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
700 ASSERT_EQ(ret, 0);
701
702 HcfObjDestroy((HcfObjectBase *)key);
703 HcfObjDestroy((HcfObjectBase *)cipher);
704 HcfObjDestroy((HcfObjectBase *)generator);
705 }
706
707 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest016, TestSize.Level0)
708 {
709 uint8_t cipherText[128] = {0};
710 int cipherTextLen = 128;
711
712 HcfSymKeyGenerator *generator = nullptr;
713 HcfCipher *cipher = nullptr;
714 HcfSymKey *key = nullptr;
715 uint8_t iv[8] = {0};
716 HcfIvParamsSpec ivSpec = {};
717 ivSpec.iv.data = iv;
718 ivSpec.iv.len = 8;
719
720 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
721 ASSERT_EQ(ret, 0);
722
723 ret = generator->generateSymKey(generator, &key);
724 ASSERT_EQ(ret, 0);
725
726 ret = HcfCipherCreate("3DES192|CBC|NoPadding", &cipher);
727 ASSERT_EQ(ret, 0);
728
729 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
730 ASSERT_NE(ret, 0);
731
732 HcfObjDestroy((HcfObjectBase *)key);
733 HcfObjDestroy((HcfObjectBase *)cipher);
734 HcfObjDestroy((HcfObjectBase *)generator);
735 }
736
737 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest017, TestSize.Level0)
738 {
739 uint8_t cipherText[128] = {0};
740 int cipherTextLen = 128;
741
742 HcfSymKeyGenerator *generator = nullptr;
743 HcfCipher *cipher = nullptr;
744 HcfSymKey *key = nullptr;
745 uint8_t iv[8] = {0};
746 HcfIvParamsSpec ivSpec = {};
747 ivSpec.iv.data = iv;
748 ivSpec.iv.len = 8;
749
750 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
751 ASSERT_EQ(ret, 0);
752
753 ret = generator->generateSymKey(generator, &key);
754 ASSERT_EQ(ret, 0);
755
756 ret = HcfCipherCreate("3DES192|CBC|PKCS5", &cipher);
757 ASSERT_EQ(ret, 0);
758
759 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
760 ASSERT_EQ(ret, 0);
761
762 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
763 ASSERT_EQ(ret, 0);
764
765 HcfObjDestroy((HcfObjectBase *)key);
766 HcfObjDestroy((HcfObjectBase *)cipher);
767 HcfObjDestroy((HcfObjectBase *)generator);
768 }
769
770 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest018, TestSize.Level0)
771 {
772 uint8_t cipherText[128] = {0};
773 int cipherTextLen = 128;
774
775 HcfSymKeyGenerator *generator = nullptr;
776 HcfCipher *cipher = nullptr;
777 HcfSymKey *key = nullptr;
778 uint8_t iv[8] = {0};
779 HcfIvParamsSpec ivSpec = {};
780 ivSpec.iv.data = iv;
781 ivSpec.iv.len = 8;
782
783 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
784 ASSERT_EQ(ret, 0);
785
786 ret = generator->generateSymKey(generator, &key);
787 ASSERT_EQ(ret, 0);
788
789 ret = HcfCipherCreate("3DES192|CBC|PKCS7", &cipher);
790 ASSERT_EQ(ret, 0);
791
792 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
793 ASSERT_EQ(ret, 0);
794
795 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
796 ASSERT_EQ(ret, 0);
797
798 HcfObjDestroy((HcfObjectBase *)key);
799 HcfObjDestroy((HcfObjectBase *)cipher);
800 HcfObjDestroy((HcfObjectBase *)generator);
801 }
802
803 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest019, TestSize.Level0)
804 {
805 uint8_t cipherText[128] = {0};
806 int cipherTextLen = 128;
807
808 HcfSymKeyGenerator *generator = nullptr;
809 HcfCipher *cipher = nullptr;
810 HcfSymKey *key = nullptr;
811 uint8_t iv[8] = {0};
812 HcfIvParamsSpec ivSpec = {};
813 ivSpec.iv.data = iv;
814 ivSpec.iv.len = 8;
815
816 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
817 ASSERT_EQ(ret, 0);
818
819 ret = generator->generateSymKey(generator, &key);
820 ASSERT_EQ(ret, 0);
821
822 ret = HcfCipherCreate("3DES192|OFB|NoPadding", &cipher);
823 ASSERT_EQ(ret, 0);
824
825 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
826 ASSERT_EQ(ret, 0);
827
828 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
829 ASSERT_EQ(ret, 0);
830
831 HcfObjDestroy((HcfObjectBase *)key);
832 HcfObjDestroy((HcfObjectBase *)cipher);
833 HcfObjDestroy((HcfObjectBase *)generator);
834 }
835
836 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest020, TestSize.Level0)
837 {
838 uint8_t cipherText[128] = {0};
839 int cipherTextLen = 128;
840
841 HcfSymKeyGenerator *generator = nullptr;
842 HcfCipher *cipher = nullptr;
843 HcfSymKey *key = nullptr;
844 uint8_t iv[8] = {0};
845 HcfIvParamsSpec ivSpec = {};
846 ivSpec.iv.data = iv;
847 ivSpec.iv.len = 8;
848
849 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
850 ASSERT_EQ(ret, 0);
851
852 ret = generator->generateSymKey(generator, &key);
853 ASSERT_EQ(ret, 0);
854
855 ret = HcfCipherCreate("3DES192|OFB|PKCS5", &cipher);
856 ASSERT_EQ(ret, 0);
857
858 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
859 ASSERT_EQ(ret, 0);
860
861 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
862 ASSERT_EQ(ret, 0);
863
864 HcfObjDestroy((HcfObjectBase *)key);
865 HcfObjDestroy((HcfObjectBase *)cipher);
866 HcfObjDestroy((HcfObjectBase *)generator);
867 }
868
869 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest021, TestSize.Level0)
870 {
871 uint8_t cipherText[128] = {0};
872 int cipherTextLen = 128;
873
874 HcfSymKeyGenerator *generator = nullptr;
875 HcfCipher *cipher = nullptr;
876 HcfSymKey *key = nullptr;
877 uint8_t iv[8] = {0};
878 HcfIvParamsSpec ivSpec = {};
879 ivSpec.iv.data = iv;
880 ivSpec.iv.len = 8;
881
882 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
883 ASSERT_EQ(ret, 0);
884
885 ret = generator->generateSymKey(generator, &key);
886 ASSERT_EQ(ret, 0);
887
888 ret = HcfCipherCreate("3DES192|OFB|PKCS7", &cipher);
889 ASSERT_EQ(ret, 0);
890
891 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
892 ASSERT_EQ(ret, 0);
893
894 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
895 ASSERT_EQ(ret, 0);
896
897 HcfObjDestroy((HcfObjectBase *)key);
898 HcfObjDestroy((HcfObjectBase *)cipher);
899 HcfObjDestroy((HcfObjectBase *)generator);
900 }
901
902 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest022, TestSize.Level0)
903 {
904 uint8_t cipherText[128] = {0};
905 int cipherTextLen = 128;
906
907 HcfSymKeyGenerator *generator = nullptr;
908 HcfCipher *cipher = nullptr;
909 HcfSymKey *key = nullptr;
910 uint8_t iv[8] = {0};
911 HcfIvParamsSpec ivSpec = {};
912 ivSpec.iv.data = iv;
913 ivSpec.iv.len = 8;
914
915 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
916 ASSERT_EQ(ret, 0);
917
918 ret = generator->generateSymKey(generator, &key);
919 ASSERT_EQ(ret, 0);
920
921 ret = HcfCipherCreate("3DES192|CFB|NoPadding", &cipher);
922 ASSERT_EQ(ret, 0);
923
924 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
925 ASSERT_EQ(ret, 0);
926
927 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
928 ASSERT_EQ(ret, 0);
929
930 HcfObjDestroy((HcfObjectBase *)key);
931 HcfObjDestroy((HcfObjectBase *)cipher);
932 HcfObjDestroy((HcfObjectBase *)generator);
933 }
934
935 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest023, TestSize.Level0)
936 {
937 uint8_t cipherText[128] = {0};
938 int cipherTextLen = 128;
939
940 HcfSymKeyGenerator *generator = nullptr;
941 HcfCipher *cipher = nullptr;
942 HcfSymKey *key = nullptr;
943 uint8_t iv[8] = {0};
944 HcfIvParamsSpec ivSpec = {};
945 ivSpec.iv.data = iv;
946 ivSpec.iv.len = 8;
947
948 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
949 ASSERT_EQ(ret, 0);
950
951 ret = generator->generateSymKey(generator, &key);
952 ASSERT_EQ(ret, 0);
953
954 ret = HcfCipherCreate("3DES192|CFB|PKCS5", &cipher);
955 ASSERT_EQ(ret, 0);
956
957 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
958 ASSERT_EQ(ret, 0);
959
960 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
961 ASSERT_EQ(ret, 0);
962
963 HcfObjDestroy((HcfObjectBase *)key);
964 HcfObjDestroy((HcfObjectBase *)cipher);
965 HcfObjDestroy((HcfObjectBase *)generator);
966 }
967
968 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest024, TestSize.Level0)
969 {
970 uint8_t cipherText[128] = {0};
971 int cipherTextLen = 128;
972
973 HcfSymKeyGenerator *generator = nullptr;
974 HcfCipher *cipher = nullptr;
975 HcfSymKey *key = nullptr;
976 uint8_t iv[8] = {0};
977 HcfIvParamsSpec ivSpec = {};
978 ivSpec.iv.data = iv;
979 ivSpec.iv.len = 8;
980
981 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
982 ASSERT_EQ(ret, 0);
983
984 ret = generator->generateSymKey(generator, &key);
985 ASSERT_EQ(ret, 0);
986
987 ret = HcfCipherCreate("3DES192|CFB|PKCS7", &cipher);
988 ASSERT_EQ(ret, 0);
989
990 ret = DesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
991 ASSERT_EQ(ret, 0);
992
993 ret = DesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
994 ASSERT_EQ(ret, 0);
995
996 HcfObjDestroy((HcfObjectBase *)key);
997 HcfObjDestroy((HcfObjectBase *)cipher);
998 HcfObjDestroy((HcfObjectBase *)generator);
999 }
1000
1001 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest025, TestSize.Level0)
1002 {
1003 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1004 int cipherTextLen = CIPHER_TEXT_LEN;
1005 HcfCipher *cipher = nullptr;
1006 HcfSymKey *key = nullptr;
1007 uint8_t iv[DES_IV_LEN] = { 0 };
1008 HcfIvParamsSpec ivSpec = {};
1009 ivSpec.iv.data = iv;
1010 ivSpec.iv.len = DES_IV_LEN;
1011
1012 int ret = Generate3DesSymKey(&key);
1013 ASSERT_EQ(ret, 0);
1014
1015 ret = HcfCipherCreate("3DES192|CFB1|NoPadding", &cipher);
1016 ASSERT_EQ(ret, 0);
1017
1018 ret = DesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1019 ASSERT_EQ(ret, 0);
1020
1021 ret = DesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1022 ASSERT_EQ(ret, 0);
1023
1024 HcfObjDestroy(key);
1025 HcfObjDestroy(cipher);
1026 }
1027
1028 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest026, TestSize.Level0)
1029 {
1030 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1031 int cipherTextLen = CIPHER_TEXT_LEN;
1032 HcfCipher *cipher = nullptr;
1033 HcfSymKey *key = nullptr;
1034 uint8_t iv[DES_IV_LEN] = { 0 };
1035 HcfIvParamsSpec ivSpec = {};
1036 ivSpec.iv.data = iv;
1037 ivSpec.iv.len = DES_IV_LEN;
1038
1039 int ret = Generate3DesSymKey(&key);
1040 ASSERT_EQ(ret, 0);
1041
1042 ret = HcfCipherCreate("3DES192|CFB8|NoPadding", &cipher);
1043 ASSERT_EQ(ret, 0);
1044
1045 ret = DesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1046 ASSERT_EQ(ret, 0);
1047
1048 ret = DesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1049 ASSERT_EQ(ret, 0);
1050
1051 HcfObjDestroy(key);
1052 HcfObjDestroy(cipher);
1053 }
1054
1055 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest027, TestSize.Level0)
1056 {
1057 uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
1058 int cipherTextLen = CIPHER_TEXT_LEN;
1059 HcfCipher *cipher = nullptr;
1060 HcfSymKey *key = nullptr;
1061 uint8_t iv[DES_IV_LEN] = { 0 };
1062 HcfIvParamsSpec ivSpec = {};
1063 ivSpec.iv.data = iv;
1064 ivSpec.iv.len = DES_IV_LEN;
1065
1066 int ret = Generate3DesSymKey(&key);
1067 ASSERT_EQ(ret, 0);
1068
1069 ret = HcfCipherCreate("3DES192|PKCS5", &cipher);
1070 ASSERT_EQ(ret, 0);
1071
1072 ret = DesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
1073 ASSERT_EQ(ret, 0);
1074
1075 ret = DesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
1076 ASSERT_EQ(ret, 0);
1077
1078 HcfObjDestroy(key);
1079 HcfObjDestroy(cipher);
1080 }
1081
1082 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest028, TestSize.Level0)
1083 {
1084 HcfCipher *cipher = nullptr;
1085 HcfSymKey *key = nullptr;
1086
1087 int ret = Generate3DesSymKey(&key);
1088 ASSERT_EQ(ret, 0);
1089
1090 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1091 ASSERT_EQ(ret, 0);
1092
1093 ret = cipher->init(nullptr, ENCRYPT_MODE, &(key->key), nullptr);
1094 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1095
1096 HcfObjDestroy(key);
1097 HcfObjDestroy(cipher);
1098 }
1099
1100 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest029, TestSize.Level0)
1101 {
1102 HcfSymKeyGenerator *generator = nullptr;
1103 HcfCipher *cipher = nullptr;
1104 HcfSymKey *key = nullptr;
1105
1106 int ret = HcfSymKeyGeneratorCreate("3DES192", &generator);
1107 ASSERT_EQ(ret, 0);
1108
1109 ret = generator->generateSymKey(generator, &key);
1110 ASSERT_EQ(ret, 0);
1111
1112 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1113 ASSERT_EQ(ret, 0);
1114
1115 ret = cipher->init(reinterpret_cast<HcfCipher *>(generator), ENCRYPT_MODE, &(key->key), nullptr);
1116 EXPECT_NE(ret, 0);
1117
1118 HcfObjDestroy(key);
1119 HcfObjDestroy(cipher);
1120 HcfObjDestroy(generator);
1121 }
1122
1123 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest030, TestSize.Level0)
1124 {
1125 HcfCipher *cipher = nullptr;
1126 HcfSymKey *key = nullptr;
1127
1128 int ret = Generate3DesSymKey(&key);
1129 ASSERT_EQ(ret, 0);
1130
1131 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1132 ASSERT_EQ(ret, 0);
1133
1134 ret = cipher->init(cipher, ENCRYPT_MODE, reinterpret_cast<HcfKey *>(cipher), nullptr);
1135 EXPECT_NE(ret, 0);
1136
1137 HcfObjDestroy(key);
1138 HcfObjDestroy(cipher);
1139 }
1140
1141 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest031, TestSize.Level0)
1142 {
1143 HcfCipher *cipher = nullptr;
1144 HcfSymKey *key = nullptr;
1145 uint8_t plainText[] = "this is test!";
1146 HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
1147 HcfBlob output = { .data = nullptr, .len = 0 };
1148
1149 int ret = Generate3DesSymKey(&key);
1150 ASSERT_EQ(ret, 0);
1151
1152 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1153 ASSERT_EQ(ret, 0);
1154
1155 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
1156 ASSERT_EQ(ret, 0);
1157
1158 ret = cipher->update(nullptr, &input, &output);
1159 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1160
1161 if (output.data != nullptr) {
1162 HcfFree(output.data);
1163 output.data = nullptr;
1164 }
1165 HcfObjDestroy(key);
1166 HcfObjDestroy(cipher);
1167 }
1168
1169 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest032, TestSize.Level0)
1170 {
1171 HcfCipher *cipher = nullptr;
1172 HcfSymKey *key = nullptr;
1173 uint8_t plainText[] = "this is test!";
1174 HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
1175 HcfBlob output = { .data = nullptr, .len = 0 };
1176
1177 int ret = Generate3DesSymKey(&key);
1178 ASSERT_EQ(ret, 0);
1179
1180 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1181 ASSERT_EQ(ret, 0);
1182
1183 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
1184 ASSERT_EQ(ret, 0);
1185
1186 ret = cipher->doFinal(reinterpret_cast<HcfCipher *>(key), &input, &output);
1187 EXPECT_NE(ret, 0);
1188
1189 HcfObjDestroy(key);
1190 HcfObjDestroy(cipher);
1191 if (output.data != nullptr) {
1192 HcfFree(output.data);
1193 output.data = nullptr;
1194 }
1195 }
1196
1197 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest033, TestSize.Level0)
1198 {
1199 int ret = 0;
1200 HcfCipher *cipher = nullptr;
1201 HcfSymKey *key = nullptr;
1202 uint8_t plainText[] = "this is test!";
1203 HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
1204 HcfBlob output = { .data = nullptr, .len = 0 };
1205
1206 ret = Generate3DesSymKey(&key);
1207 EXPECT_EQ(ret, HCF_SUCCESS);
1208
1209 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1210 EXPECT_EQ(ret, HCF_SUCCESS);
1211
1212 cipher->base.destroy(nullptr);
1213 ret = cipher->getCipherSpecString(nullptr, SM2_MD_NAME_STR, nullptr);
1214 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1215 ret = cipher->getCipherSpecUint8Array(nullptr, SM2_MD_NAME_STR, nullptr);
1216 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1217 HcfBlob blob = { .data = nullptr, .len = 0 };
1218 ret = cipher->setCipherSpecUint8Array(nullptr, SM2_MD_NAME_STR, blob);
1219 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1220 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
1221 EXPECT_EQ(ret, HCF_SUCCESS);
1222 ret = cipher->doFinal(nullptr, &input, &output);
1223 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1224 HcfObjDestroy(key);
1225 HcfObjDestroy(cipher);
1226 if (output.data != nullptr) {
1227 HcfFree(output.data);
1228 output.data = nullptr;
1229 }
1230 }
1231
1232 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest034, TestSize.Level0)
1233 {
1234 HcfCipher *cipher = nullptr;
1235 HcfSymKey *key = nullptr;
1236 uint8_t plainText[] = "this is test!";
1237 HcfBlob input = { .data = plainText, .len = PLAINTEXT_LEN };
1238 HcfBlob output = { .data = nullptr, .len = 0 };
1239
1240 int ret = Generate3DesSymKey(&key);
1241 ASSERT_EQ(ret, 0);
1242
1243 ret = HcfCipherCreate("3DES192|ECB|PKCS5", &cipher);
1244 ASSERT_EQ(ret, 0);
1245
1246 ret = cipher->init(cipher, ENCRYPT_MODE, &(key->key), nullptr);
1247 ASSERT_EQ(ret, 0);
1248
1249 ret = cipher->doFinal(reinterpret_cast<HcfCipher *>(key), &input, &output);
1250 EXPECT_NE(ret, 0);
1251
1252 HcfObjDestroy(key);
1253 HcfObjDestroy(cipher);
1254 if (output.data != nullptr) {
1255 HcfFree(output.data);
1256 output.data = nullptr;
1257 }
1258 }
1259
1260 HWTEST_F(Crypto3DesCipherTest, Crypto3DesCipherTest035, TestSize.Level0)
1261 {
1262 HcfResult ret = HcfCipherDesGeneratorSpiCreate(nullptr, nullptr);
1263 if (ret != 0) {
1264 LOGE("HcfCipherDesGeneratorSpiCreate failed!");
1265 }
1266 EXPECT_NE(ret, 0);
1267
1268 HcfCipherGeneratorSpi *cipher = nullptr;
1269 CipherAttr params = {
1270 .algo = HCF_ALG_3DES,
1271 .mode = HCF_ALG_MODE_ECB,
1272 .paddingMode = HCF_ALG_PADDING_PKCS5,
1273 };
1274 ret = HcfCipherDesGeneratorSpiCreate(¶ms, &cipher);
1275 EXPECT_EQ(ret, HCF_SUCCESS);
1276
1277 ret = cipher->init(nullptr, ENCRYPT_MODE, nullptr, nullptr);
1278 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1279
1280 ret = cipher->update(nullptr, nullptr, nullptr);
1281 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1282
1283 ret = cipher->doFinal(nullptr, nullptr, nullptr);
1284 EXPECT_EQ(ret, HCF_INVALID_PARAMS);
1285
1286 HcfBlob dataArray = { .data = nullptr, .len = 0 };
1287 ret = cipher->getCipherSpecString(nullptr, OAEP_MGF1_MD_STR, nullptr);
1288 EXPECT_EQ(ret, HCF_NOT_SUPPORT);
1289
1290 ret = cipher->getCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, &dataArray);
1291 EXPECT_EQ(ret, HCF_NOT_SUPPORT);
1292
1293 HcfBlob dataUint8 = { .data = nullptr, .len = 0 };
1294 ret = cipher->setCipherSpecUint8Array(nullptr, OAEP_MGF1_MD_STR, dataUint8);
1295 EXPECT_EQ(ret, HCF_NOT_SUPPORT);
1296
1297 (void)cipher->base.destroy(nullptr);
1298
1299 HcfObjDestroy(cipher);
1300 HcfBlobDataFree(&dataArray);
1301 }
1302
1303 HWTEST_F(Crypto3DesCipherTest, CryptoDesCipherTest001, TestSize.Level0)
1304 {
1305 int ret = 0;
1306 uint8_t cipherText[CIPHER_TEXT_LEN] = {0};
1307 int cipherTextLen = CIPHER_TEXT_LEN;
1308
1309 HcfSymKey *key = nullptr;
1310 HcfCipher *cipher = nullptr;
1311
1312 ret = GenerateDesSymKey(&key);
1313 EXPECT_EQ(ret, HCF_SUCCESS);
1314
1315 ret = HcfCipherCreate("DES64|ECB|PKCS7", &cipher);
1316 EXPECT_EQ(ret, HCF_SUCCESS);
1317
1318 ret = DesEncrypt(cipher, key, nullptr, cipherText, &cipherTextLen);
1319 EXPECT_EQ(ret, HCF_SUCCESS);
1320
1321 ret = DesDecrypt(cipher, key, nullptr, cipherText, cipherTextLen);
1322 EXPECT_EQ(ret, HCF_SUCCESS);
1323
1324 HcfObjDestroy(key);
1325 HcfObjDestroy(cipher);
1326 }
1327
ConvertDesSymKey(HcfBlob * dataBlob,HcfSymKey ** key)1328 static HcfResult ConvertDesSymKey(HcfBlob *dataBlob, HcfSymKey **key)
1329 {
1330 HcfSymKeyGenerator *generator = nullptr;
1331
1332 HcfResult ret = HcfSymKeyGeneratorCreate("DES64", &generator);
1333 if (ret != HCF_SUCCESS) {
1334 LOGE("HcfSymKeyGeneratorCreate failed!");
1335 return ret;
1336 }
1337
1338 ret = generator->convertSymKey(generator, dataBlob, key);
1339 if (ret != HCF_SUCCESS) {
1340 LOGE("generateSymKey failed!");
1341 }
1342 HcfObjDestroy(generator);
1343 return ret;
1344 }
1345
1346 HWTEST_F(Crypto3DesCipherTest, CryptoDesCipherTestVecderEnc, TestSize.Level0)
1347 {
1348 int ret = 0;
1349 uint8_t plainText[] = {0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74}; // "Now is t"
1350 uint8_t keyData[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}; // Test key
1351 uint8_t expectedCipherText[] = {0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15}; // Expected ciphertext
1352
1353 HcfBlob input = {.data = plainText, .len = sizeof(plainText)};
1354 HcfBlob output = {};
1355 HcfBlob keyDataBlob = {.data = keyData, .len = sizeof(keyData)};
1356
1357 HcfSymKey *key = nullptr;
1358 HcfCipher *cipher = nullptr;
1359
1360 // Convert key data to HcfSymKey
1361 ret = ConvertDesSymKey(&keyDataBlob, &key);
1362 EXPECT_EQ(ret, HCF_SUCCESS);
1363
1364 // Create DES cipher
1365 ret = HcfCipherCreate("DES64|ECB|NoPadding", &cipher);
1366 EXPECT_EQ(ret, HCF_SUCCESS);
1367
1368 // Encrypt
1369 ret = cipher->init(cipher, ENCRYPT_MODE, (HcfKey *)key, nullptr);
1370 EXPECT_EQ(ret, HCF_SUCCESS);
1371
1372 ret = cipher->doFinal(cipher, &input, &output);
1373 EXPECT_EQ(ret, HCF_SUCCESS);
1374
1375 // Verify ciphertext
1376 EXPECT_EQ(output.len, sizeof(expectedCipherText));
1377 EXPECT_EQ(memcmp(output.data, expectedCipherText, sizeof(expectedCipherText)), 0);
1378
1379 HcfObjDestroy(key);
1380 HcfObjDestroy(cipher);
1381 if (output.data != nullptr) {
1382 HcfBlobDataFree(&output);
1383 }
1384 }
1385
1386 HWTEST_F(Crypto3DesCipherTest, CryptoDesCipherTestVecderDec, TestSize.Level0)
1387 {
1388 int ret = 0;
1389 uint8_t expectedCipherText[] = {0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74}; // "Now is t"
1390 uint8_t keyData[] = {0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef}; // Test key
1391 uint8_t plainText[] = {0x3f, 0xa4, 0x0e, 0x8a, 0x98, 0x4d, 0x48, 0x15}; // Expected ciphertext
1392
1393 HcfBlob input = {.data = plainText, .len = sizeof(plainText)};
1394 HcfBlob output = {};
1395 HcfBlob keyDataBlob = {.data = keyData, .len = sizeof(keyData)};
1396
1397 HcfSymKey *key = nullptr;
1398 HcfCipher *cipher = nullptr;
1399
1400 // Convert key data to HcfSymKey
1401 ret = ConvertDesSymKey(&keyDataBlob, &key);
1402 EXPECT_EQ(ret, HCF_SUCCESS);
1403
1404 // Create DES cipher
1405 ret = HcfCipherCreate("DES64|ECB|NoPadding", &cipher);
1406 EXPECT_EQ(ret, HCF_SUCCESS);
1407
1408 // Encrypt
1409 ret = cipher->init(cipher, DECRYPT_MODE, (HcfKey *)key, nullptr);
1410 EXPECT_EQ(ret, HCF_SUCCESS);
1411
1412 ret = cipher->doFinal(cipher, &input, &output);
1413 EXPECT_EQ(ret, HCF_SUCCESS);
1414
1415 // Verify ciphertext
1416 EXPECT_EQ(output.len, sizeof(expectedCipherText));
1417 EXPECT_EQ(memcmp(output.data, expectedCipherText, sizeof(expectedCipherText)), 0);
1418
1419 HcfObjDestroy(key);
1420 HcfObjDestroy(cipher);
1421 if (output.data != nullptr) {
1422 HcfBlobDataFree(&output);
1423 }
1424 }
1425 }
1426