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_control.h"
17
18 #include <securec.h>
19 #include <string.h>
20
21 #include "auth_interface.h"
22 #include "cJSON.h"
23 #include "softbus_def.h"
24 #include "softbus_errcode.h"
25 #include "softbus_log.h"
26 #include "softbus_proxychannel_manager.h"
27 #include "softbus_proxychannel_message.h"
28 #include "softbus_proxychannel_transceiver.h"
29 #include "softbus_utils.h"
30
TransProxySendInnerMessage(ProxyChannelInfo * info,const char * payLoad,uint32_t payLoadLen,int32_t priority)31 NO_SANITIZE("cfi") int32_t TransProxySendInnerMessage(ProxyChannelInfo *info, const char *payLoad,
32 uint32_t payLoadLen, int32_t priority)
33 {
34 if (info == NULL) {
35 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
36 return SOFTBUS_INVALID_PARAM;
37 }
38
39 ProxyDataInfo dataInfo = {0};
40 ProxyMessageHead msgHead = {0};
41 msgHead.type = (PROXYCHANNEL_MSG_TYPE_NORMAL & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
42 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
43 msgHead.myId = info->myId;
44 msgHead.peerId = info->peerId;
45
46 dataInfo.inData = (uint8_t *)payLoad;
47 dataInfo.inLen = payLoadLen;
48 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
49 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack msg error");
50 return SOFTBUS_TRANS_PROXY_PACKMSG_ERR;
51 }
52 return TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
53 priority, info->appInfo.myData.pid);
54 }
55
SetCipherOfHandshakeMsg(uint32_t channelId,uint8_t * cipher)56 static int32_t SetCipherOfHandshakeMsg(uint32_t channelId, uint8_t *cipher)
57 {
58 int64_t authId = TransProxyGetAuthId(channelId);
59 if (authId == AUTH_INVALID_ID) {
60 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get authId fail");
61 return SOFTBUS_ERR;
62 }
63 AuthConnInfo connInfo;
64 (void)memset_s(&connInfo, sizeof(AuthConnInfo), 0, sizeof(AuthConnInfo));
65 if (AuthGetConnInfo(authId, &connInfo) != SOFTBUS_OK) {
66 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get auth connInfo fail");
67 return SOFTBUS_ERR;
68 }
69 bool isAuthServer = false;
70 if (AuthGetServerSide(authId, &isAuthServer) != SOFTBUS_OK) {
71 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "get auth server side fail");
72 return SOFTBUS_ERR;
73 }
74
75 *cipher |= ENCRYPTED;
76 if (isAuthServer) {
77 *cipher |= AUTH_SERVER_SIDE;
78 }
79 if (connInfo.type == AUTH_LINK_TYPE_BLE) {
80 *cipher |= USE_BLE_CIPHER;
81 }
82 return SOFTBUS_OK;
83 }
84
TransProxyHandshake(ProxyChannelInfo * info)85 NO_SANITIZE("cfi") int32_t TransProxyHandshake(ProxyChannelInfo *info)
86 {
87 if (info == NULL) {
88 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
89 return SOFTBUS_INVALID_PARAM;
90 }
91 char *payLoad = NULL;
92 ProxyDataInfo dataInfo = {0};
93 ProxyMessageHead msgHead = {0};
94 msgHead.type = (PROXYCHANNEL_MSG_TYPE_HANDSHAKE & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
95 msgHead.cipher = CS_MODE;
96 if (info->appInfo.appType != APP_TYPE_AUTH) {
97 if (SetCipherOfHandshakeMsg(info->channelId, &msgHead.cipher) != SOFTBUS_OK) {
98 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "set cipher fail");
99 return SOFTBUS_ERR;
100 }
101 }
102 msgHead.myId = info->myId;
103 msgHead.peerId = INVALID_CHANNEL_ID;
104 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO,
105 "handshake myId=%d cipher=0x%02x", msgHead.myId, msgHead.cipher);
106 payLoad = TransProxyPackHandshakeMsg(info);
107 if (payLoad == NULL) {
108 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake fail");
109 return SOFTBUS_ERR;
110 }
111 dataInfo.inData = (uint8_t *)payLoad;
112 dataInfo.inLen = strlen(payLoad) + 1;
113 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
114 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake head fail");
115 cJSON_free(payLoad);
116 return SOFTBUS_ERR;
117 }
118 cJSON_free(payLoad);
119 dataInfo.inData = NULL;
120
121 if (TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
122 CONN_HIGH, info->appInfo.myData.pid) != SOFTBUS_OK) {
123 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send handshake buf fail");
124 return SOFTBUS_ERR;
125 }
126 return SOFTBUS_OK;
127 }
128
TransProxyAckHandshake(uint32_t connId,ProxyChannelInfo * chan,int32_t retCode)129 NO_SANITIZE("cfi") int32_t TransProxyAckHandshake(uint32_t connId, ProxyChannelInfo *chan, int32_t retCode)
130 {
131 if (chan == NULL) {
132 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
133 return SOFTBUS_INVALID_PARAM;
134 }
135 char *payLoad = NULL;
136 ProxyDataInfo dataInfo = {0};
137 ProxyMessageHead msgHead = {0};
138 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send handshake ack msg myid %d peerid %d",
139 chan->myId, chan->peerId);
140 msgHead.type = (PROXYCHANNEL_MSG_TYPE_HANDSHAKE_ACK & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
141 if (chan->appInfo.appType != APP_TYPE_AUTH) {
142 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
143 }
144 msgHead.myId = chan->myId;
145 msgHead.peerId = chan->peerId;
146
147 if (retCode != SOFTBUS_OK) {
148 payLoad = TransProxyPackHandshakeErrMsg(retCode);
149 } else {
150 payLoad = TransProxyPackHandshakeAckMsg(chan);
151 }
152 if (payLoad == NULL) {
153 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake ack fail");
154 return SOFTBUS_ERR;
155 }
156 dataInfo.inData = (uint8_t *)payLoad;
157 dataInfo.inLen = strlen(payLoad) + 1;
158 if (TransProxyPackMessage(&msgHead, chan->authId, &dataInfo) != SOFTBUS_OK) {
159 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack handshake ack head fail");
160 cJSON_free(payLoad);
161 return SOFTBUS_ERR;
162 }
163 cJSON_free(payLoad);
164 if (TransProxyTransSendMsg(connId, dataInfo.outData, dataInfo.outLen,
165 CONN_HIGH, chan->appInfo.myData.pid) != SOFTBUS_OK) {
166 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send handshakeack buf fail");
167 return SOFTBUS_ERR;
168 }
169 return SOFTBUS_OK;
170 }
171
TransProxyKeepalive(uint32_t connId,const ProxyChannelInfo * info)172 NO_SANITIZE("cfi") void TransProxyKeepalive(uint32_t connId, const ProxyChannelInfo *info)
173 {
174 if (info == NULL) {
175 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
176 return;
177 }
178
179 char *payLoad = NULL;
180 ProxyDataInfo dataInfo = {0};
181 ProxyMessageHead msgHead = {0};
182 msgHead.type = (PROXYCHANNEL_MSG_TYPE_KEEPALIVE & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
183 msgHead.myId = info->myId;
184 msgHead.peerId = info->peerId;
185 if (info->appInfo.appType != APP_TYPE_AUTH) {
186 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
187 }
188
189 payLoad = TransProxyPackIdentity(info->identity);
190 if (payLoad == NULL) {
191 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive fail");
192 return;
193 }
194 dataInfo.inData = (uint8_t *)payLoad;
195 dataInfo.inLen = strlen(payLoad) + 1;
196 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
197 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive head fail");
198 cJSON_free(payLoad);
199 return;
200 }
201 cJSON_free(payLoad);
202 if (TransProxyTransSendMsg(connId, dataInfo.outData, dataInfo.outLen,
203 CONN_HIGH, info->appInfo.myData.pid) != SOFTBUS_OK) {
204 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send keepalive buf fail");
205 return;
206 }
207 }
208
TransProxyAckKeepalive(ProxyChannelInfo * info)209 NO_SANITIZE("cfi") int32_t TransProxyAckKeepalive(ProxyChannelInfo *info)
210 {
211 if (info == NULL) {
212 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
213 return SOFTBUS_INVALID_PARAM;
214 }
215 char *payLoad = NULL;
216 ProxyDataInfo dataInfo = {0};
217 ProxyMessageHead msgHead = {0};
218 msgHead.type = (PROXYCHANNEL_MSG_TYPE_KEEPALIVE_ACK & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
219 msgHead.myId = info->myId;
220 msgHead.peerId = info->peerId;
221 if (info->appInfo.appType != APP_TYPE_AUTH) {
222 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
223 }
224
225 payLoad = TransProxyPackIdentity(info->identity);
226 if (payLoad == NULL) {
227 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive ack fail");
228 return SOFTBUS_ERR;
229 }
230 dataInfo.inData = (uint8_t *)payLoad;
231 dataInfo.inLen = strlen(payLoad) + 1;
232 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
233 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack keepalive ack head fail");
234 cJSON_free(payLoad);
235 return SOFTBUS_ERR;
236 }
237 cJSON_free(payLoad);
238 if (TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
239 CONN_HIGH, info->appInfo.myData.pid) != SOFTBUS_OK) {
240 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send keepalive ack buf fail");
241 return SOFTBUS_ERR;
242 }
243 return SOFTBUS_OK;
244 }
245
TransProxyResetPeer(ProxyChannelInfo * info)246 NO_SANITIZE("cfi") int32_t TransProxyResetPeer(ProxyChannelInfo *info)
247 {
248 if (info == NULL) {
249 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "[%s] invalid param.", __func__);
250 return SOFTBUS_INVALID_PARAM;
251 }
252
253 char *payLoad = NULL;
254 ProxyDataInfo dataInfo = {0};
255 ProxyMessageHead msgHead = {0};
256 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_INFO, "send reset msg myId %d peerid %d", info->myId, info->peerId);
257 msgHead.type = (PROXYCHANNEL_MSG_TYPE_RESET & FOUR_BIT_MASK) | (VERSION << VERSION_SHIFT);
258 msgHead.myId = info->myId;
259 msgHead.peerId = info->peerId;
260 if (info->appInfo.appType != APP_TYPE_AUTH) {
261 msgHead.cipher = (msgHead.cipher | ENCRYPTED);
262 }
263
264 payLoad = TransProxyPackIdentity(info->identity);
265 if (payLoad == NULL) {
266 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack reset fail");
267 return SOFTBUS_ERR;
268 }
269 dataInfo.inData = (uint8_t *)payLoad;
270 dataInfo.inLen = strlen(payLoad) + 1;
271 if (TransProxyPackMessage(&msgHead, info->authId, &dataInfo) != SOFTBUS_OK) {
272 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "pack reset head fail");
273 cJSON_free(payLoad);
274 return SOFTBUS_ERR;
275 }
276 cJSON_free(payLoad);
277 if (TransProxyTransSendMsg(info->connId, dataInfo.outData, dataInfo.outLen,
278 CONN_LOW, info->appInfo.myData.pid) != SOFTBUS_OK) {
279 SoftBusLog(SOFTBUS_LOG_TRAN, SOFTBUS_LOG_ERROR, "send reset buf fail");
280 return SOFTBUS_ERR;
281 }
282 return SOFTBUS_OK;
283 }
284