1 /*
2  * Copyright (c) 2022-2023 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_common.h"
17 
18 #include <securec.h>
19 
20 #include "anonymizer.h"
21 #include "auth_log.h"
22 #include "bus_center_manager.h"
23 #include "message_handler.h"
24 #include "softbus_adapter_crypto.h"
25 #include "softbus_adapter_mem.h"
26 #include "softbus_adapter_timer.h"
27 #include "softbus_base_listener.h"
28 #include "softbus_def.h"
29 #include "softbus_feature_config.h"
30 
31 #define TIME_SEC_TO_MSEC  1000L
32 #define TIME_MSEC_TO_USEC 1000L
33 
34 #define SEQ_NETWORK_ID_BITS 32
35 #define SEQ_TIME_STAMP_BITS 8
36 #define SEQ_TIME_STAMP_MASK 0xFFL
37 #define SEQ_INTEGER_BITS    24
38 #define SEQ_INTEGER_MAX     0xFFFFFF
39 
40 #define AUTH_SUPPORT_AS_SERVER_MASK 0x01
41 
42 typedef struct {
43     EventType event;
44     RemoveCompareFunc cmpFunc;
45     void *param;
46 } EventRemoveInfo;
47 
48 static uint64_t g_uniqueId = 0;
49 static SoftBusMutex g_authLock;
50 static SoftBusHandler g_authHandler = { NULL, NULL, NULL };
51 
52 /* auth handler */
IsAuthHandlerInit(void)53 static bool IsAuthHandlerInit(void)
54 {
55     if (g_authHandler.looper == NULL || g_authHandler.looper->PostMessage == NULL ||
56         g_authHandler.looper->PostMessageDelay == NULL || g_authHandler.looper->RemoveMessageCustom == NULL) {
57         AUTH_LOGE(AUTH_INIT, "auth handler not init");
58         return false;
59     }
60     return true;
61 }
62 
DelAuthMessage(SoftBusMessage *msg)63 static void DelAuthMessage(SoftBusMessage *msg)
64 {
65     CHECK_NULL_PTR_RETURN_VOID(msg);
66     if (msg->obj != NULL) {
67         SoftBusFree(msg->obj);
68         msg->obj = NULL;
69     }
70     SoftBusFree(msg);
71 }
72 
NewAuthMessage(const uint8_t *obj, uint32_t size)73 static SoftBusMessage *NewAuthMessage(const uint8_t *obj, uint32_t size)
74 {
75     SoftBusMessage *msg = MallocMessage();
76     if (msg == NULL) {
77         AUTH_LOGE(AUTH_CONN, "malloc message fail");
78         return NULL;
79     }
80     msg->obj = NULL;
81     if (obj != NULL && size > 0) {
82         msg->obj = DupMemBuffer(obj, size);
83         if (msg->obj == NULL) {
84             AUTH_LOGE(AUTH_CONN, "dup data fail");
85             SoftBusFree(msg);
86             return NULL;
87         }
88     }
89     msg->handler = &g_authHandler;
90     msg->FreeMessage = DelAuthMessage;
91     return msg;
92 }
93 
HandleAuthMessage(SoftBusMessage *msg)94 static void HandleAuthMessage(SoftBusMessage *msg)
95 {
96     CHECK_NULL_PTR_RETURN_VOID(msg);
97     EventHandler handler = (EventHandler)(uintptr_t)msg->arg1;
98     if (handler == NULL) {
99         AUTH_LOGE(AUTH_CONN, "invalid event handler, event=%{public}d", msg->what);
100         return;
101     }
102     handler(msg->obj);
103 }
104 
PostAuthEvent(EventType event, EventHandler handler, const void *obj, uint32_t size, uint64_t delayMs)105 int32_t PostAuthEvent(EventType event, EventHandler handler, const void *obj, uint32_t size, uint64_t delayMs)
106 {
107     if (!IsAuthHandlerInit()) {
108         return SOFTBUS_NO_INIT;
109     }
110     SoftBusMessage *msg = NewAuthMessage(obj, size);
111     if (msg == NULL) {
112         AUTH_LOGE(AUTH_CONN, "malloc fail, event=%{public}d", event);
113         return SOFTBUS_MALLOC_ERR;
114     }
115     msg->what = (int32_t)event;
116     msg->arg1 = (uint64_t)(uintptr_t)handler;
117     if (delayMs == 0) {
118         g_authHandler.looper->PostMessage(g_authHandler.looper, msg);
119     } else {
120         g_authHandler.looper->PostMessageDelay(g_authHandler.looper, msg, delayMs);
121     }
122     return SOFTBUS_OK;
123 }
124 
CustomFunc(const SoftBusMessage *msg, void *param)125 static int32_t CustomFunc(const SoftBusMessage *msg, void *param)
126 {
127     CHECK_NULL_PTR_RETURN_VALUE(msg, SOFTBUS_ERR);
128     CHECK_NULL_PTR_RETURN_VALUE(param, SOFTBUS_ERR);
129     EventRemoveInfo *info = (EventRemoveInfo *)param;
130     if (msg->what != (int32_t)info->event) {
131         AUTH_LOGE(AUTH_CONN, "msg->what and event inequality");
132         return SOFTBUS_ERR;
133     }
134     if (info->cmpFunc == NULL) {
135         AUTH_LOGE(AUTH_CONN, "cmpFunc is null");
136         return SOFTBUS_ERR;
137     }
138     return info->cmpFunc(msg->obj, info->param);
139 }
140 
RemoveAuthEvent(EventType event, RemoveCompareFunc func, void *param)141 int32_t RemoveAuthEvent(EventType event, RemoveCompareFunc func, void *param)
142 {
143     if (!IsAuthHandlerInit()) {
144         return SOFTBUS_NO_INIT;
145     }
146     EventRemoveInfo info = {
147         .event = event,
148         .cmpFunc = func,
149         .param = param,
150     };
151     g_authHandler.looper->RemoveMessageCustom(g_authHandler.looper, &g_authHandler, CustomFunc, &info);
152     return SOFTBUS_OK;
153 }
154 
155 /* auth lock */
RequireAuthLock(void)156 bool RequireAuthLock(void)
157 {
158     if (SoftBusMutexLock(&g_authLock) != SOFTBUS_OK) {
159         AUTH_LOGE(AUTH_CONN, "auth lock fail");
160         return false;
161     }
162     return true;
163 }
164 
ReleaseAuthLock(void)165 void ReleaseAuthLock(void)
166 {
167     if (SoftBusMutexUnlock(&g_authLock) != SOFTBUS_OK) {
168         AUTH_LOGE(AUTH_CONN, "auth unlock fail");
169     }
170 }
171 
172 /* auth config */
GetConfigSupportAsServer(void)173 bool GetConfigSupportAsServer(void)
174 {
175     uint32_t ability = 0;
176     if (SoftbusGetConfig(SOFTBUS_INT_AUTH_ABILITY_COLLECTION, (uint8_t *)(&ability), sizeof(ability)) != SOFTBUS_OK) {
177         AUTH_LOGE(AUTH_CONN, "get auth ability from config file fail");
178     }
179     AUTH_LOGI(AUTH_CONN, "auth ability=%{public}u", ability);
180     return ((ability & AUTH_SUPPORT_AS_SERVER_MASK) != 0);
181 }
182 
183 /* auth capacity */
GetAuthCapacity(void)184 uint32_t GetAuthCapacity(void)
185 {
186     uint32_t authCapacity = 0;
187     if (SoftbusGetConfig(SOFTBUS_INT_AUTH_CAPACITY, (uint8_t *)(&authCapacity), sizeof(authCapacity)) != SOFTBUS_OK) {
188         AUTH_LOGE(AUTH_CONN, "get auth capacity from config file fail");
189     }
190     AUTH_LOGI(AUTH_CONN, "auth capacity=%{public}u", authCapacity);
191     return authCapacity;
192 }
193 
194 /* auth common function */
DupMemBuffer(const uint8_t *buf, uint32_t size)195 uint8_t *DupMemBuffer(const uint8_t *buf, uint32_t size)
196 {
197     if (buf == NULL || size == 0) {
198         AUTH_LOGE(AUTH_CONN, "param err");
199         return NULL;
200     }
201     uint8_t *dup = (uint8_t *)SoftBusMalloc(size);
202     if (dup == NULL) {
203         AUTH_LOGE(AUTH_CONN, "malloc err");
204         return NULL;
205     }
206     if (memcpy_s(dup, size, buf, size) != EOK) {
207         AUTH_LOGE(AUTH_CONN, "memcpy err");
208         SoftBusFree(dup);
209         return NULL;
210     }
211     return dup;
212 }
213 
UpdateUniqueId(void)214 static void UpdateUniqueId(void)
215 {
216     char networkId[NETWORK_ID_BUF_LEN] = { 0 };
217     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, networkId, sizeof(networkId)) != SOFTBUS_OK) {
218         AUTH_LOGE(AUTH_CONN, "get local networkId fail");
219         return;
220     }
221     uint8_t hashId[SHA_256_HASH_LEN] = { 0 };
222     if (SoftBusGenerateStrHash((uint8_t *)networkId, strlen(networkId), hashId) != SOFTBUS_OK) {
223         AUTH_LOGE(AUTH_CONN, "GenerateStrHash fail");
224         return;
225     }
226     for (uint32_t i = 0; i < SEQ_NETWORK_ID_BITS / BYTES_BIT_NUM; i++) {
227         g_uniqueId = (g_uniqueId << BYTES_BIT_NUM) | hashId[i];
228     }
229     uint64_t timeStamp = GetCurrentTimeMs();
230     g_uniqueId = (g_uniqueId << SEQ_TIME_STAMP_BITS) | (SEQ_TIME_STAMP_MASK & timeStamp);
231 }
232 
GenSeq(bool isServer)233 int64_t GenSeq(bool isServer)
234 {
235     static uint32_t integer = 0;
236     if (integer >= SEQ_INTEGER_MAX) {
237         integer = 0;
238     }
239     if (integer == 0) {
240         UpdateUniqueId();
241     }
242     integer += SEQ_INTERVAL;
243     uint64_t seq = isServer ? (integer + 1) : integer;
244     /* |----NetworkIdHash(32)----|-----timeStamp(8)----|----AtomicInteger(24)----| */
245     seq = (g_uniqueId << SEQ_INTEGER_BITS) | (seq & SEQ_INTEGER_MAX);
246     return (int64_t)seq;
247 }
248 
GetCurrentTimeMs(void)249 uint64_t GetCurrentTimeMs(void)
250 {
251     SoftBusSysTime now = { 0 };
252     if (SoftBusGetTime(&now) != SOFTBUS_OK) {
253         AUTH_LOGE(AUTH_CONN, "SoftBusGetTime fail");
254         return 0;
255     }
256     return (uint64_t)now.sec * TIME_SEC_TO_MSEC + (uint64_t)now.usec / TIME_MSEC_TO_USEC;
257 }
258 
GetAuthSideStr(bool isServer)259 const char *GetAuthSideStr(bool isServer)
260 {
261     return isServer ? "server" : "client";
262 }
263 
CompareConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)264 bool CompareConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
265 {
266     CHECK_NULL_PTR_RETURN_VALUE(info1, false);
267     CHECK_NULL_PTR_RETURN_VALUE(info2, false);
268     bool isLinkble = false;
269     switch (info1->type) {
270         case AUTH_LINK_TYPE_WIFI:
271             if (info2->type == AUTH_LINK_TYPE_WIFI && strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
272                 return true;
273             }
274             break;
275         case AUTH_LINK_TYPE_BR:
276             if (info2->type == AUTH_LINK_TYPE_BR &&
277                 StrCmpIgnoreCase(info1->info.brInfo.brMac, info2->info.brInfo.brMac) == 0) {
278                 return true;
279             }
280             break;
281         case AUTH_LINK_TYPE_BLE:
282             isLinkble = (info2->type == AUTH_LINK_TYPE_BLE &&
283                 (memcmp(info1->info.bleInfo.deviceIdHash, info2->info.bleInfo.deviceIdHash,
284                 (cmpShortHash ? SHORT_HASH_LEN : UDID_HASH_LEN)) == 0 ||
285                 StrCmpIgnoreCase(info1->info.bleInfo.bleMac, info2->info.bleInfo.bleMac) == 0));
286             if (isLinkble) {
287                 return true;
288             }
289             break;
290         case AUTH_LINK_TYPE_P2P:
291             if (info2->type == AUTH_LINK_TYPE_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
292                 strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
293                 return true;
294             }
295             break;
296         case AUTH_LINK_TYPE_ENHANCED_P2P:
297             if (info2->type == AUTH_LINK_TYPE_ENHANCED_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
298                 strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
299                 return true;
300             }
301             break;
302         default:
303             return false;
304     }
305     return false;
306 }
307 
SetP2pSocketOption(const AuthConnInfo *connInfo, ConnectOption *option)308 static int32_t SetP2pSocketOption(const AuthConnInfo *connInfo, ConnectOption *option)
309 {
310     CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
311     CHECK_NULL_PTR_RETURN_VALUE(option, SOFTBUS_INVALID_PARAM);
312     option->type = CONNECT_TCP;
313     if (strcpy_s(option->socketOption.addr, sizeof(option->socketOption.addr), connInfo->info.ipInfo.ip) != EOK) {
314         AUTH_LOGE(AUTH_CONN, "copy ip fail");
315         return SOFTBUS_MEM_ERR;
316     }
317     option->socketOption.port = connInfo->info.ipInfo.port;
318     option->socketOption.protocol = LNN_PROTOCOL_IP;
319     option->socketOption.keepAlive = 1;
320     if (connInfo->type == AUTH_LINK_TYPE_P2P) {
321         option->socketOption.moduleId = AUTH_P2P;
322     } else {
323         option->socketOption.moduleId = connInfo->info.ipInfo.moduleId;
324     }
325     return SOFTBUS_OK;
326 }
327 
ConvertToConnectOption(const AuthConnInfo *connInfo, ConnectOption *option)328 int32_t ConvertToConnectOption(const AuthConnInfo *connInfo, ConnectOption *option)
329 {
330     CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
331     CHECK_NULL_PTR_RETURN_VALUE(option, SOFTBUS_INVALID_PARAM);
332     switch (connInfo->type) {
333         case AUTH_LINK_TYPE_BR:
334             option->type = CONNECT_BR;
335             if (strcpy_s(option->brOption.brMac, BT_MAC_LEN, connInfo->info.brInfo.brMac) != EOK) {
336                 AUTH_LOGE(AUTH_CONN, "copy brMac fail");
337                 return SOFTBUS_MEM_ERR;
338             }
339             option->brOption.connectionId = connInfo->info.brInfo.connectionId;
340             break;
341         case AUTH_LINK_TYPE_BLE:
342             option->type = CONNECT_BLE;
343             if (strcpy_s(option->bleOption.bleMac, BT_MAC_LEN, connInfo->info.bleInfo.bleMac) != EOK ||
344                 memcpy_s(option->bleOption.deviceIdHash, UDID_HASH_LEN, connInfo->info.bleInfo.deviceIdHash,
345                     UDID_HASH_LEN) != EOK) {
346                 AUTH_LOGE(AUTH_CONN, "copy bleMac/deviceIdHash fail");
347                 return SOFTBUS_MEM_ERR;
348             }
349             option->bleOption.fastestConnectEnable = true;
350             option->bleOption.psm = connInfo->info.bleInfo.psm;
351             option->bleOption.protocol = connInfo->info.bleInfo.protocol;
352             break;
353         case AUTH_LINK_TYPE_P2P:
354         case AUTH_LINK_TYPE_ENHANCED_P2P:
355             if (SetP2pSocketOption(connInfo, option) != SOFTBUS_OK) {
356                 return SOFTBUS_MEM_ERR;
357             }
358             break;
359         default:
360             AUTH_LOGE(AUTH_CONN, "unexpected connType=%{public}d", connInfo->type);
361             return SOFTBUS_ERR;
362     }
363     return SOFTBUS_OK;
364 }
365 
IsEnhanceP2pModuleId(ListenerModule moduleId)366 static bool IsEnhanceP2pModuleId(ListenerModule moduleId)
367 {
368     if (moduleId >= AUTH_ENHANCED_P2P_START && moduleId <= AUTH_ENHANCED_P2P_END) {
369         return true;
370     }
371     return false;
372 }
373 
ConvertToAuthConnInfo(const ConnectionInfo *info, AuthConnInfo *connInfo)374 int32_t ConvertToAuthConnInfo(const ConnectionInfo *info, AuthConnInfo *connInfo)
375 {
376     CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
377     CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
378     switch (info->type) {
379         case CONNECT_TCP:
380             if (info->socketInfo.protocol != LNN_PROTOCOL_IP) {
381                 AUTH_LOGW(AUTH_CONN, "only support LNN_PROTOCOL_IP");
382                 return SOFTBUS_ERR;
383             }
384             if (IsEnhanceP2pModuleId(info->socketInfo.moduleId)) {
385                 connInfo->type = AUTH_LINK_TYPE_ENHANCED_P2P;
386             } else {
387                 connInfo->type = AUTH_LINK_TYPE_P2P;
388             }
389             connInfo->info.ipInfo.moduleId = info->socketInfo.moduleId;
390             connInfo->info.ipInfo.port = info->socketInfo.port;
391             if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, info->socketInfo.addr) != EOK) {
392                 AUTH_LOGE(AUTH_CONN, "copy ip fail");
393                 return SOFTBUS_MEM_ERR;
394             }
395             break;
396         case CONNECT_BR:
397             connInfo->type = AUTH_LINK_TYPE_BR;
398             if (strcpy_s(connInfo->info.brInfo.brMac, BT_MAC_LEN, info->brInfo.brMac) != EOK) {
399                 AUTH_LOGE(AUTH_CONN, "copy brMac fail");
400                 return SOFTBUS_MEM_ERR;
401             }
402             break;
403         case CONNECT_BLE:
404             connInfo->type = AUTH_LINK_TYPE_BLE;
405             if (strcpy_s(connInfo->info.bleInfo.bleMac, BT_MAC_LEN, info->bleInfo.bleMac) != EOK ||
406                 memcpy_s(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN, info->bleInfo.deviceIdHash,
407                     UDID_HASH_LEN) != EOK) {
408                 AUTH_LOGE(AUTH_CONN, "copy bleMac/deviceIdHash fail");
409                 return SOFTBUS_MEM_ERR;
410             }
411             connInfo->info.bleInfo.protocol = info->bleInfo.protocol;
412             connInfo->info.bleInfo.psm = info->bleInfo.psm;
413             break;
414         default:
415             AUTH_LOGE(AUTH_CONN, "unexpected connType=%{public}d", info->type);
416             return SOFTBUS_ERR;
417     }
418     return SOFTBUS_OK;
419 }
420 
ConvertToDiscoveryType(AuthLinkType type)421 DiscoveryType ConvertToDiscoveryType(AuthLinkType type)
422 {
423     switch (type) {
424         case AUTH_LINK_TYPE_WIFI:
425             return DISCOVERY_TYPE_WIFI;
426         case AUTH_LINK_TYPE_BLE:
427             return DISCOVERY_TYPE_BLE;
428         case AUTH_LINK_TYPE_BR:
429             return DISCOVERY_TYPE_BR;
430         case AUTH_LINK_TYPE_P2P:
431             return DISCOVERY_TYPE_P2P;
432         default:
433             break;
434     }
435     AUTH_LOGE(AUTH_CONN, "unexpected AuthLinkType=%{public}d", type);
436     return DISCOVERY_TYPE_UNKNOWN;
437 }
438 
ConvertToAuthLinkType(DiscoveryType type)439 AuthLinkType ConvertToAuthLinkType(DiscoveryType type)
440 {
441     switch (type) {
442         case DISCOVERY_TYPE_WIFI:
443             return AUTH_LINK_TYPE_WIFI;
444         case DISCOVERY_TYPE_BLE:
445             return AUTH_LINK_TYPE_BLE;
446         case DISCOVERY_TYPE_BR:
447             return AUTH_LINK_TYPE_BR;
448         case DISCOVERY_TYPE_P2P:
449             return AUTH_LINK_TYPE_P2P;
450         default:
451             AUTH_LOGE(AUTH_CONN, "unexpected discType=%{public}d", type);
452             break;
453     }
454     return AUTH_LINK_TYPE_MAX;
455 }
456 
AuthCommonInit(void)457 int32_t AuthCommonInit(void)
458 {
459     g_authHandler.name = "AuthHandler";
460     g_authHandler.HandleMessage = HandleAuthMessage;
461     g_authHandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
462 
463     if (SoftBusMutexInit(&g_authLock, NULL) != SOFTBUS_OK) {
464         AUTH_LOGE(AUTH_INIT, "auth mutex init fail");
465         return SOFTBUS_ERR;
466     }
467     return SOFTBUS_OK;
468 }
469 
AuthCommonDeinit(void)470 void AuthCommonDeinit(void)
471 {
472     g_authHandler.looper = NULL;
473     g_authHandler.HandleMessage = NULL;
474 
475     if (SoftBusMutexDestroy(&g_authLock) != SOFTBUS_OK) {
476         AUTH_LOGE(AUTH_INIT, "auth mutex destroy fail");
477     }
478 }
479 
GetPeerUdidByNetworkId(const char *networkId, char *udid, uint32_t len)480 int32_t GetPeerUdidByNetworkId(const char *networkId, char *udid, uint32_t len)
481 {
482     if (networkId == NULL || udid == NULL || len < UDID_BUF_LEN) {
483         AUTH_LOGW(AUTH_CONN, "param err");
484         return SOFTBUS_INVALID_PARAM;
485     }
486     NodeInfo cacheInfo;
487     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
488     if (LnnRetrieveDeviceInfoByNetworkId(networkId, &cacheInfo) == SOFTBUS_OK &&
489         cacheInfo.deviceInfo.deviceUdid[0] != '\0') {
490         if (strcpy_s(udid, len, cacheInfo.deviceInfo.deviceUdid) != EOK) {
491             AUTH_LOGE(AUTH_CONN, "copy deviceUdid failed");
492             return SOFTBUS_MEM_ERR;
493         }
494         return SOFTBUS_OK;
495     }
496     AUTH_LOGE(AUTH_CONN, "info or deviceUdid is null");
497     return SOFTBUS_NOT_FIND;
498 }
499 
GetIsExchangeUdidByNetworkId(const char *networkId, bool *isExchangeUdid)500 int32_t GetIsExchangeUdidByNetworkId(const char *networkId, bool *isExchangeUdid)
501 {
502     if (networkId == NULL || isExchangeUdid == NULL) {
503         AUTH_LOGW(AUTH_CONN, "param err");
504         return SOFTBUS_INVALID_PARAM;
505     }
506     NodeInfo cacheInfo;
507     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
508     if (LnnRetrieveDeviceInfoByNetworkId(networkId, &cacheInfo) == SOFTBUS_OK) {
509         *isExchangeUdid = cacheInfo.isAuthExchangeUdid;
510         return SOFTBUS_OK;
511     }
512     AUTH_LOGE(AUTH_CONN, "deviceInfo not found");
513     return SOFTBUS_NOT_FIND;
514 }
515 
CheckAuthConnInfoType(const AuthConnInfo *connInfo)516 bool CheckAuthConnInfoType(const AuthConnInfo *connInfo)
517 {
518     AUTH_CHECK_AND_RETURN_RET_LOGE(connInfo != NULL, false, AUTH_FSM, "connInfo is null");
519     if (connInfo->type >= AUTH_LINK_TYPE_WIFI && connInfo->type < AUTH_LINK_TYPE_MAX) {
520         return true;
521     }
522     return false;
523 }
524 
PrintAuthConnInfo(const AuthConnInfo *connInfo)525 void PrintAuthConnInfo(const AuthConnInfo *connInfo)
526 {
527     if (connInfo == NULL) {
528         return;
529     }
530     char *anonyUdidHash = NULL;
531     char *anonyMac = NULL;
532     char *anonyIp = NULL;
533     char udidHash[UDID_BUF_LEN] = { 0 };
534     switch (connInfo->type) {
535         case AUTH_LINK_TYPE_WIFI:
536             Anonymize(connInfo->info.ipInfo.ip, &anonyIp);
537             AUTH_LOGD(AUTH_CONN, "print AuthConninfo ip=*.*.*%{public}s", AnonymizeWrapper(anonyIp));
538             AnonymizeFree(anonyIp);
539             break;
540         case AUTH_LINK_TYPE_BR:
541             Anonymize(connInfo->info.brInfo.brMac, &anonyMac);
542             AUTH_LOGD(AUTH_CONN, "print AuthConninfo brMac=**:**:**:**:%{public}s", AnonymizeWrapper(anonyMac));
543             AnonymizeFree(anonyMac);
544             break;
545         case AUTH_LINK_TYPE_BLE:
546             if (ConvertBytesToHexString(udidHash, UDID_BUF_LEN,
547                 (const unsigned char *)connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN) != SOFTBUS_OK) {
548                 AUTH_LOGE(AUTH_CONN, "gen udid hash hex str err");
549                 return;
550             }
551             Anonymize(udidHash, &anonyUdidHash);
552             Anonymize(connInfo->info.bleInfo.bleMac, &anonyMac);
553             AUTH_LOGD(AUTH_CONN, "print AuthConninfo bleMac=**:**:**:**:%{public}s, udidhash=%{public}s",
554                 AnonymizeWrapper(anonyMac), AnonymizeWrapper(anonyUdidHash));
555             AnonymizeFree(anonyMac);
556             AnonymizeFree(anonyUdidHash);
557             break;
558         default:
559             break;
560     }
561 }
562