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
26using namespace std;
27using namespace testing::ext;
28
29namespace OHOS {
30class AdapterDsoftbusAesCryptoTest : public testing::Test {
31protected:
32    static void SetUpTestCase(void);
33    static void TearDownTestCase(void);
34    void SetUp();
35    void TearDown();
36};
37void AdapterDsoftbusAesCryptoTest::SetUpTestCase(void) { }
38void AdapterDsoftbusAesCryptoTest::TearDownTestCase(void) { }
39void AdapterDsoftbusAesCryptoTest::SetUp() { }
40void AdapterDsoftbusAesCryptoTest::TearDown() { }
41
42/*
43 * @tc.name: SoftBusGenerateHmacHash001
44 * @tc.desc: parameters are Legal
45 * @tc.type: FUNC
46 * @tc.require: I5OHDE
47 */
48HWTEST_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 */
73HWTEST_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 */
102HWTEST_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 */
131HWTEST_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 */
170HWTEST_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 */
222HWTEST_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 */
266HWTEST_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 */
308HWTEST_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 */
345HWTEST_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 */
387HWTEST_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 */
426HWTEST_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*/
466HWTEST_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*/
509HWTEST_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*/
557HWTEST_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*/
602HWTEST_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