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_device.h"
17 
18 #include <securec.h>
19 #include "anonymizer.h"
20 #include "auth_connection.h"
21 #include "auth_hichain.h"
22 #include "auth_log.h"
23 #include "auth_request.h"
24 #include "auth_session_message.h"
25 #include "bus_center_manager.h"
26 #include "device_profile_listener.h"
27 #include "lnn_app_bind_interface.h"
28 #include "lnn_decision_db.h"
29 #include "lnn_heartbeat_ctrl.h"
30 #include "lnn_local_net_ledger.h"
31 #include "lnn_map.h"
32 #include "lnn_net_builder.h"
33 #include "softbus_adapter_hitrace.h"
34 #include "softbus_adapter_mem.h"
35 
36 #define DELAY_AUTH_TIME                    (8 * 1000L)
37 
38 static AuthVerifyListener g_verifyListener = { 0 };
39 static GroupChangeListener g_groupChangeListener = { 0 };
40 static Map g_authLimitMap;
41 static SoftBusMutex g_authLimitMutex;
42 static bool g_isInit = false;
43 static bool g_regDataChangeListener = false;
44 
AuthMapInit(void)45 static bool AuthMapInit(void)
46 {
47     if (SoftBusMutexInit(&g_authLimitMutex, NULL) != SOFTBUS_OK) {
48         AUTH_LOGE(AUTH_FSM, "g_authLimit mutex init fail");
49         return false;
50     }
51     LnnMapInit(&g_authLimitMap);
52     g_isInit = true;
53     AUTH_LOGI(AUTH_FSM, "authLimit map init success");
54     return true;
55 }
56 
InsertToAuthLimitMap(const char * udidHash,uint64_t currentTime)57 static void InsertToAuthLimitMap(const char *udidHash, uint64_t currentTime)
58 {
59     if (SoftBusMutexLock(&g_authLimitMutex) != SOFTBUS_OK) {
60         AUTH_LOGE(AUTH_FSM, "SoftBusMutexLock fail");
61         return;
62     }
63     if (LnnMapSet(&g_authLimitMap, udidHash, (const void *)&currentTime, sizeof(uint64_t)) != SOFTBUS_OK) {
64         AUTH_LOGE(AUTH_FSM, "LnnMapSet fail");
65         (void)SoftBusMutexUnlock(&g_authLimitMutex);
66         return;
67     }
68     (void)SoftBusMutexUnlock(&g_authLimitMutex);
69 }
70 
GetNodeFromAuthLimitMap(const char * udidHash,uint64_t * time)71 static int32_t GetNodeFromAuthLimitMap(const char *udidHash, uint64_t *time)
72 {
73     if (!g_isInit) {
74         return SOFTBUS_OK;
75     }
76     if (SoftBusMutexLock(&g_authLimitMutex) != SOFTBUS_OK) {
77         AUTH_LOGE(AUTH_FSM, "SoftBusMutexLock fail");
78         return SOFTBUS_LOCK_ERR;
79     }
80     uint64_t *ptr = (uint64_t *)LnnMapGet(&g_authLimitMap, udidHash);
81     if (ptr == NULL) {
82         AUTH_LOGE(AUTH_FSM, "LnnMapGet fail");
83         (void)SoftBusMutexUnlock(&g_authLimitMutex);
84         return SOFTBUS_INVALID_PARAM;
85     }
86     *time = *ptr;
87     (void)SoftBusMutexUnlock(&g_authLimitMutex);
88     return SOFTBUS_OK;
89 }
90 
IsNeedAuthLimit(const char * udidHash)91 bool IsNeedAuthLimit(const char *udidHash)
92 {
93     if (udidHash == NULL) {
94         AUTH_LOGE(AUTH_FSM, "invalid param");
95         return false;
96     }
97     uint64_t time = 0;
98     uint64_t currentTime = 0;
99     if (GetNodeFromAuthLimitMap(udidHash, &time) != SOFTBUS_OK) {
100         return false;
101     }
102     if (time == 0) {
103         AUTH_LOGI(AUTH_FSM, "no need delay authentication");
104         return false;
105     }
106     currentTime = GetCurrentTimeMs();
107     AUTH_LOGI(AUTH_FSM, "currentTime=%{public}" PRIu64 ", time=%{public}" PRIu64 "", currentTime, time);
108     if (currentTime - time < DELAY_AUTH_TIME) {
109         AUTH_LOGI(AUTH_FSM, "lastest retcode authentication time less than 8s");
110         return true;
111     }
112     return false;
113 }
114 
AuthDeleteLimitMap(const char * udidHash)115 void AuthDeleteLimitMap(const char *udidHash)
116 {
117     if (!g_isInit || udidHash == NULL) {
118         return;
119     }
120     if (SoftBusMutexLock(&g_authLimitMutex) != SOFTBUS_OK) {
121         AUTH_LOGE(AUTH_FSM, "SoftBusMutexLock fail");
122         return;
123     }
124     int32_t ret = LnnMapErase(&g_authLimitMap, udidHash);
125     if (ret != SOFTBUS_OK) {
126         AUTH_LOGE(AUTH_FSM, "delete item fail, ret=%{public}d", ret);
127         (void)SoftBusMutexUnlock(&g_authLimitMutex);
128         return;
129     }
130     (void)SoftBusMutexUnlock(&g_authLimitMutex);
131 }
132 
ClearAuthLimitMap(void)133 void ClearAuthLimitMap(void)
134 {
135     if (!g_isInit) {
136         return;
137     }
138     if (SoftBusMutexLock(&g_authLimitMutex) != SOFTBUS_OK) {
139         AUTH_LOGE(AUTH_FSM, "SoftBusMutexLock fail");
140         return;
141     }
142     LnnMapDelete(&g_authLimitMap);
143     AUTH_LOGI(AUTH_FSM, "ClearAuthLimitMap success");
144     (void)SoftBusMutexUnlock(&g_authLimitMutex);
145 }
146 
AuthAddNodeToLimitMap(const char * udid,int32_t reason)147 void AuthAddNodeToLimitMap(const char *udid, int32_t reason)
148 {
149     AUTH_CHECK_AND_RETURN_LOGE(udid != NULL, AUTH_FSM, "udid is null");
150 
151     if (reason == SOFTBUS_AUTH_HICHAIN_LOCAL_IDENTITY_NOT_EXIST || reason == SOFTBUS_AUTH_HICHAIN_GROUP_NOT_EXIST ||
152         reason == SOFTBUS_AUTH_HICHAIN_NO_CANDIDATE_GROUP) {
153         uint64_t currentTime = GetCurrentTimeMs();
154         AUTH_LOGI(AUTH_FSM, "reason=%{public}d, currentTime=%{public}" PRIu64 "", reason, currentTime);
155 
156         uint8_t hash[SHA_256_HASH_LEN] = { 0 };
157         char udidHash[SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
158         if (SoftBusGenerateStrHash((uint8_t *)udid, strlen(udid), hash) != SOFTBUS_OK) {
159             AUTH_LOGE(AUTH_FSM, "GenerateUdidShortHash fail.");
160             return;
161         }
162         if (ConvertBytesToUpperCaseHexString(udidHash, SHORT_UDID_HASH_HEX_LEN + 1, hash, UDID_SHORT_HASH_LEN_TEMP) !=
163             SOFTBUS_OK) {
164             AUTH_LOGE(AUTH_FSM, "convert bytes to string fail");
165             return;
166         }
167         if (!g_isInit && !AuthMapInit()) {
168             return;
169         }
170         InsertToAuthLimitMap(udidHash, currentTime);
171     }
172 }
173 
AuthDevicePostTransData(AuthHandle authHandle,const AuthTransData * dataInfo)174 int32_t AuthDevicePostTransData(AuthHandle authHandle, const AuthTransData *dataInfo)
175 {
176     if (dataInfo == NULL) {
177         AUTH_LOGE(AUTH_CONN, "dataInfo is null");
178         return SOFTBUS_INVALID_PARAM;
179     }
180     if (authHandle.type < AUTH_LINK_TYPE_WIFI || authHandle.type >= AUTH_LINK_TYPE_MAX) {
181         AUTH_LOGE(AUTH_CONN, "authHandle type error");
182         return SOFTBUS_INVALID_PARAM;
183     }
184     AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
185     if (auth == NULL) {
186         return SOFTBUS_AUTH_NOT_FOUND;
187     }
188     AuthDataHead head;
189     head.dataType = DATA_TYPE_CONNECTION;
190     head.module = dataInfo->module;
191     head.seq = dataInfo->seq;
192     head.flag = dataInfo->flag;
193     head.len = 0;
194     uint8_t *encData = NULL;
195     InDataInfo inDataInfo = { .inData = dataInfo->data, .inLen = dataInfo->len };
196     if (EncryptInner(&auth->sessionKeyList, (AuthLinkType)authHandle.type, &inDataInfo, &encData,
197         &head.len) != SOFTBUS_OK) {
198         AUTH_LOGE(AUTH_KEY, "encrypt trans data fail");
199         DelDupAuthManager(auth);
200         return SOFTBUS_ENCRYPT_ERR;
201     }
202     if (PostAuthData(auth->connId[authHandle.type], !auth->isServer, &head, encData) != SOFTBUS_OK) {
203         AUTH_LOGE(AUTH_CONN, "post trans data fail");
204         SoftBusFree(encData);
205         DelDupAuthManager(auth);
206         return SOFTBUS_AUTH_SEND_FAIL;
207     }
208     SoftBusFree(encData);
209     DelDupAuthManager(auth);
210     return SOFTBUS_OK;
211 }
212 
AuthDeviceEncrypt(AuthHandle * authHandle,const uint8_t * inData,uint32_t inLen,uint8_t * outData,uint32_t * outLen)213 int32_t AuthDeviceEncrypt(AuthHandle *authHandle, const uint8_t *inData, uint32_t inLen, uint8_t *outData,
214     uint32_t *outLen)
215 {
216     if (authHandle == NULL || inData == NULL || inLen == 0 || outData == NULL || outLen == NULL ||
217         *outLen < (inLen + ENCRYPT_OVER_HEAD_LEN)) {
218         AUTH_LOGE(AUTH_KEY, "invalid param");
219         return SOFTBUS_INVALID_PARAM;
220     }
221     AuthManager *auth = GetAuthManagerByAuthId(authHandle->authId);
222     if (auth == NULL) {
223         return SOFTBUS_AUTH_NOT_FOUND;
224     }
225     InDataInfo inDataInfo = { .inData = inData, .inLen = inLen };
226     if (EncryptData(&auth->sessionKeyList, (AuthLinkType)authHandle->type, &inDataInfo, outData,
227         outLen) != SOFTBUS_OK) {
228         AUTH_LOGE(AUTH_KEY, "auth encrypt fail");
229         DelDupAuthManager(auth);
230         return SOFTBUS_ENCRYPT_ERR;
231     }
232     DelDupAuthManager(auth);
233     return SOFTBUS_OK;
234 }
235 
AuthDeviceDecrypt(AuthHandle * authHandle,const uint8_t * inData,uint32_t inLen,uint8_t * outData,uint32_t * outLen)236 int32_t AuthDeviceDecrypt(AuthHandle *authHandle, const uint8_t *inData, uint32_t inLen, uint8_t *outData,
237     uint32_t *outLen)
238 {
239     if (authHandle == NULL || inData == NULL || inLen == 0 || outData == NULL || outLen == NULL ||
240         *outLen < AuthGetDecryptSize(inLen)) {
241         AUTH_LOGE(AUTH_KEY, "invalid param");
242         return SOFTBUS_INVALID_PARAM;
243     }
244     AuthManager *auth = GetAuthManagerByAuthId(authHandle->authId);
245     if (auth == NULL) {
246         return SOFTBUS_AUTH_NOT_FOUND;
247     }
248     InDataInfo inDataInfo = { .inData = inData, .inLen = inLen };
249     if (DecryptData(&auth->sessionKeyList, (AuthLinkType)authHandle->type, &inDataInfo, outData,
250         outLen) != SOFTBUS_OK) {
251         AUTH_LOGE(AUTH_KEY, "auth decrypt fail, authId=%{public}" PRId64, authHandle->authId);
252         DelDupAuthManager(auth);
253         return SOFTBUS_ENCRYPT_ERR;
254     }
255     DelDupAuthManager(auth);
256     return SOFTBUS_OK;
257 }
258 
AuthDeviceGetConnInfo(AuthHandle authHandle,AuthConnInfo * connInfo)259 int32_t AuthDeviceGetConnInfo(AuthHandle authHandle, AuthConnInfo *connInfo)
260 {
261     if (connInfo == NULL) {
262         AUTH_LOGE(AUTH_CONN, "connInfo is null");
263         return SOFTBUS_INVALID_PARAM;
264     }
265     if (authHandle.type < AUTH_LINK_TYPE_WIFI || authHandle.type >= AUTH_LINK_TYPE_MAX) {
266         AUTH_LOGE(AUTH_CONN, "authHandle type error");
267         return SOFTBUS_INVALID_PARAM;
268     }
269     AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
270     if (auth == NULL) {
271         return SOFTBUS_AUTH_NOT_FOUND;
272     }
273     *connInfo = auth->connInfo[authHandle.type];
274     DelDupAuthManager(auth);
275     return SOFTBUS_OK;
276 }
277 
AuthDeviceGetServerSide(int64_t authId,bool * isServer)278 int32_t AuthDeviceGetServerSide(int64_t authId, bool *isServer)
279 {
280     if (isServer == NULL) {
281         AUTH_LOGE(AUTH_CONN, "isServer is null");
282         return SOFTBUS_INVALID_PARAM;
283     }
284     AuthManager *auth = GetAuthManagerByAuthId(authId);
285     if (auth == NULL) {
286         return SOFTBUS_AUTH_NOT_FOUND;
287     }
288     *isServer = auth->isServer;
289     DelDupAuthManager(auth);
290     return SOFTBUS_OK;
291 }
292 
AuthDeviceGetDeviceUuid(int64_t authId,char * uuid,uint16_t size)293 int32_t AuthDeviceGetDeviceUuid(int64_t authId, char *uuid, uint16_t size)
294 {
295     if (uuid == NULL) {
296         AUTH_LOGE(AUTH_CONN, "uuid is empty");
297         return SOFTBUS_INVALID_PARAM;
298     }
299     AuthManager *auth = GetAuthManagerByAuthId(authId);
300     if (auth == NULL) {
301         return SOFTBUS_AUTH_NOT_FOUND;
302     }
303     if (strcpy_s(uuid, size, auth->uuid) != EOK) {
304         AUTH_LOGI(AUTH_CONN, "copy uuid fail, size=%{public}u", size);
305         DelDupAuthManager(auth);
306         return SOFTBUS_ERR;
307     }
308     DelDupAuthManager(auth);
309     return SOFTBUS_OK;
310 }
311 
AuthDeviceGetVersion(int64_t authId,SoftBusVersion * version)312 int32_t AuthDeviceGetVersion(int64_t authId, SoftBusVersion *version)
313 {
314     if (version == NULL) {
315         AUTH_LOGE(AUTH_CONN, "version is null");
316         return SOFTBUS_INVALID_PARAM;
317     }
318     AuthManager *auth = GetAuthManagerByAuthId(authId);
319     if (auth == NULL) {
320         return SOFTBUS_AUTH_NOT_FOUND;
321     }
322     *version = auth->version;
323     DelDupAuthManager(auth);
324     return SOFTBUS_OK;
325 }
326 
AuthDeviceNotTrust(const char * peerUdid)327 void AuthDeviceNotTrust(const char *peerUdid)
328 {
329     if (peerUdid == NULL || strlen(peerUdid) == 0) {
330         AUTH_LOGE(AUTH_HICHAIN, "invalid param");
331         return;
332     }
333     char networkId[NETWORK_ID_BUF_LEN] = {0};
334     if (LnnGetNetworkIdByUdid(peerUdid, networkId, sizeof(networkId)) != SOFTBUS_OK) {
335         AUTH_LOGE(AUTH_HICHAIN, "get networkId by udid fail");
336         return;
337     }
338     RemoveNotPassedAuthManagerByUdid(peerUdid);
339     AuthSessionHandleDeviceNotTrusted(peerUdid);
340     LnnDeleteSpecificTrustedDevInfo(peerUdid);
341     LnnHbOnTrustedRelationReduced();
342     AuthRemoveDeviceKeyByUdid(peerUdid);
343     if (LnnRequestLeaveSpecific(networkId, CONNECTION_ADDR_MAX) != SOFTBUS_OK) {
344         AUTH_LOGE(AUTH_HICHAIN, "request leave specific fail");
345     } else {
346         AUTH_LOGI(AUTH_HICHAIN, "request leave specific successful");
347     }
348 }
349 
AuthNotifyDeviceVerifyPassed(AuthHandle authHandle,const NodeInfo * nodeInfo)350 void AuthNotifyDeviceVerifyPassed(AuthHandle authHandle, const NodeInfo *nodeInfo)
351 {
352     CHECK_NULL_PTR_RETURN_VOID(nodeInfo);
353     AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
354     if (auth == NULL) {
355         AUTH_LOGE(AUTH_FSM, "get auth manager failed");
356         return;
357     }
358     if (auth->connInfo[authHandle.type].type == AUTH_LINK_TYPE_P2P ||
359         auth->connInfo[authHandle.type].type == AUTH_LINK_TYPE_ENHANCED_P2P) {
360         /* P2P auth no need notify to LNN. */
361         DelDupAuthManager(auth);
362         return;
363     }
364     DelDupAuthManager(auth);
365 
366     /* notify LNN device verify pass. */
367     if (g_verifyListener.onDeviceVerifyPass == NULL) {
368         AUTH_LOGW(AUTH_FSM, "onDeviceVerifyPass not set");
369         return;
370     }
371     g_verifyListener.onDeviceVerifyPass(authHandle, nodeInfo);
372 }
373 
AuthNotifyDeviceDisconnect(AuthHandle authHandle)374 void AuthNotifyDeviceDisconnect(AuthHandle authHandle)
375 {
376     if (g_verifyListener.onDeviceDisconnect == NULL) {
377         AUTH_LOGW(AUTH_FSM, "onDeviceDisconnect not set");
378         return;
379     }
380     g_verifyListener.onDeviceDisconnect(authHandle);
381 }
382 
OnDeviceNotTrusted(const char * peerUdid)383 static void OnDeviceNotTrusted(const char *peerUdid)
384 {
385     RemoveNotPassedAuthManagerByUdid(peerUdid);
386     AuthSessionHandleDeviceNotTrusted(peerUdid);
387     LnnDeleteSpecificTrustedDevInfo(peerUdid);
388     if (g_verifyListener.onDeviceNotTrusted == NULL) {
389         AUTH_LOGW(AUTH_HICHAIN, "onDeviceNotTrusted not set");
390         return;
391     }
392     g_verifyListener.onDeviceNotTrusted(peerUdid);
393     LnnHbOnTrustedRelationReduced();
394     AuthRemoveDeviceKeyByUdid(peerUdid);
395 }
396 
RegAuthVerifyListener(const AuthVerifyListener * listener)397 int32_t RegAuthVerifyListener(const AuthVerifyListener *listener)
398 {
399     if (listener == NULL) {
400         AUTH_LOGE(AUTH_CONN, "invalid listener");
401         return SOFTBUS_INVALID_PARAM;
402     }
403     g_verifyListener = *listener;
404     return SOFTBUS_OK;
405 }
406 
UnregAuthVerifyListener(void)407 void UnregAuthVerifyListener(void)
408 {
409     (void)memset_s(&g_verifyListener, sizeof(AuthVerifyListener), 0, sizeof(AuthVerifyListener));
410 }
411 
OnGroupCreated(const char * groupId,int32_t groupType)412 static void OnGroupCreated(const char *groupId, int32_t groupType)
413 {
414     if (g_groupChangeListener.onGroupCreated != NULL) {
415         g_groupChangeListener.onGroupCreated(groupId, groupType);
416     }
417 }
418 
OnGroupDeleted(const char * groupId,int32_t groupType)419 static void OnGroupDeleted(const char *groupId, int32_t groupType)
420 {
421     if (g_groupChangeListener.onGroupDeleted != NULL) {
422         g_groupChangeListener.onGroupDeleted(groupId, groupType);
423     }
424 }
425 
OnDeviceBound(const char * udid,const char * groupInfo)426 static void OnDeviceBound(const char *udid, const char *groupInfo)
427 {
428     LnnInsertSpecificTrustedDevInfo(udid);
429     if (g_groupChangeListener.onDeviceBound != NULL) {
430         g_groupChangeListener.onDeviceBound(udid, groupInfo);
431     }
432 }
433 
RetryRegTrustDataChangeListener()434 static int32_t RetryRegTrustDataChangeListener()
435 {
436     TrustDataChangeListener trustListener = {
437         .onGroupCreated = OnGroupCreated,
438         .onGroupDeleted = OnGroupDeleted,
439         .onDeviceNotTrusted = OnDeviceNotTrusted,
440         .onDeviceBound = OnDeviceBound,
441     };
442     for (int32_t i = 1; i <= RETRY_REGDATA_TIMES; i++) {
443         int32_t ret = RegTrustDataChangeListener(&trustListener);
444         if (ret == SOFTBUS_OK) {
445             AUTH_LOGI(AUTH_HICHAIN, "regDataChangeListener success, times=%{public}d", i);
446             return SOFTBUS_OK;
447         }
448         AUTH_LOGW(AUTH_HICHAIN, "retry regDataChangeListener, current retry times=%{public}d, err=%{public}d", i, ret);
449         (void)SoftBusSleepMs(RETRY_REGDATA_MILLSECONDS);
450     }
451     return SOFTBUS_ERR;
452 }
453 
RegTrustListenerOnHichainSaStart(void)454 int32_t RegTrustListenerOnHichainSaStart(void)
455 {
456     TrustDataChangeListener trustListener = {
457         .onGroupCreated = OnGroupCreated,
458         .onGroupDeleted = OnGroupDeleted,
459         .onDeviceNotTrusted = OnDeviceNotTrusted,
460         .onDeviceBound = OnDeviceBound,
461     };
462     if (RegTrustDataChangeListener(&trustListener) != SOFTBUS_OK) {
463         AUTH_LOGE(AUTH_INIT, "RegTrustDataChangeListener fail");
464         g_regDataChangeListener = false;
465         return SOFTBUS_AUTH_INIT_FAIL;
466     }
467     g_regDataChangeListener = true;
468     AUTH_LOGE(AUTH_INIT, "OnHichainSaStart add listener succ");
469     return SOFTBUS_OK;
470 }
471 
RegGroupChangeListener(const GroupChangeListener * listener)472 int32_t RegGroupChangeListener(const GroupChangeListener *listener)
473 {
474     if (listener == NULL) {
475         AUTH_LOGE(AUTH_CONN, "listener is null");
476         return SOFTBUS_INVALID_PARAM;
477     }
478     g_groupChangeListener.onGroupCreated = listener->onGroupCreated;
479     g_groupChangeListener.onGroupDeleted = listener->onGroupDeleted;
480     g_groupChangeListener.onDeviceBound = listener->onDeviceBound;
481     return SOFTBUS_OK;
482 }
483 
UnregGroupChangeListener(void)484 void UnregGroupChangeListener(void)
485 {
486     g_groupChangeListener.onGroupCreated = NULL;
487     g_groupChangeListener.onGroupDeleted = NULL;
488     g_groupChangeListener.onDeviceBound = NULL;
489 }
490 
AuthRegisterToDpDelay(void * para)491 void AuthRegisterToDpDelay(void *para)
492 {
493     DeviceProfileChangeListener deviceProfileChangeListener = {
494         .onDeviceProfileAdd = OnDeviceBound,
495         .onDeviceProfileDeleted = OnDeviceNotTrusted,
496     };
497     RegisterToDp(&deviceProfileChangeListener);
498 }
499 
AuthDirectOnlineCreateAuthManager(int64_t authSeq,const AuthSessionInfo * info)500 int32_t AuthDirectOnlineCreateAuthManager(int64_t authSeq, const AuthSessionInfo *info)
501 {
502     AUTH_CHECK_AND_RETURN_RET_LOGE(info, SOFTBUS_INVALID_PARAM, AUTH_FSM, "info is null");
503     AUTH_CHECK_AND_RETURN_RET_LOGE(CheckAuthConnInfoType(&info->connInfo), SOFTBUS_INVALID_PARAM,
504         AUTH_FSM, "connInfo type error");
505     AUTH_LOGI(AUTH_FSM, "direct online authSeq=%{public}" PRId64 ", side=%{public}s, requestId=%{public}u",
506         authSeq, GetAuthSideStr(info->isServer), info->requestId);
507     if (!RequireAuthLock()) {
508         return SOFTBUS_LOCK_ERR;
509     }
510     if (info->connInfo.type != AUTH_LINK_TYPE_BLE) {
511         AUTH_LOGE(AUTH_FSM, "sessionkey online only support ble");
512         ReleaseAuthLock();
513         return SOFTBUS_ERR;
514     }
515 
516     bool isNewCreated = false;
517     AuthManager *auth = GetDeviceAuthManager(authSeq, info, &isNewCreated, authSeq);
518     if (auth == NULL) {
519         AUTH_LOGE(AUTH_FSM, "auth manager does not exist.");
520         ReleaseAuthLock();
521         return SOFTBUS_ERR;
522     }
523     auth->hasAuthPassed[info->connInfo.type] = true;
524     AUTH_LOGI(AUTH_FSM,
525         "auth manager without sessionkey. isNewCreated=%{public}d, authId=%{public}" PRId64 ", authSeq=%{public}" PRId64
526         ", lastVerifyTime=%{public}" PRId64,
527         isNewCreated, auth->authId, authSeq, auth->lastVerifyTime);
528     ReleaseAuthLock();
529     return SOFTBUS_OK;
530 }
531 
VerifyDevice(AuthRequest * request)532 static int32_t VerifyDevice(AuthRequest *request)
533 {
534     int64_t traceId = GenSeq(false);
535     request->traceId = traceId;
536     SoftbusHitraceStart(SOFTBUS_HITRACE_ID_VALID, (uint64_t)traceId);
537     AUTH_LOGI(AUTH_CONN, "start verify device: requestId=%{public}u", request->requestId);
538     if (!g_regDataChangeListener) {
539         if (RetryRegTrustDataChangeListener() != SOFTBUS_OK) {
540             AUTH_LOGE(AUTH_HICHAIN, "hichain regDataChangeListener failed");
541             SoftbusHitraceStop();
542             return SOFTBUS_AUTH_INIT_FAIL;
543         }
544         g_regDataChangeListener = true;
545     }
546     uint32_t waitNum = AddAuthRequest(request);
547     if (waitNum == 0) {
548         AUTH_LOGE(AUTH_CONN, "add verify request to list fail, requestId=%{public}u", request->requestId);
549         SoftbusHitraceStop();
550         return SOFTBUS_AUTH_INNER_ERR;
551     }
552     if (waitNum > 1) {
553         AUTH_LOGI(
554             AUTH_CONN, "wait last verify request complete, waitNum=%{public}u, requestId=%{public}u",
555             waitNum, request->requestId);
556         SoftbusHitraceStop();
557         return SOFTBUS_OK;
558     }
559     if (ConnectAuthDevice(request->requestId, &request->connInfo, CONN_SIDE_ANY) != SOFTBUS_OK) {
560         AUTH_LOGE(AUTH_CONN, "connect auth device failed: requestId=%{public}u", request->requestId);
561         FindAndDelAuthRequestByConnInfo(request->requestId, &request->connInfo);
562         SoftbusHitraceStop();
563         return SOFTBUS_AUTH_CONN_FAIL;
564     }
565     SoftbusHitraceStop();
566     AUTH_LOGI(AUTH_CONN, "verify device succ. requestId=%{public}u", request->requestId);
567     return SOFTBUS_OK;
568 }
569 
StartConnVerifyDevice(uint32_t requestId,const AuthConnInfo * connInfo,const AuthConnCallback * connCb,AuthVerifyModule module,bool isFastAuth)570 static int32_t StartConnVerifyDevice(uint32_t requestId, const AuthConnInfo *connInfo, const AuthConnCallback *connCb,
571     AuthVerifyModule module, bool isFastAuth)
572 {
573     if (connInfo == NULL || connCb == NULL) {
574         AUTH_LOGE(AUTH_CONN, "invalid param");
575         return SOFTBUS_INVALID_PARAM;
576     }
577     AuthRequest request;
578     (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
579     request.connCb = *connCb;
580     request.module = module;
581     request.requestId = requestId;
582     request.connInfo = *connInfo;
583     request.authId = AUTH_INVALID_ID;
584     request.type = REQUEST_TYPE_VERIFY;
585     request.isFastAuth = isFastAuth;
586     return VerifyDevice(&request);
587 }
588 
StartVerifyDevice(uint32_t requestId,const AuthConnInfo * connInfo,const AuthVerifyCallback * verifyCb,AuthVerifyModule module,bool isFastAuth)589 static int32_t StartVerifyDevice(uint32_t requestId, const AuthConnInfo *connInfo, const AuthVerifyCallback *verifyCb,
590     AuthVerifyModule module, bool isFastAuth)
591 {
592     if (connInfo == NULL || verifyCb == NULL) {
593         AUTH_LOGE(AUTH_CONN, "invalid param");
594         return SOFTBUS_INVALID_PARAM;
595     }
596     AuthRequest request;
597     (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
598     request.verifyCb = *verifyCb;
599     request.module = module;
600     request.requestId = requestId;
601     request.connInfo = *connInfo;
602     request.authId = AUTH_INVALID_ID;
603     request.type = REQUEST_TYPE_VERIFY;
604     request.isFastAuth = isFastAuth;
605     return VerifyDevice(&request);
606 }
607 
AuthStartReconnectDevice(AuthHandle authHandle,const AuthConnInfo * connInfo,uint32_t requestId,const AuthConnCallback * connCb)608 int32_t AuthStartReconnectDevice(
609     AuthHandle authHandle, const AuthConnInfo *connInfo, uint32_t requestId, const AuthConnCallback *connCb)
610 {
611     AUTH_CHECK_AND_RETURN_RET_LOGE(connInfo != NULL, SOFTBUS_INVALID_PARAM, AUTH_CONN, "connInfo is NULL");
612     AUTH_CHECK_AND_RETURN_RET_LOGE(connCb != NULL, SOFTBUS_INVALID_PARAM, AUTH_CONN, "connCb is NULL");
613     AUTH_LOGI(AUTH_CONN, "start reconnect device. requestId=%{public}u, authId=%{public}" PRId64,
614         requestId, authHandle.authId);
615     AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
616     if (auth == NULL) {
617         return SOFTBUS_AUTH_NOT_FOUND;
618     }
619     ConnSideType sideType = GetConnSideType(auth->connId[connInfo->type]);
620     uint64_t connId = auth->connId[AUTH_LINK_TYPE_BR];
621     DelDupAuthManager(auth);
622 
623     AuthRequest request;
624     (void)memset_s(&request, sizeof(AuthRequest), 0, sizeof(AuthRequest));
625     request.authId = authHandle.authId;
626     request.connCb = *connCb;
627     request.connInfo = *connInfo;
628     request.requestId = requestId;
629     request.type = REQUEST_TYPE_RECONNECT;
630     request.isFastAuth = true;
631     if (connInfo->type == AUTH_LINK_TYPE_BR) {
632         request.connInfo.info.brInfo.connectionId = GetConnId(connId);
633     }
634     if (AddAuthRequest(&request) == 0) {
635         AUTH_LOGE(AUTH_CONN, "add reconnect request fail, requestId=%{public}u", requestId);
636         return SOFTBUS_ERR;
637     }
638     if (ConnectAuthDevice(requestId, &request.connInfo, sideType) != SOFTBUS_OK) {
639         DelAuthRequest(requestId);
640         return SOFTBUS_AUTH_CONN_FAIL;
641     }
642     return SOFTBUS_OK;
643 }
644 
AuthCheckSessionKey(AuthHandle * authHandle)645 static bool AuthCheckSessionKey(AuthHandle *authHandle)
646 {
647     AuthManager *auth = GetAuthManagerByAuthId(authHandle->authId);
648     if (auth == NULL) {
649         AUTH_LOGE(AUTH_CONN, "not found auth manager, authId=%{public}" PRId64, authHandle->authId);
650         return false;
651     }
652     bool res = CheckSessionKeyListExistType(&auth->sessionKeyList, (AuthLinkType)authHandle->type);
653     DelDupAuthManager(auth);
654     return res;
655 }
656 
AuthDeviceOpenConn(const AuthConnInfo * info,uint32_t requestId,const AuthConnCallback * callback)657 int32_t AuthDeviceOpenConn(const AuthConnInfo *info, uint32_t requestId, const AuthConnCallback *callback)
658 {
659     if (info == NULL || !CheckAuthConnCallback(callback)) {
660         AUTH_LOGE(AUTH_CONN, "invalid param");
661         return SOFTBUS_INVALID_PARAM;
662     }
663     AUTH_CHECK_AND_RETURN_RET_LOGE(CheckAuthConnInfoType(info), SOFTBUS_INVALID_PARAM,
664         AUTH_FSM, "connInfo type error");
665     AUTH_LOGI(AUTH_CONN, "open auth conn: connType=%{public}d, requestId=%{public}u", info->type, requestId);
666     AuthHandle authHandle = { .authId = AUTH_INVALID_ID, .type = info->type };
667     bool judgeTimeOut = false;
668     switch (info->type) {
669         case AUTH_LINK_TYPE_WIFI:
670             authHandle.authId = GetLatestIdByConnInfo(info);
671             if (authHandle.authId == AUTH_INVALID_ID) {
672                 return SOFTBUS_AUTH_NOT_FOUND;
673             }
674             callback->onConnOpened(requestId, authHandle);
675             break;
676         case AUTH_LINK_TYPE_BR:
677             /* fall-through */
678         case AUTH_LINK_TYPE_BLE:
679             judgeTimeOut = true;
680             authHandle.authId = GetActiveAuthIdByConnInfo(info, judgeTimeOut);
681             if (authHandle.authId != AUTH_INVALID_ID && AuthCheckSessionKey(&authHandle)) {
682                 return AuthStartReconnectDevice(authHandle, info, requestId, callback);
683             }
684             return StartConnVerifyDevice(requestId, info, callback, AUTH_MODULE_LNN, true);
685         case AUTH_LINK_TYPE_P2P:
686         case AUTH_LINK_TYPE_ENHANCED_P2P:
687             authHandle.authId = GetActiveAuthIdByConnInfo(info, judgeTimeOut);
688             if (authHandle.authId != AUTH_INVALID_ID) {
689                 AUTH_LOGI(AUTH_CONN, "reuse type=%{public}d, authId=%{public}" PRId64, info->type, authHandle.authId);
690                 callback->onConnOpened(requestId, authHandle);
691                 break;
692             }
693             return StartConnVerifyDevice(requestId, info, callback, AUTH_MODULE_LNN, true);
694         default:
695             AUTH_LOGE(AUTH_CONN, "unknown connType. type=%{public}d", info->type);
696             return SOFTBUS_INVALID_PARAM;
697     }
698     return SOFTBUS_OK;
699 }
700 
AuthDeviceCloseConn(AuthHandle authHandle)701 void AuthDeviceCloseConn(AuthHandle authHandle)
702 {
703     AUTH_LOGI(AUTH_CONN, "close auth conn: authId=%{public}" PRId64, authHandle.authId);
704     if (authHandle.type < AUTH_LINK_TYPE_WIFI || authHandle.type >= AUTH_LINK_TYPE_MAX) {
705         AUTH_LOGE(AUTH_CONN, "authHandle type error");
706         return;
707     }
708     AuthManager *auth = GetAuthManagerByAuthId(authHandle.authId);
709     if (auth == NULL) {
710         return;
711     }
712     switch (auth->connInfo[authHandle.type].type) {
713         case AUTH_LINK_TYPE_WIFI:
714         case AUTH_LINK_TYPE_P2P:
715         case AUTH_LINK_TYPE_ENHANCED_P2P:
716             /* Do nothing. */
717             break;
718         case AUTH_LINK_TYPE_BR:
719         case AUTH_LINK_TYPE_BLE:
720             DisconnectAuthDevice(&auth->connId[authHandle.type]);
721             break;
722         default:
723             break;
724     }
725     DelDupAuthManager(auth);
726     return;
727 }
728 
AuthStartVerify(const AuthConnInfo * connInfo,uint32_t requestId,const AuthVerifyCallback * callback,AuthVerifyModule module,bool isFastAuth)729 int32_t AuthStartVerify(const AuthConnInfo *connInfo, uint32_t requestId, const AuthVerifyCallback *callback,
730     AuthVerifyModule module, bool isFastAuth)
731 {
732     if (connInfo == NULL || !CheckVerifyCallback(callback)) {
733         AUTH_LOGE(AUTH_CONN, "invalid param");
734         return SOFTBUS_INVALID_PARAM;
735     }
736     AUTH_CHECK_AND_RETURN_RET_LOGE(CheckAuthConnInfoType(connInfo), SOFTBUS_INVALID_PARAM,
737         AUTH_FSM, "connInfo type error");
738     return StartVerifyDevice(requestId, connInfo, callback, module, isFastAuth);
739 }
740 
AuthStartConnVerify(const AuthConnInfo * connInfo,uint32_t requestId,const AuthConnCallback * connCallback,AuthVerifyModule module,bool isFastAuth)741 int32_t AuthStartConnVerify(const AuthConnInfo *connInfo, uint32_t requestId, const AuthConnCallback *connCallback,
742     AuthVerifyModule module, bool isFastAuth)
743 {
744     if (connInfo == NULL || !CheckAuthConnCallback(connCallback)) {
745         AUTH_LOGE(AUTH_CONN, "invalid param");
746         return SOFTBUS_INVALID_PARAM;
747     }
748     AUTH_CHECK_AND_RETURN_RET_LOGE(CheckAuthConnInfoType(connInfo), SOFTBUS_INVALID_PARAM,
749         AUTH_FSM, "connInfo type error");
750     return StartConnVerifyDevice(requestId, connInfo, connCallback, module, isFastAuth);
751 }
752