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 CryptoAesCtrCipherTest : 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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest001, 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|CTR|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_EQ(ret, 0);
94 }
95 
96 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest002, 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|CTR|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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest003, 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|CTR|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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest004, 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|CTR|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_EQ(ret, 0);
247 }
248 
249 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest005, 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|CTR|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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest006, 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|CTR|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(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest007, TestSize.Level0)
352 {
353     int ret = 0;
354     uint8_t iv[16] = {0};
355 
356     HcfIvParamsSpec ivSpec = {};
357     HcfCipher *cipher = nullptr;
358     HcfSymKey *key = nullptr;
359     ivSpec.iv.data = iv;
360     ivSpec.iv.len = 16;
361 
362     ret = ConvertSymKey("AES128", &key);
363     if (ret != 0) {
364         LOGE("ConvertSymKey failed!");
365         goto CLEAR_UP;
366     }
367 
368     ret = HcfCipherCreate("AES128|CTR|NoPadding", &cipher);
369     if (ret != 0) {
370         LOGE("HcfCipherCreate failed!");
371         goto CLEAR_UP;
372     }
373     ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE);
374     if (ret != 0) {
375         LOGE("GeneratorFile failed!");
376         goto CLEAR_UP;
377     }
378 
379     ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
380     if (ret != 0) {
381         LOGE("AesNoUpdateEncrypt failed! %d", ret);
382         goto CLEAR_UP;
383     }
384 
385     ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
386     if (ret != 0) {
387         LOGE("AesNoUpdateDecrypt failed! %d", ret);
388         goto CLEAR_UP;
389     }
390     ret = CompareFileContent();
391     if (ret != 0) {
392         LOGE("CompareFileContent failed!");
393         goto CLEAR_UP;
394     }
395 
396 CLEAR_UP:
397     HcfObjDestroy((HcfObjectBase *)key);
398     HcfObjDestroy((HcfObjectBase *)cipher);
399     EXPECT_EQ(ret, 0);
400 }
401 
402 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest008, TestSize.Level0)
403 {
404     int ret = 0;
405     uint8_t iv[AES_IV_LEN] = { 0 };
406     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
407     int cipherTextLen = CIPHER_TEXT_LEN;
408 
409     HcfIvParamsSpec ivSpec = {};
410     HcfCipher *cipher = nullptr;
411     HcfSymKey *key = nullptr;
412     ivSpec.iv.data = iv;
413     ivSpec.iv.len = AES_IV_LEN;
414 
415     ret = GenerateSymKey("AES192", &key);
416     if (ret != 0) {
417         LOGE("GenerateSymKey failed!");
418         goto CLEAR_UP;
419     }
420 
421     ret = HcfCipherCreate("AES192|CTR|PKCS5", &cipher);
422     if (ret != 0) {
423         LOGE("HcfCipherCreate failed!");
424         goto CLEAR_UP;
425     }
426 
427     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
428     if (ret != 0) {
429         LOGE("AesEncrypt failed! %d", ret);
430         goto CLEAR_UP;
431     }
432 
433     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
434     if (ret != 0) {
435         LOGE("AesDecrypt failed! %d", ret);
436     }
437 
438 CLEAR_UP:
439     HcfObjDestroy(key);
440     HcfObjDestroy(cipher);
441     EXPECT_EQ(ret, 0);
442 }
443 
444 HWTEST_F(CryptoAesCtrCipherTest, CryptoAesCtrCipherTest009, TestSize.Level0)
445 {
446     int ret = 0;
447     uint8_t iv[AES_IV_LEN] = { 0 };
448     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
449     int cipherTextLen = CIPHER_TEXT_LEN;
450 
451     HcfIvParamsSpec ivSpec = {};
452     HcfCipher *cipher = nullptr;
453     HcfSymKey *key = nullptr;
454     ivSpec.iv.data = iv;
455     ivSpec.iv.len = AES_IV_LEN;
456 
457     ret = GenerateSymKey("AES256", &key);
458     if (ret != 0) {
459         LOGE("GenerateSymKey failed!");
460         goto CLEAR_UP;
461     }
462 
463     ret = HcfCipherCreate("AES256|CTR|PKCS5", &cipher);
464     if (ret != 0) {
465         LOGE("HcfCipherCreate failed!");
466         goto CLEAR_UP;
467     }
468 
469     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
470     if (ret != 0) {
471         LOGE("AesEncrypt failed! %d", ret);
472         goto CLEAR_UP;
473     }
474 
475     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
476     if (ret != 0) {
477         LOGE("AesDecrypt failed! %d", ret);
478     }
479 
480 CLEAR_UP:
481     HcfObjDestroy(key);
482     HcfObjDestroy(cipher);
483     EXPECT_EQ(ret, 0);
484 }
485 }