1 /*
2  * Copyright (c) 2021-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 "softbus_proxychannel_message.h"
17 
18 #include <securec.h>
19 #include <stdatomic.h>
20 
21 #include "auth_interface.h"
22 #include "bus_center_manager.h"
23 #include "softbus_adapter_crypto.h"
24 #include "softbus_adapter_mem.h"
25 #include "softbus_adapter_socket.h"
26 #include "softbus_def.h"
27 #include "softbus_datahead_transform.h"
28 #include "softbus_errcode.h"
29 #include "softbus_json_utils.h"
30 #include "softbus_message_open_channel.h"
31 #include "softbus_proxychannel_manager.h"
32 #include "softbus_utils.h"
33 #include "trans_log.h"
34 
35 static _Atomic int32_t g_proxyPktHeadSeq = 2048;
36 
TransProxyParseMessageHead(char * data,int32_t len,ProxyMessage * msg)37 static int32_t TransProxyParseMessageHead(char *data, int32_t len, ProxyMessage *msg)
38 {
39     char *ptr = data;
40     uint8_t firstByte = *ptr;
41     ptr += sizeof(int8_t);
42     int8_t version = (firstByte >> VERSION_SHIFT) & FOUR_BIT_MASK;
43     msg->msgHead.type = firstByte & FOUR_BIT_MASK;
44     if (version != VERSION || msg->msgHead.type >= PROXYCHANNEL_MSG_TYPE_MAX) {
45         TRANS_LOGE(TRANS_CTRL, "parseMessage: unsupported message, version=%{public}d, type=%{public}d",
46             version, msg->msgHead.type);
47         return SOFTBUS_TRANS_INVALID_MESSAGE_TYPE;
48     }
49 
50     msg->msgHead.cipher = *ptr;
51     ptr += sizeof(int8_t);
52     msg->msgHead.peerId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
53     ptr += sizeof(uint16_t);
54     msg->msgHead.myId = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
55     ptr += sizeof(uint16_t);
56     msg->msgHead.reserved = (int16_t)SoftBusBEtoLEs(*(uint16_t *)ptr);
57     msg->data = data + sizeof(ProxyMessageHead);
58     msg->dateLen = len - sizeof(ProxyMessageHead);
59 
60     return SOFTBUS_OK;
61 }
62 
TransProxyPackMessageHead(ProxyMessageHead * msgHead,uint8_t * buf,uint32_t size)63 static void TransProxyPackMessageHead(ProxyMessageHead *msgHead, uint8_t *buf, uint32_t size)
64 {
65     if (size < PROXY_CHANNEL_HEAD_LEN) {
66         TRANS_LOGE(TRANS_CTRL, "proxy head not enough");
67         return;
68     }
69     uint32_t offset = 0;
70     *buf = msgHead->type;
71     offset += sizeof(uint8_t);
72     *(buf + offset) = msgHead->cipher;
73     offset += sizeof(uint8_t);
74     *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->myId);
75     offset += sizeof(uint16_t);
76     *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->peerId);
77     offset += sizeof(uint16_t);
78     *(uint16_t *)(buf + offset) = SoftBusLEtoBEs((uint16_t)msgHead->reserved);
79 }
80 
GetRemoteUdidByBtMac(const char * peerMac,char * udid,int32_t len)81 static int32_t GetRemoteUdidByBtMac(const char *peerMac, char *udid, int32_t len)
82 {
83     char networkId[NETWORK_ID_BUF_LEN] = {0};
84     char *tmpMac = NULL;
85     Anonymize(peerMac, &tmpMac);
86     int32_t ret = LnnGetNetworkIdByBtMac(peerMac, networkId, sizeof(networkId));
87     if (ret != SOFTBUS_OK) {
88         TRANS_LOGE(TRANS_CTRL, "LnnGetNetworkIdByBtMac fail, peerMac=%{public}s", tmpMac);
89         AnonymizeFree(tmpMac);
90         return ret;
91     }
92     ret = LnnGetRemoteStrInfo(networkId, STRING_KEY_DEV_UDID, udid, len);
93     if (ret != SOFTBUS_OK) {
94         TRANS_LOGE(TRANS_CTRL, "LnnGetRemoteStrInfo UDID fail, peerMac=%{public}s", tmpMac);
95     }
96     AnonymizeFree(tmpMac);
97     return ret;
98 }
99 
GetRemoteBtMacByUdidHash(const uint8_t * udidHash,uint32_t udidHashLen,char * brMac,int32_t len)100 static int32_t GetRemoteBtMacByUdidHash(const uint8_t *udidHash, uint32_t udidHashLen, char *brMac, int32_t len)
101 {
102     char networkId[NETWORK_ID_BUF_LEN] = {0};
103     int32_t ret = LnnGetNetworkIdByUdidHash(udidHash, udidHashLen, networkId, sizeof(networkId));
104     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "LnnGetNetworkIdByUdidHash fail");
105 
106     ret = LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, brMac, len);
107     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "GetRemoteBtMac fail");
108 
109     return SOFTBUS_OK;
110 }
111 
TransProxyGetAuthConnInfo(uint32_t connId,AuthConnInfo * connInfo)112 static int32_t TransProxyGetAuthConnInfo(uint32_t connId, AuthConnInfo *connInfo)
113 {
114     ConnectionInfo info = { 0 };
115     int32_t ret = ConnGetConnectionInfo(connId, &info);
116     TRANS_CHECK_AND_RETURN_RET_LOGE(
117         ret == SOFTBUS_OK, ret, TRANS_CTRL, "ConnGetConnectionInfo fail, connId=%{public}u", connId);
118     switch (info.type) {
119         case CONNECT_TCP:
120             connInfo->type = AUTH_LINK_TYPE_WIFI;
121             if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, info.socketInfo.addr) != EOK) {
122                 TRANS_LOGE(TRANS_CTRL, "strcpy_s ip fail.");
123                 return SOFTBUS_STRCPY_ERR;
124             }
125             break;
126         case CONNECT_BR:
127             connInfo->type = AUTH_LINK_TYPE_BR;
128             if (strcpy_s(connInfo->info.brInfo.brMac, BT_MAC_LEN, info.brInfo.brMac) != EOK) {
129                 TRANS_LOGE(TRANS_CTRL, "strcpy_s brMac fail.");
130                 return SOFTBUS_STRCPY_ERR;
131             }
132             break;
133         case CONNECT_BLE:
134             connInfo->type = AUTH_LINK_TYPE_BLE;
135             if (strcpy_s(connInfo->info.bleInfo.bleMac, BT_MAC_LEN, info.bleInfo.bleMac) != EOK) {
136                 TRANS_LOGE(TRANS_CTRL, "strcpy_s brMac fail.");
137                 return SOFTBUS_STRCPY_ERR;
138             }
139             if (memcpy_s(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN,
140                 info.bleInfo.deviceIdHash, UDID_HASH_LEN) != EOK) {
141                 TRANS_LOGE(TRANS_CTRL, "memcpy_s brMac fail.");
142                 return SOFTBUS_MEM_ERR;
143             }
144             connInfo->info.bleInfo.protocol = info.bleInfo.protocol;
145             connInfo->info.bleInfo.psm = (int32_t)info.bleInfo.psm;
146             break;
147         default:
148             TRANS_LOGE(TRANS_CTRL, "unexpected conn type=%{public}d.", info.type);
149             return SOFTBUS_TRANS_UNEXPECTED_CONN_TYPE;
150     }
151     return SOFTBUS_OK;
152 }
153 
ConvertBrConnInfo2BleConnInfo(AuthConnInfo * connInfo)154 static int32_t ConvertBrConnInfo2BleConnInfo(AuthConnInfo *connInfo)
155 {
156     char udid[UDID_BUF_LEN] = {0};
157     int32_t ret = GetRemoteUdidByBtMac(connInfo->info.brInfo.brMac, udid, UDID_BUF_LEN);
158     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "get udid by btmac fail");
159 
160     ret = SoftBusGenerateStrHash((unsigned char *)udid, strlen(udid), connInfo->info.bleInfo.deviceIdHash);
161     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "generate udid hash fail");
162 
163     connInfo->type = AUTH_LINK_TYPE_BLE;
164     return SOFTBUS_OK;
165 }
166 
ConvertBleConnInfo2BrConnInfo(AuthConnInfo * connInfo)167 static int32_t ConvertBleConnInfo2BrConnInfo(AuthConnInfo *connInfo)
168 {
169     char brMac[BT_MAC_LEN] = {0};
170     int32_t ret = GetRemoteBtMacByUdidHash(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN, brMac, BT_MAC_LEN);
171     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "get btmac by udid fail");
172 
173     if (strcpy_s(connInfo->info.brInfo.brMac, BT_MAC_LEN, brMac) != EOK) {
174         TRANS_LOGE(TRANS_CTRL, "copy br mac fail");
175         return SOFTBUS_STRCPY_ERR;
176     }
177     connInfo->type = AUTH_LINK_TYPE_BR;
178     return SOFTBUS_OK;
179 }
180 
GetAuthIdByHandshakeMsg(uint32_t connId,uint8_t cipher,AuthHandle * authHandle,int32_t index)181 static int32_t GetAuthIdByHandshakeMsg(uint32_t connId, uint8_t cipher, AuthHandle *authHandle, int32_t index)
182 {
183     AuthConnInfo connInfo;
184     int32_t ret = TransProxyGetAuthConnInfo(connId, &connInfo);
185     TRANS_CHECK_AND_RETURN_RET_LOGE(
186         ret == SOFTBUS_OK, ret, TRANS_CTRL, "get connInfo fail connId=%{public}d", connId);
187     bool isBle = ((cipher & USE_BLE_CIPHER) != 0);
188     if (isBle && connInfo.type == AUTH_LINK_TYPE_BR) {
189         ret = ConvertBrConnInfo2BleConnInfo(&connInfo);
190         TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
191             TRANS_CTRL, "ConvertBrConnInfo2BleConnInfo fail, connInfoType=%{public}d", connInfo.type);
192     } else if (!isBle && connInfo.type == AUTH_LINK_TYPE_BLE) {
193         ret = ConvertBleConnInfo2BrConnInfo(&connInfo);
194         TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
195             TRANS_CTRL, "ConvertBleConnInfo2BrConnInfo fail, connInfoType=%{public}d", connInfo.type);
196     }
197     bool isAuthServer = !((cipher & AUTH_SERVER_SIDE) != 0);
198     authHandle->type = connInfo.type;
199     authHandle->authId = AuthGetIdByConnInfo(&connInfo, isAuthServer, false);
200     if (authHandle->authId == AUTH_INVALID_ID) {
201         if (AuthGetAuthHandleByIndex(&connInfo, isAuthServer, index, authHandle) != SOFTBUS_OK &&
202             AuthGetAuthHandleByIndex(&connInfo, !isAuthServer, index, authHandle) != SOFTBUS_OK) {
203             TRANS_LOGE(TRANS_CTRL, "get auth handle fail");
204             return SOFTBUS_NOT_FIND;
205         }
206     }
207     return SOFTBUS_OK;
208 }
209 
GetAuthIdReDecrypt(AuthHandle * authHandle,ProxyMessage * msg,uint8_t * decData,uint32_t * decDataLen)210 static int32_t GetAuthIdReDecrypt(AuthHandle *authHandle, ProxyMessage *msg, uint8_t *decData, uint32_t *decDataLen)
211 {
212     AuthConnInfo connInfo;
213     (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
214     int32_t ret = TransProxyGetAuthConnInfo(msg->connId, &connInfo);
215     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
216         TRANS_CTRL, "get connInfo fail connId=%{public}d", msg->connId);
217     int32_t index = (int32_t)SoftBusLtoHl(*(uint32_t *)msg->data);
218     if (AuthGetAuthHandleByIndex(&connInfo, false, index, authHandle) != SOFTBUS_OK &&
219         AuthGetAuthHandleByIndex(&connInfo, true, index, authHandle) != SOFTBUS_OK) {
220         TRANS_LOGE(TRANS_CTRL, "get auth handle fail");
221         return SOFTBUS_NOT_FIND;
222     }
223     return AuthDecrypt(authHandle, (uint8_t *)msg->data, (uint32_t)msg->dateLen, decData, decDataLen);
224 }
225 
GetBrMacFromConnInfo(uint32_t connId,char * peerBrMac,uint32_t len)226 int32_t GetBrMacFromConnInfo(uint32_t connId, char *peerBrMac, uint32_t len)
227 {
228     AuthConnInfo connInfo;
229 
230     if (peerBrMac == NULL || len <= 0 || len > BT_MAC_LEN) {
231         return SOFTBUS_INVALID_PARAM;
232     }
233     int32_t ret = TransProxyGetAuthConnInfo(connId, &connInfo);
234     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret,
235         TRANS_CTRL, "get connInfo fail connId=%{public}d", connId);
236 
237     if (strcpy_s(peerBrMac, len, connInfo.info.brInfo.brMac) != EOK) {
238         TRANS_LOGE(TRANS_CTRL, "copy brMac fail.");
239         return SOFTBUS_STRCPY_ERR;
240     }
241     return SOFTBUS_OK;
242 }
243 
TransProxyParseMessageNoDecrypt(ProxyMessage * msg)244 static int32_t TransProxyParseMessageNoDecrypt(ProxyMessage *msg)
245 {
246     uint8_t *allocData = (uint8_t *)SoftBusCalloc((uint32_t)msg->dateLen);
247     if (allocData == NULL) {
248         TRANS_LOGE(TRANS_CTRL, "malloc data fail");
249         return SOFTBUS_MALLOC_ERR;
250     }
251     if (memcpy_s(allocData, msg->dateLen, msg->data, msg->dateLen) != EOK) {
252         TRANS_LOGE(TRANS_CTRL, "memcpy data fail");
253         SoftBusFree(allocData);
254         return SOFTBUS_MEM_ERR;
255     }
256     msg->data = (char *)allocData;
257     return SOFTBUS_OK;
258 }
259 
TransProxyParseMessage(char * data,int32_t len,ProxyMessage * msg,AuthHandle * auth)260 int32_t TransProxyParseMessage(char *data, int32_t len, ProxyMessage *msg, AuthHandle *auth)
261 {
262     TRANS_CHECK_AND_RETURN_RET_LOGE(len > PROXY_CHANNEL_HEAD_LEN,
263         SOFTBUS_INVALID_PARAM, TRANS_CTRL, "parseMessage: invalid message len!");
264     int32_t ret = TransProxyParseMessageHead(data, len, msg);
265     TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "TransProxyParseMessageHead fail!");
266     if ((msg->msgHead.cipher & ENCRYPTED) != 0) {
267         if (msg->dateLen <= 0 || (uint32_t)msg->dateLen < sizeof(uint32_t)) {
268             TRANS_LOGE(TRANS_CTRL, "The data length of the ProxyMessage is abnormal!");
269             return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
270         }
271         if (msg->msgHead.type == PROXYCHANNEL_MSG_TYPE_HANDSHAKE) {
272             TRANS_LOGD(TRANS_CTRL, "prxoy recv handshake cipher=0x%{public}02x", msg->msgHead.cipher);
273             ret = GetAuthIdByHandshakeMsg(msg->connId, msg->msgHead.cipher, auth,
274                 (int32_t)SoftBusLtoHl(*(uint32_t *)msg->data));
275         } else {
276             ret = TransProxyGetAuthId(msg->msgHead.myId, auth);
277         }
278         if (ret != SOFTBUS_OK || auth->authId == AUTH_INVALID_ID) {
279             TRANS_LOGE(TRANS_CTRL, "get authId fail, connId=%{public}d, myChannelId=%{public}d, type=%{public}d",
280                 msg->connId, msg->msgHead.myId, msg->msgHead.type);
281             return SOFTBUS_AUTH_NOT_FOUND;
282         }
283         msg->authHandle = (*auth);
284         uint32_t decDataLen = AuthGetDecryptSize((uint32_t)msg->dateLen);
285         uint8_t *decData = (uint8_t *)SoftBusCalloc(decDataLen);
286         if (decData == NULL) {
287             return SOFTBUS_MALLOC_ERR;
288         }
289         msg->keyIndex = (int32_t)SoftBusLtoHl(*(uint32_t *)msg->data);
290         if (AuthDecrypt(auth, (uint8_t *)msg->data, (uint32_t)msg->dateLen, decData, &decDataLen) != SOFTBUS_OK &&
291             GetAuthIdReDecrypt(auth, msg, decData, &decDataLen) != SOFTBUS_OK) {
292             SoftBusFree(decData);
293             TRANS_LOGE(TRANS_CTRL, "parse msg decrypt fail");
294             return SOFTBUS_DECRYPT_ERR;
295         }
296         msg->data = (char *)decData;
297         msg->dateLen = (int32_t)decDataLen;
298     } else {
299         ret = TransProxyParseMessageNoDecrypt(msg);
300         if (ret != SOFTBUS_OK) {
301             TRANS_LOGE(TRANS_CTRL, "trans not need decrypt msg fail, ret=%{public}d", ret);
302             return ret;
303         }
304     }
305     return SOFTBUS_OK;
306 }
307 
PackPlaintextMessage(ProxyMessageHead * msg,ProxyDataInfo * dataInfo)308 int32_t PackPlaintextMessage(ProxyMessageHead *msg, ProxyDataInfo *dataInfo)
309 {
310     if (msg == NULL || dataInfo == NULL) {
311         TRANS_LOGE(TRANS_CTRL, "invalid param.");
312         return SOFTBUS_INVALID_PARAM;
313     }
314     uint32_t connHeadLen = ConnGetHeadSize();
315     uint32_t size = PROXY_CHANNEL_HEAD_LEN + connHeadLen + dataInfo->inLen;
316     uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
317     if (buf == NULL) {
318         TRANS_LOGE(TRANS_CTRL, "malloc proxy buf fail, myChannelId=%{public}d", msg->myId);
319         return SOFTBUS_MALLOC_ERR;
320     }
321     TransProxyPackMessageHead(msg, buf + connHeadLen, PROXY_CHANNEL_HEAD_LEN);
322     if (memcpy_s(buf + connHeadLen + PROXY_CHANNEL_HEAD_LEN, size - connHeadLen - PROXY_CHANNEL_HEAD_LEN,
323         dataInfo->inData, dataInfo->inLen) != EOK) {
324         TRANS_LOGE(TRANS_CTRL, "plaint ext message memcpy fail.");
325         SoftBusFree(buf);
326         return SOFTBUS_MEM_ERR;
327     }
328     dataInfo->outData = buf;
329     dataInfo->outLen = size;
330     return SOFTBUS_OK;
331 }
332 
PackEncryptedMessage(ProxyMessageHead * msg,AuthHandle authHandle,ProxyDataInfo * dataInfo)333 static int32_t PackEncryptedMessage(ProxyMessageHead *msg, AuthHandle authHandle, ProxyDataInfo *dataInfo)
334 {
335     if (authHandle.authId == AUTH_INVALID_ID) {
336         TRANS_LOGE(TRANS_CTRL, "invalid authId, myChannelId=%{public}d", msg->myId);
337         return SOFTBUS_INVALID_PARAM;
338     }
339     uint32_t size = ConnGetHeadSize() + PROXY_CHANNEL_HEAD_LEN +
340         AuthGetEncryptSize(authHandle.authId, dataInfo->inLen);
341     uint8_t *buf = (uint8_t *)SoftBusCalloc(size);
342     if (buf == NULL) {
343         TRANS_LOGE(TRANS_CTRL, "malloc enc buf fail, myChannelId=%{public}d", msg->myId);
344         return SOFTBUS_MALLOC_ERR;
345     }
346     TransProxyPackMessageHead(msg, buf + ConnGetHeadSize(), PROXY_CHANNEL_HEAD_LEN);
347     uint8_t *encData = buf + ConnGetHeadSize() + PROXY_CHANNEL_HEAD_LEN;
348     uint32_t encDataLen = size - ConnGetHeadSize() - PROXY_CHANNEL_HEAD_LEN;
349     if (AuthEncrypt(&authHandle, dataInfo->inData, dataInfo->inLen, encData, &encDataLen) != SOFTBUS_OK) {
350         SoftBusFree(buf);
351         TRANS_LOGE(TRANS_CTRL, "pack msg encrypt fail, myChannelId=%{public}d", msg->myId);
352         return SOFTBUS_ENCRYPT_ERR;
353     }
354     dataInfo->outData = buf;
355     dataInfo->outLen = size;
356     return SOFTBUS_OK;
357 }
358 
TransProxyPackMessage(ProxyMessageHead * msg,AuthHandle authHandle,ProxyDataInfo * dataInfo)359 int32_t TransProxyPackMessage(ProxyMessageHead *msg, AuthHandle authHandle, ProxyDataInfo *dataInfo)
360 {
361     if (msg == NULL || dataInfo == NULL || dataInfo->inData == NULL || dataInfo->inData == 0) {
362         return SOFTBUS_INVALID_PARAM;
363     }
364 
365     int32_t ret;
366     if ((msg->cipher & ENCRYPTED) == 0) {
367         ret = PackPlaintextMessage(msg, dataInfo);
368     } else {
369         ret = PackEncryptedMessage(msg, authHandle, dataInfo);
370     }
371     if (ret != SOFTBUS_OK) {
372         TRANS_LOGE(TRANS_CTRL, "pack proxy msg fail, myChannelId=%{public}d", msg->myId);
373         return ret;
374     }
375     return SOFTBUS_OK;
376 }
377 
PackHandshakeMsgForFastData(AppInfo * appInfo,cJSON * root)378 static int32_t PackHandshakeMsgForFastData(AppInfo *appInfo, cJSON *root)
379 {
380     if (appInfo->fastTransDataSize > 0) {
381         TRANS_LOGI(TRANS_CTRL, "have fast data need transport");
382         if (!AddNumberToJsonObject(root, JSON_KEY_ROUTE_TYPE, appInfo->routeType)) {
383             TRANS_LOGE(TRANS_CTRL, "add route type fail.");
384             return SOFTBUS_PARSE_JSON_ERR;
385         }
386         uint8_t *encodeFastData = (uint8_t *)SoftBusMalloc(BASE64_FAST_DATA_LEN);
387         if (encodeFastData == NULL) {
388             TRANS_LOGE(TRANS_CTRL, "malloc encode fast data fail.");
389             return SOFTBUS_MALLOC_ERR;
390         }
391         size_t fastDataSize = 0;
392         uint32_t outLen;
393         char *buf = TransProxyPackFastData(appInfo, &outLen);
394         if (buf == NULL) {
395             TRANS_LOGE(TRANS_CTRL, "failed to pack bytes.");
396             SoftBusFree(encodeFastData);
397             return SOFTBUS_TRANS_PACK_FAST_DATA_FAILED;
398         }
399         int32_t ret = SoftBusBase64Encode(encodeFastData, BASE64_FAST_DATA_LEN, &fastDataSize,
400             (const unsigned char *)buf, outLen);
401         if (ret != SOFTBUS_OK) {
402             TRANS_LOGE(TRANS_CTRL, "mbedtls base64 encode failed.");
403             SoftBusFree(encodeFastData);
404             SoftBusFree(buf);
405             return SOFTBUS_DECRYPT_ERR;
406         }
407         if (!AddStringToJsonObject(root, JSON_KEY_FIRST_DATA, (const char *)encodeFastData)) {
408             TRANS_LOGE(TRANS_CTRL, "add first data failed.");
409             SoftBusFree(encodeFastData);
410             SoftBusFree(buf);
411             return SOFTBUS_PARSE_JSON_ERR;
412         }
413         SoftBusFree(encodeFastData);
414         SoftBusFree(buf);
415     }
416     if (!AddNumber16ToJsonObject(root, JSON_KEY_FIRST_DATA_SIZE, appInfo->fastTransDataSize)) {
417         TRANS_LOGE(TRANS_CTRL, "add first data size failed.");
418         return SOFTBUS_PARSE_JSON_ERR;
419     }
420     return SOFTBUS_OK;
421 }
422 
PackHandshakeMsgForNormal(SessionKeyBase64 * sessionBase64,AppInfo * appInfo,cJSON * root)423 static int32_t PackHandshakeMsgForNormal(SessionKeyBase64 *sessionBase64, AppInfo *appInfo, cJSON *root)
424 {
425     int32_t ret = SoftBusBase64Encode((unsigned char *)sessionBase64->sessionKeyBase64,
426         sizeof(sessionBase64->sessionKeyBase64), &(sessionBase64->len),
427         (unsigned char *)appInfo->sessionKey, sizeof(appInfo->sessionKey));
428     if (ret != SOFTBUS_OK) {
429         TRANS_LOGE(TRANS_CTRL, "mbedtls_base64_encode FAIL ret=%{public}d", ret);
430         return ret;
431     }
432     TRANS_LOGI(TRANS_CTRL, "mbedtls_base64_encode len=%{public}zu", sessionBase64->len);
433     if (!AddNumberToJsonObject(root, JSON_KEY_UID, appInfo->myData.uid) ||
434         !AddNumberToJsonObject(root, JSON_KEY_PID, appInfo->myData.pid) ||
435         !AddStringToJsonObject(root, JSON_KEY_GROUP_ID, appInfo->groupId) ||
436         !AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName) ||
437         !AddStringToJsonObject(root, JSON_KEY_SESSION_KEY, sessionBase64->sessionKeyBase64)) {
438         return SOFTBUS_PARSE_JSON_ERR;
439     }
440     if (!AddNumberToJsonObject(root, JSON_KEY_ENCRYPT, appInfo->encrypt) ||
441         !AddNumberToJsonObject(root, JSON_KEY_ALGORITHM, appInfo->algorithm) ||
442         !AddNumberToJsonObject(root, JSON_KEY_CRC, appInfo->crc)) {
443         return SOFTBUS_PARSE_JSON_ERR;
444     }
445     if (PackHandshakeMsgForFastData(appInfo, root) != SOFTBUS_OK) {
446         TRANS_LOGE(TRANS_CTRL, "proxy channel pack fast data failed");
447         return SOFTBUS_PARSE_JSON_ERR;
448     }
449     (void)AddNumberToJsonObject(root, JSON_KEY_BUSINESS_TYPE, appInfo->businessType);
450     (void)AddNumberToJsonObject(root, JSON_KEY_TRANS_FLAGS, TRANS_FLAG_HAS_CHANNEL_AUTH);
451     (void)AddNumberToJsonObject(root, JSON_KEY_MY_HANDLE_ID, appInfo->myHandleId);
452     (void)AddNumberToJsonObject(root, JSON_KEY_PEER_HANDLE_ID, appInfo->peerHandleId);
453     (void)AddNumberToJsonObject(root, JSON_KEY_CALLING_TOKEN_ID, (int32_t)appInfo->callingTokenId);
454     return SOFTBUS_OK;
455 }
456 
TransProxyPackHandshakeErrMsg(int32_t errCode)457 char *TransProxyPackHandshakeErrMsg(int32_t errCode)
458 {
459     cJSON *root = NULL;
460     char *buf = NULL;
461 
462     root = cJSON_CreateObject();
463     if (root == NULL) {
464         TRANS_LOGE(TRANS_CTRL, "create json object failed.");
465         return NULL;
466     }
467 
468     if (!AddNumberToJsonObject(root, ERR_CODE, errCode)) {
469         cJSON_Delete(root);
470         return NULL;
471     }
472 
473     buf = cJSON_PrintUnformatted(root);
474     cJSON_Delete(root);
475     return buf;
476 }
477 
TransProxyPackHandshakeMsg(ProxyChannelInfo * info)478 char *TransProxyPackHandshakeMsg(ProxyChannelInfo *info)
479 {
480     cJSON *root = cJSON_CreateObject();
481     if (root == NULL) {
482         TRANS_LOGE(TRANS_CTRL, "create json object failed.");
483         return NULL;
484     }
485 
486     int32_t ret;
487     char *buf = NULL;
488     AppInfo *appInfo = &(info->appInfo);
489     SessionKeyBase64 sessionBase64;
490     (void)memset_s(&sessionBase64, sizeof(SessionKeyBase64), 0, sizeof(SessionKeyBase64));
491     if (!AddNumberToJsonObject(root, JSON_KEY_TYPE, appInfo->appType) ||
492         !AddStringToJsonObject(root, JSON_KEY_IDENTITY, info->identity) ||
493         !AddStringToJsonObject(root, JSON_KEY_DEVICE_ID, appInfo->myData.deviceId) ||
494         !AddStringToJsonObject(root, JSON_KEY_SRC_BUS_NAME, appInfo->myData.sessionName) ||
495         !AddStringToJsonObject(root, JSON_KEY_DST_BUS_NAME, appInfo->peerData.sessionName) ||
496         !AddNumberToJsonObject(root, JSON_KEY_MTU_SIZE, appInfo->myData.dataConfig)) {
497         goto EXIT;
498     }
499     (void)cJSON_AddTrueToObject(root, JSON_KEY_HAS_PRIORITY);
500     if (appInfo->appType == APP_TYPE_NORMAL) {
501         if (PackHandshakeMsgForNormal(&sessionBase64, appInfo, root) != SOFTBUS_OK) {
502             goto EXIT;
503         }
504     } else if (appInfo->appType == APP_TYPE_AUTH) {
505         if (strlen(appInfo->reqId) == 0 && GenerateRandomStr(appInfo->reqId, REQ_ID_SIZE_MAX) != SOFTBUS_OK) {
506             goto EXIT;
507         }
508         if (!AddStringToJsonObject(root, JSON_KEY_REQUEST_ID, appInfo->reqId)) {
509             goto EXIT;
510         }
511         if (!AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName)) {
512             goto EXIT;
513         }
514     } else {
515         ret = SoftBusBase64Encode((uint8_t *)sessionBase64.sessionKeyBase64, sizeof(sessionBase64.sessionKeyBase64),
516             &(sessionBase64.len), (uint8_t *)appInfo->sessionKey, sizeof(appInfo->sessionKey));
517         if (ret != SOFTBUS_OK) {
518             TRANS_LOGE(TRANS_CTRL, "mbedtls_base64_encode FAIL ret=%{public}d", ret);
519             goto EXIT;
520         }
521         if (!AddStringToJsonObject(root, JSON_KEY_SESSION_KEY, sessionBase64.sessionKeyBase64)) {
522             goto EXIT;
523         }
524     }
525 
526     buf = cJSON_PrintUnformatted(root);
527 EXIT:
528     cJSON_Delete(root);
529     return buf;
530 }
531 
TransProxyPackHandshakeAckMsg(ProxyChannelInfo * chan)532 char *TransProxyPackHandshakeAckMsg(ProxyChannelInfo *chan)
533 {
534     cJSON *root = NULL;
535     char *buf = NULL;
536     AppInfo *appInfo = &(chan->appInfo);
537     if (appInfo == NULL || appInfo->appType == APP_TYPE_NOT_CARE) {
538         TRANS_LOGE(TRANS_CTRL, "invalid param.");
539         return NULL;
540     }
541 
542     root = cJSON_CreateObject();
543     if (root == NULL) {
544         TRANS_LOGE(TRANS_CTRL, "create json object failed.");
545         return NULL;
546     }
547 
548     if (!AddStringToJsonObject(root, JSON_KEY_IDENTITY, chan->identity) ||
549         !AddStringToJsonObject(root, JSON_KEY_DEVICE_ID, appInfo->myData.deviceId)) {
550         cJSON_Delete(root);
551         return NULL;
552     }
553     if (appInfo->peerData.dataConfig != 0) {
554         if (!AddNumberToJsonObject(root, JSON_KEY_MTU_SIZE, appInfo->myData.dataConfig)) {
555             cJSON_Delete(root);
556             return NULL;
557         }
558     }
559     (void)cJSON_AddTrueToObject(root, JSON_KEY_HAS_PRIORITY);
560     if (appInfo->appType == APP_TYPE_NORMAL) {
561         if (!AddNumberToJsonObject(root, JSON_KEY_UID, appInfo->myData.uid) ||
562             !AddNumberToJsonObject(root, JSON_KEY_PID, appInfo->myData.pid) ||
563             !AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName) ||
564             !AddNumberToJsonObject(root, JSON_KEY_ENCRYPT, appInfo->encrypt) ||
565             !AddNumberToJsonObject(root, JSON_KEY_ALGORITHM, appInfo->algorithm) ||
566             !AddNumberToJsonObject(root, JSON_KEY_CRC, appInfo->crc) ||
567             !AddNumber16ToJsonObject(root, JSON_KEY_FIRST_DATA_SIZE, appInfo->fastTransDataSize) ||
568             !AddStringToJsonObject(root, JSON_KEY_SRC_BUS_NAME, appInfo->myData.sessionName) ||
569             !AddStringToJsonObject(root, JSON_KEY_DST_BUS_NAME, appInfo->peerData.sessionName)) {
570             cJSON_Delete(root);
571             return NULL;
572         }
573         (void)AddNumberToJsonObject(root, JSON_KEY_MY_HANDLE_ID, appInfo->myHandleId);
574     } else if (appInfo->appType == APP_TYPE_AUTH) {
575         if (!AddStringToJsonObject(root, JSON_KEY_PKG_NAME, appInfo->myData.pkgName)) {
576             cJSON_Delete(root);
577             return NULL;
578         }
579     }
580 
581     buf = cJSON_PrintUnformatted(root);
582     cJSON_Delete(root);
583     return buf;
584 }
585 
TransProxyUnPackHandshakeErrMsg(const char * msg,int32_t * errCode,int32_t len)586 int32_t TransProxyUnPackHandshakeErrMsg(const char *msg, int32_t *errCode, int32_t len)
587 {
588     if (errCode == NULL) {
589         TRANS_LOGE(TRANS_CTRL, "invalid param errCode.");
590         return SOFTBUS_INVALID_PARAM;
591     }
592 
593     cJSON *root = cJSON_ParseWithLength(msg, len);
594     if (root == NULL) {
595         TRANS_LOGE(TRANS_CTRL, "parse json failed.");
596         return SOFTBUS_CREATE_JSON_ERR;
597     }
598 
599     if (!GetJsonObjectInt32Item(root, ERR_CODE, errCode)) {
600         cJSON_Delete(root);
601         return SOFTBUS_PARSE_JSON_ERR;
602     }
603     TRANS_LOGE(TRANS_CTRL, "remote device is faulty, errCode=%{public}d", *errCode);
604 
605     cJSON_Delete(root);
606     return SOFTBUS_OK;
607 }
608 
TransProxyUnPackRestErrMsg(const char * msg,int32_t * errCode,int32_t len)609 int32_t TransProxyUnPackRestErrMsg(const char *msg, int32_t *errCode, int32_t len)
610 {
611     if (errCode == NULL) {
612         TRANS_LOGE(TRANS_CTRL, "invalid param errCode.");
613         return SOFTBUS_INVALID_PARAM;
614     }
615 
616     cJSON *root = cJSON_ParseWithLength(msg, len);
617     if (root == NULL) {
618         TRANS_LOGE(TRANS_CTRL, "parse json failed.");
619         return SOFTBUS_CREATE_JSON_ERR;
620     }
621 
622     if (!GetJsonObjectInt32Item(root, ERR_CODE, errCode) && !GetJsonObjectInt32Item(root, "ERROR_CODE", errCode)) {
623         TRANS_LOGE(TRANS_CTRL, "get errCode failed.");
624         cJSON_Delete(root);
625         return SOFTBUS_PARSE_JSON_ERR;
626     }
627 
628     cJSON_Delete(root);
629     return SOFTBUS_OK;
630 }
631 
TransProxyUnpackHandshakeAckMsg(const char * msg,ProxyChannelInfo * chanInfo,int32_t len,uint16_t * fastDataSize)632 int32_t TransProxyUnpackHandshakeAckMsg(const char *msg, ProxyChannelInfo *chanInfo,
633     int32_t len, uint16_t *fastDataSize)
634 {
635     TRANS_CHECK_AND_RETURN_RET_LOGE(msg != NULL && chanInfo != NULL && fastDataSize != NULL,
636         SOFTBUS_INVALID_PARAM, TRANS_CTRL, "msg or chanInfo or fastDataSize is empty.");
637 
638     TRANS_CHECK_AND_RETURN_RET_LOGE(&chanInfo->appInfo != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "appInfo is null");
639 
640     cJSON *root = cJSON_ParseWithLength(msg, len);
641     TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_CTRL, "parse json failed.");
642 
643     if (!GetJsonObjectStringItem(root, JSON_KEY_IDENTITY, chanInfo->identity, sizeof(chanInfo->identity)) ||
644         !GetJsonObjectStringItem(root, JSON_KEY_DEVICE_ID, chanInfo->appInfo.peerData.deviceId,
645                                  sizeof(chanInfo->appInfo.peerData.deviceId))) {
646         TRANS_LOGE(TRANS_CTRL, "fail to get json item");
647         cJSON_Delete(root);
648         return SOFTBUS_PARSE_JSON_ERR;
649     }
650     if (!GetJsonObjectNumberItem(root, JSON_KEY_MTU_SIZE, (int32_t *)&(chanInfo->appInfo.peerData.dataConfig))) {
651         TRANS_LOGD(TRANS_CTRL, "peer dataconfig is null.");
652     }
653     chanInfo->appInfo.encrypt = APP_INFO_FILE_FEATURES_SUPPORT;
654     chanInfo->appInfo.algorithm = APP_INFO_ALGORITHM_AES_GCM_256;
655     chanInfo->appInfo.crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
656 
657     int32_t ret = TransProxyGetAppInfoType(chanInfo->myId, chanInfo->identity, &chanInfo->appInfo.appType);
658     if (ret != SOFTBUS_OK) {
659         TRANS_LOGE(TRANS_CTRL, "failed to get app type");
660         cJSON_Delete(root);
661         return SOFTBUS_TRANS_PROXY_ERROR_APP_TYPE;
662     }
663     if (chanInfo->appInfo.appType == APP_TYPE_NORMAL) {
664         if (!GetJsonObjectNumberItem(root, JSON_KEY_UID, &chanInfo->appInfo.peerData.uid) ||
665             !GetJsonObjectNumberItem(root, JSON_KEY_PID, &chanInfo->appInfo.peerData.pid) ||
666             !GetJsonObjectNumberItem(root, JSON_KEY_ENCRYPT, &chanInfo->appInfo.encrypt) ||
667             !GetJsonObjectNumberItem(root, JSON_KEY_ALGORITHM, &chanInfo->appInfo.algorithm) ||
668             !GetJsonObjectNumberItem(root, JSON_KEY_CRC, &chanInfo->appInfo.crc) ||
669             !GetJsonObjectNumber16Item(root, JSON_KEY_FIRST_DATA_SIZE, fastDataSize) ||
670             !GetJsonObjectStringItem(root, JSON_KEY_SRC_BUS_NAME, chanInfo->appInfo.peerData.sessionName,
671                                      sizeof(chanInfo->appInfo.peerData.sessionName)) ||
672             !GetJsonObjectStringItem(root, JSON_KEY_DST_BUS_NAME, chanInfo->appInfo.myData.sessionName,
673                                      sizeof(chanInfo->appInfo.myData.sessionName))) {
674             TRANS_LOGW(TRANS_CTRL, "unpack handshake ack old version");
675         }
676         if (!GetJsonObjectInt32Item(root, JSON_KEY_MY_HANDLE_ID, &chanInfo->appInfo.peerHandleId)) {
677             chanInfo->appInfo.peerHandleId = -1;
678         }
679     }
680 
681     if (!GetJsonObjectStringItem(root, JSON_KEY_PKG_NAME, chanInfo->appInfo.peerData.pkgName,
682                                  sizeof(chanInfo->appInfo.peerData.pkgName))) {
683         TRANS_LOGW(TRANS_CTRL, "no item to get pkg name");
684     }
685     cJSON_Delete(root);
686     return SOFTBUS_OK;
687 }
688 
UnpackPackHandshakeMsgForFastData(AppInfo * appInfo,cJSON * root)689 static int32_t UnpackPackHandshakeMsgForFastData(AppInfo *appInfo, cJSON *root)
690 {
691     if (!GetJsonObjectNumber16Item(root, JSON_KEY_FIRST_DATA_SIZE, &(appInfo->fastTransDataSize))) {
692         TRANS_LOGW(TRANS_CTRL, "Failed to get handshake msg fast data size");
693         appInfo->fastTransDataSize = 0;
694     }
695     if (appInfo->fastTransDataSize > 0 && appInfo->fastTransDataSize <= MAX_FAST_DATA_LEN) {
696         if (!GetJsonObjectNumberItem(root, JSON_KEY_ROUTE_TYPE, (int32_t*)&(appInfo->routeType))) {
697             TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg route type");
698             return SOFTBUS_PARSE_JSON_ERR;
699         }
700         uint8_t *encodeFastData = (uint8_t *)SoftBusMalloc(BASE64_FAST_DATA_LEN);
701         if (encodeFastData == NULL) {
702             TRANS_LOGE(TRANS_CTRL, "malloc encode fast data fail.");
703             return SOFTBUS_MALLOC_ERR;
704         }
705         size_t fastDataSize = 0;
706         if (!GetJsonObjectStringItem(root, JSON_KEY_FIRST_DATA, (char *)encodeFastData, BASE64_FAST_DATA_LEN)) {
707             TRANS_LOGE(TRANS_CTRL, "failed to get fast data");
708             SoftBusFree(encodeFastData);
709             return SOFTBUS_PARSE_JSON_ERR;
710         }
711         appInfo->fastTransData = (uint8_t *)SoftBusCalloc(appInfo->fastTransDataSize + FAST_EXT_BYTE_SIZE);
712         if (appInfo->fastTransData == NULL) {
713             TRANS_LOGE(TRANS_CTRL, "malloc fast data fail.");
714             SoftBusFree(encodeFastData);
715             return SOFTBUS_MALLOC_ERR;
716         }
717 
718         int32_t ret = SoftBusBase64Decode((unsigned char *)appInfo->fastTransData, appInfo->fastTransDataSize +
719             FAST_EXT_BYTE_SIZE, &fastDataSize, encodeFastData, strlen((char*)encodeFastData));
720         if (ret != SOFTBUS_OK) {
721             TRANS_LOGE(TRANS_CTRL, "mbedtls decode failed.");
722             SoftBusFree((void *)appInfo->fastTransData);
723             appInfo->fastTransData = NULL;
724             SoftBusFree(encodeFastData);
725             return SOFTBUS_DECRYPT_ERR;
726         }
727         SoftBusFree(encodeFastData);
728     }
729     return SOFTBUS_OK;
730 }
731 
TransProxyUnpackNormalHandshakeMsg(cJSON * root,AppInfo * appInfo,char * sessionKey,int32_t keyLen)732 static int32_t TransProxyUnpackNormalHandshakeMsg(cJSON *root, AppInfo *appInfo, char *sessionKey, int32_t keyLen)
733 {
734     if (!GetJsonObjectNumberItem(root, JSON_KEY_UID, &(appInfo->peerData.uid)) ||
735         !GetJsonObjectNumberItem(root, JSON_KEY_PID, &(appInfo->peerData.pid)) ||
736         !GetJsonObjectStringItem(root, JSON_KEY_PKG_NAME, appInfo->peerData.pkgName,
737                                  sizeof(appInfo->peerData.pkgName)) ||
738         !GetJsonObjectStringItem(root, JSON_KEY_SESSION_KEY, sessionKey, keyLen)) {
739         TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg APP_TYPE_NORMAL");
740         return SOFTBUS_PARSE_JSON_ERR;
741     }
742     if (!GetJsonObjectNumberItem(root, JSON_KEY_ENCRYPT, &appInfo->encrypt) ||
743         !GetJsonObjectNumberItem(root, JSON_KEY_ALGORITHM, &appInfo->algorithm) ||
744         !GetJsonObjectNumberItem(root, JSON_KEY_CRC, &appInfo->crc)) {
745         TRANS_LOGW(TRANS_CTRL, "unpack handshake old version");
746         appInfo->encrypt = APP_INFO_FILE_FEATURES_SUPPORT;
747         appInfo->algorithm = APP_INFO_ALGORITHM_AES_GCM_256;
748         appInfo->crc = APP_INFO_FILE_FEATURES_NO_SUPPORT;
749     }
750     if (!GetJsonObjectNumberItem(root, JSON_KEY_BUSINESS_TYPE, (int*)&appInfo->businessType)) {
751         appInfo->businessType = BUSINESS_TYPE_NOT_CARE;
752     }
753 
754     GetJsonObjectStringItem(root, JSON_KEY_GROUP_ID, appInfo->groupId, sizeof(appInfo->groupId));
755     if (!GetJsonObjectInt32Item(root, JSON_KEY_MY_HANDLE_ID, &(appInfo->peerHandleId)) ||
756         !GetJsonObjectInt32Item(root, JSON_KEY_PEER_HANDLE_ID, &(appInfo->myHandleId))) {
757             appInfo->myHandleId = -1;
758             appInfo->peerHandleId = -1;
759     }
760     size_t len = 0;
761     int32_t ret = SoftBusBase64Decode((uint8_t *)appInfo->sessionKey, sizeof(appInfo->sessionKey),
762         &len, (uint8_t *)sessionKey, strlen(sessionKey));
763     if (len != sizeof(appInfo->sessionKey) || ret != SOFTBUS_OK) {
764         TRANS_LOGE(TRANS_CTRL, "decode session fail ret=%{public}d", ret);
765         return SOFTBUS_DECRYPT_ERR;
766     }
767     if (UnpackPackHandshakeMsgForFastData(appInfo, root) != SOFTBUS_OK) {
768         TRANS_LOGE(TRANS_CTRL, "unpack fast data failed");
769         return SOFTBUS_TRANS_PROXY_UNPACK_FAST_DATA_FAILED;
770     }
771     if (!GetJsonObjectNumberItem(root, JSON_KEY_CALLING_TOKEN_ID, (int32_t *)&appInfo->callingTokenId)) {
772         appInfo->callingTokenId = TOKENID_NOT_SET;
773     }
774     return SOFTBUS_OK;
775 }
776 
TransProxyUnpackAuthHandshakeMsg(cJSON * root,AppInfo * appInfo)777 static int32_t TransProxyUnpackAuthHandshakeMsg(cJSON *root, AppInfo *appInfo)
778 {
779     if (!GetJsonObjectStringItem(root, JSON_KEY_REQUEST_ID, appInfo->reqId, REQ_ID_SIZE_MAX)) {
780         TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg REQUEST_ID");
781         return SOFTBUS_TRANS_PROXY_HANDSHAKE_GET_REQUEST_FAILED;
782     }
783     if (!GetJsonObjectStringItem(root, JSON_KEY_PKG_NAME,
784         appInfo->peerData.pkgName, sizeof(appInfo->peerData.pkgName))) {
785         TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg pkgName");
786         return SOFTBUS_TRANS_PROXY_HANDSHAKE_GET_PKG_FAILED;
787     }
788     return SOFTBUS_OK;
789 }
790 
TransProxyUnpackInnerHandshakeMsg(cJSON * root,AppInfo * appInfo,char * sessionKey,int32_t keyLen)791 static int32_t TransProxyUnpackInnerHandshakeMsg(cJSON *root, AppInfo *appInfo, char *sessionKey, int32_t keyLen)
792 {
793     if (!GetJsonObjectStringItem(root, JSON_KEY_SESSION_KEY, sessionKey, keyLen)) {
794         TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg");
795         return SOFTBUS_TRANS_PROXY_HANDSHAKE_GET_SESSIONKEY_FAILED;
796     }
797     size_t len = 0;
798     int32_t ret = SoftBusBase64Decode((uint8_t *)appInfo->sessionKey, sizeof(appInfo->sessionKey),
799         &len, (uint8_t *)sessionKey, strlen(sessionKey));
800     if (len != sizeof(appInfo->sessionKey) || ret != SOFTBUS_OK) {
801         TRANS_LOGE(TRANS_CTRL, "decode session fail ret=%{public}d", ret);
802         return SOFTBUS_DECRYPT_ERR;
803     }
804     return SOFTBUS_OK;
805 }
806 
TransProxyUnpackHandshakeMsg(const char * msg,ProxyChannelInfo * chan,int32_t len)807 int32_t TransProxyUnpackHandshakeMsg(const char *msg, ProxyChannelInfo *chan, int32_t len)
808 {
809     TRANS_CHECK_AND_RETURN_RET_LOGE(msg != NULL && chan != NULL, SOFTBUS_INVALID_PARAM, TRANS_CTRL, "param invalid.");
810     cJSON *root = cJSON_ParseWithLength(msg, len);
811     TRANS_CHECK_AND_RETURN_RET_LOGE(root != NULL, SOFTBUS_PARSE_JSON_ERR, TRANS_CTRL, "parse json failed.");
812 
813     char sessionKey[BASE64KEY] = { 0 };
814     AppInfo *appInfo = &(chan->appInfo);
815 
816     if (!GetJsonObjectNumberItem(root, JSON_KEY_TYPE, (int32_t *)&(appInfo->appType)) ||
817         !GetJsonObjectStringItem(root, JSON_KEY_IDENTITY, chan->identity, sizeof(chan->identity)) ||
818         !GetJsonObjectStringItem(root, JSON_KEY_DEVICE_ID, appInfo->peerData.deviceId,
819                                  sizeof(appInfo->peerData.deviceId)) ||
820         !GetJsonObjectStringItem(root, JSON_KEY_SRC_BUS_NAME, appInfo->peerData.sessionName,
821                                  sizeof(appInfo->peerData.sessionName)) ||
822         !GetJsonObjectStringItem(root, JSON_KEY_DST_BUS_NAME, appInfo->myData.sessionName,
823                                  sizeof(appInfo->myData.sessionName))) {
824         TRANS_LOGE(TRANS_CTRL, "Failed to get handshake msg");
825         cJSON_Delete(root);
826         return SOFTBUS_PARSE_JSON_ERR;
827     }
828 
829     if (!GetJsonObjectNumberItem(root, JSON_KEY_MTU_SIZE, (int32_t *)&(appInfo->peerData.dataConfig))) {
830         TRANS_LOGD(TRANS_CTRL, "peer dataconfig is null.");
831     }
832 
833     int32_t ret = SOFTBUS_TRANS_UNPACK_HANDSHAKE_MSG_FAILED;
834     if (appInfo->appType == APP_TYPE_NORMAL) {
835         ret = TransProxyUnpackNormalHandshakeMsg(root, appInfo, sessionKey, BASE64KEY);
836         if (ret != SOFTBUS_OK) {
837             goto ERR_EXIT;
838         }
839     } else if (appInfo->appType == APP_TYPE_AUTH) {
840         ret = TransProxyUnpackAuthHandshakeMsg(root, appInfo);
841         if (ret != SOFTBUS_OK) {
842             goto ERR_EXIT;
843         }
844     } else {
845         ret = TransProxyUnpackInnerHandshakeMsg(root, appInfo, sessionKey, BASE64KEY);
846         if (ret != SOFTBUS_OK) {
847             goto ERR_EXIT;
848         }
849     }
850 
851     GetJsonObjectNumberItem(root, JSON_KEY_TRANS_FLAGS, &appInfo->transFlag);
852     if (((uint32_t)appInfo->transFlag & TRANS_FLAG_HAS_CHANNEL_AUTH) != 0) {
853         GetJsonObjectNumber64Item(root, JSON_KEY_AUTH_SEQ, &appInfo->authSeq);
854     }
855 
856     cJSON_Delete(root);
857     (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
858     return SOFTBUS_OK;
859 ERR_EXIT:
860     cJSON_Delete(root);
861     (void)memset_s(sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
862     return ret;
863 }
864 
TransProxyPackIdentity(const char * identity)865 char *TransProxyPackIdentity(const char *identity)
866 {
867     cJSON *root = NULL;
868     char *buf = NULL;
869 
870     if (identity == NULL) {
871         TRANS_LOGE(TRANS_CTRL, "invalid param.");
872         return NULL;
873     }
874 
875     root = cJSON_CreateObject();
876     if (root == NULL) {
877         TRANS_LOGE(TRANS_CTRL, "create json object failed.");
878         return NULL;
879     }
880 
881     if (!AddStringToJsonObject(root, JSON_KEY_IDENTITY, identity)) {
882         TRANS_LOGE(TRANS_CTRL, "add identity to json object failed.");
883         cJSON_Delete(root);
884         return NULL;
885     }
886 
887     buf = cJSON_PrintUnformatted(root);
888     cJSON_Delete(root);
889     return buf;
890 }
891 
TransProxyUnpackIdentity(const char * msg,char * identity,uint32_t identitySize,int32_t len)892 int32_t TransProxyUnpackIdentity(const char *msg, char *identity, uint32_t identitySize, int32_t len)
893 {
894     cJSON *root = NULL;
895 
896     root = cJSON_ParseWithLength(msg, len);
897     if (root == NULL) {
898         TRANS_LOGE(TRANS_CTRL, "parse json failed.");
899         return SOFTBUS_PARSE_JSON_ERR;
900     }
901 
902     if (!GetJsonObjectStringItem(root, JSON_KEY_IDENTITY, identity, identitySize)) {
903         TRANS_LOGE(TRANS_CTRL, "fail to get json item");
904         cJSON_Delete(root);
905         return SOFTBUS_PARSE_JSON_ERR;
906     }
907 
908     cJSON_Delete(root);
909     return SOFTBUS_OK;
910 }
911 
TransProxyEncryptFastData(const char * sessionKey,int32_t seq,const char * in,uint32_t inLen,char * out,uint32_t * outLen)912 static int32_t TransProxyEncryptFastData(const char *sessionKey, int32_t seq, const char *in, uint32_t inLen,
913     char *out, uint32_t *outLen)
914 {
915     AesGcmCipherKey cipherKey = { 0 };
916     cipherKey.keyLen = SESSION_KEY_LENGTH;
917     if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
918         TRANS_LOGE(TRANS_CTRL, "memcpy key error.");
919         return SOFTBUS_MEM_ERR;
920     }
921 
922     int ret = SoftBusEncryptDataWithSeq(&cipherKey, (unsigned char*)in, inLen,
923         (unsigned char*)out, outLen, seq);
924     (void)memset_s(cipherKey.key, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
925 
926     if (ret != SOFTBUS_OK || *outLen != inLen + OVERHEAD_LEN) {
927         TRANS_LOGE(TRANS_CTRL, "encrypt error, ret=%{public}d.", ret);
928         return SOFTBUS_ENCRYPT_ERR;
929     }
930     return SOFTBUS_OK;
931 }
932 
FastDataPackPacketHead(PacketFastHead * data)933 static void FastDataPackPacketHead(PacketFastHead *data)
934 {
935     data->magicNumber = (int32_t)SoftBusHtoLl((uint32_t)data->magicNumber);
936     data->seq = (int32_t)SoftBusHtoLl((uint32_t)data->seq);
937     data->flags = (int32_t)SoftBusHtoLl((uint32_t)data->flags);
938     data->dataLen = (int32_t)SoftBusHtoLl((uint32_t)data->dataLen);
939 }
940 
TransProxyPackFastDataHead(ProxyDataInfo * dataInfo,const AppInfo * appInfo)941 static int32_t TransProxyPackFastDataHead(ProxyDataInfo *dataInfo, const AppInfo *appInfo)
942 {
943 #define MAGIC_NUMBER 0xBABEFACE
944     if (dataInfo == NULL || appInfo ==NULL) {
945         TRANS_LOGE(TRANS_CTRL, "invaild param.");
946         return SOFTBUS_INVALID_PARAM;
947     }
948     dataInfo->outLen = dataInfo->inLen + OVERHEAD_LEN + sizeof(PacketFastHead);
949     uint32_t cipherLength = dataInfo->inLen + OVERHEAD_LEN;
950     dataInfo->outData = (uint8_t *)SoftBusCalloc(dataInfo->outLen);
951     if (dataInfo->outData == NULL) {
952         TRANS_LOGE(TRANS_CTRL, "calloc error");
953         return SOFTBUS_MALLOC_ERR;
954     }
955 
956     int32_t seq = atomic_fetch_add_explicit(&g_proxyPktHeadSeq, 1, memory_order_relaxed);
957     if (TransProxyEncryptFastData(appInfo->sessionKey, seq, (const char*)dataInfo->inData,
958         dataInfo->inLen, (char*)dataInfo->outData + sizeof(PacketFastHead), &cipherLength) != SOFTBUS_OK) {
959         SoftBusFree(dataInfo->outData);
960         TRANS_LOGE(TRANS_CTRL, "TransProxyEncryptFastData err");
961         return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
962     }
963 
964     PacketFastHead *pktHead = (PacketFastHead*)dataInfo->outData;
965     pktHead->magicNumber = MAGIC_NUMBER;
966     pktHead->seq = seq;
967     pktHead->flags = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE;
968     pktHead->dataLen = (int32_t)cipherLength;
969     FastDataPackPacketHead(pktHead);
970 
971     return SOFTBUS_OK;
972 }
973 
FastDataPackSliceHead(SliceFastHead * data)974 static void FastDataPackSliceHead(SliceFastHead *data)
975 {
976     data->priority = (int32_t)SoftBusHtoLl((uint32_t)data->priority);
977     data->sliceNum = (int32_t)SoftBusHtoLl((uint32_t)data->sliceNum);
978     data->sliceSeq = (int32_t)SoftBusHtoLl((uint32_t)data->sliceSeq);
979     data->reserved = (int32_t)SoftBusHtoLl((uint32_t)data->reserved);
980 }
TransProxyMessageData(const AppInfo * appInfo,ProxyDataInfo * dataInfo)981 static int32_t TransProxyMessageData(const AppInfo *appInfo, ProxyDataInfo *dataInfo)
982 {
983     dataInfo->inData = (uint8_t *)SoftBusMalloc(appInfo->fastTransDataSize);
984     if (dataInfo->inData == NULL) {
985         TRANS_LOGE(TRANS_CTRL, "malloc error");
986         return SOFTBUS_MALLOC_ERR;
987     }
988     uint16_t fastDataSize = appInfo->fastTransDataSize;
989     if (memcpy_s(dataInfo->inData, fastDataSize, appInfo->fastTransData, fastDataSize) != EOK) {
990         TRANS_LOGE(TRANS_CTRL, "memcpy_s fastTransData error.");
991         SoftBusFree(dataInfo->inData);
992         return SOFTBUS_MEM_ERR;
993     }
994     dataInfo->inLen = fastDataSize;
995     return SOFTBUS_OK;
996 }
997 
TransProxyByteData(const AppInfo * appInfo,ProxyDataInfo * dataInfo)998 static int32_t TransProxyByteData(const AppInfo *appInfo, ProxyDataInfo *dataInfo)
999 {
1000     dataInfo->inData = (uint8_t *)SoftBusMalloc(appInfo->fastTransDataSize + sizeof(SessionHead));
1001     if (dataInfo->inData == NULL) {
1002         TRANS_LOGE(TRANS_CTRL, "malloc error");
1003         return SOFTBUS_MALLOC_ERR;
1004     }
1005     uint16_t fastDataSize = appInfo->fastTransDataSize;
1006     SessionHead *sessionHead = (SessionHead*)dataInfo->inData;
1007     sessionHead->seq = atomic_fetch_add_explicit(&g_proxyPktHeadSeq, 1, memory_order_relaxed);
1008     sessionHead->packetFlag = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE;
1009     sessionHead->shouldAck = 0;
1010     if (memcpy_s(dataInfo->inData + sizeof(SessionHead), fastDataSize, appInfo->fastTransData, fastDataSize) != EOK) {
1011         TRANS_LOGE(TRANS_CTRL, "memcpy_s fastTransData error.");
1012         SoftBusFree(dataInfo->inData);
1013         return SOFTBUS_MEM_ERR;
1014     }
1015     dataInfo->inLen = fastDataSize + sizeof(SessionHead);
1016     return SOFTBUS_OK;
1017 }
1018 
TransProxyPackFastData(const AppInfo * appInfo,uint32_t * outLen)1019 char *TransProxyPackFastData(const AppInfo *appInfo, uint32_t *outLen)
1020 {
1021     ProxyDataInfo dataInfo = {0};
1022     if (appInfo->businessType == BUSINESS_TYPE_MESSAGE && appInfo->routeType == WIFI_STA) {
1023         if (TransProxyMessageData(appInfo, &dataInfo) != SOFTBUS_OK) {
1024             TRANS_LOGE(TRANS_CTRL, "TransProxyMessageData error");
1025             return NULL;
1026         }
1027     } else {
1028         if (TransProxyByteData(appInfo, &dataInfo) != SOFTBUS_OK) {
1029             TRANS_LOGE(TRANS_CTRL, "TransProxyByteData error");
1030             return NULL;
1031         }
1032     }
1033     if (TransProxyPackFastDataHead(&dataInfo, appInfo) != SOFTBUS_OK) {
1034         TRANS_LOGE(TRANS_CTRL, "TransProxyPackFastDataHead error");
1035         SoftBusFree(dataInfo.inData);
1036         return NULL;
1037     }
1038 
1039     char *sliceData = (char *)SoftBusMalloc(dataInfo.outLen + sizeof(SliceFastHead));
1040     if (sliceData == NULL) {
1041         TRANS_LOGE(TRANS_CTRL, "malloc slice data error");
1042         SoftBusFree(dataInfo.inData);
1043         SoftBusFree(dataInfo.outData);
1044         return NULL;
1045     }
1046     SliceFastHead *slicehead = (SliceFastHead*)sliceData;
1047     slicehead->priority = (appInfo->businessType == BUSINESS_TYPE_BYTE) ? FLAG_BYTES : FLAG_MESSAGE;
1048     slicehead->sliceNum = 1;
1049     slicehead->sliceSeq = 0;
1050     FastDataPackSliceHead(slicehead);
1051     if (memcpy_s(sliceData + sizeof(SliceFastHead), dataInfo.outLen, dataInfo.outData, dataInfo.outLen) != EOK) {
1052         TRANS_LOGE(TRANS_CTRL, "memcpy_s error");
1053         SoftBusFree(dataInfo.inData);
1054         SoftBusFree(dataInfo.outData);
1055         SoftBusFree(sliceData);
1056         return NULL;
1057     }
1058     *outLen = dataInfo.outLen + sizeof(SliceFastHead);
1059     SoftBusFree(dataInfo.inData);
1060     SoftBusFree(dataInfo.outData);
1061     return sliceData;
1062 }
1063