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 CryptoAesOfbCipherTest : 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(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest001, 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|OFB|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(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest002, 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|OFB|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(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest003, 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|OFB|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 CLEAR_UP:
191     HcfObjDestroy((HcfObjectBase *)key);
192     HcfObjDestroy((HcfObjectBase *)cipher);
193     HcfObjDestroy((HcfObjectBase *)generator);
194     EXPECT_EQ(ret, 0);
195 }
196 
197 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest004, TestSize.Level0)
198 {
199     int ret = 0;
200     uint8_t iv[16] = {0};
201     uint8_t cipherText[128] = {0};
202     int cipherTextLen = 128;
203 
204     HcfIvParamsSpec ivSpec = {};
205     HcfSymKeyGenerator *generator = nullptr;
206     HcfCipher *cipher = nullptr;
207     HcfSymKey *key = nullptr;
208     ivSpec.iv.data = iv;
209     ivSpec.iv.len = 16;
210 
211     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
212     if (ret != 0) {
213         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
214         goto CLEAR_UP;
215     }
216 
217     ret = generator->generateSymKey(generator, &key);
218     if (ret != 0) {
219         LOGE("generateSymKey failed!");
220         goto CLEAR_UP;
221     }
222 
223     ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher);
224     if (ret != 0) {
225         LOGE("HcfCipherCreate failed!");
226         goto CLEAR_UP;
227     }
228 
229     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
230     if (ret != 0) {
231         LOGE("AesNoUpdateEncrypt failed! %d", ret);
232         goto CLEAR_UP;
233     }
234 
235     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
236     if (ret != 0) {
237         LOGE("AesNoUpdateDecrypt failed! %d", ret);
238         goto CLEAR_UP;
239     }
240 
241 CLEAR_UP:
242     HcfObjDestroy((HcfObjectBase *)key);
243     HcfObjDestroy((HcfObjectBase *)cipher);
244     HcfObjDestroy((HcfObjectBase *)generator);
245     EXPECT_EQ(ret, 0);
246 }
247 
248 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest005, TestSize.Level0)
249 {
250     int ret = 0;
251     uint8_t iv[16] = {0};
252     uint8_t cipherText[128] = {0};
253     int cipherTextLen = 128;
254 
255     HcfIvParamsSpec ivSpec = {};
256     HcfSymKeyGenerator *generator = nullptr;
257     HcfCipher *cipher = nullptr;
258     HcfSymKey *key = nullptr;
259     ivSpec.iv.data = iv;
260     ivSpec.iv.len = 16;
261 
262     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
263     if (ret != 0) {
264         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
265         goto CLEAR_UP;
266     }
267 
268     ret = generator->generateSymKey(generator, &key);
269     if (ret != 0) {
270         LOGE("generateSymKey failed!");
271         goto CLEAR_UP;
272     }
273 
274     ret = HcfCipherCreate("AES128|OFB|PKCS5", &cipher);
275     if (ret != 0) {
276         LOGE("HcfCipherCreate failed!");
277         goto CLEAR_UP;
278     }
279 
280     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
281     if (ret != 0) {
282         LOGE("AesNoUpdateEncrypt failed! %d", ret);
283         goto CLEAR_UP;
284     }
285 
286     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
287     if (ret != 0) {
288         LOGE("AesNoUpdateDecrypt failed! %d", ret);
289         goto CLEAR_UP;
290     }
291 
292 CLEAR_UP:
293     HcfObjDestroy((HcfObjectBase *)key);
294     HcfObjDestroy((HcfObjectBase *)cipher);
295     HcfObjDestroy((HcfObjectBase *)generator);
296     EXPECT_EQ(ret, 0);
297 }
298 
299 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest006, TestSize.Level0)
300 {
301     int ret = 0;
302     uint8_t iv[16] = {0};
303     uint8_t cipherText[128] = {0};
304     int cipherTextLen = 128;
305 
306     HcfIvParamsSpec ivSpec = {};
307     HcfSymKeyGenerator *generator = nullptr;
308     HcfCipher *cipher = nullptr;
309     HcfSymKey *key = nullptr;
310     ivSpec.iv.data = iv;
311     ivSpec.iv.len = 16;
312 
313     ret = HcfSymKeyGeneratorCreate("AES128", &generator);
314     if (ret != 0) {
315         LOGE("HcfSymKeyGeneratorCreate failed!%d", ret);
316         goto CLEAR_UP;
317     }
318 
319     ret = generator->generateSymKey(generator, &key);
320     if (ret != 0) {
321         LOGE("generateSymKey failed!");
322         goto CLEAR_UP;
323     }
324 
325     ret = HcfCipherCreate("AES128|OFB|PKCS7", &cipher);
326     if (ret != 0) {
327         LOGE("HcfCipherCreate failed!");
328         goto CLEAR_UP;
329     }
330 
331     ret = AesNoUpdateEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, &cipherTextLen);
332     if (ret != 0) {
333         LOGE("AesNoUpdateEncrypt failed! %d", ret);
334         goto CLEAR_UP;
335     }
336 
337     ret = AesNoUpdateDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec, cipherText, cipherTextLen);
338     if (ret != 0) {
339         LOGE("AesNoUpdateDecrypt failed! %d", ret);
340         goto CLEAR_UP;
341     }
342 CLEAR_UP:
343     HcfObjDestroy((HcfObjectBase *)key);
344     HcfObjDestroy((HcfObjectBase *)cipher);
345     HcfObjDestroy((HcfObjectBase *)generator);
346     EXPECT_EQ(ret, 0);
347 }
348 
349 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest007, TestSize.Level0)
350 {
351     int ret = 0;
352     uint8_t iv[16] = {0};
353 
354     HcfIvParamsSpec ivSpec = {};
355     HcfCipher *cipher = nullptr;
356     HcfSymKey *key = nullptr;
357     ivSpec.iv.data = iv;
358     ivSpec.iv.len = 16;
359 
360     ret = GenerateSymKey("AES128", &key);
361     if (ret != 0) {
362         LOGE("GenerateSymKey failed!");
363         goto CLEAR_UP;
364     }
365 
366     ret = HcfCipherCreate("AES128|OFB|NoPadding", &cipher);
367     if (ret != 0) {
368         LOGE("HcfCipherCreate failed!");
369         goto CLEAR_UP;
370     }
371     ret = GeneratorFile("/data/test_aes.txt", 10 * FILE_BLOCK_SIZE);
372     if (ret != 0) {
373         LOGE("GeneratorFile failed!");
374         goto CLEAR_UP;
375     }
376 
377     ret = AesMultiBlockEncrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
378     if (ret != 0) {
379         LOGE("AesNoUpdateEncrypt failed! %d", ret);
380         goto CLEAR_UP;
381     }
382 
383     ret = AesMultiBlockDecrypt(cipher, key, (HcfParamsSpec *)&ivSpec);
384     if (ret != 0) {
385         LOGE("AesNoUpdateDecrypt failed! %d", ret);
386         goto CLEAR_UP;
387     }
388     ret = CompareFileContent();
389     if (ret != 0) {
390         LOGE("CompareFileContent failed!");
391         goto CLEAR_UP;
392     }
393 
394 CLEAR_UP:
395     HcfObjDestroy((HcfObjectBase *)key);
396     HcfObjDestroy((HcfObjectBase *)cipher);
397     EXPECT_EQ(ret, 0);
398 }
399 
400 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest008, TestSize.Level0)
401 {
402     int ret = 0;
403     uint8_t iv[AES_IV_LEN] = { 0 };
404     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
405     int cipherTextLen = CIPHER_TEXT_LEN;
406 
407     HcfIvParamsSpec ivSpec = {};
408     HcfCipher *cipher = nullptr;
409     HcfSymKey *key = nullptr;
410     ivSpec.iv.data = iv;
411     ivSpec.iv.len = AES_IV_LEN;
412 
413     ret = GenerateSymKey("AES192", &key);
414     if (ret != 0) {
415         LOGE("GenerateSymKey failed!");
416         goto CLEAR_UP;
417     }
418 
419     ret = HcfCipherCreate("AES192|OFB|PKCS5", &cipher);
420     if (ret != 0) {
421         LOGE("HcfCipherCreate failed!");
422         goto CLEAR_UP;
423     }
424 
425     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
426     if (ret != 0) {
427         LOGE("AesEncrypt failed! %d", ret);
428         goto CLEAR_UP;
429     }
430 
431     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
432     if (ret != 0) {
433         LOGE("AesDecrypt failed! %d", ret);
434     }
435 
436 CLEAR_UP:
437     HcfObjDestroy(key);
438     HcfObjDestroy(cipher);
439     EXPECT_EQ(ret, 0);
440 }
441 
442 HWTEST_F(CryptoAesOfbCipherTest, CryptoAesOfbCipherTest009, TestSize.Level0)
443 {
444     int ret = 0;
445     uint8_t iv[AES_IV_LEN] = { 0 };
446     uint8_t cipherText[CIPHER_TEXT_LEN] = { 0 };
447     int cipherTextLen = CIPHER_TEXT_LEN;
448 
449     HcfIvParamsSpec ivSpec = {};
450     HcfCipher *cipher = nullptr;
451     HcfSymKey *key = nullptr;
452     ivSpec.iv.data = iv;
453     ivSpec.iv.len = AES_IV_LEN;
454 
455     ret = GenerateSymKey("AES256", &key);
456     if (ret != 0) {
457         LOGE("GenerateSymKey failed!");
458         goto CLEAR_UP;
459     }
460 
461     ret = HcfCipherCreate("AES256|OFB|PKCS5", &cipher);
462     if (ret != 0) {
463         LOGE("HcfCipherCreate failed!");
464         goto CLEAR_UP;
465     }
466 
467     ret = AesEncrypt(cipher, key, &(ivSpec.base), cipherText, &cipherTextLen);
468     if (ret != 0) {
469         LOGE("AesEncrypt failed! %d", ret);
470         goto CLEAR_UP;
471     }
472 
473     ret = AesDecrypt(cipher, key, &(ivSpec.base), cipherText, cipherTextLen);
474     if (ret != 0) {
475         LOGE("AesDecrypt failed! %d", ret);
476     }
477 
478 CLEAR_UP:
479     HcfObjDestroy(key);
480     HcfObjDestroy(cipher);
481     EXPECT_EQ(ret, 0);
482 }
483 }