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