1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "auth_session_message.h"
17
18 #include <securec.h>
19
20 #include "auth_common.h"
21 #include "auth_connection.h"
22 #include "auth_manager.h"
23 #include "bus_center_manager.h"
24 #include "lnn_local_net_ledger.h"
25 #include "lnn_network_manager.h"
26 #include "lnn_node_info.h"
27 #include "softbus_adapter_mem.h"
28 #include "softbus_json_utils.h"
29
30 /* DeviceId */
31 #define CMD_TAG "TECmd"
32 #define CMD_GET_AUTH_INFO "getAuthInfo"
33 #define CMD_RET_AUTH_INFO "retAuthInfo"
34 #define DATA_TAG "TEData"
35 #define DEVICE_ID_TAG "TEDeviceId"
36 #define DATA_BUF_SIZE_TAG "DataBufSize"
37 #define SOFTBUS_VERSION_TAG "softbusVersion"
38 #define CMD_TAG_LEN 30
39 #define PACKET_SIZE (64 * 1024)
40
41 /* DeviceInfo */
42 #define CODE "CODE"
43 #define CODE_VERIFY_IP 1
44 #define CODE_VERIFY_BT 5
45 #define DEVICE_NAME "DEVICE_NAME"
46 #define DEVICE_TYPE "DEVICE_TYPE"
47 #define DEVICE_UDID "DEVICE_UDID"
48 #define DEVICE_UUID "DEVICE_UUID"
49 #define NETWORK_ID "NETWORK_ID"
50 #define NODE_ADDR "NODE_ADDR"
51 #define VERSION_TYPE "VERSION_TYPE"
52 #define BT_MAC "BT_MAC"
53 #define BUS_MAX_VERSION "BUS_MAX_VERSION"
54 #define BUS_MIN_VERSION "BUS_MIN_VERSION"
55 #define AUTH_PORT "AUTH_PORT"
56 #define SESSION_PORT "SESSION_PORT"
57 #define PROXY_PORT "PROXY_PORT"
58 #define CONN_CAP "CONN_CAP"
59 #define SW_VERSION "SW_VERSION"
60 #define MASTER_UDID "MASTER_UDID"
61 #define MASTER_WEIGHT "MASTER_WEIGHT"
62 #define BLE_P2P "BLE_P2P"
63 #define P2P_MAC_ADDR "P2P_MAC_ADDR"
64 #define P2P_ROLE "P2P_ROLE"
65 #define TRANSPORT_PROTOCOL "TRANSPORT_PROTOCOL"
66 #define BLE_OFFLINE_CODE "OFFLINE_CODE"
67 #define DATA_CHANGE_FLAG "NODE_DATA_CHANGE_FLAG"
68 #define BUS_V1 1
69 #define BUS_V2 2
70
71 #define FLAG_COMPRESS_DEVICE_INFO 1
72 #define FLAG_UNCOMPRESS_DEVICE_INFO 0
73
74 /* VerifyDevice */
75 #define CODE_VERIFY_DEVICE 2
76 #define DEVICE_ID "DEVICE_ID"
77
PackDeviceIdMessage(int32_t linkType,bool isServer,int32_t softbusVersion)78 static char *PackDeviceIdMessage(int32_t linkType, bool isServer, int32_t softbusVersion)
79 {
80 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "PackDeviceId: connType = %d.", linkType);
81 cJSON *obj = cJSON_CreateObject();
82 if (obj == NULL) {
83 return NULL;
84 }
85 char uuid[UUID_BUF_LEN] = {0};
86 char udid[UDID_BUF_LEN] = {0};
87 if (LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) != SOFTBUS_OK ||
88 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
89 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "get uuid/udid fail.");
90 cJSON_Delete(obj);
91 return NULL;
92 }
93 if (linkType == AUTH_LINK_TYPE_WIFI && !isServer) {
94 if (!AddStringToJsonObject(obj, CMD_TAG, CMD_GET_AUTH_INFO)) {
95 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add CMD_GET fail.");
96 cJSON_Delete(obj);
97 return NULL;
98 }
99 } else {
100 if (!AddStringToJsonObject(obj, CMD_TAG, CMD_RET_AUTH_INFO)) {
101 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add CMD_RET fail.");
102 cJSON_Delete(obj);
103 return NULL;
104 }
105 }
106 if (!AddStringToJsonObject(obj, DATA_TAG, uuid) ||
107 !AddStringToJsonObject(obj, DEVICE_ID_TAG, udid) ||
108 !AddNumberToJsonObject(obj, DATA_BUF_SIZE_TAG, PACKET_SIZE) ||
109 !AddNumberToJsonObject(obj, SOFTBUS_VERSION_TAG, softbusVersion)) {
110 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add msg body fail.");
111 cJSON_Delete(obj);
112 return NULL;
113 }
114 char *msg = cJSON_PrintUnformatted(obj);
115 cJSON_Delete(obj);
116 return msg;
117 }
118
UnpackDeviceIdMessage(const char * msg,AuthSessionInfo * info)119 static int32_t UnpackDeviceIdMessage(const char *msg, AuthSessionInfo *info)
120 {
121 cJSON *obj = cJSON_Parse(msg);
122 if (obj == NULL) {
123 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "json parse fail.");
124 return SOFTBUS_ERR;
125 }
126 char cmd[CMD_TAG_LEN] = {0};
127 if (!GetJsonObjectStringItem(obj, CMD_TAG, cmd, CMD_TAG_LEN)) {
128 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "CMD_TAG not found.");
129 cJSON_Delete(obj);
130 return SOFTBUS_ERR;
131 }
132 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI && info->isServer) {
133 if (strncmp(cmd, CMD_GET_AUTH_INFO, strlen(CMD_GET_AUTH_INFO)) != 0) {
134 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "CMD_GET not match.");
135 cJSON_Delete(obj);
136 return SOFTBUS_ERR;
137 }
138 } else {
139 if (strncmp(cmd, CMD_RET_AUTH_INFO, strlen(CMD_RET_AUTH_INFO)) != 0) {
140 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "CMD_RET not match.");
141 cJSON_Delete(obj);
142 return SOFTBUS_ERR;
143 }
144 }
145 if (!GetJsonObjectStringItem(obj, DATA_TAG, info->uuid, UUID_BUF_LEN) ||
146 !GetJsonObjectStringItem(obj, DEVICE_ID_TAG, info->udid, UDID_BUF_LEN)) {
147 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "uuid/udid not found.");
148 cJSON_Delete(obj);
149 return SOFTBUS_ERR;
150 }
151 if (!GetJsonObjectNumberItem(obj, SOFTBUS_VERSION_TAG, (int32_t *)&info->version)) {
152 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "set default version: SOFTBUS_OLD_V2.");
153 info->version = SOFTBUS_OLD_V2;
154 }
155 cJSON_Delete(obj);
156 return SOFTBUS_OK;
157 }
158
PackCommon(cJSON * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth)159 static int32_t PackCommon(cJSON *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
160 {
161 if (version >= SOFTBUS_NEW_V1) {
162 if (!AddStringToJsonObject(json, SW_VERSION, info->softBusVersion)) {
163 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add version info fail.");
164 return SOFTBUS_ERR;
165 }
166 if (!AddStringToJsonObject(json, MASTER_UDID, info->masterUdid) ||
167 !AddNumberToJsonObject(json, MASTER_WEIGHT, info->masterWeight)) {
168 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add master node info fail.");
169 return SOFTBUS_ERR;
170 }
171 if (!AddStringToJsonObject(json, NODE_ADDR, info->nodeAddress)) {
172 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "pack node address Fail.");
173 return SOFTBUS_ERR;
174 }
175 }
176
177 char offlineCodeResult[OFFLINE_CODE_LEN] = {0};
178 int32_t ret = ConvertBytesToHexString(offlineCodeResult, OFFLINE_CODE_LEN,
179 (const unsigned char *)info->offlineCode, OFFLINE_CODE_BYTE_SIZE);
180 if (ret != SOFTBUS_OK) {
181 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "convert bytes to str offline fail, ret=%d", ret);
182 return SOFTBUS_ERR;
183 }
184 if (!AddStringToJsonObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo)) ||
185 !AddStringToJsonObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
186 !AddStringToJsonObject(json, DEVICE_UDID, LnnGetDeviceUdid(info))) {
187 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddStringToJsonObject fail.");
188 return SOFTBUS_ERR;
189 }
190 if (isMetaAuth && !AddStringToJsonObject(json, DEVICE_UUID, info->uuid)) {
191 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddStringToJsonObject fail.");
192 return SOFTBUS_ERR;
193 }
194 if (!AddStringToJsonObject(json, NETWORK_ID, info->networkId) ||
195 !AddStringToJsonObject(json, VERSION_TYPE, info->versionType) ||
196 !AddNumberToJsonObject(json, CONN_CAP, info->netCapacity) ||
197 !AddNumberToJsonObject(json, P2P_ROLE, LnnGetP2pRole(info)) ||
198 !AddNumberToJsonObject(json, DATA_CHANGE_FLAG, info->dataChangeFlag) ||
199 !AddBoolToJsonObject(json, BLE_P2P, info->isBleP2p) ||
200 !AddStringToJsonObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info)) ||
201 !AddNumber64ToJsonObject(json, TRANSPORT_PROTOCOL, (int64_t)LnnGetSupportedProtocols(info)) ||
202 !AddStringToJsonObject(json, BLE_OFFLINE_CODE, offlineCodeResult)) {
203 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "AddStringToJsonObject fail.");
204 return SOFTBUS_ERR;
205 }
206 return SOFTBUS_OK;
207 }
208
UnpackCommon(const cJSON * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)209 static void UnpackCommon(const cJSON *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
210 {
211 if (version >= SOFTBUS_NEW_V1) {
212 (void)GetJsonObjectStringItem(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN);
213 if (!GetJsonObjectStringItem(json, MASTER_UDID, info->masterUdid, UDID_BUF_LEN) ||
214 !GetJsonObjectNumberItem(json, MASTER_WEIGHT, &info->masterWeight)) {
215 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "get master node info fail");
216 }
217 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "get master weight: %d", info->masterWeight);
218 if (!GetJsonObjectStringItem(json, NODE_ADDR, info->nodeAddress, sizeof(info->nodeAddress))) {
219 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_WARN,
220 "no node address packed. set to address %s", NODE_ADDR_LOOPBACK);
221 (void)strcpy_s(info->nodeAddress, sizeof(info->nodeAddress), NODE_ADDR_LOOPBACK);
222 }
223 }
224
225 char deviceType[DEVICE_TYPE_BUF_LEN] = {0};
226 (void)GetJsonObjectStringItem(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN);
227 if (GetJsonObjectStringItem(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN)) {
228 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
229 }
230 (void)GetJsonObjectStringItem(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN);
231 if (isMetaAuth) {
232 (void)GetJsonObjectStringItem(json, DEVICE_UUID, info->uuid, UDID_BUF_LEN);
233 }
234 (void)GetJsonObjectStringItem(json, NETWORK_ID, info->networkId, NETWORK_ID_BUF_LEN);
235 (void)GetJsonObjectStringItem(json, VERSION_TYPE, info->versionType, VERSION_MAX_LEN);
236 (void)GetJsonObjectNumberItem(json, CONN_CAP, (int *)&info->netCapacity);
237
238 info->isBleP2p = false;
239 char getOfflineCodeResult[OFFLINE_CODE_LEN] = {0};
240 (void)GetJsonObjectBoolItem(json, BLE_P2P, &info->isBleP2p);
241 (void)GetJsonObjectNumberItem(json, P2P_ROLE, &info->p2pInfo.p2pRole);
242 (void)GetJsonObjectNumber16Item(json, DATA_CHANGE_FLAG, &info->dataChangeFlag);
243 (void)GetJsonObjectStringItem(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN);
244 (void)GetJsonObjectStringItem(json, BLE_OFFLINE_CODE, getOfflineCodeResult, OFFLINE_CODE_LEN);
245 int32_t ret = ConvertHexStringToBytes(info->offlineCode, OFFLINE_CODE_BYTE_SIZE,
246 (const char *)getOfflineCodeResult, OFFLINE_CODE_LEN);
247 if (ret != SOFTBUS_OK) {
248 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "convert str to bytes offline fail, ret=%d", ret);
249 }
250 }
251
PackBt(cJSON * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth)252 static int32_t PackBt(cJSON *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
253 {
254 if (!AddNumberToJsonObject(json, CODE, CODE_VERIFY_BT) ||
255 !AddStringToJsonObject(json, BT_MAC, LnnGetBtMac(info))) {
256 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add bt info fail.");
257 return SOFTBUS_ERR;
258 }
259 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
260 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "PackCommon fail.");
261 return SOFTBUS_ERR;
262 }
263 return SOFTBUS_OK;
264 }
265
UnpackBt(const cJSON * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)266 static int32_t UnpackBt(const cJSON *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
267 {
268 (void)GetJsonObjectStringItem(json, BT_MAC, info->connectInfo.macAddr, MAC_LEN);
269 if (!GetJsonObjectNumber64Item(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
270 info->supportedProtocols = LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE;
271 }
272 UnpackCommon(json, info, version, isMetaAuth);
273 return SOFTBUS_OK;
274 }
275
PackWiFi(cJSON * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth)276 static int32_t PackWiFi(cJSON *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
277 {
278 if (!AddNumberToJsonObject(json, CODE, CODE_VERIFY_IP) ||
279 !AddNumberToJsonObject(json, BUS_MAX_VERSION, BUS_V2) ||
280 !AddNumberToJsonObject(json, BUS_MIN_VERSION, BUS_V1) ||
281 !AddNumberToJsonObject(json, AUTH_PORT, LnnGetAuthPort(info)) ||
282 !AddNumberToJsonObject(json, SESSION_PORT, LnnGetSessionPort(info)) ||
283 !AddNumberToJsonObject(json, PROXY_PORT, LnnGetProxyPort(info))) {
284 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add wifi info fail.");
285 return SOFTBUS_ERR;
286 }
287 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
288 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "PackCommon fail.");
289 return SOFTBUS_ERR;
290 }
291 return SOFTBUS_OK;
292 }
293
UnpackWiFi(const cJSON * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)294 static int32_t UnpackWiFi(const cJSON *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
295 {
296 (void)GetJsonObjectNumberItem(json, AUTH_PORT, &info->connectInfo.authPort);
297 (void)GetJsonObjectNumberItem(json, SESSION_PORT, &info->connectInfo.sessionPort);
298 (void)GetJsonObjectNumberItem(json, PROXY_PORT, &info->connectInfo.proxyPort);
299 if (!GetJsonObjectNumber64Item(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
300 info->supportedProtocols = LNN_PROTOCOL_IP;
301 }
302 UnpackCommon(json, info, version, isMetaAuth);
303 return SOFTBUS_OK;
304 }
305
PackDeviceInfoMessage(int32_t linkType,SoftBusVersion version,bool isMetaAuth)306 char *PackDeviceInfoMessage(int32_t linkType, SoftBusVersion version, bool isMetaAuth)
307 {
308 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "PackDeviceInfo: connType = %d.", linkType);
309 const NodeInfo *info = LnnGetLocalNodeInfo();
310 if (info == NULL) {
311 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "local info is null.");
312 return NULL;
313 }
314 cJSON *json = cJSON_CreateObject();
315 if (json == NULL) {
316 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "create cjson fail.");
317 return NULL;
318 }
319 int32_t ret;
320 if (linkType == AUTH_LINK_TYPE_WIFI) {
321 ret = PackWiFi(json, info, version, isMetaAuth);
322 } else {
323 ret = PackBt(json, info, version, isMetaAuth);
324 }
325 if (ret != SOFTBUS_OK) {
326 cJSON_Delete(json);
327 return NULL;
328 }
329
330 char *msg = cJSON_PrintUnformatted(json);
331 if (msg == NULL) {
332 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "cJSON_PrintUnformatted fail.");
333 }
334 cJSON_Delete(json);
335 return msg;
336 }
337
UnpackDeviceInfoMessage(const char * msg,int32_t linkType,SoftBusVersion version,NodeInfo * nodeInfo,bool isMetaAuth)338 int32_t UnpackDeviceInfoMessage(const char *msg, int32_t linkType, SoftBusVersion version,
339 NodeInfo *nodeInfo, bool isMetaAuth)
340 {
341 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_INFO, "UnpackDeviceInfo: connType = %d.", linkType);
342 cJSON *json = cJSON_Parse(msg);
343 if (json == NULL) {
344 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "parse cjson fail.");
345 return SOFTBUS_ERR;
346 }
347 int32_t ret;
348 if (linkType == AUTH_LINK_TYPE_WIFI) {
349 ret = UnpackWiFi(json, nodeInfo, version, isMetaAuth);
350 } else {
351 ret = UnpackBt(json, nodeInfo, version, isMetaAuth);
352 }
353 cJSON_Delete(json);
354 return ret;
355 }
356
PostDeviceIdMessage(int64_t authSeq,const AuthSessionInfo * info)357 int32_t PostDeviceIdMessage(int64_t authSeq, const AuthSessionInfo *info)
358 {
359 CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
360 char *msg = PackDeviceIdMessage(info->connInfo.type, info->isServer, SOFTBUS_NEW_V1);
361 if (msg == NULL) {
362 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "pack deviceId msg fail.");
363 return SOFTBUS_ERR;
364 }
365 AuthDataHead head = {
366 .dataType = DATA_TYPE_DEVICE_ID,
367 .module = MODULE_TRUST_ENGINE,
368 .seq = authSeq,
369 .flag = info->isServer ? SERVER_SIDE_FLAG : CLIENT_SIDE_FLAG,
370 .len = strlen(msg) + 1,
371 };
372 if (PostAuthData(info->connId, !info->isServer, &head, (uint8_t *)msg) != SOFTBUS_OK) {
373 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "post device id fail.");
374 cJSON_free(msg);
375 return SOFTBUS_ERR;
376 }
377 cJSON_free(msg);
378 return SOFTBUS_OK;
379 }
380
ProcessDeviceIdMessage(AuthSessionInfo * info,const uint8_t * data,uint32_t len)381 int32_t ProcessDeviceIdMessage(AuthSessionInfo *info, const uint8_t *data, uint32_t len)
382 {
383 CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
384 CHECK_NULL_PTR_RETURN_VALUE(data, SOFTBUS_INVALID_PARAM);
385 CHECK_EXPRESSION_RETURN_VALUE((len == 0 || strnlen((const char *)data, len) >= len),
386 SOFTBUS_INVALID_PARAM);
387 return UnpackDeviceIdMessage((const char *)data, info);
388 }
389
GetSessionKeyList(int64_t authSeq,const AuthSessionInfo * info,SessionKeyList * list)390 static void GetSessionKeyList(int64_t authSeq, const AuthSessionInfo *info, SessionKeyList *list)
391 {
392 ListInit(list);
393 SessionKey sessionKey;
394 if (AuthManagerGetSessionKey(authSeq, info, &sessionKey) != SOFTBUS_OK) {
395 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "get session key fail.");
396 return;
397 }
398 if (AddSessionKey(list, TO_INT32(authSeq), &sessionKey) != SOFTBUS_OK) {
399 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add session key fail.");
400 return;
401 }
402 }
403
PostDeviceInfoMessage(int64_t authSeq,const AuthSessionInfo * info)404 int32_t PostDeviceInfoMessage(int64_t authSeq, const AuthSessionInfo *info)
405 {
406 CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
407 char *msg = PackDeviceInfoMessage(info->connInfo.type, SOFTBUS_NEW_V1, false);
408 if (msg == NULL) {
409 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "pack device info fail.");
410 return SOFTBUS_ERR;
411 }
412
413 uint8_t *data = NULL;
414 uint32_t dataLen = 0;
415 SessionKeyList sessionKeyList;
416 GetSessionKeyList(authSeq, info, &sessionKeyList);
417 if (EncryptInner(&sessionKeyList, (uint8_t *)msg, strlen(msg) + 1, &data, &dataLen) != SOFTBUS_OK) {
418 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "encrypt device info fail.");
419 cJSON_free(msg);
420 return SOFTBUS_ENCRYPT_ERR;
421 }
422 cJSON_free(msg);
423
424 AuthDataHead head = {
425 .dataType = DATA_TYPE_DEVICE_INFO,
426 .module = MODULE_AUTH_CONNECTION,
427 .seq = authSeq,
428 .flag = FLAG_UNCOMPRESS_DEVICE_INFO,
429 .len = dataLen,
430 };
431 if (PostAuthData(info->connId, !info->isServer, &head, data) != SOFTBUS_OK) {
432 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "post device info fail.");
433 SoftBusFree(data);
434 return SOFTBUS_ERR;
435 }
436 SoftBusFree(data);
437 return SOFTBUS_OK;
438 }
439
ProcessDeviceInfoMessage(int64_t authSeq,AuthSessionInfo * info,const uint8_t * data,uint32_t len)440 int32_t ProcessDeviceInfoMessage(int64_t authSeq, AuthSessionInfo *info, const uint8_t *data, uint32_t len)
441 {
442 CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
443 CHECK_NULL_PTR_RETURN_VALUE(data, SOFTBUS_INVALID_PARAM);
444 uint8_t *msg = NULL;
445 uint32_t msgSize = 0;
446 SessionKeyList sessionKeyList;
447 GetSessionKeyList(authSeq, info, &sessionKeyList);
448 if (DecryptInner(&sessionKeyList, data, len, &msg, &msgSize) != SOFTBUS_OK) {
449 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "decrypt device info fail.");
450 return SOFTBUS_DECRYPT_ERR;
451 }
452 if (UnpackDeviceInfoMessage((const char *)msg,
453 info->connInfo.type, info->version, &info->nodeInfo, false) != SOFTBUS_OK) {
454 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "unpack device info fail.");
455 SoftBusFree(msg);
456 return SOFTBUS_ERR;
457 }
458 SoftBusFree(msg);
459 return SOFTBUS_OK;
460 }
461
PostCloseAckMessage(int64_t authSeq,const AuthSessionInfo * info)462 int32_t PostCloseAckMessage(int64_t authSeq, const AuthSessionInfo *info)
463 {
464 CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
465 const char *msg = "";
466 AuthDataHead head = {
467 .dataType = DATA_TYPE_CLOSE_ACK,
468 .module = 0,
469 .seq = authSeq,
470 .flag = 0,
471 .len = strlen(msg) + 1,
472 };
473 if (PostAuthData(info->connId, !info->isServer, &head, (uint8_t *)msg) != SOFTBUS_OK) {
474 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "post close ack fail.");
475 return SOFTBUS_ERR;
476 }
477 return SOFTBUS_OK;
478 }
479
PostHichainAuthMessage(int64_t authSeq,const AuthSessionInfo * info,const uint8_t * data,uint32_t len)480 int32_t PostHichainAuthMessage(int64_t authSeq, const AuthSessionInfo *info, const uint8_t *data, uint32_t len)
481 {
482 CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
483 CHECK_NULL_PTR_RETURN_VALUE(data, SOFTBUS_INVALID_PARAM);
484 AuthDataHead head = {
485 .dataType = DATA_TYPE_AUTH,
486 .module = MODULE_AUTH_SDK,
487 .seq = authSeq,
488 .flag = 0,
489 .len = len,
490 };
491 if (PostAuthData(info->connId, !info->isServer, &head, data) != SOFTBUS_OK) {
492 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "post hichain data fail.");
493 return SOFTBUS_ERR;
494 }
495 return SOFTBUS_OK;
496 }
497
PackVerifyDeviceMessage(const char * uuid)498 static char *PackVerifyDeviceMessage(const char *uuid)
499 {
500 cJSON *obj = cJSON_CreateObject();
501 if (obj == NULL) {
502 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "create json fail.");
503 return NULL;
504 }
505 if (!AddNumberToJsonObject(obj, CODE, CODE_VERIFY_DEVICE) ||
506 !AddStringToJsonObject(obj, DEVICE_ID, uuid)) {
507 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "add uuid fail.");
508 cJSON_Delete(obj);
509 return NULL;
510 }
511 char *msg = cJSON_PrintUnformatted(obj);
512 cJSON_Delete(obj);
513 return msg;
514 }
515
PostVerifyDeviceMessage(const AuthManager * auth)516 int32_t PostVerifyDeviceMessage(const AuthManager *auth)
517 {
518 CHECK_NULL_PTR_RETURN_VALUE(auth, SOFTBUS_INVALID_PARAM);
519 char *msg = PackVerifyDeviceMessage(auth->uuid);
520 if (msg == NULL) {
521 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "pack verify device msg fail.");
522 return SOFTBUS_ERR;
523 }
524
525 uint8_t *data = NULL;
526 uint32_t dataLen = 0;
527 if (EncryptInner(&auth->sessionKeyList, (uint8_t *)msg, strlen(msg) + 1, &data, &dataLen) != SOFTBUS_OK) {
528 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "encrypt device info fail.");
529 cJSON_free(msg);
530 return SOFTBUS_ENCRYPT_ERR;
531 }
532 cJSON_free(msg);
533
534 AuthDataHead head = {
535 .dataType = DATA_TYPE_DEVICE_INFO,
536 .module = MODULE_AUTH_CONNECTION,
537 .seq = GenSeq(false),
538 .flag = 0,
539 .len = dataLen,
540 };
541 if (PostAuthData(auth->connId, !auth->isServer, &head, data) != SOFTBUS_OK) {
542 SoftBusLog(SOFTBUS_LOG_AUTH, SOFTBUS_LOG_ERROR, "post verify device msg fail.");
543 return SOFTBUS_ERR;
544 }
545 return SOFTBUS_OK;
546 }
547