1 /*
2 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "auth_session_message.h"
17
18 #include <math.h>
19 #include <securec.h>
20
21 #include "anonymizer.h"
22 #include "auth_common.h"
23 #include "auth_connection.h"
24 #include "auth_device_common_key.h"
25 #include "auth_hichain_adapter.h"
26 #include "auth_interface.h"
27 #include "auth_log.h"
28 #include "auth_manager.h"
29 #include "auth_request.h"
30 #include "bus_center_manager.h"
31 #include "lnn_cipherkey_manager.h"
32 #include "lnn_common_utils.h"
33 #include "lnn_compress.h"
34 #include "lnn_event.h"
35 #include "lnn_extdata_config.h"
36 #include "lnn_feature_capability.h"
37 #include "lnn_local_net_ledger.h"
38 #include "lnn_network_manager.h"
39 #include "lnn_node_info.h"
40 #include "lnn_settingdata_event_monitor.h"
41 #include "softbus_adapter_json.h"
42 #include "softbus_adapter_mem.h"
43 #include "softbus_adapter_socket.h"
44 #include "softbus_adapter_timer.h"
45 #include "softbus_common.h"
46 #include "softbus_config_type.h"
47 #include "softbus_def.h"
48 #include "softbus_feature_config.h"
49 #include "softbus_json_utils.h"
50 #include "softbus_socket.h"
51
52 /* DeviceId */
53 #define CMD_TAG "TECmd"
54 #define CMD_GET_AUTH_INFO "getAuthInfo"
55 #define CMD_RET_AUTH_INFO "retAuthInfo"
56 #define DATA_TAG "TEData"
57 #define DEVICE_ID_TAG "TEDeviceId"
58 #define DATA_BUF_SIZE_TAG "DataBufSize"
59 #define SOFTBUS_VERSION_TAG "softbusVersion"
60 #define SUPPORT_INFO_COMPRESS "supportInfoCompress"
61 #define EXCHANGE_ID_TYPE "exchangeIdType"
62 #define DEV_IP_HASH_TAG "DevIpHash"
63 #define CMD_TAG_LEN 30
64 #define PACKET_SIZE (64 * 1024)
65
66 /* DeviceInfo-WiFi */
67 #define CODE_VERIFY_IP 1
68 #define BUS_MAX_VERSION "BUS_MAX_VERSION"
69 #define BUS_MIN_VERSION "BUS_MIN_VERSION"
70 #define AUTH_PORT "AUTH_PORT"
71 #define SESSION_PORT "SESSION_PORT"
72 #define PROXY_PORT "PROXY_PORT"
73 #define DEV_IP "DEV_IP"
74 #define BLE_OFFLINE_CODE "OFFLINE_CODE"
75 #define BUS_V1 1
76 #define BUS_V2 2
77
78 /* DeviceInfo-BT */
79 #define CODE_VERIFY_BT 5
80 #define DISCOVERY_TYPE "DISCOVERY_TYPE"
81 #define UUID "UUID"
82 #define DEVICE_VERSION_TYPE "DEVICE_VERSION_TYPE"
83 #define BR_MAC_ADDR "BR_MAC_ADDR"
84 #define CONNECT_INFO "CONNECT_INFO"
85
86 /* DeviceInfo-common */
87 #define CODE "CODE"
88 #define DEVICE_NAME "DEVICE_NAME"
89 #define DEVICE_TYPE "DEVICE_TYPE"
90 #define DEVICE_UDID "DEVICE_UDID"
91 #define DEVICE_UUID "DEVICE_UUID"
92 #define NETWORK_ID "NETWORK_ID"
93 #define NODE_ADDR "NODE_ADDR"
94 #define VERSION_TYPE "VERSION_TYPE"
95 #define BT_MAC "BT_MAC"
96 #define BLE_MAC "BLE_MAC"
97 #define CONN_CAP "CONN_CAP"
98 #define AUTH_CAP "AUTH_CAP"
99 #define SW_VERSION "SW_VERSION"
100 #define MASTER_UDID "MASTER_UDID"
101 #define MASTER_WEIGHT "MASTER_WEIGHT"
102 #define BLE_P2P "BLE_P2P"
103 #define STA_FREQUENCY "STA_FREQUENCY"
104 #define P2P_MAC_ADDR "P2P_MAC_ADDR"
105 #define P2P_ROLE "P2P_ROLE"
106 #define TRANSPORT_PROTOCOL "TRANSPORT_PROTOCOL"
107 #define DATA_CHANGE_FLAG "NODE_DATA_CHANGE_FLAG"
108 #define IS_CHARGING "IS_CHARGING"
109 #define BATTERY_LEAVEL "BATTERY_LEAVEL"
110 #define PKG_VERSION "PKG_VERSION"
111 #define OS_TYPE "OS_TYPE"
112 #define OS_VERSION "OS_VERSION"
113 #define WIFI_VERSION "WIFI_VERSION"
114 #define BLE_VERSION "BLE_VERSION"
115 #define HML_MAC "HML_MAC"
116 #define WIFI_CFG "WIFI_CFG"
117 #define CHAN_LIST_5G "CHAN_LIST_5G"
118 #define REMAIN_POWER "REMAIN_POWER"
119 #define IS_CHARGING "IS_CHARGING"
120 #define IS_SCREENON "IS_SCREENON"
121 #define IP_MAC "IP_MAC"
122 #define NODE_WEIGHT "NODE_WEIGHT"
123 #define ACCOUNT_ID "ACCOUNT_ID"
124 #define DISTRIBUTED_SWITCH "DISTRIBUTED_SWITCH"
125 #define TRANS_FLAGS "TRANS_FLAGS"
126 #define BLE_TIMESTAMP "BLE_TIMESTAMP"
127 #define WIFI_BUFF_SIZE "WIFI_BUFF_SIZE"
128 #define BR_BUFF_SIZE "BR_BUFF_SIZE"
129 #define FEATURE "FEATURE"
130 #define CONN_SUB_FEATURE "CONN_SUB_FEATURE"
131 #define META_NODE_INFO_OF_EAR "MetaNodeInfoOfEar"
132 #define NEW_CONN_CAP "NEW_CONN_CAP"
133 #define EXTDATA "EXTDATA"
134 #define STATE_VERSION "STATE_VERSION"
135 #define BD_KEY "BD_KEY"
136 #define IV "IV"
137 #define SETTINGS_NICK_NAME "SETTINGS_NICK_NAME"
138 #define UNIFIED_DISPLAY_DEVICE_NAME "UNIFIED_DISPLAY_DEVICE_NAME"
139 #define UNIFIED_DEFAULT_DEVICE_NAME "UNIFIED_DEFAULT_DEVICE_NAME"
140 #define UNIFIED_DEVICE_NAME "UNIFIED_DEVICE_NAME"
141 #define PTK "PTK"
142 #define STATIC_CAP "STATIC_CAP"
143 #define STATIC_CAP_LENGTH "STATIC_CAP_LEN"
144 #define BROADCAST_CIPHER_KEY "BROADCAST_CIPHER_KEY"
145 #define BROADCAST_CIPHER_IV "BROADCAST_CIPHER_IV"
146 #define IRK "IRK"
147 #define PUB_MAC "PUB_MAC"
148 #define OH_OS_TYPE 10
149
150 #define FLAG_COMPRESS_DEVICE_INFO 1
151 #define FLAG_UNCOMPRESS_DEVICE_INFO 0
152 #define FLAG_RELAY_DEVICE_INFO 1
153
154 #define HAS_CTRL_CHANNEL (0x1L)
155 #define HAS_CHANNEL_AUTH (0x2L)
156 #define HAS_P2P_AUTH_V2 (0x04L)
157 #define HAS_SUPPRESS_STRATEGY (0x08L)
158 #define HAS_WAIT_TCP_TX_DONE (0x10L)
159 #define LOCAL_FLAGS (HAS_CTRL_CHANNEL | HAS_P2P_AUTH_V2 | HAS_SUPPRESS_STRATEGY | HAS_WAIT_TCP_TX_DONE)
160 #define DEVICE_ID_STR_LEN 64 // for bt v1
161 #define DEFAULT_BATTERY_LEVEL 100
162 #define DEFAULT_NODE_WEIGHT 100
163 #define BASE64_OFFLINE_CODE_LEN ((OFFLINE_CODE_BYTE_SIZE / 3 + 1) * 4 + 1)
164 #define DEFAULT_WIFI_BUFF_SIZE 32768 // 32k
165 #define DEFAULT_BR_BUFF_SIZE 4096 // 4k
166 #define DEFAULT_BLE_TIMESTAMP (roundl(pow(2, 63)) - 1)
167 #define BT_DISC_TYPE_MAX_LEN 7 // br, ble,...
168 #define BT_MAC_LEN 18
169 #define DEFAULT_BT_DISC_TYPE_STR "NO"
170 #define PARSE_UNCOMPRESS_STRING_BUFF_LEN 6 // "true" or "false"
171 #define TRUE_STRING_TAG "true"
172 #define FALSE_STRING_TAG "false"
173
174 /* fast_auth */
175 #define ACCOUNT_HASH "accountHash"
176 #define COMMON_KEY_HASH "keyHash"
177 #define FAST_AUTH "fastauth"
178 #define SOFTBUS_FAST_AUTH "support_fast_auth"
179
180 /* VerifyDevice */
181 #define CODE_VERIFY_DEVICE 2
182 #define DEVICE_ID "DEVICE_ID"
183 #define ENCRYPTED_FAST_AUTH_MAX_LEN 512
184 #define UDID_SHORT_HASH_HEX_STR 16
185 #define UDID_SHORT_HASH_LEN_TEMP 8
186
187 /* ble conn close delay time */
188 #define BLE_CONN_CLOSE_DELAY_TIME "BLE_CONN_CLOSE_DELAY_TIME"
189 #define BLE_MAC_REFRESH_SWITCH "BLE_MAC_REFRESH_SWITCH"
190 #define BLE_CONNECTION_CLOSE_DELAY (10 * 1000L)
191 #define BLE_MAC_AUTO_REFRESH_SWITCH 1
192
OptString(const JsonObj * json,const char * const key,char * target,uint32_t targetLen,const char * defaultValue)193 static void OptString(const JsonObj *json, const char * const key,
194 char *target, uint32_t targetLen, const char *defaultValue)
195 {
196 if (JSON_GetStringFromOject(json, key, target, targetLen)) {
197 return;
198 }
199 if (strcpy_s(target, targetLen, defaultValue) != EOK) {
200 AUTH_LOGI(AUTH_FSM, "set default fail");
201 return;
202 }
203 AUTH_LOGI(AUTH_FSM, "key prase fail, use default. key=%{public}s", key);
204 }
205
OptInt(const JsonObj * json,const char * const key,int * target,int defaultValue)206 static void OptInt(const JsonObj *json, const char * const key, int *target, int defaultValue)
207 {
208 if (JSON_GetInt32FromOject(json, key, target)) {
209 return;
210 }
211 AUTH_LOGI(AUTH_FSM, "key prase fail, use default. key=%{public}s", key);
212 *target = defaultValue;
213 }
214
OptInt64(const JsonObj * json,const char * const key,int64_t * target,int64_t defaultValue)215 static void OptInt64(const JsonObj *json, const char * const key, int64_t *target, int64_t defaultValue)
216 {
217 if (JSON_GetInt64FromOject(json, key, target)) {
218 return;
219 }
220 AUTH_LOGI(AUTH_FSM, "key prase fail, use default. key=%{public}s", key);
221 *target = defaultValue;
222 }
223
OptBool(const JsonObj * json,const char * const key,bool * target,bool defaultValue)224 static void OptBool(const JsonObj *json, const char * const key, bool *target, bool defaultValue)
225 {
226 if (JSON_GetBoolFromOject(json, key, target)) {
227 return;
228 }
229 AUTH_LOGI(AUTH_FSM, "key prase fail, use default. key=%{public}s", key);
230 *target = defaultValue;
231 }
232
PackFastAuthValue(JsonObj * obj,AuthDeviceKeyInfo * deviceCommKey)233 static int32_t PackFastAuthValue(JsonObj *obj, AuthDeviceKeyInfo *deviceCommKey)
234 {
235 uint32_t dataLen = 0;
236 uint8_t *data = NULL;
237 AesGcmInputParam aesParam = {0};
238 aesParam.data = (uint8_t *)SOFTBUS_FAST_AUTH;
239 aesParam.dataLen = strlen(SOFTBUS_FAST_AUTH);
240 aesParam.key = deviceCommKey->deviceKey;
241 aesParam.keyLen = deviceCommKey->keyLen;
242 int32_t ret = LnnEncryptAesGcm(&aesParam, (int32_t)deviceCommKey->keyIndex, &data, &dataLen);
243 if (ret != SOFTBUS_OK) {
244 AUTH_LOGE(AUTH_FSM, "SoftBusEncryptDataWithSeq fail=%{public}d", ret);
245 return SOFTBUS_ERR;
246 }
247 if (data == NULL || dataLen == 0) {
248 AUTH_LOGE(AUTH_FSM, "encrypt data invalid");
249 return SOFTBUS_INVALID_PARAM;
250 }
251 char encryptFastAuth[ENCRYPTED_FAST_AUTH_MAX_LEN] = {0};
252 if (ConvertBytesToUpperCaseHexString(encryptFastAuth, ENCRYPTED_FAST_AUTH_MAX_LEN - 1,
253 data, dataLen) != SOFTBUS_OK) {
254 SoftBusFree(data);
255 return SOFTBUS_ERR;
256 }
257 AUTH_LOGD(AUTH_FSM, "pack fastAuthTag=%{public}s", encryptFastAuth);
258 JSON_AddStringToObject(obj, FAST_AUTH, encryptFastAuth);
259 SoftBusFree(data);
260 return SOFTBUS_OK;
261 }
262
GenerateUdidShortHash(const char * udid,char * udidHashBuf,uint32_t bufLen)263 static bool GenerateUdidShortHash(const char *udid, char *udidHashBuf, uint32_t bufLen)
264 {
265 uint8_t hash[SHA_256_HASH_LEN] = {0};
266 int ret = SoftBusGenerateStrHash((uint8_t *)udid, strlen(udid), hash);
267 if (ret != SOFTBUS_OK) {
268 AUTH_LOGE(AUTH_FSM, "generate udidHash fail");
269 return false;
270 }
271 if (ConvertBytesToUpperCaseHexString(udidHashBuf, bufLen, hash, UDID_SHORT_HASH_LEN_TEMP) != SOFTBUS_OK) {
272 AUTH_LOGE(AUTH_FSM, "convert bytes to string fail");
273 return false;
274 }
275 return true;
276 }
277
GetUdidOrShortHash(const AuthSessionInfo * info,char * udidBuf,uint32_t bufLen)278 static bool GetUdidOrShortHash(const AuthSessionInfo *info, char *udidBuf, uint32_t bufLen)
279 {
280 if (!info->isServer && info->connInfo.type == AUTH_LINK_TYPE_ENHANCED_P2P) {
281 AUTH_LOGD(AUTH_FSM, "client(enhance p2p), use conninfo udid");
282 return GenerateUdidShortHash(info->connInfo.info.ipInfo.udid, udidBuf, bufLen);
283 }
284 if (strlen(info->udid) != 0) {
285 AUTH_LOGI(AUTH_FSM, "use info->udid build fastAuthInfo");
286 return GenerateUdidShortHash(info->udid, udidBuf, bufLen);
287 }
288 if (info->connInfo.type == AUTH_LINK_TYPE_BLE) {
289 AUTH_LOGI(AUTH_FSM, "use bleInfo deviceIdHash build fastAuthInfo");
290 AuthRequest request = {0};
291 if (GetAuthRequestNoLock(info->requestId, &request) != SOFTBUS_OK) {
292 AUTH_LOGE(AUTH_FSM, "GetAuthRequest fail");
293 return false;
294 }
295 return (memcpy_s(udidBuf, bufLen, request.connInfo.info.bleInfo.deviceIdHash, UDID_SHORT_HASH_HEX_STR) == EOK);
296 }
297 AUTH_LOGD(AUTH_FSM, "udidLen=%{public}zu, connInfoType=%{public}d", strlen(info->udid), info->connInfo.type);
298 return false;
299 }
300
GetEnhancedP2pAuthKey(const char * udidHash,AuthSessionInfo * info,AuthDeviceKeyInfo * deviceKey)301 static int32_t GetEnhancedP2pAuthKey(const char *udidHash, AuthSessionInfo *info, AuthDeviceKeyInfo *deviceKey)
302 {
303 /* first, reuse ble authKey */
304 if (AuthFindDeviceKey(udidHash, AUTH_LINK_TYPE_BLE, deviceKey) == SOFTBUS_OK) {
305 AUTH_LOGD(AUTH_FSM, "get ble authKey succ");
306 return SOFTBUS_OK;
307 }
308 /* second, reuse wifi authKey */
309 int64_t authId = AuthGetLatestIdByUuid(info->uuid, AUTH_LINK_TYPE_WIFI, false);
310 if (authId == AUTH_INVALID_ID) {
311 AUTH_LOGE(AUTH_FSM, "get wifi authKey fail");
312 return SOFTBUS_ERR;
313 }
314 AuthManager *auth = GetAuthManagerByAuthId(authId);
315 int32_t index;
316 SessionKey sessionKey;
317 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
318 if (GetLatestSessionKey(&auth->sessionKeyList, &index, &sessionKey) != SOFTBUS_OK) {
319 AUTH_LOGE(AUTH_FSM, "get key fail");
320 DelAuthManager(auth, false);
321 return SOFTBUS_ERR;
322 }
323 DelAuthManager(auth, false);
324 if (memcpy_s(deviceKey->deviceKey, SESSION_KEY_LENGTH,
325 sessionKey.value, sizeof(sessionKey.value)) != EOK) {
326 AUTH_LOGE(AUTH_FSM, "memcpy fail");
327 return SOFTBUS_MEM_ERR;
328 }
329 deviceKey->keyLen = sessionKey.len;
330 /* wifi authKey not enable, associated with recoveryDeviceKey */
331 return SOFTBUS_ERR;
332 }
333
GetFastAuthKey(const char * udidHash,AuthSessionInfo * info,AuthDeviceKeyInfo * deviceKey)334 static int32_t GetFastAuthKey(const char *udidHash, AuthSessionInfo *info, AuthDeviceKeyInfo *deviceKey)
335 {
336 if (info->connInfo.type == AUTH_LINK_TYPE_ENHANCED_P2P) {
337 AUTH_LOGI(AUTH_FSM, "get enhanced p2p fastAuth key");
338 return GetEnhancedP2pAuthKey(udidHash, info, deviceKey);
339 }
340 if (AuthFindDeviceKey(udidHash, info->connInfo.type, deviceKey) != SOFTBUS_OK) {
341 AUTH_LOGW(AUTH_FSM, "can't find common key, unsupport fastAuth");
342 info->isSupportFastAuth = false;
343 return SOFTBUS_ERR;
344 }
345 return SOFTBUS_OK;
346 }
347
PackFastAuth(JsonObj * obj,AuthSessionInfo * info,const NodeInfo * localNodeInfo)348 static void PackFastAuth(JsonObj *obj, AuthSessionInfo *info, const NodeInfo *localNodeInfo)
349 {
350 AUTH_LOGD(AUTH_FSM, "pack fastAuth, isServer=%{public}d", info->isServer);
351 bool isNeedPack;
352 if (!info->isServer || info->isSupportFastAuth) {
353 isNeedPack = true;
354 } else {
355 AUTH_LOGI(AUTH_FSM, "unsupport fastAuth");
356 isNeedPack = false;
357 }
358 if (isNeedPack && info->isNeedFastAuth == false) {
359 AUTH_LOGI(AUTH_FSM, "no need fastAuth");
360 isNeedPack = false;
361 }
362 if (!isNeedPack) {
363 return;
364 }
365 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = {0};
366 if (!GetUdidOrShortHash(info, udidHashHexStr, SHA_256_HEX_HASH_LEN)) {
367 AUTH_LOGE(AUTH_FSM, "get udid fail, bypass fastAuth");
368 info->isSupportFastAuth = false;
369 return;
370 }
371 AUTH_LOGD(AUTH_FSM, "udidHashHexStr=%{public}s", udidHashHexStr);
372 if (info->connInfo.type != AUTH_LINK_TYPE_ENHANCED_P2P &&
373 !IsPotentialTrustedDevice(ID_TYPE_DEVID, (const char *)udidHashHexStr, false, false)) {
374 AUTH_LOGI(AUTH_FSM, "not potential trusted realtion, bypass fastAuthProc");
375 info->isSupportFastAuth = false;
376 return;
377 }
378 AuthDeviceKeyInfo deviceCommKey = {0};
379 if (GetFastAuthKey(udidHashHexStr, info, &deviceCommKey) != SOFTBUS_OK) {
380 info->isSupportFastAuth = false;
381 return;
382 }
383 if (PackFastAuthValue(obj, &deviceCommKey) != SOFTBUS_OK) {
384 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
385 info->isSupportFastAuth = false;
386 return;
387 }
388 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
389 }
390
ParseFastAuthValue(AuthSessionInfo * info,const char * encryptedFastAuth,AuthDeviceKeyInfo * deviceKey)391 static void ParseFastAuthValue(AuthSessionInfo *info, const char *encryptedFastAuth, AuthDeviceKeyInfo *deviceKey)
392 {
393 uint8_t fastAuthBytes[ENCRYPTED_FAST_AUTH_MAX_LEN] = {0};
394 if (ConvertHexStringToBytes(fastAuthBytes, ENCRYPTED_FAST_AUTH_MAX_LEN,
395 encryptedFastAuth, strlen(encryptedFastAuth)) != SOFTBUS_OK) {
396 AUTH_LOGE(AUTH_FSM, "fastAuth data String to bytes fail");
397 return;
398 }
399 uint32_t bytesLen = strlen(encryptedFastAuth) >> 1;
400 uint32_t dataLen = 0;
401 uint8_t *data = NULL;
402 AesGcmInputParam aesParam = {0};
403 aesParam.data = fastAuthBytes;
404 aesParam.dataLen = bytesLen;
405 aesParam.key = deviceKey->deviceKey;
406 aesParam.keyLen = deviceKey->keyLen;
407 int32_t ret = LnnDecryptAesGcm(&aesParam, &data, &dataLen);
408 if (ret != SOFTBUS_OK) {
409 AUTH_LOGE(AUTH_FSM, "LnnDecryptAesGcm fail, fastAuth not support. ret=%{public}d", ret);
410 return;
411 }
412 if (data == NULL || dataLen == 0) {
413 AUTH_LOGE(AUTH_FSM, "decrypt data invalid, fastAuth not support");
414 return;
415 }
416 if (strncmp((char *)data, SOFTBUS_FAST_AUTH, strlen(SOFTBUS_FAST_AUTH)) != 0) {
417 AUTH_LOGE(AUTH_FSM, "fast auth info error");
418 SoftBusFree(data);
419 return;
420 }
421 AUTH_LOGD(AUTH_FSM, "parse fastAuth succ");
422 SoftBusFree(data);
423 info->isSupportFastAuth = true;
424 }
425
UnpackFastAuth(JsonObj * obj,AuthSessionInfo * info)426 static void UnpackFastAuth(JsonObj *obj, AuthSessionInfo *info)
427 {
428 info->isSupportFastAuth = false;
429 char encryptedFastAuth[ENCRYPTED_FAST_AUTH_MAX_LEN] = {0};
430 if (!JSON_GetStringFromOject(obj, FAST_AUTH, encryptedFastAuth, ENCRYPTED_FAST_AUTH_MAX_LEN)) {
431 AUTH_LOGI(AUTH_FSM, "old version or not support fastAuth");
432 return;
433 }
434 AUTH_LOGE(AUTH_FSM, "unpack fastAuthTag=%{public}s", encryptedFastAuth);
435 uint8_t udidHash[SHA_256_HASH_LEN] = {0};
436 int ret = SoftBusGenerateStrHash((uint8_t *)info->udid, strlen(info->udid), udidHash);
437 if (ret != SOFTBUS_OK) {
438 AUTH_LOGE(AUTH_FSM, "generate udidHash fail");
439 return;
440 }
441 char udidShortHash[UDID_SHORT_HASH_HEX_STR + 1] = {0};
442 if (ConvertBytesToUpperCaseHexString(udidShortHash, UDID_SHORT_HASH_HEX_STR + 1,
443 udidHash, UDID_SHORT_HASH_LEN_TEMP) != SOFTBUS_OK) {
444 AUTH_LOGE(AUTH_FSM, "udid hash bytes to hexString fail");
445 return;
446 }
447 if (info->connInfo.type != AUTH_LINK_TYPE_ENHANCED_P2P &&
448 !IsPotentialTrustedDevice(ID_TYPE_DEVID, (const char *)udidShortHash, false, false)) {
449 AUTH_LOGI(AUTH_FSM, "not potential trusted realtion, fastAuth not support");
450 return;
451 }
452 AuthDeviceKeyInfo deviceKey = {0};
453 if (GetFastAuthKey(udidShortHash, info, &deviceKey) != SOFTBUS_OK) {
454 AUTH_LOGW(AUTH_FSM, "can't find device key, fastAuth not support");
455 return;
456 }
457 ParseFastAuthValue(info, encryptedFastAuth, &deviceKey);
458 (void)memset_s(&deviceKey, sizeof(deviceKey), 0, sizeof(deviceKey));
459 }
460
PackCompressInfo(JsonObj * obj,const NodeInfo * info)461 static void PackCompressInfo(JsonObj *obj, const NodeInfo *info)
462 {
463 if (info != NULL) {
464 if (IsFeatureSupport(info->feature, BIT_INFO_COMPRESS)) {
465 JSON_AddStringToObject(obj, SUPPORT_INFO_COMPRESS, TRUE_STRING_TAG);
466 } else {
467 JSON_AddStringToObject(obj, SUPPORT_INFO_COMPRESS, FALSE_STRING_TAG);
468 }
469 }
470 }
471
PackWifiSinglePassInfo(JsonObj * obj,const AuthSessionInfo * info)472 static void PackWifiSinglePassInfo(JsonObj *obj, const AuthSessionInfo *info)
473 {
474 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI) {
475 AUTH_LOGE(AUTH_FSM, "link type is not wifi");
476 return;
477 }
478 uint8_t hash[SHA_256_HASH_LEN] = {0};
479 char localIp[MAX_ADDR_LEN] = {0};
480 if (LnnGetLocalStrInfo(STRING_KEY_WLAN_IP, localIp, MAX_ADDR_LEN) != SOFTBUS_OK) {
481 AUTH_LOGE(AUTH_FSM, "get local ip fail");
482 return;
483 }
484 int32_t ret = SoftBusGenerateStrHash((const unsigned char *)localIp, strlen(localIp), hash);
485 if (ret != SOFTBUS_OK) {
486 return;
487 }
488 char devIpHash[SHA_256_HEX_HASH_LEN] = {0};
489 if (ConvertBytesToUpperCaseHexString(devIpHash, SHA_256_HEX_HASH_LEN,
490 hash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
491 return;
492 }
493 JSON_AddStringToObject(obj, DEV_IP_HASH_TAG, devIpHash);
494 }
495
VerifySessionInfoIdType(const AuthSessionInfo * info,JsonObj * obj,char * networkId,char * udid)496 static bool VerifySessionInfoIdType(const AuthSessionInfo *info, JsonObj *obj, char *networkId, char *udid)
497 {
498 if (info->idType == EXCHANGE_NETWORKID) {
499 if (!JSON_AddStringToObject(obj, DEVICE_ID_TAG, networkId)) {
500 AUTH_LOGE(AUTH_FSM, "add msg body fail");
501 return false;
502 }
503 char *anonyNetworkId = NULL;
504 Anonymize(networkId, &anonyNetworkId);
505 AUTH_LOGI(AUTH_FSM, "exchangeIdType=%{public}d, networkid=%{public}s", info->idType, anonyNetworkId);
506 AnonymizeFree(anonyNetworkId);
507 } else {
508 if (!JSON_AddStringToObject(obj, DEVICE_ID_TAG, udid)) {
509 AUTH_LOGE(AUTH_FSM, "add msg body fail");
510 return false;
511 }
512 char *anonyUdid = NULL;
513 Anonymize(udid, &anonyUdid);
514 AUTH_LOGI(AUTH_FSM, "exchangeIdType=%{public}d, udid=%{public}s", info->idType, anonyUdid);
515 AnonymizeFree(anonyUdid);
516 }
517
518 AUTH_LOGI(AUTH_FSM, "session info verify succ.");
519 return true;
520 }
521
PackDeviceIdJson(const AuthSessionInfo * info)522 static char *PackDeviceIdJson(const AuthSessionInfo *info)
523 {
524 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", info->connInfo.type);
525 JsonObj *obj = JSON_CreateObject();
526 if (obj == NULL) {
527 return NULL;
528 }
529 char uuid[UUID_BUF_LEN] = {0};
530 char udid[UDID_BUF_LEN] = {0};
531 char networkId[NETWORK_ID_BUF_LEN] = {0};
532 if (LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) != SOFTBUS_OK ||
533 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK ||
534 LnnGetLocalStrInfo(STRING_KEY_NETWORKID, networkId, sizeof(networkId)) != SOFTBUS_OK) {
535 AUTH_LOGE(AUTH_FSM, "get uuid/udid/networkId fail");
536 JSON_Delete(obj);
537 return NULL;
538 }
539 PackWifiSinglePassInfo(obj, info);
540 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI && !info->isServer) {
541 if (!JSON_AddStringToObject(obj, CMD_TAG, CMD_GET_AUTH_INFO)) {
542 AUTH_LOGE(AUTH_FSM, "add CMD_GET fail");
543 JSON_Delete(obj);
544 return NULL;
545 }
546 } else {
547 if (!JSON_AddStringToObject(obj, CMD_TAG, CMD_RET_AUTH_INFO)) {
548 AUTH_LOGE(AUTH_FSM, "add CMD_RET fail");
549 JSON_Delete(obj);
550 return NULL;
551 }
552 }
553 if (!VerifySessionInfoIdType(info, obj, networkId, udid)) {
554 JSON_Delete(obj);
555 return NULL;
556 }
557 if (!JSON_AddStringToObject(obj, DATA_TAG, uuid) || !JSON_AddInt32ToObject(obj, DATA_BUF_SIZE_TAG, PACKET_SIZE) ||
558 !JSON_AddInt32ToObject(obj, SOFTBUS_VERSION_TAG, info->version) ||
559 !JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, info->idType)) {
560 AUTH_LOGE(AUTH_FSM, "add msg body fail");
561 JSON_Delete(obj);
562 return NULL;
563 }
564 const NodeInfo *nodeInfo = LnnGetLocalNodeInfo();
565 PackCompressInfo(obj, nodeInfo);
566 PackFastAuth(obj, (AuthSessionInfo *)info, nodeInfo);
567 char *msg = JSON_PrintUnformatted(obj);
568 JSON_Delete(obj);
569 return msg;
570 }
571
UnpackWifiSinglePassInfo(JsonObj * obj,AuthSessionInfo * info)572 static bool UnpackWifiSinglePassInfo(JsonObj *obj, AuthSessionInfo *info)
573 {
574 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI) {
575 AUTH_LOGD(AUTH_FSM, "isn't wifi link, ignore");
576 return true;
577 }
578 char devIpHash[SHA_256_HEX_HASH_LEN] = {0};
579 if (!JSON_GetStringFromOject(obj, DEV_IP_HASH_TAG, devIpHash, SHA_256_HEX_HASH_LEN)) {
580 AUTH_LOGD(AUTH_FSM, "devIpHash hash not found, ignore");
581 return true;
582 }
583 // check devIpHash
584 int32_t socketFd = GetFd(info->connId);
585 SoftBusSockAddrIn addr = {0};
586 SocketAddr socketAddr;
587 int32_t rc = SoftBusSocketGetPeerName(socketFd, (SoftBusSockAddr *)&addr);
588 if (rc != SOFTBUS_OK) {
589 AUTH_LOGE(AUTH_FSM, "GetPerrName fd=%{public}d, rc=%{public}d", socketFd, rc);
590 return true;
591 }
592 (void)memset_s(&socketAddr, sizeof(socketAddr), 0, sizeof(socketAddr));
593 if (SoftBusInetNtoP(SOFTBUS_AF_INET, (void *)&addr.sinAddr, socketAddr.addr, sizeof(socketAddr.addr)) == NULL) {
594 AUTH_LOGE(AUTH_FSM, "GetPerrName fd=%{public}d, rc=%{public}d", socketFd, rc);
595 return true;
596 }
597 uint8_t hash[SHA_256_HASH_LEN] = {0};
598 rc = SoftBusGenerateStrHash((const unsigned char *)socketAddr.addr, strlen(socketAddr.addr), hash);
599 if (rc != SOFTBUS_OK) {
600 AUTH_LOGE(AUTH_FSM, "generate hash failed rc=%{public}d", rc);
601 return true;
602 }
603 char socketIpHash[SHA_256_HEX_HASH_LEN] = { 0 };
604 if (ConvertBytesToUpperCaseHexString(socketIpHash, SHA_256_HEX_HASH_LEN, hash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
605 return true;
606 }
607 if (strcmp(devIpHash, socketIpHash) == 0) {
608 AUTH_LOGE(AUTH_FSM, "devIpHash is mismatch");
609 return true;
610 }
611 return false;
612 }
613
UnPackBtDeviceIdV1(AuthSessionInfo * info,const uint8_t * data,uint32_t len)614 static int32_t UnPackBtDeviceIdV1(AuthSessionInfo *info, const uint8_t *data, uint32_t len)
615 {
616 if (!info->isServer) {
617 AUTH_LOGE(AUTH_FSM, "is not server");
618 return SOFTBUS_INVALID_PARAM;
619 }
620 if (memcpy_s(info->udid, UDID_BUF_LEN, data, len) != EOK) { // data:StandardCharsets.UTF_8
621 AUTH_LOGE(AUTH_FSM, "memcpy fail");
622 return SOFTBUS_MEM_ERR;
623 }
624 return SOFTBUS_OK;
625 }
626
SetCompressFlag(const char * compressCapa,bool * sessionSupportFlag)627 static void SetCompressFlag(const char *compressCapa, bool *sessionSupportFlag)
628 {
629 const NodeInfo *node = LnnGetLocalNodeInfo();
630 if (node == NULL) {
631 return;
632 }
633 bool isRemoteSupportCompress = false;
634 if (strncmp(compressCapa, TRUE_STRING_TAG, strlen(compressCapa)) == 0) {
635 isRemoteSupportCompress = true;
636 } else {
637 isRemoteSupportCompress = false;
638 }
639 if (IsFeatureSupport(node->feature, BIT_INFO_COMPRESS) && isRemoteSupportCompress) {
640 *sessionSupportFlag = true;
641 AUTH_LOGI(AUTH_FSM, "local-remote all support deviceinfo compress");
642 } else {
643 *sessionSupportFlag = false;
644 }
645 }
646
VerifyExchangeIdTypeAndInfo(AuthSessionInfo * info,int32_t idType,char * anonyUdid)647 static int32_t VerifyExchangeIdTypeAndInfo(AuthSessionInfo *info, int32_t idType, char *anonyUdid)
648 {
649 char peerUdid[UDID_BUF_LEN] = {0};
650
651 if (idType == EXCHANGE_NETWORKID) {
652 if (GetPeerUdidByNetworkId(info->udid, peerUdid) != SOFTBUS_OK) {
653 AUTH_LOGE(AUTH_FSM, "get peer udid fail, peer networkId=%s", anonyUdid);
654 info->idType = EXCHANGE_FAIL;
655 } else {
656 if (memcpy_s(info->udid, UDID_BUF_LEN, peerUdid, UDID_BUF_LEN) != EOK) {
657 AUTH_LOGE(AUTH_FSM, "copy peer udid fail");
658 info->idType = EXCHANGE_FAIL;
659 return SOFTBUS_MEM_ERR;
660 }
661 AUTH_LOGE(AUTH_FSM, "get peer udid success, peer udid=%s", anonyUdid);
662 info->idType = EXCHANGE_NETWORKID;
663 }
664 }
665 AUTH_LOGI(AUTH_FSM, "idType verify and get info succ.");
666 return SOFTBUS_OK;
667 }
668
SetExchangeIdTypeAndValue(JsonObj * obj,AuthSessionInfo * info)669 static int32_t SetExchangeIdTypeAndValue(JsonObj *obj, AuthSessionInfo *info)
670 {
671 if (obj == NULL || info == NULL) {
672 AUTH_LOGE(AUTH_FSM, "param invalid");
673 return SOFTBUS_INVALID_PARAM;
674 }
675
676 int32_t idType = -1;
677 if (!JSON_GetInt32FromOject(obj, EXCHANGE_ID_TYPE, &idType)) {
678 AUTH_LOGI(AUTH_FSM, "parse idType failed, ignore");
679 info->idType = EXCHANHE_UDID;
680 return SOFTBUS_OK;
681 }
682 char *anonyUdid = NULL;
683 Anonymize(info->udid, &anonyUdid);
684 AUTH_LOGI(AUTH_FSM,
685 "oldIdType=%{public}d, exchangeIdType=%{public}d, deviceId=%{public}s", info->idType, idType, anonyUdid);
686 if (idType == EXCHANHE_UDID) {
687 info->idType = EXCHANHE_UDID;
688 AnonymizeFree(anonyUdid);
689 return SOFTBUS_OK;
690 }
691 if (info->isServer) {
692 if (VerifyExchangeIdTypeAndInfo(info, idType, anonyUdid) != SOFTBUS_OK) {
693 AnonymizeFree(anonyUdid);
694 return SOFTBUS_ERR;
695 }
696 AUTH_LOGI(AUTH_FSM, "isServer is true in authSessionInfo.");
697 AnonymizeFree(anonyUdid);
698 return SOFTBUS_OK;
699 }
700 if (info->idType == EXCHANGE_NETWORKID) {
701 if (idType == EXCHANGE_FAIL) {
702 info->idType = EXCHANGE_FAIL;
703 }
704 if (VerifyExchangeIdTypeAndInfo(info, idType, anonyUdid) != SOFTBUS_OK) {
705 AnonymizeFree(anonyUdid);
706 return SOFTBUS_ERR;
707 }
708 }
709 AnonymizeFree(anonyUdid);
710 return SOFTBUS_OK;
711 }
712
UnPackVersionByDeviceId(JsonObj * obj,AuthSessionInfo * info)713 static void UnPackVersionByDeviceId(JsonObj *obj, AuthSessionInfo *info)
714 {
715 int32_t maxBuffSize;
716 OptString(obj, DEVICE_ID_TAG, info->udid, UDID_BUF_LEN, "");
717 OptInt(obj, DATA_BUF_SIZE_TAG, &maxBuffSize, PACKET_SIZE);
718 if (strlen(info->udid) != 0) {
719 info->version = SOFTBUS_OLD_V2;
720 } else {
721 info->version = SOFTBUS_OLD_V1;
722 if (strcpy_s(info->udid, UDID_BUF_LEN, info->uuid) != EOK) {
723 AUTH_LOGE(AUTH_FSM, "strcpy udid fail, ignore");
724 }
725 }
726 if (!JSON_GetInt32FromOject(obj, SOFTBUS_VERSION_TAG, (int32_t *)&info->version)) {
727 AUTH_LOGE(AUTH_FSM, "softbusVersion is not found");
728 }
729 }
730
UnpackDeviceIdJson(const char * msg,uint32_t len,AuthSessionInfo * info)731 static int32_t UnpackDeviceIdJson(const char *msg, uint32_t len, AuthSessionInfo *info)
732 {
733 JsonObj *obj = JSON_Parse(msg, len);
734 if (obj == NULL) {
735 AUTH_LOGE(AUTH_FSM, "json parse fail");
736 return SOFTBUS_ERR;
737 }
738 char cmd[CMD_TAG_LEN] = {0};
739 if (!JSON_GetStringFromOject(obj, CMD_TAG, cmd, CMD_TAG_LEN)) {
740 AUTH_LOGE(AUTH_FSM, "CMD_TAG not found");
741 JSON_Delete(obj);
742 return SOFTBUS_ERR;
743 }
744 if (!UnpackWifiSinglePassInfo(obj, info)) {
745 AUTH_LOGE(AUTH_FSM, "check ip fail, can't support auth");
746 JSON_Delete(obj);
747 return SOFTBUS_ERR;
748 }
749 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI && info->isServer) {
750 if (strncmp(cmd, CMD_GET_AUTH_INFO, strlen(CMD_GET_AUTH_INFO)) != 0) {
751 AUTH_LOGE(AUTH_FSM, "CMD_GET not match");
752 JSON_Delete(obj);
753 return SOFTBUS_ERR;
754 }
755 } else {
756 if (strncmp(cmd, CMD_RET_AUTH_INFO, strlen(CMD_RET_AUTH_INFO)) != 0) {
757 AUTH_LOGE(AUTH_FSM, "CMD_RET not match");
758 JSON_Delete(obj);
759 return SOFTBUS_ERR;
760 }
761 }
762 if (!JSON_GetStringFromOject(obj, DATA_TAG, info->uuid, UUID_BUF_LEN)) {
763 AUTH_LOGE(AUTH_FSM, "uuid not found");
764 JSON_Delete(obj);
765 return SOFTBUS_ERR;
766 }
767 UnPackVersionByDeviceId(obj, info);
768 if (SetExchangeIdTypeAndValue(obj, info) != SOFTBUS_OK) {
769 AUTH_LOGE(AUTH_FSM, "set exchange id type or value failed");
770 JSON_Delete(obj);
771 return SOFTBUS_ERR;
772 }
773 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI) {
774 char compressParse[PARSE_UNCOMPRESS_STRING_BUFF_LEN] = { 0 };
775 OptString(obj, SUPPORT_INFO_COMPRESS, compressParse, PARSE_UNCOMPRESS_STRING_BUFF_LEN, FALSE_STRING_TAG);
776 SetCompressFlag(compressParse, &info->isSupportCompress);
777 }
778 UnpackFastAuth(obj, info);
779 JSON_Delete(obj);
780 return SOFTBUS_OK;
781 }
782
GetAndSetLocalUnifiedName(JsonObj * json)783 static void GetAndSetLocalUnifiedName(JsonObj *json)
784 {
785 char unified[DEVICE_NAME_BUF_LEN] = {0};
786 if (LnnGetUnifiedDeviceName(unified, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
787 AUTH_LOGE(AUTH_FSM, "get defaultDeviceName fail");
788 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, unified);
789 return;
790 }
791
792 if (strlen(unified) != 0) {
793 if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_NAME, unified) != SOFTBUS_OK) {
794 AUTH_LOGE(AUTH_FSM, "set device unifiedDefaultName fail");
795 }
796 AUTH_LOGI(AUTH_FSM, "unifed length is not zero, unified=%{public}s", unified);
797 }
798 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, unified);
799 }
800
PackCommonDevInfo(JsonObj * json,const NodeInfo * info,bool isMetaAuth)801 static int32_t PackCommonDevInfo(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
802 {
803 if (strlen(info->deviceInfo.unifiedName) == 0) {
804 GetAndSetLocalUnifiedName(json);
805 } else {
806 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, info->deviceInfo.unifiedName);
807 }
808 (void)JSON_AddStringToObject(json, UNIFIED_DEFAULT_DEVICE_NAME, info->deviceInfo.unifiedDefaultName);
809 (void)JSON_AddStringToObject(json, SETTINGS_NICK_NAME, info->deviceInfo.nickName);
810 if (!JSON_AddStringToObject(json, NETWORK_ID, info->networkId) ||
811 !JSON_AddStringToObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo)) ||
812 !JSON_AddStringToObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
813 !JSON_AddStringToObject(json, DEVICE_UDID, LnnGetDeviceUdid(info))) {
814 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject fail");
815 return SOFTBUS_ERR;
816 }
817 if (isMetaAuth && !JSON_AddStringToObject(json, DEVICE_UUID, info->uuid)) {
818 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject fail");
819 return SOFTBUS_ERR;
820 }
821 return SOFTBUS_OK;
822 }
823
PackCommonFastAuth(JsonObj * json,const NodeInfo * info)824 static void PackCommonFastAuth(JsonObj *json, const NodeInfo *info)
825 {
826 (void)JSON_AddInt32ToObject(json, STATE_VERSION, info->stateVersion);
827 char extData[EXTDATA_LEN] = {0};
828 int32_t ret = GetExtData(extData, EXTDATA_LEN);
829 if (ret != SOFTBUS_OK) {
830 AUTH_LOGE(AUTH_FSM, "GetExtData fail");
831 } else {
832 AUTH_LOGI(AUTH_FSM, "GetExtData=%{public}s", extData);
833 (void)JSON_AddStringToObject(json, EXTDATA, extData);
834 }
835 }
836
PackOsInfo(JsonObj * json,const NodeInfo * info)837 static void PackOsInfo(JsonObj *json, const NodeInfo *info)
838 {
839 (void)JSON_AddInt32ToObject(json, OS_TYPE, info->deviceInfo.osType);
840 (void)JSON_AddStringToObject(json, OS_VERSION, info->deviceInfo.osVersion);
841 }
842
PackCommP2pInfo(JsonObj * json,const NodeInfo * info)843 static void PackCommP2pInfo(JsonObj *json, const NodeInfo *info)
844 {
845 (void)JSON_AddInt32ToObject(json, P2P_ROLE, LnnGetP2pRole(info));
846 (void)JSON_AddStringToObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info));
847 (void)JSON_AddStringToObject(json, HML_MAC, info->wifiDirectAddr);
848
849 (void)JSON_AddStringToObject(json, WIFI_CFG, info->p2pInfo.wifiCfg);
850 (void)JSON_AddStringToObject(json, CHAN_LIST_5G, info->p2pInfo.chanList5g);
851 (void)JSON_AddInt32ToObject(json, STA_FREQUENCY, LnnGetStaFrequency(info));
852 }
853
PackWifiDirectInfo(JsonObj * json,const NodeInfo * info,const char * remoteUuid)854 static void PackWifiDirectInfo(JsonObj *json, const NodeInfo *info, const char *remoteUuid)
855 {
856 if (json == NULL || remoteUuid == NULL) {
857 AUTH_LOGE(AUTH_FSM, "invalid param");
858 return;
859 }
860 unsigned char encodePtk[PTK_ENCODE_LEN] = {0};
861 char localPtk[PTK_DEFAULT_LEN] = {0};
862 if (LnnGetLocalPtkByUuid(remoteUuid, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
863 AUTH_LOGE(AUTH_FSM, "get ptk by uuid fail");
864 return;
865 }
866 size_t keyLen = 0;
867 if (SoftBusBase64Encode(encodePtk, PTK_ENCODE_LEN, &keyLen, (unsigned char *)localPtk,
868 PTK_DEFAULT_LEN) != SOFTBUS_OK) {
869 AUTH_LOGE(AUTH_FSM, "encode ptk fail");
870 return;
871 }
872 if (!JSON_AddStringToObject(json, PTK, (char *)encodePtk)) {
873 AUTH_LOGE(AUTH_FSM, "add ptk string to json fail");
874 return;
875 }
876 if (!JSON_AddInt32ToObject(json, STATIC_CAP_LENGTH, info->staticCapLen)) {
877 AUTH_LOGE(AUTH_FSM, "add static cap len fail");
878 return;
879 }
880 char staticCap[STATIC_CAP_STR_LEN] = {0};
881 if (ConvertBytesToHexString((char *)staticCap, STATIC_CAP_STR_LEN,
882 info->staticCapability, info->staticCapLen) != SOFTBUS_OK) {
883 AUTH_LOGW(AUTH_FSM, "convert static cap fail");
884 return;
885 }
886 if (!JSON_AddStringToObject(json, STATIC_CAP, (char *)staticCap)) {
887 AUTH_LOGW(AUTH_FSM, "add static capability fail");
888 return;
889 }
890 return;
891 }
892
PackCipherRpaInfo(JsonObj * json,const NodeInfo * info)893 static int32_t PackCipherRpaInfo(JsonObj *json, const NodeInfo *info)
894 {
895 char cipherKey[SESSION_KEY_STR_LEN] = {0};
896 char cipherIv[BROADCAST_IV_STR_LEN] = {0};
897 char peerIrk[LFINDER_IRK_STR_LEN] = {0};
898 char pubMac[LFINDER_MAC_ADDR_STR_LEN] = {0};
899
900 if (ConvertBytesToHexString(cipherKey, SESSION_KEY_STR_LEN,
901 info->cipherInfo.key, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
902 AUTH_LOGE(AUTH_FSM, "convert cipher key to string fail.");
903 return SOFTBUS_ERR;
904 }
905 if (ConvertBytesToHexString(cipherIv, BROADCAST_IV_STR_LEN,
906 info->cipherInfo.iv, BROADCAST_IV_LEN) != SOFTBUS_OK) {
907 AUTH_LOGE(AUTH_FSM, "convert cipher iv to string fail.");
908 return SOFTBUS_ERR;
909 }
910 if (ConvertBytesToHexString(peerIrk, LFINDER_IRK_STR_LEN,
911 info->rpaInfo.peerIrk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
912 AUTH_LOGE(AUTH_FSM, "convert peerIrk to string fail.");
913 return SOFTBUS_ERR;
914 }
915 if (ConvertBytesToHexString(pubMac, LFINDER_MAC_ADDR_STR_LEN,
916 info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN) != SOFTBUS_OK) {
917 AUTH_LOGE(AUTH_FSM, "convert publicAddress to string fail.");
918 return SOFTBUS_ERR;
919 }
920 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_KEY, cipherKey);
921 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_IV, cipherIv);
922 (void)JSON_AddStringToObject(json, IRK, peerIrk);
923 (void)JSON_AddStringToObject(json, PUB_MAC, pubMac);
924 AUTH_LOGI(AUTH_FSM, "pack cipher and rpa info success!");
925
926 BroadcastCipherKey broadcastKey;
927 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
928 if (memcpy_s(broadcastKey.udid, UDID_BUF_LEN, info->deviceInfo.deviceUdid, UDID_BUF_LEN) != EOK) {
929 AUTH_LOGE(AUTH_FSM, "memcpy udid fail.");
930 return SOFTBUS_ERR;
931 }
932 if (memcpy_s(broadcastKey.cipherInfo.key, SESSION_KEY_LENGTH, info->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
933 AUTH_LOGE(AUTH_FSM, "memcpy key fail.");
934 return SOFTBUS_ERR;
935 }
936 if (memcpy_s(broadcastKey.cipherInfo.iv, BROADCAST_IV_LEN, info->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
937 AUTH_LOGE(AUTH_FSM, "memcpy iv fail.");
938 return SOFTBUS_ERR;
939 }
940 if (LnnUpdateLocalBroadcastCipherKey(&broadcastKey) != SOFTBUS_OK) {
941 AUTH_LOGE(AUTH_FSM, "update local broadcast key failed");
942 return SOFTBUS_ERR;
943 }
944 AUTH_LOGI(AUTH_FSM, "update broadcast cipher key success!");
945 return SOFTBUS_OK;
946 }
947
UnpackCipherRpaInfo(const JsonObj * json,NodeInfo * info)948 static void UnpackCipherRpaInfo(const JsonObj *json, NodeInfo *info)
949 {
950 char cipherKey[SESSION_KEY_STR_LEN] = {0};
951 char cipherIv[BROADCAST_IV_STR_LEN] = {0};
952 char peerIrk[LFINDER_IRK_STR_LEN] = {0};
953 char pubMac[LFINDER_MAC_ADDR_STR_LEN] = {0};
954
955 if (!JSON_GetStringFromOject(json, BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_STR_LEN) ||
956 !JSON_GetStringFromOject(json, BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_STR_LEN) ||
957 !JSON_GetStringFromOject(json, IRK, peerIrk, LFINDER_IRK_STR_LEN) ||
958 !JSON_GetStringFromOject(json, PUB_MAC, pubMac, LFINDER_MAC_ADDR_STR_LEN)) {
959 AUTH_LOGE(AUTH_FSM, "get json info fail.");
960 return;
961 }
962
963 if (ConvertHexStringToBytes((unsigned char *)info->cipherInfo.key,
964 SESSION_KEY_LENGTH, cipherKey, strlen(cipherKey)) != SOFTBUS_OK) {
965 AUTH_LOGE(AUTH_FSM, "convert cipher key to bytes fail.");
966 return;
967 }
968 if (ConvertHexStringToBytes((unsigned char *)info->cipherInfo.iv,
969 BROADCAST_IV_LEN, cipherIv, strlen(cipherIv)) != SOFTBUS_OK) {
970 AUTH_LOGE(AUTH_FSM, "convert cipher iv to bytes fail.");
971 return;
972 }
973 if (ConvertHexStringToBytes((unsigned char *)info->rpaInfo.peerIrk,
974 LFINDER_IRK_LEN, peerIrk, strlen(peerIrk)) != SOFTBUS_OK) {
975 AUTH_LOGE(AUTH_FSM, "convert peerIrk to bytes fail.");
976 return;
977 }
978 if (ConvertHexStringToBytes((unsigned char *)info->rpaInfo.publicAddress,
979 LFINDER_MAC_ADDR_LEN, pubMac, strlen(pubMac)) != SOFTBUS_OK) {
980 AUTH_LOGE(AUTH_FSM, "convert publicAddress to bytes fail.");
981 return;
982 }
983 AUTH_LOGI(AUTH_FSM, "unpack cipher and rpa info success!");
984 }
985
PackCommonEx(JsonObj * json,const NodeInfo * info)986 static int32_t PackCommonEx(JsonObj *json, const NodeInfo *info)
987 {
988 bool isFalse = (
989 !JSON_AddStringToObject(json, VERSION_TYPE, info->versionType) ||
990 !JSON_AddInt32ToObject(json, CONN_CAP, info->netCapacity) ||
991 !JSON_AddInt32ToObject(json, AUTH_CAP, info->authCapacity) ||
992 !JSON_AddInt16ToObject(json, DATA_CHANGE_FLAG, info->dataChangeFlag) ||
993 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
994 !JSON_AddBoolToObject(json, BLE_P2P, info->isBleP2p) ||
995 !JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, (int64_t)LnnGetSupportedProtocols(info)));
996 if (isFalse) {
997 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
998 return SOFTBUS_ERR;
999 }
1000
1001 char btMacUpper[BT_MAC_LEN] = {0};
1002 if (StringToUpperCase(LnnGetBtMac(info), btMacUpper, BT_MAC_LEN) != SOFTBUS_OK) {
1003 AUTH_LOGE(AUTH_FSM, "btMac to upperCase failed.");
1004 if (memcpy_s(btMacUpper, BT_MAC_LEN, LnnGetBtMac(info), BT_MAC_LEN) != EOK) {
1005 AUTH_LOGE(AUTH_FSM, "btMac cpy failed.");
1006 return SOFTBUS_MEM_ERR;
1007 }
1008 }
1009 isFalse = (
1010 !JSON_AddStringToObject(json, PKG_VERSION, info->pkgVersion) ||
1011 !JSON_AddInt64ToObject(json, WIFI_VERSION, info->wifiVersion) ||
1012 !JSON_AddInt64ToObject(json, BLE_VERSION, info->bleVersion) ||
1013 !JSON_AddStringToObject(json, BT_MAC, btMacUpper) ||
1014 !JSON_AddStringToObject(json, BLE_MAC, info->connectInfo.bleMacAddr) ||
1015 !JSON_AddInt32ToObject(json, REMAIN_POWER, info->batteryInfo.batteryLevel) ||
1016 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1017 !JSON_AddBoolToObject(json, IS_SCREENON, info->isScreenOn) ||
1018 !JSON_AddInt32ToObject(json, NODE_WEIGHT, info->masterWeight) ||
1019 !JSON_AddInt64ToObject(json, ACCOUNT_ID, info->accountId) ||
1020 !JSON_AddBoolToObject(json, DISTRIBUTED_SWITCH, true) ||
1021 !JSON_AddInt64ToObject(json, BLE_TIMESTAMP, info->bleStartTimestamp) ||
1022 !JSON_AddInt32ToObject(json, WIFI_BUFF_SIZE, info->wifiBuffSize) ||
1023 !JSON_AddInt32ToObject(json, BR_BUFF_SIZE, info->brBuffSize) ||
1024 !JSON_AddInt64ToObject(json, FEATURE, info->feature) ||
1025 !JSON_AddInt64ToObject(json, CONN_SUB_FEATURE, info->connSubFeature) ||
1026 !JSON_AddInt64ToObject(json, NEW_CONN_CAP, info->netCapacity));
1027 if (isFalse) {
1028 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
1029 return SOFTBUS_ERR;
1030 }
1031 AUTH_LOGI(AUTH_FSM, "pack common succ.");
1032 return SOFTBUS_OK;
1033 }
1034
PackCommon(JsonObj * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1035 static int32_t PackCommon(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1036 {
1037 if (version >= SOFTBUS_NEW_V1) {
1038 if (!JSON_AddStringToObject(json, MASTER_UDID, info->masterUdid) ||
1039 !JSON_AddInt32ToObject(json, MASTER_WEIGHT, info->masterWeight)) {
1040 AUTH_LOGE(AUTH_FSM, "add master node info fail");
1041 return SOFTBUS_ERR;
1042 }
1043 if (!JSON_AddStringToObject(json, NODE_ADDR, info->nodeAddress)) {
1044 AUTH_LOGE(AUTH_FSM, "pack node address Fail");
1045 return SOFTBUS_ERR;
1046 }
1047 }
1048 if (!JSON_AddStringToObject(json, SW_VERSION, info->softBusVersion)) {
1049 AUTH_LOGE(AUTH_FSM, "add version info fail");
1050 return SOFTBUS_ERR;
1051 }
1052 if (PackCommonDevInfo(json, info, isMetaAuth) != SOFTBUS_OK) {
1053 return SOFTBUS_ERR;
1054 }
1055 if (PackCommonEx(json, info) != SOFTBUS_OK) {
1056 AUTH_LOGE(AUTH_FSM, "data pack failed.");
1057 return SOFTBUS_ERR;
1058 }
1059 PackOsInfo(json, info);
1060 PackCommonFastAuth(json, info);
1061 if (!PackCipherKeySyncMsg(json)) {
1062 AUTH_LOGE(AUTH_FSM, "PackCipherKeySyncMsg failed.");
1063 }
1064 PackCommP2pInfo(json, info);
1065
1066 if (PackCipherRpaInfo(json, info) != SOFTBUS_OK) {
1067 AUTH_LOGE(AUTH_FSM, "pack CipherRpaInfo of device key failed.");
1068 }
1069 return SOFTBUS_OK;
1070 }
1071
UnpackWifiDirectInfo(const JsonObj * json,NodeInfo * info)1072 static void UnpackWifiDirectInfo(const JsonObj *json, NodeInfo *info)
1073 {
1074 char staticCap[STATIC_CAP_STR_LEN] = {0};
1075 if (!JSON_GetInt32FromOject(json, STATIC_CAP_LENGTH, &info->staticCapLen)) {
1076 AUTH_LOGE(AUTH_FSM, "get static cap len fail");
1077 return;
1078 }
1079 if (!JSON_GetStringFromOject(json, STATIC_CAP, staticCap, STATIC_CAP_STR_LEN)) {
1080 AUTH_LOGE(AUTH_FSM, "get static cap fail");
1081 return;
1082 }
1083 if (ConvertHexStringToBytes((unsigned char *)info->staticCapability, STATIC_CAP_LEN,
1084 staticCap, strlen(staticCap)) != SOFTBUS_OK) {
1085 AUTH_LOGE(AUTH_FSM, "convert static cap fail");
1086 return;
1087 }
1088 char encodePtk[PTK_ENCODE_LEN] = {0};
1089 size_t len = 0;
1090 if (!JSON_GetStringFromOject(json, PTK, encodePtk, PTK_ENCODE_LEN)) {
1091 AUTH_LOGE(AUTH_FSM, "get encode ptk fail");
1092 return;
1093 }
1094 if (SoftBusBase64Decode((unsigned char *)info->remotePtk, PTK_DEFAULT_LEN,
1095 &len, (const unsigned char *)encodePtk, strlen((char *)encodePtk)) != SOFTBUS_OK) {
1096 AUTH_LOGE(AUTH_FSM, "decode static cap fail");
1097 return;
1098 }
1099 if (len != PTK_DEFAULT_LEN) {
1100 AUTH_LOGE(AUTH_FSM, "decode data len error");
1101 return;
1102 }
1103 }
1104
UnpackCommon(const JsonObj * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1105 static void UnpackCommon(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1106 {
1107 if (version >= SOFTBUS_NEW_V1) {
1108 if (!JSON_GetStringFromOject(json, MASTER_UDID, info->masterUdid, UDID_BUF_LEN) ||
1109 !JSON_GetInt32FromOject(json, MASTER_WEIGHT, &info->masterWeight)) {
1110 AUTH_LOGE(AUTH_FSM, "get master node info fail");
1111 }
1112 AUTH_LOGE(AUTH_FSM, "get master weight=%{public}d", info->masterWeight);
1113 if (!JSON_GetStringFromOject(json, NODE_ADDR, info->nodeAddress, sizeof(info->nodeAddress))) {
1114 AUTH_LOGW(AUTH_FSM,
1115 "no node address packed. set to address NODE_ADDR_LOOPBACK. NODE_ADDR_LOOPBACK=%{public}s",
1116 NODE_ADDR_LOOPBACK);
1117 (void)strcpy_s(info->nodeAddress, sizeof(info->nodeAddress), NODE_ADDR_LOOPBACK);
1118 }
1119 }
1120 (void)JSON_GetStringFromOject(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN);
1121 OptString(json, PKG_VERSION, info->pkgVersion, VERSION_MAX_LEN, "");
1122 OptString(json, UNIFIED_DEVICE_NAME, info->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, "");
1123 OptString(json, UNIFIED_DEFAULT_DEVICE_NAME, info->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, "");
1124 OptString(json, SETTINGS_NICK_NAME, info->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, "");
1125 OptInt64(json, WIFI_VERSION, &info->wifiVersion, 0);
1126 OptInt64(json, BLE_VERSION, &info->bleVersion, 0);
1127 OptString(json, BT_MAC, info->connectInfo.macAddr, MAC_LEN, "");
1128 OptString(json, BLE_MAC, info->connectInfo.bleMacAddr, MAC_LEN, "");
1129 char deviceType[DEVICE_TYPE_BUF_LEN] = {0};
1130 (void)JSON_GetStringFromOject(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN);
1131 if (JSON_GetStringFromOject(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN)) {
1132 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
1133 }
1134 (void)JSON_GetStringFromOject(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN);
1135 if (isMetaAuth) {
1136 (void)JSON_GetStringFromOject(json, DEVICE_UUID, info->uuid, UDID_BUF_LEN);
1137 }
1138 (void)JSON_GetStringFromOject(json, NETWORK_ID, info->networkId, NETWORK_ID_BUF_LEN);
1139 (void)JSON_GetStringFromOject(json, VERSION_TYPE, info->versionType, VERSION_MAX_LEN);
1140 (void)JSON_GetInt32FromOject(json, CONN_CAP, (int32_t *)&info->netCapacity);
1141 (void)JSON_GetInt32FromOject(json, AUTH_CAP, (int32_t *)&info->authCapacity);
1142
1143 info->isBleP2p = false;
1144 (void)JSON_GetBoolFromOject(json, BLE_P2P, &info->isBleP2p);
1145 (void)JSON_GetInt16FromOject(json, DATA_CHANGE_FLAG, (int16_t *)&info->dataChangeFlag);
1146 (void)JSON_GetBoolFromOject(json, IS_CHARGING, &info->batteryInfo.isCharging);
1147 (void)JSON_GetInt32FromOject(json, REMAIN_POWER, &info->batteryInfo.batteryLevel);
1148 OptBool(json, IS_SCREENON, &info->isScreenOn, false);
1149 OptInt64(json, ACCOUNT_ID, &info->accountId, 0);
1150 OptInt(json, NODE_WEIGHT, &info->masterWeight, DEFAULT_NODE_WEIGHT);
1151 OptInt(json, OS_TYPE, &info->deviceInfo.osType, -1);
1152 if ((info->deviceInfo.osType == -1) && info->authCapacity != 0) {
1153 info->deviceInfo.osType = OH_OS_TYPE;
1154 AUTH_LOGD(AUTH_FSM, "info->deviceInfo.osType: %{public}d", info->deviceInfo.osType);
1155 }
1156 OptString(json, OS_VERSION, info->deviceInfo.osVersion, OS_VERSION_BUF_LEN, "");
1157
1158 // IS_SUPPORT_TCP_HEARTBEAT
1159 OptInt(json, NEW_CONN_CAP, (int32_t *)&info->netCapacity, -1);
1160 if (info->netCapacity == (uint32_t)-1) {
1161 (void)JSON_GetInt32FromOject(json, CONN_CAP, (int32_t *)&info->netCapacity);
1162 }
1163 OptInt(json, WIFI_BUFF_SIZE, &info->wifiBuffSize, DEFAULT_WIFI_BUFF_SIZE);
1164 OptInt(json, BR_BUFF_SIZE, &info->wifiBuffSize, DEFAULT_BR_BUFF_SIZE);
1165 OptInt64(json, FEATURE, (int64_t *)&info->feature, 0);
1166 OptInt64(json, CONN_SUB_FEATURE, (int64_t *)&info->connSubFeature, 0);
1167 //MetaNodeInfoOfEar
1168 OptString(json, EXTDATA, info->extData, EXTDATA_LEN, "");
1169 if (version == SOFTBUS_OLD_V1) {
1170 if (strcpy_s(info->networkId, NETWORK_ID_BUF_LEN, info->uuid) != EOK) {
1171 AUTH_LOGE(AUTH_FSM, "v1 version strcpy networkid fail");
1172 }
1173 }
1174 ProcessCipherKeySyncInfo(json, info->deviceInfo.deviceUdid);
1175
1176 // unpack p2p info
1177 OptInt(json, P2P_ROLE, &info->p2pInfo.p2pRole, -1);
1178 OptString(json, WIFI_CFG, info->p2pInfo.wifiCfg, WIFI_CFG_INFO_MAX_LEN, "");
1179 OptString(json, CHAN_LIST_5G, info->p2pInfo.chanList5g, CHANNEL_LIST_STR_LEN, "");
1180 OptInt(json, STA_FREQUENCY, &info->p2pInfo.staFrequency, -1);
1181 OptString(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN, "");
1182 OptString(json, HML_MAC, info->wifiDirectAddr, MAC_LEN, "");
1183
1184 UnpackCipherRpaInfo(json, info);
1185 }
1186
GetBtDiscTypeString(const NodeInfo * info,char * buf,uint32_t len)1187 static int32_t GetBtDiscTypeString(const NodeInfo *info, char *buf, uint32_t len)
1188 {
1189 uint32_t i = 0;
1190 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)) {
1191 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_ERR);
1192 buf[i++] = DISCOVERY_TYPE_BLE + '0';
1193 }
1194 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
1195 if (i != 0) {
1196 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_ERR);
1197 buf[i++] = ',';
1198 }
1199 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_ERR);
1200 buf[i++] = DISCOVERY_TYPE_BR + '0';
1201 }
1202 return SOFTBUS_OK;
1203 }
1204
AddDiscoveryType(JsonObj * json,const char * remoteUuid)1205 static void AddDiscoveryType(JsonObj *json, const char *remoteUuid)
1206 {
1207 if (remoteUuid == NULL) {
1208 return;
1209 }
1210 char networkId[NETWORK_ID_BUF_LEN] = {0};
1211 if (LnnGetNetworkIdByUuid(remoteUuid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
1212 AUTH_LOGE(AUTH_FSM, "networkId not found by uuid, maybe first online");
1213 return;
1214 }
1215 uint32_t discoveryType = 0;
1216 if (LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, (int32_t *)&discoveryType) != SOFTBUS_OK) {
1217 AUTH_LOGE(AUTH_FSM, "get discoveryType fail");
1218 return;
1219 }
1220 NodeInfo nodeInfo; // only for discType calc
1221 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1222 nodeInfo.discoveryType = discoveryType;
1223 char discTypeStr[BT_DISC_TYPE_MAX_LEN] = {0};
1224 if (GetBtDiscTypeString(&nodeInfo, discTypeStr, BT_DISC_TYPE_MAX_LEN) != SOFTBUS_OK) {
1225 AUTH_LOGE(AUTH_FSM, "disc Type calc fail");
1226 return;
1227 }
1228 AUTH_LOGD(AUTH_FSM, "discTypeStr=%{public}s", discTypeStr);
1229 JSON_AddStringToObject(json, DISCOVERY_TYPE, discTypeStr);
1230 }
1231
PackBt(JsonObj * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth,const char * remoteUuid)1232 static int32_t PackBt(JsonObj *json, const NodeInfo *info, SoftBusVersion version,
1233 bool isMetaAuth, const char *remoteUuid)
1234 {
1235 if (!JSON_AddInt32ToObject(json, CODE, CODE_VERIFY_BT)) {
1236 AUTH_LOGE(AUTH_FSM, "add bt info fail");
1237 return SOFTBUS_ERR;
1238 }
1239 AddDiscoveryType(json, remoteUuid);
1240 int32_t delayTime = BLE_CONNECTION_CLOSE_DELAY;
1241 if (SoftbusGetConfig(SOFTBUS_INT_CONN_BLE_CLOSE_DELAY_TIME,
1242 (unsigned char *)(&delayTime), sizeof(delayTime)) != SOFTBUS_OK) {
1243 AUTH_LOGI(AUTH_FSM, "get ble conn close delay time from config file fail");
1244 }
1245 int32_t bleMacRefreshSwitch = BLE_MAC_AUTO_REFRESH_SWITCH;
1246 if (SoftbusGetConfig(SOFTBUS_INT_BLE_MAC_AUTO_REFRESH_SWITCH,
1247 (unsigned char *)(&bleMacRefreshSwitch), sizeof(bleMacRefreshSwitch)) != SOFTBUS_OK) {
1248 AUTH_LOGI(AUTH_FSM, "get ble mac refresh switch from config file fail");
1249 }
1250 if (!JSON_AddInt32ToObject(json, BLE_CONN_CLOSE_DELAY_TIME, delayTime) ||
1251 !JSON_AddInt32ToObject(json, BLE_MAC_REFRESH_SWITCH, bleMacRefreshSwitch)) {
1252 AUTH_LOGI(AUTH_FSM, "add ble conn close delay time or refresh switch fail");
1253 }
1254 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
1255 AUTH_LOGE(AUTH_FSM, "PackCommon fail");
1256 return SOFTBUS_ERR;
1257 }
1258 return SOFTBUS_OK;
1259 }
1260
SetDiscType(uint32_t * discType,const char * discStr)1261 static int32_t SetDiscType(uint32_t *discType, const char *discStr)
1262 {
1263 if (strcmp(discStr, DEFAULT_BT_DISC_TYPE_STR) == 0) {
1264 AUTH_LOGE(AUTH_FSM, "disc type can't parse");
1265 return SOFTBUS_ERR;
1266 }
1267 return SOFTBUS_OK;
1268 }
1269
UnpackBt(const JsonObj * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1270 static int32_t UnpackBt(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1271 {
1272 char discTypeStr[BT_DISC_TYPE_MAX_LEN] = {0};
1273 if (!JSON_GetInt64FromOject(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
1274 info->supportedProtocols = LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE;
1275 }
1276 OptString(json, DISCOVERY_TYPE, discTypeStr, BT_DISC_TYPE_MAX_LEN, DEFAULT_BT_DISC_TYPE_STR);
1277 (void)SetDiscType(&info->discoveryType, discTypeStr);
1278 OptInt64(json, BLE_TIMESTAMP, &info->bleStartTimestamp, DEFAULT_BLE_TIMESTAMP);
1279 OptInt(json, STATE_VERSION, &info->stateVersion, 0);
1280 OptInt(json, BLE_CONN_CLOSE_DELAY_TIME, &info->bleConnCloseDelayTime, BLE_CONNECTION_CLOSE_DELAY);
1281 OptInt(json, BLE_MAC_REFRESH_SWITCH, &info->bleMacRefreshSwitch, BLE_MAC_AUTO_REFRESH_SWITCH);
1282 UnpackCommon(json, info, version, isMetaAuth);
1283 return SOFTBUS_OK;
1284 }
1285
PackWiFi(JsonObj * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1286 static int32_t PackWiFi(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1287 {
1288 AUTH_LOGD(AUTH_FSM, "devIp=%{public}zu", strlen(info->connectInfo.deviceIp));
1289 if (!JSON_AddInt32ToObject(json, CODE, CODE_VERIFY_IP) || !JSON_AddInt32ToObject(json, BUS_MAX_VERSION, BUS_V2) ||
1290 !JSON_AddInt32ToObject(json, BUS_MIN_VERSION, BUS_V1) ||
1291 !JSON_AddInt32ToObject(json, AUTH_PORT, LnnGetAuthPort(info)) ||
1292 !JSON_AddInt32ToObject(json, SESSION_PORT, LnnGetSessionPort(info)) ||
1293 !JSON_AddInt32ToObject(json, PROXY_PORT, LnnGetProxyPort(info)) ||
1294 !JSON_AddStringToObject(json, DEV_IP, info->connectInfo.deviceIp)) {
1295 AUTH_LOGE(AUTH_FSM, "add wifi info fail");
1296 return SOFTBUS_ERR;
1297 }
1298 char offlineCode[BASE64_OFFLINE_CODE_LEN] = {0};
1299 size_t len = 0;
1300 AUTH_LOGE(AUTH_FSM, "offlineCodeLen=%{public}zu, offlineCodeSize=%{public}zu",
1301 strlen(offlineCode), sizeof(info->offlineCode));
1302 int32_t ret = SoftBusBase64Encode((unsigned char*)offlineCode, BASE64_OFFLINE_CODE_LEN, &len,
1303 (unsigned char*)info->offlineCode, sizeof(info->offlineCode));
1304 if (ret != 0) {
1305 AUTH_LOGE(AUTH_FSM, "mbedtls base64 encode failed");
1306 return SOFTBUS_ERR;
1307 }
1308 (void)JSON_AddStringToObject(json, BLE_OFFLINE_CODE, offlineCode);
1309 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
1310 AUTH_LOGE(AUTH_FSM, "PackCommon fail");
1311 return SOFTBUS_ERR;
1312 }
1313 return SOFTBUS_OK;
1314 }
1315
CheckBusVersion(const JsonObj * json)1316 static int32_t CheckBusVersion(const JsonObj *json)
1317 {
1318 int32_t maxVersion;
1319 int32_t minVersion;
1320 OptInt(json, BUS_MAX_VERSION, &maxVersion, -1);
1321 OptInt(json, BUS_MIN_VERSION, &minVersion, -1);
1322 if (maxVersion > BUS_V2) {
1323 maxVersion = BUS_V2;
1324 }
1325 if (minVersion < BUS_V1) {
1326 minVersion = BUS_V1;
1327 }
1328 if (maxVersion < 0 || maxVersion < minVersion) {
1329 AUTH_LOGE(AUTH_FSM, "no common version");
1330 return SOFTBUS_ERR;
1331 }
1332 return maxVersion;
1333 }
1334
UnpackWiFi(const JsonObj * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1335 static int32_t UnpackWiFi(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1336 {
1337 if (CheckBusVersion(json) < 0) {
1338 return SOFTBUS_ERR;
1339 }
1340 (void)JSON_GetInt32FromOject(json, AUTH_PORT, &info->connectInfo.authPort);
1341 (void)JSON_GetInt32FromOject(json, SESSION_PORT, &info->connectInfo.sessionPort);
1342 (void)JSON_GetInt32FromOject(json, PROXY_PORT, &info->connectInfo.proxyPort);
1343 if (!JSON_GetInt64FromOject(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
1344 info->supportedProtocols = LNN_PROTOCOL_IP;
1345 }
1346 char offlineCode[BASE64_OFFLINE_CODE_LEN] = {0};
1347 OptString(json, DEV_IP, info->connectInfo.deviceIp, MAX_ADDR_LEN, ""); // check ip available
1348 OptString(json, BLE_OFFLINE_CODE, offlineCode, BASE64_OFFLINE_CODE_LEN, "");
1349 size_t len;
1350 if (SoftBusBase64Decode(info->offlineCode, OFFLINE_CODE_BYTE_SIZE,
1351 &len, (const unsigned char *)offlineCode, strlen(offlineCode)) != 0) {
1352 AUTH_LOGE(AUTH_FSM, "base64Decode fail");
1353 }
1354 if (len != OFFLINE_CODE_BYTE_SIZE) {
1355 AUTH_LOGE(AUTH_FSM, "base64Decode data err");
1356 }
1357 UnpackCommon(json, info, version, isMetaAuth);
1358 return SOFTBUS_OK;
1359 }
1360
PackDeviceInfoBtV1(JsonObj * json,const NodeInfo * info,bool isMetaAuth)1361 static int32_t PackDeviceInfoBtV1(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
1362 {
1363 AUTH_LOGI(AUTH_FSM, "pack deviceInfo bt-v1");
1364 if (!JSON_AddStringToObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo)) ||
1365 !JSON_AddStringToObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
1366 !JSON_AddStringToObject(json, DEVICE_VERSION_TYPE, info->versionType) ||
1367 !JSON_AddStringToObject(json, BR_MAC_ADDR, LnnGetBtMac(info)) ||
1368 !JSON_AddStringToObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info)) ||
1369 !JSON_AddStringToObject(json, UUID, info->uuid) ||
1370 !JSON_AddStringToObject(json, SW_VERSION, info->softBusVersion) ||
1371 !JSON_AddStringToObject(json, DEVICE_UDID, info->deviceInfo.deviceUdid) ||
1372 !JSON_AddInt64ToObject(json, WIFI_VERSION, info->wifiVersion) ||
1373 !JSON_AddInt64ToObject(json, BLE_VERSION, info->bleVersion) ||
1374 !JSON_AddInt64ToObject(json, CONN_CAP, info->netCapacity) ||
1375 !JSON_AddInt64ToObject(json, NEW_CONN_CAP, info->netCapacity) ||
1376 !JSON_AddStringToObject(json, BT_MAC, info->connectInfo.macAddr) ||
1377 !JSON_AddStringToObject(json, HML_MAC, info->wifiDirectAddr) ||
1378 !JSON_AddInt32ToObject(json, REMAIN_POWER, info->batteryInfo.batteryLevel) ||
1379 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1380 !JSON_AddBoolToObject(json, IS_SCREENON, info->isScreenOn) ||
1381 !JSON_AddInt32ToObject(json, P2P_ROLE, info->p2pInfo.p2pRole) ||
1382 !JSON_AddInt64ToObject(json, ACCOUNT_ID, info->accountId) ||
1383 !JSON_AddInt32ToObject(json, NODE_WEIGHT, info->masterWeight)) {
1384 AUTH_LOGE(AUTH_FSM, "add wifi info fail");
1385 return SOFTBUS_ERR;
1386 }
1387 return SOFTBUS_OK;
1388 }
1389
UnpackDeviceInfoBtV1(const JsonObj * json,NodeInfo * info)1390 static int32_t UnpackDeviceInfoBtV1(const JsonObj *json, NodeInfo *info)
1391 {
1392 char deviceType[DEVICE_TYPE_BUF_LEN] = { 0 };
1393 if (!JSON_GetStringFromOject(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN) ||
1394 !JSON_GetStringFromOject(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN) ||
1395 !JSON_GetStringFromOject(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN) ||
1396 !JSON_GetStringFromOject(json, UUID, info->uuid, UUID_BUF_LEN) ||
1397 !JSON_GetStringFromOject(json, BR_MAC_ADDR, info->connectInfo.macAddr, MAC_LEN)) {
1398 AUTH_LOGE(AUTH_FSM, "prase devinfo fail, invalid msg");
1399 return SOFTBUS_ERR;
1400 }
1401 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
1402 OptString(json, HML_MAC, info->wifiDirectAddr, MAC_LEN, "");
1403 OptString(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN, "");
1404 OptString(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN, "");
1405 OptString(json, DEVICE_VERSION_TYPE, info->versionType, VERSION_MAX_LEN, "");
1406 OptInt64(json, WIFI_VERSION, &info->wifiVersion, 0);
1407 OptInt64(json, BLE_VERSION, &info->bleVersion, 0);
1408 OptInt(json, REMAIN_POWER, &info->batteryInfo.batteryLevel, DEFAULT_BATTERY_LEVEL);
1409 OptBool(json, IS_CHARGING, &info->batteryInfo.isCharging, false);
1410 OptBool(json, IS_SCREENON, &info->isScreenOn, false);
1411 OptInt(json, P2P_ROLE, &info->p2pInfo.p2pRole, 0);
1412 OptInt64(json, ACCOUNT_ID, &info->accountId, 0);
1413 OptInt(json, NODE_WEIGHT, &info->masterWeight, DEFAULT_NODE_WEIGHT);
1414 OptInt64(json, FEATURE, (int64_t *)&info->feature, 0);
1415 OptInt64(json, NEW_CONN_CAP, (int64_t *)&info->netCapacity, -1);
1416 if (info->netCapacity == (uint32_t)-1) {
1417 OptInt64(json, CONN_CAP, (int64_t *)&info->netCapacity, 0);
1418 }
1419 if (strcpy_s(info->networkId, NETWORK_ID_BUF_LEN, info->uuid) != EOK) {
1420 AUTH_LOGE(AUTH_FSM, "strcpy networkId fail");
1421 return SOFTBUS_ERR;
1422 }
1423 return SOFTBUS_OK;
1424 }
1425
PackDeviceInfoMessage(int32_t linkType,SoftBusVersion version,bool isMetaAuth,const char * remoteUuid)1426 char *PackDeviceInfoMessage(int32_t linkType, SoftBusVersion version, bool isMetaAuth, const char *remoteUuid)
1427 {
1428 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", linkType);
1429 const NodeInfo *info = LnnGetLocalNodeInfo();
1430 if (info == NULL) {
1431 AUTH_LOGE(AUTH_FSM, "local info is null");
1432 return NULL;
1433 }
1434 JsonObj *json = JSON_CreateObject();
1435 if (json == NULL) {
1436 AUTH_LOGE(AUTH_FSM, "create cjson fail");
1437 return NULL;
1438 }
1439 int32_t ret;
1440 if (linkType == AUTH_LINK_TYPE_WIFI) {
1441 ret = PackWiFi(json, info, version, isMetaAuth);
1442 } else if (version == SOFTBUS_OLD_V1) {
1443 ret = PackDeviceInfoBtV1(json, info, isMetaAuth);
1444 } else {
1445 ret = PackBt(json, info, version, isMetaAuth, remoteUuid);
1446 }
1447 if (ret != SOFTBUS_OK) {
1448 JSON_Delete(json);
1449 return NULL;
1450 }
1451 PackWifiDirectInfo(json, info, remoteUuid);
1452
1453 char *msg = JSON_PrintUnformatted(json);
1454 if (msg == NULL) {
1455 AUTH_LOGE(AUTH_FSM, "JSON_PrintUnformatted fail");
1456 }
1457 JSON_Delete(json);
1458 return msg;
1459 }
1460
UpdatePeerDeviceName(NodeInfo * peerNodeInfo)1461 static void UpdatePeerDeviceName(NodeInfo *peerNodeInfo)
1462 {
1463 const NodeInfo *localInfo = LnnGetLocalNodeInfo();
1464 if (localInfo == NULL) {
1465 AUTH_LOGE(AUTH_FSM, "localInfo is null");
1466 return;
1467 }
1468 int32_t ret = EOK;
1469 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
1470 if (strlen(peerNodeInfo->deviceInfo.unifiedName) != 0 &&
1471 strcmp(peerNodeInfo->deviceInfo.unifiedName, peerNodeInfo->deviceInfo.unifiedDefaultName) != 0) {
1472 ret = strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedName);
1473 } else if (strlen(peerNodeInfo->deviceInfo.nickName) == 0 || localInfo->accountId == peerNodeInfo->accountId) {
1474 ret = strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedDefaultName);
1475 } else {
1476 LnnGetDeviceDisplayName(peerNodeInfo->deviceInfo.nickName,
1477 peerNodeInfo->deviceInfo.unifiedDefaultName, deviceName, DEVICE_NAME_BUF_LEN);
1478 }
1479 AUTH_LOGD(AUTH_FSM,
1480 "peer tmpDeviceName=%{public}s, deviceName=%{public}s, unifiedName=%{public}s, "
1481 "unifiedDefaultName=%{public}s, nickName=%{public}s",
1482 deviceName, peerNodeInfo->deviceInfo.deviceName, peerNodeInfo->deviceInfo.unifiedName,
1483 peerNodeInfo->deviceInfo.unifiedDefaultName, peerNodeInfo->deviceInfo.nickName);
1484 if (strlen(deviceName) != 0) {
1485 ret = strcpy_s(peerNodeInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, deviceName);
1486 }
1487 if (ret != EOK) {
1488 AUTH_LOGW(AUTH_FSM, "strcpy_s fail, use default name");
1489 }
1490 }
1491
UnpackDeviceInfoMessage(const DevInfoData * devInfo,NodeInfo * nodeInfo,bool isMetaAuth)1492 int32_t UnpackDeviceInfoMessage(const DevInfoData *devInfo, NodeInfo *nodeInfo, bool isMetaAuth)
1493 {
1494 AUTH_CHECK_AND_RETURN_RET_LOGE(devInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "devInfo is NULL");
1495 AUTH_CHECK_AND_RETURN_RET_LOGE(nodeInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "nodeInfo is NULL");
1496 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", devInfo->linkType);
1497 JsonObj *json = JSON_Parse(devInfo->msg, devInfo->len);
1498 if (json == NULL) {
1499 AUTH_LOGE(AUTH_FSM, "parse cjson fail");
1500 return SOFTBUS_ERR;
1501 }
1502 int32_t ret;
1503 if (devInfo->linkType == AUTH_LINK_TYPE_WIFI) {
1504 ret = UnpackWiFi(json, nodeInfo, devInfo->version, isMetaAuth);
1505 } else if (devInfo->version == SOFTBUS_OLD_V1) {
1506 ret = UnpackDeviceInfoBtV1(json, nodeInfo);
1507 } else {
1508 ret = UnpackBt(json, nodeInfo, devInfo->version, isMetaAuth);
1509 }
1510 UnpackWifiDirectInfo(json, nodeInfo);
1511 JSON_Delete(json);
1512 int32_t stateVersion;
1513 if (LnnGetLocalNumInfo(NUM_KEY_STATE_VERSION, &stateVersion) == SOFTBUS_OK) {
1514 nodeInfo->localStateVersion = stateVersion;
1515 }
1516 if (IsFeatureSupport(nodeInfo->feature, BIT_SUPPORT_UNIFORM_NAME_CAPABILITY)) {
1517 UpdatePeerDeviceName(nodeInfo);
1518 }
1519 return ret;
1520 }
1521
PostDeviceIdData(int64_t authSeq,const AuthSessionInfo * info,uint8_t * data,uint32_t len)1522 static int32_t PostDeviceIdData(int64_t authSeq, const AuthSessionInfo *info, uint8_t *data, uint32_t len)
1523 {
1524 AuthDataHead head = {
1525 .dataType = DATA_TYPE_DEVICE_ID,
1526 .module = MODULE_TRUST_ENGINE,
1527 .seq = authSeq,
1528 .flag = info->isServer ? SERVER_SIDE_FLAG : CLIENT_SIDE_FLAG,
1529 .len = len,
1530 };
1531 if (PostAuthData(info->connId, !info->isServer, &head, data) != SOFTBUS_OK) {
1532 AUTH_LOGE(AUTH_FSM, "post device id fail");
1533 return SOFTBUS_AUTH_SEND_FAIL;
1534 }
1535 return SOFTBUS_OK;
1536 }
1537
PostBtV1DevId(int64_t authSeq,const AuthSessionInfo * info)1538 static int32_t PostBtV1DevId(int64_t authSeq, const AuthSessionInfo *info)
1539 {
1540 if (!info->isServer) {
1541 AUTH_LOGE(AUTH_FSM, "client don't send Bt-v1 devId");
1542 return SOFTBUS_ERR;
1543 }
1544 char uuid[UUID_BUF_LEN] = {0};
1545 if (LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) != SOFTBUS_OK) {
1546 AUTH_LOGE(AUTH_FSM, "get uuid fail");
1547 return SOFTBUS_ERR;
1548 }
1549 return PostDeviceIdData(authSeq, info, (uint8_t *)uuid, strlen(uuid));
1550 }
1551
PostWifiV1DevId(int64_t authSeq,const AuthSessionInfo * info)1552 static int32_t PostWifiV1DevId(int64_t authSeq, const AuthSessionInfo *info)
1553 {
1554 if (!info->isServer) {
1555 AUTH_LOGE(AUTH_FSM, "client don't send wifi-v1 devId");
1556 return SOFTBUS_ERR;
1557 }
1558 char *msg = PackDeviceIdJson(info);
1559 if (msg == NULL) {
1560 AUTH_LOGE(AUTH_FSM, "pack devId fail");
1561 return SOFTBUS_ERR;
1562 }
1563 if (PostDeviceIdData(authSeq, info, (uint8_t *)msg, strlen(msg) + 1) != SOFTBUS_OK) {
1564 JSON_Free(msg);
1565 return SOFTBUS_ERR;
1566 }
1567 JSON_Free(msg);
1568 return SOFTBUS_OK;
1569 }
1570
PostDeviceIdV1(int64_t authSeq,const AuthSessionInfo * info)1571 static int32_t PostDeviceIdV1(int64_t authSeq, const AuthSessionInfo *info)
1572 {
1573 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI) {
1574 return PostWifiV1DevId(authSeq, info);
1575 } else {
1576 AUTH_LOGI(AUTH_FSM, "process v1 bt deviceIdSync");
1577 return PostBtV1DevId(authSeq, info);
1578 }
1579 }
1580
PostDeviceIdNew(int64_t authSeq,const AuthSessionInfo * info)1581 static int32_t PostDeviceIdNew(int64_t authSeq, const AuthSessionInfo *info)
1582 {
1583 char *msg = PackDeviceIdJson(info);
1584 if (msg == NULL) {
1585 AUTH_LOGE(AUTH_FSM, "pack devId fail");
1586 return SOFTBUS_ERR;
1587 }
1588 if (PostDeviceIdData(authSeq, info, (uint8_t *)msg, strlen(msg) + 1) != SOFTBUS_OK) {
1589 JSON_Free(msg);
1590 return SOFTBUS_AUTH_SEND_FAIL;
1591 }
1592 JSON_Free(msg);
1593 return SOFTBUS_OK;
1594 }
1595
DfxRecordLnnPostDeviceIdStart(int64_t authSeq)1596 static void DfxRecordLnnPostDeviceIdStart(int64_t authSeq)
1597 {
1598 LnnEventExtra extra = { 0 };
1599 LnnEventExtraInit(&extra);
1600 extra.authId = (int32_t)authSeq;
1601 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH_DEVICE_ID_POST, extra);
1602 }
1603
PostDeviceIdMessage(int64_t authSeq,const AuthSessionInfo * info)1604 int32_t PostDeviceIdMessage(int64_t authSeq, const AuthSessionInfo *info)
1605 {
1606 DfxRecordLnnPostDeviceIdStart(authSeq);
1607 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1608 if (info->version == SOFTBUS_OLD_V1) {
1609 return PostDeviceIdV1(authSeq, info);
1610 } else {
1611 return PostDeviceIdNew(authSeq, info);
1612 }
1613 }
1614
ProcessDeviceIdMessage(AuthSessionInfo * info,const uint8_t * data,uint32_t len)1615 int32_t ProcessDeviceIdMessage(AuthSessionInfo *info, const uint8_t *data, uint32_t len)
1616 {
1617 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1618 AUTH_CHECK_AND_RETURN_RET_LOGE(data != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "data is NULL");
1619 if ((info->connInfo.type != AUTH_LINK_TYPE_WIFI) && (len == DEVICE_ID_STR_LEN) && (info->isServer)) {
1620 info->version = SOFTBUS_OLD_V1;
1621 return UnPackBtDeviceIdV1(info, data, len);
1622 }
1623 return UnpackDeviceIdJson((const char *)data, len, info);
1624 }
1625
GetSessionKeyList(int64_t authSeq,const AuthSessionInfo * info,SessionKeyList * list)1626 static void GetSessionKeyList(int64_t authSeq, const AuthSessionInfo *info, SessionKeyList *list)
1627 {
1628 ListInit(list);
1629 SessionKey sessionKey;
1630 if (AuthManagerGetSessionKey(authSeq, info, &sessionKey) != SOFTBUS_OK) {
1631 AUTH_LOGE(AUTH_FSM, "get session key fail");
1632 return;
1633 }
1634 if (AddSessionKey(list, TO_INT32(authSeq), &sessionKey) != SOFTBUS_OK) {
1635 AUTH_LOGE(AUTH_FSM, "add session key fail");
1636 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
1637 return;
1638 }
1639 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
1640 }
1641
DfxRecordLnnPostDeviceInfoStart(int64_t authSeq)1642 static void DfxRecordLnnPostDeviceInfoStart(int64_t authSeq)
1643 {
1644 LnnEventExtra extra = { 0 };
1645 LnnEventExtraInit(&extra);
1646 extra.authId = (int32_t)authSeq;
1647 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH_DEVICE_INFO_POST, extra);
1648 }
1649
PostDeviceInfoMessage(int64_t authSeq,const AuthSessionInfo * info)1650 int32_t PostDeviceInfoMessage(int64_t authSeq, const AuthSessionInfo *info)
1651 {
1652 DfxRecordLnnPostDeviceInfoStart(authSeq);
1653 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1654 char *msg = PackDeviceInfoMessage(info->connInfo.type, info->version, false, info->uuid);
1655 if (msg == NULL) {
1656 AUTH_LOGE(AUTH_FSM, "pack device info fail");
1657 return SOFTBUS_ERR;
1658 }
1659 int32_t compressFlag = FLAG_UNCOMPRESS_DEVICE_INFO;
1660 uint8_t *compressData = NULL;
1661 uint32_t compressLen = 0;
1662 if ((info->connInfo.type != AUTH_LINK_TYPE_WIFI) && info->isSupportCompress) {
1663 AUTH_LOGI(AUTH_FSM, "before compress, datalen=%{public}zu", strlen(msg) + 1);
1664 if (DataCompress((uint8_t *)msg, strlen(msg) + 1, &compressData, &compressLen) != SOFTBUS_OK) {
1665 compressFlag = FLAG_UNCOMPRESS_DEVICE_INFO;
1666 } else {
1667 compressFlag = FLAG_COMPRESS_DEVICE_INFO;
1668 AUTH_LOGI(AUTH_FSM, "deviceInfo compress finish");
1669 }
1670 AUTH_LOGI(AUTH_FSM, "after compress, datalen=%{public}u", compressLen);
1671 }
1672 uint8_t *inputData = NULL;
1673 uint32_t inputLen;
1674 uint8_t *data = NULL;
1675 uint32_t dataLen = 0;
1676 if ((compressData != NULL) && (compressLen != 0)) {
1677 inputData = compressData;
1678 inputLen = compressLen;
1679 } else {
1680 inputData = (uint8_t *)msg;
1681 inputLen = strlen(msg) + 1;
1682 }
1683 SessionKeyList sessionKeyList;
1684 GetSessionKeyList(authSeq, info, &sessionKeyList);
1685 if (EncryptInner(&sessionKeyList, inputData, inputLen, &data, &dataLen) != SOFTBUS_OK) {
1686 AUTH_LOGE(AUTH_FSM, "encrypt device info fail");
1687 JSON_Free(msg);
1688 SoftBusFree(compressData);
1689 return SOFTBUS_ENCRYPT_ERR;
1690 }
1691 JSON_Free(msg);
1692 SoftBusFree(compressData);
1693 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI && info->isServer) {
1694 compressFlag = FLAG_RELAY_DEVICE_INFO;
1695 authSeq = 0;
1696 }
1697 AuthDataHead head = {
1698 .dataType = DATA_TYPE_DEVICE_INFO,
1699 .module = MODULE_AUTH_CONNECTION,
1700 .seq = authSeq,
1701 .flag = compressFlag,
1702 .len = dataLen,
1703 };
1704 if (PostAuthData(info->connId, !info->isServer, &head, data) != SOFTBUS_OK) {
1705 AUTH_LOGE(AUTH_FSM, "post device info fail");
1706 SoftBusFree(data);
1707 return SOFTBUS_AUTH_SEND_FAIL;
1708 }
1709 SoftBusFree(data);
1710 return SOFTBUS_OK;
1711 }
1712
ProcessDeviceInfoMessage(int64_t authSeq,AuthSessionInfo * info,const uint8_t * data,uint32_t len)1713 int32_t ProcessDeviceInfoMessage(int64_t authSeq, AuthSessionInfo *info, const uint8_t *data, uint32_t len)
1714 {
1715 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1716 AUTH_CHECK_AND_RETURN_RET_LOGE(data != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "data is NULL");
1717 uint8_t *msg = NULL;
1718 uint32_t msgSize = 0;
1719 SessionKeyList sessionKeyList;
1720 GetSessionKeyList(authSeq, info, &sessionKeyList);
1721 if (DecryptInner(&sessionKeyList, data, len, &msg, &msgSize) != SOFTBUS_OK) {
1722 AUTH_LOGE(AUTH_FSM, "decrypt device info fail");
1723 return SOFTBUS_DECRYPT_ERR;
1724 }
1725 uint8_t *decompressData = NULL;
1726 uint32_t decompressLen = 0;
1727 if ((info->connInfo.type != AUTH_LINK_TYPE_WIFI) && info->isSupportCompress) {
1728 AUTH_LOGI(AUTH_FSM, "before decompress, msgSize=%{public}u", msgSize);
1729 if (DataDecompress((uint8_t *)msg, msgSize, &decompressData, &decompressLen) != SOFTBUS_OK) {
1730 AUTH_LOGE(AUTH_FSM, "data decompress fail");
1731 SoftBusFree(msg);
1732 return SOFTBUS_ERR;
1733 } else {
1734 AUTH_LOGI(AUTH_FSM, "deviceInfo deCompress finish, decompress=%{public}d", decompressLen);
1735 }
1736 AUTH_LOGI(AUTH_FSM, "after decompress, datalen=%{public}d", decompressLen);
1737 }
1738 DevInfoData devInfo = {NULL, 0, info->connInfo.type, info->version};
1739 if ((decompressData != NULL) && (decompressLen != 0)) {
1740 devInfo.msg = (const char *)decompressData;
1741 devInfo.len = decompressLen;
1742 } else {
1743 devInfo.msg = (const char *)msg;
1744 devInfo.len = msgSize;
1745 }
1746 if (UnpackDeviceInfoMessage(&devInfo, &info->nodeInfo, false) != SOFTBUS_OK) {
1747 AUTH_LOGE(AUTH_FSM, "unpack device info fail");
1748 SoftBusFree(msg);
1749 SoftBusFree(decompressData);
1750 return SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL;
1751 }
1752 SoftBusFree(msg);
1753 SoftBusFree(decompressData);
1754 return SOFTBUS_OK;
1755 }
1756
PostCloseAckMessage(int64_t authSeq,const AuthSessionInfo * info)1757 int32_t PostCloseAckMessage(int64_t authSeq, const AuthSessionInfo *info)
1758 {
1759 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1760 const char *msg = "";
1761 AuthDataHead head = {
1762 .dataType = DATA_TYPE_CLOSE_ACK,
1763 .module = 0,
1764 .seq = authSeq,
1765 .flag = 0,
1766 .len = strlen(msg) + 1,
1767 };
1768 if (PostAuthData(info->connId, !info->isServer, &head, (uint8_t *)msg) != SOFTBUS_OK) {
1769 AUTH_LOGE(AUTH_FSM, "post close ack fail");
1770 return SOFTBUS_AUTH_SEND_FAIL;
1771 }
1772 return SOFTBUS_OK;
1773 }
1774
PostHichainAuthMessage(int64_t authSeq,const AuthSessionInfo * info,const uint8_t * data,uint32_t len)1775 int32_t PostHichainAuthMessage(int64_t authSeq, const AuthSessionInfo *info, const uint8_t *data, uint32_t len)
1776 {
1777 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1778 AUTH_CHECK_AND_RETURN_RET_LOGE(data != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "data is NULL");
1779 AuthDataHead head = {
1780 .dataType = DATA_TYPE_AUTH,
1781 .module = MODULE_AUTH_SDK,
1782 .seq = authSeq,
1783 .flag = 0,
1784 .len = len,
1785 };
1786 if (PostAuthData(info->connId, !info->isServer, &head, data) != SOFTBUS_OK) {
1787 AUTH_LOGE(AUTH_FSM, "post hichain data fail");
1788 return SOFTBUS_AUTH_SEND_FAIL;
1789 }
1790 return SOFTBUS_OK;
1791 }
1792
PackVerifyDeviceMessage(const char * uuid)1793 static char *PackVerifyDeviceMessage(const char *uuid)
1794 {
1795 JsonObj *obj = JSON_CreateObject();
1796 if (obj == NULL) {
1797 AUTH_LOGE(AUTH_FSM, "create json fail");
1798 return NULL;
1799 }
1800 if (!JSON_AddInt32ToObject(obj, CODE, CODE_VERIFY_DEVICE) || !JSON_AddStringToObject(obj, DEVICE_ID, uuid)) {
1801 AUTH_LOGE(AUTH_FSM, "add uuid fail");
1802 JSON_Delete(obj);
1803 return NULL;
1804 }
1805 char *msg = JSON_PrintUnformatted(obj);
1806 JSON_Delete(obj);
1807 return msg;
1808 }
1809
IsFlushDevicePacket(const AuthConnInfo * connInfo,const AuthDataHead * head,const uint8_t * data,bool isServer)1810 bool IsFlushDevicePacket(const AuthConnInfo *connInfo, const AuthDataHead *head, const uint8_t *data, bool isServer)
1811 {
1812 if (connInfo->type != AUTH_LINK_TYPE_WIFI) {
1813 return false;
1814 }
1815 int64_t authId = AuthDeviceGetIdByConnInfo(connInfo, isServer);
1816 if (authId == AUTH_INVALID_ID) {
1817 AUTH_LOGE(AUTH_FSM, "is flush device packet not find authId");
1818 return false;
1819 }
1820 uint32_t decDataLen = AuthGetDecryptSize(head->len);
1821 uint8_t *decData = (uint8_t *)SoftBusCalloc(decDataLen);
1822 if (decData == NULL) {
1823 return false;
1824 }
1825 if (AuthDeviceDecrypt(authId, data, head->len, decData, &decDataLen) != SOFTBUS_OK) {
1826 SoftBusFree(decData);
1827 AUTH_LOGE(AUTH_FSM, "parse device info decrypt fail");
1828 return false;
1829 }
1830 JsonObj *json = JSON_Parse((char *)decData, decDataLen);
1831 if (json == NULL) {
1832 AUTH_LOGE(AUTH_FSM, "parse json fail");
1833 SoftBusFree(decData);
1834 return false;
1835 }
1836 bool result = false;
1837 int32_t verifyDevice = 0;
1838 if (!JSON_GetInt32FromOject(json, CODE, &verifyDevice)) {
1839 AUTH_LOGE(AUTH_FSM, "parse device info fail");
1840 }
1841 if (verifyDevice == CODE_VERIFY_DEVICE) {
1842 result = true;
1843 }
1844 JSON_Delete(json);
1845 SoftBusFree(decData);
1846 return result;
1847 }
1848
PostVerifyDeviceMessage(const AuthManager * auth,int32_t flagRelay)1849 int32_t PostVerifyDeviceMessage(const AuthManager *auth, int32_t flagRelay)
1850 {
1851 AUTH_CHECK_AND_RETURN_RET_LOGE(auth != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "auth is NULL");
1852 char *msg = PackVerifyDeviceMessage(auth->uuid);
1853 if (msg == NULL) {
1854 AUTH_LOGE(AUTH_FSM, "pack verify device msg fail");
1855 return SOFTBUS_ERR;
1856 }
1857
1858 uint8_t *data = NULL;
1859 uint32_t dataLen = 0;
1860 if (EncryptInner(&auth->sessionKeyList, (uint8_t *)msg, strlen(msg) + 1, &data, &dataLen) != SOFTBUS_OK) {
1861 AUTH_LOGE(AUTH_FSM, "encrypt device info fail");
1862 JSON_Free(msg);
1863 return SOFTBUS_ENCRYPT_ERR;
1864 }
1865 JSON_Free(msg);
1866
1867 AuthDataHead head = {
1868 .dataType = DATA_TYPE_DEVICE_INFO,
1869 .module = MODULE_AUTH_CONNECTION,
1870 .seq = auth->authId,
1871 .flag = flagRelay,
1872 .len = dataLen,
1873 };
1874 if (PostAuthData(auth->connId, !auth->isServer, &head, data) != SOFTBUS_OK) {
1875 AUTH_LOGE(AUTH_FSM, "post verify device msg fail");
1876 SoftBusFree(data);
1877 return SOFTBUS_AUTH_SEND_FAIL;
1878 }
1879 SoftBusFree(data);
1880 return SOFTBUS_OK;
1881 }