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 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", AnonymizeWrapper(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",
767 info->idType, AnonymizeWrapper(anonyNetworkId));
768 AnonymizeFree(anonyNetworkId);
769 } else {
770 if (!JSON_AddStringToObject(obj, DEVICE_ID_TAG, udid)) {
771 AUTH_LOGE(AUTH_FSM, "add msg body fail");
772 return false;
773 }
774 char *anonyUdid = NULL;
775 Anonymize(udid, &anonyUdid);
776 AUTH_LOGI(AUTH_FSM, "exchangeIdType=%{public}d, udid=%{public}s",
777 info->idType, AnonymizeWrapper(anonyUdid));
778 AnonymizeFree(anonyUdid);
779 }
780
781 AUTH_LOGI(AUTH_FSM, "session info verify succ.");
782 return true;
783 }
784
PackUDIDAbatementFlag(JsonObj *obj, const AuthSessionInfo *info)785 static void PackUDIDAbatementFlag(JsonObj *obj, const AuthSessionInfo *info)
786 {
787 if (IsSupportUDIDAbatement() && !JSON_AddBoolToObject(obj, IS_NEED_PACK_CERT, IsNeedUDIDAbatement(info))) {
788 AUTH_LOGE(AUTH_FSM, "add pack cert flag fail.");
789 }
790 }
791
PackDeviceJsonInfo(const AuthSessionInfo *info, JsonObj *obj)792 static int32_t PackDeviceJsonInfo(const AuthSessionInfo *info, JsonObj *obj)
793 {
794 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI && !info->isConnectServer) {
795 if (!JSON_AddStringToObject(obj, CMD_TAG, CMD_GET_AUTH_INFO)) {
796 AUTH_LOGE(AUTH_FSM, "add CMD_GET fail");
797 return SOFTBUS_ERR;
798 }
799 } else {
800 if (!JSON_AddStringToObject(obj, CMD_TAG, CMD_RET_AUTH_INFO)) {
801 AUTH_LOGE(AUTH_FSM, "add CMD_RET fail");
802 return SOFTBUS_ERR;
803 }
804 }
805 if (!JSON_AddInt32ToObject(obj, AUTH_START_STATE, info->localState)) {
806 AUTH_LOGE(AUTH_FSM, "add local auth state fail.");
807 return SOFTBUS_ERR;
808 }
809 return SOFTBUS_OK;
810 }
811
PackNormalizedData(const AuthSessionInfo *info, JsonObj *obj, const NodeInfo *nodeInfo)812 static int32_t PackNormalizedData(const AuthSessionInfo *info, JsonObj *obj, const NodeInfo *nodeInfo)
813 {
814 bool isSupportNormalizedKey = IsSupportFeatureByCapaBit(nodeInfo->authCapacity, BIT_SUPPORT_NORMALIZED_LINK);
815 if (!JSON_AddBoolToObject(obj, IS_NORMALIZED, isSupportNormalizedKey)) {
816 AUTH_LOGE(AUTH_FSM, "add normalizedType fail");
817 return SOFTBUS_ERR;
818 }
819 if (isSupportNormalizedKey) {
820 PackNormalizedKey(obj, (AuthSessionInfo *)info);
821 }
822 if (info->isServer && info->connInfo.type == AUTH_LINK_TYPE_WIFI) {
823 GenerateUdidShortHash(info->udid, (char *)info->connInfo.info.ipInfo.deviceIdHash, UDID_HASH_LEN);
824 }
825 return SOFTBUS_OK;
826 }
827
PackDeviceIdJson(const AuthSessionInfo *info)828 char *PackDeviceIdJson(const AuthSessionInfo *info)
829 {
830 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, NULL, AUTH_FSM, "info is NULL");
831 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", info->connInfo.type);
832 JsonObj *obj = JSON_CreateObject();
833 if (obj == NULL) {
834 return NULL;
835 }
836 char uuid[UUID_BUF_LEN] = {0};
837 char udid[UDID_BUF_LEN] = {0};
838 char networkId[NETWORK_ID_BUF_LEN] = {0};
839 if (LnnGetLocalStrInfo(STRING_KEY_UUID, uuid, UUID_BUF_LEN) != SOFTBUS_OK ||
840 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, udid, UDID_BUF_LEN) != SOFTBUS_OK ||
841 LnnGetLocalStrInfo(STRING_KEY_NETWORKID, networkId, sizeof(networkId)) != SOFTBUS_OK) {
842 AUTH_LOGE(AUTH_FSM, "get uuid/udid/networkId fail");
843 JSON_Delete(obj);
844 return NULL;
845 }
846 PackWifiSinglePassInfo(obj, info);
847 if (PackDeviceJsonInfo(info, obj) != SOFTBUS_OK ||
848 !VerifySessionInfoIdType(info, obj, networkId, udid)) {
849 JSON_Delete(obj);
850 return NULL;
851 }
852 if (!JSON_AddStringToObject(obj, DATA_TAG, uuid) || !JSON_AddInt32ToObject(obj, DATA_BUF_SIZE_TAG, PACKET_SIZE) ||
853 !JSON_AddInt32ToObject(obj, SOFTBUS_VERSION_TAG, info->version) ||
854 !JSON_AddInt32ToObject(obj, EXCHANGE_ID_TYPE, info->idType) ||
855 !JSON_AddInt32ToObject(obj, AUTH_MODULE, info->module)) {
856 AUTH_LOGE(AUTH_FSM, "add msg body fail");
857 JSON_Delete(obj);
858 return NULL;
859 }
860 const NodeInfo *nodeInfo = LnnGetLocalNodeInfo();
861 if (nodeInfo == NULL) {
862 AUTH_LOGE(AUTH_FSM, "nodeInfo is null!");
863 JSON_Delete(obj);
864 return NULL;
865 }
866 PackCompressInfo(obj, nodeInfo);
867 PackFastAuth(obj, (AuthSessionInfo *)info);
868 if (PackNormalizedData(info, obj, nodeInfo) != SOFTBUS_OK) {
869 JSON_Delete(obj);
870 return NULL;
871 }
872 PackUDIDAbatementFlag(obj, info);
873 char *msg = JSON_PrintUnformatted(obj);
874 JSON_Delete(obj);
875 return msg;
876 }
877
UnpackWifiSinglePassInfo(JsonObj *obj, AuthSessionInfo *info)878 static bool UnpackWifiSinglePassInfo(JsonObj *obj, AuthSessionInfo *info)
879 {
880 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI) {
881 AUTH_LOGD(AUTH_FSM, "isn't wifi link, ignore");
882 return true;
883 }
884 char devIpHash[SHA_256_HEX_HASH_LEN] = {0};
885 if (!JSON_GetStringFromOject(obj, DEV_IP_HASH_TAG, devIpHash, SHA_256_HEX_HASH_LEN)) {
886 AUTH_LOGD(AUTH_FSM, "devIpHash hash not found, ignore");
887 return true;
888 }
889 // check devIpHash
890 int32_t socketFd = GetFd(info->connId);
891 SoftBusSockAddrIn addr = {0};
892 SocketAddr socketAddr;
893 int32_t rc = SoftBusSocketGetPeerName(socketFd, (SoftBusSockAddr *)&addr);
894 if (rc != SOFTBUS_OK) {
895 AUTH_LOGE(AUTH_FSM, "GetPerrName fd=%{public}d, rc=%{public}d", socketFd, rc);
896 return true;
897 }
898 (void)memset_s(&socketAddr, sizeof(socketAddr), 0, sizeof(socketAddr));
899 if (SoftBusInetNtoP(SOFTBUS_AF_INET, (void *)&addr.sinAddr, socketAddr.addr, sizeof(socketAddr.addr)) == NULL) {
900 AUTH_LOGE(AUTH_FSM, "GetPerrName fd=%{public}d, rc=%{public}d", socketFd, rc);
901 return true;
902 }
903 uint8_t hash[SHA_256_HASH_LEN] = {0};
904 rc = SoftBusGenerateStrHash((const unsigned char *)socketAddr.addr, strlen(socketAddr.addr), hash);
905 if (rc != SOFTBUS_OK) {
906 AUTH_LOGE(AUTH_FSM, "generate hash failed rc=%{public}d", rc);
907 return true;
908 }
909 char socketIpHash[SHA_256_HEX_HASH_LEN] = { 0 };
910 if (ConvertBytesToUpperCaseHexString(socketIpHash, SHA_256_HEX_HASH_LEN, hash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
911 return true;
912 }
913 if (strcmp(devIpHash, socketIpHash) == 0) {
914 AUTH_LOGE(AUTH_FSM, "devIpHash is mismatch");
915 return true;
916 }
917 return false;
918 }
919
SetCompressFlag(const char *compressCapa, bool *sessionSupportFlag)920 static void SetCompressFlag(const char *compressCapa, bool *sessionSupportFlag)
921 {
922 const NodeInfo *node = LnnGetLocalNodeInfo();
923 if (node == NULL) {
924 return;
925 }
926 bool isRemoteSupportCompress = false;
927 if (strncmp(compressCapa, TRUE_STRING_TAG, strlen(compressCapa)) == 0) {
928 isRemoteSupportCompress = true;
929 } else {
930 isRemoteSupportCompress = false;
931 }
932 if (IsFeatureSupport(node->feature, BIT_INFO_COMPRESS) && isRemoteSupportCompress) {
933 *sessionSupportFlag = true;
934 AUTH_LOGI(AUTH_FSM, "local-remote all support deviceinfo compress");
935 } else {
936 *sessionSupportFlag = false;
937 }
938 }
939
VerifyExchangeIdTypeAndInfo(AuthSessionInfo *info, int32_t idType, char *anonyUdid)940 static int32_t VerifyExchangeIdTypeAndInfo(AuthSessionInfo *info, int32_t idType, char *anonyUdid)
941 {
942 char peerUdid[UDID_BUF_LEN] = {0};
943 bool isExchangeUdid = true;
944 if (idType == EXCHANGE_NETWORKID) {
945 if (GetPeerUdidByNetworkId(info->udid, peerUdid, UDID_BUF_LEN) != SOFTBUS_OK) {
946 AUTH_LOGE(AUTH_FSM, "get peer udid fail, peer networkId=%{public}s", anonyUdid);
947 info->idType = EXCHANGE_FAIL;
948 (void)memset_s(info->udid, sizeof(info->udid), 0, sizeof(info->udid));
949 } else {
950 if (GetIsExchangeUdidByNetworkId(info->udid, &isExchangeUdid) == SOFTBUS_OK && isExchangeUdid) {
951 AUTH_LOGE(AUTH_FSM, "need exchange udid, peer udid=%{public}s", anonyUdid);
952 info->idType = EXCHANGE_UDID;
953 } else {
954 AUTH_LOGE(AUTH_FSM, "get peer udid success, peer udid=%{public}s", anonyUdid);
955 info->idType = EXCHANGE_NETWORKID;
956 }
957 if (memcpy_s(info->udid, UDID_BUF_LEN, peerUdid, UDID_BUF_LEN) != EOK) {
958 AUTH_LOGE(AUTH_FSM, "copy peer udid fail");
959 info->idType = EXCHANGE_FAIL;
960 return SOFTBUS_MEM_ERR;
961 }
962 }
963 }
964 AUTH_LOGI(AUTH_FSM, "idType verify and get info succ.");
965 return SOFTBUS_OK;
966 }
967
SetExchangeIdTypeAndValue(JsonObj *obj, AuthSessionInfo *info)968 static int32_t SetExchangeIdTypeAndValue(JsonObj *obj, AuthSessionInfo *info)
969 {
970 if (obj == NULL || info == NULL) {
971 AUTH_LOGE(AUTH_FSM, "param invalid");
972 return SOFTBUS_INVALID_PARAM;
973 }
974
975 int32_t idType = -1;
976 if (!JSON_GetInt32FromOject(obj, EXCHANGE_ID_TYPE, &idType)) {
977 AUTH_LOGI(AUTH_FSM, "parse idType failed, ignore");
978 info->idType = EXCHANGE_UDID;
979 return SOFTBUS_OK;
980 }
981 char *anonyUdid = NULL;
982 Anonymize(info->udid, &anonyUdid);
983 AUTH_LOGI(AUTH_FSM,
984 "oldIdType=%{public}d, exchangeIdType=%{public}d, deviceId=%{public}s",
985 info->idType, idType, AnonymizeWrapper(anonyUdid));
986 if (idType == EXCHANGE_UDID) {
987 info->idType = EXCHANGE_UDID;
988 AnonymizeFree(anonyUdid);
989 return SOFTBUS_OK;
990 }
991 if (info->isServer) {
992 if (VerifyExchangeIdTypeAndInfo(info, idType, anonyUdid) != SOFTBUS_OK) {
993 AnonymizeFree(anonyUdid);
994 return SOFTBUS_ERR;
995 }
996 AUTH_LOGI(AUTH_FSM, "isServer is true in authSessionInfo.");
997 AnonymizeFree(anonyUdid);
998 return SOFTBUS_OK;
999 }
1000 if (info->idType == EXCHANGE_NETWORKID) {
1001 if (idType == EXCHANGE_FAIL) {
1002 info->idType = EXCHANGE_FAIL;
1003 }
1004 if (VerifyExchangeIdTypeAndInfo(info, idType, anonyUdid) != SOFTBUS_OK) {
1005 AnonymizeFree(anonyUdid);
1006 return SOFTBUS_ERR;
1007 }
1008 }
1009 AnonymizeFree(anonyUdid);
1010 return SOFTBUS_OK;
1011 }
1012
UnPackVersionByDeviceId(JsonObj *obj, AuthSessionInfo *info)1013 static void UnPackVersionByDeviceId(JsonObj *obj, AuthSessionInfo *info)
1014 {
1015 int32_t maxBuffSize;
1016 OptString(obj, DEVICE_ID_TAG, info->udid, UDID_BUF_LEN, "");
1017 OptInt(obj, DATA_BUF_SIZE_TAG, &maxBuffSize, PACKET_SIZE);
1018 if (strlen(info->udid) != 0) {
1019 info->version = SOFTBUS_OLD_V2;
1020 } else {
1021 info->version = SOFTBUS_OLD_V1;
1022 if (strcpy_s(info->udid, UDID_BUF_LEN, info->uuid) != EOK) {
1023 AUTH_LOGE(AUTH_FSM, "strcpy udid fail, ignore");
1024 }
1025 }
1026 if (!JSON_GetInt32FromOject(obj, SOFTBUS_VERSION_TAG, (int32_t *)&info->version)) {
1027 AUTH_LOGE(AUTH_FSM, "softbusVersion is not found");
1028 }
1029 OptInt(obj, AUTH_START_STATE, (int32_t *)&info->peerState, AUTH_STATE_COMPATIBLE);
1030 }
1031
UnpackWifiInfoFromJsonObj(JsonObj *obj, AuthSessionInfo *info)1032 static int32_t UnpackWifiInfoFromJsonObj(JsonObj *obj, AuthSessionInfo *info)
1033 {
1034 char cmd[CMD_TAG_LEN] = {0};
1035 if (!JSON_GetStringFromOject(obj, CMD_TAG, cmd, CMD_TAG_LEN)) {
1036 AUTH_LOGE(AUTH_FSM, "CMD_TAG not found");
1037 return SOFTBUS_NOT_FIND;
1038 }
1039 if (!UnpackWifiSinglePassInfo(obj, info)) {
1040 AUTH_LOGE(AUTH_FSM, "check ip fail, can't support auth");
1041 return SOFTBUS_PARSE_JSON_ERR;
1042 }
1043 if (info->connInfo.type == AUTH_LINK_TYPE_WIFI && info->isConnectServer) {
1044 if (strncmp(cmd, CMD_GET_AUTH_INFO, strlen(CMD_GET_AUTH_INFO)) != 0) {
1045 AUTH_LOGE(AUTH_FSM, "CMD_GET not match");
1046 return SOFTBUS_CMP_FAIL;
1047 }
1048 } else {
1049 if (strncmp(cmd, CMD_RET_AUTH_INFO, strlen(CMD_RET_AUTH_INFO)) != 0) {
1050 AUTH_LOGE(AUTH_FSM, "CMD_RET not match");
1051 return SOFTBUS_CMP_FAIL;
1052 }
1053 }
1054 return SOFTBUS_OK;
1055 }
1056
UnpackDeviceIdJson(const char *msg, uint32_t len, AuthSessionInfo *info)1057 int32_t UnpackDeviceIdJson(const char *msg, uint32_t len, AuthSessionInfo *info)
1058 {
1059 AUTH_CHECK_AND_RETURN_RET_LOGE(msg != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "msg is NULL");
1060 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
1061 JsonObj *obj = JSON_Parse(msg, len);
1062 if (obj == NULL) {
1063 AUTH_LOGE(AUTH_FSM, "json parse fail");
1064 return SOFTBUS_INVALID_PARAM;
1065 }
1066 int32_t ret = UnpackWifiInfoFromJsonObj(obj, info);
1067 if (ret != SOFTBUS_OK) {
1068 JSON_Delete(obj);
1069 return ret;
1070 }
1071 if (!JSON_GetStringFromOject(obj, DATA_TAG, info->uuid, UUID_BUF_LEN)) {
1072 AUTH_LOGE(AUTH_FSM, "uuid not found");
1073 JSON_Delete(obj);
1074 return SOFTBUS_ERR;
1075 }
1076 UnPackVersionByDeviceId(obj, info);
1077 if (SetExchangeIdTypeAndValue(obj, info) != SOFTBUS_OK) {
1078 AUTH_LOGE(AUTH_FSM, "set exchange id type or value failed");
1079 JSON_Delete(obj);
1080 return SOFTBUS_ERR;
1081 }
1082 if (info->connInfo.type != AUTH_LINK_TYPE_WIFI) {
1083 char compressParse[PARSE_UNCOMPRESS_STRING_BUFF_LEN] = { 0 };
1084 OptString(obj, SUPPORT_INFO_COMPRESS, compressParse, PARSE_UNCOMPRESS_STRING_BUFF_LEN, FALSE_STRING_TAG);
1085 SetCompressFlag(compressParse, &info->isSupportCompress);
1086 }
1087 OptInt(obj, AUTH_MODULE, (int32_t *)&info->module, AUTH_MODULE_LNN);
1088 bool isSupportNormalizedKey = false;
1089 OptBool(obj, IS_NORMALIZED, &isSupportNormalizedKey, false);
1090 UnpackFastAuth(obj, info);
1091 UnpackNormalizedKey(obj, info, isSupportNormalizedKey);
1092 OptBool(obj, IS_NEED_PACK_CERT, &info->isNeedPackCert, false);
1093 JSON_Delete(obj);
1094 return SOFTBUS_OK;
1095 }
1096
GetAndSetLocalUnifiedName(JsonObj *json)1097 static void GetAndSetLocalUnifiedName(JsonObj *json)
1098 {
1099 char unified[DEVICE_NAME_BUF_LEN] = {0};
1100 if (LnnGetUnifiedDeviceName(unified, DEVICE_NAME_BUF_LEN) != SOFTBUS_OK) {
1101 AUTH_LOGE(AUTH_FSM, "get defaultDeviceName fail");
1102 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, unified);
1103 return;
1104 }
1105
1106 if (strlen(unified) != 0) {
1107 if (LnnSetLocalStrInfo(STRING_KEY_DEV_UNIFIED_NAME, unified) != SOFTBUS_OK) {
1108 AUTH_LOGE(AUTH_FSM, "set device unifiedDefaultName fail");
1109 }
1110 AUTH_LOGI(AUTH_FSM, "unifed length is not zero, unified=%{public}s", unified);
1111 }
1112 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, unified);
1113 }
1114
PackCommonDevInfo(JsonObj *json, const NodeInfo *info, bool isMetaAuth)1115 static int32_t PackCommonDevInfo(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
1116 {
1117 char localDevName[DEVICE_NAME_BUF_LEN] = {0};
1118 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, localDevName, sizeof(localDevName));
1119 if (ret == SOFTBUS_OK) {
1120 (void)JSON_AddStringToObject(json, DEVICE_NAME, localDevName);
1121 } else {
1122 (void)JSON_AddStringToObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo));
1123 }
1124
1125 if (strlen(info->deviceInfo.unifiedName) == 0) {
1126 GetAndSetLocalUnifiedName(json);
1127 } else {
1128 (void)JSON_AddStringToObject(json, UNIFIED_DEVICE_NAME, info->deviceInfo.unifiedName);
1129 }
1130 (void)JSON_AddStringToObject(json, UNIFIED_DEFAULT_DEVICE_NAME, info->deviceInfo.unifiedDefaultName);
1131 (void)JSON_AddStringToObject(json, SETTINGS_NICK_NAME, info->deviceInfo.nickName);
1132 if (!JSON_AddStringToObject(json, NETWORK_ID, info->networkId) ||
1133 !JSON_AddStringToObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
1134 !JSON_AddStringToObject(json, DEVICE_UDID, LnnGetDeviceUdid(info))) {
1135 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject fail");
1136 return SOFTBUS_ERR;
1137 }
1138 if (isMetaAuth && !JSON_AddStringToObject(json, DEVICE_UUID, info->uuid)) {
1139 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject fail");
1140 return SOFTBUS_ERR;
1141 }
1142 return SOFTBUS_OK;
1143 }
1144
PackCommonFastAuth(JsonObj *json, const NodeInfo *info)1145 static void PackCommonFastAuth(JsonObj *json, const NodeInfo *info)
1146 {
1147 (void)JSON_AddInt32ToObject(json, STATE_VERSION, info->stateVersion);
1148 char extData[EXTDATA_LEN] = {0};
1149 int32_t ret = GetExtData(extData, EXTDATA_LEN);
1150 if (ret != SOFTBUS_OK) {
1151 AUTH_LOGE(AUTH_FSM, "GetExtData fail");
1152 } else {
1153 AUTH_LOGI(AUTH_FSM, "GetExtData=%{public}s", extData);
1154 (void)JSON_AddStringToObject(json, EXTDATA, extData);
1155 }
1156 }
1157
PackOsInfo(JsonObj *json, const NodeInfo *info)1158 static void PackOsInfo(JsonObj *json, const NodeInfo *info)
1159 {
1160 (void)JSON_AddInt32ToObject(json, OS_TYPE, info->deviceInfo.osType);
1161 (void)JSON_AddStringToObject(json, OS_VERSION, info->deviceInfo.osVersion);
1162 }
1163
PackDeviceVersion(JsonObj *json, const NodeInfo *info)1164 static void PackDeviceVersion(JsonObj *json, const NodeInfo *info)
1165 {
1166 (void)JSON_AddStringToObject(json, DEVICE_VERSION, info->deviceInfo.deviceVersion);
1167 (void)JSON_AddInt32ToObject(json, STATE_VERSION_CHANGE_REASON, info->stateVersionReason);
1168 }
1169
PackCommP2pInfo(JsonObj *json, const NodeInfo *info)1170 static void PackCommP2pInfo(JsonObj *json, const NodeInfo *info)
1171 {
1172 (void)JSON_AddInt32ToObject(json, P2P_ROLE, LnnGetP2pRole(info));
1173 (void)JSON_AddStringToObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info));
1174 (void)JSON_AddStringToObject(json, HML_MAC, info->wifiDirectAddr);
1175
1176 (void)JSON_AddStringToObject(json, WIFI_CFG, info->p2pInfo.wifiCfg);
1177 (void)JSON_AddStringToObject(json, CHAN_LIST_5G, info->p2pInfo.chanList5g);
1178 (void)JSON_AddInt32ToObject(json, STA_FREQUENCY, LnnGetStaFrequency(info));
1179 }
1180
AuthPrintBase64Ptk(const char *ptk)1181 static void AuthPrintBase64Ptk(const char *ptk)
1182 {
1183 char *anonyPtk = NULL;
1184 Anonymize(ptk, &anonyPtk);
1185 AUTH_LOGD(AUTH_FSM, "base Ptk=%{public}s", AnonymizeWrapper(anonyPtk));
1186 AnonymizeFree(anonyPtk);
1187 }
1188
PackWifiDirectInfo( const AuthConnInfo *connInfo, JsonObj *json, const NodeInfo *info, const char *remoteUuid, bool isMetaAuth)1189 static void PackWifiDirectInfo(
1190 const AuthConnInfo *connInfo, JsonObj *json, const NodeInfo *info, const char *remoteUuid, bool isMetaAuth)
1191 {
1192 unsigned char encodePtk[PTK_ENCODE_LEN] = {0};
1193 char localPtk[PTK_DEFAULT_LEN] = {0};
1194 if (isMetaAuth || remoteUuid == NULL) {
1195 uint32_t connId;
1196 AuthMetaGetConnIdByInfo(connInfo, &connId);
1197 if (LnnGetMetaPtk(connId, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
1198 AUTH_LOGE(AUTH_FSM, "get meta ptk fail");
1199 return;
1200 }
1201 } else {
1202 if (LnnGetLocalPtkByUuid(remoteUuid, localPtk, PTK_DEFAULT_LEN) != SOFTBUS_OK) {
1203 AUTH_LOGE(AUTH_FSM, "get ptk by uuid fail");
1204 return;
1205 }
1206 }
1207 LnnDumpRemotePtk(NULL, localPtk, "pack wifi direct info");
1208 size_t keyLen = 0;
1209 if (SoftBusBase64Encode(encodePtk, PTK_ENCODE_LEN, &keyLen, (unsigned char *)localPtk,
1210 PTK_DEFAULT_LEN) != SOFTBUS_OK) {
1211 AUTH_LOGE(AUTH_FSM, "encode ptk fail");
1212 (void)memset_s(localPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
1213 return;
1214 }
1215 (void)memset_s(localPtk, PTK_DEFAULT_LEN, 0, PTK_DEFAULT_LEN);
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 (void)memset_s(encodePtk, PTK_ENCODE_LEN, 0, PTK_ENCODE_LEN);
1220 return;
1221 }
1222 (void)memset_s(encodePtk, PTK_ENCODE_LEN, 0, PTK_ENCODE_LEN);
1223 if (!JSON_AddInt32ToObject(json, STATIC_CAP_LENGTH, info->staticCapLen)) {
1224 AUTH_LOGE(AUTH_FSM, "add static cap len fail");
1225 return;
1226 }
1227 char staticCap[STATIC_CAP_STR_LEN] = {0};
1228 if (ConvertBytesToHexString((char *)staticCap, STATIC_CAP_STR_LEN,
1229 info->staticCapability, info->staticCapLen) != SOFTBUS_OK) {
1230 AUTH_LOGW(AUTH_FSM, "convert static cap fail");
1231 return;
1232 }
1233 if (!JSON_AddStringToObject(json, STATIC_CAP, (char *)staticCap)) {
1234 AUTH_LOGW(AUTH_FSM, "add static capability fail");
1235 return;
1236 }
1237 }
1238
FillBroadcastCipherKey(BroadcastCipherKey *broadcastKey, const NodeInfo *info)1239 static int32_t FillBroadcastCipherKey(BroadcastCipherKey *broadcastKey, const NodeInfo *info)
1240 {
1241 if (memcpy_s(broadcastKey->udid, UDID_BUF_LEN, info->deviceInfo.deviceUdid, UDID_BUF_LEN) != EOK) {
1242 AUTH_LOGE(AUTH_FSM, "memcpy udid fail.");
1243 return SOFTBUS_ERR;
1244 }
1245 if (memcpy_s(broadcastKey->cipherInfo.key, SESSION_KEY_LENGTH, info->cipherInfo.key, SESSION_KEY_LENGTH) != EOK) {
1246 AUTH_LOGE(AUTH_FSM, "memcpy key fail.");
1247 return SOFTBUS_ERR;
1248 }
1249 if (memcpy_s(broadcastKey->cipherInfo.iv, BROADCAST_IV_LEN, info->cipherInfo.iv, BROADCAST_IV_LEN) != EOK) {
1250 AUTH_LOGE(AUTH_FSM, "memcpy iv fail.");
1251 return SOFTBUS_ERR;
1252 }
1253 return SOFTBUS_OK;
1254 }
1255
DumpRpaCipherKey(char *cipherKey, char *cipherIv, const char *peerIrk, const char *log)1256 static void DumpRpaCipherKey(char *cipherKey, char *cipherIv, const char *peerIrk, const char *log)
1257 {
1258 char *anonyIrk = NULL;
1259 char *anonyCipherKey = NULL;
1260 char *anonyCipherIv = NULL;
1261 Anonymize(cipherKey, &anonyCipherKey);
1262 Anonymize(cipherIv, &anonyCipherIv);
1263 Anonymize(peerIrk, &anonyIrk);
1264 AUTH_LOGI(AUTH_FSM, "log=%{public}s, cipherKey=%{public}s, cipherIv=%{public}s, peerIrk=%{public}s", log,
1265 AnonymizeWrapper(anonyCipherKey), AnonymizeWrapper(anonyCipherIv), AnonymizeWrapper(anonyIrk));
1266 AnonymizeFree(anonyCipherKey);
1267 AnonymizeFree(anonyCipherIv);
1268 AnonymizeFree(anonyIrk);
1269 }
1270
UpdateBroadcastCipherKey(const NodeInfo *info)1271 static int32_t UpdateBroadcastCipherKey(const NodeInfo *info)
1272 {
1273 BroadcastCipherKey broadcastKey;
1274 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1275 if (FillBroadcastCipherKey(&broadcastKey, info) != SOFTBUS_OK) {
1276 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1277 return SOFTBUS_ERR;
1278 }
1279 if (LnnUpdateLocalBroadcastCipherKey(&broadcastKey) != SOFTBUS_OK) {
1280 AUTH_LOGE(AUTH_FSM, "update local broadcast key failed");
1281 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1282 return SOFTBUS_ERR;
1283 }
1284 (void)memset_s(&broadcastKey, sizeof(BroadcastCipherKey), 0, sizeof(BroadcastCipherKey));
1285 return SOFTBUS_OK;
1286 }
1287
PackCipherRpaInfo(JsonObj *json, const NodeInfo *info)1288 static int32_t PackCipherRpaInfo(JsonObj *json, const NodeInfo *info)
1289 {
1290 char cipherKey[SESSION_KEY_STR_LEN] = {0};
1291 char cipherIv[BROADCAST_IV_STR_LEN] = {0};
1292 char peerIrk[LFINDER_IRK_STR_LEN] = {0};
1293 char pubMac[LFINDER_MAC_ADDR_STR_LEN] = {0};
1294
1295 if (ConvertBytesToHexString(cipherKey, SESSION_KEY_STR_LEN,
1296 info->cipherInfo.key, SESSION_KEY_LENGTH) != SOFTBUS_OK) {
1297 AUTH_LOGE(AUTH_FSM, "convert cipher key to string fail.");
1298 return SOFTBUS_ERR;
1299 }
1300 if (ConvertBytesToHexString(cipherIv, BROADCAST_IV_STR_LEN,
1301 info->cipherInfo.iv, BROADCAST_IV_LEN) != SOFTBUS_OK) {
1302 AUTH_LOGE(AUTH_FSM, "convert cipher iv to string fail.");
1303 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1304 return SOFTBUS_ERR;
1305 }
1306 if (ConvertBytesToHexString(peerIrk, LFINDER_IRK_STR_LEN,
1307 info->rpaInfo.peerIrk, LFINDER_IRK_LEN) != SOFTBUS_OK) {
1308 AUTH_LOGE(AUTH_FSM, "convert peerIrk to string fail.");
1309 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1310 return SOFTBUS_ERR;
1311 }
1312 if (ConvertBytesToHexString(pubMac, LFINDER_MAC_ADDR_STR_LEN,
1313 info->rpaInfo.publicAddress, LFINDER_MAC_ADDR_LEN) != SOFTBUS_OK) {
1314 AUTH_LOGE(AUTH_FSM, "convert publicAddress to string fail.");
1315 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1316 (void)memset_s(peerIrk, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
1317 return SOFTBUS_ERR;
1318 }
1319 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_KEY, cipherKey);
1320 (void)JSON_AddStringToObject(json, BROADCAST_CIPHER_IV, cipherIv);
1321 (void)JSON_AddStringToObject(json, IRK, peerIrk);
1322 (void)JSON_AddStringToObject(json, PUB_MAC, pubMac);
1323 DumpRpaCipherKey(cipherKey, cipherIv, peerIrk, "pack broadcast cipher key");
1324 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1325 (void)memset_s(peerIrk, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
1326 int32_t ret = UpdateBroadcastCipherKey(info);
1327 if (ret != SOFTBUS_OK) {
1328 return ret;
1329 }
1330 return SOFTBUS_OK;
1331 }
1332
UnpackCipherRpaInfo(const JsonObj *json, NodeInfo *info)1333 static void UnpackCipherRpaInfo(const JsonObj *json, NodeInfo *info)
1334 {
1335 char cipherKey[SESSION_KEY_STR_LEN] = {0};
1336 char cipherIv[BROADCAST_IV_STR_LEN] = {0};
1337 char peerIrk[LFINDER_IRK_STR_LEN] = {0};
1338 char pubMac[LFINDER_MAC_ADDR_STR_LEN] = {0};
1339
1340 do {
1341 if (!JSON_GetStringFromOject(json, BROADCAST_CIPHER_KEY, cipherKey, SESSION_KEY_STR_LEN) ||
1342 !JSON_GetStringFromOject(json, BROADCAST_CIPHER_IV, cipherIv, BROADCAST_IV_STR_LEN) ||
1343 !JSON_GetStringFromOject(json, IRK, peerIrk, LFINDER_IRK_STR_LEN) ||
1344 !JSON_GetStringFromOject(json, PUB_MAC, pubMac, LFINDER_MAC_ADDR_STR_LEN)) {
1345 AUTH_LOGE(AUTH_FSM, "get json info fail.");
1346 break;
1347 }
1348 if (ConvertHexStringToBytes((unsigned char *)info->cipherInfo.key,
1349 SESSION_KEY_LENGTH, cipherKey, strlen(cipherKey)) != SOFTBUS_OK) {
1350 AUTH_LOGE(AUTH_FSM, "convert cipher key to bytes fail.");
1351 break;
1352 }
1353 if (ConvertHexStringToBytes((unsigned char *)info->cipherInfo.iv,
1354 BROADCAST_IV_LEN, cipherIv, strlen(cipherIv)) != SOFTBUS_OK) {
1355 AUTH_LOGE(AUTH_FSM, "convert cipher iv to bytes fail.");
1356 break;
1357 }
1358 if (ConvertHexStringToBytes((unsigned char *)info->rpaInfo.peerIrk,
1359 LFINDER_IRK_LEN, peerIrk, strlen(peerIrk)) != SOFTBUS_OK) {
1360 AUTH_LOGE(AUTH_FSM, "convert peerIrk to bytes fail.");
1361 break;
1362 }
1363 if (ConvertHexStringToBytes((unsigned char *)info->rpaInfo.publicAddress,
1364 LFINDER_MAC_ADDR_LEN, pubMac, strlen(pubMac)) != SOFTBUS_OK) {
1365 AUTH_LOGE(AUTH_FSM, "convert publicAddress to bytes fail.");
1366 break;
1367 }
1368 DumpRpaCipherKey(cipherKey, cipherIv, peerIrk, "unpack broadcast cipher key");
1369 } while (0);
1370 (void)memset_s(cipherKey, SESSION_KEY_STR_LEN, 0, SESSION_KEY_STR_LEN);
1371 (void)memset_s(cipherIv, BROADCAST_IV_STR_LEN, 0, BROADCAST_IV_STR_LEN);
1372 (void)memset_s(peerIrk, LFINDER_IRK_STR_LEN, 0, LFINDER_IRK_STR_LEN);
1373 }
1374
PackCommonEx(JsonObj *json, const NodeInfo *info)1375 static int32_t PackCommonEx(JsonObj *json, const NodeInfo *info)
1376 {
1377 bool isFalse = (
1378 !JSON_AddStringToObject(json, VERSION_TYPE, info->versionType) ||
1379 !JSON_AddInt32ToObject(json, CONN_CAP, info->netCapacity) ||
1380 !JSON_AddInt32ToObject(json, AUTH_CAP, info->authCapacity) ||
1381 !JSON_AddInt32ToObject(json, HB_CAP, info->heartbeatCapacity) ||
1382 !JSON_AddInt16ToObject(json, DATA_CHANGE_FLAG, info->dataChangeFlag) ||
1383 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1384 !JSON_AddBoolToObject(json, BLE_P2P, info->isBleP2p) ||
1385 !JSON_AddInt64ToObject(json, TRANSPORT_PROTOCOL, (int64_t)LnnGetSupportedProtocols(info)) ||
1386 !JSON_AddBoolToObject(json, IS_SUPPORT_IPV6, true));
1387 if (isFalse) {
1388 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
1389 return SOFTBUS_ERR;
1390 }
1391
1392 char btMacUpper[BT_MAC_LEN] = {0};
1393 if (StringToUpperCase(LnnGetBtMac(info), btMacUpper, BT_MAC_LEN) != SOFTBUS_OK) {
1394 AUTH_LOGE(AUTH_FSM, "btMac to upperCase failed.");
1395 if (memcpy_s(btMacUpper, BT_MAC_LEN, LnnGetBtMac(info), BT_MAC_LEN) != EOK) {
1396 AUTH_LOGE(AUTH_FSM, "btMac cpy failed.");
1397 return SOFTBUS_MEM_ERR;
1398 }
1399 }
1400 isFalse = (
1401 !JSON_AddStringToObject(json, PKG_VERSION, info->pkgVersion) ||
1402 !JSON_AddInt64ToObject(json, WIFI_VERSION, info->wifiVersion) ||
1403 !JSON_AddInt64ToObject(json, BLE_VERSION, info->bleVersion) ||
1404 !JSON_AddStringToObject(json, BT_MAC, btMacUpper) ||
1405 !JSON_AddStringToObject(json, BLE_MAC, info->connectInfo.bleMacAddr) ||
1406 !JSON_AddInt32ToObject(json, REMAIN_POWER, info->batteryInfo.batteryLevel) ||
1407 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1408 !JSON_AddBoolToObject(json, IS_SCREENON, info->isScreenOn) ||
1409 !JSON_AddInt32ToObject(json, NODE_WEIGHT, info->masterWeight) ||
1410 !JSON_AddInt64ToObject(json, ACCOUNT_ID, info->accountId) ||
1411 !JSON_AddBoolToObject(json, DISTRIBUTED_SWITCH, true) ||
1412 !JSON_AddInt64ToObject(json, BLE_TIMESTAMP, info->bleStartTimestamp) ||
1413 !JSON_AddInt32ToObject(json, WIFI_BUFF_SIZE, info->wifiBuffSize) ||
1414 !JSON_AddInt32ToObject(json, BR_BUFF_SIZE, info->brBuffSize) ||
1415 !JSON_AddInt64ToObject(json, FEATURE, info->feature) ||
1416 !JSON_AddInt64ToObject(json, CONN_SUB_FEATURE, info->connSubFeature) ||
1417 !JSON_AddInt64ToObject(json, NEW_CONN_CAP, info->netCapacity));
1418 if (isFalse) {
1419 AUTH_LOGE(AUTH_FSM, "JSON_AddStringToObject failed.");
1420 return SOFTBUS_ERR;
1421 }
1422 AUTH_LOGI(AUTH_FSM, "pack common succ.");
1423 return SOFTBUS_OK;
1424 }
1425
PackCommon(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)1426 static int32_t PackCommon(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1427 {
1428 if (version >= SOFTBUS_NEW_V1) {
1429 if (!JSON_AddStringToObject(json, MASTER_UDID, info->masterUdid) ||
1430 !JSON_AddInt32ToObject(json, MASTER_WEIGHT, info->masterWeight)) {
1431 AUTH_LOGE(AUTH_FSM, "add master node info fail");
1432 return SOFTBUS_ERR;
1433 }
1434 if (!JSON_AddStringToObject(json, NODE_ADDR, info->nodeAddress)) {
1435 AUTH_LOGE(AUTH_FSM, "pack node address Fail");
1436 return SOFTBUS_ERR;
1437 }
1438 }
1439 if (!JSON_AddStringToObject(json, SW_VERSION, info->softBusVersion)) {
1440 AUTH_LOGE(AUTH_FSM, "add version info fail");
1441 return SOFTBUS_ERR;
1442 }
1443 if (PackCommonDevInfo(json, info, isMetaAuth) != SOFTBUS_OK) {
1444 return SOFTBUS_ERR;
1445 }
1446 if (PackCommonEx(json, info) != SOFTBUS_OK) {
1447 AUTH_LOGE(AUTH_FSM, "data pack failed.");
1448 return SOFTBUS_ERR;
1449 }
1450 PackOsInfo(json, info);
1451 PackDeviceVersion(json, info);
1452 PackCommonFastAuth(json, info);
1453 if (!PackCipherKeySyncMsg(json)) {
1454 AUTH_LOGE(AUTH_FSM, "PackCipherKeySyncMsg failed.");
1455 }
1456 PackCommP2pInfo(json, info);
1457
1458 if (PackCipherRpaInfo(json, info) != SOFTBUS_OK) {
1459 AUTH_LOGE(AUTH_FSM, "pack CipherRpaInfo of device key failed.");
1460 }
1461
1462 if (!JSON_AddInt32ToObject(json, DEVICE_SECURITY_LEVEL, info->deviceSecurityLevel)) {
1463 AUTH_LOGE(AUTH_FSM, "pack deviceSecurityLevel fail.");
1464 }
1465 return SOFTBUS_OK;
1466 }
1467
UnpackMetaPtk(char *remoteMetaPtk, char *decodePtk)1468 static void UnpackMetaPtk(char *remoteMetaPtk, char *decodePtk)
1469 {
1470 size_t len = 0;
1471 if (SoftBusBase64Decode((unsigned char *)remoteMetaPtk, PTK_DEFAULT_LEN, &len,
1472 (const unsigned char *)decodePtk, strlen((char *)decodePtk)) != SOFTBUS_OK) {
1473 AUTH_LOGE(AUTH_FSM, "decode remote meta ptk fail");
1474 return;
1475 }
1476 LnnDumpRemotePtk(NULL, remoteMetaPtk, "unpack meta wifi direct info");
1477 if (len != PTK_DEFAULT_LEN) {
1478 AUTH_LOGE(AUTH_FSM, "decode data len error");
1479 return;
1480 }
1481 return;
1482 }
1483
UnpackPtk(char *remotePtk, char *decodePtk)1484 static void UnpackPtk(char *remotePtk, char *decodePtk)
1485 {
1486 size_t len = 0;
1487 if (SoftBusBase64Decode((unsigned char *)remotePtk, PTK_DEFAULT_LEN, &len,
1488 (const unsigned char *)decodePtk, strlen((char *)decodePtk)) != SOFTBUS_OK) {
1489 AUTH_LOGE(AUTH_FSM, "decode remote ptk fail");
1490 return;
1491 }
1492 LnnDumpRemotePtk(NULL, remotePtk, "unpack wifi direct info");
1493 if (len != PTK_DEFAULT_LEN) {
1494 AUTH_LOGE(AUTH_FSM, "decode data len error");
1495 return;
1496 }
1497 return;
1498 }
1499
UnpackWifiDirectInfo(const JsonObj *json, NodeInfo *info, bool isMetaAuth)1500 static void UnpackWifiDirectInfo(const JsonObj *json, NodeInfo *info, bool isMetaAuth)
1501 {
1502 char staticCap[STATIC_CAP_STR_LEN] = {0};
1503 if (!JSON_GetInt32FromOject(json, STATIC_CAP_LENGTH, &info->staticCapLen)) {
1504 AUTH_LOGE(AUTH_FSM, "get static cap len fail");
1505 return;
1506 }
1507 if (!JSON_GetStringFromOject(json, STATIC_CAP, staticCap, STATIC_CAP_STR_LEN)) {
1508 AUTH_LOGE(AUTH_FSM, "get static cap fail");
1509 return;
1510 }
1511 if (ConvertHexStringToBytes((unsigned char *)info->staticCapability, STATIC_CAP_LEN,
1512 staticCap, strlen(staticCap)) != SOFTBUS_OK) {
1513 AUTH_LOGE(AUTH_FSM, "convert static cap fail");
1514 return;
1515 }
1516 char encodePtk[PTK_ENCODE_LEN] = {0};
1517 if (!JSON_GetStringFromOject(json, PTK, encodePtk, PTK_ENCODE_LEN)) {
1518 AUTH_LOGE(AUTH_FSM, "get encode ptk fail");
1519 return;
1520 }
1521 AuthPrintBase64Ptk((const char *)encodePtk);
1522 if (isMetaAuth) {
1523 UnpackMetaPtk(info->remoteMetaPtk, encodePtk);
1524 } else {
1525 UnpackPtk(info->remotePtk, encodePtk);
1526 }
1527 (void)memset_s(encodePtk, PTK_ENCODE_LEN, 0, PTK_ENCODE_LEN);
1528 }
1529
ParseCommonJsonInfo(const JsonObj *json, NodeInfo *info, bool isMetaAuth)1530 static void ParseCommonJsonInfo(const JsonObj *json, NodeInfo *info, bool isMetaAuth)
1531 {
1532 (void)JSON_GetStringFromOject(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN);
1533 OptString(json, PKG_VERSION, info->pkgVersion, VERSION_MAX_LEN, "");
1534 OptString(json, UNIFIED_DEVICE_NAME, info->deviceInfo.unifiedName, DEVICE_NAME_BUF_LEN, "");
1535 OptString(json, UNIFIED_DEFAULT_DEVICE_NAME, info->deviceInfo.unifiedDefaultName, DEVICE_NAME_BUF_LEN, "");
1536 OptString(json, SETTINGS_NICK_NAME, info->deviceInfo.nickName, DEVICE_NAME_BUF_LEN, "");
1537 OptInt64(json, WIFI_VERSION, &info->wifiVersion, 0);
1538 OptInt64(json, BLE_VERSION, &info->bleVersion, 0);
1539 OptString(json, BT_MAC, info->connectInfo.macAddr, MAC_LEN, "");
1540 OptString(json, BLE_MAC, info->connectInfo.bleMacAddr, MAC_LEN, "");
1541 char deviceType[DEVICE_TYPE_BUF_LEN] = {0};
1542 (void)JSON_GetStringFromOject(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN);
1543 if (JSON_GetStringFromOject(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN)) {
1544 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
1545 }
1546 (void)JSON_GetStringFromOject(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN);
1547 if (isMetaAuth) {
1548 (void)JSON_GetStringFromOject(json, DEVICE_UUID, info->uuid, UDID_BUF_LEN);
1549 }
1550 (void)JSON_GetStringFromOject(json, NETWORK_ID, info->networkId, NETWORK_ID_BUF_LEN);
1551 (void)JSON_GetStringFromOject(json, VERSION_TYPE, info->versionType, VERSION_MAX_LEN);
1552 (void)JSON_GetInt32FromOject(json, CONN_CAP, (int32_t *)&info->netCapacity);
1553 (void)JSON_GetInt32FromOject(json, AUTH_CAP, (int32_t *)&info->authCapacity);
1554 (void)JSON_GetInt32FromOject(json, HB_CAP, (int32_t *)&info->heartbeatCapacity);
1555 info->isBleP2p = false;
1556 (void)JSON_GetBoolFromOject(json, BLE_P2P, &info->isBleP2p);
1557 (void)JSON_GetInt16FromOject(json, DATA_CHANGE_FLAG, (int16_t *)&info->dataChangeFlag);
1558 (void)JSON_GetBoolFromOject(json, IS_CHARGING, &info->batteryInfo.isCharging);
1559 (void)JSON_GetInt32FromOject(json, REMAIN_POWER, &info->batteryInfo.batteryLevel);
1560 (void)JSON_GetBoolFromOject(json, IS_SUPPORT_IPV6, &info->isSupportIpv6);
1561 OptBool(json, IS_SCREENON, &info->isScreenOn, false);
1562 OptInt64(json, ACCOUNT_ID, &info->accountId, 0);
1563 OptInt(json, NODE_WEIGHT, &info->masterWeight, DEFAULT_NODE_WEIGHT);
1564 OptInt(json, OS_TYPE, &info->deviceInfo.osType, -1);
1565 if ((info->deviceInfo.osType == -1) && info->authCapacity != 0) {
1566 info->deviceInfo.osType = OH_OS_TYPE;
1567 AUTH_LOGD(AUTH_FSM, "info->deviceInfo.osType: %{public}d", info->deviceInfo.osType);
1568 }
1569 OptString(json, OS_VERSION, info->deviceInfo.osVersion, OS_VERSION_BUF_LEN, "");
1570 OptString(json, DEVICE_VERSION, info->deviceInfo.deviceVersion, DEVICE_VERSION_SIZE_MAX, "");
1571 // IS_SUPPORT_TCP_HEARTBEAT
1572 OptInt(json, NEW_CONN_CAP, (int32_t *)&info->netCapacity, -1);
1573 if (info->netCapacity == (uint32_t)-1) {
1574 (void)JSON_GetInt32FromOject(json, CONN_CAP, (int32_t *)&info->netCapacity);
1575 }
1576 OptInt(json, WIFI_BUFF_SIZE, &info->wifiBuffSize, DEFAULT_WIFI_BUFF_SIZE);
1577 OptInt(json, BR_BUFF_SIZE, &info->wifiBuffSize, DEFAULT_BR_BUFF_SIZE);
1578 OptInt64(json, FEATURE, (int64_t *)&info->feature, 0);
1579 OptInt64(json, CONN_SUB_FEATURE, (int64_t *)&info->connSubFeature, 0);
1580 OptInt(json, STATE_VERSION_CHANGE_REASON, (int32_t *)&info->stateVersionReason, 0);
1581 }
1582
UnpackCommon(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)1583 static void UnpackCommon(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1584 {
1585 if (version >= SOFTBUS_NEW_V1) {
1586 if (!JSON_GetStringFromOject(json, MASTER_UDID, info->masterUdid, UDID_BUF_LEN) ||
1587 !JSON_GetInt32FromOject(json, MASTER_WEIGHT, &info->masterWeight)) {
1588 AUTH_LOGE(AUTH_FSM, "get master node info fail");
1589 }
1590 AUTH_LOGE(AUTH_FSM, "get master weight=%{public}d", info->masterWeight);
1591 if (!JSON_GetStringFromOject(json, NODE_ADDR, info->nodeAddress, sizeof(info->nodeAddress))) {
1592 AUTH_LOGW(AUTH_FSM,
1593 "no node address packed. set to address NODE_ADDR_LOOPBACK. NODE_ADDR_LOOPBACK=%{public}s",
1594 NODE_ADDR_LOOPBACK);
1595 (void)strcpy_s(info->nodeAddress, sizeof(info->nodeAddress), NODE_ADDR_LOOPBACK);
1596 }
1597 }
1598 ParseCommonJsonInfo(json, info, isMetaAuth);
1599 // MetaNodeInfoOfEar
1600 OptString(json, EXTDATA, info->extData, EXTDATA_LEN, "");
1601 if (version == SOFTBUS_OLD_V1) {
1602 if (strcpy_s(info->networkId, NETWORK_ID_BUF_LEN, info->uuid) != EOK) {
1603 AUTH_LOGE(AUTH_FSM, "v1 version strcpy networkid fail");
1604 }
1605 }
1606 ProcessCipherKeySyncInfo(json, info->deviceInfo.deviceUdid);
1607
1608 // unpack p2p info
1609 OptInt(json, P2P_ROLE, &info->p2pInfo.p2pRole, -1);
1610 OptString(json, WIFI_CFG, info->p2pInfo.wifiCfg, WIFI_CFG_INFO_MAX_LEN, "");
1611 OptString(json, CHAN_LIST_5G, info->p2pInfo.chanList5g, CHANNEL_LIST_STR_LEN, "");
1612 OptInt(json, STA_FREQUENCY, &info->p2pInfo.staFrequency, -1);
1613 OptString(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN, "");
1614 OptString(json, HML_MAC, info->wifiDirectAddr, MAC_LEN, "");
1615
1616 UnpackCipherRpaInfo(json, info);
1617 OptInt(json, DEVICE_SECURITY_LEVEL, &info->deviceSecurityLevel, 0);
1618 }
1619
GetBtDiscTypeString(const NodeInfo *info, char *buf, uint32_t len)1620 static int32_t GetBtDiscTypeString(const NodeInfo *info, char *buf, uint32_t len)
1621 {
1622 uint32_t i = 0;
1623 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BLE)) {
1624 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_ERR);
1625 buf[i++] = DISCOVERY_TYPE_BLE + '0';
1626 }
1627 if (LnnHasDiscoveryType(info, DISCOVERY_TYPE_BR)) {
1628 if (i != 0) {
1629 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_ERR);
1630 buf[i++] = ',';
1631 }
1632 CHECK_EXPRESSION_RETURN_VALUE((i >= len), SOFTBUS_ERR);
1633 buf[i++] = DISCOVERY_TYPE_BR + '0';
1634 }
1635 return SOFTBUS_OK;
1636 }
1637
AddDiscoveryType(JsonObj *json, const char *remoteUuid)1638 static void AddDiscoveryType(JsonObj *json, const char *remoteUuid)
1639 {
1640 if (remoteUuid == NULL) {
1641 return;
1642 }
1643 char networkId[NETWORK_ID_BUF_LEN] = {0};
1644 if (LnnGetNetworkIdByUuid(remoteUuid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
1645 AUTH_LOGE(AUTH_FSM, "networkId not found by uuid, maybe first online");
1646 return;
1647 }
1648 uint32_t discoveryType = 0;
1649 if (LnnGetRemoteNumInfo(networkId, NUM_KEY_DISCOVERY_TYPE, (int32_t *)&discoveryType) != SOFTBUS_OK) {
1650 AUTH_LOGE(AUTH_FSM, "get discoveryType fail");
1651 return;
1652 }
1653 NodeInfo nodeInfo; // only for discType calc
1654 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
1655 nodeInfo.discoveryType = discoveryType;
1656 char discTypeStr[BT_DISC_TYPE_MAX_LEN] = {0};
1657 if (GetBtDiscTypeString(&nodeInfo, discTypeStr, BT_DISC_TYPE_MAX_LEN) != SOFTBUS_OK) {
1658 AUTH_LOGE(AUTH_FSM, "disc Type calc fail");
1659 return;
1660 }
1661 AUTH_LOGD(AUTH_FSM, "discTypeStr=%{public}s", discTypeStr);
1662 JSON_AddStringToObject(json, DISCOVERY_TYPE, discTypeStr);
1663 }
1664
PackBt(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth, const char *remoteUuid)1665 static int32_t PackBt(JsonObj *json, const NodeInfo *info, SoftBusVersion version,
1666 bool isMetaAuth, const char *remoteUuid)
1667 {
1668 if (!JSON_AddInt32ToObject(json, CODE, CODE_VERIFY_BT)) {
1669 AUTH_LOGE(AUTH_FSM, "add bt info fail");
1670 return SOFTBUS_ERR;
1671 }
1672 AddDiscoveryType(json, remoteUuid);
1673 int32_t delayTime = BLE_CONNECTION_CLOSE_DELAY;
1674 if (SoftbusGetConfig(SOFTBUS_INT_CONN_BLE_CLOSE_DELAY_TIME,
1675 (unsigned char *)(&delayTime), sizeof(delayTime)) != SOFTBUS_OK) {
1676 AUTH_LOGI(AUTH_FSM, "get ble conn close delay time from config file fail");
1677 }
1678 int32_t bleMacRefreshSwitch = BLE_MAC_AUTO_REFRESH_SWITCH;
1679 if (SoftbusGetConfig(SOFTBUS_INT_BLE_MAC_AUTO_REFRESH_SWITCH,
1680 (unsigned char *)(&bleMacRefreshSwitch), sizeof(bleMacRefreshSwitch)) != SOFTBUS_OK) {
1681 AUTH_LOGI(AUTH_FSM, "get ble mac refresh switch from config file fail");
1682 }
1683 if (!JSON_AddInt32ToObject(json, BLE_CONN_CLOSE_DELAY_TIME, delayTime) ||
1684 !JSON_AddInt32ToObject(json, BLE_MAC_REFRESH_SWITCH, bleMacRefreshSwitch)) {
1685 AUTH_LOGI(AUTH_FSM, "add ble conn close delay time or refresh switch fail");
1686 }
1687 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
1688 AUTH_LOGE(AUTH_FSM, "PackCommon fail");
1689 return SOFTBUS_ERR;
1690 }
1691 return SOFTBUS_OK;
1692 }
1693
SetDiscType(uint32_t *discType, const char *discStr)1694 static int32_t SetDiscType(uint32_t *discType, const char *discStr)
1695 {
1696 if (strcmp(discStr, DEFAULT_BT_DISC_TYPE_STR) == 0) {
1697 AUTH_LOGE(AUTH_FSM, "disc type can't parse");
1698 return SOFTBUS_ERR;
1699 }
1700 return SOFTBUS_OK;
1701 }
1702
UnpackBt(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)1703 static int32_t UnpackBt(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1704 {
1705 char discTypeStr[BT_DISC_TYPE_MAX_LEN] = {0};
1706 if (!JSON_GetInt64FromOject(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
1707 info->supportedProtocols = LNN_PROTOCOL_BR | LNN_PROTOCOL_BLE;
1708 }
1709 OptString(json, DISCOVERY_TYPE, discTypeStr, BT_DISC_TYPE_MAX_LEN, DEFAULT_BT_DISC_TYPE_STR);
1710 (void)SetDiscType(&info->discoveryType, discTypeStr);
1711 OptInt64(json, BLE_TIMESTAMP, &info->bleStartTimestamp, DEFAULT_BLE_TIMESTAMP);
1712 OptInt(json, STATE_VERSION, &info->stateVersion, 0);
1713 OptInt(json, BLE_CONN_CLOSE_DELAY_TIME, &info->bleConnCloseDelayTime, BLE_CONNECTION_CLOSE_DELAY);
1714 OptInt(json, BLE_MAC_REFRESH_SWITCH, &info->bleMacRefreshSwitch, BLE_MAC_AUTO_REFRESH_SWITCH);
1715 UnpackCommon(json, info, version, isMetaAuth);
1716 return SOFTBUS_OK;
1717 }
1718
PackWiFi(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)1719 static int32_t PackWiFi(JsonObj *json, const NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1720 {
1721 AUTH_LOGD(AUTH_FSM, "devIp=%{public}zu", strlen(info->connectInfo.deviceIp));
1722 if (!JSON_AddInt32ToObject(json, CODE, CODE_VERIFY_IP) || !JSON_AddInt32ToObject(json, BUS_MAX_VERSION, BUS_V2) ||
1723 !JSON_AddInt32ToObject(json, BUS_MIN_VERSION, BUS_V1) ||
1724 !JSON_AddInt32ToObject(json, AUTH_PORT, LnnGetAuthPort(info)) ||
1725 !JSON_AddInt32ToObject(json, SESSION_PORT, LnnGetSessionPort(info)) ||
1726 !JSON_AddInt32ToObject(json, PROXY_PORT, LnnGetProxyPort(info)) ||
1727 !JSON_AddStringToObject(json, DEV_IP, info->connectInfo.deviceIp)) {
1728 AUTH_LOGE(AUTH_FSM, "add wifi info fail");
1729 return SOFTBUS_ERR;
1730 }
1731 char offlineCode[BASE64_OFFLINE_CODE_LEN] = {0};
1732 size_t len = 0;
1733 AUTH_LOGE(AUTH_FSM, "offlineCodeLen=%{public}zu, offlineCodeSize=%{public}zu",
1734 strlen(offlineCode), sizeof(info->offlineCode));
1735 int32_t ret = SoftBusBase64Encode((unsigned char*)offlineCode, BASE64_OFFLINE_CODE_LEN, &len,
1736 (unsigned char*)info->offlineCode, sizeof(info->offlineCode));
1737 if (ret != 0) {
1738 AUTH_LOGE(AUTH_FSM, "mbedtls base64 encode failed");
1739 return SOFTBUS_ERR;
1740 }
1741 (void)JSON_AddStringToObject(json, BLE_OFFLINE_CODE, offlineCode);
1742 if (PackCommon(json, info, version, isMetaAuth) != SOFTBUS_OK) {
1743 AUTH_LOGE(AUTH_FSM, "PackCommon fail");
1744 return SOFTBUS_ERR;
1745 }
1746 return SOFTBUS_OK;
1747 }
1748
CheckBusVersion(const JsonObj *json)1749 static int32_t CheckBusVersion(const JsonObj *json)
1750 {
1751 int32_t maxVersion;
1752 int32_t minVersion;
1753 OptInt(json, BUS_MAX_VERSION, &maxVersion, -1);
1754 OptInt(json, BUS_MIN_VERSION, &minVersion, -1);
1755 if (maxVersion > BUS_V2) {
1756 maxVersion = BUS_V2;
1757 }
1758 if (minVersion < BUS_V1) {
1759 minVersion = BUS_V1;
1760 }
1761 if (maxVersion < 0 || maxVersion < minVersion) {
1762 AUTH_LOGE(AUTH_FSM, "no common version");
1763 return SOFTBUS_ERR;
1764 }
1765 return maxVersion;
1766 }
1767
UnpackWiFi(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)1768 static int32_t UnpackWiFi(const JsonObj *json, NodeInfo *info, SoftBusVersion version, bool isMetaAuth)
1769 {
1770 if (CheckBusVersion(json) < 0) {
1771 return SOFTBUS_ERR;
1772 }
1773 (void)JSON_GetInt32FromOject(json, AUTH_PORT, &info->connectInfo.authPort);
1774 (void)JSON_GetInt32FromOject(json, SESSION_PORT, &info->connectInfo.sessionPort);
1775 (void)JSON_GetInt32FromOject(json, PROXY_PORT, &info->connectInfo.proxyPort);
1776 if (!JSON_GetInt64FromOject(json, TRANSPORT_PROTOCOL, (int64_t *)&info->supportedProtocols)) {
1777 info->supportedProtocols = LNN_PROTOCOL_IP;
1778 }
1779 char offlineCode[BASE64_OFFLINE_CODE_LEN] = {0};
1780 OptString(json, DEV_IP, info->connectInfo.deviceIp, MAX_ADDR_LEN, ""); // check ip available
1781 OptString(json, BLE_OFFLINE_CODE, offlineCode, BASE64_OFFLINE_CODE_LEN, "");
1782 size_t len;
1783 if (SoftBusBase64Decode(info->offlineCode, OFFLINE_CODE_BYTE_SIZE,
1784 &len, (const unsigned char *)offlineCode, strlen(offlineCode)) != 0) {
1785 AUTH_LOGE(AUTH_FSM, "base64Decode fail");
1786 }
1787 if (len != OFFLINE_CODE_BYTE_SIZE) {
1788 AUTH_LOGE(AUTH_FSM, "base64Decode data err");
1789 }
1790 UnpackCommon(json, info, version, isMetaAuth);
1791 return SOFTBUS_OK;
1792 }
1793
PackDeviceInfoMac(JsonObj *json, const NodeInfo *info, bool isMetaAuth)1794 static int32_t PackDeviceInfoMac(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
1795 {
1796 AUTH_LOGI(AUTH_FSM, "pack deviceInfo mac");
1797 if (!JSON_AddStringToObject(json, BR_MAC_ADDR, LnnGetBtMac(info)) ||
1798 !JSON_AddStringToObject(json, P2P_MAC_ADDR, LnnGetP2pMac(info)) ||
1799 !JSON_AddStringToObject(json, BT_MAC, info->connectInfo.macAddr) ||
1800 !JSON_AddStringToObject(json, HML_MAC, info->wifiDirectAddr)) {
1801 AUTH_LOGE(AUTH_FSM, "add mac info fail");
1802 return SOFTBUS_AUTH_REG_DATA_FAIL;
1803 }
1804 return SOFTBUS_OK;
1805 }
1806
PackDeviceInfoBtV1(JsonObj *json, const NodeInfo *info, bool isMetaAuth)1807 static int32_t PackDeviceInfoBtV1(JsonObj *json, const NodeInfo *info, bool isMetaAuth)
1808 {
1809 AUTH_LOGI(AUTH_FSM, "pack deviceInfo bt-v1");
1810 if (PackDeviceInfoMac(json, info, isMetaAuth) != SOFTBUS_OK) {
1811 AUTH_LOGI(AUTH_FSM, "add packdevice mac info fail ");
1812 return SOFTBUS_AUTH_REG_DATA_FAIL;
1813 }
1814 char localDevName[DEVICE_NAME_BUF_LEN] = {0};
1815 int32_t ret = LnnGetLocalStrInfo(STRING_KEY_DEV_NAME, localDevName, sizeof(localDevName));
1816 if (ret == SOFTBUS_OK) {
1817 (void)JSON_AddStringToObject(json, DEVICE_NAME, localDevName);
1818 } else {
1819 (void)JSON_AddStringToObject(json, DEVICE_NAME, LnnGetDeviceName(&info->deviceInfo));
1820 }
1821 if (!JSON_AddStringToObject(json, DEVICE_TYPE, LnnConvertIdToDeviceType(info->deviceInfo.deviceTypeId)) ||
1822 !JSON_AddStringToObject(json, DEVICE_VERSION_TYPE, info->versionType) ||
1823 !JSON_AddStringToObject(json, UUID, info->uuid) ||
1824 !JSON_AddStringToObject(json, SW_VERSION, info->softBusVersion) ||
1825 !JSON_AddStringToObject(json, DEVICE_UDID, info->deviceInfo.deviceUdid) ||
1826 !JSON_AddInt64ToObject(json, WIFI_VERSION, info->wifiVersion) ||
1827 !JSON_AddInt64ToObject(json, BLE_VERSION, info->bleVersion) ||
1828 !JSON_AddInt64ToObject(json, CONN_CAP, info->netCapacity) ||
1829 !JSON_AddInt64ToObject(json, NEW_CONN_CAP, info->netCapacity) ||
1830 !JSON_AddInt32ToObject(json, REMAIN_POWER, info->batteryInfo.batteryLevel) ||
1831 !JSON_AddBoolToObject(json, IS_CHARGING, info->batteryInfo.isCharging) ||
1832 !JSON_AddBoolToObject(json, IS_SCREENON, info->isScreenOn) ||
1833 !JSON_AddInt32ToObject(json, P2P_ROLE, info->p2pInfo.p2pRole) ||
1834 !JSON_AddInt64ToObject(json, ACCOUNT_ID, info->accountId) ||
1835 !JSON_AddInt32ToObject(json, NODE_WEIGHT, info->masterWeight) ||
1836 !JSON_AddInt32ToObject(json, STATE_VERSION_CHANGE_REASON, info->stateVersionReason)) {
1837 AUTH_LOGE(AUTH_FSM, "add wifi info fail");
1838 return SOFTBUS_ERR;
1839 }
1840 return SOFTBUS_OK;
1841 }
1842
UnpackDeviceInfoBtV1(const JsonObj *json, NodeInfo *info)1843 static int32_t UnpackDeviceInfoBtV1(const JsonObj *json, NodeInfo *info)
1844 {
1845 char deviceType[DEVICE_TYPE_BUF_LEN] = { 0 };
1846 if (!JSON_GetStringFromOject(json, DEVICE_NAME, info->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN) ||
1847 !JSON_GetStringFromOject(json, DEVICE_TYPE, deviceType, DEVICE_TYPE_BUF_LEN) ||
1848 !JSON_GetStringFromOject(json, DEVICE_UDID, info->deviceInfo.deviceUdid, UDID_BUF_LEN) ||
1849 !JSON_GetStringFromOject(json, UUID, info->uuid, UUID_BUF_LEN) ||
1850 !JSON_GetStringFromOject(json, BR_MAC_ADDR, info->connectInfo.macAddr, MAC_LEN)) {
1851 AUTH_LOGE(AUTH_FSM, "prase devinfo fail, invalid msg");
1852 return SOFTBUS_ERR;
1853 }
1854 (void)LnnConvertDeviceTypeToId(deviceType, &(info->deviceInfo.deviceTypeId));
1855 OptString(json, HML_MAC, info->wifiDirectAddr, MAC_LEN, "");
1856 OptString(json, P2P_MAC_ADDR, info->p2pInfo.p2pMac, MAC_LEN, "");
1857 OptString(json, SW_VERSION, info->softBusVersion, VERSION_MAX_LEN, "");
1858 OptString(json, DEVICE_VERSION_TYPE, info->versionType, VERSION_MAX_LEN, "");
1859 OptInt64(json, WIFI_VERSION, &info->wifiVersion, 0);
1860 OptInt64(json, BLE_VERSION, &info->bleVersion, 0);
1861 OptInt(json, REMAIN_POWER, &info->batteryInfo.batteryLevel, DEFAULT_BATTERY_LEVEL);
1862 OptBool(json, IS_CHARGING, &info->batteryInfo.isCharging, false);
1863 OptBool(json, IS_SCREENON, &info->isScreenOn, false);
1864 OptInt(json, P2P_ROLE, &info->p2pInfo.p2pRole, 0);
1865 OptInt64(json, ACCOUNT_ID, &info->accountId, 0);
1866 OptInt(json, NODE_WEIGHT, &info->masterWeight, DEFAULT_NODE_WEIGHT);
1867 OptInt64(json, FEATURE, (int64_t *)&info->feature, 0);
1868 OptInt(json, STATE_VERSION_CHANGE_REASON, (int32_t *)&info->stateVersionReason, 0);
1869 OptInt64(json, NEW_CONN_CAP, (int64_t *)&info->netCapacity, -1);
1870 if (info->netCapacity == (uint32_t)-1) {
1871 OptInt64(json, CONN_CAP, (int64_t *)&info->netCapacity, 0);
1872 }
1873 if (strcpy_s(info->networkId, NETWORK_ID_BUF_LEN, info->uuid) != EOK) {
1874 AUTH_LOGE(AUTH_FSM, "strcpy networkId fail");
1875 return SOFTBUS_ERR;
1876 }
1877 return SOFTBUS_OK;
1878 }
1879
PackCertificateInfo(JsonObj *json, const AuthSessionInfo *info)1880 static int32_t PackCertificateInfo(JsonObj *json, const AuthSessionInfo *info)
1881 {
1882 if (info == NULL || !IsSupportUDIDAbatement() || !info->isNeedPackCert) {
1883 AUTH_LOGI(AUTH_FSM, "device not support udid abatement or no need");
1884 return SOFTBUS_OK;
1885 }
1886
1887 SoftbusCertChain softbusCertChain;
1888 (void)memset_s(&softbusCertChain, sizeof(SoftbusCertChain), 0, sizeof(SoftbusCertChain));
1889 if (GenerateCertificate(&softbusCertChain, info) != SOFTBUS_OK) {
1890 AUTH_LOGW(AUTH_FSM, "GenerateCertificate fail");
1891 return SOFTBUS_OK;
1892 }
1893 if (!JSON_AddBytesToObject(json, ATTEST_CERTS, softbusCertChain.cert[ATTEST_CERTS_INDEX].data,
1894 softbusCertChain.cert[ATTEST_CERTS_INDEX].size) ||
1895 !JSON_AddBytesToObject(json, DEVICE_CERTS, softbusCertChain.cert[DEVICE_CERTS_INDEX].data,
1896 softbusCertChain.cert[DEVICE_CERTS_INDEX].size) ||
1897 !JSON_AddBytesToObject(json, MANUFACTURE_CERTS, softbusCertChain.cert[MANUFACTURE_CERTS_INDEX].data,
1898 softbusCertChain.cert[MANUFACTURE_CERTS_INDEX].size) ||
1899 !JSON_AddBytesToObject(json, ROOT_CERTS, softbusCertChain.cert[ROOT_CERTS_INDEX].data,
1900 softbusCertChain.cert[ROOT_CERTS_INDEX].size)) {
1901 FreeSoftbusChain(&softbusCertChain);
1902 AUTH_LOGE(AUTH_FSM, "pack certChain fail.");
1903 return SOFTBUS_AUTH_INNER_ERR;
1904 }
1905 FreeSoftbusChain(&softbusCertChain);
1906 return SOFTBUS_OK;
1907 }
1908
UnpackCertificateInfo(JsonObj *json, NodeInfo *nodeInfo, const AuthSessionInfo *info)1909 static int32_t UnpackCertificateInfo(JsonObj *json, NodeInfo *nodeInfo, const AuthSessionInfo *info)
1910 {
1911 if (info == NULL || !IsSupportUDIDAbatement() || !IsNeedUDIDAbatement(info)) {
1912 AUTH_LOGI(AUTH_FSM, "device not support udid abatement or no need");
1913 return SOFTBUS_OK;
1914 }
1915 SoftbusCertChain softbusCertChain;
1916 (void)memset_s(&softbusCertChain, sizeof(SoftbusCertChain), 0, sizeof(SoftbusCertChain));
1917 if (InitSoftbusChain(&softbusCertChain) != SOFTBUS_OK) {
1918 AUTH_LOGW(AUTH_FSM, "malloc fail.");
1919 return SOFTBUS_OK;
1920 }
1921 if (!JSON_GetBytesFromObject(json, ATTEST_CERTS, softbusCertChain.cert[ATTEST_CERTS_INDEX].data,
1922 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[ATTEST_CERTS_INDEX].size) ||
1923 !JSON_GetBytesFromObject(json, DEVICE_CERTS, softbusCertChain.cert[DEVICE_CERTS_INDEX].data,
1924 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[DEVICE_CERTS_INDEX].size) ||
1925 !JSON_GetBytesFromObject(json, MANUFACTURE_CERTS, softbusCertChain.cert[MANUFACTURE_CERTS_INDEX].data,
1926 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[MANUFACTURE_CERTS_INDEX].size) ||
1927 !JSON_GetBytesFromObject(json, ROOT_CERTS, softbusCertChain.cert[ROOT_CERTS_INDEX].data,
1928 SOFTBUS_CERTIFICATE_SIZE, &softbusCertChain.cert[ROOT_CERTS_INDEX].size)) {
1929 FreeSoftbusChain(&softbusCertChain);
1930 nodeInfo->deviceSecurityLevel = 0;
1931 AUTH_LOGE(AUTH_FSM, "unpack certChain fail.");
1932 return SOFTBUS_OK;
1933 }
1934 if (VerifyCertificate(&softbusCertChain, nodeInfo, info) != SOFTBUS_OK) {
1935 AUTH_LOGE(AUTH_FSM, "attest cert fail.");
1936 FreeSoftbusChain(&softbusCertChain);
1937 return SOFTBUS_ERR;
1938 }
1939 FreeSoftbusChain(&softbusCertChain);
1940 return SOFTBUS_OK;
1941 }
1942
UpdateLocalNetBrMac(void)1943 static void UpdateLocalNetBrMac(void)
1944 {
1945 NodeInfo info;
1946 if (memset_s(&info, sizeof(NodeInfo), 0, sizeof(NodeInfo)) != EOK) {
1947 AUTH_LOGE(AUTH_FSM, "memset_s fail");
1948 return;
1949 }
1950 if (LnnGetLocalNodeInfoSafe(&info) != SOFTBUS_OK) {
1951 AUTH_LOGE(AUTH_FSM, "get local node info fail");
1952 return;
1953 }
1954 const char *brMacTemp = LnnGetBtMac(&info);
1955 int32_t lenBrMac = strlen(brMacTemp);
1956 if ((lenBrMac == 0 || (strncmp(brMacTemp, INVALID_BR_MAC_ADDR, BT_MAC_LEN) == 0)) &&
1957 SoftBusGetBtState() == BLE_ENABLE) {
1958 char brMac[BT_MAC_LEN] = {0};
1959 SoftBusBtAddr mac = {0};
1960 int32_t ret = 0;
1961 ret = SoftBusGetBtMacAddr(&mac);
1962 if (ret != SOFTBUS_OK) {
1963 AUTH_LOGE(AUTH_FSM, "get bt mac addr fail, do not update local brmac");
1964 return;
1965 }
1966 ret = ConvertBtMacToStr(brMac, BT_MAC_LEN, mac.addr, sizeof(mac.addr));
1967 if (ret != SOFTBUS_OK || strlen(brMac) == 0) {
1968 AUTH_LOGE(AUTH_FSM, "convert bt mac to str fail, do not update local brmac");
1969 return;
1970 }
1971 if (LnnSetLocalStrInfo(STRING_KEY_BT_MAC, brMac) != SOFTBUS_OK) {
1972 AUTH_LOGE(AUTH_FSM, "set local brmac fail, do not update local brmac");
1973 return;
1974 }
1975 char *anonyMac = NULL;
1976 Anonymize(brMac, &anonyMac);
1977 AUTH_LOGI(AUTH_FSM, "update local brmac=%{public}s", AnonymizeWrapper(anonyMac));
1978 AnonymizeFree(anonyMac);
1979 }
1980 }
1981
PackDeviceInfoMessage(const AuthConnInfo *connInfo, SoftBusVersion version, bool isMetaAuth, const char *remoteUuid, const AuthSessionInfo *info)1982 char *PackDeviceInfoMessage(const AuthConnInfo *connInfo, SoftBusVersion version, bool isMetaAuth,
1983 const char *remoteUuid, const AuthSessionInfo *info)
1984 {
1985 // uuid and info is null in meta, no need check param
1986 if (connInfo == NULL) {
1987 AUTH_LOGE(AUTH_FSM, "conninfo is null");
1988 return NULL;
1989 }
1990 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", connInfo->type);
1991 UpdateLocalNetBrMac();
1992 const NodeInfo *nodeInfo = LnnGetLocalNodeInfo();
1993 if (nodeInfo == NULL) {
1994 AUTH_LOGE(AUTH_FSM, "local info is null");
1995 return NULL;
1996 }
1997 JsonObj *json = JSON_CreateObject();
1998 if (json == NULL) {
1999 AUTH_LOGE(AUTH_FSM, "create cjson fail");
2000 return NULL;
2001 }
2002 int32_t ret;
2003 if (connInfo->type == AUTH_LINK_TYPE_WIFI) {
2004 ret = PackWiFi(json, nodeInfo, version, isMetaAuth);
2005 } else if (version == SOFTBUS_OLD_V1) {
2006 ret = PackDeviceInfoBtV1(json, nodeInfo, isMetaAuth);
2007 } else {
2008 ret = PackBt(json, nodeInfo, version, isMetaAuth, remoteUuid);
2009 }
2010 if (ret != SOFTBUS_OK) {
2011 JSON_Delete(json);
2012 return NULL;
2013 }
2014 PackWifiDirectInfo(connInfo, json, nodeInfo, remoteUuid, isMetaAuth);
2015
2016 if (PackCertificateInfo(json, info) != SOFTBUS_OK) {
2017 AUTH_LOGE(AUTH_FSM, "packCertificateInfo fail");
2018 JSON_Delete(json);
2019 return NULL;
2020 }
2021 char *msg = JSON_PrintUnformatted(json);
2022 if (msg == NULL) {
2023 AUTH_LOGE(AUTH_FSM, "JSON_PrintUnformatted fail");
2024 }
2025 JSON_Delete(json);
2026 return msg;
2027 }
2028
UpdatePeerDeviceName(NodeInfo *peerNodeInfo)2029 static void UpdatePeerDeviceName(NodeInfo *peerNodeInfo)
2030 {
2031 const NodeInfo *localInfo = LnnGetLocalNodeInfo();
2032 if (localInfo == NULL) {
2033 AUTH_LOGE(AUTH_FSM, "localInfo is null");
2034 return;
2035 }
2036 int32_t ret = EOK;
2037 char deviceName[DEVICE_NAME_BUF_LEN] = {0};
2038 if (strlen(peerNodeInfo->deviceInfo.unifiedName) != 0 &&
2039 strcmp(peerNodeInfo->deviceInfo.unifiedName, peerNodeInfo->deviceInfo.unifiedDefaultName) != 0) {
2040 ret = strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedName);
2041 } else if (strlen(peerNodeInfo->deviceInfo.nickName) == 0 || localInfo->accountId == peerNodeInfo->accountId) {
2042 ret = strcpy_s(deviceName, DEVICE_NAME_BUF_LEN, peerNodeInfo->deviceInfo.unifiedDefaultName);
2043 } else {
2044 LnnGetDeviceDisplayName(peerNodeInfo->deviceInfo.nickName,
2045 peerNodeInfo->deviceInfo.unifiedDefaultName, deviceName, DEVICE_NAME_BUF_LEN);
2046 }
2047 char *anonyDeviceName = NULL;
2048 Anonymize(deviceName, &anonyDeviceName);
2049 char *anonyPeerDeviceName = NULL;
2050 Anonymize(peerNodeInfo->deviceInfo.deviceName, &anonyPeerDeviceName);
2051 char *anonyUnifiedName = NULL;
2052 Anonymize(peerNodeInfo->deviceInfo.unifiedName, &anonyUnifiedName);
2053 char *anonyUnifiedDefaultName = NULL;
2054 Anonymize(peerNodeInfo->deviceInfo.unifiedDefaultName, &anonyUnifiedDefaultName);
2055 char *anonyNickName = NULL;
2056 Anonymize(peerNodeInfo->deviceInfo.nickName, &anonyNickName);
2057 AUTH_LOGD(AUTH_FSM,
2058 "peer tmpDeviceName=%{public}s, deviceName=%{public}s, unifiedName=%{public}s, "
2059 "unifiedDefaultName=%{public}s, nickName=%{public}s",
2060 AnonymizeWrapper(anonyDeviceName), AnonymizeWrapper(anonyPeerDeviceName),
2061 AnonymizeWrapper(anonyUnifiedName), AnonymizeWrapper(anonyUnifiedDefaultName),
2062 AnonymizeWrapper(anonyNickName));
2063 AnonymizeFree(anonyDeviceName);
2064 AnonymizeFree(anonyPeerDeviceName);
2065 AnonymizeFree(anonyUnifiedName);
2066 AnonymizeFree(anonyUnifiedDefaultName);
2067 AnonymizeFree(anonyNickName);
2068 if (strlen(deviceName) != 0) {
2069 ret = strcpy_s(peerNodeInfo->deviceInfo.deviceName, DEVICE_NAME_BUF_LEN, deviceName);
2070 }
2071 if (ret != EOK) {
2072 AUTH_LOGW(AUTH_FSM, "strcpy_s fail, use default name");
2073 }
2074 }
2075
UnpackDeviceInfoMessage(const DevInfoData *devInfo, NodeInfo *nodeInfo, bool isMetaAuth, const AuthSessionInfo *info)2076 int32_t UnpackDeviceInfoMessage(const DevInfoData *devInfo, NodeInfo *nodeInfo, bool isMetaAuth,
2077 const AuthSessionInfo *info)
2078 {
2079 AUTH_CHECK_AND_RETURN_RET_LOGE(devInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "devInfo is NULL");
2080 AUTH_CHECK_AND_RETURN_RET_LOGE(nodeInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "nodeInfo is NULL");
2081 AUTH_LOGI(AUTH_FSM, "connType=%{public}d", devInfo->linkType);
2082 JsonObj *json = JSON_Parse(devInfo->msg, devInfo->len);
2083 if (json == NULL) {
2084 AUTH_LOGE(AUTH_FSM, "parse cjson fail");
2085 return SOFTBUS_ERR;
2086 }
2087 int32_t ret;
2088 if (devInfo->linkType == AUTH_LINK_TYPE_WIFI) {
2089 ret = UnpackWiFi(json, nodeInfo, devInfo->version, isMetaAuth);
2090 } else if (devInfo->version == SOFTBUS_OLD_V1) {
2091 ret = UnpackDeviceInfoBtV1(json, nodeInfo);
2092 } else {
2093 ret = UnpackBt(json, nodeInfo, devInfo->version, isMetaAuth);
2094 }
2095 UnpackWifiDirectInfo(json, nodeInfo, isMetaAuth);
2096 if (UnpackCertificateInfo(json, nodeInfo, info) != SOFTBUS_OK) {
2097 JSON_Delete(json);
2098 return SOFTBUS_ERR;
2099 }
2100 JSON_Delete(json);
2101 int32_t stateVersion;
2102 if (LnnGetLocalNumInfo(NUM_KEY_STATE_VERSION, &stateVersion) == SOFTBUS_OK) {
2103 nodeInfo->localStateVersion = stateVersion;
2104 }
2105 if (IsFeatureSupport(nodeInfo->feature, BIT_SUPPORT_UNIFORM_NAME_CAPABILITY)) {
2106 UpdatePeerDeviceName(nodeInfo);
2107 }
2108 nodeInfo->updateTimestamp = SoftBusGetSysTimeMs();
2109 return ret;
2110 }
2111