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