1 /*
2  * Copyright (c) 2023 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 "softbus_aes_encrypt.h"
17 
18 #include <cstring>
19 #include <securec.h>
20 
21 #include "softbus_adapter_crypto.h"
22 #include "softbus_adapter_mem.h"
23 #include "softbus_errcode.h"
24 #include "gtest/gtest.h"
25 
26 using namespace std;
27 using namespace testing::ext;
28 
29 namespace OHOS {
30 class AdapterDsoftbusAesCryptoTest : public testing::Test {
31 protected:
32     static void SetUpTestCase(void);
33     static void TearDownTestCase(void);
34     void SetUp();
35     void TearDown();
36 };
SetUpTestCase(void)37 void AdapterDsoftbusAesCryptoTest::SetUpTestCase(void) { }
TearDownTestCase(void)38 void AdapterDsoftbusAesCryptoTest::TearDownTestCase(void) { }
SetUp()39 void AdapterDsoftbusAesCryptoTest::SetUp() { }
TearDown()40 void AdapterDsoftbusAesCryptoTest::TearDown() { }
41 
42 /*
43  * @tc.name: SoftBusGenerateHmacHash001
44  * @tc.desc: parameters are Legal
45  * @tc.type: FUNC
46  * @tc.require: I5OHDE
47  */
48 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusGenerateHmacHash001, TestSize.Level0)
49 {
50     uint32_t randLen = 8;
51     uint32_t rootKeyLen = 16;
52     uint32_t hashLen = 32;
53     uint8_t randStr[randLen];
54     uint8_t rootKey[rootKeyLen];
55     uint8_t hash[hashLen];
56 
57     int32_t ret = SoftBusGenerateRandomArray(randStr, randLen);
58     EXPECT_EQ(SOFTBUS_OK, ret);
59     ret = SoftBusGenerateRandomArray(rootKey, rootKeyLen);
60     EXPECT_EQ(SOFTBUS_OK, ret);
61     EncryptKey randomKey = { randStr, randLen };
62 
63     ret = SoftBusGenerateHmacHash(&randomKey, rootKey, rootKeyLen, hash, hashLen);
64     EXPECT_EQ(SOFTBUS_OK, ret);
65 }
66 
67 /*
68  * @tc.name: SoftBusGenerateHmacHash002
69  * @tc.desc: parameter is nullptr
70  * @tc.type: FUNC
71  * @tc.require: I5OHDE
72  */
73 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusGenerateHmacHash002, TestSize.Level0)
74 {
75     uint32_t randLen = 8;
76     uint32_t rootKeyLen = 16;
77     uint32_t hashLen = 32;
78     uint8_t randStr[randLen];
79     uint8_t rootKey[rootKeyLen];
80     uint8_t hash[hashLen];
81 
82     int32_t ret = SoftBusGenerateRandomArray(randStr, randLen);
83     EXPECT_EQ(SOFTBUS_OK, ret);
84     ret = SoftBusGenerateRandomArray(rootKey, rootKeyLen);
85     EXPECT_EQ(SOFTBUS_OK, ret);
86     EncryptKey randomKey = { randStr, randLen };
87 
88     ret = SoftBusGenerateHmacHash(nullptr, rootKey, rootKeyLen, hash, hashLen);
89     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
90     ret = SoftBusGenerateHmacHash(&randomKey, nullptr, rootKeyLen, hash, hashLen);
91     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
92     ret = SoftBusGenerateHmacHash(&randomKey, rootKey, rootKeyLen, nullptr, hashLen);
93     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
94 }
95 
96 /*
97  * @tc.name: SoftBusGenerateHmacHash003
98  * @tc.desc: rootKeyLen or hashLen is illegal
99  * @tc.type: FUNC
100  * @tc.require: I5OHDE
101  */
102 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusGenerateHmacHash003, TestSize.Level0)
103 {
104     uint32_t randLen = 8;
105     uint32_t rootKeyLen = 16;
106     uint32_t hashLen = 32;
107     uint32_t rootKeyLen1 = 0;
108     uint32_t hashLen1 = 0;
109     uint8_t randStr[randLen];
110     uint8_t rootKey[rootKeyLen];
111     uint8_t hash[hashLen];
112 
113     int32_t ret = SoftBusGenerateRandomArray(randStr, randLen);
114     EXPECT_EQ(SOFTBUS_OK, ret);
115     ret = SoftBusGenerateRandomArray(rootKey, rootKeyLen);
116     EXPECT_EQ(SOFTBUS_OK, ret);
117     EncryptKey randomKey = { randStr, randLen };
118 
119     ret = SoftBusGenerateHmacHash(&randomKey, rootKey, rootKeyLen1, hash, hashLen);
120     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
121     ret = SoftBusGenerateHmacHash(&randomKey, rootKey, rootKeyLen, hash, hashLen1);
122     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
123 }
124 
125 /*
126  * @tc.name: SoftBusAesCfbRootEncrypt001
127  * @tc.desc: parameters are Legal
128  * @tc.type: FUNC
129  * @tc.require: I5OHDE
130  */
131 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbRootEncrypt001, TestSize.Level0)
132 {
133     uint32_t randLen = 8;
134     uint32_t inDataLen = 10;
135     uint32_t rootKeyLen = 16;
136     uint8_t randStr[randLen];
137     uint8_t inData[inDataLen];
138     uint8_t rKey[rootKeyLen];
139     AesOutputData encryptOutData = { 0 };
140     AesOutputData decryptOutData = { 0 };
141 
142     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
143     EXPECT_EQ(SOFTBUS_OK, ret);
144     ret = SoftBusGenerateRandomArray(randStr, randLen);
145     EXPECT_EQ(SOFTBUS_OK, ret);
146     ret = SoftBusGenerateRandomArray(rKey, rootKeyLen);
147     EXPECT_EQ(SOFTBUS_OK, ret);
148     AesInputData encryptInData = { inData, inDataLen };
149     EncryptKey randomKey = { randStr, randLen };
150     EncryptKey rootKey = { rKey, rootKeyLen };
151 
152     ret = SoftBusAesCfbRootEncrypt(&encryptInData, &randomKey, &rootKey, ENCRYPT_MODE, &encryptOutData);
153     EXPECT_EQ(SOFTBUS_OK, ret);
154     ret = SoftBusAesCfbRootEncrypt(
155         (const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
156     EXPECT_EQ(SOFTBUS_OK, ret);
157 
158     ret = memcmp((const char *)decryptOutData.data, (const char *)encryptInData.data, decryptOutData.len);
159     EXPECT_EQ(0, ret);
160     SoftBusFree(encryptOutData.data);
161     SoftBusFree(decryptOutData.data);
162 }
163 
164 /*
165  * @tc.name: SoftBusAesCfbRootEncrypt002
166  * @tc.desc: encrypt parameter is nullptr
167  * @tc.type: FUNC
168  * @tc.require: I5OHDE
169  */
170 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbRootEncrypt002, TestSize.Level0)
171 {
172     uint32_t randLen = 8;
173     uint32_t inDataLen = 10;
174     uint32_t rootKeyLen = 16;
175     uint8_t randStr[randLen];
176     uint8_t inData[inDataLen];
177     uint8_t rKey[rootKeyLen];
178     AesOutputData encryptOutData = { 0 };
179     AesOutputData decryptOutData = { 0 };
180 
181     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
182     EXPECT_EQ(SOFTBUS_OK, ret);
183     ret = SoftBusGenerateRandomArray(randStr, randLen);
184     EXPECT_EQ(SOFTBUS_OK, ret);
185     ret = SoftBusGenerateRandomArray(rKey, rootKeyLen);
186     EXPECT_EQ(SOFTBUS_OK, ret);
187     AesInputData encryptInData = { inData, inDataLen };
188     EncryptKey randomKey = { randStr, randLen };
189     EncryptKey rootKey = { rKey, rootKeyLen };
190 
191     ret = SoftBusAesCfbRootEncrypt(nullptr, &randomKey, &rootKey, ENCRYPT_MODE, &encryptOutData);
192     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
193     ret = SoftBusAesCfbRootEncrypt(
194         (const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
195     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
196 
197     ret = SoftBusAesCfbRootEncrypt(&encryptInData, nullptr, &rootKey, ENCRYPT_MODE, &encryptOutData);
198     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
199     ret = SoftBusAesCfbRootEncrypt(
200         (const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
201     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
202 
203     ret = SoftBusAesCfbRootEncrypt(&encryptInData, &randomKey, nullptr, ENCRYPT_MODE, &encryptOutData);
204     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
205     ret = SoftBusAesCfbRootEncrypt(
206         (const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
207     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
208 
209     ret = SoftBusAesCfbRootEncrypt(&encryptInData, &randomKey, &rootKey, ENCRYPT_MODE, nullptr);
210     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
211     ret = SoftBusAesCfbRootEncrypt(
212         (const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
213     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
214 }
215 
216 /*
217  * @tc.name: SoftBusAesCfbRootEncrypt003
218  * @tc.desc: decrypt parameter is nullptr
219  * @tc.type: FUNC
220  * @tc.require: I5OHDE
221  */
222 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbRootEncrypt003, TestSize.Level0)
223 {
224     uint32_t randLen = 8;
225     uint32_t inDataLen = 10;
226     uint32_t rootKeyLen = 16;
227     uint8_t randStr[randLen];
228     uint8_t inData[inDataLen];
229     uint8_t rKey[rootKeyLen];
230     AesOutputData encryptOutData = { 0 };
231     AesOutputData decryptOutData = { 0 };
232 
233     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
234     EXPECT_EQ(SOFTBUS_OK, ret);
235     ret = SoftBusGenerateRandomArray(randStr, randLen);
236     EXPECT_EQ(SOFTBUS_OK, ret);
237     ret = SoftBusGenerateRandomArray(rKey, rootKeyLen);
238     EXPECT_EQ(SOFTBUS_OK, ret);
239     AesInputData encryptInData = { inData, inDataLen };
240     EncryptKey randomKey = { randStr, randLen };
241     EncryptKey rootKey = { rKey, rootKeyLen };
242 
243     ret = SoftBusAesCfbRootEncrypt(&encryptInData, &randomKey, &rootKey, ENCRYPT_MODE, &encryptOutData);
244     EXPECT_EQ(SOFTBUS_OK, ret);
245 
246     ret = SoftBusAesCfbRootEncrypt(nullptr, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
247     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
248     ret = SoftBusAesCfbRootEncrypt(
249         (const AesInputData *)&encryptOutData, nullptr, &rootKey, DECRYPT_MODE, &decryptOutData);
250     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
251     ret = SoftBusAesCfbRootEncrypt(
252         (const AesInputData *)&encryptOutData, &randomKey, nullptr, DECRYPT_MODE, &decryptOutData);
253     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
254     ret = SoftBusAesCfbRootEncrypt((const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, nullptr);
255     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
256 
257     SoftBusFree(encryptOutData.data);
258 }
259 
260 /*
261  * @tc.name: SoftBusAesCfbRootEncrypt004
262  * @tc.desc: encMode is illegal
263  * @tc.type: FUNC
264  * @tc.require: I5OHDE
265  */
266 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbRootEncrypt004, TestSize.Level0)
267 {
268     uint32_t randLen = 8;
269     uint32_t inDataLen = 10;
270     uint32_t rootKeyLen = 16;
271     int32_t encMode = 2;
272     uint8_t randStr[randLen];
273     uint8_t inData[inDataLen];
274     uint8_t rKey[rootKeyLen];
275     AesOutputData encryptOutData = { 0 };
276     AesOutputData decryptOutData = { 0 };
277 
278     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
279     EXPECT_EQ(SOFTBUS_OK, ret);
280     ret = SoftBusGenerateRandomArray(randStr, randLen);
281     EXPECT_EQ(SOFTBUS_OK, ret);
282     ret = SoftBusGenerateRandomArray(rKey, rootKeyLen);
283     EXPECT_EQ(SOFTBUS_OK, ret);
284     AesInputData encryptInData = { inData, inDataLen };
285     EncryptKey randomKey = { randStr, randLen };
286     EncryptKey rootKey = { rKey, rootKeyLen };
287 
288     ret = SoftBusAesCfbRootEncrypt(&encryptInData, &randomKey, &rootKey, encMode, &encryptOutData);
289     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
290     ret = SoftBusAesCfbRootEncrypt(
291         (const AesInputData *)&encryptOutData, &randomKey, &rootKey, DECRYPT_MODE, &decryptOutData);
292     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
293 
294     ret = SoftBusAesCfbRootEncrypt(&encryptInData, &randomKey, &rootKey, ENCRYPT_MODE, &encryptOutData);
295     EXPECT_EQ(SOFTBUS_OK, ret);
296     ret =
297         SoftBusAesCfbRootEncrypt((const AesInputData *)&encryptOutData, &randomKey, &rootKey, encMode, &decryptOutData);
298     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
299     SoftBusFree(encryptOutData.data);
300 }
301 
302 /*
303  * @tc.name: SoftBusAesGcmEncrypt001
304  * @tc.desc: parameters are Legal
305  * @tc.type: FUNC
306  * @tc.require: I5OHDE
307  */
308 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesGcmEncrypt001, TestSize.Level0)
309 {
310     uint32_t randKeyLen = 32;
311     uint32_t randIvLen = 16;
312     uint32_t inDataLen = 10;
313     uint8_t randSession[randKeyLen];
314     uint8_t randIv[randIvLen];
315     uint8_t inData[inDataLen];
316     AesOutputData encryptOutData = { 0 };
317     AesOutputData decryptOutData = { 0 };
318 
319     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
320     EXPECT_EQ(SOFTBUS_OK, ret);
321     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
322     EXPECT_EQ(SOFTBUS_OK, ret);
323     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
324     EXPECT_EQ(SOFTBUS_OK, ret);
325     AesInputData encryptInData = { inData, inDataLen };
326     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
327 
328     ret = SoftBusAesGcmEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, &encryptOutData);
329     EXPECT_EQ(SOFTBUS_OK, ret);
330     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, DECRYPT_MODE, &decryptOutData);
331     EXPECT_EQ(SOFTBUS_OK, ret);
332 
333     ret = memcmp((const char *)decryptOutData.data, (const char *)encryptInData.data, decryptOutData.len);
334     EXPECT_EQ(0, ret);
335     SoftBusFree(encryptOutData.data);
336     SoftBusFree(decryptOutData.data);
337 }
338 
339 /*
340  * @tc.name: SoftBusAesGcmEncrypt002
341  * @tc.desc: encrypt parameter is nullptr
342  * @tc.type: FUNC
343  * @tc.require: I5OHDE
344  */
345 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesGcmEncrypt002, TestSize.Level0)
346 {
347     uint32_t randKeyLen = 32;
348     uint32_t randIvLen = 16;
349     uint32_t inDataLen = 10;
350     uint8_t randSession[randKeyLen];
351     uint8_t randIv[randIvLen];
352     uint8_t inData[inDataLen];
353     AesOutputData encryptOutData = { 0 };
354     AesOutputData decryptOutData = { 0 };
355 
356     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
357     EXPECT_EQ(SOFTBUS_OK, ret);
358     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
359     EXPECT_EQ(SOFTBUS_OK, ret);
360     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
361     EXPECT_EQ(SOFTBUS_OK, ret);
362     AesInputData encryptInData = { inData, inDataLen };
363     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
364 
365     ret = SoftBusAesGcmEncrypt(nullptr, &cipherKey, ENCRYPT_MODE, &encryptOutData);
366     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
367     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, DECRYPT_MODE, &decryptOutData);
368     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
369 
370     ret = SoftBusAesGcmEncrypt(&encryptInData, nullptr, ENCRYPT_MODE, &encryptOutData);
371     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
372     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, DECRYPT_MODE, &decryptOutData);
373     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
374 
375     ret = SoftBusAesGcmEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, nullptr);
376     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
377     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, DECRYPT_MODE, &decryptOutData);
378     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
379 }
380 
381 /*
382  * @tc.name: SoftBusAesGcmEncrypt003
383  * @tc.desc: decrypt parameter is nullptr
384  * @tc.type: FUNC
385  * @tc.require: I5OHDE
386  */
387 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesGcmEncrypt003, TestSize.Level0)
388 {
389     uint32_t randKeyLen = 32;
390     uint32_t randIvLen = 16;
391     uint32_t inDataLen = 10;
392     uint8_t randSession[randKeyLen];
393     uint8_t randIv[randIvLen];
394     uint8_t inData[inDataLen];
395     AesOutputData encryptOutData = { 0 };
396     AesOutputData decryptOutData = { 0 };
397 
398     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
399     EXPECT_EQ(SOFTBUS_OK, ret);
400     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
401     EXPECT_EQ(SOFTBUS_OK, ret);
402     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
403     EXPECT_EQ(SOFTBUS_OK, ret);
404     AesInputData encryptInData = { inData, inDataLen };
405     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
406 
407     ret = SoftBusAesGcmEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, &encryptOutData);
408     EXPECT_EQ(SOFTBUS_OK, ret);
409 
410     ret = SoftBusAesGcmEncrypt(nullptr, &cipherKey, DECRYPT_MODE, &decryptOutData);
411     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
412     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, nullptr, DECRYPT_MODE, &decryptOutData);
413     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
414     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, DECRYPT_MODE, nullptr);
415     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
416 
417     SoftBusFree(encryptOutData.data);
418 }
419 
420 /*
421  * @tc.name: SoftBusAesGcmEncrypt004
422  * @tc.desc: decrypt parameter is nullptr
423  * @tc.type: FUNC
424  * @tc.require: I5OHDE
425  */
426 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesGcmEncrypt004, TestSize.Level0)
427 {
428     uint32_t randKeyLen = 32;
429     uint32_t randIvLen = 16;
430     uint32_t inDataLen = 10;
431     int32_t encMode = 2;
432     uint8_t randSession[randKeyLen];
433     uint8_t randIv[randIvLen];
434     uint8_t inData[inDataLen];
435     AesOutputData encryptOutData = { 0 };
436     AesOutputData decryptOutData = { 0 };
437 
438     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
439     EXPECT_EQ(SOFTBUS_OK, ret);
440     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
441     EXPECT_EQ(SOFTBUS_OK, ret);
442     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
443     EXPECT_EQ(SOFTBUS_OK, ret);
444     AesInputData encryptInData = { inData, inDataLen };
445     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
446 
447     ret = SoftBusAesGcmEncrypt(&encryptInData, &cipherKey, encMode, &encryptOutData);
448     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
449     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, DECRYPT_MODE, &decryptOutData);
450     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
451 
452     ret = SoftBusAesGcmEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, &encryptOutData);
453     EXPECT_EQ(SOFTBUS_OK, ret);
454     ret = SoftBusAesGcmEncrypt((const AesInputData *)&encryptOutData, &cipherKey, encMode, &decryptOutData);
455     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
456 
457     SoftBusFree(encryptOutData.data);
458 }
459 
460 /*
461 * @tc.name: SoftBusAesCfbEncrypt001
462 * @tc.desc: parameters are Legal
463 * @tc.type: FUNC
464 * @tc.require: I5OHDE
465 */
466 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbEncrypt001, TestSize.Level0)
467 {
468     uint32_t randKeyLen = 32;
469     uint32_t randIvLen = 16;
470     uint32_t inDataLen = 10;
471     uint8_t inData[inDataLen];
472     uint8_t randSession[randKeyLen];
473     uint8_t randIv[randIvLen];
474     AesOutputData encryptOutData = { 0 };
475     AesOutputData decryptOutData = { 0 };
476 
477     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
478     EXPECT_EQ(SOFTBUS_OK, ret);
479     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
480     EXPECT_EQ(SOFTBUS_OK, ret);
481     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
482     EXPECT_EQ(SOFTBUS_OK, ret);
483     AesInputData encryptInData = { inData, inDataLen };
484     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
485 
486     uint8_t randSession1[randKeyLen];
487     (void)memcpy_s(randSession1, randKeyLen, randSession, randKeyLen);
488     uint8_t randIv1[randIvLen];
489     (void)memcpy_s(randIv1, randIvLen, randIv, randIvLen);
490 
491     ret = SoftBusAesCfbEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, &encryptOutData);
492     EXPECT_EQ(SOFTBUS_OK, ret);
493 
494     AesCipherKey cipherKey1 = { randSession1, randKeyLen, randIv1, randIvLen };
495     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, DECRYPT_MODE, &decryptOutData);
496     EXPECT_EQ(SOFTBUS_OK, ret);
497 
498     ret = memcmp((const char *)decryptOutData.data, (const char *)encryptInData.data, decryptOutData.len);
499     EXPECT_EQ(0, ret);
500     SoftBusFree(encryptOutData.data);
501     SoftBusFree(decryptOutData.data);
502 }
503 
504 /*
505 * @tc.name: SoftBusAesCfbEncrypt002
506 * @tc.desc: encrypt parameter is nullptr
507 * @tc.require: I5OHDE
508 */
509 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbEncrypt002, TestSize.Level0)
510 {
511     uint32_t randKeyLen = 32;
512     uint32_t randIvLen = 16;
513     uint32_t inDataLen = 10;
514     uint8_t inData[inDataLen];
515     uint8_t randSession[randKeyLen];
516     uint8_t randIv[randIvLen];
517     AesOutputData encryptOutData = { 0 };
518     AesOutputData decryptOutData = { 0 };
519 
520     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
521     EXPECT_EQ(SOFTBUS_OK, ret);
522     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
523     EXPECT_EQ(SOFTBUS_OK, ret);
524     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
525     EXPECT_EQ(SOFTBUS_OK, ret);
526     AesInputData encryptInData = { inData, inDataLen };
527     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
528 
529     uint8_t randSession1[randKeyLen];
530     (void)memcpy_s(randSession1, randKeyLen, randSession, randKeyLen);
531     uint8_t randIv1[randIvLen];
532     (void)memcpy_s(randIv1, randIvLen, randIv, randIvLen);
533     AesCipherKey cipherKey1 = { randSession1, randKeyLen, randIv1, randIvLen };
534 
535     ret = SoftBusAesCfbEncrypt(nullptr, &cipherKey, ENCRYPT_MODE, &encryptOutData);
536     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
537     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, DECRYPT_MODE, &decryptOutData);
538     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
539 
540     ret = SoftBusAesCfbEncrypt(&encryptInData, nullptr, ENCRYPT_MODE, &encryptOutData);
541     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
542     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, DECRYPT_MODE, &decryptOutData);
543     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
544 
545     ret = SoftBusAesCfbEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, nullptr);
546     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
547     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, DECRYPT_MODE, &decryptOutData);
548     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
549 }
550 
551 /*
552 * @tc.name: SoftBusAesCfbEncrypt003
553 * @tc.desc: decrypt parameter is nullptr
554 * @tc.type: FUNC
555 * @tc.require: I5OHDE
556 */
557 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbEncrypt003, TestSize.Level0)
558 {
559     uint32_t randKeyLen = 32;
560     uint32_t randIvLen = 16;
561     uint32_t inDataLen = 10;
562     uint8_t inData[inDataLen];
563     uint8_t randSession[randKeyLen];
564     uint8_t randIv[randIvLen];
565     AesOutputData encryptOutData = { 0 };
566     AesOutputData decryptOutData = { 0 };
567 
568     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
569     EXPECT_EQ(SOFTBUS_OK, ret);
570     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
571     EXPECT_EQ(SOFTBUS_OK, ret);
572     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
573     EXPECT_EQ(SOFTBUS_OK, ret);
574     AesInputData encryptInData = { inData, inDataLen };
575     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
576 
577     uint8_t randSession1[randKeyLen];
578     (void)memcpy_s(randSession1, randKeyLen, randSession, randKeyLen);
579     uint8_t randIv1[randIvLen];
580     (void)memcpy_s(randIv1, randIvLen, randIv, randIvLen);
581     AesCipherKey cipherKey1 = { randSession1, randKeyLen, randIv1, randIvLen };
582 
583     ret = SoftBusAesCfbEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, &encryptOutData);
584     EXPECT_EQ(SOFTBUS_OK, ret);
585 
586     ret = SoftBusAesCfbEncrypt(nullptr, &cipherKey1, DECRYPT_MODE, &decryptOutData);
587     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
588     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, nullptr, DECRYPT_MODE, &decryptOutData);
589     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
590     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, DECRYPT_MODE, nullptr);
591     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
592 
593     SoftBusFree(encryptOutData.data);
594 }
595 
596 /*
597 * @tc.name: SoftBusAesCfbEncrypt004
598 * @tc.desc: encMode is illegal
599 * @tc.type: FUNC
600 * @tc.require: I5OHDE
601 */
602 HWTEST_F(AdapterDsoftbusAesCryptoTest, SoftBusAesCfbEncrypt004, TestSize.Level0)
603 {
604     uint32_t randKeyLen = 32;
605     uint32_t randIvLen = 16;
606     uint32_t inDataLen = 10;
607     int32_t encMode = 2;
608     uint8_t inData[inDataLen];
609     uint8_t randSession[randKeyLen];
610     uint8_t randIv[randIvLen];
611     AesOutputData encryptOutData = { 0 };
612     AesOutputData decryptOutData = { 0 };
613 
614     int32_t ret = SoftBusGenerateRandomArray(inData, inDataLen);
615     EXPECT_EQ(SOFTBUS_OK, ret);
616     ret = SoftBusGenerateRandomArray(randSession, randKeyLen);
617     EXPECT_EQ(SOFTBUS_OK, ret);
618     ret = SoftBusGenerateRandomArray(randIv, randIvLen);
619     EXPECT_EQ(SOFTBUS_OK, ret);
620     AesInputData encryptInData = { inData, inDataLen };
621     AesCipherKey cipherKey = { randSession, randKeyLen, randIv, randIvLen };
622 
623     uint8_t randSession1[randKeyLen];
624     (void)memcpy_s(randSession1, randKeyLen, randSession, randKeyLen);
625     uint8_t randIv1[randIvLen];
626     (void)memcpy_s(randIv1, randIvLen, randIv, randIvLen);
627     AesCipherKey cipherKey1 = { randSession1, randKeyLen, randIv1, randIvLen };
628 
629     ret = SoftBusAesCfbEncrypt(&encryptInData, &cipherKey, encMode, &encryptOutData);
630     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
631     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, DECRYPT_MODE, &decryptOutData);
632     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
633 
634     ret = SoftBusAesCfbEncrypt(&encryptInData, &cipherKey, ENCRYPT_MODE, &encryptOutData);
635     EXPECT_EQ(SOFTBUS_OK, ret);
636     ret = SoftBusAesCfbEncrypt((const AesInputData *)&encryptOutData, &cipherKey1, encMode, &decryptOutData);
637     EXPECT_EQ(SOFTBUS_INVALID_PARAM, ret);
638 
639     SoftBusFree(encryptOutData.data);
640 }
641 } // namespace OHOS
642 
643