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 common function */
DupMemBuffer(const uint8_t * buf,uint32_t size)184 uint8_t *DupMemBuffer(const uint8_t *buf, uint32_t size)
185 {
186     if (buf == NULL || size == 0) {
187         AUTH_LOGE(AUTH_CONN, "param err");
188         return NULL;
189     }
190     uint8_t *dup = (uint8_t *)SoftBusMalloc(size);
191     if (dup == NULL) {
192         AUTH_LOGE(AUTH_CONN, "malloc err");
193         return NULL;
194     }
195     if (memcpy_s(dup, size, buf, size) != EOK) {
196         AUTH_LOGE(AUTH_CONN, "memcpy err");
197         SoftBusFree(dup);
198         return NULL;
199     }
200     return dup;
201 }
202 
UpdateUniqueId(void)203 static void UpdateUniqueId(void)
204 {
205     char networkId[NETWORK_ID_BUF_LEN] = { 0 };
206     if (LnnGetLocalStrInfo(STRING_KEY_NETWORKID, networkId, sizeof(networkId)) != SOFTBUS_OK) {
207         AUTH_LOGE(AUTH_CONN, "get local networkId fail");
208         return;
209     }
210     uint8_t hashId[SHA_256_HASH_LEN] = { 0 };
211     if (SoftBusGenerateStrHash((uint8_t *)networkId, strlen(networkId), hashId) != SOFTBUS_OK) {
212         AUTH_LOGE(AUTH_CONN, "GenerateStrHash fail");
213         return;
214     }
215     for (uint32_t i = 0; i < SEQ_NETWORK_ID_BITS / BYTES_BIT_NUM; i++) {
216         g_uniqueId = (g_uniqueId << BYTES_BIT_NUM) | hashId[i];
217     }
218     uint64_t timeStamp = GetCurrentTimeMs();
219     g_uniqueId = (g_uniqueId << SEQ_TIME_STAMP_BITS) | (SEQ_TIME_STAMP_MASK & timeStamp);
220 }
221 
GenSeq(bool isServer)222 int64_t GenSeq(bool isServer)
223 {
224     static uint32_t integer = 0;
225     if (integer >= SEQ_INTEGER_MAX) {
226         integer = 0;
227     }
228     if (integer == 0) {
229         UpdateUniqueId();
230     }
231     integer += SEQ_INTERVAL;
232     uint64_t seq = isServer ? (integer + 1) : integer;
233     /* |----NetworkIdHash(32)----|-----timeStamp(8)----|----AtomicInteger(24)----| */
234     seq = (g_uniqueId << SEQ_INTEGER_BITS) | (seq & SEQ_INTEGER_MAX);
235     return (int64_t)seq;
236 }
237 
GetCurrentTimeMs(void)238 uint64_t GetCurrentTimeMs(void)
239 {
240     SoftBusSysTime now = { 0 };
241     if (SoftBusGetTime(&now) != SOFTBUS_OK) {
242         AUTH_LOGE(AUTH_CONN, "SoftBusGetTime fail");
243         return 0;
244     }
245     return (uint64_t)now.sec * TIME_SEC_TO_MSEC + (uint64_t)now.usec / TIME_MSEC_TO_USEC;
246 }
247 
GetAuthSideStr(bool isServer)248 const char *GetAuthSideStr(bool isServer)
249 {
250     return isServer ? "server" : "client";
251 }
252 
CompareConnInfo(const AuthConnInfo * info1,const AuthConnInfo * info2,bool cmpShortHash)253 bool CompareConnInfo(const AuthConnInfo *info1, const AuthConnInfo *info2, bool cmpShortHash)
254 {
255     CHECK_NULL_PTR_RETURN_VALUE(info1, false);
256     CHECK_NULL_PTR_RETURN_VALUE(info2, false);
257     bool isLinkble = false;
258     switch (info1->type) {
259         case AUTH_LINK_TYPE_WIFI:
260             if (info2->type == AUTH_LINK_TYPE_WIFI && strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
261                 return true;
262             }
263             break;
264         case AUTH_LINK_TYPE_BR:
265             if (info2->type == AUTH_LINK_TYPE_BR &&
266                 StrCmpIgnoreCase(info1->info.brInfo.brMac, info2->info.brInfo.brMac) == 0) {
267                 return true;
268             }
269             break;
270         case AUTH_LINK_TYPE_BLE:
271             isLinkble = (info2->type == AUTH_LINK_TYPE_BLE &&
272                 (memcmp(info1->info.bleInfo.deviceIdHash, info2->info.bleInfo.deviceIdHash,
273                 (cmpShortHash ? SHORT_HASH_LEN : UDID_HASH_LEN)) == 0 ||
274                 StrCmpIgnoreCase(info1->info.bleInfo.bleMac, info2->info.bleInfo.bleMac) == 0));
275             if (isLinkble) {
276                 return true;
277             }
278             break;
279         case AUTH_LINK_TYPE_P2P:
280             if (info2->type == AUTH_LINK_TYPE_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
281                 strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
282                 return true;
283             }
284             break;
285         case AUTH_LINK_TYPE_ENHANCED_P2P:
286             if (info2->type == AUTH_LINK_TYPE_ENHANCED_P2P && info1->info.ipInfo.port == info2->info.ipInfo.port &&
287                 strcmp(info1->info.ipInfo.ip, info2->info.ipInfo.ip) == 0) {
288                 return true;
289             }
290             break;
291         default:
292             return false;
293     }
294     return false;
295 }
296 
SetP2pSocketOption(const AuthConnInfo * connInfo,ConnectOption * option)297 static int32_t SetP2pSocketOption(const AuthConnInfo *connInfo, ConnectOption *option)
298 {
299     CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
300     CHECK_NULL_PTR_RETURN_VALUE(option, SOFTBUS_INVALID_PARAM);
301     option->type = CONNECT_TCP;
302     if (strcpy_s(option->socketOption.addr, sizeof(option->socketOption.addr), connInfo->info.ipInfo.ip) != EOK) {
303         AUTH_LOGE(AUTH_CONN, "copy ip fail");
304         return SOFTBUS_MEM_ERR;
305     }
306     option->socketOption.port = connInfo->info.ipInfo.port;
307     option->socketOption.protocol = LNN_PROTOCOL_IP;
308     option->socketOption.keepAlive = 1;
309     if (connInfo->type == AUTH_LINK_TYPE_P2P) {
310         option->socketOption.moduleId = AUTH_P2P;
311     } else {
312         option->socketOption.moduleId = connInfo->info.ipInfo.moduleId;
313     }
314     return SOFTBUS_OK;
315 }
316 
ConvertToConnectOption(const AuthConnInfo * connInfo,ConnectOption * option)317 int32_t ConvertToConnectOption(const AuthConnInfo *connInfo, ConnectOption *option)
318 {
319     CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
320     CHECK_NULL_PTR_RETURN_VALUE(option, SOFTBUS_INVALID_PARAM);
321     switch (connInfo->type) {
322         case AUTH_LINK_TYPE_BR:
323             option->type = CONNECT_BR;
324             if (strcpy_s(option->brOption.brMac, BT_MAC_LEN, connInfo->info.brInfo.brMac) != EOK) {
325                 AUTH_LOGE(AUTH_CONN, "copy brMac fail");
326                 return SOFTBUS_MEM_ERR;
327             }
328             option->brOption.connectionId = connInfo->info.brInfo.connectionId;
329             break;
330         case AUTH_LINK_TYPE_BLE:
331             option->type = CONNECT_BLE;
332             if (strcpy_s(option->bleOption.bleMac, BT_MAC_LEN, connInfo->info.bleInfo.bleMac) != EOK ||
333                 memcpy_s(option->bleOption.deviceIdHash, UDID_HASH_LEN, connInfo->info.bleInfo.deviceIdHash,
334                     UDID_HASH_LEN) != EOK) {
335                 AUTH_LOGE(AUTH_CONN, "copy bleMac/deviceIdHash fail");
336                 return SOFTBUS_MEM_ERR;
337             }
338             option->bleOption.fastestConnectEnable = true;
339             option->bleOption.psm = connInfo->info.bleInfo.psm;
340             option->bleOption.protocol = connInfo->info.bleInfo.protocol;
341             break;
342         case AUTH_LINK_TYPE_P2P:
343         case AUTH_LINK_TYPE_ENHANCED_P2P:
344             if (SetP2pSocketOption(connInfo, option) != SOFTBUS_OK) {
345                 return SOFTBUS_MEM_ERR;
346             }
347             break;
348         default:
349             AUTH_LOGE(AUTH_CONN, "unexpected connType=%{public}d", connInfo->type);
350             return SOFTBUS_ERR;
351     }
352     return SOFTBUS_OK;
353 }
354 
IsEnhanceP2pModuleId(ListenerModule moduleId)355 static bool IsEnhanceP2pModuleId(ListenerModule moduleId)
356 {
357     if (moduleId >= AUTH_ENHANCED_P2P_START && moduleId <= AUTH_ENHANCED_P2P_END) {
358         return true;
359     }
360     return false;
361 }
362 
ConvertToAuthConnInfo(const ConnectionInfo * info,AuthConnInfo * connInfo)363 int32_t ConvertToAuthConnInfo(const ConnectionInfo *info, AuthConnInfo *connInfo)
364 {
365     CHECK_NULL_PTR_RETURN_VALUE(info, SOFTBUS_INVALID_PARAM);
366     CHECK_NULL_PTR_RETURN_VALUE(connInfo, SOFTBUS_INVALID_PARAM);
367     switch (info->type) {
368         case CONNECT_TCP:
369             if (info->socketInfo.protocol != LNN_PROTOCOL_IP) {
370                 AUTH_LOGW(AUTH_CONN, "only support LNN_PROTOCOL_IP");
371                 return SOFTBUS_ERR;
372             }
373             if (IsEnhanceP2pModuleId(info->socketInfo.moduleId)) {
374                 connInfo->type = AUTH_LINK_TYPE_ENHANCED_P2P;
375             } else {
376                 connInfo->type = AUTH_LINK_TYPE_P2P;
377             }
378             connInfo->info.ipInfo.moduleId = info->socketInfo.moduleId;
379             connInfo->info.ipInfo.port = info->socketInfo.port;
380             if (strcpy_s(connInfo->info.ipInfo.ip, IP_LEN, info->socketInfo.addr) != EOK) {
381                 AUTH_LOGE(AUTH_CONN, "copy ip fail");
382                 return SOFTBUS_MEM_ERR;
383             }
384             break;
385         case CONNECT_BR:
386             connInfo->type = AUTH_LINK_TYPE_BR;
387             if (strcpy_s(connInfo->info.brInfo.brMac, BT_MAC_LEN, info->brInfo.brMac) != EOK) {
388                 AUTH_LOGE(AUTH_CONN, "copy brMac fail");
389                 return SOFTBUS_MEM_ERR;
390             }
391             break;
392         case CONNECT_BLE:
393             connInfo->type = AUTH_LINK_TYPE_BLE;
394             if (strcpy_s(connInfo->info.bleInfo.bleMac, BT_MAC_LEN, info->bleInfo.bleMac) != EOK ||
395                 memcpy_s(connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN, info->bleInfo.deviceIdHash,
396                     UDID_HASH_LEN) != EOK) {
397                 AUTH_LOGE(AUTH_CONN, "copy bleMac/deviceIdHash fail");
398                 return SOFTBUS_MEM_ERR;
399             }
400             connInfo->info.bleInfo.protocol = info->bleInfo.protocol;
401             connInfo->info.bleInfo.psm = info->bleInfo.psm;
402             break;
403         default:
404             AUTH_LOGE(AUTH_CONN, "unexpected connType=%{public}d", info->type);
405             return SOFTBUS_ERR;
406     }
407     return SOFTBUS_OK;
408 }
409 
ConvertToDiscoveryType(AuthLinkType type)410 DiscoveryType ConvertToDiscoveryType(AuthLinkType type)
411 {
412     switch (type) {
413         case AUTH_LINK_TYPE_WIFI:
414             return DISCOVERY_TYPE_WIFI;
415         case AUTH_LINK_TYPE_BLE:
416             return DISCOVERY_TYPE_BLE;
417         case AUTH_LINK_TYPE_BR:
418             return DISCOVERY_TYPE_BR;
419         case AUTH_LINK_TYPE_P2P:
420             return DISCOVERY_TYPE_P2P;
421         default:
422             break;
423     }
424     AUTH_LOGE(AUTH_CONN, "unexpected AuthLinkType=%{public}d", type);
425     return DISCOVERY_TYPE_UNKNOWN;
426 }
427 
ConvertToAuthLinkType(DiscoveryType type)428 AuthLinkType ConvertToAuthLinkType(DiscoveryType type)
429 {
430     switch (type) {
431         case DISCOVERY_TYPE_WIFI:
432             return AUTH_LINK_TYPE_WIFI;
433         case DISCOVERY_TYPE_BLE:
434             return AUTH_LINK_TYPE_BLE;
435         case DISCOVERY_TYPE_BR:
436             return AUTH_LINK_TYPE_BR;
437         case DISCOVERY_TYPE_P2P:
438             return AUTH_LINK_TYPE_P2P;
439         default:
440             AUTH_LOGE(AUTH_CONN, "unexpected discType=%{public}d", type);
441             break;
442     }
443     return AUTH_LINK_TYPE_MAX;
444 }
445 
AuthCommonInit(void)446 int32_t AuthCommonInit(void)
447 {
448     g_authHandler.name = "AuthHandler";
449     g_authHandler.HandleMessage = HandleAuthMessage;
450     g_authHandler.looper = GetLooper(LOOP_TYPE_DEFAULT);
451 
452     if (SoftBusMutexInit(&g_authLock, NULL) != SOFTBUS_OK) {
453         AUTH_LOGE(AUTH_INIT, "auth mutex init fail");
454         return SOFTBUS_ERR;
455     }
456     return SOFTBUS_OK;
457 }
458 
AuthCommonDeinit(void)459 void AuthCommonDeinit(void)
460 {
461     g_authHandler.looper = NULL;
462     g_authHandler.HandleMessage = NULL;
463 
464     if (SoftBusMutexDestroy(&g_authLock) != SOFTBUS_OK) {
465         AUTH_LOGE(AUTH_INIT, "auth mutex destroy fail");
466     }
467 }
468 
GetPeerUdidByNetworkId(const char * networkId,char * udid,uint32_t len)469 int32_t GetPeerUdidByNetworkId(const char *networkId, char *udid, uint32_t len)
470 {
471     if (networkId == NULL || udid == NULL || len < UDID_BUF_LEN) {
472         AUTH_LOGW(AUTH_CONN, "param err");
473         return SOFTBUS_INVALID_PARAM;
474     }
475     NodeInfo cacheInfo;
476     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
477     if (LnnRetrieveDeviceInfoByNetworkId(networkId, &cacheInfo) == SOFTBUS_OK &&
478         cacheInfo.deviceInfo.deviceUdid[0] != '\0') {
479         if (strcpy_s(udid, len, cacheInfo.deviceInfo.deviceUdid) != EOK) {
480             AUTH_LOGE(AUTH_CONN, "copy deviceUdid failed");
481             return SOFTBUS_MEM_ERR;
482         }
483         return SOFTBUS_OK;
484     }
485     AUTH_LOGE(AUTH_CONN, "info or deviceUdid is null");
486     return SOFTBUS_NOT_FIND;
487 }
488 
GetIsExchangeUdidByNetworkId(const char * networkId,bool * isExchangeUdid)489 int32_t GetIsExchangeUdidByNetworkId(const char *networkId, bool *isExchangeUdid)
490 {
491     if (networkId == NULL || isExchangeUdid == NULL) {
492         AUTH_LOGW(AUTH_CONN, "param err");
493         return SOFTBUS_INVALID_PARAM;
494     }
495     NodeInfo cacheInfo;
496     (void)memset_s(&cacheInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
497     if (LnnRetrieveDeviceInfoByNetworkId(networkId, &cacheInfo) == SOFTBUS_OK) {
498         *isExchangeUdid = cacheInfo.isAuthExchangeUdid;
499         return SOFTBUS_OK;
500     }
501     AUTH_LOGE(AUTH_CONN, "deviceInfo not found");
502     return SOFTBUS_NOT_FIND;
503 }
504 
CheckAuthConnInfoType(const AuthConnInfo * connInfo)505 bool CheckAuthConnInfoType(const AuthConnInfo *connInfo)
506 {
507     AUTH_CHECK_AND_RETURN_RET_LOGE(connInfo != NULL, false, AUTH_FSM, "connInfo is null");
508     if (connInfo->type >= AUTH_LINK_TYPE_WIFI && connInfo->type < AUTH_LINK_TYPE_MAX) {
509         return true;
510     }
511     return false;
512 }
513 
PrintAuthConnInfo(const AuthConnInfo * connInfo)514 void PrintAuthConnInfo(const AuthConnInfo *connInfo)
515 {
516     if (connInfo == NULL) {
517         return;
518     }
519     char *anonyUdidHash = NULL;
520     char *anonyMac = NULL;
521     char *anonyIp = NULL;
522     char udidHash[UDID_BUF_LEN] = { 0 };
523     switch (connInfo->type) {
524         case AUTH_LINK_TYPE_WIFI:
525             Anonymize(connInfo->info.ipInfo.ip, &anonyIp);
526             AUTH_LOGD(AUTH_CONN, "print AuthConninfo ip=*.*.*%{public}s", anonyIp);
527             AnonymizeFree(anonyIp);
528             break;
529         case AUTH_LINK_TYPE_BR:
530             Anonymize(connInfo->info.brInfo.brMac, &anonyMac);
531             AUTH_LOGD(AUTH_CONN, "print AuthConninfo brMac=**:**:**:**:%{public}s", anonyMac);
532             AnonymizeFree(anonyMac);
533             break;
534         case AUTH_LINK_TYPE_BLE:
535             if (ConvertBytesToHexString(udidHash, UDID_BUF_LEN,
536                 (const unsigned char *)connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN) != SOFTBUS_OK) {
537                 AUTH_LOGE(AUTH_CONN, "gen udid hash hex str err");
538                 return;
539             }
540             Anonymize(udidHash, &anonyUdidHash);
541             Anonymize(connInfo->info.bleInfo.bleMac, &anonyMac);
542             AUTH_LOGD(AUTH_CONN, "print AuthConninfo bleMac=**:**:**:**:%{public}s, udidhash=%{public}s", anonyMac,
543                 anonyUdidHash);
544             AnonymizeFree(anonyMac);
545             AnonymizeFree(anonyUdidHash);
546             break;
547         default:
548             break;
549     }
550 }