1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "auth_session_json.h"
17
18 #include <math.h>
19 #include <securec.h>
20
21 #include "anonymizer.h"
22 #include "auth_connection.h"
23 #include "auth_hichain_adapter.h"
24 #include "auth_deviceprofile.h"
25 #include "auth_identity_service_adapter.h"
26 #include "auth_log.h"
27 #include "auth_manager.h"
28 #include "auth_pre_link.h"
29 #include "bus_center_info_key.h"
30 #include "bus_center_manager.h"
31 #include "comm_log.h"
32 #include "g_enhance_lnn_func.h"
33 #include "g_enhance_auth_func.h"
34 #include "g_enhance_auth_func_pack.h"
35 #include "g_enhance_lnn_func_pack.h"
36 #include "lnn_common_utils.h"
37 #include "lnn_extdata_config.h"
38 #include "lnn_feature_capability.h"
39 #include "lnn_local_net_ledger.h"
40 #include "lnn_node_info.h"
41 #include "lnn_ohos_account.h"
42 #include "lnn_settingdata_event_monitor.h"
43 #include "lnn_log.h"
44 #include "softbus_adapter_bt_common.h"
45 #include "softbus_adapter_json.h"
46 #include "softbus_adapter_mem.h"
47 #include "softbus_adapter_socket.h"
48 #include "softbus_def.h"
49 #include "softbus_feature_config.h"
50 #include "softbus_socket.h"
51 #include "softbus_utils.h"
52 #include "softbus_init_common.h"
53
54 /* DeviceId */
55 #define CMD_TAG "TECmd"
56 #define CMD_GET_AUTH_INFO "getAuthInfo"
57 #define CMD_RET_AUTH_INFO "retAuthInfo"
58 #define DATA_TAG "TEData"
59 #define DEVICE_ID_TAG "TEDeviceId"
60 #define DATA_BUF_SIZE_TAG "DataBufSize"
61 #define SOFTBUS_VERSION_TAG "softbusVersion"
62 #define AUTH_VERSION_TAG "authVersion"
63 #define SUPPORT_INFO_COMPRESS "supportInfoCompress"
64 #define IS_NORMALIZED "isNormalized"
65 #define NORMALIZED_DATA "normalizedData"
66 #define EXCHANGE_ID_TYPE "exchangeIdType"
67 #define DEV_IP_HASH_TAG "DevIpHash"
68 #define AUTH_MODULE "AuthModule"
69 #define DM_R_DEVICE_KEY_ID "dmRemoteDeviceKeyId"
70 #define DM_L_DEVICE_KEY_ID "dmLocalDeviceKeyId"
71 #define AUTH_PRELINK_NODE "AuthPreLinkNode"
72 #define CMD_TAG_LEN 30
73 #define PACKET_SIZE (64 * 1024)
74
75 /* DeviceInfo-WiFi */
76 #define CODE_VERIFY_IP 1
77 #define BUS_MAX_VERSION "BUS_MAX_VERSION"
78 #define BUS_MIN_VERSION "BUS_MIN_VERSION"
79 #define AUTH_PORT "AUTH_PORT"
80 #define SESSION_PORT "SESSION_PORT"
81 #define PROXY_PORT "PROXY_PORT"
82 #define DEV_IP "DEV_IP"
83 #define BLE_OFFLINE_CODE "OFFLINE_CODE"
84 #define BUS_V1 1
85 #define BUS_V2 2
86
87 /* DeviceInfo-BT */
88 #define CODE_VERIFY_BT 5
89 #define DISCOVERY_TYPE "DISCOVERY_TYPE"
90 #define UUID "UUID"
91 #define DEVICE_VERSION_TYPE "DEVICE_VERSION_TYPE"
92 #define BR_MAC_ADDR "BR_MAC_ADDR"
93 #define CONNECT_INFO "CONNECT_INFO"
94
95 /* DeviceInfo-common */
96 #define DEVICE_NAME "DEVICE_NAME"
97 #define DEVICE_TYPE "DEVICE_TYPE"
98 #define DEVICE_UDID "DEVICE_UDID"
99 #define DEVICE_UUID "DEVICE_UUID"
100 #define NETWORK_ID "NETWORK_ID"
101 #define NODE_ADDR "NODE_ADDR"
102 #define VERSION_TYPE "VERSION_TYPE"
103 #define BT_MAC "BT_MAC"
104 #define BLE_MAC "BLE_MAC"
105 #define STATIC_NET_CAP "STATIC_NET_CAP"
106 #define CONN_CAP "CONN_CAP"
107 #define AUTH_CAP "AUTH_CAP"
108 #define HB_CAP "HB_CAP"
109 #define SW_VERSION "SW_VERSION"
110 #define MASTER_UDID "MASTER_UDID"
111 #define MASTER_WEIGHT "MASTER_WEIGHT"
112 #define BLE_P2P "BLE_P2P"
113 #define PRODUCT_ID "PRODUCT_ID"
114 #define MODEL_NAME "MODEL_NAME"
115 #define STA_FREQUENCY "STA_FREQUENCY"
116 #define P2P_MAC_ADDR "P2P_MAC_ADDR"
117 #define P2P_ROLE "P2P_ROLE"
118 #define TRANSPORT_PROTOCOL "TRANSPORT_PROTOCOL"
119 #define DATA_CHANGE_FLAG "NODE_DATA_CHANGE_FLAG"
120 #define IS_CHARGING "IS_CHARGING"
121 #define BATTERY_LEAVEL "BATTERY_LEAVEL"
122 #define PKG_VERSION "PKG_VERSION"
123 #define OS_TYPE "OS_TYPE"
124 #define OS_VERSION "OS_VERSION"
125 #define DEVICE_VERSION "DEVICE_VERSION"
126 #define WIFI_VERSION "WIFI_VERSION"
127 #define BLE_VERSION "BLE_VERSION"
128 #define HML_MAC "HML_MAC"
129 #define WIFI_CFG "WIFI_CFG"
130 #define CHAN_LIST_5G "CHAN_LIST_5G"
131 #define REMAIN_POWER "REMAIN_POWER"
132 #define IS_CHARGING "IS_CHARGING"
133 #define IS_SCREENON "IS_SCREENON"
134 #define IP_MAC "IP_MAC"
135 #define NODE_WEIGHT "NODE_WEIGHT"
136 #define ACCOUNT_ID "ACCOUNT_ID"
137 #define ACCOUNT_UID "ACCOUNT_UID"
138 #define DISTRIBUTED_SWITCH "DISTRIBUTED_SWITCH"
139 #define TRANS_FLAGS "TRANS_FLAGS"
140 #define BLE_TIMESTAMP "BLE_TIMESTAMP"
141 #define WIFI_BUFF_SIZE "WIFI_BUFF_SIZE"
142 #define BR_BUFF_SIZE "BR_BUFF_SIZE"
143 #define FEATURE "FEATURE"
144 #define CONN_SUB_FEATURE "CONN_SUB_FEATURE"
145 #define META_NODE_INFO_OF_EAR "MetaNodeInfoOfEar"
146 #define NEW_CONN_CAP "NEW_CONN_CAP"
147 #define EXTDATA "EXTDATA"
148 #define STATE_VERSION "STATE_VERSION"
149 #define STATE_VERSION_CHANGE_REASON "STATE_VERSION_CHANGE_REASON"
150 #define BD_KEY "BD_KEY"
151 #define IV "IV"
152 #define SETTINGS_NICK_NAME "SETTINGS_NICK_NAME"
153 #define UNIFIED_DISPLAY_DEVICE_NAME "UNIFIED_DISPLAY_DEVICE_NAME"
154 #define UNIFIED_DEFAULT_DEVICE_NAME "UNIFIED_DEFAULT_DEVICE_NAME"
155 #define UNIFIED_DEVICE_NAME "UNIFIED_DEVICE_NAME"
156 #define PTK "PTK"
157 #define STATIC_CAP "STATIC_CAP"
158 #define STATIC_CAP_LENGTH "STATIC_CAP_LEN"
159 #define BROADCAST_CIPHER_KEY "BROADCAST_CIPHER_KEY"
160 #define BROADCAST_CIPHER_IV "BROADCAST_CIPHER_IV"
161 #define IRK "IRK"
162 #define PUB_MAC "PUB_MAC"
163 #define DEVICE_SECURITY_LEVEL "DEVICE_SECURITY_LEVEL"
164 #define AUTH_START_STATE "AUTH_START_STATE"
165 #define SLE_RANGE_CAP "SLE_RANGE_CAP"
166 #define SLE_MAC "SLE_MAC"
167
168 #define HAS_CTRL_CHANNEL (0x1L)
169 #define HAS_CHANNEL_AUTH (0x2L)
170 #define HAS_P2P_AUTH_V2 (0x04L)
171 #define HAS_SUPPRESS_STRATEGY (0x08L)
172 #define HAS_WAIT_TCP_TX_DONE (0x10L)
173 #define LOCAL_FLAGS (HAS_CTRL_CHANNEL | HAS_P2P_AUTH_V2 | HAS_SUPPRESS_STRATEGY | HAS_WAIT_TCP_TX_DONE)
174 #define LONG_TO_STRING_MAX_LEN 21
175 #define DEFAULT_BATTERY_LEVEL 100
176 #define DEFAULT_NODE_WEIGHT 100
177 #define BASE64_OFFLINE_CODE_LEN 16
178 #define DEFAULT_WIFI_BUFF_SIZE 32768 // 32k
179 #define DEFAULT_BR_BUFF_SIZE 4096 // 4k
180 #define DEFAULT_BLE_TIMESTAMP (roundl(pow(2, 63)) - 1)
181 #define BT_DISC_TYPE_MAX_LEN 7 // br, ble,...
182 #define BT_MAC_LEN 18
183 #define DEFAULT_BT_DISC_TYPE_STR "NO"
184 #define PARSE_UNCOMPRESS_STRING_BUFF_LEN 6 // "true" or "false"
185 #define TRUE_STRING_TAG "true"
186 #define FALSE_STRING_TAG "false"
187 #define DEFAULT_STATIC_NET_CAP 0x3F
188
189 /* fast_auth */
190 #define ACCOUNT_HASH "accountHash"
191 #define COMMON_KEY_HASH "keyHash"
192 #define FAST_AUTH "fastauth"
193 #define SOFTBUS_FAST_AUTH "support_fast_auth"
194
195 #define ENCRYPTED_FAST_AUTH_MAX_LEN 512
196 #define ENCRYPTED_NORMALIZED_KEY_MAX_LEN 512
197
198 /* UDID abatement*/
199 #define ATTEST_CERTS "ATTEST_CERTS"
200 #define DEVICE_CERTS "DEVICE_CERTS"
201 #define MANUFACTURE_CERTS "MANUFACTURE_CERTS"
202 #define ROOT_CERTS "ROOT_CERTS"
203 #define IS_NEED_PACK_CERT "IS_NEED_PACK_CERT"
204
205 /* ble conn close delay time */
206 #define BLE_CONN_CLOSE_DELAY_TIME "BLE_CONN_CLOSE_DELAY_TIME"
207 #define BLE_MAC_REFRESH_SWITCH "BLE_MAC_REFRESH_SWITCH"
208 #define BLE_CONNECTION_CLOSE_DELAY (10 * 1000L)
209 #define BLE_MAC_AUTO_REFRESH_SWITCH 1
210
211 #define INVALID_BR_MAC_ADDR "00:00:00:00:00:00"
212
213 /* userId */
214 #define USERID_CHECKSUM "USERID_CHECKSUM"
215 #define USERID "USERID"
216
217 /* udid short hash */
218 #define UDID_SHORT_HASH "UDID_SHORT_HASH"
219
OptString(const JsonObj * json,const char * const key,char * target,uint32_t targetLen,const char * defaultValue)220 static void OptString(
221 const JsonObj *json, const char * const key, char *target, uint32_t targetLen, const char *defaultValue)
222 {
223 if (JSON_GetStringFromObject(json, key, target, targetLen)) {
224 return;
225 }
226 if (strcpy_s(target, targetLen, defaultValue) != EOK) {
227 AUTH_LOGI(AUTH_FSM, "set default fail");
228 return;
229 }
230 AUTH_LOGI(AUTH_FSM, "key parse fail, use default. key=%{public}s", key);
231 }
232
OptInt(const JsonObj * json,const char * const key,int * target,int defaultValue)233 static void OptInt(const JsonObj *json, const char * const key, int *target, int defaultValue)
234 {
235 if (JSON_GetInt32FromOject(json, key, target)) {
236 return;
237 }
238 AUTH_LOGI(AUTH_FSM, "key parse fail, use default. key=%{public}s", key);
239 *target = defaultValue;
240 }
241
OptInt64(const JsonObj * json,const char * const key,int64_t * target,int64_t defaultValue)242 static void OptInt64(const JsonObj *json, const char * const key, int64_t *target, int64_t defaultValue)
243 {
244 if (JSON_GetInt64FromOject(json, key, target)) {
245 return;
246 }
247 AUTH_LOGI(AUTH_FSM, "key parse fail, use default. key=%{public}s", key);
248 *target = defaultValue;
249 }
250
OptBool(const JsonObj * json,const char * const key,bool * target,bool defaultValue)251 static void OptBool(const JsonObj *json, const char * const key, bool *target, bool defaultValue)
252 {
253 if (JSON_GetBoolFromOject(json, key, target)) {
254 return;
255 }
256 AUTH_LOGI(AUTH_FSM, "key parse fail, use default. key=%{public}s", key);
257 *target = defaultValue;
258 }
259
PackFastAuthValue(JsonObj * obj,AuthDeviceKeyInfo * deviceCommKey)260 static int32_t PackFastAuthValue(JsonObj *obj, AuthDeviceKeyInfo *deviceCommKey)
261 {
262 uint32_t dataLen = 0;
263 uint8_t *data = NULL;
264 AesGcmInputParam aesParam = { 0 };
265 aesParam.data = (uint8_t *)SOFTBUS_FAST_AUTH;
266 aesParam.dataLen = strlen(SOFTBUS_FAST_AUTH);
267 aesParam.key = deviceCommKey->deviceKey;
268 aesParam.keyLen = deviceCommKey->keyLen;
269 int32_t ret = LnnEncryptAesGcm(&aesParam, (int32_t)deviceCommKey->keyIndex, &data, &dataLen);
270 if (ret != SOFTBUS_OK) {
271 AUTH_LOGE(AUTH_FSM, "SoftBusEncryptDataWithSeq fail=%{public}d", ret);
272 return SOFTBUS_ENCRYPT_ERR;
273 }
274 if (data == NULL || dataLen == 0) {
275 AUTH_LOGE(AUTH_FSM, "encrypt data invalid");
276 return SOFTBUS_INVALID_PARAM;
277 }
278 char encryptFastAuth[ENCRYPTED_FAST_AUTH_MAX_LEN] = { 0 };
279 if (ConvertBytesToUpperCaseHexString(encryptFastAuth, ENCRYPTED_FAST_AUTH_MAX_LEN - 1, data, dataLen) !=
280 SOFTBUS_OK) {
281 SoftBusFree(data);
282 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
283 }
284 AUTH_LOGD(AUTH_FSM, "pack fastAuthTag=%{public}s", encryptFastAuth);
285 JSON_AddStringToObject(obj, FAST_AUTH, encryptFastAuth);
286 SoftBusFree(data);
287 return SOFTBUS_OK;
288 }
289
GenerateUdidShortHash(const char * udid,char * udidHashBuf,uint32_t bufLen)290 static bool GenerateUdidShortHash(const char *udid, char *udidHashBuf, uint32_t bufLen)
291 {
292 uint8_t hash[SHA_256_HASH_LEN] = { 0 };
293 int ret = SoftBusGenerateStrHash((uint8_t *)udid, strlen(udid), hash);
294 if (ret != SOFTBUS_OK) {
295 AUTH_LOGE(AUTH_FSM, "generate udidHash fail");
296 return false;
297 }
298 if (ConvertBytesToHexString(udidHashBuf, bufLen, hash, UDID_SHORT_HASH_LEN_TEMP) != SOFTBUS_OK) {
299 AUTH_LOGE(AUTH_FSM, "convert bytes to string fail");
300 return false;
301 }
302 return true;
303 }
304
GenerateAccountHash(int64_t accountId,char * accountHashBuf,uint32_t bufLen)305 static int32_t GenerateAccountHash(int64_t accountId, char *accountHashBuf, uint32_t bufLen)
306 {
307 char accountString[LONG_TO_STRING_MAX_LEN] = { 0 };
308 uint8_t accountHash[SHA_256_HASH_LEN] = { 0 };
309 if (sprintf_s(accountString, LONG_TO_STRING_MAX_LEN, "%" PRId64, accountId) == -1) {
310 AUTH_LOGE(AUTH_FSM, "long to string fail");
311 return SOFTBUS_SPRINTF_ERR;
312 }
313 char *anonyAccountId = NULL;
314 Anonymize(accountString, &anonyAccountId);
315 AUTH_LOGI(AUTH_FSM, "accountString=%{public}s", AnonymizeWrapper(anonyAccountId));
316 AnonymizeFree(anonyAccountId);
317 int32_t ret = SoftBusGenerateStrHash((uint8_t *)accountString, strlen(accountString), accountHash);
318 if (ret != SOFTBUS_OK) {
319 AUTH_LOGE(AUTH_FSM, "accountId hash fail, ret=%{public}d", ret);
320 return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
321 }
322 if (ConvertBytesToHexString(accountHashBuf, bufLen, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
323 AUTH_LOGE(AUTH_FSM, "convert bytes to string fail");
324 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
325 }
326 return SOFTBUS_OK;
327 }
328
GetUdidOrShortHash(const AuthSessionInfo * info,char * udidBuf,uint32_t bufLen)329 static bool GetUdidOrShortHash(const AuthSessionInfo *info, char *udidBuf, uint32_t bufLen)
330 {
331 if (!info->isServer) {
332 AUTH_LOGI(AUTH_FSM, "client generate udid, connType is %{public}d", info->connInfo.type);
333 if (info->connInfo.type == AUTH_LINK_TYPE_ENHANCED_P2P) {
334 return GenerateUdidShortHash(info->connInfo.info.ipInfo.udid, udidBuf, bufLen);
335 } else if (info->connInfo.type == AUTH_LINK_TYPE_SESSION) {
336 return GenerateUdidShortHash(info->connInfo.info.sessionInfo.udid, udidBuf, bufLen);
337 }
338 }
339 if (strlen(info->udid) != 0) {
340 AUTH_LOGI(AUTH_FSM, "use info->udid build fastAuthInfo");
341 return GenerateUdidShortHash(info->udid, udidBuf, bufLen);
342 }
343 if (info->connInfo.type == AUTH_LINK_TYPE_BLE) {
344 AUTH_LOGI(AUTH_FSM, "use bleInfo deviceIdHash build fastAuthInfo");
345 return (ConvertBytesToHexString(
346 udidBuf, bufLen, info->connInfo.info.bleInfo.deviceIdHash, UDID_SHORT_HASH_LEN_TEMP) == SOFTBUS_OK);
347 }
348 AUTH_LOGD(AUTH_FSM, "udidLen=%{public}zu, connInfoType=%{public}d", strlen(info->udid), info->connInfo.type);
349 return false;
350 }
351
GetUdidShortHash(const AuthSessionInfo * info,char * udidBuf,uint32_t bufLen)352 bool GetUdidShortHash(const AuthSessionInfo *info, char *udidBuf, uint32_t bufLen)
353 {
354 if (info == NULL || udidBuf == NULL || bufLen <= UDID_SHORT_HASH_HEX_STR) {
355 AUTH_LOGE(AUTH_FSM, "param error");
356 return false;
357 }
358 if (strlen(info->udid) != 0) {
359 AUTH_LOGI(AUTH_FSM, "use info->udid build normalize auth");
360 return GenerateUdidShortHash(info->udid, udidBuf, bufLen);
361 }
362 char udid[UDID_BUF_LEN] = { 0 };
363 switch (info->connInfo.type) {
364 case AUTH_LINK_TYPE_BR:
365 if (LnnGetUdidByBrMacPacked(info->connInfo.info.brInfo.brMac, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
366 AUTH_LOGE(AUTH_FSM, "get udid by brMac fail.");
367 return false;
368 }
369 return GenerateUdidShortHash(udid, udidBuf, bufLen);
370 case AUTH_LINK_TYPE_WIFI:
371 case AUTH_LINK_TYPE_SESSION_KEY:
372 case AUTH_LINK_TYPE_USB:
373 return (memcpy_s(udidBuf, bufLen, info->connInfo.info.ipInfo.deviceIdHash, UDID_SHORT_HASH_HEX_STR) == EOK);
374 case AUTH_LINK_TYPE_BLE:
375 return (ConvertBytesToHexString(udidBuf, bufLen, info->connInfo.info.bleInfo.deviceIdHash,
376 UDID_SHORT_HASH_LEN_TEMP) == SOFTBUS_OK);
377 case AUTH_LINK_TYPE_SLE:
378 break;
379 case AUTH_LINK_TYPE_P2P:
380 case AUTH_LINK_TYPE_ENHANCED_P2P:
381 if (!info->isServer) {
382 AUTH_LOGD(AUTH_FSM, "client(enhance p2p), use conninfo udid");
383 return GenerateUdidShortHash(info->connInfo.info.ipInfo.udid, udidBuf, bufLen);
384 }
385 return false;
386 case AUTH_LINK_TYPE_SESSION:
387 AUTH_LOGD(AUTH_FSM, "client(session), use conninfo.sessionInfo udid");
388 return GenerateUdidShortHash(info->connInfo.info.sessionInfo.udid, udidBuf, bufLen);
389 default:
390 AUTH_LOGE(AUTH_CONN, "unknown connType. type=%{public}d", info->connInfo.type);
391 }
392 return false;
393 }
394
GetEnhancedP2pAuthKey(const char * udidHash,AuthSessionInfo * info,AuthDeviceKeyInfo * deviceKey)395 static int32_t GetEnhancedP2pAuthKey(const char *udidHash, AuthSessionInfo *info, AuthDeviceKeyInfo *deviceKey)
396 {
397 /* first, reuse ble authKey */
398 if (AuthFindLatestNormalizeKeyPacked(udidHash, deviceKey, true) == SOFTBUS_OK ||
399 AuthFindDeviceKeyPacked(udidHash, AUTH_LINK_TYPE_BLE, deviceKey) == SOFTBUS_OK) {
400 AUTH_LOGD(AUTH_FSM, "get ble authKey succ");
401 return SOFTBUS_OK;
402 }
403 /* second, reuse wifi authKey */
404 AuthHandle authHandle = { .authId = AUTH_INVALID_ID };
405 AuthGetLatestIdByUuid(info->uuid, AUTH_LINK_TYPE_WIFI, false, &authHandle);
406 if (authHandle.authId == AUTH_INVALID_ID) {
407 AUTH_LOGE(AUTH_FSM, "get wifi authKey fail");
408 return SOFTBUS_AUTH_NOT_FOUND;
409 }
410 AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
411 if (auth == NULL) {
412 AUTH_LOGE(AUTH_FSM, "get AuthManager fail");
413 return SOFTBUS_AUTH_NOT_FOUND;
414 }
415 int32_t index;
416 SessionKey sessionKey;
417 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
418 if (GetLatestSessionKey(&auth->sessionKeyList, (AuthLinkType)authHandle.type, &index, &sessionKey) != SOFTBUS_OK) {
419 AUTH_LOGE(AUTH_FSM, "get key fail");
420 DelDupAuthManager(auth);
421 return SOFTBUS_AUTH_GET_SESSION_KEY_FAIL;
422 }
423 DelDupAuthManager(auth);
424 if (memcpy_s(deviceKey->deviceKey, SESSION_KEY_LENGTH, sessionKey.value, sizeof(sessionKey.value)) != EOK) {
425 AUTH_LOGE(AUTH_FSM, "memcpy fail");
426 return SOFTBUS_MEM_ERR;
427 }
428 deviceKey->keyLen = sessionKey.len;
429 /* wifi authKey not enable, associated with recoveryFastAuthKey */
430 return SOFTBUS_AUTH_GET_SESSION_KEY_FAIL;
431 }
432
GetFastAuthKey(const char * udidHash,AuthSessionInfo * info,AuthDeviceKeyInfo * deviceKey)433 static int32_t GetFastAuthKey(const char *udidHash, AuthSessionInfo *info, AuthDeviceKeyInfo *deviceKey)
434 {
435 if (info->connInfo.type == AUTH_LINK_TYPE_ENHANCED_P2P) {
436 AUTH_LOGI(AUTH_FSM, "get enhanced p2p fastAuth key");
437 return GetEnhancedP2pAuthKey(udidHash, info, deviceKey);
438 }
439 if (AuthFindDeviceKeyPacked(udidHash, info->connInfo.type, deviceKey) != SOFTBUS_OK) {
440 AUTH_LOGW(AUTH_FSM, "can't find common key, unsupport fastAuth");
441 info->isSupportFastAuth = false;
442 return SOFTBUS_AUTH_NOT_FOUND;
443 }
444 return SOFTBUS_OK;
445 }
446
PackFastAuth(JsonObj * obj,AuthSessionInfo * info)447 static void PackFastAuth(JsonObj *obj, AuthSessionInfo *info)
448 {
449 AUTH_LOGD(AUTH_FSM, "pack fastAuth, isServer=%{public}d", info->isServer);
450 bool isNeedPack;
451 if (!info->isServer || info->isSupportFastAuth) {
452 isNeedPack = true;
453 } else {
454 AUTH_LOGI(AUTH_FSM, "unsupport fastAuth");
455 isNeedPack = false;
456 }
457 if (isNeedPack && info->isNeedFastAuth == false) {
458 AUTH_LOGI(AUTH_FSM, "no need fastAuth");
459 isNeedPack = false;
460 }
461 if (!isNeedPack) {
462 return;
463 }
464 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = { 0 };
465 if (!GetUdidOrShortHash(info, udidHashHexStr, SHA_256_HEX_HASH_LEN)) {
466 AUTH_LOGE(AUTH_FSM, "get udid fail, bypass fastAuth");
467 info->isSupportFastAuth = false;
468 return;
469 }
470 char *anonyUdidHash = NULL;
471 Anonymize(udidHashHexStr, &anonyUdidHash);
472 AUTH_LOGI(AUTH_FSM, "udidHashHexStr=%{public}s", AnonymizeWrapper(anonyUdidHash));
473 AnonymizeFree(anonyUdidHash);
474 if (info->connInfo.type != AUTH_LINK_TYPE_ENHANCED_P2P &&
475 !IsPotentialTrustedDevice(ID_TYPE_DEVID, (const char *)udidHashHexStr, false, false)) {
476 AUTH_LOGI(AUTH_FSM, "not potential trusted realtion, bypass fastAuthProc");
477 info->isSupportFastAuth = false;
478 return;
479 }
480 AuthDeviceKeyInfo deviceCommKey = { 0 };
481 if (GetFastAuthKey(udidHashHexStr, info, &deviceCommKey) != SOFTBUS_OK) {
482 info->isSupportFastAuth = false;
483 return;
484 }
485 if (PackFastAuthValue(obj, &deviceCommKey) != SOFTBUS_OK) {
486 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
487 info->isSupportFastAuth = false;
488 return;
489 }
490 (void)memset_s(&deviceCommKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
491 }
492
PackNormalizedKeyValue(JsonObj * obj,SessionKey * sessionKey)493 static int32_t PackNormalizedKeyValue(JsonObj *obj, SessionKey *sessionKey)
494 {
495 uint32_t dataLen = 0;
496 uint8_t *data = NULL;
497 AesGcmInputParam aesParam = { 0 };
498 aesParam.data = (uint8_t *)TRUE_STRING_TAG;
499 aesParam.dataLen = strlen(TRUE_STRING_TAG);
500 aesParam.key = sessionKey->value;
501 aesParam.keyLen = sessionKey->len;
502 int32_t ret = LnnEncryptAesGcm(&aesParam, 0, &data, &dataLen);
503 if (ret != SOFTBUS_OK) {
504 AUTH_LOGE(AUTH_FSM, "encrypt aes gcm fail=%{public}d", ret);
505 return SOFTBUS_ENCRYPT_ERR;
506 }
507 if (data == NULL || dataLen == 0) {
508 AUTH_LOGE(AUTH_FSM, "encrypt data invalid");
509 return SOFTBUS_INVALID_PARAM;
510 }
511 char encNormalizedKey[ENCRYPTED_NORMALIZED_KEY_MAX_LEN] = { 0 };
512 if (ConvertBytesToUpperCaseHexString(encNormalizedKey, ENCRYPTED_NORMALIZED_KEY_MAX_LEN - 1, data, dataLen) !=
513 SOFTBUS_OK) {
514 SoftBusFree(data);
515 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
516 }
517 (void)JSON_AddStringToObject(obj, NORMALIZED_DATA, encNormalizedKey);
518 AUTH_LOGI(AUTH_FSM, "pack normalize value succ");
519 SoftBusFree(data);
520 return SOFTBUS_OK;
521 }
522
PackDeviceKeyId(JsonObj * obj,const AuthSessionInfo * info)523 static void PackDeviceKeyId(JsonObj *obj, const AuthSessionInfo *info)
524 {
525 int32_t localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
526 int32_t remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
527 localDeviceKeyId = info->deviceKeyId.localDeviceKeyId;
528 remoteDeviceKeyId = info->deviceKeyId.remoteDeviceKeyId;
529 if (localDeviceKeyId == AUTH_INVALID_DEVICEKEY_ID || remoteDeviceKeyId == AUTH_INVALID_DEVICEKEY_ID) {
530 AUTH_LOGE(AUTH_FSM, "deviceKeyId invalid");
531 return;
532 }
533 if (!JSON_AddInt32ToObject(obj, DM_L_DEVICE_KEY_ID, localDeviceKeyId)) {
534 AUTH_LOGE(AUTH_FSM, "add deviceKeyId fail");
535 return;
536 }
537 if (!JSON_AddInt32ToObject(obj, DM_R_DEVICE_KEY_ID, remoteDeviceKeyId)) {
538 AUTH_LOGE(AUTH_FSM, "add deviceKeyId fail");
539 return;
540 }
541 }
542
PackNormalizedKeyInner(JsonObj * obj,AuthSessionInfo * info,int64_t authSeq)543 static void PackNormalizedKeyInner(JsonObj *obj, AuthSessionInfo *info, int64_t authSeq)
544 {
545 char udidHashHexStr[SHA_256_HEX_HASH_LEN] = { 0 };
546 if (!GetUdidShortHash(info, udidHashHexStr, SHA_256_HEX_HASH_LEN)) {
547 AUTH_LOGE(AUTH_FSM, "get udid fail, bypass normalizedAuth");
548 return;
549 }
550 if (info->normalizedKey != NULL) {
551 if (PackNormalizedKeyValue(obj, info->normalizedKey) != SOFTBUS_OK) {
552 AUTH_LOGE(AUTH_FSM, "pack normalized key fail");
553 }
554 return;
555 }
556 info->normalizedKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
557 if (info->normalizedKey == NULL) {
558 AUTH_LOGE(AUTH_FSM, "malloc fail");
559 return;
560 }
561 AuthDeviceKeyInfo deviceKey;
562 (void)memset_s(&deviceKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
563 if (info->deviceKeyId.hasDeviceKeyId) {
564 if (!GetSessionKeyProfile(info->deviceKeyId.localDeviceKeyId, deviceKey.deviceKey, &deviceKey.keyLen)) {
565 AUTH_LOGE(AUTH_FSM, "get auth key fail");
566 deviceKey.keyLen = 0;
567 (void)memset_s(deviceKey.deviceKey, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
568 return;
569 }
570 deviceKey.keyIndex = authSeq;
571 info->nodeInfo.aclState = ACL_NOT_WRITE;
572 } else if (AuthFindLatestNormalizeKeyPacked((char *)udidHashHexStr, &deviceKey, true) != SOFTBUS_OK) {
573 AUTH_LOGW(AUTH_FSM, "can't find device key");
574 return;
575 }
576 info->normalizedIndex = deviceKey.keyIndex;
577 info->normalizedKey->len = deviceKey.keyLen;
578 if (memcpy_s(info->normalizedKey->value, sizeof(info->normalizedKey->value), deviceKey.deviceKey,
579 sizeof(deviceKey.deviceKey)) != EOK) {
580 AUTH_LOGE(AUTH_FSM, "session key cpy fail");
581 return;
582 }
583 (void)memset_s(&deviceKey, sizeof(AuthDeviceKeyInfo), 0, sizeof(AuthDeviceKeyInfo));
584 if (PackNormalizedKeyValue(obj, info->normalizedKey) != SOFTBUS_OK) {
585 AUTH_LOGE(AUTH_FSM, "pack normalized key fail");
586 return;
587 }
588 }
589
PackNormalizedKey(JsonObj * obj,AuthSessionInfo * info,int64_t authSeq)590 static void PackNormalizedKey(JsonObj *obj, AuthSessionInfo *info, int64_t authSeq)
591 {
592 if (!info->isNeedFastAuth && !info->isServer) {
593 AUTH_LOGE(AUTH_FSM, "force auth.");
594 return;
595 }
596 if (info->isServer && info->normalizedType == NORMALIZED_KEY_ERROR) {
597 AUTH_LOGE(AUTH_FSM, "peer not support normalize or key error.");
598 return;
599 }
600 if (info->localState != AUTH_STATE_START && info->localState != AUTH_STATE_ACK &&
601 info->localState != AUTH_STATE_COMPATIBLE) {
602 AUTH_LOGI(AUTH_FSM, "nego state, not send normalize data.");
603 return;
604 }
605 PackNormalizedKeyInner(obj, info, authSeq);
606 }
607
ParseFastAuthValue(AuthSessionInfo * info,const char * encryptedFastAuth,AuthDeviceKeyInfo * deviceKey)608 static void ParseFastAuthValue(AuthSessionInfo *info, const char *encryptedFastAuth, AuthDeviceKeyInfo *deviceKey)
609 {
610 uint8_t fastAuthBytes[ENCRYPTED_FAST_AUTH_MAX_LEN] = { 0 };
611 if (ConvertHexStringToBytes(
612 fastAuthBytes, ENCRYPTED_FAST_AUTH_MAX_LEN, encryptedFastAuth, strlen(encryptedFastAuth)) != SOFTBUS_OK) {
613 AUTH_LOGE(AUTH_FSM, "fastAuth data String to bytes fail");
614 return;
615 }
616 uint32_t bytesLen = strlen(encryptedFastAuth) >> 1;
617 uint32_t dataLen = 0;
618 uint8_t *data = NULL;
619 AesGcmInputParam aesParam = { 0 };
620 aesParam.data = fastAuthBytes;
621 aesParam.dataLen = bytesLen;
622 aesParam.key = deviceKey->deviceKey;
623 aesParam.keyLen = deviceKey->keyLen;
624 int32_t ret = LnnDecryptAesGcm(&aesParam, &data, &dataLen);
625 if (ret != SOFTBUS_OK) {
626 AUTH_LOGE(AUTH_FSM, "LnnDecryptAesGcm fail, fastAuth not support. ret=%{public}d", ret);
627 return;
628 }
629 if (data == NULL || dataLen == 0) {
630 AUTH_LOGE(AUTH_FSM, "decrypt data invalid, fastAuth not support");
631 return;
632 }
633 if (strncmp((char *)data, SOFTBUS_FAST_AUTH, strlen(SOFTBUS_FAST_AUTH)) != 0) {
634 AUTH_LOGE(AUTH_FSM, "fast auth info error");
635 SoftBusFree(data);
636 return;
637 }
638 AUTH_LOGD(AUTH_FSM, "parse fastAuth succ");
639 SoftBusFree(data);
640 info->isSupportFastAuth = true;
641 }
642
ParseNormalizedKeyValue(AuthSessionInfo * info,const char * encNormalizedKey,SessionKey * sessionKey)643 static int32_t ParseNormalizedKeyValue(AuthSessionInfo *info, const char *encNormalizedKey, SessionKey *sessionKey)
644 {
645 uint8_t normalizedKeyBytes[ENCRYPTED_NORMALIZED_KEY_MAX_LEN] = { 0 };
646 if (ConvertHexStringToBytes(normalizedKeyBytes, ENCRYPTED_NORMALIZED_KEY_MAX_LEN, encNormalizedKey,
647 strlen(encNormalizedKey)) != SOFTBUS_OK) {
648 AUTH_LOGE(AUTH_FSM, "normalizedType String to bytes fail");
649 return SOFTBUS_AUTH_HEX_STR_TO_BYTES_FAIL;
650 }
651 uint32_t bytesLen = strlen(encNormalizedKey) >> 1;
652 uint32_t dataLen = 0;
653 uint8_t *data = NULL;
654 AesGcmInputParam aesParam = { 0 };
655 aesParam.data = normalizedKeyBytes;
656 aesParam.dataLen = bytesLen;
657 aesParam.key = sessionKey->value;
658 aesParam.keyLen = sessionKey->len;
659 int32_t ret = LnnDecryptAesGcm(&aesParam, &data, &dataLen);
660 if (ret != SOFTBUS_OK) {
661 AUTH_LOGE(AUTH_FSM, "LnnDecryptAesGcm fail=%{public}d, key error", ret);
662 return SOFTBUS_DECRYPT_ERR;
663 }
664 if (data == NULL || dataLen == 0) {
665 AUTH_LOGE(AUTH_FSM, "decrypt data invalid");
666 return SOFTBUS_DECRYPT_ERR;
667 }
668 if (strncmp((char *)data, TRUE_STRING_TAG, strlen(TRUE_STRING_TAG)) != 0) {
669 AUTH_LOGE(AUTH_FSM, "normalized key error");
670 SoftBusFree(data);
671 return SOFTBUS_AUTH_NORMALIZED_KEY_PROC_ERR;
672 }
673 AUTH_LOGI(AUTH_FSM, "parse normalized key succ");
674 SoftBusFree(data);
675 info->normalizedType = NORMALIZED_SUPPORT;
676 return SOFTBUS_OK;
677 }
678
TryGetDmSessionKeyForUnpack(AuthSessionInfo * info,char * encNormalizedKey,AuthDeviceKeyInfo * deviceKey,int64_t authSeq)679 static int32_t TryGetDmSessionKeyForUnpack(AuthSessionInfo *info, char *encNormalizedKey,
680 AuthDeviceKeyInfo *deviceKey, int64_t authSeq)
681 {
682 if (!GetSessionKeyProfile(info->deviceKeyId.localDeviceKeyId, deviceKey->deviceKey, &deviceKey->keyLen)) {
683 AUTH_LOGE(AUTH_FSM, "get auth key fail");
684 deviceKey->keyLen = 0;
685 (void)memset_s(deviceKey->deviceKey, SESSION_KEY_LENGTH, 0, SESSION_KEY_LENGTH);
686 return SOFTBUS_AUTH_NORMALIZED_KEY_PROC_ERR;
687 }
688 deviceKey->keyIndex = authSeq;
689 SessionKey sessionKey;
690 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
691 sessionKey.len = deviceKey->keyLen;
692 if (memcpy_s(sessionKey.value, sizeof(sessionKey.value), deviceKey->deviceKey, sizeof(deviceKey->deviceKey)) !=
693 EOK) {
694 AUTH_LOGE(AUTH_FSM, "session key cpy fail");
695 return SOFTBUS_MEM_ERR;
696 }
697 if (ParseNormalizedKeyValue(info, encNormalizedKey, &sessionKey) != SOFTBUS_OK) {
698 return SOFTBUS_AUTH_NORMALIZED_KEY_PROC_ERR;
699 }
700 (void)memset_s(&sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
701 info->nodeInfo.aclState = ACL_NOT_WRITE;
702 AUTH_LOGI(AUTH_FSM, "use skId. authSeq=%{public}" PRId64, authSeq);
703 return SOFTBUS_OK;
704 }
705
ParseNormalizeData(AuthSessionInfo * info,char * encNormalizedKey,AuthDeviceKeyInfo * deviceKey,int64_t authSeq)706 static int32_t ParseNormalizeData(AuthSessionInfo *info, char *encNormalizedKey,
707 AuthDeviceKeyInfo *deviceKey, int64_t authSeq)
708 {
709 uint8_t udidHash[SHA_256_HASH_LEN] = { 0 };
710 int ret = SoftBusGenerateStrHash((uint8_t *)info->udid, strlen(info->udid), udidHash);
711 if (ret != SOFTBUS_OK) {
712 AUTH_LOGE(AUTH_FSM, "generate udidHash fail");
713 return SOFTBUS_NETWORK_GENERATE_STR_HASH_ERR;
714 }
715 char hashHexStr[UDID_SHORT_HASH_HEX_STR + 1] = { 0 };
716 if (ConvertBytesToUpperCaseHexString(hashHexStr, UDID_SHORT_HASH_HEX_STR + 1, udidHash, UDID_SHORT_HASH_LEN_TEMP) !=
717 SOFTBUS_OK) {
718 AUTH_LOGE(AUTH_FSM, "udid hash bytes to hexString fail");
719 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
720 }
721 SessionKey sessionKey;
722 (void)memset_s(&sessionKey, sizeof(SessionKey), 0, sizeof(SessionKey));
723 if (info->deviceKeyId.hasDeviceKeyId) {
724 return TryGetDmSessionKeyForUnpack(info, encNormalizedKey, deviceKey, authSeq);
725 }
726 // First: use latest normalizedKey
727 if (AuthFindLatestNormalizeKeyPacked(hashHexStr, deviceKey, true) != SOFTBUS_OK) {
728 AUTH_LOGE(AUTH_FSM, "can't find common key, parse normalize data fail");
729 return SOFTBUS_AUTH_NORMALIZED_KEY_PROC_ERR;
730 }
731 sessionKey.len = deviceKey->keyLen;
732 if (memcpy_s(sessionKey.value, sizeof(sessionKey.value), deviceKey->deviceKey, sizeof(deviceKey->deviceKey)) !=
733 EOK) {
734 AUTH_LOGE(AUTH_FSM, "session key cpy fail");
735 return SOFTBUS_MEM_ERR;
736 }
737 if (ParseNormalizedKeyValue(info, encNormalizedKey, &sessionKey) == SOFTBUS_OK) {
738 return SOFTBUS_OK;
739 }
740 // Second: decrypt fail, use another side normalizedKey
741 AUTH_LOGI(AUTH_FSM, "find another key");
742 if (AuthFindNormalizeKeyByServerSidePacked(hashHexStr, !deviceKey->isServerSide, deviceKey) != SOFTBUS_OK) {
743 AUTH_LOGE(AUTH_FSM, "can't find another key, parse normalize data fail");
744 return SOFTBUS_AUTH_NORMALIZED_KEY_PROC_ERR;
745 }
746 sessionKey.len = deviceKey->keyLen;
747 if (memcpy_s(sessionKey.value, sizeof(sessionKey.value), deviceKey->deviceKey, sizeof(deviceKey->deviceKey)) !=
748 EOK) {
749 AUTH_LOGE(AUTH_FSM, "session key cpy fail");
750 return SOFTBUS_MEM_ERR;
751 }
752 if (ParseNormalizedKeyValue(info, encNormalizedKey, &sessionKey) != SOFTBUS_OK) {
753 return SOFTBUS_AUTH_NORMALIZED_KEY_PROC_ERR;
754 }
755 (void)memset_s(&sessionKey, sizeof(sessionKey), 0, sizeof(sessionKey));
756 AuthUpdateCreateTimePacked(hashHexStr, AUTH_LINK_TYPE_NORMALIZED, deviceKey->isServerSide);
757 return SOFTBUS_OK;
758 }
759
UnpackSKId(JsonObj * obj,AuthSessionInfo * info)760 static void UnpackSKId(JsonObj *obj, AuthSessionInfo *info)
761 {
762 int32_t localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
763 int32_t remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
764 if (!JSON_GetInt32FromOject(obj, DM_L_DEVICE_KEY_ID, &remoteDeviceKeyId)) {
765 AUTH_LOGE(AUTH_FSM, "get device key id fail");
766 return;
767 }
768 if (!JSON_GetInt32FromOject(obj, DM_R_DEVICE_KEY_ID, &localDeviceKeyId)) {
769 AUTH_LOGE(AUTH_FSM, "get device key id fail");
770 return;
771 }
772 if (localDeviceKeyId == AUTH_INVALID_DEVICEKEY_ID || remoteDeviceKeyId == AUTH_INVALID_DEVICEKEY_ID) {
773 AUTH_LOGE(AUTH_FSM, "get device key id invalid");
774 return;
775 }
776 info->deviceKeyId.localDeviceKeyId = localDeviceKeyId;
777 info->deviceKeyId.remoteDeviceKeyId = remoteDeviceKeyId;
778 info->deviceKeyId.hasDeviceKeyId = true;
779 }
780
UnpackNormalizedKeyInner(JsonObj * obj,AuthSessionInfo * info,bool isSupportNormalizedKey,int64_t authSeq)781 static void UnpackNormalizedKeyInner(JsonObj *obj, AuthSessionInfo *info, bool isSupportNormalizedKey, int64_t authSeq)
782 {
783 info->normalizedType = NORMALIZED_KEY_ERROR;
784 char encNormalizedKey[ENCRYPTED_NORMALIZED_KEY_MAX_LEN] = { 0 };
785 if (!JSON_GetStringFromObject(obj, NORMALIZED_DATA, encNormalizedKey, ENCRYPTED_NORMALIZED_KEY_MAX_LEN)) {
786 AUTH_LOGI(AUTH_FSM, "peer not send normalizedKey");
787 return;
788 }
789 if (!info->isServer && info->normalizedKey != NULL) {
790 AUTH_LOGI(AUTH_FSM, "client already exit normalizedKey");
791 (void)ParseNormalizedKeyValue(info, encNormalizedKey, info->normalizedKey);
792 info->normalizedType = NORMALIZED_SUPPORT;
793 return;
794 }
795 info->normalizedKey = (SessionKey *)SoftBusCalloc(sizeof(SessionKey));
796 if (info->normalizedKey == NULL) {
797 AUTH_LOGE(AUTH_FSM, "malloc fail");
798 return;
799 }
800 uint8_t udidHash[SHA_256_HASH_LEN] = { 0 };
801 int ret = SoftBusGenerateStrHash((uint8_t *)info->udid, strlen(info->udid), udidHash);
802 if (ret != SOFTBUS_OK) {
803 AUTH_LOGE(AUTH_FSM, "generate udidHash fail");
804 return;
805 }
806 char hashHexStr[UDID_SHORT_HASH_HEX_STR + 1] = { 0 };
807 if (ConvertBytesToUpperCaseHexString(hashHexStr, UDID_SHORT_HASH_HEX_STR + 1, udidHash, UDID_SHORT_HASH_LEN_TEMP) !=
808 SOFTBUS_OK) {
809 AUTH_LOGE(AUTH_FSM, "udid hash bytes to hexString fail");
810 return;
811 }
812 AuthDeviceKeyInfo deviceKey = { 0 };
813 if (ParseNormalizeData(info, encNormalizedKey, &deviceKey, authSeq) != SOFTBUS_OK) {
814 AUTH_LOGE(AUTH_FSM, "normalize decrypt fail.");
815 return;
816 }
817 info->normalizedIndex = deviceKey.keyIndex;
818 info->normalizedType = NORMALIZED_SUPPORT;
819 info->normalizedKey->len = deviceKey.keyLen;
820 if (memcpy_s(info->normalizedKey->value, sizeof(info->normalizedKey->value), deviceKey.deviceKey,
821 sizeof(deviceKey.deviceKey)) != EOK) {
822 AUTH_LOGE(AUTH_FSM, "session key cpy fail");
823 return;
824 }
825 (void)memset_s(&deviceKey, sizeof(deviceKey), 0, sizeof(deviceKey));
826 }
827
UnpackNormalizedKey(JsonObj * obj,AuthSessionInfo * info,bool isSupportNormalizedKey,int64_t authSeq)828 static void UnpackNormalizedKey(JsonObj *obj, AuthSessionInfo *info, bool isSupportNormalizedKey, int64_t authSeq)
829 {
830 if (isSupportNormalizedKey == NORMALIZED_NOT_SUPPORT) {
831 AUTH_LOGI(AUTH_FSM, "peer old version or not support normalizedType");
832 info->normalizedType = NORMALIZED_NOT_SUPPORT;
833 return;
834 }
835 UnpackNormalizedKeyInner(obj, info, isSupportNormalizedKey, authSeq);
836 }
837
UnpackFastAuth(JsonObj * obj,AuthSessionInfo * info)838 static void UnpackFastAuth(JsonObj *obj, AuthSessionInfo *info)
839 {
840 info->isSupportFastAuth = false;
841 char encryptedFastAuth[ENCRYPTED_FAST_AUTH_MAX_LEN] = { 0 };
842 if (!JSON_GetStringFromObject(obj, FAST_AUTH, encryptedFastAuth, ENCRYPTED_FAST_AUTH_MAX_LEN)) {
843 AUTH_LOGI(AUTH_FSM, "old version or not support fastAuth");
844 return;
845 }
846 AUTH_LOGE(AUTH_FSM, "unpack fastAuthTag=%{public}s", encryptedFastAuth);
847 uint8_t udidHash[SHA_256_HASH_LEN] = { 0 };
848 int ret = SoftBusGenerateStrHash((uint8_t *)info->udid, strlen(info->udid), udidHash);
849 if (ret != SOFTBUS_OK) {
850 AUTH_LOGE(AUTH_FSM, "generate udidHash fail");
851 return;
852 }
853 char udidShortHash[UDID_SHORT_HASH_HEX_STR + 1] = { 0 };
854 if (ConvertBytesToHexString(udidShortHash, UDID_SHORT_HASH_HEX_STR + 1, udidHash, UDID_SHORT_HASH_LEN_TEMP) !=
855 SOFTBUS_OK) {
856 AUTH_LOGE(AUTH_FSM, "udid hash bytes to hexString fail");
857 return;
858 }
859 if (info->connInfo.type != AUTH_LINK_TYPE_ENHANCED_P2P &&
860 !IsPotentialTrustedDevice(ID_TYPE_DEVID, (const char *)udidShortHash, false, false)) {
861 AUTH_LOGI(AUTH_FSM, "not potential trusted realtion, fastAuth not support");
862 return;
863 }
864 AuthDeviceKeyInfo deviceKey = { 0 };
865 if (GetFastAuthKey(udidShortHash, info, &deviceKey) != SOFTBUS_OK) {
866 AUTH_LOGW(AUTH_FSM, "can't find device key, fastAuth not support");
867 return;
868 }
869 ParseFastAuthValue(info, encryptedFastAuth, &deviceKey);
870 (void)memset_s(&deviceKey, sizeof(deviceKey), 0, sizeof(deviceKey));
871 }
872
JudgeIsSameAccount(const char * accountHash)873 static bool JudgeIsSameAccount(const char *accountHash)
874 {
875 uint8_t localAccountHash[SHA_256_HASH_LEN] = { 0 };
876 if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, localAccountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
877 AUTH_LOGE(AUTH_FSM, "get local account hash fail");
878 return false;
879 }
880
881 uint8_t peerAccountHash[SHA_256_HASH_LEN] = { 0 };
882 if (ConvertHexStringToBytes(peerAccountHash, SHA_256_HASH_LEN, accountHash, strlen(accountHash)) != SOFTBUS_OK) {
883 AUTH_LOGE(AUTH_FSM, "convert peer account hash to bytes fail");
884 return false;
885 }
886
887 return (memcmp(localAccountHash, peerAccountHash, SHA_256_HASH_LEN) == 0) &&
888 (!LnnIsDefaultOhosAccount());
889 }
890
GetLocalUdidShortHash(char * localUdidHash)891 static int32_t GetLocalUdidShortHash(char *localUdidHash)
892 {
893 char udid[UDID_BUF_LEN] = { 0 };
894 if (LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK) {
895 AUTH_LOGE(AUTH_FSM, "get local udid fail");
896 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
897 }
898 if (!GenerateUdidShortHash(udid, localUdidHash, SHA_256_HEX_HASH_LEN)) {
899 AUTH_LOGE(AUTH_FSM, "get local udid hash fail");
900 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
901 }
902
903 return SOFTBUS_OK;
904 }
905
UnpackExternalAuthInfo(JsonObj * obj,AuthSessionInfo * info)906 static void UnpackExternalAuthInfo(JsonObj *obj, AuthSessionInfo *info)
907 {
908 OptInt(obj, USERID, &info->userId, 0);
909 if (info->authVersion < AUTH_VERSION_V2) {
910 AUTH_LOGD(AUTH_FSM, "lower version dont need unpack auth info");
911 return;
912 }
913 if (!JSON_GetStringFromObject(obj, UDID_SHORT_HASH, info->udidShortHash, SHA_256_HEX_HASH_LEN)) {
914 AUTH_LOGE(AUTH_FSM, "udid short hash not found");
915 return;
916 }
917 if (!JSON_GetStringFromObject(obj, ACCOUNT_HASH, info->accountHash, SHA_256_HEX_HASH_LEN)) {
918 AUTH_LOGE(AUTH_FSM, "account hash not found");
919 return;
920 }
921 if (info->deviceKeyId.hasDeviceKeyId &&
922 IsSKIdInvalid(info->deviceKeyId.localDeviceKeyId, info->accountHash, info->udidShortHash, info->userId)) {
923 info->deviceKeyId.hasDeviceKeyId = false;
924 info->deviceKeyId.localDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
925 info->deviceKeyId.remoteDeviceKeyId = AUTH_INVALID_DEVICEKEY_ID;
926 AUTH_LOGE(AUTH_FSM, "SKId invalid, hasDeviceKeyId=false");
927 }
928 NodeInfo nodeInfo;
929 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
930 int32_t ret = LnnGetLocalNodeInfoSafe(&nodeInfo);
931 if (ret != SOFTBUS_OK) {
932 AUTH_LOGE(AUTH_FSM, "get node info fail");
933 return;
934 }
935 info->isSameAccount = JudgeIsSameAccount(info->accountHash);
936 char localUdidHash[SHA_256_HEX_HASH_LEN] = { 0 };
937 if (GetLocalUdidShortHash(localUdidHash) != SOFTBUS_OK) {
938 AUTH_LOGE(AUTH_FSM, "get local udid short hash fail");
939 return;
940 }
941 char *udidShortHash = info->isSameAccount ? localUdidHash : info->udidShortHash;
942 char *credList = NULL;
943 ret = AuthIdServiceQueryCredential(info->userId, udidShortHash, info->accountHash, info->isSameAccount, &credList);
944 if (ret != SOFTBUS_OK) {
945 AUTH_LOGE(AUTH_FSM, "query credential fail");
946 return;
947 }
948 info->credId = IdServiceGetCredIdFromCredList(nodeInfo.userId, credList);
949 if (info->credId == NULL) {
950 AUTH_LOGE(AUTH_FSM, "get cred id fail");
951 }
952 IdServiceDestroyCredentialList(&credList);
953 }
954
PackCompressInfo(JsonObj * obj,const NodeInfo * info)955 static void PackCompressInfo(JsonObj *obj, const NodeInfo *info)
956 {
957 if (info != NULL) {
958 if (IsFeatureSupport(info->feature, BIT_INFO_COMPRESS)) {
959 JSON_AddStringToObject(obj, SUPPORT_INFO_COMPRESS, TRUE_STRING_TAG);
960 } else {
961 JSON_AddStringToObject(obj, SUPPORT_INFO_COMPRESS, FALSE_STRING_TAG);
962 }
963 }
964 }
965
PackWifiSinglePassInfo(JsonObj * obj,const AuthSessionInfo * info)966 static void PackWifiSinglePassInfo(JsonObj *obj, const AuthSessionInfo *info)
967 {
968 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI && info->connInfo.type != AUTH_LINK_TYPE_SESSION_KEY &&
969 info->connInfo.type != AUTH_LINK_TYPE_USB) {
970 AUTH_LOGE(AUTH_FSM, "link type is not wifi");
971 return;
972 }
973 uint8_t hash[SHA_256_HASH_LEN] = { 0 };
974 char localIp[MAX_ADDR_LEN] = { 0 };
975 int32_t ifIdx = (info->connInfo.type == AUTH_LINK_TYPE_USB) ? USB_IF : WLAN_IF;
976 if (LnnGetLocalStrInfoByIfnameIdx(STRING_KEY_IP, localIp, MAX_ADDR_LEN, ifIdx) != SOFTBUS_OK) {
977 AUTH_LOGE(AUTH_FSM, "get local ip fail");
978 return;
979 }
980 int32_t ret = SoftBusGenerateStrHash((const unsigned char *)localIp, strlen(localIp), hash);
981 if (ret != SOFTBUS_OK) {
982 return;
983 }
984 char devIpHash[SHA_256_HEX_HASH_LEN] = { 0 };
985 if (ConvertBytesToUpperCaseHexString(devIpHash, SHA_256_HEX_HASH_LEN, hash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
986 return;
987 }
988 JSON_AddStringToObject(obj, DEV_IP_HASH_TAG, devIpHash);
989 }
990
VerifySessionInfoIdType(const AuthSessionInfo * info,JsonObj * obj,char * networkId,char * udid)991 static bool VerifySessionInfoIdType(const AuthSessionInfo *info, JsonObj *obj, char *networkId, char *udid)
992 {
993 if (info->idType == EXCHANGE_NETWORKID) {
994 if (!JSON_AddStringToObject(obj, DEVICE_ID_TAG, networkId)) {
995 AUTH_LOGE(AUTH_FSM, "add msg body fail");
996 return false;
997 }
998 char *anonyNetworkId = NULL;
999 Anonymize(networkId, &anonyNetworkId);
1000 AUTH_LOGI(AUTH_FSM, "exchangeIdType=%{public}d, networkid=%{public}s", info->idType,
1001 AnonymizeWrapper(anonyNetworkId));
1002 AnonymizeFree(anonyNetworkId);
1003 } else {
1004 if (!JSON_AddStringToObject(obj, DEVICE_ID_TAG, udid)) {
1005 AUTH_LOGE(AUTH_FSM, "add msg body fail");
1006 return false;
1007 }
1008 char *anonyUdid = NULL;
1009 Anonymize(udid, &anonyUdid);
1010 AUTH_LOGI(AUTH_FSM, "exchangeIdType=%{public}d, udid=%{public}s", info->idType, AnonymizeWrapper(anonyUdid));
1011 AnonymizeFree(anonyUdid);
1012 }
1013
1014 AUTH_LOGI(AUTH_FSM, "session info verify succ.");
1015 return true;
1016 }
1017
PackUDIDAbatementFlag(JsonObj * obj,const AuthSessionInfo * info)1018 static void PackUDIDAbatementFlag(JsonObj *obj, const AuthSessionInfo *info)
1019 {
1020 if (IsSupportUDIDAbatementPacked() && !JSON_AddBoolToObject(obj, IS_NEED_PACK_CERT, IsNeedUDIDAbatementPacked(info))) {
1021 AUTH_LOGE(AUTH_FSM, "add pack cert flag fail.");
1022 }
1023 }
1024
PackDeviceJsonInfo(const AuthSessionInfo * info,JsonObj * obj)1025 static int32_t PackDeviceJsonInfo(const AuthSessionInfo *info, JsonObj *obj)
1026 {
1027 if ((info->connInfo.type == AUTH_LINK_TYPE_WIFI || info->connInfo.type == AUTH_LINK_TYPE_SESSION_KEY ||
1028 info->connInfo.type == AUTH_LINK_TYPE_USB) && !info->isConnectServer) {
1029 if (!JSON_AddStringToObject(obj, CMD_TAG, CMD_GET_AUTH_INFO)) {
1030 AUTH_LOGE(AUTH_FSM, "add CMD_GET fail");
1031 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1032 }
1033 } else {
1034 if (!JSON_AddStringToObject(obj, CMD_TAG, CMD_RET_AUTH_INFO)) {
1035 AUTH_LOGE(AUTH_FSM, "add CMD_RET fail");
1036 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1037 }
1038 }
1039 #ifdef DISABLE_IDENTITY_SERVICE
1040 int32_t authVersion = AUTH_VERSION_INVALID;
1041 #else
1042 int32_t authVersion = AUTH_VERSION_VALUE;
1043 #endif
1044
1045 if (!JSON_AddInt32ToObject(obj, AUTH_START_STATE, info->localState) ||
1046 !JSON_AddInt32ToObject(obj, AUTH_VERSION_TAG, authVersion)) {
1047 AUTH_LOGE(AUTH_FSM, "add auth info fail.");
1048 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1049 }
1050 return SOFTBUS_OK;
1051 }
1052
IsNeedNormalizedProcess(AuthSessionInfo * info)1053 static bool IsNeedNormalizedProcess(AuthSessionInfo *info)
1054 {
1055 if (!info->isConnectServer || info->deviceKeyId.hasDeviceKeyId) {
1056 return true;
1057 }
1058 if (info->authVersion < AUTH_VERSION_V2) {
1059 AUTH_LOGI(AUTH_FSM, "lower version don't need check acl");
1060 return true;
1061 }
1062 if (IsTrustedDeviceFromAccess(info->accountHash, info->udid, info->userId)) {
1063 AUTH_LOGI(AUTH_FSM, "has trust device acl");
1064 return true;
1065 }
1066 char *anonyDeviceIdHash = NULL;
1067 Anonymize(info->udid, &anonyDeviceIdHash);
1068 AUTH_LOGE(AUTH_FSM, "device is not trusted in dp, deviceIdHash=%{public}s, userId=%{public}d",
1069 AnonymizeWrapper(anonyDeviceIdHash), info->userId);
1070 AnonymizeFree(anonyDeviceIdHash);
1071 info->normalizedType = NORMALIZED_KEY_ERROR;
1072 return false;
1073 }
1074
PackNormalizedData(const AuthSessionInfo * info,JsonObj * obj,const NodeInfo * nodeInfo,int64_t authSeq)1075 static int32_t PackNormalizedData(const AuthSessionInfo *info, JsonObj *obj, const NodeInfo *nodeInfo, int64_t authSeq)
1076 {
1077 bool isSupportNormalizedKey = IsSupportFeatureByCapaBit(nodeInfo->authCapacity, BIT_SUPPORT_NORMALIZED_LINK);
1078 if (!JSON_AddBoolToObject(obj, IS_NORMALIZED, isSupportNormalizedKey)) {
1079 AUTH_LOGE(AUTH_FSM, "add normalizedType fail");
1080 return SOFTBUS_AUTH_PACK_NORMALIZED_DATA_FAIL;
1081 }
1082 if (isSupportNormalizedKey && IsNeedNormalizedProcess((AuthSessionInfo *)info)) {
1083 PackNormalizedKey(obj, (AuthSessionInfo *)info, authSeq);
1084 }
1085 if (info->isServer &&
1086 (info->connInfo.type == AUTH_LINK_TYPE_WIFI || info->connInfo.type == AUTH_LINK_TYPE_SESSION_KEY ||
1087 info->connInfo.type == AUTH_LINK_TYPE_USB)) {
1088 GenerateUdidShortHash(info->udid, (char *)info->connInfo.info.ipInfo.deviceIdHash, UDID_HASH_LEN);
1089 char *anonyUdidHash = NULL;
1090 Anonymize((char *)info->connInfo.info.ipInfo.deviceIdHash, &anonyUdidHash);
1091 AUTH_LOGI(AUTH_FSM, "deviceIdHash is %{public}s", AnonymizeWrapper(anonyUdidHash));
1092 AnonymizeFree(anonyUdidHash);
1093 }
1094 return SOFTBUS_OK;
1095 }
1096
PackUserId(JsonObj * json,int32_t userId)1097 static void PackUserId(JsonObj *json, int32_t userId)
1098 {
1099 if (!JSON_AddInt32ToObject(json, USERID, userId)) {
1100 AUTH_LOGW(AUTH_FSM, "pack userId fail");
1101 }
1102 }
1103
PackAuthPreLinkNode(JsonObj * obj,const AuthSessionInfo * info)1104 static void PackAuthPreLinkNode(JsonObj *obj, const AuthSessionInfo *info)
1105 {
1106 AuthPreLinkNode node;
1107 (void)memset_s(&node, sizeof(AuthPreLinkNode), 0, sizeof(AuthPreLinkNode));
1108 if (FindAuthPreLinkNodeById(info->requestId, &node) == SOFTBUS_OK) {
1109 AUTH_LOGI(AUTH_FSM, "add prelink node info");
1110 if (!JSON_AddBoolToObject(obj, AUTH_PRELINK_NODE, true)) {
1111 AUTH_LOGE(AUTH_FSM, "add AUTH_PRELINK_NODE fail");
1112 }
1113 }
1114 }
1115
PackExternalAuthInfo(JsonObj * json)1116 static int32_t PackExternalAuthInfo(JsonObj *json)
1117 {
1118 char localUdidHash[SHA_256_HEX_HASH_LEN] = { 0 };
1119 uint8_t localAccountHash[SHA_256_HASH_LEN] = { 0 };
1120 char accountHexHash[SHA_256_HEX_HASH_LEN] = { 0 };
1121
1122 if (GetLocalUdidShortHash(localUdidHash) != SOFTBUS_OK) {
1123 AUTH_LOGE(AUTH_FSM, "get local udid short hash fail");
1124 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
1125 }
1126
1127 if (!JSON_AddStringToObject(json, UDID_SHORT_HASH, localUdidHash)) {
1128 AUTH_LOGE(AUTH_FSM, "pack udid hash fail");
1129 return SOFTBUS_CREATE_JSON_ERR;
1130 }
1131
1132 if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, localAccountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
1133 AUTH_LOGE(AUTH_FSM, "get local account hash fail");
1134 return SOFTBUS_NETWORK_GET_LOCAL_NODE_INFO_ERR;
1135 }
1136
1137 if (ConvertBytesToHexString(accountHexHash, SHA_256_HEX_HASH_LEN, localAccountHash, SHA_256_HASH_LEN) !=
1138 SOFTBUS_OK) {
1139 AUTH_LOGE(AUTH_FSM, "convert account hash fail");
1140 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
1141 }
1142
1143 if (!JSON_AddStringToObject(json, ACCOUNT_HASH, accountHexHash)) {
1144 AUTH_LOGE(AUTH_FSM, "pack account hash fail");
1145 return SOFTBUS_CREATE_JSON_ERR;
1146 }
1147
1148 return SOFTBUS_OK;
1149 }
1150
PackDeviceIdJson(const AuthSessionInfo * info,int64_t authSeq)1151 char *PackDeviceIdJson(const AuthSessionInfo *info, int64_t authSeq)
1152 {
1153 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, NULL, AUTH_FSM, "info is NULL");
1154 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", info->connInfo.type);
1155 JsonObj *obj = JSON_CreateObject();
1156 if (obj == NULL) {
1157 return NULL;
1158 }
1159 char uuid[UUID_BUF_LEN] = { 0 };
1160 char udid[UDID_BUF_LEN] = { 0 };
1161 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1162 if (LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) != SOFTBUS_OK ||
1163 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK ||
1164 LnnGetLocalStrInfo(STRING_KEY_NETWORKID, networkId, sizeof(networkId)) != SOFTBUS_OK) {
1165 AUTH_LOGE(AUTH_FSM, "get uuid/udid/networkId fail");
1166 JSON_Delete(obj);
1167 return NULL;
1168 }
1169 PackWifiSinglePassInfo(obj, info);
1170 if (PackDeviceJsonInfo(info, obj) != SOFTBUS_OK || !VerifySessionInfoIdType(info, obj, networkId, udid)) {
1171 JSON_Delete(obj);
1172 return NULL;
1173 }
1174 if (!JSON_AddStringToObject(obj, DATA_TAG, uuid) || !JSON_AddInt32ToObject(obj, DATA_BUF_SIZE_TAG, PACKET_SIZE) ||
1175 !JSON_AddInt32ToObject(obj, SOFTBUS_VERSION_TAG, info->version) ||
1176 !JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, info->idType) ||
1177 !JSON_AddInt32ToObject(obj, AUTH_MODULE, info->module)) {
1178 AUTH_LOGE(AUTH_FSM, "add msg body fail");
1179 JSON_Delete(obj);
1180 return NULL;
1181 }
1182 PackAuthPreLinkNode(obj, info);
1183 PackDeviceKeyId(obj, info);
1184 const NodeInfo *nodeInfo = LnnGetLocalNodeInfo();
1185 if (nodeInfo == NULL) {
1186 AUTH_LOGE(AUTH_FSM, "nodeInfo is null!");
1187 JSON_Delete(obj);
1188 return NULL;
1189 }
1190 PackCompressInfo(obj, nodeInfo);
1191 PackFastAuth(obj, (AuthSessionInfo *)info);
1192 PackUserId(obj, GetActiveOsAccountIds());
1193 if ((PackNormalizedData(info, obj, nodeInfo, authSeq) != SOFTBUS_OK) || (PackExternalAuthInfo(obj) != SOFTBUS_OK)) {
1194 JSON_Delete(obj);
1195 return NULL;
1196 }
1197 PackUDIDAbatementFlag(obj, info);
1198 char *msg = JSON_PrintUnformatted(obj);
1199 JSON_Delete(obj);
1200 return msg;
1201 }
1202
UnpackWifiSinglePassInfo(JsonObj * obj,AuthSessionInfo * info)1203 static bool UnpackWifiSinglePassInfo(JsonObj *obj, AuthSessionInfo *info)
1204 {
1205 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI && info->connInfo.type != AUTH_LINK_TYPE_USB) {
1206 AUTH_LOGD(AUTH_FSM, "isn't wifi or usb link, ignore");
1207 return true;
1208 }
1209 char devIpHash[SHA_256_HEX_HASH_LEN] = { 0 };
1210 if (!JSON_GetStringFromObject(obj, DEV_IP_HASH_TAG, devIpHash, SHA_256_HEX_HASH_LEN)) {
1211 AUTH_LOGD(AUTH_FSM, "devIpHash hash not found, ignore");
1212 return true;
1213 }
1214 // check devIpHash
1215 int32_t socketFd = GetFd(info->connId);
1216 SoftBusSockAddr addr = { 0 };
1217 SocketAddr socketAddr;
1218 int32_t rc = SoftBusSocketGetPeerName(socketFd, &addr);
1219 if (rc != SOFTBUS_OK) {
1220 AUTH_LOGE(AUTH_FSM, "GetPerrName fd=%{public}d, rc=%{public}d", socketFd, rc);
1221 return true;
1222 }
1223 (void)memset_s(&socketAddr, sizeof(socketAddr), 0, sizeof(socketAddr));
1224 const char* ret = NULL;
1225 if (addr.saFamily == SOFTBUS_AF_INET) {
1226 ret = SoftBusInetNtoP(addr.saFamily, (void *)&((SoftBusSockAddrIn *)&addr)->sinAddr,
1227 socketAddr.addr, sizeof(socketAddr.addr));
1228 } else if (addr.saFamily == SOFTBUS_AF_INET6) {
1229 ret = SoftBusInetNtoP(addr.saFamily, (void *)&((SoftBusSockAddrIn6 *)&addr)->sin6Addr,
1230 socketAddr.addr, sizeof(socketAddr.addr));
1231 }
1232 if (ret == NULL) {
1233 AUTH_LOGE(AUTH_FSM, "SoftBusInetNtoP error addr family %{public}hu", addr.saFamily);
1234 return true;
1235 }
1236 uint8_t hash[SHA_256_HASH_LEN] = { 0 };
1237 rc = SoftBusGenerateStrHash((const unsigned char *)socketAddr.addr, strlen(socketAddr.addr), hash);
1238 if (rc != SOFTBUS_OK) {
1239 AUTH_LOGE(AUTH_FSM, "generate hash failed rc=%{public}d", rc);
1240 return true;
1241 }
1242 char socketIpHash[SHA_256_HEX_HASH_LEN] = { 0 };
1243 if (ConvertBytesToUpperCaseHexString(socketIpHash, SHA_256_HEX_HASH_LEN, hash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
1244 return true;
1245 }
1246 if (strcmp(devIpHash, socketIpHash) == 0) {
1247 AUTH_LOGE(AUTH_FSM, "devIpHash is mismatch");
1248 return true;
1249 }
1250 return false;
1251 }
1252
SetCompressFlag(const char * compressCapa,bool * sessionSupportFlag)1253 static void SetCompressFlag(const char *compressCapa, bool *sessionSupportFlag)
1254 {
1255 const NodeInfo *node = LnnGetLocalNodeInfo();
1256 if (node == NULL) {
1257 return;
1258 }
1259 bool isRemoteSupportCompress = false;
1260 if (strncmp(compressCapa, TRUE_STRING_TAG, strlen(compressCapa)) == 0) {
1261 isRemoteSupportCompress = true;
1262 } else {
1263 isRemoteSupportCompress = false;
1264 }
1265 if (IsFeatureSupport(node->feature, BIT_INFO_COMPRESS) && isRemoteSupportCompress) {
1266 *sessionSupportFlag = true;
1267 AUTH_LOGI(AUTH_FSM, "local-remote all support deviceinfo compress");
1268 } else {
1269 *sessionSupportFlag = false;
1270 }
1271 }
1272
VerifyExchangeIdTypeAndInfo(AuthSessionInfo * info,int32_t idType,char * anonyUdid)1273 static int32_t VerifyExchangeIdTypeAndInfo(AuthSessionInfo *info, int32_t idType, char *anonyUdid)
1274 {
1275 char peerUdid[UDID_BUF_LEN] = { 0 };
1276 bool isExchangeUdid = true;
1277 if (idType == EXCHANGE_NETWORKID) {
1278 if (GetPeerUdidByNetworkId(info->udid, peerUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
1279 AUTH_LOGE(AUTH_FSM, "get peer udid fail, peer networkId=%{public}s", AnonymizeWrapper(anonyUdid));
1280 info->idType = EXCHANGE_FAIL;
1281 (void)memset_s(info->udid, sizeof(info->udid), 0, sizeof(info->udid));
1282 } else {
1283 if (GetIsExchangeUdidByNetworkId(info->udid, &isExchangeUdid) == SOFTBUS_OK && isExchangeUdid) {
1284 AUTH_LOGE(AUTH_FSM, "need exchange udid, peer udid=%{public}s", AnonymizeWrapper(anonyUdid));
1285 info->idType = EXCHANGE_UDID;
1286 } else {
1287 AUTH_LOGE(AUTH_FSM, "get peer udid success, peer udid=%{public}s", AnonymizeWrapper(anonyUdid));
1288 info->idType = EXCHANGE_NETWORKID;
1289 }
1290 if (memcpy_s(info->udid, UDID_BUF_LEN, peerUdid, UDID_BUF_LEN) != EOK) {
1291 AUTH_LOGE(AUTH_FSM, "copy peer udid fail");
1292 info->idType = EXCHANGE_FAIL;
1293 return SOFTBUS_MEM_ERR;
1294 }
1295 }
1296 }
1297 AUTH_LOGI(AUTH_FSM, "idType verify and get info succ.");
1298 return SOFTBUS_OK;
1299 }
1300
SetExchangeIdTypeAndValue(JsonObj * obj,AuthSessionInfo * info)1301 static int32_t SetExchangeIdTypeAndValue(JsonObj *obj, AuthSessionInfo *info)
1302 {
1303 if (obj == NULL || info == NULL) {
1304 AUTH_LOGE(AUTH_FSM, "param invalid");
1305 return SOFTBUS_INVALID_PARAM;
1306 }
1307
1308 int32_t idType = -1;
1309 if (!JSON_GetInt32FromOject(obj, EXCHANGE_ID_TYPE, &idType)) {
1310 AUTH_LOGI(AUTH_FSM, "parse idType failed, ignore");
1311 info->idType = EXCHANGE_UDID;
1312 return SOFTBUS_OK;
1313 }
1314 char *anonyUdid = NULL;
1315 Anonymize(info->udid, &anonyUdid);
1316 AUTH_LOGI(AUTH_FSM, "oldIdType=%{public}d, exchangeIdType=%{public}d, deviceId=%{public}s", info->idType, idType,
1317 AnonymizeWrapper(anonyUdid));
1318 if (idType == EXCHANGE_UDID) {
1319 info->idType = EXCHANGE_UDID;
1320 AnonymizeFree(anonyUdid);
1321 return SOFTBUS_OK;
1322 }
1323 if (info->isServer) {
1324 if (VerifyExchangeIdTypeAndInfo(info, idType, anonyUdid) != SOFTBUS_OK) {
1325 AnonymizeFree(anonyUdid);
1326 return SOFTBUS_AUTH_SET_EXCHANGE_INFO_FAIL;
1327 }
1328 AUTH_LOGI(AUTH_FSM, "isServer is true in authSessionInfo.");
1329 AnonymizeFree(anonyUdid);
1330 return SOFTBUS_OK;
1331 }
1332 if (info->idType == EXCHANGE_NETWORKID) {
1333 if (idType == EXCHANGE_FAIL) {
1334 info->idType = EXCHANGE_FAIL;
1335 }
1336 if (VerifyExchangeIdTypeAndInfo(info, idType, anonyUdid) != SOFTBUS_OK) {
1337 AnonymizeFree(anonyUdid);
1338 return SOFTBUS_AUTH_SET_EXCHANGE_INFO_FAIL;
1339 }
1340 }
1341 AnonymizeFree(anonyUdid);
1342 return SOFTBUS_OK;
1343 }
1344
UnPackVersionByDeviceId(JsonObj * obj,AuthSessionInfo * info)1345 static void UnPackVersionByDeviceId(JsonObj *obj, AuthSessionInfo *info)
1346 {
1347 int32_t maxBuffSize;
1348 OptString(obj, DEVICE_ID_TAG, info->udid, UDID_BUF_LEN, "");
1349 OptInt(obj, DATA_BUF_SIZE_TAG, &maxBuffSize, PACKET_SIZE);
1350
1351 if (strlen(info->udid) != 0) {
1352 info->version = SOFTBUS_OLD_V2;
1353 } else {
1354 info->version = SOFTBUS_OLD_V1;
1355 if (strcpy_s(info->udid, UDID_BUF_LEN, info->uuid) != EOK) {
1356 AUTH_LOGE(AUTH_FSM, "strcpy udid fail, ignore");
1357 }
1358 }
1359 if (!JSON_GetInt32FromOject(obj, SOFTBUS_VERSION_TAG, (int32_t *)&info->version)) {
1360 AUTH_LOGE(AUTH_FSM, "softbusVersion is not found");
1361 }
1362 OptInt(obj, AUTH_START_STATE, (int32_t *)&info->peerState, AUTH_STATE_COMPATIBLE);
1363 OptInt(obj, AUTH_VERSION_TAG, (int32_t *)&info->authVersion, AUTH_VERSION_INVALID);
1364 }
1365
IsCmdMatchByDeviceId(JsonObj * obj,AuthSessionInfo * info)1366 static int32_t IsCmdMatchByDeviceId(JsonObj *obj, AuthSessionInfo *info)
1367 {
1368 char cmd[CMD_TAG_LEN] = { 0 };
1369 if (!JSON_GetStringFromObject(obj, CMD_TAG, cmd, CMD_TAG_LEN)) {
1370 AUTH_LOGE(AUTH_FSM, "CMD_TAG not found");
1371 return SOFTBUS_NOT_FIND;
1372 }
1373 if (!UnpackWifiSinglePassInfo(obj, info)) {
1374 AUTH_LOGE(AUTH_FSM, "check ip fail, can't support auth");
1375 return SOFTBUS_PARSE_JSON_ERR;
1376 }
1377 if ((info->connInfo.type == AUTH_LINK_TYPE_WIFI || info->connInfo.type == AUTH_LINK_TYPE_SESSION_KEY ||
1378 info->connInfo.type == AUTH_LINK_TYPE_USB) &&
1379 info->isConnectServer) {
1380 if (strncmp(cmd, CMD_GET_AUTH_INFO, strlen(CMD_GET_AUTH_INFO)) != 0) {
1381 AUTH_LOGE(AUTH_FSM, "CMD_GET not match");
1382 return SOFTBUS_CMP_FAIL;
1383 }
1384 } else {
1385 if (strncmp(cmd, CMD_RET_AUTH_INFO, strlen(CMD_RET_AUTH_INFO)) != 0) {
1386 AUTH_LOGE(AUTH_FSM, "CMD_RET not match");
1387 return SOFTBUS_CMP_FAIL;
1388 }
1389 }
1390 return SOFTBUS_OK;
1391 }
1392
UnPackAuthPreLinkNode(JsonObj * obj,AuthSessionInfo * info)1393 static void UnPackAuthPreLinkNode(JsonObj *obj, AuthSessionInfo *info)
1394 {
1395 bool isPreLinkNode = false;
1396 (void)JSON_GetBoolFromOject(obj, AUTH_PRELINK_NODE, &isPreLinkNode);
1397 if (isPreLinkNode) {
1398 if (IsAuthPreLinkNodeExist(info->requestId)) {
1399 AUTH_LOGI(AUTH_FSM, "has prelink node");
1400 } else if (AddToAuthPreLinkList(info->requestId, GetFd(info->connId), NULL) != SOFTBUS_OK) {
1401 AUTH_LOGE(AUTH_FSM, "add auth pre link node fail");
1402 }
1403 }
1404 }
1405
UnpackDeviceIdJson(const char * msg,uint32_t len,AuthSessionInfo * info,int64_t authSeq)1406 int32_t UnpackDeviceIdJson(const char *msg, uint32_t len, AuthSessionInfo *info, int64_t authSeq)
1407 {
1408 AUTH_CHECK_AND_RETURN_RET_LOGE(msg != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "msg is NULL");
1409 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1410 JsonObj *obj = JSON_Parse(msg, len);
1411 if (obj == NULL) {
1412 AUTH_LOGE(AUTH_FSM, "json parse fail");
1413 return SOFTBUS_INVALID_PARAM;
1414 }
1415 int32_t ret = IsCmdMatchByDeviceId(obj, info);
1416 if (ret != SOFTBUS_OK) {
1417 JSON_Delete(obj);
1418 return ret;
1419 }
1420 if (!JSON_GetStringFromObject(obj, DATA_TAG, info->uuid, UUID_BUF_LEN)) {
1421 AUTH_LOGE(AUTH_FSM, "uuid not found");
1422 JSON_Delete(obj);
1423 return SOFTBUS_AUTH_UNPACK_DEV_ID_FAIL;
1424 }
1425 UnPackVersionByDeviceId(obj, info);
1426 if (SetExchangeIdTypeAndValue(obj, info) != SOFTBUS_OK) {
1427 AUTH_LOGE(AUTH_FSM, "set exchange id type or value fail");
1428 JSON_Delete(obj);
1429 return SOFTBUS_AUTH_SET_EXCHANGE_INFO_FAIL;
1430 }
1431 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI && info->connInfo.type != AUTH_LINK_TYPE_SESSION_KEY &&
1432 info->connInfo.type != AUTH_LINK_TYPE_USB) {
1433 char compressParse[PARSE_UNCOMPRESS_STRING_BUFF_LEN] = { 0 };
1434 OptString(obj, SUPPORT_INFO_COMPRESS, compressParse, PARSE_UNCOMPRESS_STRING_BUFF_LEN, FALSE_STRING_TAG);
1435 SetCompressFlag(compressParse, &info->isSupportCompress);
1436 }
1437 UnPackAuthPreLinkNode(obj, info);
1438 UnpackSKId(obj, info);
1439 OptInt(obj, AUTH_MODULE, (int32_t *)&info->module, AUTH_MODULE_LNN);
1440 bool isSupportNormalizedKey = false;
1441 OptBool(obj, IS_NORMALIZED, &isSupportNormalizedKey, false);
1442 UnpackFastAuth(obj, info);
1443 UnpackNormalizedKey(obj, info, isSupportNormalizedKey, authSeq);
1444 OptBool(obj, IS_NEED_PACK_CERT, &info->isNeedPackCert, false);
1445 UnpackExternalAuthInfo(obj, info);
1446 JSON_Delete(obj);
1447 return SOFTBUS_OK;
1448 }
1449
GetAndSetLocalUnifiedName(JsonObj * json)1450 static void GetAndSetLocalUnifiedName(JsonObj *json)
1451 {
1452 char unified[DEVICE_NAME_BUF_LEN] = { 0 };
1453 if (LnnGetUnifiedDeviceName(unified, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
1454 AUTH_LOGE(AUTH_FSM, "get defaultDeviceName fail");
1455 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, unified);
1456 return;
1457 }
1458 if (strlen(unified) != 0) {
1459 if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_NAME, unified) != SOFTBUS_OK) {
1460 AUTH_LOGE(AUTH_FSM, "set device unifiedDefaultName fail");
1461 }
1462 char *anonyUniFiedName = NULL;
1463 AnonymizeDeviceName(unified, &anonyUniFiedName);
1464 AUTH_LOGI(AUTH_FSM, "unifed length is not zero, unified=%{public}s", AnonymizeWrapper(anonyUniFiedName));
1465 AnonymizeFree(anonyUniFiedName);
1466 }
1467 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, unified);
1468 }
1469
PackCommonDevInfo(JsonObj * json,const NodeInfo * info,bool isMetaAuth)1470 static int32_t PackCommonDevInfo(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
1471 {
1472 char localDevName[DEVICE_NAME_BUF_LEN] = { 0 };
1473 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, localDevName, sizeof(localDevName));
1474 if (ret == SOFTBUS_OK) {
1475 (void)JSON_AddStringToObject(json, DEVICE_NAME, localDevName);
1476 } else {
1477 (void)JSON_AddStringToObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo));
1478 }
1479
1480 if (strlen(info->deviceInfo.unifiedName) == 0) {
1481 GetAndSetLocalUnifiedName(json);
1482 } else {
1483 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, info->deviceInfo.unifiedName);
1484 }
1485 (void)JSON_AddStringToObject(json, UNIFIED_DEFAULT_DEVICE_NAME, info->deviceInfo.unifiedDefaultName);
1486 (void)JSON_AddStringToObject(json, SETTINGS_NICK_NAME, info->deviceInfo.nickName);
1487 if (!JSON_AddStringToObject(json, NETWORK_ID, info->networkId) ||
1488 !JSON_AddStringToObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
1489 !JSON_AddStringToObject(json, DEVICE_UDID, LnnGetDeviceUdid(info)) ||
1490 !JSON_AddStringToObject(json, PRODUCT_ID, info->deviceInfo.productId) ||
1491 !JSON_AddStringToObject(json, MODEL_NAME, info->deviceInfo.modelName)) {
1492 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject fail");
1493 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1494 }
1495 if (isMetaAuth && !JSON_AddStringToObject(json, DEVICE_UUID, info->uuid)) {
1496 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject fail");
1497 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1498 }
1499 return SOFTBUS_OK;
1500 }
1501
PackCommonFastAuth(JsonObj * json,const NodeInfo * info)1502 static void PackCommonFastAuth(JsonObj *json, const NodeInfo *info)
1503 {
1504 (void)JSON_AddInt32ToObject(json, STATE_VERSION, info->stateVersion);
1505 char extData[EXTDATA_LEN] = { 0 };
1506 int32_t ret = GetExtData(extData, EXTDATA_LEN);
1507 if (ret != SOFTBUS_OK) {
1508 AUTH_LOGE(AUTH_FSM, "GetExtData fail");
1509 } else {
1510 AUTH_LOGI(AUTH_FSM, "GetExtData=%{public}s", extData);
1511 (void)JSON_AddStringToObject(json, EXTDATA, extData);
1512 }
1513 }
1514
PackOsInfo(JsonObj * json,const NodeInfo * info)1515 static void PackOsInfo(JsonObj *json, const NodeInfo *info)
1516 {
1517 (void)JSON_AddInt32ToObject(json, OS_TYPE, info->deviceInfo.osType);
1518 (void)JSON_AddStringToObject(json, OS_VERSION, info->deviceInfo.osVersion);
1519 }
1520
PackDeviceVersion(JsonObj * json,const NodeInfo * info)1521 static void PackDeviceVersion(JsonObj *json, const NodeInfo *info)
1522 {
1523 (void)JSON_AddStringToObject(json, DEVICE_VERSION, info->deviceInfo.deviceVersion);
1524 (void)JSON_AddInt32ToObject(json, STATE_VERSION_CHANGE_REASON, info->stateVersionReason);
1525 }
1526
PackCommP2pInfo(JsonObj * json,const NodeInfo * info)1527 static void PackCommP2pInfo(JsonObj *json, const NodeInfo *info)
1528 {
1529 (void)JSON_AddInt32ToObject(json, P2P_ROLE, LnnGetP2pRole(info));
1530 (void)JSON_AddStringToObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info));
1531 (void)JSON_AddStringToObject(json, HML_MAC, info->wifiDirectAddr);
1532
1533 (void)JSON_AddStringToObject(json, WIFI_CFG, info->p2pInfo.wifiCfg);
1534 (void)JSON_AddStringToObject(json, CHAN_LIST_5G, info->p2pInfo.chanList5g);
1535 (void)JSON_AddInt32ToObject(json, STA_FREQUENCY, LnnGetStaFrequency(info));
1536 }
1537
AuthPrintBase64Ptk(const char * ptk)1538 static void AuthPrintBase64Ptk(const char *ptk)
1539 {
1540 char *anonyPtk = NULL;
1541 Anonymize(ptk, &anonyPtk);
1542 AUTH_LOGD(AUTH_FSM, "base Ptk=%{public}s", AnonymizeWrapper(anonyPtk));
1543 AnonymizeFree(anonyPtk);
1544 }
1545
PackWifiDirectInfo(const AuthConnInfo * connInfo,JsonObj * json,const NodeInfo * info,const char * remoteUuid,bool isMetaAuth)1546 static void PackWifiDirectInfo(
1547 const AuthConnInfo *connInfo, JsonObj *json, const NodeInfo *info, const char *remoteUuid, bool isMetaAuth)
1548 {
1549 unsigned char encodePtk[PTK_ENCODE_LEN] = { 0 };
1550 char localPtk[PTK_DEFAULT_LEN] = { 0 };
1551 if (isMetaAuth || remoteUuid == NULL) {
1552 uint32_t connId;
1553 AuthMetaGetConnIdByInfoPacked(connInfo, &connId);
1554 if (LnnGetMetaPtkPacked(connId, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
1555 AUTH_LOGE(AUTH_FSM, "get meta ptk fail");
1556 return;
1557 }
1558 } else {
1559 if (LnnGetLocalPtkByUuidPacked(remoteUuid, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
1560 AUTH_LOGE(AUTH_FSM, "get ptk by uuid fail");
1561 return;
1562 }
1563 }
1564 LnnDumpRemotePtk(NULL, localPtk, "pack wifi direct info");
1565 size_t keyLen = 0;
1566 if (SoftBusBase64Encode(encodePtk, PTK_ENCODE_LEN, &keyLen, (unsigned char *)localPtk, PTK_DEFAULT_LEN) !=
1567 SOFTBUS_OK) {
1568 AUTH_LOGE(AUTH_FSM, "encode ptk fail");
1569 (void)memset_s(localPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
1570 return;
1571 }
1572 (void)memset_s(localPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
1573 AuthPrintBase64Ptk((const char *)encodePtk);
1574 if (!JSON_AddStringToObject(json, PTK, (char *)encodePtk)) {
1575 AUTH_LOGE(AUTH_FSM, "add ptk string to json fail");
1576 (void)memset_s(encodePtk, PTK_ENCODE_LEN, 0, PTK_ENCODE_LEN);
1577 return;
1578 }
1579 (void)memset_s(encodePtk, PTK_ENCODE_LEN, 0, PTK_ENCODE_LEN);
1580 if (!JSON_AddInt32ToObject(json, STATIC_CAP_LENGTH, info->staticCapLen)) {
1581 AUTH_LOGE(AUTH_FSM, "add static cap len fail");
1582 return;
1583 }
1584 char staticCap[STATIC_CAP_STR_LEN] = { 0 };
1585 if (ConvertBytesToHexString((char *)staticCap, STATIC_CAP_STR_LEN, info->staticCapability, info->staticCapLen) !=
1586 SOFTBUS_OK) {
1587 AUTH_LOGW(AUTH_FSM, "convert static cap fail");
1588 return;
1589 }
1590 if (!JSON_AddStringToObject(json, STATIC_CAP, (char *)staticCap)) {
1591 AUTH_LOGW(AUTH_FSM, "add static capability fail");
1592 return;
1593 }
1594 }
1595
FillBroadcastCipherKey(BroadcastCipherKey * broadcastKey,const NodeInfo * info)1596 static int32_t FillBroadcastCipherKey(BroadcastCipherKey *broadcastKey, const NodeInfo *info)
1597 {
1598 if (memcpy_s(broadcastKey->udid, UDID_BUF_LEN, info->deviceInfo.deviceUdid, UDID_BUF_LEN) != EOK) {
1599 AUTH_LOGE(AUTH_FSM, "memcpy udid fail.");
1600 return SOFTBUS_MEM_ERR;
1601 }
1602 if (memcpy_s(broadcastKey->cipherInfo.key, SESSION_KEY_LENGTH, info->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
1603 AUTH_LOGE(AUTH_FSM, "memcpy key fail.");
1604 return SOFTBUS_MEM_ERR;
1605 }
1606 if (memcpy_s(broadcastKey->cipherInfo.iv, BROADCAST_IV_LEN, info->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
1607 AUTH_LOGE(AUTH_FSM, "memcpy iv fail.");
1608 return SOFTBUS_MEM_ERR;
1609 }
1610 return SOFTBUS_OK;
1611 }
1612
DumpRpaCipherKey(char * cipherKey,char * cipherIv,const char * peerIrk,const char * log)1613 static void DumpRpaCipherKey(char *cipherKey, char *cipherIv, const char *peerIrk, const char *log)
1614 {
1615 char *anonyIrk = NULL;
1616 char *anonyCipherKey = NULL;
1617 char *anonyCipherIv = NULL;
1618 Anonymize(cipherKey, &anonyCipherKey);
1619 Anonymize(cipherIv, &anonyCipherIv);
1620 Anonymize(peerIrk, &anonyIrk);
1621 AUTH_LOGI(AUTH_FSM, "log=%{public}s, cipherKey=%{public}s, cipherIv=%{public}s, peerIrk=%{public}s", log,
1622 AnonymizeWrapper(anonyCipherKey), AnonymizeWrapper(anonyCipherIv), AnonymizeWrapper(anonyIrk));
1623 AnonymizeFree(anonyCipherKey);
1624 AnonymizeFree(anonyCipherIv);
1625 AnonymizeFree(anonyIrk);
1626 }
1627
UpdateBroadcastCipherKey(const NodeInfo * info)1628 static int32_t UpdateBroadcastCipherKey(const NodeInfo *info)
1629 {
1630 BroadcastCipherKey broadcastKey;
1631 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1632 if (FillBroadcastCipherKey(&broadcastKey, info) != SOFTBUS_OK) {
1633 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1634 return SOFTBUS_AUTH_CIPHER_KEY_PROC_ERR;
1635 }
1636 if (LnnUpdateLocalBroadcastCipherKeyPacked(&broadcastKey) != SOFTBUS_OK) {
1637 AUTH_LOGE(AUTH_FSM, "update local broadcast key failed");
1638 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1639 return SOFTBUS_AUTH_CIPHER_KEY_PROC_ERR;
1640 }
1641 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1642 return SOFTBUS_OK;
1643 }
1644
PackCipherRpaInfo(JsonObj * json,const NodeInfo * info)1645 static int32_t PackCipherRpaInfo(JsonObj *json, const NodeInfo *info)
1646 {
1647 char cipherKey[SESSION_KEY_STR_LEN] = { 0 };
1648 char cipherIv[BROADCAST_IV_STR_LEN] = { 0 };
1649 char peerIrk[LFINDER_IRK_STR_LEN] = { 0 };
1650 char pubMac[LFINDER_MAC_ADDR_STR_LEN] = { 0 };
1651
1652 if (ConvertBytesToHexString(cipherKey, SESSION_KEY_STR_LEN, info->cipherInfo.key, SESSION_KEY_LENGTH) !=
1653 SOFTBUS_OK) {
1654 AUTH_LOGE(AUTH_FSM, "convert cipher key to string fail.");
1655 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
1656 }
1657 if (ConvertBytesToHexString(cipherIv, BROADCAST_IV_STR_LEN, info->cipherInfo.iv, BROADCAST_IV_LEN) != SOFTBUS_OK) {
1658 AUTH_LOGE(AUTH_FSM, "convert cipher iv to string fail.");
1659 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1660 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
1661 }
1662 if (ConvertBytesToHexString(peerIrk, LFINDER_IRK_STR_LEN, info->rpaInfo.peerIrk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
1663 AUTH_LOGE(AUTH_FSM, "convert peerIrk to string fail.");
1664 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1665 (void)memset_s(cipherIv, BROADCAST_IV_STR_LEN, 0, BROADCAST_IV_STR_LEN);
1666 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
1667 }
1668 if (ConvertBytesToHexString(pubMac, LFINDER_MAC_ADDR_STR_LEN, info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN) !=
1669 SOFTBUS_OK) {
1670 AUTH_LOGE(AUTH_FSM, "convert publicAddress to string fail.");
1671 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1672 (void)memset_s(cipherIv, BROADCAST_IV_STR_LEN, 0, BROADCAST_IV_STR_LEN);
1673 (void)memset_s(peerIrk, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
1674 return SOFTBUS_NETWORK_BYTES_TO_HEX_STR_ERR;
1675 }
1676 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_KEY, cipherKey);
1677 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_IV, cipherIv);
1678 (void)JSON_AddStringToObject(json, IRK, peerIrk);
1679 (void)JSON_AddStringToObject(json, PUB_MAC, pubMac);
1680 DumpRpaCipherKey(cipherKey, cipherIv, peerIrk, "pack broadcast cipher key");
1681 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1682 (void)memset_s(cipherIv, BROADCAST_IV_STR_LEN, 0, BROADCAST_IV_STR_LEN);
1683 (void)memset_s(peerIrk, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
1684 int32_t ret = UpdateBroadcastCipherKey(info);
1685 if (ret != SOFTBUS_OK) {
1686 return ret;
1687 }
1688 return SOFTBUS_OK;
1689 }
1690
UnpackCipherRpaInfo(const JsonObj * json,NodeInfo * info)1691 static void UnpackCipherRpaInfo(const JsonObj *json, NodeInfo *info)
1692 {
1693 char cipherKey[SESSION_KEY_STR_LEN] = { 0 };
1694 char cipherIv[BROADCAST_IV_STR_LEN] = { 0 };
1695 char peerIrk[LFINDER_IRK_STR_LEN] = { 0 };
1696 char pubMac[LFINDER_MAC_ADDR_STR_LEN] = { 0 };
1697
1698 do {
1699 if (!JSON_GetStringFromObject(json, BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_STR_LEN) ||
1700 !JSON_GetStringFromObject(json, BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_STR_LEN) ||
1701 !JSON_GetStringFromObject(json, IRK, peerIrk, LFINDER_IRK_STR_LEN) ||
1702 !JSON_GetStringFromObject(json, PUB_MAC, pubMac, LFINDER_MAC_ADDR_STR_LEN)) {
1703 AUTH_LOGE(AUTH_FSM, "get json info fail.");
1704 break;
1705 }
1706 if (ConvertHexStringToBytes((unsigned char *)info->cipherInfo.key, SESSION_KEY_LENGTH, cipherKey,
1707 strlen(cipherKey)) != SOFTBUS_OK) {
1708 AUTH_LOGE(AUTH_FSM, "convert cipher key to bytes fail.");
1709 break;
1710 }
1711 if (ConvertHexStringToBytes(
1712 (unsigned char *)info->cipherInfo.iv, BROADCAST_IV_LEN, cipherIv, strlen(cipherIv)) != SOFTBUS_OK) {
1713 AUTH_LOGE(AUTH_FSM, "convert cipher iv to bytes fail.");
1714 break;
1715 }
1716 if (ConvertHexStringToBytes(
1717 (unsigned char *)info->rpaInfo.peerIrk, LFINDER_IRK_LEN, peerIrk, strlen(peerIrk)) != SOFTBUS_OK) {
1718 AUTH_LOGE(AUTH_FSM, "convert peerIrk to bytes fail.");
1719 break;
1720 }
1721 if (ConvertHexStringToBytes((unsigned char *)info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN, pubMac,
1722 strlen(pubMac)) != SOFTBUS_OK) {
1723 AUTH_LOGE(AUTH_FSM, "convert publicAddress to bytes fail.");
1724 break;
1725 }
1726 DumpRpaCipherKey(cipherKey, cipherIv, peerIrk, "unpack broadcast cipher key");
1727 } while (0);
1728 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1729 (void)memset_s(cipherIv, BROADCAST_IV_STR_LEN, 0, BROADCAST_IV_STR_LEN);
1730 (void)memset_s(peerIrk, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
1731 }
1732
PackNetCapacityByVersion(JsonObj * json,const NodeInfo * info,SoftBusVersion version)1733 static int32_t PackNetCapacityByVersion(JsonObj *json, const NodeInfo *info, SoftBusVersion version)
1734 {
1735 uint32_t netCapacity = 0;
1736 if (version == SOFTBUS_OLD_V1 || version == SOFTBUS_OLD_V2) {
1737 AUTH_LOGW(AUTH_FSM, "The bit cannot exceed 8 bits in old version");
1738 netCapacity = (uint16_t)(info->netCapacity) & 0xFF;
1739 } else {
1740 netCapacity = info->netCapacity;
1741 }
1742 AUTH_LOGI(AUTH_FSM, "pack device info version=%{public}d, netCapacity=%{public}d", version, netCapacity);
1743 if (!JSON_AddInt32ToObject(json, CONN_CAP, netCapacity)) {
1744 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
1745 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1746 }
1747 return SOFTBUS_OK;
1748 }
1749
PackCommonEx(JsonObj * json,const NodeInfo * info)1750 static int32_t PackCommonEx(JsonObj *json, const NodeInfo *info)
1751 {
1752 bool isFalse = (!JSON_AddStringToObject(json, VERSION_TYPE, info->versionType) ||
1753 !JSON_AddInt32ToObject(json, STATIC_NET_CAP, info->staticNetCap) ||
1754 !JSON_AddInt32ToObject(json, AUTH_CAP, info->authCapacity) ||
1755 !JSON_AddInt32ToObject(json, HB_CAP, info->heartbeatCapacity) ||
1756 !JSON_AddInt16ToObject(json, DATA_CHANGE_FLAG, info->dataChangeFlag) ||
1757 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1758 !JSON_AddBoolToObject(json, BLE_P2P, info->isBleP2p) ||
1759 !JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, (int64_t)LnnGetSupportedProtocols(info)) ||
1760 !JSON_AddBoolToObject(json, IS_SUPPORT_IPV6, true));
1761 if (isFalse) {
1762 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
1763 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1764 }
1765
1766 char btMacUpper[BT_MAC_LEN] = { 0 };
1767 if (StringToUpperCase(LnnGetBtMac(info), btMacUpper, BT_MAC_LEN) != SOFTBUS_OK) {
1768 AUTH_LOGE(AUTH_FSM, "btMac to upperCase failed.");
1769 if (memcpy_s(btMacUpper, BT_MAC_LEN, LnnGetBtMac(info), BT_MAC_LEN) != EOK) {
1770 AUTH_LOGE(AUTH_FSM, "btMac cpy failed.");
1771 return SOFTBUS_MEM_ERR;
1772 }
1773 }
1774 isFalse = (!JSON_AddStringToObject(json, PKG_VERSION, info->pkgVersion) ||
1775 !JSON_AddInt64ToObject(json, WIFI_VERSION, info->wifiVersion) ||
1776 !JSON_AddInt64ToObject(json, BLE_VERSION, info->bleVersion) ||
1777 !JSON_AddStringToObject(json, BT_MAC, btMacUpper) ||
1778 !JSON_AddStringToObject(json, BLE_MAC, info->connectInfo.bleMacAddr) ||
1779 !JSON_AddInt32ToObject(json, REMAIN_POWER, info->batteryInfo.batteryLevel) ||
1780 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1781 !JSON_AddBoolToObject(json, IS_SCREENON, info->isScreenOn) ||
1782 !JSON_AddInt32ToObject(json, NODE_WEIGHT, info->masterWeight) ||
1783 !JSON_AddInt64ToObject(json, ACCOUNT_ID, info->accountId) ||
1784 !JSON_AddStringToObject(json, ACCOUNT_UID, info->accountUid) ||
1785 !JSON_AddBoolToObject(json, DISTRIBUTED_SWITCH, true) ||
1786 !JSON_AddInt64ToObject(json, BLE_TIMESTAMP, info->bleStartTimestamp) ||
1787 !JSON_AddInt32ToObject(json, WIFI_BUFF_SIZE, info->wifiBuffSize) ||
1788 !JSON_AddInt32ToObject(json, BR_BUFF_SIZE, info->brBuffSize) ||
1789 !JSON_AddInt64ToObject(json, FEATURE, info->feature) ||
1790 !JSON_AddInt64ToObject(json, CONN_SUB_FEATURE, info->connSubFeature) ||
1791 !JSON_AddInt64ToObject(json, NEW_CONN_CAP, info->netCapacity) ||
1792 !JSON_AddInt32ToObject(json, SLE_RANGE_CAP, info->sleRangeCapacity) ||
1793 !JSON_AddStringToObject(json, SLE_MAC, info->connectInfo.sleMacAddr));
1794 if (isFalse) {
1795 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
1796 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1797 }
1798 AUTH_LOGI(AUTH_FSM, "pack common succ.");
1799 return SOFTBUS_OK;
1800 }
1801
PackCommon(JsonObj * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1802 static int32_t PackCommon(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1803 {
1804 if (version >= SOFTBUS_NEW_V1) {
1805 if (!JSON_AddStringToObject(json, MASTER_UDID, info->masterUdid) ||
1806 !JSON_AddInt32ToObject(json, MASTER_WEIGHT, info->masterWeight)) {
1807 AUTH_LOGE(AUTH_FSM, "add master node info fail");
1808 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1809 }
1810 if (!JSON_AddStringToObject(json, NODE_ADDR, info->nodeAddress)) {
1811 AUTH_LOGE(AUTH_FSM, "pack node address Fail");
1812 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1813 }
1814 }
1815 if (!JSON_AddStringToObject(json, SW_VERSION, info->softBusVersion)) {
1816 AUTH_LOGE(AUTH_FSM, "add version info fail");
1817 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1818 }
1819 if (PackCommonDevInfo(json, info, isMetaAuth) != SOFTBUS_OK) {
1820 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1821 }
1822 if (PackNetCapacityByVersion(json, info, version) != SOFTBUS_OK) {
1823 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1824 }
1825 if (PackCommonEx(json, info) != SOFTBUS_OK) {
1826 AUTH_LOGE(AUTH_FSM, "data pack failed.");
1827 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
1828 }
1829 PackOsInfo(json, info);
1830 PackDeviceVersion(json, info);
1831 PackCommonFastAuth(json, info);
1832 if (!PackCipherKeySyncMsgPacked(json)) {
1833 AUTH_LOGE(AUTH_FSM, "PackCipherKeySyncMsg failed.");
1834 }
1835 PackCommP2pInfo(json, info);
1836 if (PackCipherRpaInfo(json, info) != SOFTBUS_OK) {
1837 AUTH_LOGE(AUTH_FSM, "pack CipherRpaInfo of device key failed.");
1838 }
1839 if (!JSON_AddInt32ToObject(json, DEVICE_SECURITY_LEVEL, info->deviceSecurityLevel)) {
1840 AUTH_LOGE(AUTH_FSM, "pack deviceSecurityLevel fail.");
1841 }
1842 #ifdef DISABLE_IDENTITY_SERVICE
1843 int32_t authVersion = AUTH_VERSION_INVALID;
1844 #else
1845 int32_t authVersion = AUTH_VERSION_VALUE;
1846 #endif
1847 if (!JSON_AddInt32ToObject(json, AUTH_VERSION_TAG, authVersion)) {
1848 AUTH_LOGE(AUTH_FSM, "pack authVersion fail.");
1849 }
1850 return SOFTBUS_OK;
1851 }
1852
UnpackMetaPtk(char * remoteMetaPtk,char * decodePtk)1853 static void UnpackMetaPtk(char *remoteMetaPtk, char *decodePtk)
1854 {
1855 size_t len = 0;
1856 if (SoftBusBase64Decode((unsigned char *)remoteMetaPtk, PTK_DEFAULT_LEN, &len, (const unsigned char *)decodePtk,
1857 strlen((char *)decodePtk)) != SOFTBUS_OK) {
1858 AUTH_LOGE(AUTH_FSM, "decode remote meta ptk fail");
1859 return;
1860 }
1861 LnnDumpRemotePtk(NULL, remoteMetaPtk, "unpack meta wifi direct info");
1862 if (len != PTK_DEFAULT_LEN) {
1863 AUTH_LOGE(AUTH_FSM, "decode data len error");
1864 return;
1865 }
1866 return;
1867 }
1868
UnpackPtk(char * remotePtk,char * decodePtk)1869 static void UnpackPtk(char *remotePtk, char *decodePtk)
1870 {
1871 size_t len = 0;
1872 if (SoftBusBase64Decode((unsigned char *)remotePtk, PTK_DEFAULT_LEN, &len, (const unsigned char *)decodePtk,
1873 strlen((char *)decodePtk)) != SOFTBUS_OK) {
1874 AUTH_LOGE(AUTH_FSM, "decode remote ptk fail");
1875 return;
1876 }
1877 LnnDumpRemotePtk(NULL, remotePtk, "unpack wifi direct info");
1878 if (len != PTK_DEFAULT_LEN) {
1879 AUTH_LOGE(AUTH_FSM, "decode data len error");
1880 return;
1881 }
1882 return;
1883 }
1884
UnpackWifiDirectInfo(const JsonObj * json,NodeInfo * info,bool isMetaAuth)1885 static void UnpackWifiDirectInfo(const JsonObj *json, NodeInfo *info, bool isMetaAuth)
1886 {
1887 char staticCap[STATIC_CAP_STR_LEN] = { 0 };
1888 if (!JSON_GetInt32FromOject(json, STATIC_CAP_LENGTH, &info->staticCapLen)) {
1889 AUTH_LOGE(AUTH_FSM, "get static cap len fail");
1890 return;
1891 }
1892 if (!JSON_GetStringFromObject(json, STATIC_CAP, staticCap, STATIC_CAP_STR_LEN)) {
1893 AUTH_LOGE(AUTH_FSM, "get static cap fail");
1894 return;
1895 }
1896 if (ConvertHexStringToBytes(
1897 (unsigned char *)info->staticCapability, STATIC_CAP_LEN, staticCap, strlen(staticCap)) != SOFTBUS_OK) {
1898 AUTH_LOGE(AUTH_FSM, "convert static cap fail");
1899 return;
1900 }
1901 char encodePtk[PTK_ENCODE_LEN] = { 0 };
1902 if (!JSON_GetStringFromObject(json, PTK, encodePtk, PTK_ENCODE_LEN)) {
1903 AUTH_LOGE(AUTH_FSM, "get encode ptk fail");
1904 return;
1905 }
1906 AuthPrintBase64Ptk((const char *)encodePtk);
1907 if (isMetaAuth) {
1908 UnpackMetaPtk(info->remoteMetaPtk, encodePtk);
1909 } else {
1910 UnpackPtk(info->remotePtk, encodePtk);
1911 }
1912 (void)memset_s(encodePtk, PTK_ENCODE_LEN, 0, PTK_ENCODE_LEN);
1913 }
1914
ParseDeviceName(const JsonObj * json,NodeInfo * info)1915 static void ParseDeviceName(const JsonObj *json, NodeInfo *info)
1916 {
1917 OptString(json, UNIFIED_DEVICE_NAME, info->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, "");
1918 OptString(json, UNIFIED_DEFAULT_DEVICE_NAME, info->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, "");
1919 OptString(json, SETTINGS_NICK_NAME, info->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, "");
1920 (void)JSON_GetStringFromObject(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN);
1921 }
1922
ParseCommonJsonOptInfo(const JsonObj * json,NodeInfo * info)1923 static void ParseCommonJsonOptInfo(const JsonObj *json, NodeInfo *info)
1924 {
1925 OptInt(json, STATIC_NET_CAP, (int32_t *)&info->staticNetCap, DEFAULT_STATIC_NET_CAP);
1926 OptString(json, PKG_VERSION, info->pkgVersion, VERSION_MAX_LEN, "");
1927 OptInt64(json, WIFI_VERSION, &info->wifiVersion, 0);
1928 OptInt64(json, BLE_VERSION, &info->bleVersion, 0);
1929 OptString(json, BT_MAC, info->connectInfo.macAddr, MAC_LEN, "");
1930 OptString(json, BLE_MAC, info->connectInfo.bleMacAddr, MAC_LEN, "");
1931 OptBool(json, IS_SCREENON, &info->isScreenOn, false);
1932 OptInt64(json, ACCOUNT_ID, &info->accountId, 0);
1933 OptString(json, ACCOUNT_UID, info->accountUid, ACCOUNT_UID_STR_LEN, "");
1934 OptInt(json, NODE_WEIGHT, &info->masterWeight, DEFAULT_NODE_WEIGHT);
1935 OptInt(json, OS_TYPE, &info->deviceInfo.osType, -1);
1936 if ((info->deviceInfo.osType == -1) && info->authCapacity != 0) {
1937 info->deviceInfo.osType = OH_OS_TYPE;
1938 AUTH_LOGD(AUTH_FSM, "info->deviceInfo.osType=%{public}d", info->deviceInfo.osType);
1939 }
1940 OptString(json, OS_VERSION, info->deviceInfo.osVersion, OS_VERSION_BUF_LEN, "");
1941 OptString(json, DEVICE_VERSION, info->deviceInfo.deviceVersion, DEVICE_VERSION_SIZE_MAX, "");
1942 // IS_SUPPORT_TCP_HEARTBEAT
1943 OptInt(json, NEW_CONN_CAP, (int32_t *)&info->netCapacity, -1);
1944 if (info->netCapacity == (uint32_t)-1) {
1945 (void)JSON_GetInt32FromOject(json, CONN_CAP, (int32_t *)&info->netCapacity);
1946 }
1947 OptInt(json, WIFI_BUFF_SIZE, &info->wifiBuffSize, DEFAULT_WIFI_BUFF_SIZE);
1948 OptInt(json, BR_BUFF_SIZE, &info->wifiBuffSize, DEFAULT_BR_BUFF_SIZE);
1949 OptInt64(json, FEATURE, (int64_t *)&info->feature, 0);
1950 OptInt64(json, CONN_SUB_FEATURE, (int64_t *)&info->connSubFeature, 0);
1951 OptInt(json, STATE_VERSION_CHANGE_REASON, (int32_t *)&info->stateVersionReason, 0);
1952
1953 OptInt(json, SLE_RANGE_CAP, &info->sleRangeCapacity, 0);
1954 OptString(json, SLE_MAC, info->connectInfo.sleMacAddr, MAC_LEN, "");
1955 }
1956
ParseCommonJsonInfo(const JsonObj * json,NodeInfo * info,bool isMetaAuth)1957 static void ParseCommonJsonInfo(const JsonObj *json, NodeInfo *info, bool isMetaAuth)
1958 {
1959 ParseDeviceName(json, info);
1960 (void)JSON_GetStringFromObject(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN);
1961 char deviceType[DEVICE_TYPE_BUF_LEN] = { 0 };
1962 if (JSON_GetStringFromObject(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN)) {
1963 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
1964 }
1965 (void)JSON_GetStringFromObject(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN);
1966 (void)JSON_GetStringFromObject(json, PRODUCT_ID, info->deviceInfo.productId, PRODUCT_ID_SIZE_MAX);
1967 (void)JSON_GetStringFromObject(json, MODEL_NAME, info->deviceInfo.modelName, MODEL_NAME_SIZE_MAX);
1968 if (isMetaAuth) {
1969 (void)JSON_GetStringFromObject(json, DEVICE_UUID, info->uuid, UDID_BUF_LEN);
1970 }
1971 (void)JSON_GetStringFromObject(json, NETWORK_ID, info->networkId, NETWORK_ID_BUF_LEN);
1972 (void)JSON_GetStringFromObject(json, VERSION_TYPE, info->versionType, VERSION_MAX_LEN);
1973 (void)JSON_GetInt32FromOject(json, CONN_CAP, (int32_t *)&info->netCapacity);
1974 (void)JSON_GetInt32FromOject(json, AUTH_CAP, (int32_t *)&info->authCapacity);
1975 (void)JSON_GetInt32FromOject(json, HB_CAP, (int32_t *)&info->heartbeatCapacity);
1976 info->isBleP2p = false;
1977 (void)JSON_GetBoolFromOject(json, BLE_P2P, &info->isBleP2p);
1978 (void)JSON_GetInt16FromOject(json, DATA_CHANGE_FLAG, (int16_t *)&info->dataChangeFlag);
1979 (void)JSON_GetBoolFromOject(json, IS_CHARGING, &info->batteryInfo.isCharging);
1980 (void)JSON_GetInt32FromOject(json, REMAIN_POWER, &info->batteryInfo.batteryLevel);
1981 (void)JSON_GetBoolFromOject(json, IS_SUPPORT_IPV6, &info->isSupportIpv6);
1982 ParseCommonJsonOptInfo(json, info);
1983 }
1984
UnpackCommon(const JsonObj * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)1985 static void UnpackCommon(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1986 {
1987 if (version >= SOFTBUS_NEW_V1) {
1988 if (!JSON_GetStringFromObject(json, MASTER_UDID, info->masterUdid, UDID_BUF_LEN) ||
1989 !JSON_GetInt32FromOject(json, MASTER_WEIGHT, &info->masterWeight)) {
1990 AUTH_LOGE(AUTH_FSM, "get master node info fail");
1991 }
1992 AUTH_LOGE(AUTH_FSM, "get master weight=%{public}d", info->masterWeight);
1993 if (!JSON_GetStringFromObject(json, NODE_ADDR, info->nodeAddress, sizeof(info->nodeAddress))) {
1994 AUTH_LOGW(AUTH_FSM,
1995 "no node address packed. set to address NODE_ADDR_LOOPBACK. NODE_ADDR_LOOPBACK=%{public}s",
1996 NODE_ADDR_LOOPBACK);
1997 (void)strcpy_s(info->nodeAddress, sizeof(info->nodeAddress), NODE_ADDR_LOOPBACK);
1998 }
1999 }
2000 ParseCommonJsonInfo(json, info, isMetaAuth);
2001 // MetaNodeInfoOfEar
2002 OptString(json, EXTDATA, info->extData, EXTDATA_LEN, "");
2003 if (version == SOFTBUS_OLD_V1) {
2004 if (strcpy_s(info->networkId, NETWORK_ID_BUF_LEN, info->uuid) != EOK) {
2005 AUTH_LOGE(AUTH_FSM, "v1 version strcpy networkid fail");
2006 }
2007 }
2008 ProcessCipherKeySyncInfoPacked(json, info->deviceInfo.deviceUdid);
2009
2010 // unpack p2p info
2011 OptInt(json, P2P_ROLE, &info->p2pInfo.p2pRole, -1);
2012 OptString(json, WIFI_CFG, info->p2pInfo.wifiCfg, WIFI_CFG_INFO_MAX_LEN, "");
2013 OptString(json, CHAN_LIST_5G, info->p2pInfo.chanList5g, CHANNEL_LIST_STR_LEN, "");
2014 OptInt(json, STA_FREQUENCY, &info->p2pInfo.staFrequency, -1);
2015 OptString(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN, "");
2016 OptString(json, HML_MAC, info->wifiDirectAddr, MAC_LEN, "");
2017
2018 UnpackCipherRpaInfo(json, info);
2019 OptInt(json, DEVICE_SECURITY_LEVEL, &info->deviceSecurityLevel, 0);
2020 }
2021
GetBtDiscTypeString(const NodeInfo * info,char * buf,uint32_t len)2022 static int32_t GetBtDiscTypeString(const NodeInfo *info, char *buf, uint32_t len)
2023 {
2024 uint32_t i = 0;
2025 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)) {
2026 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_INVALID_NUM);
2027 buf[i++] = DISCOVERY_TYPE_BLE + '0';
2028 }
2029 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
2030 if (i != 0) {
2031 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_INVALID_NUM);
2032 buf[i++] = ',';
2033 }
2034 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_INVALID_NUM);
2035 buf[i++] = DISCOVERY_TYPE_BR + '0';
2036 }
2037 return SOFTBUS_OK;
2038 }
2039
AddDiscoveryType(JsonObj * json,const char * remoteUuid)2040 static void AddDiscoveryType(JsonObj *json, const char *remoteUuid)
2041 {
2042 if (remoteUuid == NULL) {
2043 return;
2044 }
2045 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
2046 if (LnnGetNetworkIdByUuid(remoteUuid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
2047 AUTH_LOGE(AUTH_FSM, "networkId not found by uuid, maybe first online");
2048 return;
2049 }
2050 uint32_t discoveryType = 0;
2051 if (LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, (int32_t *)&discoveryType) != SOFTBUS_OK) {
2052 AUTH_LOGE(AUTH_FSM, "get discoveryType fail");
2053 return;
2054 }
2055 NodeInfo nodeInfo; // only for discType calc
2056 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
2057 nodeInfo.discoveryType = discoveryType;
2058 char discTypeStr[BT_DISC_TYPE_MAX_LEN] = { 0 };
2059 if (GetBtDiscTypeString(&nodeInfo, discTypeStr, BT_DISC_TYPE_MAX_LEN) != SOFTBUS_OK) {
2060 AUTH_LOGE(AUTH_FSM, "disc Type calc fail");
2061 return;
2062 }
2063 AUTH_LOGD(AUTH_FSM, "discTypeStr=%{public}s", discTypeStr);
2064 JSON_AddStringToObject(json, DISCOVERY_TYPE, discTypeStr);
2065 }
2066
PackBt(JsonObj * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth,const char * remoteUuid)2067 static int32_t PackBt(
2068 JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth, const char *remoteUuid)
2069 {
2070 if (!JSON_AddInt32ToObject(json, CODE, CODE_VERIFY_BT)) {
2071 AUTH_LOGE(AUTH_FSM, "add bt info fail");
2072 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2073 }
2074 AddDiscoveryType(json, remoteUuid);
2075 int32_t delayTime = BLE_CONNECTION_CLOSE_DELAY;
2076 if (SoftbusGetConfig(SOFTBUS_INT_CONN_BLE_CLOSE_DELAY_TIME, (unsigned char *)(&delayTime), sizeof(delayTime)) !=
2077 SOFTBUS_OK) {
2078 AUTH_LOGI(AUTH_FSM, "get ble conn close delay time from config file fail");
2079 }
2080 int32_t bleMacRefreshSwitch = BLE_MAC_AUTO_REFRESH_SWITCH;
2081 if (SoftbusGetConfig(SOFTBUS_INT_BLE_MAC_AUTO_REFRESH_SWITCH, (unsigned char *)(&bleMacRefreshSwitch),
2082 sizeof(bleMacRefreshSwitch)) != SOFTBUS_OK) {
2083 AUTH_LOGI(AUTH_FSM, "get ble mac refresh switch from config file fail");
2084 }
2085 if (!JSON_AddInt32ToObject(json, BLE_CONN_CLOSE_DELAY_TIME, delayTime) ||
2086 !JSON_AddInt32ToObject(json, BLE_MAC_REFRESH_SWITCH, bleMacRefreshSwitch)) {
2087 AUTH_LOGI(AUTH_FSM, "add ble conn close delay time or refresh switch fail");
2088 }
2089 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
2090 AUTH_LOGE(AUTH_FSM, "PackCommon fail");
2091 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2092 }
2093 return SOFTBUS_OK;
2094 }
2095
SetDiscType(uint32_t * discType,const char * discStr)2096 static int32_t SetDiscType(uint32_t *discType, const char *discStr)
2097 {
2098 if (strcmp(discStr, DEFAULT_BT_DISC_TYPE_STR) == 0) {
2099 AUTH_LOGE(AUTH_FSM, "disc type can't parse");
2100 return SOFTBUS_INVALID_PARAM;
2101 }
2102 return SOFTBUS_OK;
2103 }
2104
UnpackBt(const JsonObj * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth)2105 static int32_t UnpackBt(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
2106 {
2107 char discTypeStr[BT_DISC_TYPE_MAX_LEN] = { 0 };
2108 if (!JSON_GetInt64FromOject(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
2109 info->supportedProtocols = LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE;
2110 }
2111 OptString(json, DISCOVERY_TYPE, discTypeStr, BT_DISC_TYPE_MAX_LEN, DEFAULT_BT_DISC_TYPE_STR);
2112 (void)SetDiscType(&info->discoveryType, discTypeStr);
2113 OptInt64(json, BLE_TIMESTAMP, &info->bleStartTimestamp, DEFAULT_BLE_TIMESTAMP);
2114 OptInt(json, STATE_VERSION, &info->stateVersion, 0);
2115 OptInt(json, BLE_CONN_CLOSE_DELAY_TIME, &info->bleConnCloseDelayTime, BLE_CONNECTION_CLOSE_DELAY);
2116 OptInt(json, BLE_MAC_REFRESH_SWITCH, &info->bleMacRefreshSwitch, BLE_MAC_AUTO_REFRESH_SWITCH);
2117 UnpackCommon(json, info, version, isMetaAuth);
2118 return SOFTBUS_OK;
2119 }
2120
PackWiFi(JsonObj * json,const NodeInfo * info,SoftBusVersion version,bool isMetaAuth,int32_t ifnameIdx)2121 static int32_t PackWiFi(
2122 JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth, int32_t ifnameIdx)
2123 {
2124 AUTH_LOGD(AUTH_FSM, "devIp=%{public}zu", strlen(info->connectInfo.ifInfo[ifnameIdx].deviceIp));
2125 if (!JSON_AddInt32ToObject(json, CODE, CODE_VERIFY_IP) || !JSON_AddInt32ToObject(json, BUS_MAX_VERSION, BUS_V2) ||
2126 !JSON_AddInt32ToObject(json, BUS_MIN_VERSION, BUS_V1) ||
2127 !JSON_AddInt32ToObject(json, AUTH_PORT, LnnGetAuthPort(info, ifnameIdx)) ||
2128 !JSON_AddInt32ToObject(json, SESSION_PORT, LnnGetSessionPort(info, ifnameIdx)) ||
2129 !JSON_AddInt32ToObject(json, PROXY_PORT, LnnGetProxyPort(info, ifnameIdx)) ||
2130 !JSON_AddStringToObject(json, DEV_IP, info->connectInfo.ifInfo[ifnameIdx].deviceIp)) {
2131 AUTH_LOGE(AUTH_FSM, "add wifi info fail");
2132 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2133 }
2134 char offlineCode[BASE64_OFFLINE_CODE_LEN] = { 0 };
2135 size_t len = 0;
2136 AUTH_LOGE(AUTH_FSM, "offlineCodeLen=%{public}zu, offlineCodeSize=%{public}zu", strlen(offlineCode),
2137 sizeof(info->offlineCode));
2138 int32_t ret = SoftBusBase64Encode((unsigned char *)offlineCode, BASE64_OFFLINE_CODE_LEN, &len,
2139 (unsigned char *)info->offlineCode, sizeof(info->offlineCode));
2140 if (ret != 0) {
2141 AUTH_LOGE(AUTH_FSM, "mbedtls base64 encode failed");
2142 return SOFTBUS_ENCRYPT_ERR;
2143 }
2144 (void)JSON_AddStringToObject(json, BLE_OFFLINE_CODE, offlineCode);
2145 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
2146 AUTH_LOGE(AUTH_FSM, "PackCommon fail");
2147 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2148 }
2149 return SOFTBUS_OK;
2150 }
2151
CheckBusVersion(const JsonObj * json)2152 static int32_t CheckBusVersion(const JsonObj *json)
2153 {
2154 int32_t maxVersion;
2155 int32_t minVersion;
2156 OptInt(json, BUS_MAX_VERSION, &maxVersion, -1);
2157 OptInt(json, BUS_MIN_VERSION, &minVersion, -1);
2158 if (maxVersion > BUS_V2) {
2159 maxVersion = BUS_V2;
2160 }
2161 if (minVersion < BUS_V1) {
2162 minVersion = BUS_V1;
2163 }
2164 if (maxVersion < 0 || maxVersion < minVersion) {
2165 AUTH_LOGE(AUTH_FSM, "no common version");
2166 return SOFTBUS_INVALID_NUM;
2167 }
2168 return maxVersion;
2169 }
2170
UnpackWiFi(const JsonObj * json,NodeInfo * info,SoftBusVersion version,bool isMetaAuth,int32_t ifnameIdx)2171 static int32_t UnpackWiFi(
2172 const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth, int32_t ifnameIdx)
2173 {
2174 if (CheckBusVersion(json) < 0) {
2175 return SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL;
2176 }
2177 (void)JSON_GetInt32FromOject(json, AUTH_PORT, &info->connectInfo.ifInfo[ifnameIdx].authPort);
2178 (void)JSON_GetInt32FromOject(json, SESSION_PORT, &info->connectInfo.ifInfo[ifnameIdx].sessionPort);
2179 (void)JSON_GetInt32FromOject(json, PROXY_PORT, &info->connectInfo.ifInfo[ifnameIdx].proxyPort);
2180 if (!JSON_GetInt64FromOject(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
2181 info->supportedProtocols = LNN_PROTOCOL_IP;
2182 }
2183 char offlineCode[BASE64_OFFLINE_CODE_LEN] = { 0 };
2184 OptString(json, DEV_IP, info->connectInfo.ifInfo[ifnameIdx].deviceIp, MAX_ADDR_LEN, ""); // check ip available
2185 OptString(json, BLE_OFFLINE_CODE, offlineCode, BASE64_OFFLINE_CODE_LEN, "");
2186 size_t len;
2187 if (SoftBusBase64Decode(info->offlineCode, OFFLINE_CODE_BYTE_SIZE, &len, (const unsigned char *)offlineCode,
2188 strlen(offlineCode)) != 0) {
2189 AUTH_LOGE(AUTH_FSM, "base64Decode fail");
2190 }
2191 if (len != OFFLINE_CODE_BYTE_SIZE) {
2192 AUTH_LOGE(AUTH_FSM, "base64Decode data err");
2193 }
2194 UnpackCommon(json, info, version, isMetaAuth);
2195 return SOFTBUS_OK;
2196 }
2197
PackDeviceInfoMac(JsonObj * json,const NodeInfo * info,bool isMetaAuth)2198 static int32_t PackDeviceInfoMac(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
2199 {
2200 AUTH_LOGI(AUTH_FSM, "pack deviceInfo mac");
2201 if (!JSON_AddStringToObject(json, BR_MAC_ADDR, LnnGetBtMac(info)) ||
2202 !JSON_AddStringToObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info)) ||
2203 !JSON_AddStringToObject(json, BT_MAC, info->connectInfo.macAddr) ||
2204 !JSON_AddStringToObject(json, HML_MAC, info->wifiDirectAddr)) {
2205 AUTH_LOGE(AUTH_FSM, "add mac info fail");
2206 return SOFTBUS_AUTH_REG_DATA_FAIL;
2207 }
2208 return SOFTBUS_OK;
2209 }
2210
PackDeviceBaseInfo(JsonObj * json,const NodeInfo * info,bool isMetaAuth)2211 static int32_t PackDeviceBaseInfo(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
2212 {
2213 if (!JSON_AddStringToObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
2214 !JSON_AddStringToObject(json, DEVICE_VERSION_TYPE, info->versionType) ||
2215 !JSON_AddStringToObject(json, UUID, info->uuid) ||
2216 !JSON_AddStringToObject(json, SW_VERSION, info->softBusVersion) ||
2217 !JSON_AddStringToObject(json, DEVICE_UDID, info->deviceInfo.deviceUdid) ||
2218 !JSON_AddInt64ToObject(json, WIFI_VERSION, info->wifiVersion) ||
2219 !JSON_AddInt64ToObject(json, BLE_VERSION, info->bleVersion) ||
2220 !JSON_AddInt64ToObject(json, CONN_CAP, info->netCapacity) ||
2221 !JSON_AddInt64ToObject(json, NEW_CONN_CAP, info->netCapacity) ||
2222 !JSON_AddInt32ToObject(json, REMAIN_POWER, info->batteryInfo.batteryLevel) ||
2223 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
2224 !JSON_AddBoolToObject(json, IS_SCREENON, info->isScreenOn) ||
2225 !JSON_AddInt32ToObject(json, P2P_ROLE, info->p2pInfo.p2pRole) ||
2226 !JSON_AddInt64ToObject(json, ACCOUNT_ID, info->accountId) ||
2227 !JSON_AddInt32ToObject(json, NODE_WEIGHT, info->masterWeight) ||
2228 !JSON_AddStringToObject(json, PRODUCT_ID, info->deviceInfo.productId) ||
2229 !JSON_AddStringToObject(json, MODEL_NAME, info->deviceInfo.modelName) ||
2230 !JSON_AddInt32ToObject(json, STATE_VERSION_CHANGE_REASON, info->stateVersionReason)) {
2231 AUTH_LOGE(AUTH_FSM, "add wifi info fail");
2232 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2233 }
2234 return SOFTBUS_OK;
2235 }
2236
PackDeviceInfoBtV1(JsonObj * json,const NodeInfo * info,bool isMetaAuth)2237 static int32_t PackDeviceInfoBtV1(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
2238 {
2239 AUTH_LOGI(AUTH_FSM, "pack deviceInfo bt-v1");
2240 if (PackDeviceInfoMac(json, info, isMetaAuth) != SOFTBUS_OK) {
2241 AUTH_LOGI(AUTH_FSM, "add packdevice mac info fail ");
2242 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2243 }
2244 char localDevName[DEVICE_NAME_BUF_LEN] = { 0 };
2245 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, localDevName, sizeof(localDevName));
2246 if (ret == SOFTBUS_OK) {
2247 (void)JSON_AddStringToObject(json, DEVICE_NAME, localDevName);
2248 } else {
2249 (void)JSON_AddStringToObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo));
2250 }
2251 if (PackDeviceBaseInfo(json, info, isMetaAuth) != SOFTBUS_OK) {
2252 AUTH_LOGE(AUTH_FSM, "add packdevice wifi info fail");
2253 return SOFTBUS_AUTH_PACK_DEVINFO_FAIL;
2254 }
2255 return SOFTBUS_OK;
2256 }
2257
UnpackDeviceInfoBtV1(const JsonObj * json,NodeInfo * info)2258 static int32_t UnpackDeviceInfoBtV1(const JsonObj *json, NodeInfo *info)
2259 {
2260 char deviceType[DEVICE_TYPE_BUF_LEN] = { 0 };
2261 if (!JSON_GetStringFromObject(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN) ||
2262 !JSON_GetStringFromObject(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN) ||
2263 !JSON_GetStringFromObject(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN) ||
2264 !JSON_GetStringFromObject(json, UUID, info->uuid, UUID_BUF_LEN) ||
2265 !JSON_GetStringFromObject(json, BR_MAC_ADDR, info->connectInfo.macAddr, MAC_LEN)) {
2266 AUTH_LOGE(AUTH_FSM, "parse devinfo fail, invalid msg");
2267 return SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL;
2268 }
2269 OptString(json, PRODUCT_ID, info->deviceInfo.productId, PRODUCT_ID_SIZE_MAX, "");
2270 OptString(json, MODEL_NAME, info->deviceInfo.modelName, MODEL_NAME_SIZE_MAX, "");
2271 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
2272 OptString(json, HML_MAC, info->wifiDirectAddr, MAC_LEN, "");
2273 OptString(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN, "");
2274 OptString(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN, "");
2275 OptString(json, DEVICE_VERSION_TYPE, info->versionType, VERSION_MAX_LEN, "");
2276 OptInt64(json, WIFI_VERSION, &info->wifiVersion, 0);
2277 OptInt64(json, BLE_VERSION, &info->bleVersion, 0);
2278 OptInt(json, REMAIN_POWER, &info->batteryInfo.batteryLevel, DEFAULT_BATTERY_LEVEL);
2279 OptBool(json, IS_CHARGING, &info->batteryInfo.isCharging, false);
2280 OptBool(json, IS_SCREENON, &info->isScreenOn, false);
2281 OptInt(json, P2P_ROLE, &info->p2pInfo.p2pRole, 0);
2282 OptInt64(json, ACCOUNT_ID, &info->accountId, 0);
2283 OptInt(json, NODE_WEIGHT, &info->masterWeight, DEFAULT_NODE_WEIGHT);
2284 OptInt64(json, FEATURE, (int64_t *)&info->feature, 0);
2285 OptInt(json, STATE_VERSION_CHANGE_REASON, (int32_t *)&info->stateVersionReason, 0);
2286 OptInt64(json, NEW_CONN_CAP, (int64_t *)&info->netCapacity, -1);
2287 if (info->netCapacity == (uint32_t)-1) {
2288 OptInt64(json, CONN_CAP, (int64_t *)&info->netCapacity, 0);
2289 }
2290 if (strcpy_s(info->networkId, NETWORK_ID_BUF_LEN, info->uuid) != EOK) {
2291 AUTH_LOGE(AUTH_FSM, "strcpy networkId fail");
2292 return SOFTBUS_STRCPY_ERR;
2293 }
2294 return SOFTBUS_OK;
2295 }
2296
PackCertificateInfo(JsonObj * json,const AuthSessionInfo * info)2297 static int32_t PackCertificateInfo(JsonObj *json, const AuthSessionInfo *info)
2298 {
2299 if (info == NULL || !IsSupportUDIDAbatementPacked() || !info->isNeedPackCert) {
2300 AUTH_LOGI(AUTH_FSM, "device not support udid abatement or no need");
2301 return SOFTBUS_OK;
2302 }
2303 AuthGenCertNode *authGenCertNodePtr = NULL;
2304 SoftbusCertChain *softbusCertChainPtr = NULL;
2305 SoftbusCertChain softbusCertChain;
2306 if (FindAndWaitAuthGenCertParaNodeById(info->requestId, &authGenCertNodePtr) == SOFTBUS_OK) {
2307 AUTH_LOGI(AUTH_FSM, "use parallel gen cert.");
2308 softbusCertChainPtr = authGenCertNodePtr->softbusCertChain;
2309 } else {
2310 (void)memset_s(&softbusCertChain, sizeof(SoftbusCertChain), 0, sizeof(SoftbusCertChain));
2311 if (GenerateCertificatePacked(&softbusCertChain, info) != SOFTBUS_OK) {
2312 AUTH_LOGW(AUTH_FSM, "GenerateCertificate fail");
2313 return SOFTBUS_OK;
2314 }
2315 softbusCertChainPtr = &softbusCertChain;
2316 }
2317 if (!JSON_AddBytesToObject(json, ATTEST_CERTS, softbusCertChainPtr->cert[ATTEST_CERTS_INDEX].data,
2318 softbusCertChainPtr->cert[ATTEST_CERTS_INDEX].size) ||
2319 !JSON_AddBytesToObject(json, DEVICE_CERTS, softbusCertChainPtr->cert[DEVICE_CERTS_INDEX].data,
2320 softbusCertChainPtr->cert[DEVICE_CERTS_INDEX].size) ||
2321 !JSON_AddBytesToObject(json, MANUFACTURE_CERTS, softbusCertChainPtr->cert[MANUFACTURE_CERTS_INDEX].data,
2322 softbusCertChainPtr->cert[MANUFACTURE_CERTS_INDEX].size) ||
2323 !JSON_AddBytesToObject(json, ROOT_CERTS, softbusCertChainPtr->cert[ROOT_CERTS_INDEX].data,
2324 softbusCertChainPtr->cert[ROOT_CERTS_INDEX].size)) {
2325 FreeSoftbusChainPacked(softbusCertChainPtr);
2326 AUTH_LOGE(AUTH_FSM, "pack certChain fail.");
2327 return SOFTBUS_AUTH_INNER_ERR;
2328 }
2329 if (authGenCertNodePtr != NULL) {
2330 DelAuthGenCertParaNodeById(info->requestId);
2331 } else {
2332 FreeSoftbusChainPacked(softbusCertChainPtr);
2333 }
2334 return SOFTBUS_OK;
2335 }
2336
UnpackCertificateInfo(JsonObj * json,NodeInfo * nodeInfo,const AuthSessionInfo * info)2337 static int32_t UnpackCertificateInfo(JsonObj *json, NodeInfo *nodeInfo, const AuthSessionInfo *info)
2338 {
2339 if (info == NULL || !IsSupportUDIDAbatementPacked() || !IsNeedUDIDAbatementPacked(info)) {
2340 AUTH_LOGI(AUTH_FSM, "device not support udid abatement or no need");
2341 return SOFTBUS_OK;
2342 }
2343 SoftbusCertChain softbusCertChain;
2344 (void)memset_s(&softbusCertChain, sizeof(SoftbusCertChain), 0, sizeof(SoftbusCertChain));
2345 if (InitSoftbusChainPacked(&softbusCertChain) != SOFTBUS_OK) {
2346 AUTH_LOGW(AUTH_FSM, "malloc fail.");
2347 return SOFTBUS_OK;
2348 }
2349 if (!JSON_GetBytesFromObject(json, ATTEST_CERTS, softbusCertChain.cert[ATTEST_CERTS_INDEX].data,
2350 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[ATTEST_CERTS_INDEX].size) ||
2351 !JSON_GetBytesFromObject(json, DEVICE_CERTS, softbusCertChain.cert[DEVICE_CERTS_INDEX].data,
2352 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[DEVICE_CERTS_INDEX].size) ||
2353 !JSON_GetBytesFromObject(json, MANUFACTURE_CERTS, softbusCertChain.cert[MANUFACTURE_CERTS_INDEX].data,
2354 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[MANUFACTURE_CERTS_INDEX].size) ||
2355 !JSON_GetBytesFromObject(json, ROOT_CERTS, softbusCertChain.cert[ROOT_CERTS_INDEX].data,
2356 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[ROOT_CERTS_INDEX].size)) {
2357 FreeSoftbusChainPacked(&softbusCertChain);
2358 nodeInfo->deviceSecurityLevel = 0;
2359 AUTH_LOGE(AUTH_FSM, "unpack certChain fail.");
2360 return SOFTBUS_OK;
2361 }
2362 if (VerifyCertificatePacked(&softbusCertChain, nodeInfo, info) != SOFTBUS_OK) {
2363 AUTH_LOGE(AUTH_FSM, "attest cert fail.");
2364 FreeSoftbusChainPacked(&softbusCertChain);
2365 return SOFTBUS_AUTH_ATTEST_CERT_FAIL;
2366 }
2367 FreeSoftbusChainPacked(&softbusCertChain);
2368 return SOFTBUS_OK;
2369 }
2370
UpdateLocalNetBrMac(void)2371 static void UpdateLocalNetBrMac(void)
2372 {
2373 NodeInfo info;
2374 if (memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo)) != EOK) {
2375 AUTH_LOGE(AUTH_FSM, "memset_s fail");
2376 return;
2377 }
2378 if (LnnGetLocalNodeInfoSafe(&info) != SOFTBUS_OK) {
2379 AUTH_LOGE(AUTH_FSM, "get local node info fail");
2380 return;
2381 }
2382 const char *brMacTemp = LnnGetBtMac(&info);
2383 int32_t lenBrMac = strlen(brMacTemp);
2384 if ((lenBrMac == 0 || (strncmp(brMacTemp, INVALID_BR_MAC_ADDR, BT_MAC_LEN) == 0)) &&
2385 SoftBusGetBtState() == BLE_ENABLE) {
2386 char brMac[BT_MAC_LEN] = { 0 };
2387 SoftBusBtAddr mac = { 0 };
2388 int32_t ret = SoftBusGetBtMacAddr(&mac);
2389 if (ret != SOFTBUS_OK) {
2390 AUTH_LOGE(AUTH_FSM, "get bt mac addr fail, do not update local brmac");
2391 return;
2392 }
2393 ret = ConvertBtMacToStr(brMac, BT_MAC_LEN, mac.addr, sizeof(mac.addr));
2394 if (ret != SOFTBUS_OK || strlen(brMac) == 0) {
2395 AUTH_LOGE(AUTH_FSM, "convert bt mac to str fail, do not update local brmac");
2396 return;
2397 }
2398 if (LnnSetLocalStrInfo(STRING_KEY_BT_MAC, brMac) != SOFTBUS_OK) {
2399 AUTH_LOGE(AUTH_FSM, "set local brmac fail, do not update local brmac");
2400 return;
2401 }
2402 char *anonyMac = NULL;
2403 Anonymize(brMac, &anonyMac);
2404 AUTH_LOGI(AUTH_FSM, "update local brmac=%{public}s", AnonymizeWrapper(anonyMac));
2405 AnonymizeFree(anonyMac);
2406 }
2407 }
2408
2409 #define USERID_CHECKSUM_HEXSTRING_LEN 9
PackUserIdCheckSum(JsonObj * json,const NodeInfo * nodeInfo)2410 static int32_t PackUserIdCheckSum(JsonObj *json, const NodeInfo *nodeInfo)
2411 {
2412 if (!JSON_AddInt32ToObject(json, USERID, GetActiveOsAccountIds())) {
2413 AUTH_LOGW(AUTH_FSM, "pack userId fail");
2414 }
2415 char userIdCheckSumHexStr[USERID_CHECKSUM_HEXSTRING_LEN] = { 0 };
2416 int32_t ret = ConvertBytesToHexString(userIdCheckSumHexStr, USERID_CHECKSUM_HEXSTRING_LEN, nodeInfo->userIdCheckSum,
2417 sizeof(nodeInfo->userIdCheckSum));
2418 if (ret != SOFTBUS_OK) {
2419 AUTH_LOGE(AUTH_FSM, "ConvertBytesToHexString failed.");
2420 return ret;
2421 }
2422 if (!JSON_AddStringToObject(json, USERID_CHECKSUM, userIdCheckSumHexStr)) {
2423 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
2424 return SOFTBUS_CREATE_JSON_ERR;
2425 }
2426 return SOFTBUS_OK;
2427 }
2428
PackDeviceInfoMessage(const AuthConnInfo * connInfo,SoftBusVersion version,bool isMetaAuth,const char * remoteUuid,const AuthSessionInfo * info)2429 char *PackDeviceInfoMessage(const AuthConnInfo *connInfo, SoftBusVersion version, bool isMetaAuth,
2430 const char *remoteUuid, const AuthSessionInfo *info)
2431 {
2432 // uuid and info is null in meta, no need check param
2433 if (connInfo == NULL) {
2434 AUTH_LOGE(AUTH_FSM, "conninfo is null");
2435 return NULL;
2436 }
2437 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", connInfo->type);
2438 UpdateLocalNetBrMac();
2439 const NodeInfo *nodeInfo = LnnGetLocalNodeInfo();
2440 if (nodeInfo == NULL) {
2441 AUTH_LOGE(AUTH_FSM, "local info is null");
2442 return NULL;
2443 }
2444 JsonObj *json = JSON_CreateObject();
2445 if (json == NULL) {
2446 AUTH_LOGE(AUTH_FSM, "create cjson fail");
2447 return NULL;
2448 }
2449 int32_t ret;
2450 if (connInfo->type == AUTH_LINK_TYPE_WIFI || connInfo->type == AUTH_LINK_TYPE_SESSION_KEY ||
2451 connInfo->type == AUTH_LINK_TYPE_USB) {
2452 int32_t ifIdx = (connInfo->type == AUTH_LINK_TYPE_USB) ? USB_IF : WLAN_IF;
2453 ret = PackWiFi(json, nodeInfo, version, isMetaAuth, ifIdx);
2454 } else if (version == SOFTBUS_OLD_V1) {
2455 ret = PackDeviceInfoBtV1(json, nodeInfo, isMetaAuth);
2456 } else {
2457 ret = PackBt(json, nodeInfo, version, isMetaAuth, remoteUuid);
2458 }
2459 if (ret != SOFTBUS_OK) {
2460 JSON_Delete(json);
2461 return NULL;
2462 }
2463 PackWifiDirectInfo(connInfo, json, nodeInfo, remoteUuid, isMetaAuth);
2464
2465 if (PackCertificateInfo(json, info) != SOFTBUS_OK) {
2466 AUTH_LOGE(AUTH_FSM, "packCertificateInfo fail");
2467 JSON_Delete(json);
2468 return NULL;
2469 }
2470 ret = PackUserIdCheckSum(json, nodeInfo);
2471 if (ret != SOFTBUS_OK) {
2472 JSON_Delete(json);
2473 return NULL;
2474 }
2475 char *msg = JSON_PrintUnformatted(json);
2476 if (msg == NULL) {
2477 AUTH_LOGE(AUTH_FSM, "JSON_PrintUnformatted fail");
2478 }
2479 JSON_Delete(json);
2480 return msg;
2481 }
2482
UpdatePeerDeviceName(NodeInfo * peerNodeInfo)2483 static void UpdatePeerDeviceName(NodeInfo *peerNodeInfo)
2484 {
2485 const NodeInfo *localInfo = LnnGetLocalNodeInfo();
2486 if (localInfo == NULL) {
2487 AUTH_LOGE(AUTH_FSM, "localInfo is null");
2488 return;
2489 }
2490 int32_t ret = EOK;
2491 char deviceName[DEVICE_NAME_BUF_LEN] = { 0 };
2492 if (strlen(peerNodeInfo->deviceInfo.unifiedName) != 0 &&
2493 strcmp(peerNodeInfo->deviceInfo.unifiedName, peerNodeInfo->deviceInfo.unifiedDefaultName) != 0) {
2494 ret = strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedName);
2495 } else if (strlen(peerNodeInfo->deviceInfo.nickName) == 0 || localInfo->accountId == peerNodeInfo->accountId) {
2496 ret = strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedDefaultName);
2497 } else {
2498 LnnGetDeviceDisplayName(peerNodeInfo->deviceInfo.nickName, peerNodeInfo->deviceInfo.unifiedDefaultName,
2499 deviceName, DEVICE_NAME_BUF_LEN);
2500 }
2501 char *anonyDeviceName = NULL;
2502 AnonymizeDeviceName(deviceName, &anonyDeviceName);
2503 char *anonyPeerDeviceName = NULL;
2504 AnonymizeDeviceName(peerNodeInfo->deviceInfo.deviceName, &anonyPeerDeviceName);
2505 char *anonyUnifiedName = NULL;
2506 Anonymize(peerNodeInfo->deviceInfo.unifiedName, &anonyUnifiedName);
2507 char *anonyUnifiedDefaultName = NULL;
2508 Anonymize(peerNodeInfo->deviceInfo.unifiedDefaultName, &anonyUnifiedDefaultName);
2509 char *anonyNickName = NULL;
2510 Anonymize(peerNodeInfo->deviceInfo.nickName, &anonyNickName);
2511 AUTH_LOGD(AUTH_FSM,
2512 "peer tmpDeviceName=%{public}s, deviceName=%{public}s, unifiedName=%{public}s, "
2513 "unifiedDefaultName=%{public}s, nickName=%{public}s",
2514 AnonymizeWrapper(anonyDeviceName), AnonymizeWrapper(anonyPeerDeviceName), AnonymizeWrapper(anonyUnifiedName),
2515 AnonymizeWrapper(anonyUnifiedDefaultName), AnonymizeWrapper(anonyNickName));
2516 AnonymizeFree(anonyDeviceName);
2517 AnonymizeFree(anonyPeerDeviceName);
2518 AnonymizeFree(anonyUnifiedName);
2519 AnonymizeFree(anonyUnifiedDefaultName);
2520 AnonymizeFree(anonyNickName);
2521 if (strlen(deviceName) != 0) {
2522 ret = strcpy_s(peerNodeInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, deviceName);
2523 }
2524 if (ret != EOK) {
2525 AUTH_LOGW(AUTH_FSM, "strcpy_s fail, use default name");
2526 }
2527 }
2528
UnpackUserIdCheckSum(JsonObj * json,NodeInfo * nodeInfo)2529 static void UnpackUserIdCheckSum(JsonObj *json, NodeInfo *nodeInfo)
2530 {
2531 char userIdCheckSumHexStr[USERID_CHECKSUM_HEXSTRING_LEN] = { 0 };
2532 OptInt(json, USERID, &nodeInfo->userId, 0);
2533 if (!JSON_GetStringFromObject(json, USERID_CHECKSUM, userIdCheckSumHexStr, sizeof(userIdCheckSumHexStr))) {
2534 AUTH_LOGE(AUTH_FSM, "JSON_GetStringFromObject failed!");
2535 return;
2536 }
2537 int32_t ret = ConvertHexStringToBytes(
2538 nodeInfo->userIdCheckSum, USERID_CHECKSUM_LEN, userIdCheckSumHexStr, strlen(userIdCheckSumHexStr));
2539 if (ret != SOFTBUS_OK) {
2540 AUTH_LOGE(AUTH_FSM, "ConvertHexStringToBytes failed! ret:%{public}d", ret);
2541 }
2542 }
2543
UnpackDeviceInfoMsgInner(const JsonObj * json,const DevInfoData * devInfo,NodeInfo * nodeInfo,bool isMetaAuth)2544 static int32_t UnpackDeviceInfoMsgInner(
2545 const JsonObj *json, const DevInfoData *devInfo, NodeInfo *nodeInfo, bool isMetaAuth)
2546 {
2547 int32_t ret;
2548 if (devInfo->linkType == AUTH_LINK_TYPE_WIFI || devInfo->linkType == AUTH_LINK_TYPE_SESSION_KEY ||
2549 devInfo->linkType == AUTH_LINK_TYPE_USB) {
2550 int32_t ifIdx = (devInfo->linkType == AUTH_LINK_TYPE_USB) ? USB_IF : WLAN_IF;
2551 ret = UnpackWiFi(json, nodeInfo, devInfo->version, isMetaAuth, ifIdx);
2552 } else if (devInfo->version == SOFTBUS_OLD_V1) {
2553 ret = UnpackDeviceInfoBtV1(json, nodeInfo);
2554 } else {
2555 ret = UnpackBt(json, nodeInfo, devInfo->version, isMetaAuth);
2556 }
2557 return ret;
2558 }
2559
IsInvalidExternalAuthInfo(JsonObj * obj,NodeInfo * nodeInfo,const AuthSessionInfo * info)2560 static bool IsInvalidExternalAuthInfo(JsonObj *obj, NodeInfo *nodeInfo, const AuthSessionInfo *info)
2561 {
2562 char udidHash[SHA_256_HEX_HASH_LEN] = { 0 };
2563 char accountHash[SHA_256_HEX_HASH_LEN] = { 0 };
2564 if (!GenerateUdidShortHash(nodeInfo->deviceInfo.deviceUdid, udidHash, SHA_256_HEX_HASH_LEN)) {
2565 AUTH_LOGE(AUTH_FSM, "get local udid hash fail");
2566 return false;
2567 }
2568 if (strcmp(udidHash, info->udidShortHash) != 0) {
2569 AUTH_LOGE(AUTH_FSM, "udidHash change!");
2570 return true;
2571 }
2572 if (GenerateAccountHash(nodeInfo->accountId, accountHash, SHA_256_HEX_HASH_LEN) != SOFTBUS_OK) {
2573 AUTH_LOGE(AUTH_FSM, "gen accountHash fail");
2574 return false;
2575 }
2576 if (strcmp(accountHash, info->accountHash) != 0) {
2577 AUTH_LOGE(AUTH_FSM, "accountHash change!");
2578 return true;
2579 }
2580 return false;
2581 }
2582
IsInvalidDeviceInfo(JsonObj * obj,NodeInfo * nodeInfo,const AuthSessionInfo * info)2583 static bool IsInvalidDeviceInfo(JsonObj *obj, NodeInfo *nodeInfo, const AuthSessionInfo *info)
2584 {
2585 if (obj == NULL || nodeInfo == NULL || info == NULL) {
2586 AUTH_LOGE(AUTH_FSM, "param err!");
2587 return false;
2588 }
2589 if (StrCmpIgnoreCase(info->udid, nodeInfo->deviceInfo.deviceUdid) != 0) {
2590 AUTH_LOGE(AUTH_FSM, "verify udid fail");
2591 return true;
2592 }
2593 int32_t authVersion = 0;
2594 if (!JSON_GetInt32FromOject(obj, AUTH_VERSION_TAG, (int32_t *)&authVersion)) {
2595 AUTH_LOGW(AUTH_FSM, "peer not send authVersion.");
2596 return false;
2597 }
2598 AUTH_LOGI(AUTH_FSM, "authVersion new=%{public}d, old=%{public}d", authVersion, info->authVersion);
2599 if (authVersion != (int32_t)info->authVersion) {
2600 AUTH_LOGE(AUTH_FSM, "authVersion change!");
2601 return true;
2602 }
2603 if (authVersion >= AUTH_VERSION_V2 && IsInvalidExternalAuthInfo(obj, nodeInfo, info)) {
2604 AUTH_LOGE(AUTH_FSM, "is invalid ExternalAuthInfo!");
2605 return true;
2606 }
2607 return false;
2608 }
2609
UnpackDeviceInfoMessage(const DevInfoData * devInfo,NodeInfo * nodeInfo,bool isMetaAuth,const AuthSessionInfo * info)2610 int32_t UnpackDeviceInfoMessage(
2611 const DevInfoData *devInfo, NodeInfo *nodeInfo, bool isMetaAuth, const AuthSessionInfo *info)
2612 {
2613 AUTH_CHECK_AND_RETURN_RET_LOGE(devInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "devInfo is NULL");
2614 AUTH_CHECK_AND_RETURN_RET_LOGE(nodeInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "nodeInfo is NULL");
2615 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", devInfo->linkType);
2616 JsonObj *json = JSON_Parse(devInfo->msg, devInfo->len);
2617 if (json == NULL) {
2618 AUTH_LOGE(AUTH_FSM, "parse cjson fail");
2619 return SOFTBUS_PARSE_JSON_ERR;
2620 }
2621 int32_t ret;
2622 int32_t target = 0;
2623 ret = UnpackDeviceInfoMsgInner(json, devInfo, nodeInfo, isMetaAuth);
2624 UnpackWifiDirectInfo(json, nodeInfo, isMetaAuth);
2625 nodeInfo->isSupportSv = false;
2626 if (JSON_GetInt32FromOject(json, STATE_VERSION, &target)) {
2627 nodeInfo->isSupportSv = true;
2628 }
2629 if (UnpackCertificateInfo(json, nodeInfo, info) != SOFTBUS_OK) {
2630 JSON_Delete(json);
2631 return SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL;
2632 }
2633 UnpackUserIdCheckSum(json, nodeInfo);
2634 if (IsInvalidDeviceInfo(json, nodeInfo, info)) {
2635 JSON_Delete(json);
2636 return SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL;
2637 }
2638 JSON_Delete(json);
2639 if ((info != NULL) && (nodeInfo->userId != 0) && (nodeInfo->userId != info->userId)) {
2640 AUTH_LOGE(AUTH_FSM, "deviceIdUserId=%{public}d, deviceInfoUserId=%{public}d", info->userId, nodeInfo->userId);
2641 return SOFTBUS_AUTH_UNPACK_DEVINFO_FAIL;
2642 }
2643 int32_t stateVersion;
2644 if (LnnGetLocalNumInfo(NUM_KEY_STATE_VERSION, &stateVersion) == SOFTBUS_OK) {
2645 nodeInfo->localStateVersion = stateVersion;
2646 }
2647 if (IsFeatureSupport(nodeInfo->feature, BIT_SUPPORT_UNIFORM_NAME_CAPABILITY) &&
2648 nodeInfo->deviceInfo.osType != OH_OS_TYPE) {
2649 UpdatePeerDeviceName(nodeInfo);
2650 }
2651 nodeInfo->updateTimestamp = SoftBusGetSysTimeMs();
2652 return ret;
2653 }
2654