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_hichain.h"
17
18 #include <securec.h>
19
20 #include "anonymizer.h"
21 #include "auth_common.h"
22 #include "auth_hichain_adapter.h"
23 #include "auth_log.h"
24 #include "auth_session_fsm.h"
25 #include "bus_center_manager.h"
26 #include "device_auth.h"
27 #include "lnn_async_callback_utils.h"
28 #include "lnn_event.h"
29 #include "lnn_net_builder.h"
30 #include "softbus_adapter_mem.h"
31 #include "softbus_def.h"
32 #include "softbus_json_utils.h"
33 #include "lnn_connection_fsm.h"
34 #include "lnn_distributed_net_ledger.h"
35 #include "lnn_ohos_account_adapter.h"
36
37 #define AUTH_APPID "softbus_auth"
38 #define GROUPID_BUF_LEN 65
39 #define KEY_LENGTH 16 /* Note: WinPc's special nearby only support 128 bits key */
40 #define ONTRANSMIT_MAX_DATA_BUFFER_LEN 5120 /* 5 × 1024 */
41 #define PC_AUTH_ERRCODE 36870
42
43 #define HICHAIN_DAS_ERRCODE_MIN 0xF0000001
44 #define HICHAIN_DAS_ERRCODE_MAX 0xF00010FF
45 #define HICHAIN_COMMON_ERRCODE_MIN 0x0001
46 #define HICHAIN_COMMON_ERRCODE_MAX 0xFFFF
47 #define MASK_HIGH_4BIT 0xF000
48 #define MASK_LOW_8BIT 0x00FF
49 #define MASK_LOW_16BIT 0xFFFF
50 #define ERRCODE_OR_BIT 0x1000
51 #define ERRCODE_SHIFT_21BIT 21
52 #define ERRCODE_SHIFT_16BIT 16
53 #define ERRCODE_SHIFT_12BIT 12
54 #define ERRCODE_SHIFT_8BIT 8
55 #define SHORT_UDID_HASH_LEN 8
56
57 typedef struct {
58 char groupId[GROUPID_BUF_LEN];
59 GroupType groupType;
60 } GroupInfo;
61
62 typedef struct {
63 int32_t errCode;
64 uint32_t errorReturnLen;
65 uint8_t data[0];
66 } ProofInfo;
67
68 static TrustDataChangeListener g_dataChangeListener;
69
GenDeviceLevelParam(const char * udid,const char * uid,bool isClient,int32_t userId)70 static char *GenDeviceLevelParam(const char *udid, const char *uid, bool isClient, int32_t userId)
71 {
72 cJSON *msg = cJSON_CreateObject();
73 if (msg == NULL) {
74 AUTH_LOGE(AUTH_HICHAIN, "create json fail");
75 return NULL;
76 }
77 if (!AddStringToJsonObject(msg, FIELD_PEER_CONN_DEVICE_ID, udid) ||
78 !AddStringToJsonObject(msg, FIELD_SERVICE_PKG_NAME, AUTH_APPID) ||
79 !AddBoolToJsonObject(msg, FIELD_IS_DEVICE_LEVEL, true) ||
80 !AddBoolToJsonObject(msg, FIELD_IS_CLIENT, isClient) ||
81 !AddBoolToJsonObject(msg, FIELD_IS_UDID_HASH, false) ||
82 !AddNumberToJsonObject(msg, FIELD_KEY_LENGTH, KEY_LENGTH)) {
83 AUTH_LOGE(AUTH_HICHAIN, "add json object fail");
84 cJSON_Delete(msg);
85 return NULL;
86 }
87 if (userId != 0 && !AddNumberToJsonObject(msg, "peerOsAccountId", userId)) {
88 AUTH_LOGE(AUTH_HICHAIN, "add json userId fail");
89 }
90 #ifdef AUTH_ACCOUNT
91 AUTH_LOGI(AUTH_HICHAIN, "in account auth mode");
92 if (!AddStringToJsonObject(msg, FIELD_UID_HASH, uid)) {
93 AUTH_LOGE(AUTH_HICHAIN, "add uid into json fail");
94 cJSON_Delete(msg);
95 return NULL;
96 }
97 #endif
98 char *data = cJSON_PrintUnformatted(msg);
99 if (data == NULL) {
100 AUTH_LOGE(AUTH_HICHAIN, "cJSON_PrintUnformatted fail");
101 }
102 cJSON_Delete(msg);
103 return data;
104 }
105
OnTransmit(int64_t authSeq,const uint8_t * data,uint32_t len)106 static bool OnTransmit(int64_t authSeq, const uint8_t *data, uint32_t len)
107 {
108 AUTH_CHECK_AND_RETURN_RET_LOGE(len <= ONTRANSMIT_MAX_DATA_BUFFER_LEN, false, AUTH_HICHAIN,
109 "data len is invalid, len=%{public}u", len);
110 AUTH_LOGI(AUTH_HICHAIN, "hichain OnTransmit: authSeq=%{public}" PRId64 ", len=%{public}u", authSeq, len);
111 if (AuthSessionPostAuthData(authSeq, data, len) != SOFTBUS_OK) {
112 AUTH_LOGE(AUTH_HICHAIN, "hichain OnTransmit fail: authSeq=%{public}" PRId64, authSeq);
113 return false;
114 }
115 return true;
116 }
117
DfxRecordLnnExchangekeyEnd(int64_t authSeq,int32_t reason)118 static void DfxRecordLnnExchangekeyEnd(int64_t authSeq, int32_t reason)
119 {
120 LnnEventExtra extra = { 0 };
121 LnnEventExtraInit(&extra);
122 extra.authId = (int32_t)authSeq;
123 extra.errcode = reason;
124 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
125 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH_EXCHANGE_CIPHER, extra);
126 }
127
DfxRecordCertEndTime(int64_t authSeq)128 static void DfxRecordCertEndTime(int64_t authSeq)
129 {
130 uint64_t timeStamp = 0;
131 LnnEventExtra extra = { 0 };
132 (void)LnnEventExtraInit(&extra);
133 LnnTriggerInfo triggerInfo = { 0 };
134 GetLnnTriggerInfo(&triggerInfo);
135 timeStamp = SoftBusGetSysTimeMs();
136 extra.timeLatency = timeStamp - triggerInfo.triggerTime;
137 extra.authSeq = authSeq;
138 if (!RequireAuthLock()) {
139 return;
140 }
141 AuthFsm *authFsm = GetAuthFsmByAuthSeq(authSeq);
142 if (authFsm == NULL) {
143 AUTH_LOGE(AUTH_HICHAIN, "auth fsm not found");
144 ReleaseAuthLock();
145 return;
146 }
147 extra.peerUdidHash = authFsm->info.udidHash;
148 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH_EXCHANGE_CIPHER, extra);
149 ReleaseAuthLock();
150 }
151
OnSessionKeyReturned(int64_t authSeq,const uint8_t * sessionKey,uint32_t sessionKeyLen)152 static void OnSessionKeyReturned(int64_t authSeq, const uint8_t *sessionKey, uint32_t sessionKeyLen)
153 {
154 AUTH_LOGI(AUTH_HICHAIN, "hichain OnSessionKeyReturned: authSeq=%{public}" PRId64 ", len=%{public}u", authSeq,
155 sessionKeyLen);
156 if (sessionKey == NULL || sessionKeyLen > SESSION_KEY_LENGTH) {
157 DfxRecordLnnExchangekeyEnd(authSeq, SOFTBUS_AUTH_GET_SESSION_KEY_FAIL);
158 AUTH_LOGW(AUTH_HICHAIN, "invalid sessionKey");
159 return;
160 }
161 DfxRecordLnnExchangekeyEnd(authSeq, SOFTBUS_OK);
162 (void)AuthSessionSaveSessionKey(authSeq, sessionKey, sessionKeyLen);
163 DfxRecordCertEndTime(authSeq);
164 }
165
DfxRecordLnnEndHichainEnd(int64_t authSeq,int32_t reason)166 static void DfxRecordLnnEndHichainEnd(int64_t authSeq, int32_t reason)
167 {
168 LnnEventExtra extra = { 0 };
169 LnnEventExtraInit(&extra);
170 extra.authId = (int32_t)authSeq;
171 extra.errcode = reason;
172 extra.result = (reason == SOFTBUS_OK) ? EVENT_STAGE_RESULT_OK : EVENT_STAGE_RESULT_FAILED;
173 LNN_EVENT(EVENT_SCENE_JOIN_LNN, EVENT_STAGE_AUTH_HICHAIN_END, extra);
174 }
175
OnFinish(int64_t authSeq,int operationCode,const char * returnData)176 static void OnFinish(int64_t authSeq, int operationCode, const char *returnData)
177 {
178 (void)operationCode;
179 (void)returnData;
180 DfxRecordLnnEndHichainEnd(authSeq, SOFTBUS_OK);
181 AUTH_LOGI(AUTH_HICHAIN, "hichain OnFinish: authSeq=%{public}" PRId64, authSeq);
182 (void)AuthSessionHandleAuthFinish(authSeq);
183 }
184
GetSoftbusHichainAuthErrorCode(uint32_t hichainErrCode,uint32_t * softbusErrCode)185 void GetSoftbusHichainAuthErrorCode(uint32_t hichainErrCode, uint32_t *softbusErrCode)
186 {
187 if (softbusErrCode == NULL) {
188 AUTH_LOGE(AUTH_HICHAIN, "softbusErrCode is null");
189 return;
190 }
191 if (hichainErrCode >= HICHAIN_DAS_ERRCODE_MIN && hichainErrCode <= HICHAIN_DAS_ERRCODE_MAX) {
192 *softbusErrCode = hichainErrCode & MASK_LOW_16BIT;
193 *softbusErrCode = -(((SOFTBUS_SUB_SYSTEM) << ERRCODE_SHIFT_21BIT) |
194 ((AUTH_SUB_MODULE_CODE) << ERRCODE_SHIFT_16BIT) | (*softbusErrCode | ERRCODE_OR_BIT));
195 } else if (hichainErrCode >= HICHAIN_COMMON_ERRCODE_MIN && hichainErrCode <= HICHAIN_COMMON_ERRCODE_MAX) {
196 uint32_t high4bit = 0;
197 uint32_t tempCode = 0;
198 high4bit = hichainErrCode & MASK_HIGH_4BIT;
199 high4bit = high4bit >> ERRCODE_SHIFT_12BIT;
200 tempCode = hichainErrCode & MASK_LOW_8BIT;
201 *softbusErrCode = -(((SOFTBUS_SUB_SYSTEM) << ERRCODE_SHIFT_21BIT) |
202 ((AUTH_SUB_MODULE_CODE) << ERRCODE_SHIFT_16BIT) | (tempCode | (high4bit << ERRCODE_SHIFT_8BIT)));
203 } else {
204 *softbusErrCode = hichainErrCode;
205 AUTH_LOGI(AUTH_HICHAIN, "unknow hichain errcode=%{public}d", hichainErrCode);
206 }
207 }
208
GetDeviceSideFlag(int64_t authSeq,bool * flag)209 static int32_t GetDeviceSideFlag(int64_t authSeq, bool *flag)
210 {
211 if (!RequireAuthLock()) {
212 return SOFTBUS_LOCK_ERR;
213 }
214 AuthFsm *authFsm = GetAuthFsmByAuthSeq(authSeq);
215 if (authFsm == NULL) {
216 AUTH_LOGE(AUTH_HICHAIN, "auth fsm not found");
217 ReleaseAuthLock();
218 return SOFTBUS_AUTH_NOT_FOUND;
219 }
220 *flag = authFsm->info.isServer;
221 AUTH_LOGI(AUTH_HICHAIN, "find authFsm success, side=%{public}s", GetAuthSideStr(*flag));
222 ReleaseAuthLock();
223 return SOFTBUS_OK;
224 }
225
CheckErrReturnValidity(const char * errorReturn)226 static int32_t CheckErrReturnValidity(const char *errorReturn)
227 {
228 cJSON *json = cJSON_Parse(errorReturn);
229 if (json == NULL) {
230 AUTH_LOGE(AUTH_HICHAIN, "parse json fail");
231 return SOFTBUS_PARSE_JSON_ERR;
232 }
233 cJSON_Delete(json);
234 return SOFTBUS_OK;
235 }
236
ProcessAuthFailCallBack(void * para)237 static void ProcessAuthFailCallBack(void *para)
238 {
239 if (para == NULL) {
240 AUTH_LOGE(AUTH_HICHAIN, "invalid para");
241 return;
242 }
243 ProofInfo *proofInfo = (ProofInfo *)para;
244 if (AuthFailNotifyProofInfo(proofInfo->errCode, (char *)proofInfo->data, proofInfo->errorReturnLen) != SOFTBUS_OK) {
245 AUTH_LOGE(AUTH_HICHAIN, "AuthFailNotifyProofInfo fail");
246 SoftBusFree(proofInfo);
247 return;
248 }
249 SoftBusFree(proofInfo);
250 }
251
NotifyAuthFailEvent(int32_t errCode,const char * errorReturn)252 static void NotifyAuthFailEvent(int32_t errCode, const char *errorReturn)
253 {
254 uint32_t errorReturnLen = strlen(errorReturn) + 1;
255 char *anonyErrorReturn = NULL;
256 Anonymize(errorReturn, &anonyErrorReturn);
257 AUTH_LOGW(AUTH_HICHAIN, "errorReturn=%{public}s, errorReturnLen=%{public}u, errCode=%{public}d",
258 AnonymizeWrapper(anonyErrorReturn), errorReturnLen, errCode);
259 AnonymizeFree(anonyErrorReturn);
260
261 ProofInfo *proofInfo = (ProofInfo *)SoftBusCalloc(sizeof(ProofInfo) + errorReturnLen);
262 if (proofInfo == NULL) {
263 AUTH_LOGE(AUTH_HICHAIN, "proofInfo calloc fail");
264 return;
265 }
266 if (memcpy_s(proofInfo->data, errorReturnLen, (uint8_t *)errorReturn, errorReturnLen) != EOK) {
267 AUTH_LOGE(AUTH_HICHAIN, "memcpy_s errorReturn fail");
268 SoftBusFree(proofInfo);
269 return;
270 }
271 proofInfo->errorReturnLen = errorReturnLen;
272 proofInfo->errCode = errCode;
273 if (LnnAsyncCallbackDelayHelper(GetLooper(LOOP_TYPE_DEFAULT), ProcessAuthFailCallBack, (void *)proofInfo, 0) !=
274 SOFTBUS_OK) {
275 AUTH_LOGE(AUTH_HICHAIN, "set async ProcessAuthFailCallBack callback fail");
276 SoftBusFree(proofInfo);
277 return;
278 }
279 }
280
NotifyPcAuthFail(int64_t authSeq,int errCode,const char * errorReturn)281 static void NotifyPcAuthFail(int64_t authSeq, int errCode, const char *errorReturn)
282 {
283 if (errorReturn != NULL && CheckErrReturnValidity(errorReturn) == SOFTBUS_OK) {
284 if (errCode == PC_AUTH_ERRCODE) {
285 NotifyAuthFailEvent(errCode, errorReturn);
286 }
287 if (errCode == PC_PROOF_NON_CONSISTENT_ERRCODE) {
288 bool flag = false;
289 if (GetDeviceSideFlag(authSeq, &flag) == SOFTBUS_OK && flag) {
290 NotifyAuthFailEvent(errCode, errorReturn);
291 }
292 }
293 }
294 return;
295 }
296
OnError(int64_t authSeq,int operationCode,int errCode,const char * errorReturn)297 static void OnError(int64_t authSeq, int operationCode, int errCode, const char *errorReturn)
298 {
299 (void)operationCode;
300 DfxRecordLnnEndHichainEnd(authSeq, errCode);
301 uint32_t authErrCode = 0;
302 (void)GetSoftbusHichainAuthErrorCode((uint32_t)errCode, &authErrCode);
303 AUTH_LOGE(AUTH_HICHAIN, "hichain OnError: authSeq=%{public}" PRId64 ", errCode=%{public}d authErrCode=%{public}d",
304 authSeq, errCode, authErrCode);
305 NotifyPcAuthFail(authSeq, errCode, errorReturn);
306 (void)AuthSessionHandleAuthError(authSeq, authErrCode);
307 }
308
OnRequest(int64_t authSeq,int operationCode,const char * reqParams)309 static char *OnRequest(int64_t authSeq, int operationCode, const char *reqParams)
310 {
311 (void)reqParams;
312 AUTH_LOGI(AUTH_HICHAIN, "hichain OnRequest: authSeq=%{public}" PRId64 ", operationCode=%{public}d", authSeq,
313 operationCode);
314 char udid[UDID_BUF_LEN] = {0};
315 if (AuthSessionGetUdid(authSeq, udid, sizeof(udid)) != SOFTBUS_OK) {
316 AUTH_LOGE(AUTH_HICHAIN, "get udid fail");
317 return NULL;
318 }
319 cJSON *msg = cJSON_CreateObject();
320 if (msg == NULL) {
321 return NULL;
322 }
323 char localUdid[UDID_BUF_LEN] = {0};
324 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN);
325 if (!AddNumberToJsonObject(msg, FIELD_CONFIRMATION, REQUEST_ACCEPTED) ||
326 !AddStringToJsonObject(msg, FIELD_SERVICE_PKG_NAME, AUTH_APPID) ||
327 !AddStringToJsonObject(msg, FIELD_PEER_CONN_DEVICE_ID, udid) ||
328 !AddStringToJsonObject(msg, FIELD_DEVICE_ID, localUdid) ||
329 !AddBoolToJsonObject(msg, FIELD_IS_UDID_HASH, false)) {
330 AUTH_LOGE(AUTH_HICHAIN, "pack request msg fail");
331 cJSON_Delete(msg);
332 return NULL;
333 }
334 char *msgStr = cJSON_PrintUnformatted(msg);
335 if (msgStr == NULL) {
336 AUTH_LOGE(AUTH_HICHAIN, "cJSON_PrintUnformatted fail");
337 cJSON_Delete(msg);
338 return NULL;
339 }
340 cJSON_Delete(msg);
341 return msgStr;
342 }
343
344 static DeviceAuthCallback g_hichainCallback = {
345 .onTransmit = OnTransmit,
346 .onSessionKeyReturned = OnSessionKeyReturned,
347 .onFinish = OnFinish,
348 .onError = OnError,
349 .onRequest = OnRequest
350 };
351
GetUdidHash(const char * udid,char * udidHash)352 static int32_t GetUdidHash(const char *udid, char *udidHash)
353 {
354 if (udid == NULL || udidHash == NULL) {
355 AUTH_LOGE(AUTH_HICHAIN, "param error");
356 return SOFTBUS_INVALID_PARAM;
357 }
358 int32_t rc = SOFTBUS_OK;
359 uint8_t hash[UDID_HASH_LEN] = { 0 };
360 rc = SoftBusGenerateStrHash((uint8_t *)udid, strlen(udid), hash);
361 if (rc != SOFTBUS_OK) {
362 AUTH_LOGE(AUTH_HICHAIN, "generate udidhash fail");
363 return rc;
364 }
365 rc = ConvertBytesToHexString(udidHash, HB_SHORT_UDID_HASH_HEX_LEN + 1, hash, SHORT_UDID_HASH_LEN);
366 if (rc != SOFTBUS_OK) {
367 AUTH_LOGE(AUTH_HICHAIN, "convert bytes to string fail");
368 return rc;
369 }
370 return SOFTBUS_OK;
371 }
372
DeletePcRestrictNode(const char * udid)373 static void DeletePcRestrictNode(const char *udid)
374 {
375 char peerUdidHash[HB_SHORT_UDID_HASH_HEX_LEN + 1] = { 0 };
376 uint32_t count = 0;
377
378 if (GetUdidHash(udid, peerUdidHash) == SOFTBUS_OK && GetNodeFromPcRestrictMap(peerUdidHash, &count) == SOFTBUS_OK) {
379 DeleteNodeFromPcRestrictMap(peerUdidHash);
380 char *anonyUdid = NULL;
381 Anonymize(udid, &anonyUdid);
382 AUTH_LOGI(AUTH_HICHAIN, "delete restrict node success. udid=%{public}s", AnonymizeWrapper(anonyUdid));
383 AnonymizeFree(anonyUdid);
384 }
385 }
386
ParseGroupInfo(const char * groupInfoStr,GroupInfo * groupInfo)387 static int32_t ParseGroupInfo(const char *groupInfoStr, GroupInfo *groupInfo)
388 {
389 cJSON *msg = cJSON_Parse(groupInfoStr);
390 if (msg == NULL) {
391 AUTH_LOGE(AUTH_HICHAIN, "parse json fail");
392 return SOFTBUS_PARSE_JSON_ERR;
393 }
394 if (!GetJsonObjectStringItem(msg, FIELD_GROUP_ID, groupInfo->groupId, GROUPID_BUF_LEN)) {
395 AUTH_LOGE(AUTH_HICHAIN, "get FIELD_GROUP_ID fail");
396 cJSON_Delete(msg);
397 return SOFTBUS_AUTH_GET_GROUP_ID_FAIL;
398 }
399 int32_t groupType = 0;
400 if (!GetJsonObjectNumberItem(msg, FIELD_GROUP_TYPE, &groupType)) {
401 AUTH_LOGE(AUTH_HICHAIN, "get FIELD_GROUP_TYPE fail");
402 cJSON_Delete(msg);
403 return SOFTBUS_AUTH_GET_GROUP_TYPE_FAIL;
404 }
405 groupInfo->groupType = (GroupType)groupType;
406 cJSON_Delete(msg);
407 return SOFTBUS_OK;
408 }
409
OnGroupCreated(const char * groupInfo)410 static void OnGroupCreated(const char *groupInfo)
411 {
412 if (groupInfo == NULL) {
413 AUTH_LOGW(AUTH_HICHAIN, "invalid group info");
414 return;
415 }
416 GroupInfo info;
417 (void)memset_s(&info, sizeof(GroupInfo), 0, sizeof(GroupInfo));
418 if (ParseGroupInfo(groupInfo, &info) != SOFTBUS_OK) {
419 return;
420 }
421 AUTH_LOGI(AUTH_HICHAIN, "hichain OnGroupCreated, type=%{public}d", info.groupType);
422 if (g_dataChangeListener.onGroupCreated != NULL) {
423 g_dataChangeListener.onGroupCreated(info.groupId, (int32_t)info.groupType);
424 }
425 }
426
OnDeviceBound(const char * udid,const char * groupInfo)427 static void OnDeviceBound(const char *udid, const char *groupInfo)
428 {
429 if (udid == NULL || groupInfo == NULL) {
430 AUTH_LOGW(AUTH_HICHAIN, "invalid udid");
431 return;
432 }
433 GroupInfo info;
434 (void)memset_s(&info, sizeof(GroupInfo), 0, sizeof(GroupInfo));
435 if (ParseGroupInfo(groupInfo, &info) != SOFTBUS_OK) {
436 return;
437 }
438 char *anonyUdid = NULL;
439 Anonymize(udid, &anonyUdid);
440 AUTH_LOGI(AUTH_HICHAIN, "hichain onDeviceBound, udid=%{public}s, type=%{public}d",
441 AnonymizeWrapper(anonyUdid), info.groupType);
442 AnonymizeFree(anonyUdid);
443 if (info.groupType == AUTH_IDENTICAL_ACCOUNT_GROUP) {
444 AUTH_LOGI(AUTH_HICHAIN, "ignore same account udid");
445 DeletePcRestrictNode(udid);
446 return;
447 }
448 char localUdid[UDID_BUF_LEN] = { 0 };
449 LnnGetLocalStrInfo(STRING_KEY_DEV_UDID, localUdid, UDID_BUF_LEN);
450 if (strcmp(localUdid, udid) == 0) {
451 AUTH_LOGI(AUTH_HICHAIN, "ignore local udid");
452 return;
453 }
454 if (g_dataChangeListener.onDeviceBound != NULL) {
455 g_dataChangeListener.onDeviceBound(udid, groupInfo);
456 }
457 }
458
OnGroupDeleted(const char * groupInfo)459 static void OnGroupDeleted(const char *groupInfo)
460 {
461 if (groupInfo == NULL) {
462 AUTH_LOGE(AUTH_HICHAIN, "invalid group info");
463 return;
464 }
465 GroupInfo info;
466 (void)memset_s(&info, sizeof(GroupInfo), 0, sizeof(GroupInfo));
467 if (ParseGroupInfo(groupInfo, &info) != SOFTBUS_OK) {
468 return;
469 }
470 AUTH_LOGI(AUTH_HICHAIN, "hichain OnGroupDeleted, type=%{public}d", info.groupType);
471 if (g_dataChangeListener.onGroupDeleted != NULL) {
472 g_dataChangeListener.onGroupDeleted(info.groupId, info.groupType);
473 }
474 }
475
OnDeviceNotTrusted(const char * udid)476 static void OnDeviceNotTrusted(const char *udid)
477 {
478 if (udid == NULL) {
479 AUTH_LOGW(AUTH_HICHAIN, "hichain get invalid udid");
480 return;
481 }
482 char *anonyUdid = NULL;
483 Anonymize(udid, &anonyUdid);
484 AUTH_LOGI(AUTH_HICHAIN, "hichain OnDeviceNotTrusted, udid=%{public}s", AnonymizeWrapper(anonyUdid));
485 AnonymizeFree(anonyUdid);
486 NodeInfo nodeInfo;
487 (void)memset_s(&nodeInfo, sizeof(NodeInfo), 0, sizeof(NodeInfo));
488 int32_t ret = LnnGetRemoteNodeInfoById(udid, CATEGORY_UDID, &nodeInfo);
489 if (ret != SOFTBUS_OK) {
490 AUTH_LOGE(AUTH_HICHAIN, "LnnGetRemoteNodeInfoById failed! ret=%{public}d", ret);
491 return;
492 }
493 if (nodeInfo.deviceInfo.osType == OH_OS_TYPE) {
494 AUTH_LOGI(AUTH_HICHAIN, "device is oh, ignore hichain event");
495 return;
496 }
497 if (g_dataChangeListener.onDeviceNotTrusted != NULL) {
498 g_dataChangeListener.onDeviceNotTrusted(udid, GetActiveOsAccountIds());
499 }
500 }
501
RegTrustDataChangeListener(const TrustDataChangeListener * listener)502 int32_t RegTrustDataChangeListener(const TrustDataChangeListener *listener)
503 {
504 if (listener == NULL) {
505 return SOFTBUS_INVALID_PARAM;
506 }
507 g_dataChangeListener = *listener;
508
509 DataChangeListener hichainListener;
510 (void)memset_s(&hichainListener, sizeof(DataChangeListener), 0, sizeof(DataChangeListener));
511 hichainListener.onGroupCreated = OnGroupCreated;
512 hichainListener.onGroupDeleted = OnGroupDeleted;
513 hichainListener.onDeviceNotTrusted = OnDeviceNotTrusted;
514 hichainListener.onDeviceBound = OnDeviceBound;
515 if (RegChangeListener(AUTH_APPID, &hichainListener) != SOFTBUS_OK) {
516 AUTH_LOGE(AUTH_HICHAIN, "hichain regDataChangeListener fail");
517 return SOFTBUS_AUTH_REG_DATA_FAIL;
518 }
519 return SOFTBUS_OK;
520 }
521
UnregTrustDataChangeListener(void)522 void UnregTrustDataChangeListener(void)
523 {
524 int32_t ret = UnregChangeListener(AUTH_APPID);
525 if (ret != SOFTBUS_OK) {
526 AUTH_LOGE(AUTH_HICHAIN, "hichain unRegDataChangeListener err=%{public}d", ret);
527 }
528 (void)memset_s(&g_dataChangeListener, sizeof(TrustDataChangeListener), 0, sizeof(TrustDataChangeListener));
529 }
530
HichainStartAuth(int64_t authSeq,const char * udid,const char * uid,int32_t userId)531 int32_t HichainStartAuth(int64_t authSeq, const char *udid, const char *uid, int32_t userId)
532 {
533 if (udid == NULL || uid == NULL) {
534 AUTH_LOGE(AUTH_HICHAIN, "udid/uid is invalid");
535 return SOFTBUS_INVALID_PARAM;
536 }
537 char *authParams = GenDeviceLevelParam(udid, uid, true, userId);
538 if (authParams == NULL) {
539 AUTH_LOGE(AUTH_HICHAIN, "generate auth param fail");
540 return SOFTBUS_CREATE_JSON_ERR;
541 }
542 int32_t ret = AuthDevice(authSeq, authParams, &g_hichainCallback);
543 if (ret == SOFTBUS_OK) {
544 AUTH_LOGI(AUTH_HICHAIN, "hichain call authDevice succ");
545 cJSON_free(authParams);
546 return SOFTBUS_OK;
547 }
548 AUTH_LOGE(AUTH_HICHAIN, "hichain call authDevice failed");
549 cJSON_free(authParams);
550 return ret;
551 }
552
HichainProcessData(int64_t authSeq,const uint8_t * data,uint32_t len)553 int32_t HichainProcessData(int64_t authSeq, const uint8_t *data, uint32_t len)
554 {
555 if (data == NULL) {
556 AUTH_LOGE(AUTH_HICHAIN, "data is null");
557 return SOFTBUS_INVALID_PARAM;
558 }
559 int32_t ret = ProcessAuthData(authSeq, data, len, &g_hichainCallback);
560 if (ret != SOFTBUS_OK) {
561 AUTH_LOGE(AUTH_HICHAIN, "hichain processData err=%{public}d", ret);
562 return ret;
563 }
564 return SOFTBUS_OK;
565 }
566
HichainDestroy(void)567 void HichainDestroy(void)
568 {
569 UnregTrustDataChangeListener();
570 DestroyDeviceAuth();
571 AUTH_LOGI(AUTH_HICHAIN, "hichain destroy succ");
572 }
573
HichainCancelRequest(int64_t authReqId)574 void HichainCancelRequest(int64_t authReqId)
575 {
576 CancelRequest(authReqId, AUTH_APPID);
577 }
578