1 /*
2  * Copyright (c) 2022 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_adapter_crypto.h"
17 
18 #include <securec.h>
19 
20 #include <openssl/evp.h>
21 #include <openssl/rand.h>
22 
23 #include "comm_log.h"
24 #include "softbus_adapter_file.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_errcode.h"
27 
28 static SoftBusMutex g_randomLock;
29 
30 #define OPENSSL_EVP_PADDING_FUNC_OPEN  (1)
31 #define OPENSSL_EVP_PADDING_FUNC_CLOSE (0)
32 
33 #define EVP_AES_128_KEYLEN 16
34 #define EVP_AES_256_KEYLEN 32
35 
GetGcmAlgorithmByKeyLen(uint32_t keyLen)36 static EVP_CIPHER *GetGcmAlgorithmByKeyLen(uint32_t keyLen)
37 {
38     switch (keyLen) {
39         case EVP_AES_128_KEYLEN:
40             return (EVP_CIPHER *)EVP_aes_128_gcm();
41         case EVP_AES_256_KEYLEN:
42             return (EVP_CIPHER *)EVP_aes_256_gcm();
43         default:
44             return NULL;
45     }
46     return NULL;
47 }
48 
GetCtrAlgorithmByKeyLen(uint32_t keyLen)49 static EVP_CIPHER *GetCtrAlgorithmByKeyLen(uint32_t keyLen)
50 {
51     switch (keyLen) {
52         case EVP_AES_128_KEYLEN:
53             return (EVP_CIPHER *)EVP_aes_128_ctr();
54         case EVP_AES_256_KEYLEN:
55             return (EVP_CIPHER *)EVP_aes_256_ctr();
56         default:
57             return NULL;
58     }
59     return NULL;
60 }
61 
OpensslEvpInit(EVP_CIPHER_CTX **ctx, const AesGcmCipherKey *cipherkey, bool mode)62 static int32_t OpensslEvpInit(EVP_CIPHER_CTX **ctx, const AesGcmCipherKey *cipherkey, bool mode)
63 {
64     if (cipherkey == NULL) {
65         COMM_LOGE(COMM_ADAPTER, "Encrypt invalid para.");
66         return SOFTBUS_INVALID_PARAM;
67     }
68     EVP_CIPHER *cipher = GetGcmAlgorithmByKeyLen(cipherkey->keyLen);
69     if (cipher == NULL) {
70         COMM_LOGE(COMM_ADAPTER, "get cipher fail.");
71         return SOFTBUS_DECRYPT_ERR;
72     }
73     int32_t ret;
74     *ctx = EVP_CIPHER_CTX_new();
75     if (*ctx == NULL) {
76         return SOFTBUS_DECRYPT_ERR;
77     }
78     EVP_CIPHER_CTX_set_padding(*ctx, OPENSSL_EVP_PADDING_FUNC_OPEN);
79     if (mode == true) {
80         ret = EVP_EncryptInit_ex(*ctx, cipher, NULL, NULL, NULL);
81         if (ret != 1) {
82             COMM_LOGE(COMM_ADAPTER, "EVP_EncryptInit_ex fail.");
83             EVP_CIPHER_CTX_free(*ctx);
84             return SOFTBUS_DECRYPT_ERR;
85         }
86     } else {
87         ret = EVP_DecryptInit_ex(*ctx, cipher, NULL, NULL, NULL);
88         if (ret != 1) {
89             COMM_LOGE(COMM_ADAPTER, "EVP_DecryptInit_ex fail.");
90             EVP_CIPHER_CTX_free(*ctx);
91             return SOFTBUS_DECRYPT_ERR;
92         }
93     }
94     ret = EVP_CIPHER_CTX_ctrl(*ctx, EVP_CTRL_GCM_SET_IVLEN, GCM_IV_LEN, NULL);
95     if (ret != 1) {
96         COMM_LOGE(COMM_ADAPTER, "Set iv len fail.");
97         EVP_CIPHER_CTX_free(*ctx);
98         return SOFTBUS_DECRYPT_ERR;
99     }
100     return SOFTBUS_OK;
101 }
102 
PackIvAndTag(EVP_CIPHER_CTX *ctx, const AesGcmCipherKey *cipherkey, uint32_t dataLen, unsigned char *cipherText, uint32_t cipherTextLen)103 static int32_t PackIvAndTag(EVP_CIPHER_CTX *ctx, const AesGcmCipherKey *cipherkey, uint32_t dataLen,
104     unsigned char *cipherText, uint32_t cipherTextLen)
105 {
106     if ((dataLen + OVERHEAD_LEN) > cipherTextLen) {
107         COMM_LOGE(COMM_ADAPTER, "Encrypt invalid para.");
108         return SOFTBUS_ENCRYPT_ERR;
109     }
110     if (memcpy_s(cipherText, cipherTextLen - dataLen, cipherkey->iv, GCM_IV_LEN) != EOK) {
111         COMM_LOGE(COMM_ADAPTER, "EVP memcpy iv fail.");
112         return SOFTBUS_ENCRYPT_ERR;
113     }
114     char tagbuf[TAG_LEN];
115     int ret = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, TAG_LEN, (void *)tagbuf);
116     if (ret != 1) {
117         COMM_LOGE(COMM_ADAPTER, "EVP_CIPHER_CTX_ctrl fail.");
118         return SOFTBUS_DECRYPT_ERR;
119     }
120     if (memcpy_s(cipherText + dataLen + GCM_IV_LEN, cipherTextLen - dataLen - GCM_IV_LEN, tagbuf, TAG_LEN) != EOK) {
121         COMM_LOGE(COMM_ADAPTER, "EVP memcpy tag fail.");
122         return SOFTBUS_ENCRYPT_ERR;
123     }
124     return SOFTBUS_OK;
125 }
126 
SslAesGcmEncrypt(const AesGcmCipherKey *cipherkey, const unsigned char *plainText, uint32_t plainTextSize, unsigned char *cipherText, uint32_t cipherTextLen)127 static int32_t SslAesGcmEncrypt(const AesGcmCipherKey *cipherkey, const unsigned char *plainText,
128     uint32_t plainTextSize, unsigned char *cipherText, uint32_t cipherTextLen)
129 {
130     if ((cipherkey == NULL) || (plainText == NULL) || (plainTextSize == 0) || cipherText == NULL ||
131         (cipherTextLen < plainTextSize + OVERHEAD_LEN)) {
132         COMM_LOGE(COMM_ADAPTER, "Encrypt invalid para.");
133         return SOFTBUS_INVALID_PARAM;
134     }
135 
136     int32_t outlen = 0;
137     int32_t outbufLen;
138     EVP_CIPHER_CTX *ctx = NULL;
139     int32_t ret = OpensslEvpInit(&ctx, cipherkey, true);
140     if (ret != SOFTBUS_OK) {
141         COMM_LOGE(COMM_ADAPTER, "OpensslEvpInit fail.");
142         return SOFTBUS_DECRYPT_ERR;
143     }
144     ret = EVP_EncryptInit_ex(ctx, NULL, NULL, cipherkey->key, cipherkey->iv);
145     if (ret != 1) {
146         COMM_LOGE(COMM_ADAPTER, "EVP_EncryptInit_ex fail.");
147         EVP_CIPHER_CTX_free(ctx);
148         return SOFTBUS_DECRYPT_ERR;
149     }
150     ret = EVP_EncryptUpdate(ctx, cipherText + GCM_IV_LEN, (int32_t *)&outbufLen, plainText, plainTextSize);
151     if (ret != 1) {
152         COMM_LOGE(COMM_ADAPTER, "EVP_EncryptUpdate fail.");
153         EVP_CIPHER_CTX_free(ctx);
154         return SOFTBUS_DECRYPT_ERR;
155     }
156     outlen += outbufLen;
157     ret = EVP_EncryptFinal_ex(ctx, cipherText + GCM_IV_LEN + outbufLen, (int32_t *)&outbufLen);
158     if (ret != 1) {
159         COMM_LOGE(COMM_ADAPTER, "EVP_EncryptFinal_ex fail.");
160         EVP_CIPHER_CTX_free(ctx);
161         return SOFTBUS_DECRYPT_ERR;
162     }
163     outlen += outbufLen;
164     ret = PackIvAndTag(ctx, cipherkey, outlen, cipherText, cipherTextLen);
165     if (ret != SOFTBUS_OK) {
166         COMM_LOGE(COMM_ADAPTER, "pack iv and tag fail.");
167         EVP_CIPHER_CTX_free(ctx);
168         return SOFTBUS_DECRYPT_ERR;
169     }
170     EVP_CIPHER_CTX_free(ctx);
171     return (outlen + OVERHEAD_LEN);
172 }
173 
SslAesGcmDecrypt(const AesGcmCipherKey *cipherkey, const unsigned char *cipherText, uint32_t cipherTextSize, unsigned char *plain, uint32_t plainLen)174 static int32_t SslAesGcmDecrypt(const AesGcmCipherKey *cipherkey, const unsigned char *cipherText,
175     uint32_t cipherTextSize, unsigned char *plain, uint32_t plainLen)
176 {
177     if ((cipherkey == NULL) || (cipherText == NULL) || (cipherTextSize <= OVERHEAD_LEN) || plain == NULL ||
178         (plainLen < cipherTextSize - OVERHEAD_LEN)) {
179         COMM_LOGE(COMM_ADAPTER, "Decrypt invalid para.");
180         return SOFTBUS_INVALID_PARAM;
181     }
182 
183     int32_t outLen = 0;
184     EVP_CIPHER_CTX *ctx = NULL;
185     int32_t ret = OpensslEvpInit(&ctx, cipherkey, false);
186     if (ret != SOFTBUS_OK) {
187         COMM_LOGE(COMM_ADAPTER, "OpensslEvpInit fail.");
188         return SOFTBUS_DECRYPT_ERR;
189     }
190     ret = EVP_DecryptInit_ex(ctx, NULL, NULL, cipherkey->key, cipherkey->iv);
191     if (ret != 1) {
192         COMM_LOGE(COMM_ADAPTER, "EVP_EncryptInit_ex fail.");
193         goto EXIT;
194     }
195     ret = EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, TAG_LEN, (void *)(cipherText + (cipherTextSize - TAG_LEN)));
196     if (ret != 1) {
197         COMM_LOGE(COMM_ADAPTER, "EVP_DecryptUpdate fail.");
198         goto EXIT;
199     }
200     ret = EVP_DecryptUpdate(ctx, plain, (int32_t *)&plainLen, cipherText + GCM_IV_LEN, cipherTextSize - OVERHEAD_LEN);
201     if (ret != 1) {
202         COMM_LOGE(COMM_ADAPTER, "EVP_DecryptUpdate fail.");
203         goto EXIT;
204     }
205     if (plainLen > INT32_MAX) {
206         COMM_LOGE(COMM_ADAPTER, "PlainLen convert overflow.");
207         goto EXIT;
208     }
209     outLen += (int32_t)plainLen;
210     ret = EVP_DecryptFinal_ex(ctx, plain + plainLen, (int32_t *)&plainLen);
211     if (ret != 1) {
212         COMM_LOGE(COMM_ADAPTER, "EVP_DecryptFinal_ex fail.");
213         goto EXIT;
214     }
215     if ((int32_t)plainLen > INT32_MAX - outLen) {
216         COMM_LOGE(COMM_ADAPTER, "outLen convert overflow.");
217         goto EXIT;
218     }
219     outLen += (int32_t)plainLen;
220     EVP_CIPHER_CTX_free(ctx);
221     return outLen;
222 EXIT:
223     EVP_CIPHER_CTX_free(ctx);
224     return SOFTBUS_DECRYPT_ERR;
225 }
226 
HandleError(EVP_CIPHER_CTX *ctx, const char *buf)227 static int32_t HandleError(EVP_CIPHER_CTX *ctx, const char *buf)
228 {
229     if (buf != NULL) {
230         COMM_LOGE(COMM_ADAPTER, "buf=%{public}s", buf);
231     }
232     if (ctx != NULL) {
233         EVP_CIPHER_CTX_free(ctx);
234     }
235     return SOFTBUS_DECRYPT_ERR;
236 }
237 
SoftBusBase64Encode(unsigned char *dst, size_t dlen, size_t *olen, const unsigned char *src, size_t slen)238 int32_t SoftBusBase64Encode(unsigned char *dst, size_t dlen, size_t *olen, const unsigned char *src, size_t slen)
239 {
240     if (dst == NULL || dlen == 0 || olen == NULL || src == NULL || slen == 0) {
241         return SOFTBUS_INVALID_PARAM;
242     }
243     *olen = 0;
244     int32_t outlen;
245     EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();
246     if (ctx == NULL) {
247         return SOFTBUS_DECRYPT_ERR;
248     }
249     unsigned char *dstTmp = SoftBusCalloc(EVP_ENCODE_LENGTH(slen));
250     if (dstTmp == NULL) {
251         COMM_LOGE(COMM_ADAPTER, "[TRANS] SoftBusCalloc fail.");
252         EVP_ENCODE_CTX_free(ctx);
253         return SOFTBUS_MEM_ERR;
254     }
255     EVP_EncodeInit(ctx);
256     int32_t ret = EVP_EncodeUpdate(ctx, dstTmp, &outlen, src, slen);
257     if (ret != 1) {
258         COMM_LOGE(COMM_ADAPTER, "[TRANS] EVP_EncodeUpdate fail.");
259         EVP_ENCODE_CTX_free(ctx);
260         SoftBusFree(dstTmp);
261         return SOFTBUS_DECRYPT_ERR;
262     }
263     *olen += outlen;
264     EVP_EncodeFinal(ctx, dstTmp + outlen, &outlen);
265     *olen += outlen;
266 
267     if (*olen > dlen) {
268         COMM_LOGE(COMM_ADAPTER, "[TRANS] invalid dlen=%{public}zu, olen=%{public}zu.", dlen, *olen);
269         EVP_ENCODE_CTX_free(ctx);
270         SoftBusFree(dstTmp);
271         return SOFTBUS_INVALID_PARAM;
272     }
273 
274     ret = memcpy_s(dst, dlen, dstTmp, *olen);
275     if (ret != EOK) {
276         COMM_LOGE(COMM_ADAPTER, "[TRANS] memcpy_s failed.");
277         EVP_ENCODE_CTX_free(ctx);
278         SoftBusFree(dstTmp);
279         return SOFTBUS_MEM_ERR;
280     }
281     if ((*olen > 0) && (dst[*olen - 1] == '\n')) {
282         (*olen)--;
283         dst[*olen] = 0;
284     }
285 
286     EVP_ENCODE_CTX_free(ctx);
287     SoftBusFree(dstTmp);
288     return SOFTBUS_OK;
289 }
290 
SoftBusBase64Decode(unsigned char *dst, size_t dlen, size_t *olen, const unsigned char *src, size_t slen)291 int32_t SoftBusBase64Decode(unsigned char *dst, size_t dlen, size_t *olen, const unsigned char *src, size_t slen)
292 {
293     if (dst == NULL || dlen == 0 || olen == NULL || src == NULL || slen == 0) {
294         return SOFTBUS_INVALID_PARAM;
295     }
296     *olen = 0;
297     int32_t outlen;
298     EVP_ENCODE_CTX *ctx = EVP_ENCODE_CTX_new();
299     if (ctx == NULL) {
300         return SOFTBUS_DECRYPT_ERR;
301     }
302     unsigned char *dstTmp = SoftBusCalloc(EVP_DECODE_LENGTH(slen));
303     if (dstTmp == NULL) {
304         COMM_LOGE(COMM_ADAPTER, "[TRANS] SoftBusCalloc fail.");
305         EVP_ENCODE_CTX_free(ctx);
306         return SOFTBUS_MEM_ERR;
307     }
308     EVP_DecodeInit(ctx);
309     int32_t ret = EVP_DecodeUpdate(ctx, dstTmp, &outlen, src, slen);
310     if (ret == -1) {
311         COMM_LOGE(COMM_ADAPTER, "[TRANS] EVP_DecodeUpdate fail.");
312         ret = SOFTBUS_DECRYPT_ERR;
313         goto FINISHED;
314     }
315     *olen += outlen;
316     ret = EVP_DecodeFinal(ctx, dstTmp + outlen, &outlen);
317     if (ret != 1) {
318         COMM_LOGE(COMM_ADAPTER, "[TRANS] EVP_DecodeFinal fail.");
319         ret = SOFTBUS_DECRYPT_ERR;
320         goto FINISHED;
321     }
322     *olen += outlen;
323     if (*olen > dlen) {
324         COMM_LOGE(COMM_ADAPTER, "[TRANS] invalid dlen=%{public}zu, olen=%{public}zu.", dlen, *olen);
325         ret = SOFTBUS_INVALID_PARAM;
326         goto FINISHED;
327     }
328 
329     ret = memcpy_s(dst, dlen, dstTmp, *olen);
330     if (ret != EOK) {
331         COMM_LOGE(COMM_ADAPTER, "[TRANS] memcpy_s failed.");
332         ret = SOFTBUS_MEM_ERR;
333         goto FINISHED;
334     }
335     ret = SOFTBUS_OK;
336 FINISHED:
337     EVP_ENCODE_CTX_free(ctx);
338     SoftBusFree(dstTmp);
339     return ret;
340 }
341 
SoftBusGenerateStrHash(const unsigned char *str, uint32_t len, unsigned char *hash)342 int32_t SoftBusGenerateStrHash(const unsigned char *str, uint32_t len, unsigned char *hash)
343 {
344     if (str == NULL || hash == NULL || len == 0) {
345         return SOFTBUS_INVALID_PARAM;
346     }
347     uint32_t olen;
348     int32_t ret = EVP_Digest(str, len, hash, &olen, EVP_sha256(), NULL);
349     if (ret != 1) {
350         COMM_LOGE(COMM_ADAPTER, "[TRANS] Get Openssl Hash fail.");
351         return SOFTBUS_DECRYPT_ERR;
352     }
353     return SOFTBUS_OK;
354 }
355 
SoftBusGenerateRandomArray(unsigned char *randStr, uint32_t len)356 int32_t SoftBusGenerateRandomArray(unsigned char *randStr, uint32_t len)
357 {
358     if (randStr == NULL || len == 0) {
359         return SOFTBUS_INVALID_PARAM;
360     }
361 
362     static bool initFlag = false;
363     int32_t ret;
364 
365     if (SoftBusMutexInit(&g_randomLock, NULL) != SOFTBUS_OK) {
366         COMM_LOGE(COMM_ADAPTER, "init mutex failed.");
367         return SOFTBUS_ERR;
368     }
369 
370     if (SoftBusMutexLock(&g_randomLock) != SOFTBUS_OK) {
371         COMM_LOGE(COMM_ADAPTER, "lock mutex failed");
372         return SOFTBUS_ERR;
373     }
374     if (initFlag == false) {
375         RAND_seed(randStr, (int32_t)len);
376         initFlag = true;
377     }
378 
379     ret = RAND_bytes(randStr, (int32_t)len);
380     SoftBusMutexUnlock(&g_randomLock);
381     if (ret != 1) {
382         COMM_LOGE(COMM_ADAPTER, "gen random error, ret=%{public}d", ret);
383         return SOFTBUS_ERR;
384     }
385     return SOFTBUS_OK;
386 }
387 
SoftBusGenerateSessionKey(char *key, uint32_t len)388 int32_t SoftBusGenerateSessionKey(char *key, uint32_t len)
389 {
390     if (SoftBusGenerateRandomArray((unsigned char *)key, len) != SOFTBUS_OK) {
391         COMM_LOGE(COMM_ADAPTER, "generate sessionKey error.");
392         return SOFTBUS_ENCRYPT_ERR;
393     }
394     return SOFTBUS_OK;
395 }
396 
SoftBusEncryptData(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen, unsigned char *encryptData, uint32_t *encryptLen)397 int32_t SoftBusEncryptData(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen,
398     unsigned char *encryptData, uint32_t *encryptLen)
399 {
400     if (cipherKey == NULL || input == NULL || inLen == 0 || encryptData == NULL || encryptLen == NULL) {
401         return SOFTBUS_INVALID_PARAM;
402     }
403 
404     if (SoftBusGenerateRandomArray(cipherKey->iv, sizeof(cipherKey->iv)) != SOFTBUS_OK) {
405         COMM_LOGE(COMM_ADAPTER, "generate random iv error.");
406         return SOFTBUS_ENCRYPT_ERR;
407     }
408     uint32_t outLen = inLen + OVERHEAD_LEN;
409     int32_t result = SslAesGcmEncrypt(cipherKey, input, inLen, encryptData, outLen);
410     if (result <= 0) {
411         return SOFTBUS_ENCRYPT_ERR;
412     }
413     *encryptLen = result;
414     return SOFTBUS_OK;
415 }
416 
SoftBusEncryptDataWithSeq(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen, unsigned char *encryptData, uint32_t *encryptLen, int32_t seqNum)417 int32_t SoftBusEncryptDataWithSeq(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen,
418     unsigned char *encryptData, uint32_t *encryptLen, int32_t seqNum)
419 {
420     if (cipherKey == NULL || input == NULL || inLen == 0 || encryptData == NULL || encryptLen == NULL) {
421         return SOFTBUS_INVALID_PARAM;
422     }
423     if (SoftBusGenerateRandomArray(cipherKey->iv, sizeof(cipherKey->iv)) != SOFTBUS_OK) {
424         COMM_LOGE(COMM_ADAPTER, "generate random iv error.");
425         return SOFTBUS_ENCRYPT_ERR;
426     }
427     if (memcpy_s(cipherKey->iv, sizeof(int32_t), &seqNum, sizeof(int32_t)) != EOK) {
428         return SOFTBUS_ENCRYPT_ERR;
429     }
430     uint32_t outLen = inLen + OVERHEAD_LEN;
431     int32_t result = SslAesGcmEncrypt(cipherKey, input, inLen, encryptData, outLen);
432     if (result <= 0) {
433         return SOFTBUS_ENCRYPT_ERR;
434     }
435     *encryptLen = result;
436     return SOFTBUS_OK;
437 }
438 
SoftBusDecryptData(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen, unsigned char *decryptData, uint32_t *decryptLen)439 int32_t SoftBusDecryptData(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen,
440     unsigned char *decryptData, uint32_t *decryptLen)
441 {
442     if (cipherKey == NULL || input == NULL || inLen < GCM_IV_LEN || decryptData == NULL || decryptLen == NULL) {
443         return SOFTBUS_INVALID_PARAM;
444     }
445 
446     if (memcpy_s(cipherKey->iv, sizeof(cipherKey->iv), input, GCM_IV_LEN) != EOK) {
447         COMM_LOGE(COMM_ADAPTER, "copy iv failed.");
448         return SOFTBUS_ENCRYPT_ERR;
449     }
450     uint32_t outLen = inLen - OVERHEAD_LEN;
451     int32_t result = SslAesGcmDecrypt(cipherKey, input, inLen, decryptData, outLen);
452     if (result <= 0) {
453         return SOFTBUS_ENCRYPT_ERR;
454     }
455     *decryptLen = (uint32_t)result;
456     return SOFTBUS_OK;
457 }
458 
SoftBusDecryptDataWithSeq(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen, unsigned char *decryptData, uint32_t *decryptLen, int32_t seqNum)459 int32_t SoftBusDecryptDataWithSeq(AesGcmCipherKey *cipherKey, const unsigned char *input, uint32_t inLen,
460     unsigned char *decryptData, uint32_t *decryptLen, int32_t seqNum)
461 {
462     (void)seqNum;
463     return SoftBusDecryptData(cipherKey, input, inLen, decryptData, decryptLen);
464 }
465 
SoftBusCryptoRand(void)466 uint32_t SoftBusCryptoRand(void)
467 {
468     int32_t fd = SoftBusOpenFile("/dev/urandom", SOFTBUS_O_RDONLY);
469     if (fd < 0) {
470         COMM_LOGE(COMM_ADAPTER, "CryptoRand open file fail");
471         return 0;
472     }
473     uint32_t value = 0;
474     int32_t len = SoftBusReadFile(fd, &value, sizeof(uint32_t));
475     if (len < 0) {
476         COMM_LOGE(COMM_ADAPTER, "CryptoRand read file fail");
477         SoftBusCloseFile(fd);
478         return 0;
479     }
480     SoftBusCloseFile(fd);
481     return value;
482 }
483 
SoftBusEncryptDataByCtr( AesCtrCipherKey *key, const unsigned char *input, uint32_t inLen, unsigned char *encryptData, uint32_t *encryptLen)484 int32_t SoftBusEncryptDataByCtr(
485     AesCtrCipherKey *key, const unsigned char *input, uint32_t inLen, unsigned char *encryptData, uint32_t *encryptLen)
486 {
487     if (key == NULL || input == NULL || inLen == 0 || encryptData == NULL || encryptLen == NULL) {
488         return SOFTBUS_INVALID_PARAM;
489     }
490     EVP_CIPHER_CTX *ctx = NULL;
491     int32_t len = 0;
492     *encryptLen = 0;
493     EVP_CIPHER *cipher = NULL;
494     if (!(cipher = GetCtrAlgorithmByKeyLen(key->keyLen))) {
495         return HandleError(ctx, "get cipher failed");
496     }
497     if (!(ctx = EVP_CIPHER_CTX_new())) {
498         return HandleError(ctx, "EVP_CIPHER_CTX_new ctr failed");
499     }
500     if (EVP_EncryptInit_ex(ctx, cipher, NULL, key->key, key->iv) != 1) {
501         return HandleError(ctx, "EVP_EncryptInit_ex ctr failed");
502     }
503     if (EVP_EncryptUpdate(ctx, encryptData, &len, input, inLen) != 1) {
504         return HandleError(ctx, "EVP_EncryptUpdate ctr failed");
505     }
506     *encryptLen += len;
507     if (EVP_EncryptFinal_ex(ctx, encryptData + len, &len) != 1) {
508         return HandleError(ctx, "EVP_EncryptFinal_ex ctr failed");
509     }
510     *encryptLen += len;
511     EVP_CIPHER_CTX_free(ctx);
512     return SOFTBUS_OK;
513 }
514 
SoftBusDecryptDataByCtr( AesCtrCipherKey *key, const unsigned char *input, uint32_t inLen, unsigned char *decryptData, uint32_t *decryptLen)515 int32_t SoftBusDecryptDataByCtr(
516     AesCtrCipherKey *key, const unsigned char *input, uint32_t inLen, unsigned char *decryptData, uint32_t *decryptLen)
517 {
518     if (key == NULL || input == NULL || inLen == 0 || decryptData == NULL || decryptLen == NULL) {
519         return SOFTBUS_INVALID_PARAM;
520     }
521     EVP_CIPHER_CTX *ctx = NULL;
522     int32_t len = 0;
523     *decryptLen = 0;
524     EVP_CIPHER *cipher = NULL;
525     if (!(cipher = GetCtrAlgorithmByKeyLen(key->keyLen))) {
526         return HandleError(ctx, "get cipher failed");
527     }
528     if (!(ctx = EVP_CIPHER_CTX_new())) {
529         return HandleError(ctx, "EVP_CIPHER_CTX_new ctr failed");
530     }
531     if (EVP_DecryptInit_ex(ctx, cipher, NULL, key->key, key->iv) != 1) {
532         return HandleError(ctx, "EVP_DecryptInit_ex ctr failed");
533     }
534     if (EVP_DecryptUpdate(ctx, decryptData, &len, input, inLen) != 1) {
535         return HandleError(ctx, "EVP_DecryptUpdate ctr failed");
536     }
537     *decryptLen += len;
538     if (EVP_DecryptFinal_ex(ctx, decryptData + len, &len) != 1) {
539         return HandleError(ctx, "EVP_DecryptFinal_ex ctr failed");
540     }
541     *decryptLen += len;
542     EVP_CIPHER_CTX_free(ctx);
543     return SOFTBUS_OK;
544 }
545