1 /*
2 * Copyright (c) 2022-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_manager.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "auth_common.h"
22 #include "auth_connection.h"
23 #include "auth_hichain.h"
24 #include "auth_log.h"
25 #include "auth_request.h"
26 #include "auth_session_fsm.h"
27 #include "auth_session_message.h"
28 #include "bus_center_manager.h"
29 #include "device_profile_listener.h"
30 #include "lnn_async_callback_utils.h"
31 #include "lnn_app_bind_interface.h"
32 #include "lnn_decision_db.h"
33 #include "lnn_event.h"
34 #include "lnn_feature_capability.h"
35 #include "lnn_heartbeat_ctrl.h"
36 #include "lnn_net_builder.h"
37 #include "softbus_adapter_hitrace.h"
38 #include "softbus_adapter_mem.h"
39 #include "softbus_def.h"
40
41 #define MAX_AUTH_VALID_PERIOD (30 * 60 * 1000L) /* 30 mins */
42 #define SCHEDULE_UPDATE_SESSION_KEY_PERIOD ((5 * 60 + 30) * 60 * 1000L) /* 5 hour 30 mins */
43 #define FLAG_REPLY 1
44 #define FLAG_ACTIVE 0
45 #define RETRY_REGDATA_TIMES 3
46 #define RETRY_REGDATA_MILLSECONDS 300
47 #define DELAY_REG_DP_TIME 10000
48
49 static ListNode g_authClientList = { &g_authClientList, &g_authClientList };
50 static ListNode g_authServerList = { &g_authServerList, &g_authServerList };
51
52 static AuthVerifyListener g_verifyListener = { 0 };
53 static GroupChangeListener g_groupChangeListener = { 0 };
54 static AuthTransCallback g_transCallback = { 0 };
55 static bool g_regDataChangeListener = false;
56
57 /* Auth Manager */
NewAuthManager(int64_t authSeq,const AuthSessionInfo * info)58 AuthManager *NewAuthManager(int64_t authSeq, const AuthSessionInfo *info)
59 {
60 AuthManager *auth = (AuthManager *)SoftBusCalloc(sizeof(AuthManager));
61 if (auth == NULL) {
62 AUTH_LOGW(AUTH_FSM, "malloc AuthManager fail");
63 return NULL;
64 }
65 auth->authId = authSeq;
66 auth->isServer = info->isServer;
67 auth->connId = info->connId;
68 auth->connInfo = info->connInfo;
69 if (strcpy_s(auth->udid, sizeof(auth->udid), info->udid) != EOK ||
70 strcpy_s(auth->uuid, sizeof(auth->uuid), info->uuid) != EOK) {
71 AUTH_LOGW(AUTH_FSM, "copy uuid/udid fail");
72 SoftBusFree(auth);
73 return NULL;
74 }
75 auth->version = info->version;
76 auth->hasAuthPassed = false;
77 InitSessionKeyList(&auth->sessionKeyList);
78 if (auth->isServer) {
79 ListTailInsert(&g_authServerList, &auth->node);
80 } else {
81 ListTailInsert(&g_authClientList, &auth->node);
82 }
83 AUTH_LOGI(AUTH_FSM, "create auth manager, side=%{public}s, authId=%{public}" PRId64, GetAuthSideStr(auth->isServer),
84 auth->authId);
85 return auth;
86 }
87
DupAuthManager(const AuthManager * auth)88 static AuthManager *DupAuthManager(const AuthManager *auth)
89 {
90 AuthManager *newAuth = (AuthManager *)DupMemBuffer((const uint8_t *)auth, sizeof(AuthManager));
91 if (newAuth == NULL) {
92 AUTH_LOGE(AUTH_FSM, "auth manager dup fail. authId=%{public}" PRId64 "", auth->authId);
93 return NULL;
94 }
95 ListInit(&newAuth->node);
96 ListInit(&newAuth->sessionKeyList);
97 if (DupSessionKeyList(&auth->sessionKeyList, &newAuth->sessionKeyList)) {
98 AUTH_LOGE(AUTH_FSM, "auth manager dup session key fail. authId=%{public}" PRId64 "", auth->authId);
99 SoftBusFree(newAuth);
100 return NULL;
101 }
102 return newAuth;
103 }
104
DelAuthManager(AuthManager * auth,bool removeAuthFromList)105 void DelAuthManager(AuthManager *auth, bool removeAuthFromList)
106 {
107 AUTH_CHECK_AND_RETURN_LOGE(auth != NULL, AUTH_FSM, "auth is null");
108 if (removeAuthFromList) {
109 char *anonyUdid = NULL;
110 Anonymize(auth->udid, &anonyUdid);
111 AUTH_LOGI(AUTH_FSM, "delete auth manager, udid=%{public}s, side=%{public}s, authId=%{public}" PRId64, anonyUdid,
112 GetAuthSideStr(auth->isServer), auth->authId);
113 AnonymizeFree(anonyUdid);
114 ListDelete(&auth->node);
115 CancelUpdateSessionKey(auth->authId);
116 }
117 DestroySessionKeyList(&auth->sessionKeyList);
118 SoftBusFree(auth);
119 }
120
FindAuthManagerByConnInfo(const AuthConnInfo * connInfo,bool isServer)121 static AuthManager *FindAuthManagerByConnInfo(const AuthConnInfo *connInfo, bool isServer)
122 {
123 AuthManager *item = NULL;
124 ListNode *list = isServer ? &g_authServerList : &g_authClientList;
125 LIST_FOR_EACH_ENTRY(item, list, AuthManager, node) {
126 if (CompareConnInfo(&item->connInfo, connInfo, true)) {
127 return item;
128 }
129 }
130 return NULL;
131 }
132
FindAuthManagerByUuid(const char * uuid,AuthLinkType type,bool isServer)133 static AuthManager *FindAuthManagerByUuid(const char *uuid, AuthLinkType type, bool isServer)
134 {
135 AuthManager *item = NULL;
136 ListNode *list = isServer ? &g_authServerList : &g_authClientList;
137 LIST_FOR_EACH_ENTRY(item, list, AuthManager, node) {
138 if (item->connInfo.type == type && (strcmp(item->uuid, uuid) == 0) && item->hasAuthPassed) {
139 return item;
140 }
141 }
142 return NULL;
143 }
144
FindAuthManagerByUdid(const char * udid,AuthLinkType type,bool isServer)145 static AuthManager *FindAuthManagerByUdid(const char *udid, AuthLinkType type, bool isServer)
146 {
147 AuthManager *item = NULL;
148 ListNode *list = isServer ? &g_authServerList : &g_authClientList;
149 LIST_FOR_EACH_ENTRY(item, list, AuthManager, node) {
150 if (item->connInfo.type == type && (strcmp(item->udid, udid) == 0) && item->hasAuthPassed) {
151 return item;
152 }
153 }
154 return NULL;
155 }
156
PrintAuthConnInfo(const AuthConnInfo * connInfo)157 static void PrintAuthConnInfo(const AuthConnInfo *connInfo)
158 {
159 if (connInfo == NULL) {
160 return;
161 }
162 char *anonyUdidHash = NULL;
163 char *anonyMac = NULL;
164 char *anonyIp = NULL;
165 char udidHash[UDID_BUF_LEN] = { 0 };
166 switch (connInfo->type) {
167 case AUTH_LINK_TYPE_WIFI:
168 Anonymize(connInfo->info.ipInfo.ip, &anonyIp);
169 AUTH_LOGD(AUTH_CONN, "print AuthConninfo ip=*.*.*%{public}s", anonyIp);
170 AnonymizeFree(anonyIp);
171 break;
172 case AUTH_LINK_TYPE_BR:
173 Anonymize(connInfo->info.brInfo.brMac, &anonyMac);
174 AUTH_LOGD(AUTH_CONN, "print AuthConninfo brMac=**:**:**:**:%{public}s", anonyMac);
175 AnonymizeFree(anonyMac);
176 break;
177 case AUTH_LINK_TYPE_BLE:
178 if (ConvertBytesToHexString(udidHash, UDID_BUF_LEN,
179 (const unsigned char *)connInfo->info.bleInfo.deviceIdHash, UDID_HASH_LEN) != SOFTBUS_OK) {
180 AUTH_LOGE(AUTH_CONN, "gen udid hash hex str err");
181 return;
182 }
183 Anonymize(udidHash, &anonyUdidHash);
184 Anonymize(connInfo->info.bleInfo.bleMac, &anonyMac);
185 AUTH_LOGD(AUTH_CONN, "print AuthConninfo bleMac=**:**:**:**:%{public}s, udidhash=%{public}s", anonyMac,
186 anonyUdidHash);
187 AnonymizeFree(anonyMac);
188 AnonymizeFree(anonyUdidHash);
189 break;
190 default:
191 break;
192 }
193 }
194
FindAuthManagerByAuthId(int64_t authId)195 static AuthManager *FindAuthManagerByAuthId(int64_t authId)
196 {
197 AuthManager *item = NULL;
198 LIST_FOR_EACH_ENTRY(item, &g_authClientList, AuthManager, node) {
199 if (item->authId == authId) {
200 return item;
201 }
202 }
203 LIST_FOR_EACH_ENTRY(item, &g_authServerList, AuthManager, node) {
204 if (item->authId == authId) {
205 return item;
206 }
207 }
208
209 AUTH_LOGE(AUTH_FSM, "auth manager not found. authId=%{public}" PRId64 "", authId);
210 return NULL;
211 }
212
FindAuthManagerByConnId(uint64_t connId,bool isServer)213 static AuthManager *FindAuthManagerByConnId(uint64_t connId, bool isServer)
214 {
215 AuthManager *item = NULL;
216 ListNode *list = isServer ? &g_authServerList : &g_authClientList;
217 LIST_FOR_EACH_ENTRY(item, list, AuthManager, node) {
218 if (item->connId == connId) {
219 return item;
220 }
221 }
222 return NULL;
223 }
224
DestroyAuthManagerList(void)225 static void DestroyAuthManagerList(void)
226 {
227 if (!RequireAuthLock()) {
228 return;
229 }
230 AuthManager *item = NULL;
231 AuthManager *next = NULL;
232 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_authClientList, AuthManager, node) {
233 DelAuthManager(item, true);
234 }
235 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_authServerList, AuthManager, node) {
236 DelAuthManager(item, true);
237 }
238 ReleaseAuthLock();
239 }
240
SetAuthConnId(AuthManager * auth,const AuthManager * inAuth)241 static int32_t SetAuthConnId(AuthManager *auth, const AuthManager *inAuth)
242 {
243 auth->connId = inAuth->connId;
244 return SOFTBUS_OK;
245 }
246
SetAuthP2pMac(AuthManager * auth,const AuthManager * inAuth)247 static int32_t SetAuthP2pMac(AuthManager *auth, const AuthManager *inAuth)
248 {
249 if (strcpy_s(auth->p2pMac, sizeof(auth->p2pMac), inAuth->p2pMac) != EOK) {
250 AUTH_LOGE(AUTH_CONN, "copy auth p2p mac fail, authId=%{public}" PRId64, auth->authId);
251 return SOFTBUS_MEM_ERR;
252 }
253 return SOFTBUS_OK;
254 }
255
UpdateAuthManagerByAuthId(int64_t authId,int32_t (* updateFunc)(AuthManager *,const AuthManager *),const AuthManager * inAuth)256 static int32_t UpdateAuthManagerByAuthId(
257 int64_t authId, int32_t (*updateFunc)(AuthManager *, const AuthManager *), const AuthManager *inAuth)
258 {
259 if (!RequireAuthLock()) {
260 return SOFTBUS_LOCK_ERR;
261 }
262 AuthManager *auth = FindAuthManagerByAuthId(authId);
263 if (auth == NULL) {
264 AUTH_LOGE(AUTH_FSM, "auth manager not found, authId=%{public}" PRId64, authId);
265 ReleaseAuthLock();
266 return SOFTBUS_AUTH_NOT_FOUND;
267 }
268 if (updateFunc(auth, inAuth) != SOFTBUS_OK) {
269 AUTH_LOGE(AUTH_FSM, "update auth manager fail, authId=%{public}" PRId64, authId);
270 ReleaseAuthLock();
271 return SOFTBUS_ERR;
272 }
273 ReleaseAuthLock();
274 return SOFTBUS_OK;
275 }
276
ConvertAuthLinkTypeToConnect(AuthLinkType type)277 static ConnectionAddrType ConvertAuthLinkTypeToConnect(AuthLinkType type)
278 {
279 switch (type) {
280 case AUTH_LINK_TYPE_WIFI:
281 return CONNECTION_ADDR_WLAN;
282 case AUTH_LINK_TYPE_BLE:
283 return CONNECTION_ADDR_BLE;
284 case AUTH_LINK_TYPE_BR:
285 return CONNECTION_ADDR_BR;
286 default:
287 return CONNECTION_ADDR_MAX;
288 }
289 }
290
RemoveAuthSessionKeyByIndex(int64_t authId,int32_t index)291 void RemoveAuthSessionKeyByIndex(int64_t authId, int32_t index)
292 {
293 if (!RequireAuthLock()) {
294 return;
295 }
296 AuthManager *auth = FindAuthManagerByAuthId(authId);
297 if (auth == NULL) {
298 ReleaseAuthLock();
299 AUTH_LOGI(AUTH_CONN, "auth manager already removed, authId=%{public}" PRId64, authId);
300 return;
301 }
302 RemoveSessionkeyByIndex(&auth->sessionKeyList, index);
303 bool keyClear = IsListEmpty(&auth->sessionKeyList);
304 ConnectionAddrType connType = CONNECTION_ADDR_MAX;
305 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
306 int32_t ret = SOFTBUS_ERR;
307 if (keyClear) {
308 connType = ConvertAuthLinkTypeToConnect(auth->connInfo.type);
309 ret = LnnGetNetworkIdByUdid(auth->udid, networkId, sizeof(networkId));
310 }
311 char udid[UDID_BUF_LEN] = { 0 };
312 AuthLinkType type = auth->connInfo.type;
313 (void)memcpy_s(udid, UDID_BUF_LEN, auth->udid, UDID_BUF_LEN);
314 ReleaseAuthLock();
315 AuthRemoveDeviceKey(udid, type);
316 if ((ret == SOFTBUS_OK) && (connType != CONNECTION_ADDR_MAX) && (keyClear)) {
317 AUTH_LOGI(AUTH_CONN, "auth key clear empty, Lnn offline. authId=%{public}" PRId64, authId);
318 LnnRequestLeaveSpecific(networkId, connType);
319 }
320 }
321
RemoveAuthManagerByAuthId(int64_t authId)322 void RemoveAuthManagerByAuthId(int64_t authId)
323 {
324 if (!RequireAuthLock()) {
325 return;
326 }
327 AuthManager *auth = FindAuthManagerByAuthId(authId);
328 if (auth == NULL) {
329 AUTH_LOGI(AUTH_CONN, "auth manager already removed, authId=%{public}" PRId64, authId);
330 ReleaseAuthLock();
331 return;
332 }
333 DelAuthManager(auth, true);
334 ReleaseAuthLock();
335 }
336
RemoveAuthManagerByConnInfo(const AuthConnInfo * connInfo,bool isServer)337 static void RemoveAuthManagerByConnInfo(const AuthConnInfo *connInfo, bool isServer)
338 {
339 if (!RequireAuthLock()) {
340 return;
341 }
342 AuthManager *auth = FindAuthManagerByConnInfo(connInfo, isServer);
343 if (auth == NULL) {
344 PrintAuthConnInfo(connInfo);
345 ReleaseAuthLock();
346 AUTH_LOGI(AUTH_CONN, "auth manager already removed, connType=%{public}d, side=%{public}s", connInfo->type,
347 GetAuthSideStr(isServer));
348 return;
349 }
350 DelAuthManager(auth, true);
351 ReleaseAuthLock();
352 }
353
RemoveNotPassedAuthManagerByUdid(const char * udid)354 static void RemoveNotPassedAuthManagerByUdid(const char *udid)
355 {
356 if (!RequireAuthLock()) {
357 return;
358 }
359 AuthManager *item = NULL;
360 AuthManager *next = NULL;
361 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_authClientList, AuthManager, node) {
362 if (item->hasAuthPassed || strcmp(item->udid, udid) != 0) {
363 continue;
364 }
365 DelAuthManager(item, true);
366 }
367 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_authServerList, AuthManager, node) {
368 if (item->hasAuthPassed || strcmp(item->udid, udid) != 0) {
369 continue;
370 }
371 DelAuthManager(item, true);
372 }
373 ReleaseAuthLock();
374 }
375
GetAuthConnInfoByUuid(const char * uuid,AuthLinkType type,AuthConnInfo * connInfo)376 static int32_t GetAuthConnInfoByUuid(const char *uuid, AuthLinkType type, AuthConnInfo *connInfo)
377 {
378 if (!RequireAuthLock()) {
379 return SOFTBUS_LOCK_ERR;
380 }
381 AuthManager *auth = FindAuthManagerByUuid(uuid, type, false);
382 if (auth == NULL) {
383 auth = FindAuthManagerByUuid(uuid, type, true);
384 }
385 if (auth == NULL) {
386 AUTH_LOGI(AUTH_CONN, "auth not found by uuid, connType=%{public}d", type);
387 ReleaseAuthLock();
388 return SOFTBUS_AUTH_NOT_FOUND;
389 }
390 *connInfo = auth->connInfo;
391 ReleaseAuthLock();
392 return SOFTBUS_OK;
393 }
394
395 /* Note: must call DelAuthManager(auth, false) to free. */
GetAuthManagerByAuthId(int64_t authId)396 AuthManager *GetAuthManagerByAuthId(int64_t authId)
397 {
398 if (!RequireAuthLock()) {
399 return NULL;
400 }
401 AuthManager *item = FindAuthManagerByAuthId(authId);
402 if (item == NULL) {
403 AUTH_LOGI(AUTH_FSM, "auth manager not found. authId=%{public}" PRId64 "", authId);
404 ReleaseAuthLock();
405 return NULL;
406 }
407 AuthManager *newAuth = DupAuthManager(item);
408 ReleaseAuthLock();
409 return newAuth;
410 }
411
GetAuthManagerByConnInfo(const AuthConnInfo * connInfo,bool isServer)412 static AuthManager *GetAuthManagerByConnInfo(const AuthConnInfo *connInfo, bool isServer)
413 {
414 if (!RequireAuthLock()) {
415 return NULL;
416 }
417 AuthManager *item = FindAuthManagerByConnInfo(connInfo, isServer);
418 if (item == NULL) {
419 PrintAuthConnInfo(connInfo);
420 ReleaseAuthLock();
421 AUTH_LOGI(AUTH_FSM, "auth manager not found, connType=%{public}d, side=%{public}s", connInfo->type,
422 GetAuthSideStr(isServer));
423 return NULL;
424 }
425 AuthManager *newAuth = DupAuthManager(item);
426 ReleaseAuthLock();
427 return newAuth;
428 }
429
GetAuthIdByConnId(uint64_t connId,bool isServer)430 static int64_t GetAuthIdByConnId(uint64_t connId, bool isServer)
431 {
432 int64_t authId;
433 if (!RequireAuthLock()) {
434 return AUTH_INVALID_ID;
435 }
436 AuthManager *auth = FindAuthManagerByConnId(connId, isServer);
437 if (auth == NULL) {
438 ReleaseAuthLock();
439 AUTH_LOGI(AUTH_CONN, "auth manager not found, isServer=%{public}s, " CONN_INFO,
440 GetAuthSideStr(isServer), CONN_DATA(connId));
441 return AUTH_INVALID_ID;
442 }
443 authId = auth->authId;
444 ReleaseAuthLock();
445 return authId;
446 }
447
GetLatestIdByConnInfo(const AuthConnInfo * connInfo,AuthLinkType type)448 static int64_t GetLatestIdByConnInfo(const AuthConnInfo *connInfo, AuthLinkType type)
449 {
450 if (connInfo == NULL) {
451 AUTH_LOGE(AUTH_CONN, "connInfo is empty");
452 return AUTH_INVALID_ID;
453 }
454 if (!RequireAuthLock()) {
455 return SOFTBUS_LOCK_ERR;
456 }
457 uint32_t num = 0;
458 const AuthManager *auth[2] = { NULL, NULL }; /* 2: client + server */
459 auth[num++] = FindAuthManagerByConnInfo(connInfo, false);
460 auth[num++] = FindAuthManagerByConnInfo(connInfo, true);
461 int64_t latestAuthId = AUTH_INVALID_ID;
462 uint64_t latestVerifyTime = 0;
463 for (uint32_t i = 0; i < num; i++) {
464 if (auth[i] != NULL && auth[i]->lastVerifyTime > latestVerifyTime && auth[i]->hasAuthPassed) {
465 latestAuthId = auth[i]->authId;
466 latestVerifyTime = auth[i]->lastVerifyTime;
467 }
468 }
469 ReleaseAuthLock();
470 AUTH_LOGD(AUTH_CONN,
471 "latest auth manager found. num=%{public}d, latestAuthId=%{public}" PRId64 ", lastVerifyTime=%{public}" PRIu64
472 ", type=%{public}d",
473 num, latestAuthId, latestVerifyTime, type);
474 return latestAuthId;
475 }
476
GetAuthIdByConnInfo(const AuthConnInfo * connInfo,bool isServer)477 static int64_t GetAuthIdByConnInfo(const AuthConnInfo *connInfo, bool isServer)
478 {
479 int64_t authId;
480 if (!RequireAuthLock()) {
481 return AUTH_INVALID_ID;
482 }
483 AuthManager *auth = FindAuthManagerByConnInfo(connInfo, isServer);
484 if (auth == NULL) {
485 AUTH_LOGE(AUTH_CONN, "auth manager not found, connType=%{public}d, side=%{public}s", connInfo->type,
486 GetAuthSideStr(isServer));
487 ReleaseAuthLock();
488 return AUTH_INVALID_ID;
489 }
490 authId = auth->authId;
491 ReleaseAuthLock();
492 return authId;
493 }
494
GetActiveAuthIdByConnInfo(const AuthConnInfo * connInfo)495 static int64_t GetActiveAuthIdByConnInfo(const AuthConnInfo *connInfo)
496 {
497 if (!RequireAuthLock()) {
498 return AUTH_INVALID_ID;
499 }
500 uint32_t num = 0;
501 AuthManager *auth[2] = { NULL, NULL }; /* 2: client + server */
502 auth[num++] = FindAuthManagerByConnInfo(connInfo, false);
503 auth[num++] = FindAuthManagerByConnInfo(connInfo, true);
504 /* Check auth valid period */
505 uint64_t currentTime = GetCurrentTimeMs();
506 for (uint32_t i = 0; i < num; i++) {
507 if (auth[i] != NULL && (currentTime - auth[i]->lastActiveTime >= MAX_AUTH_VALID_PERIOD)) {
508 auth[i] = NULL;
509 }
510 }
511 /* Get lastest authId */
512 int64_t authId = AUTH_INVALID_ID;
513 uint64_t maxVerifyTime = 0;
514 uint32_t authMgrNum = sizeof(auth) / sizeof(auth[0]);
515 for (uint32_t i = 0; i < authMgrNum; i++) {
516 if (auth[i] == NULL) {
517 continue;
518 }
519 if (auth[i] != NULL && auth[i]->lastVerifyTime > maxVerifyTime) {
520 authId = auth[i]->authId;
521 }
522 }
523 AUTH_LOGI(AUTH_CONN, "get active auth manager. authId=%{public}" PRId64 "", authId);
524 ReleaseAuthLock();
525 return authId;
526 }
527
AuthManagerIsExist(int64_t authSeq,const AuthSessionInfo * info,bool * isNewCreated)528 static AuthManager *AuthManagerIsExist(int64_t authSeq, const AuthSessionInfo *info, bool *isNewCreated)
529 {
530 AuthManager *auth = FindAuthManagerByConnInfo(&info->connInfo, info->isServer);
531 if (auth == NULL) {
532 auth = NewAuthManager(authSeq, info);
533 if (auth == NULL) {
534 AUTH_LOGE(AUTH_FSM, "new authManager create fail.");
535 return NULL;
536 }
537 *isNewCreated = true;
538 } else {
539 if (auth->connId != info->connId && auth->connInfo.type == AUTH_LINK_TYPE_WIFI) {
540 DisconnectAuthDevice(&auth->connId);
541 auth->hasAuthPassed = false;
542 AUTH_LOGI(AUTH_FSM, "auth manager may single device on line");
543 }
544 }
545 auth->connId = info->connId;
546 auth->lastAuthSeq = authSeq;
547 auth->lastVerifyTime = GetCurrentTimeMs();
548 auth->lastActiveTime = GetCurrentTimeMs();
549
550 AUTH_LOGI(AUTH_FSM, "auth manager exist.");
551 return auth;
552 }
553
AuthManagerSetSessionKey(int64_t authSeq,const AuthSessionInfo * info,const SessionKey * sessionKey,bool isConnect)554 int32_t AuthManagerSetSessionKey(int64_t authSeq, const AuthSessionInfo *info,
555 const SessionKey *sessionKey, bool isConnect)
556 {
557 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
558 AUTH_CHECK_AND_RETURN_RET_LOGE(sessionKey != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "sessionKey is NULL");
559 AUTH_LOGI(AUTH_FSM, "SetSessionKey: authSeq=%{public}" PRId64 ", side=%{public}s, requestId=%{public}u", authSeq,
560 GetAuthSideStr(info->isServer), info->requestId);
561 if (!RequireAuthLock()) {
562 return SOFTBUS_LOCK_ERR;
563 }
564 if (!isConnect && info->connInfo.type != AUTH_LINK_TYPE_BLE) {
565 AUTH_LOGI(AUTH_FSM, "only support ble direct on line");
566 ReleaseAuthLock();
567 return SOFTBUS_OK;
568 }
569
570 bool isNewCreated = false;
571 AuthManager *auth = AuthManagerIsExist(authSeq, info, &isNewCreated);
572 if (auth == NULL) {
573 AUTH_LOGE(AUTH_FSM, "auth manager does not exist.");
574 ReleaseAuthLock();
575 return SOFTBUS_ERR;
576 }
577 int32_t sessionKeyIndex = TO_INT32(authSeq);
578 if ((info->isSupportFastAuth) && (info->version <= SOFTBUS_OLD_V2)) {
579 sessionKeyIndex = TO_INT32(info->oldIndex);
580 }
581 if (AddSessionKey(&auth->sessionKeyList, sessionKeyIndex, sessionKey) != SOFTBUS_OK) {
582 AUTH_LOGE(AUTH_FSM, "failed to add a sessionkey");
583 if (isNewCreated) {
584 DelAuthManager(auth, true);
585 }
586 ReleaseAuthLock();
587 return SOFTBUS_ERR;
588 }
589 if (auth->connInfo.type == AUTH_LINK_TYPE_WIFI && !auth->isServer) {
590 ScheduleUpdateSessionKey(auth->authId, SCHEDULE_UPDATE_SESSION_KEY_PERIOD);
591 }
592 if (!isConnect) {
593 auth->hasAuthPassed = true;
594 }
595 AUTH_LOGI(AUTH_FSM,
596 "auth manager. authId=%{public}" PRId64 ", authSeq=%{public}" PRId64
597 ", index=%{public}d, lastVerifyTime=%{public}" PRId64,
598 auth->authId, authSeq, sessionKeyIndex, auth->lastVerifyTime);
599 ReleaseAuthLock();
600 return SOFTBUS_OK;
601 }
602
AuthManagerGetSessionKey(int64_t authSeq,const AuthSessionInfo * info,SessionKey * sessionKey)603 int32_t AuthManagerGetSessionKey(int64_t authSeq, const AuthSessionInfo *info, SessionKey *sessionKey)
604 {
605 AUTH_CHECK_AND_RETURN_RET_LOGE(info != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is NULL");
606 AUTH_CHECK_AND_RETURN_RET_LOGE(sessionKey != NULL, SOFTBUS_INVALID_PARAM, AUTH_FSM, "sessionKey is NULL");
607 AUTH_LOGI(AUTH_FSM, "GetSessionKey: authSeq=%{public}" PRId64 ", side=%{public}s, requestId=%{public}u", authSeq,
608 GetAuthSideStr(info->isServer), info->requestId);
609 if (!RequireAuthLock()) {
610 return SOFTBUS_LOCK_ERR;
611 }
612 AuthManager *auth = FindAuthManagerByConnInfo(&info->connInfo, info->isServer);
613 if (auth == NULL) {
614 PrintAuthConnInfo(&info->connInfo);
615 AUTH_LOGI(AUTH_FSM, "auth manager not found, connType=%{public}d", info->connInfo.type);
616 ReleaseAuthLock();
617 return SOFTBUS_AUTH_NOT_FOUND;
618 }
619 if (GetSessionKeyByIndex(&auth->sessionKeyList, TO_INT32(authSeq), sessionKey) != SOFTBUS_OK) {
620 AUTH_LOGE(AUTH_FSM, "GetSessionKeyByIndex fail");
621 ReleaseAuthLock();
622 return SOFTBUS_AUTH_GET_SESSION_KEY_FAIL;
623 }
624 ReleaseAuthLock();
625 return SOFTBUS_OK;
626 }
627
NotifyDeviceVerifyPassed(int64_t authId,const NodeInfo * nodeInfo)628 static void NotifyDeviceVerifyPassed(int64_t authId, const NodeInfo *nodeInfo)
629 {
630 AuthManager *auth = GetAuthManagerByAuthId(authId);
631 if (auth == NULL) {
632 AUTH_LOGE(AUTH_FSM, "get auth manager failed");
633 return;
634 }
635 if (auth->connInfo.type == AUTH_LINK_TYPE_P2P || auth->connInfo.type == AUTH_LINK_TYPE_ENHANCED_P2P) {
636 /* P2P auth no need notify to LNN. */
637 DelAuthManager(auth, false);
638 return;
639 }
640 DelAuthManager(auth, false);
641
642 /* notify LNN device verify pass. */
643 if (g_verifyListener.onDeviceVerifyPass == NULL) {
644 AUTH_LOGW(AUTH_FSM, "onDeviceVerifyPass not set");
645 return;
646 }
647 g_verifyListener.onDeviceVerifyPass(authId, nodeInfo);
648 }
649
NotifyDeviceDisconnect(int64_t authId)650 static void NotifyDeviceDisconnect(int64_t authId)
651 {
652 if (g_verifyListener.onDeviceDisconnect == NULL) {
653 AUTH_LOGW(AUTH_FSM, "onDeviceDisconnect not set");
654 return;
655 }
656 g_verifyListener.onDeviceDisconnect(authId);
657 }
658
OnDeviceNotTrusted(const char * peerUdid)659 static void OnDeviceNotTrusted(const char *peerUdid)
660 {
661 RemoveNotPassedAuthManagerByUdid(peerUdid);
662 AuthSessionHandleDeviceNotTrusted(peerUdid);
663 LnnDeleteSpecificTrustedDevInfo(peerUdid);
664 if (g_verifyListener.onDeviceNotTrusted == NULL) {
665 AUTH_LOGW(AUTH_HICHAIN, "onDeviceNotTrusted not set");
666 return;
667 }
668 g_verifyListener.onDeviceNotTrusted(peerUdid);
669 LnnHbOnTrustedRelationReduced();
670 AuthRemoveDeviceKeyByUdid(peerUdid);
671 }
672
OnGroupCreated(const char * groupId,int32_t groupType)673 static void OnGroupCreated(const char *groupId, int32_t groupType)
674 {
675 if (g_groupChangeListener.onGroupCreated != NULL) {
676 g_groupChangeListener.onGroupCreated(groupId, groupType);
677 }
678 }
679
OnGroupDeleted(const char * groupId)680 static void OnGroupDeleted(const char *groupId)
681 {
682 if (g_groupChangeListener.onGroupDeleted != NULL) {
683 g_groupChangeListener.onGroupDeleted(groupId);
684 }
685 }
686
OnDeviceBound(const char * udid,const char * groupInfo)687 static void OnDeviceBound(const char *udid, const char *groupInfo)
688 {
689 LnnInsertSpecificTrustedDevInfo(udid);
690 if (g_groupChangeListener.onDeviceBound != NULL) {
691 g_groupChangeListener.onDeviceBound(udid, groupInfo);
692 }
693 }
694
RetryRegTrustDataChangeListener()695 static int32_t RetryRegTrustDataChangeListener()
696 {
697 TrustDataChangeListener trustListener = {
698 .onGroupCreated = OnGroupCreated,
699 .onGroupDeleted = OnGroupDeleted,
700 .onDeviceNotTrusted = OnDeviceNotTrusted,
701 .onDeviceBound = OnDeviceBound,
702 };
703 for (int32_t i = 1; i <= RETRY_REGDATA_TIMES; i++) {
704 int32_t ret = RegTrustDataChangeListener(&trustListener);
705 if (ret == SOFTBUS_OK) {
706 AUTH_LOGI(AUTH_HICHAIN, "regDataChangeListener success, times=%{public}d", i);
707 return SOFTBUS_OK;
708 }
709 AUTH_LOGW(AUTH_HICHAIN, "retry regDataChangeListener, current retry times=%{public}d, err=%{public}d", i, ret);
710 (void)SoftBusSleepMs(RETRY_REGDATA_MILLSECONDS);
711 }
712 return SOFTBUS_ERR;
713 }
714
DfxRecordLnnAuthStart(const AuthConnInfo * connInfo)715 static void DfxRecordLnnAuthStart(const AuthConnInfo *connInfo)
716 {
717 LnnEventExtra extra = { 0 };
718 LnnEventExtraInit(&extra);
719 if (connInfo != NULL) {
720 extra.authLinkType = connInfo->type;
721 }
722 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH, extra);
723 }
724
StartVerifyDevice(uint32_t requestId,const AuthConnInfo * connInfo,const AuthVerifyCallback * verifyCb,const AuthConnCallback * connCb,bool isFastAuth)725 static int32_t StartVerifyDevice(uint32_t requestId, const AuthConnInfo *connInfo, const AuthVerifyCallback *verifyCb,
726 const AuthConnCallback *connCb, bool isFastAuth)
727 {
728 int64_t traceId = GenSeq(false);
729 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)traceId);
730 AUTH_LOGI(AUTH_CONN, "start verify device: requestId=%{public}u", requestId);
731 if (!g_regDataChangeListener) {
732 if (RetryRegTrustDataChangeListener() != SOFTBUS_OK) {
733 AUTH_LOGE(AUTH_HICHAIN, "hichain regDataChangeListener failed");
734 SoftbusHitraceStop();
735 return SOFTBUS_AUTH_INIT_FAIL;
736 }
737 g_regDataChangeListener = true;
738 }
739 AuthRequest request;
740 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
741 if (connCb != NULL) {
742 request.connCb = *connCb;
743 }
744 if (verifyCb != NULL) {
745 request.verifyCb = *verifyCb;
746 }
747 request.traceId = traceId;
748 request.requestId = requestId;
749 request.connInfo = *connInfo;
750 request.authId = AUTH_INVALID_ID;
751 request.type =
752 (verifyCb == NULL && connInfo->type == AUTH_LINK_TYPE_BLE) ? REQUEST_TYPE_CONNECT : REQUEST_TYPE_VERIFY;
753 request.addTime = GetCurrentTimeMs();
754 request.isFastAuth = isFastAuth;
755 uint32_t waitNum = AddAuthRequest(&request);
756 if (waitNum == 0) {
757 AUTH_LOGE(AUTH_CONN, "add verify request to list fail, requestId=%{public}u", requestId);
758 SoftbusHitraceStop();
759 return SOFTBUS_AUTH_INNER_ERR;
760 }
761 if (waitNum > 1) {
762 AUTH_LOGI(
763 AUTH_CONN, "wait last verify request complete, waitNum=%{public}u, requestId=%{public}u",
764 waitNum, requestId);
765 SoftbusHitraceStop();
766 return SOFTBUS_OK;
767 }
768 if (ConnectAuthDevice(requestId, connInfo, CONN_SIDE_ANY) != SOFTBUS_OK) {
769 AUTH_LOGE(AUTH_CONN, "connect auth device failed: requestId=%{public}u", requestId);
770 FindAndDelAuthRequestByConnInfo(requestId, connInfo);
771 SoftbusHitraceStop();
772 return SOFTBUS_AUTH_CONN_FAIL;
773 }
774 SoftbusHitraceStop();
775 AUTH_LOGI(AUTH_CONN, "verify device succ. requestId=%{public}u", requestId);
776 return SOFTBUS_OK;
777 }
778
StartReconnectDevice(int64_t authId,const AuthConnInfo * connInfo,uint32_t requestId,const AuthConnCallback * connCb)779 static int32_t StartReconnectDevice(
780 int64_t authId, const AuthConnInfo *connInfo, uint32_t requestId, const AuthConnCallback *connCb)
781 {
782 AUTH_LOGI(AUTH_CONN, "start reconnect device. requestId=%{public}u, authId=%{public}" PRId64, requestId, authId);
783 AuthManager *auth = GetAuthManagerByAuthId(authId);
784 if (auth == NULL) {
785 return SOFTBUS_AUTH_NOT_FOUND;
786 }
787 ConnSideType sideType = GetConnSideType(auth->connId);
788 DelAuthManager(auth, false);
789
790 AuthRequest request;
791 (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
792 request.authId = authId;
793 request.connCb = *connCb;
794 request.connInfo = *connInfo;
795 request.requestId = requestId;
796 request.type = REQUEST_TYPE_RECONNECT;
797 request.addTime = GetCurrentTimeMs();
798 request.isFastAuth = true;
799 if (AddAuthRequest(&request) == 0) {
800 AUTH_LOGE(AUTH_CONN, "add reconnect request fail, requestId=%{public}u", requestId);
801 return SOFTBUS_ERR;
802 }
803 if (ConnectAuthDevice(requestId, connInfo, sideType) != SOFTBUS_OK) {
804 DelAuthRequest(requestId);
805 return SOFTBUS_AUTH_CONN_FAIL;
806 }
807 return SOFTBUS_OK;
808 }
809
ReportAuthRequestPassed(uint32_t requestId,int64_t authId,const NodeInfo * nodeInfo)810 static void ReportAuthRequestPassed(uint32_t requestId, int64_t authId, const NodeInfo *nodeInfo)
811 {
812 AuthRequest request;
813 if (GetAuthRequest(requestId, &request) != SOFTBUS_OK) {
814 AUTH_LOGI(AUTH_FSM, "auth request not found, only notify LNN to update nodeInfo");
815 NotifyDeviceVerifyPassed(authId, nodeInfo);
816 return;
817 }
818 do {
819 if (CheckAuthConnCallback(&request.connCb)) {
820 NotifyDeviceVerifyPassed(authId, nodeInfo);
821 if (request.connInfo.type == AUTH_LINK_TYPE_WIFI || request.connInfo.type == AUTH_LINK_TYPE_P2P ||
822 request.connInfo.type == AUTH_LINK_TYPE_ENHANCED_P2P) {
823 PerformAuthConnCallback(request.requestId, SOFTBUS_OK, authId);
824 DelAuthRequest(request.requestId);
825 continue;
826 }
827 /* For open auth br/ble connection, reconnect to keep long-connection. */
828 DelAuthRequest(request.requestId);
829 if (StartReconnectDevice(authId, &request.connInfo, request.requestId, &request.connCb) != SOFTBUS_OK) {
830 AUTH_LOGE(AUTH_CONN, "open auth reconnect fail");
831 request.connCb.onConnOpenFailed(request.requestId, SOFTBUS_AUTH_CONN_FAIL);
832 }
833 continue;
834 }
835 PerformVerifyCallback(request.requestId, SOFTBUS_OK, authId, nodeInfo);
836 DelAuthRequest(request.requestId);
837 } while (FindAuthRequestByConnInfo(&request.connInfo, &request) == SOFTBUS_OK);
838 }
839
ReportAuthRequestFailed(uint32_t requestId,int32_t reason)840 static void ReportAuthRequestFailed(uint32_t requestId, int32_t reason)
841 {
842 AuthRequest request;
843 if (GetAuthRequest(requestId, &request) != SOFTBUS_OK) {
844 AUTH_LOGE(AUTH_FSM, "auth request not found");
845 return;
846 }
847 if (CheckAuthConnCallback(&request.connCb)) {
848 PerformAuthConnCallback(request.requestId, reason, AUTH_INVALID_ID);
849 } else {
850 PerformVerifyCallback(request.requestId, reason, AUTH_INVALID_ID, NULL);
851 }
852 DelAuthRequest(request.requestId);
853 if (FindAuthRequestByConnInfo(&request.connInfo, &request) != SOFTBUS_OK) {
854 /* verify request wait list is empty, return. */
855 return;
856 }
857 AUTH_LOGI(AUTH_CONN, "find another verify request in wait list, do verify again");
858 if (ConnectAuthDevice(request.requestId, &request.connInfo, CONN_SIDE_ANY) != SOFTBUS_OK) {
859 ReportAuthRequestFailed(request.requestId, SOFTBUS_AUTH_CONN_FAIL);
860 }
861 }
862
ComplementConnectionInfoIfNeed(AuthManager * auth,const char * udid)863 static int32_t ComplementConnectionInfoIfNeed(AuthManager *auth, const char *udid)
864 {
865 if (auth->connInfo.type != AUTH_LINK_TYPE_BLE) {
866 return SOFTBUS_OK;
867 }
868 if (udid == NULL || strlen(udid) == 0) {
869 AUTH_LOGE(AUTH_FSM, "invalid udid");
870 return SOFTBUS_INVALID_PARAM;
871 }
872 int32_t ret = SoftBusGenerateStrHash((unsigned char *)udid, strlen(udid),
873 (unsigned char *)auth->connInfo.info.bleInfo.deviceIdHash);
874 return ret;
875 }
876
AuthManagerSetAuthPassed(int64_t authSeq,const AuthSessionInfo * info)877 void AuthManagerSetAuthPassed(int64_t authSeq, const AuthSessionInfo *info)
878 {
879 int64_t authId;
880 AUTH_CHECK_AND_RETURN_LOGE(info != NULL, AUTH_FSM, "info is null");
881 AUTH_LOGI(AUTH_FSM, "SetAuthPassed: authSeq=%{public}" PRId64 ", side=%{public}s, requestId=%{public}u", authSeq,
882 GetAuthSideStr(info->isServer), info->requestId);
883
884 if (!RequireAuthLock()) {
885 return;
886 }
887 AuthManager *auth = FindAuthManagerByConnInfo(&info->connInfo, info->isServer);
888 if (auth == NULL) {
889 PrintAuthConnInfo(&info->connInfo);
890 ReleaseAuthLock();
891 AUTH_LOGE(AUTH_FSM, "auth manager not found, connType=%{public}d, side=%{public}s", info->connInfo.type,
892 GetAuthSideStr(info->isServer));
893 return;
894 }
895
896 int32_t ret = ComplementConnectionInfoIfNeed(auth, info->nodeInfo.deviceInfo.deviceUdid);
897 if (ret != SOFTBUS_OK) {
898 ReleaseAuthLock();
899 AUTH_LOGE(AUTH_FSM, "complement auth connection info failed, authSeq=%{public}" PRId64 ", ret=%{public}d",
900 authSeq, ret);
901 return;
902 }
903
904 auth->hasAuthPassed = true;
905 if (info->nodeInfo.p2pInfo.p2pMac[0] != '\0') {
906 if (strcpy_s(auth->p2pMac, sizeof(auth->p2pMac), info->nodeInfo.p2pInfo.p2pMac)) {
907 AUTH_LOGE(AUTH_FSM, "copy p2pMac fail, authSeq=%{public}" PRId64, authSeq);
908 }
909 }
910 authId = auth->authId;
911 ReleaseAuthLock();
912
913 if (info->isServer) {
914 NotifyDeviceVerifyPassed(authId, &info->nodeInfo);
915 } else {
916 ReportAuthRequestPassed(info->requestId, authId, &info->nodeInfo);
917 UpdateAuthDevicePriority(info->connId);
918 }
919 }
920
AuthManagerSetAuthFailed(int64_t authSeq,const AuthSessionInfo * info,int32_t reason)921 void AuthManagerSetAuthFailed(int64_t authSeq, const AuthSessionInfo *info, int32_t reason)
922 {
923 AUTH_CHECK_AND_RETURN_LOGE(info != NULL, AUTH_FSM, "auth session info is null");
924 AUTH_LOGE(AUTH_FSM, "SetAuthFailed: authSeq=%{public}" PRId64 ", requestId=%{public}u, reason=%{public}d", authSeq,
925 info->requestId, reason);
926 AuthManager *auth = GetAuthManagerByConnInfo(&info->connInfo, info->isServer);
927 bool needDisconnect = true;
928 if (auth != NULL && reason == SOFTBUS_AUTH_TIMEOUT && info->connInfo.type == AUTH_LINK_TYPE_WIFI
929 && info->connInfo.info.ipInfo.port != auth->connInfo.info.ipInfo.port) {
930 AUTH_LOGE(AUTH_FSM, "auth manager port change, connType=%{public}d, side=%{public}s",
931 info->connInfo.type, GetAuthSideStr(info->isServer));
932 needDisconnect = false;
933 }
934 if (auth != NULL && auth->hasAuthPassed && needDisconnect) {
935 AUTH_LOGE(AUTH_FSM, "update session key fail, authId=%{public}" PRId64, auth->authId);
936 NotifyDeviceDisconnect(auth->authId);
937 }
938 DelAuthManager(auth, false);
939
940 if (needDisconnect) {
941 RemoveAuthManagerByConnInfo(&info->connInfo, info->isServer);
942 }
943 ReportAuthRequestFailed(info->requestId, reason);
944 if (GetConnType(info->connId) == AUTH_LINK_TYPE_WIFI) {
945 DisconnectAuthDevice((uint64_t *)&info->connId);
946 } else if (!info->isServer) {
947 /* Bluetooth networking only the client to close the connection. */
948 UpdateAuthDevicePriority(info->connId);
949 DisconnectAuthDevice((uint64_t *)&info->connId);
950 }
951 }
952
HandleBleDisconnectDelay(const void * para)953 static void HandleBleDisconnectDelay(const void *para)
954 {
955 AUTH_CHECK_AND_RETURN_LOGE(para != NULL, AUTH_FSM, "para is null");
956 uint64_t connId = *((uint64_t *)para);
957 DisconnectAuthDevice(&connId);
958 }
959
BleDisconnectDelay(uint64_t connId,uint64_t delayMs)960 static void BleDisconnectDelay(uint64_t connId, uint64_t delayMs)
961 {
962 (void)PostAuthEvent(EVENT_BLE_DISCONNECT_DELAY, HandleBleDisconnectDelay, &connId, sizeof(connId), delayMs);
963 }
964
AuthManagerSetAuthFinished(int64_t authSeq,const AuthSessionInfo * info)965 void AuthManagerSetAuthFinished(int64_t authSeq, const AuthSessionInfo *info)
966 {
967 AUTH_CHECK_AND_RETURN_LOGE(info != NULL, AUTH_FSM, "auth session info is null");
968 AUTH_LOGI(AUTH_FSM, "SetAuthFinished: authSeq=%{public}" PRId64 ", requestId=%{public}u", authSeq, info->requestId);
969 if (info->isServer) {
970 AUTH_LOGI(AUTH_FSM, "SERVER: wait client close connection");
971 return;
972 }
973 /* br and ble NOT long-connection, close connection after auth pass. */
974 if (info->connInfo.type == AUTH_LINK_TYPE_BLE) {
975 uint64_t localFeature;
976 int32_t ret = LnnGetLocalNumU64Info(NUM_KEY_FEATURE_CAPA, &localFeature);
977 if (ret != SOFTBUS_OK) {
978 AUTH_LOGE(AUTH_FSM, "ret=%{public}d, local=%{public}" PRIu64, ret, localFeature);
979 return;
980 }
981 if (info->connInfo.info.bleInfo.protocol == BLE_GATT &&
982 IsFeatureSupport(localFeature, BIT_BLE_ONLINE_REUSE_CAPABILITY) &&
983 IsFeatureSupport(info->nodeInfo.feature, BIT_BLE_ONLINE_REUSE_CAPABILITY)) {
984 AUTH_LOGI(
985 AUTH_FSM, "support ble reuse, bleConnCloseDelayTime=%{public}ds", info->nodeInfo.bleConnCloseDelayTime);
986 BleDisconnectDelay(info->connId, info->nodeInfo.bleConnCloseDelayTime);
987 } else {
988 AUTH_LOGI(AUTH_FSM, "ble disconn now");
989 DisconnectAuthDevice((uint64_t *)&info->connId);
990 }
991 }
992 if (info->connInfo.type == AUTH_LINK_TYPE_BR) {
993 AUTH_LOGI(AUTH_FSM, "br disconn now");
994 DisconnectAuthDevice((uint64_t *)&info->connId);
995 }
996 }
997
HandleReconnectResult(const AuthRequest * request,uint64_t connId,int32_t result)998 static void HandleReconnectResult(const AuthRequest *request, uint64_t connId, int32_t result)
999 {
1000 if (result != SOFTBUS_OK) {
1001 PerformAuthConnCallback(request->requestId, result, AUTH_INVALID_ID);
1002 DelAuthRequest(request->requestId);
1003 return;
1004 }
1005 AuthManager inAuth = { .connId = connId };
1006 if (UpdateAuthManagerByAuthId(request->authId, SetAuthConnId, &inAuth) != SOFTBUS_OK) {
1007 AUTH_LOGE(AUTH_CONN, "set auth connId fail, requestId=%{public}u", request->requestId);
1008 PerformAuthConnCallback(request->requestId, SOFTBUS_AUTH_NOT_FOUND, AUTH_INVALID_ID);
1009 DelAuthRequest(request->requestId);
1010 return;
1011 }
1012 PerformAuthConnCallback(request->requestId, SOFTBUS_OK, request->authId);
1013 DelAuthRequest(request->requestId);
1014 }
1015
HandleBleConnectResult(uint32_t requestId,int64_t authId,uint64_t connId,int32_t result)1016 static void HandleBleConnectResult(uint32_t requestId, int64_t authId, uint64_t connId, int32_t result)
1017 {
1018 AuthRequest request;
1019 if (GetAuthRequest(requestId, &request) != SOFTBUS_OK) {
1020 AUTH_LOGI(AUTH_CONN, "get request info failed, requestId=%{public}u", requestId);
1021 return;
1022 }
1023 AuthManager inAuth = { .connId = connId };
1024 if (UpdateAuthManagerByAuthId(authId, SetAuthConnId, &inAuth) != SOFTBUS_OK) {
1025 AUTH_LOGE(AUTH_CONN, "set auth connId fail, requestId=%{public}u", requestId);
1026 return;
1027 }
1028 do {
1029 if (result != SOFTBUS_OK) {
1030 PerformAuthConnCallback(request.requestId, result, AUTH_INVALID_ID);
1031 } else {
1032 PerformAuthConnCallback(request.requestId, SOFTBUS_OK, authId);
1033 }
1034 DelAuthRequest(request.requestId);
1035 } while (FindAuthRequestByConnInfo(&request.connInfo, &request) == SOFTBUS_OK);
1036 }
1037
DfxRecordLnnConnectEnd(uint64_t connId,const AuthConnInfo * connInfo,int32_t reason)1038 static void DfxRecordLnnConnectEnd(uint64_t connId, const AuthConnInfo *connInfo, int32_t reason)
1039 {
1040 LnnEventExtra extra = { 0 };
1041 LnnEventExtraInit(&extra);
1042 extra.connectionId = (int32_t)connId;
1043 extra.errcode = reason;
1044 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
1045
1046 if (connInfo != NULL) {
1047 extra.authLinkType = connInfo->type;
1048 }
1049 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH_CONNECTION, extra);
1050 }
1051
OnConnectResult(uint32_t requestId,uint64_t connId,int32_t result,const AuthConnInfo * connInfo)1052 static void OnConnectResult(uint32_t requestId, uint64_t connId, int32_t result, const AuthConnInfo *connInfo)
1053 {
1054 DfxRecordLnnConnectEnd(connId, connInfo, result);
1055 AUTH_LOGI(AUTH_CONN, "OnConnectResult: requestId=%{public}u, result=%{public}d", requestId, result);
1056 AuthRequest request;
1057 if (GetAuthRequest(requestId, &request) != SOFTBUS_OK) {
1058 AUTH_LOGE(AUTH_CONN, "request not found, requestId=%{public}u", requestId);
1059 return;
1060 }
1061 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)request.traceId);
1062 if (request.type == REQUEST_TYPE_RECONNECT) {
1063 HandleReconnectResult(&request, connId, result);
1064 SoftbusHitraceStop();
1065 return;
1066 }
1067
1068 if (result != SOFTBUS_OK) {
1069 ReportAuthRequestFailed(requestId, result);
1070 SoftbusHitraceStop();
1071 return;
1072 }
1073 if ((connInfo != NULL) && (connInfo->type == AUTH_LINK_TYPE_BLE) && (request.type == REQUEST_TYPE_CONNECT)) {
1074 int64_t authId = GetLatestIdByConnInfo(connInfo, connInfo->type);
1075 if (authId != AUTH_INVALID_ID) {
1076 HandleBleConnectResult(requestId, authId, connId, result);
1077 SoftbusHitraceStop();
1078 return;
1079 }
1080 }
1081 int32_t ret = AuthSessionStartAuth(request.traceId, requestId, connId, connInfo, false, request.isFastAuth);
1082 if (ret != SOFTBUS_OK) {
1083 AUTH_LOGE(AUTH_CONN, "start auth session fail=%{public}d, requestId=%{public}u", ret, requestId);
1084 DisconnectAuthDevice(&connId);
1085 ReportAuthRequestFailed(requestId, ret);
1086 SoftbusHitraceStop();
1087 return;
1088 }
1089 SoftbusHitraceStop();
1090 }
1091
HandleDeviceIdData(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)1092 static void HandleDeviceIdData(
1093 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
1094 {
1095 int32_t ret;
1096 if (head->flag == CLIENT_SIDE_FLAG) {
1097 if (!GetConfigSupportAsServer()) {
1098 AUTH_LOGE(AUTH_FSM, "local device NOT support as server, ignore auth seq=%{public}" PRId64, head->seq);
1099 return;
1100 }
1101 AuthFsm *fsm = GetAuthFsmByConnId(connId, true);
1102 if ((fsm != NULL && fsm->info.idType == EXCHANGE_NETWORKID) ||
1103 (fsm != NULL && fsm->info.idType == EXCHANGE_FAIL)) {
1104 ret = AuthSessionProcessDevIdData(head->seq, data, head->len);
1105 if (ret != SOFTBUS_OK) {
1106 AUTH_LOGE(AUTH_FSM,
1107 "perform auth session recv devId fail. seq=%{public}" PRId64 ", ret=%{public}d", head->seq, ret);
1108 }
1109 return;
1110 }
1111 if (fsm != NULL && fsm->info.idType == EXCHANHE_UDID) {
1112 AUTH_LOGE(AUTH_FSM, "the same connId fsm not support, ignore auth seq=%{public}" PRId64, head->seq);
1113 HandleRepeatDeviceIdDataDelay(connId, connInfo, fromServer, head, data);
1114 return;
1115 }
1116 ret = AuthSessionStartAuth(head->seq, AuthGenRequestId(), connId, connInfo, true, true);
1117 if (ret != SOFTBUS_OK) {
1118 AUTH_LOGE(AUTH_FSM,
1119 "perform auth session start auth fail. seq=%{public}" PRId64 ", ret=%{public}d", head->seq, ret);
1120 return;
1121 }
1122 }
1123 ret = AuthSessionProcessDevIdData(head->seq, data, head->len);
1124 if (ret != SOFTBUS_OK) {
1125 AUTH_LOGE(AUTH_FSM,
1126 "perform auth session recv devId fail. seq=%{public}" PRId64 ", ret=%{public}d", head->seq, ret);
1127 return;
1128 }
1129 }
1130
HandleAuthData(const AuthConnInfo * connInfo,const AuthDataHead * head,const uint8_t * data)1131 static void HandleAuthData(const AuthConnInfo *connInfo, const AuthDataHead *head, const uint8_t *data)
1132 {
1133 int32_t ret = AuthSessionProcessAuthData(head->seq, data, head->len);
1134 if (ret != SOFTBUS_OK) {
1135 AUTH_LOGE(AUTH_FSM,
1136 "perform auth session recv authData fail. seq=%{public}" PRId64 ", ret=%{public}d", head->seq, ret);
1137 return;
1138 }
1139 }
1140
FlushDeviceProcess(const AuthConnInfo * connInfo,bool isServer)1141 static void FlushDeviceProcess(const AuthConnInfo *connInfo, bool isServer)
1142 {
1143 if (!RequireAuthLock()) {
1144 return;
1145 }
1146 AuthManager *auth = FindAuthManagerByConnInfo(connInfo, isServer);
1147 if (auth == NULL) {
1148 PrintAuthConnInfo(connInfo);
1149 ReleaseAuthLock();
1150 AUTH_LOGE(AUTH_FSM, "auth manager not found");
1151 return;
1152 }
1153 if (PostVerifyDeviceMessage(auth, FLAG_REPLY) == SOFTBUS_OK) {
1154 AUTH_LOGI(AUTH_FSM, "post flush device ok");
1155 }
1156 ReleaseAuthLock();
1157 return;
1158 }
1159
HandleDeviceInfoData(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)1160 static void HandleDeviceInfoData(
1161 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
1162 {
1163 int32_t ret = SOFTBUS_OK;
1164 if (IsFlushDevicePacket(connInfo, head, data, !fromServer)) {
1165 if (head->flag == 0) {
1166 AUTH_LOGE(AUTH_FSM, "flush device need relay");
1167 FlushDeviceProcess(connInfo, !fromServer);
1168 } else {
1169 AUTH_LOGE(AUTH_FSM, "flush device not need relay");
1170 }
1171 return;
1172 }
1173
1174 if (AuthSessionProcessDevInfoData(head->seq, data, head->len) != SOFTBUS_OK) {
1175 /* To be compatible with ohos-3.1 and early. */
1176 AUTH_LOGI(AUTH_FSM,
1177 "auth processDeviceInfo. type=0x%{public}x, module=%{public}d, seq=%{public}" PRId64 ", "
1178 "flag=%{public}d, len=%{public}u, " CONN_INFO ", fromServer=%{public}s",
1179 head->dataType, head->module, head->seq, head->flag, head->len, CONN_DATA(connId),
1180 GetAuthSideStr(fromServer));
1181 ret = AuthSessionProcessDevInfoDataByConnId(connId, !fromServer, data, head->len);
1182 }
1183 if (ret != SOFTBUS_OK) {
1184 AUTH_LOGE(AUTH_FSM, "perform auth session recv devInfo fail. seq=%{public}" PRId64 ", ret=%{public}d",
1185 head->seq, ret);
1186 return;
1187 }
1188 }
1189
HandleCloseAckData(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)1190 static void HandleCloseAckData(
1191 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
1192 {
1193 int32_t ret;
1194 if (head->seq != 0) {
1195 ret = AuthSessionProcessCloseAck(head->seq, data, head->len);
1196 } else {
1197 /* To be compatible with nearby. */
1198 ret = AuthSessionProcessCloseAckByConnId(connId, !fromServer, data, head->len);
1199 }
1200 if (ret != SOFTBUS_OK) {
1201 AUTH_LOGE(AUTH_CONN, "perform auth session recv closeAck fail. seq=%{public}" PRId64 ", ret=%{public}d",
1202 head->seq, ret);
1203 return;
1204 }
1205 }
1206
HandleConnectionData(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)1207 static void HandleConnectionData(
1208 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
1209 {
1210 if (!RequireAuthLock()) {
1211 return;
1212 }
1213 AuthManager *auth = FindAuthManagerByConnInfo(connInfo, !fromServer);
1214 if (auth == NULL) {
1215 PrintAuthConnInfo(connInfo);
1216 AUTH_LOGE(AUTH_CONN, "AuthManager not found, connType=%{public}d", connInfo->type);
1217 ReleaseAuthLock();
1218 return;
1219 }
1220 int64_t authId = auth->authId;
1221 uint8_t *decData = NULL;
1222 uint32_t decDataLen = 0;
1223 if (DecryptInner(&auth->sessionKeyList, data, head->len, &decData, &decDataLen) != SOFTBUS_OK) {
1224 AUTH_LOGE(AUTH_CONN, "decrypt trans data fail");
1225 ReleaseAuthLock();
1226 return;
1227 }
1228 auth->lastActiveTime = GetCurrentTimeMs();
1229 auth->connId = connId;
1230 ReleaseAuthLock();
1231 if (g_transCallback.OnDataReceived != NULL) {
1232 g_transCallback.OnDataReceived(authId, head, decData, decDataLen);
1233 }
1234 SoftBusFree(decData);
1235 }
1236
OnDataReceived(uint64_t connId,const AuthConnInfo * connInfo,bool fromServer,const AuthDataHead * head,const uint8_t * data)1237 static void OnDataReceived(
1238 uint64_t connId, const AuthConnInfo *connInfo, bool fromServer, const AuthDataHead *head, const uint8_t *data)
1239 {
1240 if (connInfo == NULL || head == NULL || data == NULL) {
1241 AUTH_LOGE(AUTH_CONN, "invalid param");
1242 return;
1243 }
1244 SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)head->seq);
1245 AUTH_LOGI(AUTH_CONN,
1246 "auth recv data. type=0x%{public}x, module=%{public}d, seq=%{public}" PRId64 ", "
1247 "flag=%{public}d, len=%{public}u, " CONN_INFO ", fromServer=%{public}s",
1248 head->dataType, head->module, head->seq, head->flag, head->len, CONN_DATA(connId), GetAuthSideStr(fromServer));
1249 switch (head->dataType) {
1250 case DATA_TYPE_DEVICE_ID:
1251 HandleDeviceIdData(connId, connInfo, fromServer, head, data);
1252 break;
1253 case DATA_TYPE_AUTH:
1254 HandleAuthData(connInfo, head, data);
1255 break;
1256 case DATA_TYPE_DEVICE_INFO:
1257 HandleDeviceInfoData(connId, connInfo, fromServer, head, data);
1258 break;
1259 case DATA_TYPE_CLOSE_ACK:
1260 HandleCloseAckData(connId, connInfo, fromServer, head, data);
1261 break;
1262 case DATA_TYPE_CONNECTION:
1263 HandleConnectionData(connId, connInfo, fromServer, head, data);
1264 break;
1265 default:
1266 break;
1267 }
1268 SoftbusHitraceStop();
1269 }
1270
HandleDisconnectedEvent(const void * para)1271 static void HandleDisconnectedEvent(const void *para)
1272 {
1273 AUTH_CHECK_AND_RETURN_LOGE(para != NULL, AUTH_FSM, "para is null");
1274 uint64_t connId = *((uint64_t *)para);
1275 uint32_t num = 0;
1276 uint64_t dupConnId = connId;
1277 int64_t authIds[2]; /* 2: client and server may use same connection. */
1278 authIds[num++] = GetAuthIdByConnId(connId, false);
1279 authIds[num++] = GetAuthIdByConnId(connId, true);
1280 for (uint32_t i = 0; i < num; i++) {
1281 if (authIds[i] == AUTH_INVALID_ID) {
1282 continue;
1283 }
1284 if (g_transCallback.OnDisconnected != NULL) {
1285 g_transCallback.OnDisconnected(authIds[i]);
1286 }
1287 if (GetConnType(connId) == AUTH_LINK_TYPE_WIFI || GetConnType(connId) == AUTH_LINK_TYPE_P2P ||
1288 GetConnType(connId) == AUTH_LINK_TYPE_ENHANCED_P2P) {
1289 NotifyDeviceDisconnect(authIds[i]);
1290 DisconnectAuthDevice(&dupConnId);
1291 AuthManager inAuth = { .connId = dupConnId };
1292 (void)UpdateAuthManagerByAuthId(authIds[i], SetAuthConnId, &inAuth);
1293 RemoveAuthManagerByAuthId(authIds[i]);
1294 }
1295 }
1296 /* Try to terminate authing session. */
1297 (void)AuthSessionHandleDeviceDisconnected(connId);
1298 }
1299
OnDisconnected(uint64_t connId,const AuthConnInfo * connInfo)1300 static void OnDisconnected(uint64_t connId, const AuthConnInfo *connInfo)
1301 {
1302 (void)connInfo;
1303 (void)PostAuthEvent(EVENT_AUTH_DISCONNECT, HandleDisconnectedEvent, &connId, sizeof(connId), 0);
1304 }
1305
RegAuthVerifyListener(const AuthVerifyListener * listener)1306 int32_t RegAuthVerifyListener(const AuthVerifyListener *listener)
1307 {
1308 if (listener == NULL) {
1309 AUTH_LOGE(AUTH_CONN, "invalid listener");
1310 return SOFTBUS_INVALID_PARAM;
1311 }
1312 g_verifyListener = *listener;
1313 return SOFTBUS_OK;
1314 }
1315
UnregAuthVerifyListener(void)1316 void UnregAuthVerifyListener(void)
1317 {
1318 (void)memset_s(&g_verifyListener, sizeof(AuthVerifyListener), 0, sizeof(AuthVerifyListener));
1319 }
1320
AuthGenRequestId(void)1321 uint32_t AuthGenRequestId(void)
1322 {
1323 return ConnGetNewRequestId(MODULE_DEVICE_AUTH);
1324 }
1325
AuthStartVerify(const AuthConnInfo * connInfo,uint32_t requestId,const AuthVerifyCallback * callback,bool isFastAuth)1326 int32_t AuthStartVerify(const AuthConnInfo *connInfo, uint32_t requestId,
1327 const AuthVerifyCallback *callback, bool isFastAuth)
1328 {
1329 DfxRecordLnnAuthStart(connInfo);
1330 if (connInfo == NULL || !CheckVerifyCallback(callback)) {
1331 AUTH_LOGE(AUTH_CONN, "invalid param");
1332 return SOFTBUS_INVALID_PARAM;
1333 }
1334 return StartVerifyDevice(requestId, connInfo, callback, NULL, isFastAuth);
1335 }
1336
AuthHandleLeaveLNN(int64_t authId)1337 void AuthHandleLeaveLNN(int64_t authId)
1338 {
1339 AUTH_LOGI(AUTH_FSM, "auth handle leave LNN, authId=%{public}" PRId64, authId);
1340 if (!RequireAuthLock()) {
1341 return;
1342 }
1343 AuthManager *auth = FindAuthManagerByAuthId(authId);
1344 if (auth == NULL) {
1345 ReleaseAuthLock();
1346 AUTH_LOGE(AUTH_FSM, "auth manager not found, authId=%{public}" PRId64, authId);
1347 return;
1348 }
1349 if (!auth->hasAuthPassed) {
1350 ReleaseAuthLock();
1351 AUTH_LOGI(AUTH_FSM, "auth pass = false, don't need to leave");
1352 return;
1353 }
1354 if (auth->connInfo.type == AUTH_LINK_TYPE_WIFI) {
1355 DisconnectAuthDevice(&auth->connId);
1356 }
1357 DelAuthManager(auth, true);
1358 ReleaseAuthLock();
1359 }
1360
AuthFlushDevice(const char * uuid)1361 int32_t AuthFlushDevice(const char *uuid)
1362 {
1363 if (uuid == NULL || uuid[0] == '\0') {
1364 AUTH_LOGE(AUTH_CONN, "uuid is empty");
1365 return SOFTBUS_INVALID_PARAM;
1366 }
1367 if (!RequireAuthLock()) {
1368 return SOFTBUS_LOCK_ERR;
1369 }
1370 uint32_t num = 0;
1371 int32_t ret = SOFTBUS_ERR;
1372 AuthManager *auth[2] = { NULL, NULL }; /* 2: WiFi * (Client + Server) */
1373 auth[num++] = FindAuthManagerByUuid(uuid, AUTH_LINK_TYPE_WIFI, false);
1374 auth[num++] = FindAuthManagerByUuid(uuid, AUTH_LINK_TYPE_WIFI, true);
1375 for (uint32_t i = 0; i < num; i++) {
1376 if (auth[i] == NULL) {
1377 continue;
1378 }
1379 if (PostVerifyDeviceMessage(auth[i], FLAG_ACTIVE) == SOFTBUS_OK) {
1380 ret = SOFTBUS_OK;
1381 }
1382 }
1383 ReleaseAuthLock();
1384 return ret;
1385 }
1386
TryGetBrConnInfo(const char * uuid,AuthConnInfo * connInfo)1387 static int32_t TryGetBrConnInfo(const char *uuid, AuthConnInfo *connInfo)
1388 {
1389 char networkId[NETWORK_ID_BUF_LEN] = { 0 };
1390 if (LnnGetNetworkIdByUuid(uuid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
1391 AUTH_LOGE(AUTH_CONN, "get networkdId by uuid fail");
1392 return SOFTBUS_AUTH_GET_BR_CONN_INFO_FAIL;
1393 }
1394
1395 uint32_t local, remote;
1396 if (LnnGetLocalNumInfo(NUM_KEY_NET_CAP, (int32_t *)&local) != SOFTBUS_OK ||
1397 LnnGetRemoteNumInfo(networkId, NUM_KEY_NET_CAP, (int32_t *)&remote) != SOFTBUS_OK) {
1398 AUTH_LOGE(AUTH_CONN, "get NET_CAP fail");
1399 return SOFTBUS_AUTH_GET_BR_CONN_INFO_FAIL;
1400 }
1401 if (((local & (1 << BIT_BR)) == 0) || ((remote & (1 << BIT_BR)) == 0)) {
1402 AUTH_LOGW(AUTH_CONN, "can't support BR");
1403 return SOFTBUS_AUTH_GET_BR_CONN_INFO_FAIL;
1404 }
1405 if (LnnGetRemoteStrInfo(networkId, STRING_KEY_BT_MAC, connInfo->info.brInfo.brMac, BT_MAC_LEN) != SOFTBUS_OK ||
1406 connInfo->info.brInfo.brMac[0] == '\0') {
1407 AUTH_LOGE(AUTH_CONN, "get bt mac fail");
1408 return SOFTBUS_AUTH_GET_BR_CONN_INFO_FAIL;
1409 }
1410 connInfo->type = AUTH_LINK_TYPE_BR;
1411 return SOFTBUS_OK;
1412 }
1413
AuthDeviceGetPreferConnInfo(const char * uuid,AuthConnInfo * connInfo)1414 int32_t AuthDeviceGetPreferConnInfo(const char *uuid, AuthConnInfo *connInfo)
1415 {
1416 if (uuid == NULL || uuid[0] == '\0' || connInfo == NULL) {
1417 AUTH_LOGE(AUTH_CONN, "invalid uuid or connInfo");
1418 return SOFTBUS_INVALID_PARAM;
1419 }
1420 AuthLinkType linkList[] = { AUTH_LINK_TYPE_WIFI, AUTH_LINK_TYPE_BR, AUTH_LINK_TYPE_BLE };
1421 uint32_t linkTypeNum = sizeof(linkList) / sizeof(linkList[0]);
1422 for (uint32_t i = 0; i < linkTypeNum; i++) {
1423 if (GetAuthConnInfoByUuid(uuid, linkList[i], connInfo) != SOFTBUS_OK) {
1424 continue;
1425 }
1426 if (linkList[i] == AUTH_LINK_TYPE_BLE) {
1427 if (!CheckActiveAuthConnection(connInfo)) {
1428 AUTH_LOGI(AUTH_CONN, "auth ble connection not active");
1429 continue;
1430 }
1431 }
1432 AUTH_LOGI(AUTH_CONN, "select auth type. i=%{public}d, linkList[i]=%{public}d", i, linkList[i]);
1433 return SOFTBUS_OK;
1434 }
1435 AUTH_LOGI(AUTH_CONN, "no active auth, try br connection");
1436 return TryGetBrConnInfo(uuid, connInfo);
1437 }
1438
AuthDeviceGetP2pConnInfo(const char * uuid,AuthConnInfo * connInfo)1439 int32_t AuthDeviceGetP2pConnInfo(const char *uuid, AuthConnInfo *connInfo)
1440 {
1441 if (uuid == NULL || uuid[0] == '\0' || connInfo == NULL) {
1442 AUTH_LOGE(AUTH_CONN, "invalid uuid or connInfo");
1443 return SOFTBUS_INVALID_PARAM;
1444 }
1445 int32_t ret = GetAuthConnInfoByUuid(uuid, AUTH_LINK_TYPE_ENHANCED_P2P, connInfo);
1446 if (ret == SOFTBUS_OK) {
1447 AUTH_LOGI(AUTH_CONN, "select auth type=%{public}d", AUTH_LINK_TYPE_ENHANCED_P2P);
1448 }
1449 return ret;
1450 }
1451
AuthDeviceCheckConnInfo(const char * uuid,AuthLinkType type,bool checkConnection)1452 bool AuthDeviceCheckConnInfo(const char *uuid, AuthLinkType type, bool checkConnection)
1453 {
1454 AUTH_CHECK_AND_RETURN_RET_LOGE(uuid, false, AUTH_CONN, "invalid null uuid");
1455 AUTH_CHECK_AND_RETURN_RET_LOGE(uuid[0] != '\0', false, AUTH_CONN, "invalid empty uuid");
1456
1457 AuthConnInfo connInfo;
1458 (void)memset_s(&connInfo, sizeof(connInfo), 0, sizeof(connInfo));
1459 if (GetAuthConnInfoByUuid(uuid, type, &connInfo) != SOFTBUS_OK) {
1460 return false;
1461 }
1462 return checkConnection ? CheckActiveAuthConnection(&connInfo) : true;
1463 }
1464
AuthDeviceOpenConn(const AuthConnInfo * info,uint32_t requestId,const AuthConnCallback * callback)1465 int32_t AuthDeviceOpenConn(const AuthConnInfo *info, uint32_t requestId, const AuthConnCallback *callback)
1466 {
1467 if (info == NULL || !CheckAuthConnCallback(callback)) {
1468 AUTH_LOGE(AUTH_CONN, "invalid param");
1469 return SOFTBUS_INVALID_PARAM;
1470 }
1471 AUTH_LOGI(AUTH_CONN, "open auth conn: connType=%{public}d, requestId=%{public}u", info->type, requestId);
1472 int64_t authId;
1473 switch (info->type) {
1474 case AUTH_LINK_TYPE_WIFI:
1475 authId = GetLatestIdByConnInfo(info, AUTH_LINK_TYPE_WIFI);
1476 if (authId == AUTH_INVALID_ID) {
1477 return SOFTBUS_AUTH_NOT_FOUND;
1478 }
1479 callback->onConnOpened(requestId, authId);
1480 break;
1481 case AUTH_LINK_TYPE_BR:
1482 case AUTH_LINK_TYPE_BLE:
1483 case AUTH_LINK_TYPE_P2P:
1484 authId = GetActiveAuthIdByConnInfo(info);
1485 if (authId != AUTH_INVALID_ID) {
1486 return StartReconnectDevice(authId, info, requestId, callback);
1487 }
1488 return StartVerifyDevice(requestId, info, NULL, callback, true);
1489 case AUTH_LINK_TYPE_ENHANCED_P2P:
1490 authId = GetActiveAuthIdByConnInfo(info);
1491 if (authId != AUTH_INVALID_ID) {
1492 AUTH_LOGI(AUTH_CONN, "reuse enhanced p2p authId=%{public}" PRId64, authId);
1493 callback->onConnOpened(requestId, authId);
1494 break;
1495 }
1496 return StartVerifyDevice(requestId, info, NULL, callback, true);
1497 default:
1498 AUTH_LOGE(AUTH_CONN, "unknown connType. type=%{public}d", info->type);
1499 return SOFTBUS_INVALID_PARAM;
1500 }
1501 return SOFTBUS_OK;
1502 }
1503
AuthDeviceCloseConn(int64_t authId)1504 void AuthDeviceCloseConn(int64_t authId)
1505 {
1506 AUTH_LOGI(AUTH_CONN, "close auth conn: authId=%{public}" PRId64, authId);
1507 AuthManager *auth = GetAuthManagerByAuthId(authId);
1508 if (auth == NULL) {
1509 return;
1510 }
1511 switch (auth->connInfo.type) {
1512 case AUTH_LINK_TYPE_WIFI:
1513 case AUTH_LINK_TYPE_P2P:
1514 case AUTH_LINK_TYPE_ENHANCED_P2P:
1515 /* Do nothing. */
1516 break;
1517 case AUTH_LINK_TYPE_BR:
1518 case AUTH_LINK_TYPE_BLE:
1519 DisconnectAuthDevice(&auth->connId);
1520 break;
1521 default:
1522 break;
1523 }
1524 DelAuthManager(auth, false);
1525 return;
1526 }
1527
AuthDevicePostTransData(int64_t authId,const AuthTransData * dataInfo)1528 int32_t AuthDevicePostTransData(int64_t authId, const AuthTransData *dataInfo)
1529 {
1530 if (dataInfo == NULL) {
1531 AUTH_LOGE(AUTH_CONN, "dataInfo is null");
1532 return SOFTBUS_INVALID_PARAM;
1533 }
1534 AuthManager *auth = GetAuthManagerByAuthId(authId);
1535 if (auth == NULL) {
1536 return SOFTBUS_AUTH_NOT_FOUND;
1537 }
1538 AuthDataHead head;
1539 head.dataType = DATA_TYPE_CONNECTION;
1540 head.module = dataInfo->module;
1541 head.seq = dataInfo->seq;
1542 head.flag = dataInfo->flag;
1543 head.len = 0;
1544 uint8_t *encData = NULL;
1545 if (EncryptInner(&auth->sessionKeyList, dataInfo->data, dataInfo->len, &encData, &head.len) != SOFTBUS_OK) {
1546 AUTH_LOGE(AUTH_KEY, "encrypt trans data fail");
1547 DelAuthManager(auth, false);
1548 return SOFTBUS_ENCRYPT_ERR;
1549 }
1550 if (PostAuthData(auth->connId, !auth->isServer, &head, encData) != SOFTBUS_OK) {
1551 AUTH_LOGE(AUTH_CONN, "post trans data fail");
1552 SoftBusFree(encData);
1553 DelAuthManager(auth, false);
1554 return SOFTBUS_AUTH_SEND_FAIL;
1555 }
1556 SoftBusFree(encData);
1557 DelAuthManager(auth, false);
1558 return SOFTBUS_OK;
1559 }
1560
RegGroupChangeListener(const GroupChangeListener * listener)1561 int32_t RegGroupChangeListener(const GroupChangeListener *listener)
1562 {
1563 if (listener == NULL) {
1564 AUTH_LOGE(AUTH_CONN, "listener is null");
1565 return SOFTBUS_INVALID_PARAM;
1566 }
1567 g_groupChangeListener.onGroupCreated = listener->onGroupCreated;
1568 g_groupChangeListener.onGroupDeleted = listener->onGroupDeleted;
1569 g_groupChangeListener.onDeviceBound = listener->onDeviceBound;
1570 return SOFTBUS_OK;
1571 }
1572
UnregGroupChangeListener(void)1573 void UnregGroupChangeListener(void)
1574 {
1575 g_groupChangeListener.onGroupCreated = NULL;
1576 g_groupChangeListener.onGroupDeleted = NULL;
1577 g_groupChangeListener.onDeviceBound = NULL;
1578 }
1579
AuthGetLatestAuthSeqList(const char * udid,int64_t * seqList,uint32_t num)1580 int32_t AuthGetLatestAuthSeqList(const char *udid, int64_t *seqList, uint32_t num)
1581 {
1582 if (udid == NULL || udid[0] == '\0' || seqList == NULL || num != DISCOVERY_TYPE_COUNT) {
1583 AUTH_LOGE(AUTH_CONN, "invalid param");
1584 return SOFTBUS_INVALID_PARAM;
1585 }
1586 if (!RequireAuthLock()) {
1587 return SOFTBUS_LOCK_ERR;
1588 }
1589 bool notFound = true;
1590 AuthManager *authClient = NULL;
1591 AuthManager *authServer = NULL;
1592 AuthLinkType linkList[] = { AUTH_LINK_TYPE_WIFI, AUTH_LINK_TYPE_BLE, AUTH_LINK_TYPE_BR };
1593 for (size_t i = 0; i < sizeof(linkList) / sizeof(AuthLinkType); i++) {
1594 authClient = FindAuthManagerByUdid(udid, linkList[i], false);
1595 authServer = FindAuthManagerByUdid(udid, linkList[i], true);
1596 if (authClient == NULL && authServer == NULL) {
1597 seqList[ConvertToDiscoveryType(linkList[i])] = 0;
1598 continue;
1599 }
1600 notFound = false;
1601 if (authClient != NULL && authServer == NULL) {
1602 seqList[ConvertToDiscoveryType(linkList[i])] = authClient->lastAuthSeq;
1603 } else if (authClient == NULL && authServer != NULL) {
1604 seqList[ConvertToDiscoveryType(linkList[i])] = authServer->lastAuthSeq;
1605 } else if (authClient->lastVerifyTime >= authServer->lastVerifyTime) {
1606 seqList[ConvertToDiscoveryType(linkList[i])] = authClient->lastAuthSeq;
1607 } else {
1608 seqList[ConvertToDiscoveryType(linkList[i])] = authServer->lastAuthSeq;
1609 }
1610 }
1611 if (notFound) {
1612 ReleaseAuthLock();
1613 char *anonyUdid = NULL;
1614 Anonymize(udid, &anonyUdid);
1615 AUTH_LOGE(AUTH_CONN, "not found active authManager, udid=%{public}s", anonyUdid);
1616 AnonymizeFree(anonyUdid);
1617 return SOFTBUS_AUTH_NOT_FOUND;
1618 }
1619 ReleaseAuthLock();
1620 return SOFTBUS_OK;
1621 }
1622
AuthDeviceGetLatestIdByUuid(const char * uuid,AuthLinkType type)1623 int64_t AuthDeviceGetLatestIdByUuid(const char *uuid, AuthLinkType type)
1624 {
1625 if (uuid == NULL || uuid[0] == '\0') {
1626 AUTH_LOGE(AUTH_CONN, "uuid is empty");
1627 return AUTH_INVALID_ID;
1628 }
1629 if (!RequireAuthLock()) {
1630 return SOFTBUS_LOCK_ERR;
1631 }
1632 uint32_t num = 0;
1633 AuthManager *auth[4] = { NULL, NULL, NULL, NULL }; /* 4: max size for (BR + BLE) * (CLIENT+ SERVER) */
1634 if ((type == AUTH_LINK_TYPE_WIFI) || (type == AUTH_LINK_TYPE_BLE)) {
1635 auth[num++] = FindAuthManagerByUuid(uuid, type, false);
1636 auth[num++] = FindAuthManagerByUuid(uuid, type, true);
1637 } else {
1638 auth[num++] = FindAuthManagerByUuid(uuid, AUTH_LINK_TYPE_BR, false);
1639 auth[num++] = FindAuthManagerByUuid(uuid, AUTH_LINK_TYPE_BR, true);
1640 auth[num++] = FindAuthManagerByUuid(uuid, AUTH_LINK_TYPE_BLE, false);
1641 auth[num++] = FindAuthManagerByUuid(uuid, AUTH_LINK_TYPE_BLE, true);
1642 }
1643 int64_t latestAuthId = AUTH_INVALID_ID;
1644 uint64_t latestVerifyTime = 0;
1645 for (uint32_t i = 0; i < num; i++) {
1646 if (auth[i] != NULL && auth[i]->lastVerifyTime > latestVerifyTime) {
1647 latestAuthId = auth[i]->authId;
1648 latestVerifyTime = auth[i]->lastVerifyTime;
1649 }
1650 }
1651 ReleaseAuthLock();
1652 char *anonyUuid = NULL;
1653 Anonymize(uuid, &anonyUuid);
1654 AUTH_LOGI(AUTH_CONN,
1655 "latest auth manager found, latestAuthId=%{public}" PRId64 ", lastVerifyTime=%{public}" PRIu64
1656 ", uuid=%{public}s, type=%{public}d",
1657 latestAuthId, latestVerifyTime, anonyUuid, type);
1658 AnonymizeFree(anonyUuid);
1659 return latestAuthId;
1660 }
1661
AuthDeviceGetIdByConnInfo(const AuthConnInfo * connInfo,bool isServer)1662 int64_t AuthDeviceGetIdByConnInfo(const AuthConnInfo *connInfo, bool isServer)
1663 {
1664 if (connInfo == NULL) {
1665 AUTH_LOGE(AUTH_CONN, "connInfo is null");
1666 return AUTH_INVALID_ID;
1667 }
1668 return GetAuthIdByConnInfo(connInfo, isServer);
1669 }
1670
AuthDeviceGetIdByUuid(const char * uuid,AuthLinkType type,bool isServer)1671 int64_t AuthDeviceGetIdByUuid(const char *uuid, AuthLinkType type, bool isServer)
1672 {
1673 if (uuid == NULL || uuid[0] == '\0') {
1674 AUTH_LOGE(AUTH_FSM, "uuid is empty");
1675 return AUTH_INVALID_ID;
1676 }
1677 if (!RequireAuthLock()) {
1678 return AUTH_INVALID_ID;
1679 }
1680 AuthManager *auth = FindAuthManagerByUuid(uuid, type, isServer);
1681 if (auth == NULL) {
1682 AUTH_LOGE(
1683 AUTH_CONN, "not found auth manager, connType=%{public}d, side=%{public}s", type, GetAuthSideStr(isServer));
1684 ReleaseAuthLock();
1685 return AUTH_INVALID_ID;
1686 }
1687 int64_t authId = auth->authId;
1688 ReleaseAuthLock();
1689 return authId;
1690 }
1691
AuthGetEncryptSize(uint32_t inLen)1692 uint32_t AuthGetEncryptSize(uint32_t inLen)
1693 {
1694 return inLen + ENCRYPT_OVER_HEAD_LEN;
1695 }
1696
AuthGetDecryptSize(uint32_t inLen)1697 uint32_t AuthGetDecryptSize(uint32_t inLen)
1698 {
1699 if (inLen <= OVERHEAD_LEN) {
1700 return inLen;
1701 }
1702 return inLen - OVERHEAD_LEN;
1703 }
1704
AuthDeviceEncrypt(int64_t authId,const uint8_t * inData,uint32_t inLen,uint8_t * outData,uint32_t * outLen)1705 int32_t AuthDeviceEncrypt(int64_t authId, const uint8_t *inData, uint32_t inLen, uint8_t *outData, uint32_t *outLen)
1706 {
1707 if (inData == NULL || inLen == 0 || outData == NULL || outLen == NULL || *outLen < AuthGetEncryptSize(inLen)) {
1708 AUTH_LOGE(AUTH_KEY, "invalid param");
1709 return SOFTBUS_INVALID_PARAM;
1710 }
1711 AuthManager *auth = GetAuthManagerByAuthId(authId);
1712 if (auth == NULL) {
1713 return SOFTBUS_AUTH_NOT_FOUND;
1714 }
1715 if (EncryptData(&auth->sessionKeyList, inData, inLen, outData, outLen) != SOFTBUS_OK) {
1716 AUTH_LOGE(AUTH_KEY, "auth encrypt fail");
1717 DelAuthManager(auth, false);
1718 return SOFTBUS_ENCRYPT_ERR;
1719 }
1720 DelAuthManager(auth, false);
1721 return SOFTBUS_OK;
1722 }
1723
AuthDeviceDecrypt(int64_t authId,const uint8_t * inData,uint32_t inLen,uint8_t * outData,uint32_t * outLen)1724 int32_t AuthDeviceDecrypt(int64_t authId, const uint8_t *inData, uint32_t inLen, uint8_t *outData, uint32_t *outLen)
1725 {
1726 if (inData == NULL || inLen == 0 || outData == NULL || outLen == NULL || *outLen < AuthGetDecryptSize(inLen)) {
1727 AUTH_LOGE(AUTH_KEY, "invalid param");
1728 return SOFTBUS_INVALID_PARAM;
1729 }
1730 AuthManager *auth = GetAuthManagerByAuthId(authId);
1731 if (auth == NULL) {
1732 return SOFTBUS_AUTH_NOT_FOUND;
1733 }
1734 if (DecryptData(&auth->sessionKeyList, inData, inLen, outData, outLen) != SOFTBUS_OK) {
1735 AUTH_LOGE(AUTH_KEY, "auth decrypt fail");
1736 DelAuthManager(auth, false);
1737 return SOFTBUS_ENCRYPT_ERR;
1738 }
1739 DelAuthManager(auth, false);
1740 return SOFTBUS_OK;
1741 }
1742
AuthDeviceSetP2pMac(int64_t authId,const char * p2pMac)1743 int32_t AuthDeviceSetP2pMac(int64_t authId, const char *p2pMac)
1744 {
1745 if (p2pMac == NULL || p2pMac[0] == '\0') {
1746 AUTH_LOGE(AUTH_CONN, "p2pMac is empty");
1747 return SOFTBUS_INVALID_PARAM;
1748 }
1749 AuthManager inAuth = { 0 };
1750 if (strcpy_s(inAuth.p2pMac, sizeof(inAuth.p2pMac), p2pMac) != EOK) {
1751 AUTH_LOGE(AUTH_CONN, "copy p2pMac fail, authId=%{public}" PRId64, authId);
1752 return SOFTBUS_MEM_ERR;
1753 }
1754 return UpdateAuthManagerByAuthId(authId, SetAuthP2pMac, &inAuth);
1755 }
1756
AuthDeviceGetConnInfo(int64_t authId,AuthConnInfo * connInfo)1757 int32_t AuthDeviceGetConnInfo(int64_t authId, AuthConnInfo *connInfo)
1758 {
1759 if (connInfo == NULL) {
1760 AUTH_LOGE(AUTH_CONN, "connInfo is null");
1761 return SOFTBUS_INVALID_PARAM;
1762 }
1763 AuthManager *auth = GetAuthManagerByAuthId(authId);
1764 if (auth == NULL) {
1765 return SOFTBUS_AUTH_NOT_FOUND;
1766 }
1767 *connInfo = auth->connInfo;
1768 DelAuthManager(auth, false);
1769 return SOFTBUS_OK;
1770 }
1771
AuthDeviceGetServerSide(int64_t authId,bool * isServer)1772 int32_t AuthDeviceGetServerSide(int64_t authId, bool *isServer)
1773 {
1774 if (isServer == NULL) {
1775 AUTH_LOGE(AUTH_CONN, "isServer is null");
1776 return SOFTBUS_INVALID_PARAM;
1777 }
1778 AuthManager *auth = GetAuthManagerByAuthId(authId);
1779 if (auth == NULL) {
1780 return SOFTBUS_AUTH_NOT_FOUND;
1781 }
1782 *isServer = auth->isServer;
1783 DelAuthManager(auth, false);
1784 return SOFTBUS_OK;
1785 }
1786
AuthDeviceGetDeviceUuid(int64_t authId,char * uuid,uint16_t size)1787 int32_t AuthDeviceGetDeviceUuid(int64_t authId, char *uuid, uint16_t size)
1788 {
1789 if (uuid == NULL) {
1790 AUTH_LOGE(AUTH_CONN, "uuid is empty");
1791 return SOFTBUS_INVALID_PARAM;
1792 }
1793 AuthManager *auth = GetAuthManagerByAuthId(authId);
1794 if (auth == NULL) {
1795 return SOFTBUS_AUTH_NOT_FOUND;
1796 }
1797 if (strcpy_s(uuid, size, auth->uuid) != EOK) {
1798 AUTH_LOGI(AUTH_CONN, "copy uuid fail, size=%{public}u", size);
1799 DelAuthManager(auth, false);
1800 return SOFTBUS_ERR;
1801 }
1802 DelAuthManager(auth, false);
1803 return SOFTBUS_OK;
1804 }
1805
AuthDeviceGetVersion(int64_t authId,SoftBusVersion * version)1806 int32_t AuthDeviceGetVersion(int64_t authId, SoftBusVersion *version)
1807 {
1808 if (version == NULL) {
1809 AUTH_LOGE(AUTH_CONN, "version is null");
1810 return SOFTBUS_INVALID_PARAM;
1811 }
1812 AuthManager *auth = GetAuthManagerByAuthId(authId);
1813 if (auth == NULL) {
1814 return SOFTBUS_AUTH_NOT_FOUND;
1815 }
1816 *version = auth->version;
1817 DelAuthManager(auth, false);
1818 return SOFTBUS_OK;
1819 }
1820
RegisterToDpDelay(void * para)1821 static void RegisterToDpDelay(void *para)
1822 {
1823 DeviceProfileChangeListener deviceProfileChangeListener = {
1824 .onDeviceProfileAdd = OnDeviceBound,
1825 .onDeviceProfileDeleted = OnDeviceNotTrusted,
1826 };
1827 RegisterToDp(&deviceProfileChangeListener);
1828 }
1829
AuthDeviceInit(const AuthTransCallback * callback)1830 int32_t AuthDeviceInit(const AuthTransCallback *callback)
1831 {
1832 AUTH_LOGI(AUTH_INIT, "auth init enter");
1833 if (callback == NULL) {
1834 AUTH_LOGE(AUTH_INIT, "Auth notify trans callback is null");
1835 return SOFTBUS_INVALID_PARAM;
1836 }
1837 g_transCallback = *callback;
1838 ListInit(&g_authClientList);
1839 ListInit(&g_authServerList);
1840 if (AuthCommonInit() != SOFTBUS_OK) {
1841 AUTH_LOGE(AUTH_INIT, "AuthCommonInit fail");
1842 return SOFTBUS_ERR;
1843 }
1844
1845 AuthConnListener connListener = {
1846 .onConnectResult = OnConnectResult,
1847 .onDisconnected = OnDisconnected,
1848 .onDataReceived = OnDataReceived,
1849 };
1850 if (AuthConnInit(&connListener) != SOFTBUS_OK) {
1851 AUTH_LOGE(AUTH_INIT, "AuthConnInit fail");
1852 AuthCommonDeinit();
1853 return SOFTBUS_ERR;
1854 }
1855 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), RegisterToDpDelay, NULL, DELAY_REG_DP_TIME) !=
1856 SOFTBUS_OK) {
1857 AUTH_LOGE(AUTH_INIT, "delay registertoDp failed");
1858 return SOFTBUS_AUTH_INIT_FAIL;
1859 }
1860 AUTH_LOGI(AUTH_INIT, "auth init succ");
1861 return SOFTBUS_OK;
1862 }
1863
RegTrustListenerOnHichainSaStart(void)1864 int32_t RegTrustListenerOnHichainSaStart(void)
1865 {
1866 TrustDataChangeListener trustListener = {
1867 .onGroupCreated = OnGroupCreated,
1868 .onGroupDeleted = OnGroupDeleted,
1869 .onDeviceNotTrusted = OnDeviceNotTrusted,
1870 .onDeviceBound = OnDeviceBound,
1871 };
1872 if (RegTrustDataChangeListener(&trustListener) != SOFTBUS_OK) {
1873 AUTH_LOGE(AUTH_INIT, "RegTrustDataChangeListener fail");
1874 g_regDataChangeListener = false;
1875 return SOFTBUS_AUTH_INIT_FAIL;
1876 }
1877 g_regDataChangeListener = true;
1878 AUTH_LOGE(AUTH_INIT, "OnHichainSaStart add listener succ");
1879 return SOFTBUS_OK;
1880 }
1881
AuthDeviceDeinit(void)1882 void AuthDeviceDeinit(void)
1883 {
1884 AUTH_LOGI(AUTH_INIT, "auth deinit enter");
1885 UnregTrustDataChangeListener();
1886 UnRegHichainSaStatusListener();
1887 DestroyAuthManagerList();
1888 ClearAuthRequest();
1889 AuthConnDeinit();
1890 AuthSessionFsmExit();
1891 AuthCommonDeinit();
1892 AUTH_LOGI(AUTH_INIT, "auth deinit succ");
1893 }