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