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 CryptoAesCbcCipherTest : 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(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest001, TestSize.Level0)
46 {
47     int ret = 0;
48     uint8_t iv[16] = {0};
49     uint8_t cipherText[128] = {0};
50     int cipherTextLen = 128;
51 
52     HcfIvParamsSpec ivSpec = {};
53     HcfSymKeyGenerator *generator = nullptr;
54     HcfCipher *cipher = nullptr;
55     HcfSymKey *key = nullptr;
56     ivSpec.iv.data = iv;
57     ivSpec.iv.len = 16;
58 
59     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
60     if (ret != 0) {
61         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
62         goto CLEAR_UP;
63     }
64 
65     ret = generator->generateSymKey(generator, &key);
66     if (ret != 0) {
67         LOGE("generateSymKey failed!");
68         goto CLEAR_UP;
69     }
70 
71     ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher);
72     if (ret != 0) {
73         LOGE("HcfCipherCreate failed!");
74         goto CLEAR_UP;
75     }
76 
77     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
78     if (ret != 0) {
79         LOGE("AesEncrypt failed! %d", ret);
80         goto CLEAR_UP;
81     }
82 
83     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
84     if (ret != 0) {
85         LOGE("AesDecrypt failed! %d", ret);
86         goto CLEAR_UP;
87     }
88 
89 CLEAR_UP:
90     HcfObjDestroy((HcfObjectBase *)key);
91     HcfObjDestroy((HcfObjectBase *)cipher);
92     HcfObjDestroy((HcfObjectBase *)generator);
93     EXPECT_NE(ret, 0);
94 }
95 
96 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest002, TestSize.Level0)
97 {
98     int ret = 0;
99     uint8_t iv[16] = {0};
100     uint8_t cipherText[128] = {0};
101     int cipherTextLen = 128;
102 
103     HcfIvParamsSpec ivSpec = {};
104     HcfSymKeyGenerator *generator = nullptr;
105     HcfCipher *cipher = nullptr;
106     HcfSymKey *key = nullptr;
107     ivSpec.iv.data = iv;
108     ivSpec.iv.len = 16;
109 
110     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
111     if (ret != 0) {
112         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
113         goto CLEAR_UP;
114     }
115 
116     ret = generator->generateSymKey(generator, &key);
117     if (ret != 0) {
118         LOGE("generateSymKey failed!");
119         goto CLEAR_UP;
120     }
121 
122     ret = HcfCipherCreate("AES128|CBC|PKCS5", &cipher);
123     if (ret != 0) {
124         LOGE("HcfCipherCreate failed!");
125         goto CLEAR_UP;
126     }
127 
128     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
129     if (ret != 0) {
130         LOGE("AesEncrypt failed! %d", ret);
131         goto CLEAR_UP;
132     }
133 
134     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
135     if (ret != 0) {
136         LOGE("AesDecrypt failed! %d", ret);
137         goto CLEAR_UP;
138     }
139 
140 CLEAR_UP:
141     HcfObjDestroy((HcfObjectBase *)key);
142     HcfObjDestroy((HcfObjectBase *)cipher);
143     HcfObjDestroy((HcfObjectBase *)generator);
144     EXPECT_EQ(ret, 0);
145 }
146 
147 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest003, TestSize.Level0)
148 {
149     int ret = 0;
150     uint8_t iv[16] = {0};
151     uint8_t cipherText[128] = {0};
152     int cipherTextLen = 128;
153 
154     HcfIvParamsSpec ivSpec = {};
155     HcfSymKeyGenerator *generator = nullptr;
156     HcfCipher *cipher = nullptr;
157     HcfSymKey *key = nullptr;
158     ivSpec.iv.data = iv;
159     ivSpec.iv.len = 16;
160 
161     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
162     if (ret != 0) {
163         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
164         goto CLEAR_UP;
165     }
166 
167     ret = generator->generateSymKey(generator, &key);
168     if (ret != 0) {
169         LOGE("generateSymKey failed!");
170         goto CLEAR_UP;
171     }
172 
173     ret = HcfCipherCreate("AES128|CBC|PKCS7", &cipher);
174     if (ret != 0) {
175         LOGE("HcfCipherCreate failed!");
176         goto CLEAR_UP;
177     }
178 
179     ret = AesEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
180     if (ret != 0) {
181         LOGE("AesEncrypt failed! %d", ret);
182         goto CLEAR_UP;
183     }
184 
185     ret = AesDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
186     if (ret != 0) {
187         LOGE("AesDecrypt failed! %d", ret);
188         goto CLEAR_UP;
189     }
190 
191 CLEAR_UP:
192     HcfObjDestroy((HcfObjectBase *)key);
193     HcfObjDestroy((HcfObjectBase *)cipher);
194     HcfObjDestroy((HcfObjectBase *)generator);
195     EXPECT_EQ(ret, 0);
196 }
197 
198 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest004, TestSize.Level0)
199 {
200     int ret = 0;
201     uint8_t iv[16] = {0};
202     uint8_t cipherText[128] = {0};
203     int cipherTextLen = 128;
204 
205     HcfIvParamsSpec ivSpec = {};
206     HcfSymKeyGenerator *generator = nullptr;
207     HcfCipher *cipher = nullptr;
208     HcfSymKey *key = nullptr;
209     ivSpec.iv.data = iv;
210     ivSpec.iv.len = 16;
211 
212     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
213     if (ret != 0) {
214         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
215         goto CLEAR_UP;
216     }
217 
218     ret = generator->generateSymKey(generator, &key);
219     if (ret != 0) {
220         LOGE("generateSymKey failed!");
221         goto CLEAR_UP;
222     }
223 
224     ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher);
225     if (ret != 0) {
226         LOGE("HcfCipherCreate failed!");
227         goto CLEAR_UP;
228     }
229 
230     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
231     if (ret != 0) {
232         LOGE("AesNoUpdateEncrypt failed! %d", ret);
233         goto CLEAR_UP;
234     }
235 
236     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
237     if (ret != 0) {
238         LOGE("AesNoUpdateDecrypt failed! %d", ret);
239         goto CLEAR_UP;
240     }
241 
242 CLEAR_UP:
243     HcfObjDestroy((HcfObjectBase *)key);
244     HcfObjDestroy((HcfObjectBase *)cipher);
245     HcfObjDestroy((HcfObjectBase *)generator);
246     EXPECT_NE(ret, 0);
247 }
248 
249 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest005, TestSize.Level0)
250 {
251     int ret = 0;
252     uint8_t iv[16] = {0};
253     uint8_t cipherText[128] = {0};
254     int cipherTextLen = 128;
255 
256     HcfIvParamsSpec ivSpec = {};
257     HcfSymKeyGenerator *generator = nullptr;
258     HcfCipher *cipher = nullptr;
259     HcfSymKey *key = nullptr;
260     ivSpec.iv.data = iv;
261     ivSpec.iv.len = 16;
262 
263     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
264     if (ret != 0) {
265         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
266         goto CLEAR_UP;
267     }
268 
269     ret = generator->generateSymKey(generator, &key);
270     if (ret != 0) {
271         LOGE("generateSymKey failed!");
272         goto CLEAR_UP;
273     }
274 
275     ret = HcfCipherCreate("AES128|CBC|PKCS5", &cipher);
276     if (ret != 0) {
277         LOGE("HcfCipherCreate failed!");
278         goto CLEAR_UP;
279     }
280 
281     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
282     if (ret != 0) {
283         LOGE("AesNoUpdateEncrypt failed! %d", ret);
284         goto CLEAR_UP;
285     }
286 
287     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
288     if (ret != 0) {
289         LOGE("AesNoUpdateDecrypt failed! %d", ret);
290         goto CLEAR_UP;
291     }
292 
293 CLEAR_UP:
294     HcfObjDestroy((HcfObjectBase *)key);
295     HcfObjDestroy((HcfObjectBase *)cipher);
296     HcfObjDestroy((HcfObjectBase *)generator);
297     EXPECT_EQ(ret, 0);
298 }
299 
300 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest006, TestSize.Level0)
301 {
302     int ret = 0;
303     uint8_t iv[16] = {0};
304     uint8_t cipherText[128] = {0};
305     int cipherTextLen = 128;
306 
307     HcfIvParamsSpec ivSpec = {};
308     HcfSymKeyGenerator *generator = nullptr;
309     HcfCipher *cipher = nullptr;
310     HcfSymKey *key = nullptr;
311     ivSpec.iv.data = iv;
312     ivSpec.iv.len = 16;
313 
314     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
315     if (ret != 0) {
316         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
317         goto CLEAR_UP;
318     }
319 
320     ret = generator->generateSymKey(generator, &key);
321     if (ret != 0) {
322         LOGE("generateSymKey failed!");
323         goto CLEAR_UP;
324     }
325 
326     ret = HcfCipherCreate("AES128|CBC|PKCS7", &cipher);
327     if (ret != 0) {
328         LOGE("HcfCipherCreate failed!");
329         goto CLEAR_UP;
330     }
331 
332     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
333     if (ret != 0) {
334         LOGE("AesNoUpdateEncrypt failed! %d", ret);
335         goto CLEAR_UP;
336     }
337 
338     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
339     if (ret != 0) {
340         LOGE("AesNoUpdateDecrypt failed! %d", ret);
341         goto CLEAR_UP;
342     }
343 
344 CLEAR_UP:
345     HcfObjDestroy((HcfObjectBase *)key);
346     HcfObjDestroy((HcfObjectBase *)cipher);
347     HcfObjDestroy((HcfObjectBase *)generator);
348     EXPECT_EQ(ret, 0);
349 }
350 
351 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest007, TestSize.Level0)
352 {
353     int ret = 0;
354     HcfIvParamsSpec ivSpec = {};
355     uint8_t iv[16] = {0};
356     ivSpec.iv.data = iv;
357     ivSpec.iv.len = 16;
358 
359     HcfCipher *cipher = nullptr;
360     HcfSymKey *key = nullptr;
361 
362     ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE);
363     if (ret != 0) {
364         LOGE("GeneratorFile failed!");
365         goto CLEAR_UP;
366     }
367 
368     ret = ConvertSymKey("AES128", &key);
369     if (ret != 0) {
370         LOGE("ConvertSymKey failed!");
371         goto CLEAR_UP;
372     }
373 
374     ret = HcfCipherCreate("AES128|CBC|NoPadding", &cipher);
375     if (ret != 0) {
376         LOGE("HcfCipherCreate failed!");
377         goto CLEAR_UP;
378     }
379 
380     ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
381     if (ret != 0) {
382         LOGE("AesNoUpdateEncrypt failed! %d", ret);
383         goto CLEAR_UP;
384     }
385 
386     ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
387     if (ret != 0) {
388         LOGE("AesNoUpdateDecrypt failed! %d", ret);
389         goto CLEAR_UP;
390     }
391     ret = CompareFileContent();
392     if (ret != 0) {
393         LOGE("CompareFileContent failed!");
394         goto CLEAR_UP;
395     }
396 
397 CLEAR_UP:
398     HcfObjDestroy((HcfObjectBase *)key);
399     HcfObjDestroy((HcfObjectBase *)cipher);
400     EXPECT_EQ(ret, 0);
401 }
402 
403 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest008, TestSize.Level0)
404 {
405     int ret = 0;
406     uint8_t iv[AES_IV_LEN] = { 0 };
407     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
408     int cipherTextLen = CIPHER_TEXT_LEN;
409 
410     HcfIvParamsSpec ivSpec = {};
411     HcfCipher *cipher = nullptr;
412     HcfSymKey *key = nullptr;
413     ivSpec.iv.data = iv;
414     ivSpec.iv.len = AES_IV_LEN;
415 
416     ret = GenerateSymKey("AES192", &key);
417     if (ret != 0) {
418         LOGE("GenerateSymKey failed!");
419         goto CLEAR_UP;
420     }
421 
422     ret = HcfCipherCreate("AES192|CBC|PKCS5", &cipher);
423     if (ret != 0) {
424         LOGE("HcfCipherCreate failed!");
425         goto CLEAR_UP;
426     }
427 
428     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
429     if (ret != 0) {
430         LOGE("AesEncrypt failed! %d", ret);
431         goto CLEAR_UP;
432     }
433 
434     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
435     if (ret != 0) {
436         LOGE("AesDecrypt failed! %d", ret);
437     }
438 
439 CLEAR_UP:
440     HcfObjDestroy(key);
441     HcfObjDestroy(cipher);
442     EXPECT_EQ(ret, 0);
443 }
444 
445 HWTEST_F(CryptoAesCbcCipherTest, CryptoAesCbcCipherTest009, TestSize.Level0)
446 {
447     int ret = 0;
448     uint8_t iv[AES_IV_LEN] = { 0 };
449     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
450     int cipherTextLen = CIPHER_TEXT_LEN;
451 
452     HcfIvParamsSpec ivSpec = {};
453     HcfCipher *cipher = nullptr;
454     HcfSymKey *key = nullptr;
455     ivSpec.iv.data = iv;
456     ivSpec.iv.len = AES_IV_LEN;
457 
458     ret = GenerateSymKey("AES256", &key);
459     if (ret != 0) {
460         LOGE("GenerateSymKey failed!");
461         goto CLEAR_UP;
462     }
463 
464     ret = HcfCipherCreate("AES256|CBC|PKCS5", &cipher);
465     if (ret != 0) {
466         LOGE("HcfCipherCreate failed!");
467         goto CLEAR_UP;
468     }
469 
470     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
471     if (ret != 0) {
472         LOGE("AesEncrypt failed! %d", ret);
473         goto CLEAR_UP;
474     }
475 
476     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
477     if (ret != 0) {
478         LOGE("AesDecrypt failed! %d", ret);
479     }
480 
481 CLEAR_UP:
482     HcfObjDestroy(key);
483     HcfObjDestroy(cipher);
484     EXPECT_EQ(ret, 0);
485 }
486 }