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