1 /*
2 * Copyright (c) 2025 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 "trans_proxy_process_data.h"
17
18 #include <securec.h>
19
20 #include "softbus_adapter_crypto.h"
21 #include "softbus_adapter_mem.h"
22 #include "softbus_adapter_socket.h"
23 #include "softbus_adapter_thread.h"
24 #include "softbus_error_code.h"
25 #include "softbus_feature_config.h"
26 #include "softbus_socket.h"
27 #include "softbus_utils.h"
28 #include "trans_assemble_tlv.h"
29 #include "trans_log.h"
30
31 #define SLICE_LEN (4 * 1024)
32 #define SHORT_SLICE_LEN (1024)
33 #define PROXY_TLV_ELEMENT 5
34 #define TLV_TYPE_AND_LENTH 2
35 #define PROXY_TLV_PKT_HEAD 32
36 #define MAGICNUM_SIZE sizeof(uint32_t)
37 #define TLVCOUNT_SIZE sizeof(uint8_t)
38 static uint32_t g_proxyMaxByteBufSize = 0;
39 static uint32_t g_proxyMaxMessageBufSize = 0;
40
TransGetProxyDataBufMaxSize(void)41 void TransGetProxyDataBufMaxSize(void)
42 {
43 if (SoftbusGetConfig(SOFTBUS_INT_MAX_BYTES_NEW_LENGTH, (unsigned char *)&g_proxyMaxByteBufSize,
44 sizeof(g_proxyMaxByteBufSize)) != SOFTBUS_OK) {
45 TRANS_LOGE(TRANS_INIT, "get proxy channel max bytes length fail");
46 }
47 if (SoftbusGetConfig(SOFTBUS_INT_MAX_MESSAGE_NEW_LENGTH, (unsigned char *)&g_proxyMaxMessageBufSize,
48 sizeof(g_proxyMaxMessageBufSize)) != SOFTBUS_OK) {
49 TRANS_LOGE(TRANS_INIT, "get proxy channel max message length fail");
50 }
51 TRANS_LOGI(TRANS_INIT, "proxy auth byteSize=%{public}u, mesageSize=%{public}u",
52 g_proxyMaxByteBufSize, g_proxyMaxMessageBufSize);
53 }
54
TransUnPackTlvPackHead(DataHeadTlvPacketHead * data)55 void TransUnPackTlvPackHead(DataHeadTlvPacketHead *data)
56 {
57 if (data == NULL) {
58 TRANS_LOGE(TRANS_CTRL, "invalid data");
59 return;
60 }
61 data->magicNumber = SoftBusLtoHl(data->magicNumber);
62 data->seq = (int32_t)SoftBusLtoHl((uint32_t)data->seq);
63 data->dataSeq = SoftBusLtoHl(data->dataSeq);
64 data->flags = SoftBusLtoHl(data->flags);
65 data->dataLen = SoftBusLtoHl(data->dataLen);
66 }
67
TransPackSliceHead(SliceHead * data)68 static void TransPackSliceHead(SliceHead *data)
69 {
70 data->priority = (int32_t)SoftBusHtoLl((uint32_t)data->priority);
71 data->sliceNum = (int32_t)SoftBusHtoLl((uint32_t)data->sliceNum);
72 data->sliceSeq = (int32_t)SoftBusHtoLl((uint32_t)data->sliceSeq);
73 data->reserved = (int32_t)SoftBusHtoLl((uint32_t)data->reserved);
74 }
75
TransUnPackSliceHead(SliceHead * data)76 void TransUnPackSliceHead(SliceHead *data)
77 {
78 if (data == NULL) {
79 TRANS_LOGE(TRANS_CTRL, "invalid data");
80 return;
81 }
82 data->priority = (int32_t)SoftBusLtoHl((uint32_t)data->priority);
83 data->sliceNum = (int32_t)SoftBusLtoHl((uint32_t)data->sliceNum);
84 data->sliceSeq = (int32_t)SoftBusLtoHl((uint32_t)data->sliceSeq);
85 data->reserved = (int32_t)SoftBusLtoHl((uint32_t)data->reserved);
86 }
87
TransPackPacketHead(PacketHead * data)88 static void TransPackPacketHead(PacketHead *data)
89 {
90 data->magicNumber = (int32_t)SoftBusHtoLl((uint32_t)data->magicNumber);
91 data->seq = (int32_t)SoftBusHtoLl((uint32_t)data->seq);
92 data->flags = (int32_t)SoftBusHtoLl((uint32_t)data->flags);
93 data->dataLen = (int32_t)SoftBusHtoLl((uint32_t)data->dataLen);
94 }
95
TransUnPackPacketHead(PacketHead * data)96 static void TransUnPackPacketHead(PacketHead *data)
97 {
98 data->magicNumber = (int32_t)SoftBusLtoHl((uint32_t)data->magicNumber);
99 data->seq = (int32_t)SoftBusLtoHl((uint32_t)data->seq);
100 data->flags = (int32_t)SoftBusLtoHl((uint32_t)data->flags);
101 data->dataLen = (int32_t)SoftBusLtoHl((uint32_t)data->dataLen);
102 }
103
TransProxyPackBytes(int32_t channelId,ProxyDataInfo * dataInfo,const char * sessionKey,SessionPktType flag,int32_t seq)104 int32_t TransProxyPackBytes(
105 int32_t channelId, ProxyDataInfo *dataInfo, const char *sessionKey, SessionPktType flag, int32_t seq)
106 {
107 if (dataInfo == NULL || sessionKey == NULL) {
108 TRANS_LOGE(TRANS_CTRL, "invalid para");
109 return SOFTBUS_INVALID_PARAM;
110 }
111 dataInfo->outLen = dataInfo->inLen + OVERHEAD_LEN + sizeof(PacketHead);
112 dataInfo->outData = (uint8_t *)SoftBusCalloc(dataInfo->outLen);
113 if (dataInfo->outData == NULL) {
114 TRANS_LOGE(TRANS_CTRL, "malloc failed");
115 return SOFTBUS_MEM_ERR;
116 }
117
118 uint32_t outLen = 0;
119 AesGcmCipherKey cipherKey = { 0 };
120 cipherKey.keyLen = SESSION_KEY_LENGTH;
121 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
122 TRANS_LOGE(TRANS_CTRL, "memcpy key failed");
123 SoftBusFree(dataInfo->outData);
124 return SOFTBUS_MEM_ERR;
125 }
126 char *outData = (char *)dataInfo->outData + sizeof(PacketHead);
127 int32_t ret = SoftBusEncryptDataWithSeq(&cipherKey, (const unsigned char *)dataInfo->inData,
128 dataInfo->inLen, (unsigned char *)outData, &outLen, seq);
129 (void)memset_s(cipherKey.key, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
130
131 if (ret != SOFTBUS_OK || outLen != dataInfo->inLen + OVERHEAD_LEN) {
132 outData = NULL;
133 SoftBusFree(dataInfo->outData);
134 TRANS_LOGE(TRANS_CTRL, "encrypt error, channelId=%{public}d, ret=%{public}d", channelId, ret);
135 return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
136 }
137 PacketHead *pktHead = (PacketHead *)dataInfo->outData;
138 pktHead->magicNumber = MAGIC_NUMBER;
139 pktHead->seq = seq;
140 pktHead->flags = flag;
141 pktHead->dataLen = (int32_t)((int32_t)dataInfo->outLen - sizeof(PacketHead));
142 TransPackPacketHead(pktHead);
143 return SOFTBUS_OK;
144 }
145
TransProxyPackTlvData(DataHead * pktHead,int32_t tlvBufferSize,uint32_t dataLen)146 static uint8_t *TransProxyPackTlvData(DataHead *pktHead, int32_t tlvBufferSize, uint32_t dataLen)
147 {
148 if (pktHead == NULL) {
149 TRANS_LOGE(TRANS_CTRL, "param invalid");
150 return NULL;
151 }
152 int32_t newDataHeadSize = MAGICNUM_SIZE + TLVCOUNT_SIZE + tlvBufferSize;
153 uint8_t *buf = (uint8_t *)SoftBusCalloc(dataLen + newDataHeadSize);
154 if (buf == NULL) {
155 TRANS_LOGE(TRANS_CTRL, "malloc buf failed");
156 return NULL;
157 }
158 if (memcpy_s(buf, dataLen + newDataHeadSize, &pktHead->magicNum, MAGICNUM_SIZE) != EOK) {
159 SoftBusFree(buf);
160 TRANS_LOGE(TRANS_CTRL, "memcpy magicNum failed");
161 return NULL;
162 }
163 if (memcpy_s(buf + MAGICNUM_SIZE, dataLen + newDataHeadSize, &pktHead->tlvCount, TLVCOUNT_SIZE) != EOK) {
164 SoftBusFree(buf);
165 TRANS_LOGE(TRANS_CTRL, "memcpy tlvCound failed");
166 return NULL;
167 }
168 uint8_t *temp = buf + MAGICNUM_SIZE + TLVCOUNT_SIZE;
169 for (int32_t index = 0; index < pktHead->tlvCount; index++) {
170 TlvElement *ement = (TlvElement *)pktHead->tlvElement;
171 if (memcpy_s(temp, dataLen + newDataHeadSize, &ement->type, sizeof(ement->type)) != EOK) {
172 SoftBusFree(buf);
173 TRANS_LOGE(TRANS_CTRL, "memcpy tlvEment type failed");
174 return NULL;
175 }
176
177 temp += sizeof(ement->type);
178 if (memcpy_s(temp, dataLen + newDataHeadSize, &ement->length, sizeof(ement->length)) != EOK) {
179 SoftBusFree(buf);
180 TRANS_LOGE(TRANS_CTRL, "memcpy tlvEment length failed");
181 return NULL;
182 }
183
184 temp += sizeof(ement->length);
185 if (memcpy_s(temp, dataLen + newDataHeadSize, ement->value, ement->length) != EOK) {
186 SoftBusFree(buf);
187 TRANS_LOGE(TRANS_CTRL, "memcpy tlvEment value failed");
188 return NULL;
189 }
190
191 temp += ement->length;
192 pktHead->tlvElement += sizeof(TlvElement);
193 }
194 return buf;
195 }
196
ProxyBuildTlvDataHead(DataHead * pktHead,int32_t finalSeq,int32_t flag,uint32_t dataLen,int32_t * tlvBufferSize)197 static int32_t ProxyBuildTlvDataHead(DataHead *pktHead, int32_t finalSeq, int32_t flag,
198 uint32_t dataLen, int32_t *tlvBufferSize)
199 {
200 if (pktHead == NULL) {
201 TRANS_LOGE(TRANS_CTRL, "param invalid");
202 return SOFTBUS_INVALID_PARAM;
203 }
204 pktHead->tlvElement = (uint8_t *)SoftBusCalloc(PROXY_TLV_ELEMENT * sizeof(TlvElement));
205 if (pktHead->tlvElement == NULL) {
206 TRANS_LOGE(TRANS_CTRL, "maoolc tlvElement failed");
207 return SOFTBUS_MEM_ERR;
208 }
209 pktHead->magicNum = SoftBusHtoLl(MAGIC_NUMBER);
210 uint32_t seq = SoftBusHtoLl((uint32_t)finalSeq);
211 uint32_t flags = SoftBusHtoLl((uint32_t)flag);
212 uint32_t dataLens = SoftBusHtoLl(dataLen);
213 int32_t ret = TransAssembleTlvData(pktHead, TLV_TYPE_INNER_SEQ, (uint8_t *)&seq, sizeof(seq), tlvBufferSize);
214 if (ret != SOFTBUS_OK) {
215 TRANS_LOGE(TRANS_CTRL, "assemble seq tlv failed, ret=%{public}d", ret);
216 ReleaseTlvValueBuffer(pktHead);
217 SoftBusFree(pktHead->tlvElement);
218 return ret;
219 }
220 ret = TransAssembleTlvData(pktHead, TLV_TYPE_FLAG, (uint8_t *)&flags, sizeof(flags), tlvBufferSize);
221 if (ret != SOFTBUS_OK) {
222 TRANS_LOGE(TRANS_CTRL, "assemble flag tlv failed, ret=%{public}d", ret);
223 ReleaseTlvValueBuffer(pktHead);
224 SoftBusFree(pktHead->tlvElement);
225 return ret;
226 }
227 ret = TransAssembleTlvData(pktHead, TLV_TYPE_DATA_LEN, (uint8_t *)&dataLens, sizeof(dataLens), tlvBufferSize);
228 if (ret != SOFTBUS_OK) {
229 TRANS_LOGE(TRANS_CTRL, "assemble dataLen tlv failed, ret=%{public}d", ret);
230 ReleaseTlvValueBuffer(pktHead);
231 SoftBusFree(pktHead->tlvElement);
232 return ret;
233 }
234 return SOFTBUS_OK;
235 }
236
ProxyBuildNeedAckTlvData(DataHead * pktHead,bool needAck,uint32_t dataSeqs,int32_t * tlvBufferSize)237 static int32_t ProxyBuildNeedAckTlvData(DataHead *pktHead, bool needAck, uint32_t dataSeqs, int32_t *tlvBufferSize)
238 {
239 if (pktHead == NULL) {
240 TRANS_LOGE(TRANS_CTRL, "param invalid");
241 return SOFTBUS_INVALID_PARAM;
242 }
243 uint32_t dataSeq = SoftBusHtoLl(dataSeqs);
244 int32_t ret = TransAssembleTlvData(pktHead, TLV_TYPE_NEED_ACK, (uint8_t *)&needAck, sizeof(needAck), tlvBufferSize);
245 if (ret != SOFTBUS_OK) {
246 TRANS_LOGE(TRANS_CTRL, "assemble needAck tlv failed, ret=%{public}d", ret);
247 ReleaseTlvValueBuffer(pktHead);
248 SoftBusFree(pktHead->tlvElement);
249 return ret;
250 }
251 ret = TransAssembleTlvData(pktHead, TLV_TYPE_DATA_SEQ, (uint8_t *)&dataSeq, sizeof(dataSeq), tlvBufferSize);
252 if (ret != SOFTBUS_OK) {
253 TRANS_LOGE(TRANS_CTRL, "assemble dataSeq tlv failed, ret=%{public}d", ret);
254 ReleaseTlvValueBuffer(pktHead);
255 SoftBusFree(pktHead->tlvElement);
256 return ret;
257 }
258 pktHead->tlvElement -= (PROXY_TLV_ELEMENT * sizeof(TlvElement));
259 return SOFTBUS_OK;
260 }
261
TransProxyPackTlvBytes(ProxyDataInfo * dataInfo,const char * sessionKey,SessionPktType flag,int32_t seq,DataHeadTlvPacketHead * info)262 int32_t TransProxyPackTlvBytes(
263 ProxyDataInfo *dataInfo, const char *sessionKey, SessionPktType flag, int32_t seq, DataHeadTlvPacketHead *info)
264 {
265 if (dataInfo == NULL || sessionKey == NULL || info == NULL) {
266 TRANS_LOGE(TRANS_CTRL, "param invalid");
267 return SOFTBUS_INVALID_PARAM;
268 }
269 uint32_t dataLen = dataInfo->inLen + OVERHEAD_LEN;
270 DataHead pktHead = { 0 };
271 int32_t tlvBufferSize = 0;
272 int32_t ret = ProxyBuildTlvDataHead(&pktHead, seq, flag, dataLen, &tlvBufferSize);
273 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "build tlv dataHead fail");
274 ret = ProxyBuildNeedAckTlvData(&pktHead, info->needAck, info->dataSeq, &tlvBufferSize);
275 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == SOFTBUS_OK, ret, TRANS_CTRL, "build tlv needAck fail");
276 dataInfo->outData = TransProxyPackTlvData(&pktHead, tlvBufferSize, dataLen);
277 if (dataInfo->outData == NULL) {
278 TRANS_LOGE(TRANS_CTRL, "pack tlv data failed");
279 ReleaseTlvValueBuffer(&pktHead);
280 SoftBusFree(pktHead.tlvElement);
281 return ret;
282 }
283 ReleaseTlvValueBuffer(&pktHead);
284 SoftBusFree(pktHead.tlvElement);
285 int32_t newDataHeadSize = MAGICNUM_SIZE + TLVCOUNT_SIZE + tlvBufferSize;
286 dataInfo->outLen = dataInfo->inLen + OVERHEAD_LEN + (uint32_t)newDataHeadSize;
287
288 uint32_t outLen = 0;
289 AesGcmCipherKey cipherKey = { 0 };
290 cipherKey.keyLen = SESSION_KEY_LENGTH;
291 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
292 TRANS_LOGE(TRANS_CTRL, "memcpy key failed");
293 SoftBusFree(dataInfo->outData);
294 return SOFTBUS_MEM_ERR;
295 }
296 char *outData = (char *)dataInfo->outData + newDataHeadSize;
297 ret = SoftBusEncryptDataWithSeq(&cipherKey, (const unsigned char*)dataInfo->inData,
298 dataInfo->inLen, (unsigned char*)outData, &outLen, seq);
299 (void)memset_s(cipherKey.key, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
300 if (ret != SOFTBUS_OK || outLen != dataInfo->inLen + OVERHEAD_LEN) {
301 TRANS_LOGE(TRANS_CTRL, "encrypt failed, ret=%{public}d", ret);
302 outData = NULL;
303 SoftBusFree(dataInfo->outData);
304 dataInfo->outData = NULL;
305 return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
306 }
307 return SOFTBUS_OK;
308 }
309
SessionPktTypeToProxyIndex(SessionPktType packetType)310 static int32_t SessionPktTypeToProxyIndex(SessionPktType packetType)
311 {
312 switch (packetType) {
313 case TRANS_SESSION_MESSAGE:
314 case TRANS_SESSION_ASYNC_MESSAGE:
315 case TRANS_SESSION_ACK:
316 return PROXY_CHANNEL_PRORITY_MESSAGE;
317 case TRANS_SESSION_BYTES:
318 return PROXY_CHANNEL_PRORITY_BYTES;
319 default:
320 return PROXY_CHANNEL_PRORITY_FILE;
321 }
322 }
323
TransProxyPackData(ProxyDataInfo * dataInfo,uint32_t sliceNum,SessionPktType pktType,uint32_t cnt,uint32_t * dataLen)324 uint8_t *TransProxyPackData(
325 ProxyDataInfo *dataInfo, uint32_t sliceNum, SessionPktType pktType, uint32_t cnt, uint32_t *dataLen)
326 {
327 if (dataLen == NULL || dataInfo == NULL) {
328 TRANS_LOGE(TRANS_CTRL, "param invalid");
329 return NULL;
330 }
331 *dataLen = (cnt == (sliceNum - 1)) ? (dataInfo->outLen - cnt * SLICE_LEN) : SLICE_LEN;
332 int32_t offset = (int32_t)(cnt * SLICE_LEN);
333
334 uint8_t *sliceData = (uint8_t *)SoftBusCalloc(*dataLen + sizeof(SliceHead));
335 if (sliceData == NULL) {
336 TRANS_LOGE(TRANS_CTRL, "malloc sliceData failed");
337 return NULL;
338 }
339 SliceHead *slicehead = (SliceHead *)sliceData;
340 slicehead->priority = SessionPktTypeToProxyIndex(pktType);
341 slicehead->sliceNum = (int32_t)sliceNum;
342 slicehead->sliceSeq = (int32_t)cnt;
343 TransPackSliceHead(slicehead);
344 if (memcpy_s(sliceData + sizeof(SliceHead), *dataLen, dataInfo->outData + offset, *dataLen) != EOK) {
345 TRANS_LOGE(TRANS_CTRL, "memcpy failed");
346 SoftBusFree(sliceData);
347 return NULL;
348 }
349 return sliceData;
350 }
351
TransProxyCheckSliceHead(const SliceHead * head)352 int32_t TransProxyCheckSliceHead(const SliceHead *head)
353 {
354 if (head == NULL) {
355 TRANS_LOGE(TRANS_CTRL, "invalid param");
356 return SOFTBUS_INVALID_PARAM;
357 }
358 if (head->priority < 0 || head->priority >= PROXY_CHANNEL_PRORITY_BUTT) {
359 TRANS_LOGE(TRANS_CTRL, "invalid index=%{public}d", head->priority);
360 return SOFTBUS_INVALID_DATA_HEAD;
361 }
362 if (head->sliceNum != 1 && head->sliceSeq >= head->sliceNum) {
363 TRANS_LOGE(TRANS_CTRL, "sliceNum=%{public}d, sliceSeq=%{public}d", head->sliceNum, head->sliceSeq);
364 return SOFTBUS_INVALID_DATA_HEAD;
365 }
366 return SOFTBUS_OK;
367 }
368
TransProxyNoSubPacketProc(PacketHead * head,uint32_t len,const char * data,int32_t channelId)369 int32_t TransProxyNoSubPacketProc(PacketHead *head, uint32_t len, const char *data, int32_t channelId)
370 {
371 if (head == NULL || data == NULL) {
372 TRANS_LOGE(TRANS_CTRL, "invalid param, channelId=%{public}d", channelId);
373 return SOFTBUS_INVALID_PARAM;
374 }
375 if (len < sizeof(PacketHead)) {
376 TRANS_LOGE(TRANS_CTRL, "check len failed, len=%{public}d", len);
377 return SOFTBUS_INVALID_PARAM;
378 }
379 if (memcpy_s(head, sizeof(PacketHead), data, sizeof(PacketHead)) != EOK) {
380 TRANS_LOGE(TRANS_CTRL, "memcpy packetHead failed");
381 return SOFTBUS_MEM_ERR;
382 }
383 TransUnPackPacketHead(head);
384 if ((uint32_t)head->magicNumber != MAGIC_NUMBER) {
385 TRANS_LOGE(TRANS_CTRL, "invalid magicNumber=%{public}x, channelId=%{public}d, len=%{public}d",
386 head->magicNumber, channelId, len);
387 return SOFTBUS_INVALID_DATA_HEAD;
388 }
389 if (head->dataLen <= 0) {
390 TRANS_LOGE(TRANS_CTRL, "invalid dataLen=%{public}d, channelId=%{public}d, len=%{public}d",
391 head->dataLen, channelId, len);
392 return SOFTBUS_INVALID_DATA_HEAD;
393 }
394 TRANS_LOGD(TRANS_CTRL, "NoSubPacketProc, dataLen=%{public}d, inputLen=%{public}d", head->dataLen, len);
395 if (len <= sizeof(PacketHead) || (head->dataLen != (int32_t)(len - sizeof(PacketHead)))) {
396 TRANS_LOGE(TRANS_CTRL, "dataLen error channelId=%{public}d, len=%{public}d, dataLen=%{public}d",
397 channelId, len, head->dataLen);
398 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
399 }
400 return SOFTBUS_OK;
401 }
402
TransProxyProcessSessionData(ProxyDataInfo * dataInfo,const PacketHead * dataHead,const char * data)403 int32_t TransProxyProcessSessionData(ProxyDataInfo *dataInfo, const PacketHead *dataHead, const char *data)
404 {
405 if (dataInfo == NULL || data == NULL || dataHead == NULL) {
406 TRANS_LOGE(TRANS_CTRL, "invalid param");
407 return SOFTBUS_INVALID_PARAM;
408 }
409 uint32_t outLen = 0;
410 if (dataHead->dataLen <= OVERHEAD_LEN) {
411 TRANS_LOGE(TRANS_CTRL, "invalid data head dataLen=%{public}d", dataHead->dataLen);
412 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
413 }
414 outLen = dataHead->dataLen - OVERHEAD_LEN;
415 dataInfo->outData = (unsigned char *)SoftBusCalloc(outLen);
416 if (dataInfo->outData == NULL) {
417 TRANS_LOGE(TRANS_CTRL, "malloc fail when process session out data");
418 return SOFTBUS_MALLOC_ERR;
419 }
420 dataInfo->inData = (unsigned char *)data;
421 dataInfo->inLen = dataHead->dataLen;
422 dataInfo->outLen = outLen;
423 return SOFTBUS_OK;
424 }
425
TransProxyClearProcessor(SliceProcessor * processor)426 void TransProxyClearProcessor(SliceProcessor *processor)
427 {
428 if (processor == NULL) {
429 TRANS_LOGE(TRANS_CTRL, "invalid param");
430 return;
431 }
432 if (processor->data != NULL) {
433 SoftBusFree(processor->data);
434 processor->data = NULL;
435 }
436 processor->active = false;
437 processor->bufLen = 0;
438 processor->dataLen = 0;
439 processor->expectedSeq = 0;
440 processor->sliceNumber = 0;
441 processor->timeout = 0;
442 }
443
TransProxyDecryptPacketData(int32_t seq,ProxyDataInfo * dataInfo,const char * sessionKey)444 int32_t TransProxyDecryptPacketData(int32_t seq, ProxyDataInfo *dataInfo, const char *sessionKey)
445 {
446 if (dataInfo == NULL || sessionKey == NULL) {
447 TRANS_LOGE(TRANS_CTRL, "invalid param");
448 return SOFTBUS_INVALID_PARAM;
449 }
450 AesGcmCipherKey cipherKey = { 0 };
451 cipherKey.keyLen = SESSION_KEY_LENGTH;
452 if (memcpy_s(cipherKey.key, SESSION_KEY_LENGTH, sessionKey, SESSION_KEY_LENGTH) != EOK) {
453 TRANS_LOGE(TRANS_CTRL, "memcpy key failed");
454 return SOFTBUS_MEM_ERR;
455 }
456 int32_t ret = SoftBusDecryptDataWithSeq(
457 &cipherKey, dataInfo->inData, dataInfo->inLen, dataInfo->outData, &(dataInfo->outLen), seq);
458 (void)memset_s(&cipherKey, sizeof(AesGcmCipherKey), 0, sizeof(AesGcmCipherKey));
459 if (ret != SOFTBUS_OK) {
460 TRANS_LOGE(TRANS_CTRL, "trans proxy Decrypt Data fail. ret=%{public}d", ret);
461 return SOFTBUS_DECRYPT_ERR;
462 }
463 return SOFTBUS_OK;
464 }
465
TransProxySessionDataLenCheck(uint32_t dataLen,SessionPktType type)466 int32_t TransProxySessionDataLenCheck(uint32_t dataLen, SessionPktType type)
467 {
468 switch (type) {
469 case TRANS_SESSION_MESSAGE:
470 case TRANS_SESSION_ASYNC_MESSAGE: {
471 if (dataLen > g_proxyMaxMessageBufSize) {
472 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
473 }
474 break;
475 }
476 case TRANS_SESSION_BYTES: {
477 if (dataLen > g_proxyMaxByteBufSize) {
478 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
479 }
480 break;
481 }
482 default: {
483 return SOFTBUS_OK;
484 }
485 }
486 return SOFTBUS_OK;
487 }
488
TransProxyFirstSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len,bool supportTlv)489 int32_t TransProxyFirstSliceProcess(
490 SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len, bool supportTlv)
491 {
492 if (processor == NULL || head == NULL || data == NULL) {
493 TRANS_LOGE(TRANS_CTRL, "invalid param");
494 return SOFTBUS_INVALID_PARAM;
495 }
496 uint32_t actualDataLen = 0;
497 uint32_t maxDataLen =
498 (head->priority == PROXY_CHANNEL_PRORITY_MESSAGE) ? g_proxyMaxMessageBufSize : g_proxyMaxByteBufSize;
499 // The encrypted data length is longer then the actual data length
500 maxDataLen += SLICE_LEN;
501
502 if ((head->sliceNum < 0) || ((uint32_t)head->sliceNum > (maxDataLen / SLICE_LEN))) {
503 TRANS_LOGE(TRANS_CTRL, "invalid sliceNum=%{public}d", head->sliceNum);
504 return SOFTBUS_INVALID_DATA_HEAD;
505 }
506 actualDataLen = head->sliceNum * SLICE_LEN;
507 uint32_t maxLen = 0;
508 if (supportTlv) {
509 maxLen = actualDataLen + PROXY_TLV_PKT_HEAD + OVERHEAD_LEN;
510 } else {
511 maxLen = actualDataLen + sizeof(PacketHead) + OVERHEAD_LEN;
512 }
513 processor->data = (char *)SoftBusCalloc(maxLen);
514 if (processor->data == NULL) {
515 TRANS_LOGE(TRANS_CTRL, "malloc fail when proc first slice package");
516 return SOFTBUS_MALLOC_ERR;
517 }
518 processor->bufLen = (int32_t)maxLen;
519 if (memcpy_s(processor->data, maxLen, data, len) != EOK) {
520 TRANS_LOGE(TRANS_CTRL, "memcpy fail when proce first slice package");
521 SoftBusFree(processor->data);
522 processor->data = NULL;
523 return SOFTBUS_MEM_ERR;
524 }
525 processor->sliceNumber = head->sliceNum;
526 processor->expectedSeq = 1;
527 processor->dataLen = (int32_t)len;
528 processor->active = true;
529 processor->timeout = 0;
530 TRANS_LOGI(TRANS_CTRL, "FirstSliceProcess ok");
531 return SOFTBUS_OK;
532 }
533
TransProxySliceProcessChkPkgIsValid(const SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)534 int32_t TransProxySliceProcessChkPkgIsValid(
535 const SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len)
536 {
537 (void)data;
538 if (processor == NULL || head == NULL) {
539 TRANS_LOGE(TRANS_CTRL, "invalid param");
540 return SOFTBUS_INVALID_PARAM;
541 }
542 if (head->sliceNum != processor->sliceNumber || head->sliceSeq != processor->expectedSeq) {
543 TRANS_LOGE(TRANS_CTRL, "unmatched normal slice received, head sliceNum=%{public}d, sliceSeq=%{public}d,\
544 processor sliceNumber=%{public}d, expectedSeq=%{public}d", head->sliceNum, head->sliceSeq,
545 processor->sliceNumber, processor->expectedSeq);
546 return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_NO_INVALID;
547 }
548 if (processor->dataLen > processor->bufLen || (int32_t)len > processor->bufLen - processor->dataLen) {
549 TRANS_LOGE(TRANS_CTRL, "invalid data len, len=%{public}u, dataLen=%{public}d", len, processor->dataLen);
550 return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_EXCEED_LENGTH;
551 }
552 if (processor->data == NULL) {
553 TRANS_LOGE(TRANS_CTRL, "data NULL");
554 return SOFTBUS_TRANS_PROXY_ASSEMBLE_PACK_DATA_NULL;
555 }
556 return SOFTBUS_OK;
557 }
558
TransGetActualDataLen(const SliceHead * head,uint32_t * actualDataLen)559 int32_t TransGetActualDataLen(const SliceHead *head, uint32_t *actualDataLen)
560 {
561 if (head == NULL || actualDataLen == NULL) {
562 TRANS_LOGE(TRANS_CTRL, "invalid param");
563 return SOFTBUS_INVALID_PARAM;
564 }
565 uint32_t maxDataLen =
566 (head->priority == PROXY_CHANNEL_PRORITY_MESSAGE) ? g_proxyMaxMessageBufSize : g_proxyMaxByteBufSize;
567 // The encrypted data length is longer than actual data length
568 maxDataLen += SLICE_LEN;
569
570 if ((head->sliceNum < 0) || ((uint32_t)head->sliceNum > (maxDataLen / SLICE_LEN))) {
571 TRANS_LOGE(TRANS_CTRL, "invalid sliceNum=%{public}d", head->sliceNum);
572 return SOFTBUS_INVALID_DATA_HEAD;
573 }
574
575 *actualDataLen = head->sliceNum * SLICE_LEN;
576 return SOFTBUS_OK;
577 }
578
TransProxyNormalSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len)579 int32_t TransProxyNormalSliceProcess(
580 SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len)
581 {
582 if (processor == NULL || head == NULL || data == NULL) {
583 TRANS_LOGE(TRANS_CTRL, "invalid param");
584 return SOFTBUS_INVALID_PARAM;
585 }
586 int32_t ret = TransProxySliceProcessChkPkgIsValid(processor, head, data, len);
587 if (ret != SOFTBUS_OK) {
588 return ret;
589 }
590 if (memcpy_s(processor->data + processor->dataLen,
591 (uint32_t)(processor->bufLen - processor->dataLen), data, len) != EOK) {
592 TRANS_LOGE(TRANS_CTRL, "memcpy fail when proc normal slice");
593 return SOFTBUS_MEM_ERR;
594 }
595 processor->expectedSeq++;
596 processor->dataLen += (int32_t)len;
597 processor->timeout = 0;
598 TRANS_LOGI(TRANS_CTRL, "NormalSliceProcess ok");
599 return SOFTBUS_OK;
600 }
601
CheckLenAndCopyData(uint32_t len,uint32_t headSize,const char * data,DataHeadTlvPacketHead * head)602 static int32_t CheckLenAndCopyData(uint32_t len, uint32_t headSize, const char *data, DataHeadTlvPacketHead *head)
603 {
604 if (len <= headSize) {
605 TRANS_LOGE(TRANS_CTRL, "data len not enough, bufLen Less than headSize. len=%{public}u", len);
606 return SOFTBUS_DATA_NOT_ENOUGH;
607 }
608 if (memcpy_s(&head->magicNumber, MAGICNUM_SIZE, data, MAGICNUM_SIZE) != EOK) {
609 TRANS_LOGE(TRANS_CTRL, "memcpy magicNumber failed.");
610 return SOFTBUS_MEM_ERR;
611 }
612 if (memcpy_s(&head->tlvCount, TLVCOUNT_SIZE, data + MAGICNUM_SIZE, TLVCOUNT_SIZE) != EOK) {
613 TRANS_LOGE(TRANS_CTRL, "memcpy tlvCount failed.");
614 return SOFTBUS_MEM_ERR;
615 }
616 return SOFTBUS_OK;
617 }
618
TransProxyParseTlv(uint32_t len,const char * data,DataHeadTlvPacketHead * head,uint32_t * headSize)619 int32_t TransProxyParseTlv(uint32_t len, const char *data, DataHeadTlvPacketHead *head, uint32_t *headSize)
620 {
621 if (data == NULL || head == NULL || headSize == NULL) {
622 TRANS_LOGE(TRANS_CTRL, "param invalid.");
623 return SOFTBUS_INVALID_PARAM;
624 }
625 *headSize += (MAGICNUM_SIZE + TLVCOUNT_SIZE);
626 int32_t res = CheckLenAndCopyData(len, *headSize, data, head);
627 TRANS_CHECK_AND_RETURN_RET_LOGE(res == SOFTBUS_OK, res, TRANS_CTRL, "checkLenAndCopyData failed");
628 errno_t ret = EOK;
629 char *temp = (char *)data + MAGICNUM_SIZE + TLVCOUNT_SIZE;
630 for (uint8_t index = 0; index < head->tlvCount; index++) {
631 uint8_t *type = (uint8_t *)temp;
632 if (len < (*headSize + (TLV_TYPE_AND_LENTH * sizeof(uint8_t)))) {
633 TRANS_LOGE(TRANS_CTRL, "check len contains tlv segment data fail, len=%{public}u", len);
634 return SOFTBUS_DATA_NOT_ENOUGH;
635 }
636 uint8_t *length = (uint8_t *)(temp + sizeof(uint8_t));
637 if (len < (*headSize + (TLV_TYPE_AND_LENTH * sizeof(uint8_t)) + *length)) {
638 TRANS_LOGE(TRANS_CTRL, "data len not enough. len=%{public}u", len);
639 return SOFTBUS_DATA_NOT_ENOUGH;
640 }
641 temp += (TLV_TYPE_AND_LENTH * sizeof(uint8_t));
642 switch (*type) {
643 case TLV_TYPE_INNER_SEQ:
644 ret = memcpy_s(&head->seq, sizeof(head->seq), temp, *length);
645 break;
646 case TLV_TYPE_DATA_SEQ:
647 ret = memcpy_s(&head->dataSeq, sizeof(head->dataSeq), temp, *length);
648 break;
649 case TLV_TYPE_FLAG:
650 ret = memcpy_s(&head->flags, sizeof(head->flags), temp, *length);
651 break;
652 case TLV_TYPE_NEED_ACK:
653 ret = memcpy_s(&head->needAck, sizeof(head->needAck), temp, *length);
654 break;
655 case TLV_TYPE_DATA_LEN:
656 ret = memcpy_s(&head->dataLen, sizeof(head->dataLen), temp, *length);
657 break;
658 default:
659 TRANS_LOGE(TRANS_CTRL, "unknown trans tdc tlv skip, tlvType=%{public}d", *type);
660 continue;
661 }
662 temp += *length;
663 *headSize += (TLV_TYPE_AND_LENTH * sizeof(uint8_t) + *length);
664 TRANS_CHECK_AND_RETURN_RET_LOGE(ret == EOK, SOFTBUS_MEM_ERR, TRANS_CTRL,
665 "parse tlv memcpy failed, tlvType=%{public}d, ret=%{public}d", *type, ret);
666 }
667 return SOFTBUS_OK;
668 }
669
TransProxyNoSubPacketTlvProc(int32_t channelId,const char * data,uint32_t len,DataHeadTlvPacketHead * pktHead,uint32_t newPktHeadSize)670 int32_t TransProxyNoSubPacketTlvProc(
671 int32_t channelId, const char *data, uint32_t len, DataHeadTlvPacketHead *pktHead, uint32_t newPktHeadSize)
672 {
673 if (pktHead == NULL) {
674 TRANS_LOGE(TRANS_CTRL, "param invalid.");
675 return SOFTBUS_INVALID_PARAM;
676 }
677 TransUnPackTlvPackHead(pktHead);
678 TRANS_LOGD(TRANS_CTRL, "proxy channel parse tlv newPktHeadSize=%{public}d", newPktHeadSize);
679
680 if (pktHead->magicNumber != MAGIC_NUMBER) {
681 TRANS_LOGE(TRANS_CTRL, "invalid magicNumber=%{public}x, channelId=%{public}d, len=%{public}u",
682 pktHead->magicNumber, channelId, len);
683 return SOFTBUS_INVALID_DATA_HEAD;
684 }
685 if (pktHead->dataLen == 0) {
686 TRANS_LOGE(TRANS_CTRL, "invalid dataLen=%{public}u, channelId=%{public}d, len=%{public}u",
687 pktHead->dataLen, channelId, len);
688 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
689 }
690 TRANS_LOGD(TRANS_CTRL, "NoSubPacketProc dataLen=%{public}u, inputLen=%{public}u", pktHead->dataLen, len);
691 if (len <= newPktHeadSize || (pktHead->dataLen != (len - newPktHeadSize))) {
692 TRANS_LOGE(TRANS_CTRL, "dataLen error, channelId=%{public}d, len=%{public}u, dataLen=%{public}u",
693 channelId, len, pktHead->dataLen);
694 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
695 }
696 return SOFTBUS_OK;
697 }
698
TransProxyProcData(ProxyDataInfo * dataInfo,const DataHeadTlvPacketHead * dataHead,const char * data)699 int32_t TransProxyProcData(ProxyDataInfo *dataInfo, const DataHeadTlvPacketHead *dataHead, const char *data)
700 {
701 uint32_t outLen = 0;
702
703 if (dataHead->dataLen <= OVERHEAD_LEN) {
704 TRANS_LOGE(TRANS_CTRL, "invalid data head dataLen=%{public}d", dataHead->dataLen);
705 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
706 }
707
708 outLen = dataHead->dataLen - OVERHEAD_LEN;
709 dataInfo->outData = (unsigned char *)SoftBusCalloc(outLen);
710 if (dataInfo->outData == NULL) {
711 TRANS_LOGE(TRANS_CTRL, "malloc fail when process session out data.");
712 return SOFTBUS_MALLOC_ERR;
713 }
714 dataInfo->inData = (unsigned char *)data;
715 dataInfo->inLen = dataHead->dataLen;
716 dataInfo->outLen = outLen;
717 return SOFTBUS_OK;
718 }
719
TransProxyPackD2DData(ProxyDataInfo * dataInfo,uint32_t sliceNum,SessionPktType pktType,uint32_t cnt,uint32_t * dataLen)720 uint8_t *TransProxyPackD2DData(
721 ProxyDataInfo *dataInfo, uint32_t sliceNum, SessionPktType pktType, uint32_t cnt, uint32_t *dataLen)
722 {
723 if (dataLen == NULL || dataInfo == NULL || sliceNum == 0) {
724 TRANS_LOGE(TRANS_CTRL, "param invalid");
725 return NULL;
726 }
727 *dataLen = (cnt == (sliceNum - 1)) ? (dataInfo->outLen - cnt * SHORT_SLICE_LEN) : SHORT_SLICE_LEN;
728 int32_t offset = (int32_t)(cnt * SHORT_SLICE_LEN);
729
730 uint8_t *sliceData = (uint8_t *)SoftBusCalloc(*dataLen + sizeof(SliceHead));
731 if (sliceData == NULL) {
732 TRANS_LOGE(TRANS_CTRL, "malloc sliceData failed");
733 return NULL;
734 }
735 SliceHead *slicehead = (SliceHead *)sliceData;
736 slicehead->priority = SessionPktTypeToProxyIndex(pktType);
737 slicehead->sliceNum = (int32_t)sliceNum;
738 slicehead->sliceSeq = (int32_t)cnt;
739 TransPackSliceHead(slicehead);
740 if (memcpy_s(sliceData + sizeof(SliceHead), *dataLen, dataInfo->outData + offset, *dataLen) != EOK) {
741 TRANS_LOGE(TRANS_CTRL, "memcpy failed");
742 SoftBusFree(sliceData);
743 return NULL;
744 }
745 return sliceData;
746 }
747
TransProxyProcessD2DData(ProxyDataInfo * dataInfo,const PacketD2DHead * dataHead,const char * data,int32_t businessType)748 int32_t TransProxyProcessD2DData(
749 ProxyDataInfo *dataInfo, const PacketD2DHead *dataHead, const char *data, int32_t businessType)
750 {
751 if (dataInfo == NULL || data == NULL || dataHead == NULL) {
752 TRANS_LOGE(TRANS_CTRL, "invalid param");
753 return SOFTBUS_INVALID_PARAM;
754 }
755 uint32_t outLen = 0;
756 if (businessType == BUSINESS_TYPE_D2D_MESSAGE) {
757 if (dataHead->dataLen <= SHORT_TAG_LEN) {
758 TRANS_LOGE(TRANS_CTRL, "invalid data head dataLen=%{public}d", dataHead->dataLen);
759 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
760 }
761 outLen = dataHead->dataLen - SHORT_TAG_LEN;
762 } else {
763 if (dataHead->dataLen <= 0) {
764 TRANS_LOGE(TRANS_CTRL, "invalid data head dataLen=%{public}d", dataHead->dataLen);
765 return SOFTBUS_TRANS_INVALID_DATA_LENGTH;
766 }
767 outLen = dataHead->dataLen;
768 }
769 dataInfo->outData = (unsigned char *)SoftBusCalloc(outLen);
770 if (dataInfo->outData == NULL) {
771 TRANS_LOGE(TRANS_CTRL, "malloc fail when process session out data");
772 return SOFTBUS_MALLOC_ERR;
773 }
774 dataInfo->inData = (unsigned char *)data;
775 dataInfo->inLen = dataHead->dataLen;
776 dataInfo->outLen = outLen;
777 return SOFTBUS_OK;
778 }
779
TransProxyDecryptD2DData(int32_t businessType,ProxyDataInfo * dataInfo,const char * sessionKey,const unsigned char * sessionCommonIv)780 int32_t TransProxyDecryptD2DData(
781 int32_t businessType, ProxyDataInfo *dataInfo, const char *sessionKey, const unsigned char *sessionCommonIv)
782 {
783 if (dataInfo == NULL || sessionKey == NULL || sessionCommonIv == NULL) {
784 TRANS_LOGE(TRANS_CTRL, "invalid param");
785 return SOFTBUS_INVALID_PARAM;
786 }
787 if (businessType == BUSINESS_TYPE_D2D_MESSAGE) {
788 AesGcm128CipherKey cipherKey = { 0 };
789 cipherKey.keyLen = SHORT_SESSION_KEY_LENGTH;
790 if (memcpy_s(cipherKey.key, SHORT_SESSION_KEY_LENGTH, sessionKey, SHORT_SESSION_KEY_LENGTH) != EOK) {
791 TRANS_LOGE(TRANS_CTRL, "memcpy key fail");
792 return SOFTBUS_MEM_ERR;
793 }
794 if (memcpy_s(cipherKey.iv, GCM_IV_LEN, sessionCommonIv, GCM_IV_LEN) != EOK) {
795 TRANS_LOGE(TRANS_CTRL, "memcpy iv fail");
796 (void)memset_s(cipherKey.key, SHORT_SESSION_KEY_LENGTH, 0, SHORT_SESSION_KEY_LENGTH);
797 return SOFTBUS_MEM_ERR;
798 }
799 int32_t ret = SoftBusDecryptDataByGcm128(
800 &cipherKey, dataInfo->inData, dataInfo->inLen, dataInfo->outData, &(dataInfo->outLen));
801 (void)memset_s(&cipherKey, sizeof(AesGcm128CipherKey), 0, sizeof(AesGcm128CipherKey));
802 if (ret != SOFTBUS_OK) {
803 TRANS_LOGE(TRANS_CTRL, "decrypt d2d message fail");
804 return ret;
805 }
806 return SOFTBUS_OK;
807 }
808 AesCtrCipherKey cipherKey = { 0 };
809 cipherKey.keyLen = SHORT_SESSION_KEY_LENGTH;
810 if (memcpy_s(cipherKey.key, SHORT_SESSION_KEY_LENGTH, sessionKey, SHORT_SESSION_KEY_LENGTH) != EOK) {
811 TRANS_LOGE(TRANS_CTRL, "memcpy key fail");
812 return SOFTBUS_MEM_ERR;
813 }
814 if (memcpy_s(cipherKey.iv, SHORT_SESSION_KEY_LENGTH, sessionCommonIv, GCM_IV_LEN) != EOK) {
815 TRANS_LOGE(TRANS_CTRL, "memcpy iv fail");
816 (void)memset_s(cipherKey.key, SHORT_SESSION_KEY_LENGTH, 0, SHORT_SESSION_KEY_LENGTH);
817 return SOFTBUS_MEM_ERR;
818 }
819 int32_t ret =
820 SoftBusDecryptDataByCtr(&cipherKey, dataInfo->inData, dataInfo->inLen, dataInfo->outData, &(dataInfo->outLen));
821 (void)memset_s(&cipherKey, sizeof(AesCtrCipherKey), 0, sizeof(AesCtrCipherKey));
822 if (ret != SOFTBUS_OK) {
823 TRANS_LOGE(TRANS_CTRL, "decrypt d2d message fail");
824 return ret;
825 }
826 return SOFTBUS_OK;
827 }
828
TransProxyD2DFirstSliceProcess(SliceProcessor * processor,const SliceHead * head,const char * data,uint32_t len,int32_t busineseeTye)829 int32_t TransProxyD2DFirstSliceProcess(
830 SliceProcessor *processor, const SliceHead *head, const char *data, uint32_t len, int32_t busineseeTye)
831 {
832 if (processor == NULL || head == NULL || data == NULL) {
833 TRANS_LOGE(TRANS_CTRL, "invalid param");
834 return SOFTBUS_INVALID_PARAM;
835 }
836 uint32_t actualDataLen = 0;
837 uint32_t maxDataLen =
838 (head->priority == PROXY_CHANNEL_PRORITY_MESSAGE) ? g_proxyMaxMessageBufSize : g_proxyMaxByteBufSize;
839 // The encrypted data length is longer then the actual data length
840 maxDataLen += SHORT_SLICE_LEN;
841
842 if ((head->sliceNum < 0) || ((uint32_t)head->sliceNum > (maxDataLen / SHORT_SLICE_LEN))) {
843 TRANS_LOGE(TRANS_CTRL, "invalid sliceNum=%{public}d", head->sliceNum);
844 return SOFTBUS_INVALID_DATA_HEAD;
845 }
846 actualDataLen = head->sliceNum * SHORT_SLICE_LEN;
847 uint32_t maxLen = 0;
848 if (busineseeTye == BUSINESS_TYPE_D2D_MESSAGE) {
849 maxLen = actualDataLen + sizeof(PacketD2DHead) + SHORT_TAG_LEN;
850 } else {
851 maxLen = actualDataLen + sizeof(PacketD2DHead);
852 }
853 processor->data = (char *)SoftBusCalloc(maxLen);
854 if (processor->data == NULL) {
855 TRANS_LOGE(TRANS_CTRL, "malloc fail when proc first slice package");
856 return SOFTBUS_MALLOC_ERR;
857 }
858 processor->bufLen = (int32_t)maxLen;
859 if (memcpy_s(processor->data, maxLen, data, len) != EOK) {
860 TRANS_LOGE(TRANS_CTRL, "memcpy fail when proce first slice package");
861 SoftBusFree(processor->data);
862 processor->data = NULL;
863 return SOFTBUS_MEM_ERR;
864 }
865 processor->sliceNumber = head->sliceNum;
866 processor->expectedSeq = 1;
867 processor->dataLen = (int32_t)len;
868 processor->active = true;
869 processor->timeout = 0;
870 TRANS_LOGI(TRANS_CTRL, "FirstSliceProcess ok");
871 return SOFTBUS_OK;
872 }
873
TransGenerateToBytesRandIv(unsigned char * sessionIv,const uint32_t * nonce)874 int32_t TransGenerateToBytesRandIv(unsigned char *sessionIv, const uint32_t *nonce)
875 {
876 if (sessionIv == NULL || nonce == NULL) {
877 TRANS_LOGE(TRANS_CTRL, "invalid param.");
878 return SOFTBUS_INVALID_PARAM;
879 }
880 uint8_t shortIv[SHORT_SESSION_IV_LENGTH];
881 if (memcpy_s(shortIv, SHORT_SESSION_IV_LENGTH, nonce, NONCE_LEN) != EOK) {
882 TRANS_LOGE(TRANS_CTRL, "memcpys_s nonce failed.");
883 return SOFTBUS_MEM_ERR;
884 }
885 if (SoftBusCalcHKDF(shortIv, SHORT_SESSION_IV_LENGTH, sessionIv, GCM_IV_LEN) != SOFTBUS_OK) {
886 TRANS_LOGE(TRANS_CTRL, "calc HKDF failed.");
887 return SOFTBUS_CALC_HKDF_FAIL;
888 }
889 return SOFTBUS_OK;
890 }
891
TransPackD2DToBytesExtraData(ProxyDataInfo * dataInfo,SessionPktType flag,uint32_t nonce)892 static int32_t TransPackD2DToBytesExtraData(ProxyDataInfo *dataInfo, SessionPktType flag, uint32_t nonce)
893 {
894 if (dataInfo == NULL) {
895 TRANS_LOGE(TRANS_CTRL, "invalid param.");
896 return SOFTBUS_INVALID_PARAM;
897 }
898 if (memcpy_s(dataInfo->outData + sizeof(PacketD2DHead), NONCE_LEN, &nonce, NONCE_LEN) != EOK) {
899 TRANS_LOGE(TRANS_CTRL, "memcpy nonce failed.");
900 return SOFTBUS_MEM_ERR;
901 }
902 PacketD2DHead *pktHead = (PacketD2DHead *)dataInfo->outData;
903 pktHead->flags = flag;
904 pktHead->dataLen = (int32_t)((int32_t)dataInfo->outLen - sizeof(PacketD2DHead)- NONCE_LEN);
905 pktHead->flags = (int32_t)SoftBusHtoLl((uint32_t)pktHead->flags);
906 pktHead->dataLen = (int32_t)SoftBusHtoLl((uint32_t)pktHead->dataLen);
907 return SOFTBUS_OK;
908 }
909
TransProxyPackD2DBytes(ProxyDataInfo * dataInfo,const char * sessionKey,const char * sessionIv,SessionPktType flag)910 int32_t TransProxyPackD2DBytes(
911 ProxyDataInfo *dataInfo, const char *sessionKey, const char *sessionIv, SessionPktType flag)
912 {
913 if (dataInfo == NULL || sessionKey == NULL || sessionIv == NULL) {
914 TRANS_LOGE(TRANS_CTRL, "invalid para");
915 return SOFTBUS_INVALID_PARAM;
916 }
917
918 uint32_t nonce = 0;
919 if (SoftBusGenerateRandomArray((unsigned char *)&nonce, sizeof(uint32_t)) != SOFTBUS_OK) {
920 TRANS_LOGE(TRANS_CTRL, "generate nonce failed.");
921 return SOFTBUS_GENERATE_RANDOM_ARRAY_FAIL;
922 }
923
924 AesCtrCipherKey cipherKey = { 0 };
925 cipherKey.keyLen = SHORT_SESSION_KEY_LENGTH;
926 if (memcpy_s(cipherKey.key, SHORT_SESSION_KEY_LENGTH, sessionKey, SHORT_SESSION_KEY_LENGTH) != EOK) {
927 TRANS_LOGE(TRANS_CTRL, "memcpy key failed");
928 return SOFTBUS_MEM_ERR;
929 }
930 if (TransGenerateToBytesRandIv(cipherKey.iv, &nonce) != SOFTBUS_OK) {
931 TRANS_LOGE(TRANS_CTRL, "generate iv failed");
932 (void)memset_s(&cipherKey, sizeof(AesCtrCipherKey), 0, sizeof(AesCtrCipherKey));
933 return SOFTBUS_GCM_SET_IV_FAIL;
934 }
935 dataInfo->outLen = dataInfo->inLen + NONCE_LEN + sizeof(PacketD2DHead);
936 dataInfo->outData = (uint8_t *)SoftBusCalloc(dataInfo->outLen);
937 if (dataInfo->outData == NULL) {
938 TRANS_LOGE(TRANS_CTRL, "malloc failed");
939 (void)memset_s(&cipherKey, sizeof(AesCtrCipherKey), 0, sizeof(AesCtrCipherKey));
940 return SOFTBUS_MALLOC_ERR;
941 }
942
943 uint32_t outLen = 0;
944 char *outData = (char *)dataInfo->outData + NONCE_LEN + sizeof(PacketD2DHead);
945 int32_t ret = SoftBusEncryptDataByCtr(&cipherKey, (const unsigned char *)dataInfo->inData,
946 dataInfo->inLen, (unsigned char *)outData, &outLen);
947 (void)memset_s(&cipherKey, sizeof(AesCtrCipherKey), 0, sizeof(AesCtrCipherKey));
948
949 if (ret != SOFTBUS_OK || outLen != dataInfo->inLen) {
950 outData = NULL;
951 SoftBusFree(dataInfo->outData);
952 TRANS_LOGE(TRANS_CTRL, "encrypt error, outlen=%{public}d, inlen=%{public}d", outLen, dataInfo->inLen);
953 return SOFTBUS_TRANS_PROXY_SESS_ENCRYPT_ERR;
954 }
955 ret = TransPackD2DToBytesExtraData(dataInfo, flag, nonce);
956 if (ret != SOFTBUS_OK) {
957 outData = NULL;
958 SoftBusFree(dataInfo->outData);
959 TRANS_LOGE(TRANS_CTRL, "pack extra error, ret=%{public}d", ret);
960 }
961 return ret;
962 }
963