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 "lnn_decision_db.h"
17
18 #include <securec.h>
19 #include <errno.h>
20 #include <signal.h>
21 #include <sys/stat.h>
22 #include <sys/time.h>
23
24 #include "anonymizer.h"
25 #include "auth_deviceprofile.h"
26 #include "auth_device_common_key.h"
27 #include "bus_center_info_key.h"
28 #include "bus_center_manager.h"
29 #include "g_enhance_lnn_func_pack.h"
30 #include "lnn_async_callback_utils.h"
31 #include "lnn_device_info_recovery.h"
32 #include "lnn_ohos_account.h"
33 #include "lnn_file_utils.h"
34 #include "lnn_heartbeat_ctrl.h"
35 #include "lnn_huks_utils.h"
36 #include "lnn_local_net_ledger.h"
37 #include "lnn_log.h"
38 #include "lnn_p2p_info.h"
39 #include "lnn_secure_storage_struct.h"
40 #include "sqlite3_utils.h"
41
42 #include "softbus_adapter_crypto.h"
43 #include "softbus_adapter_file.h"
44 #include "softbus_adapter_mem.h"
45 #include "softbus_adapter_thread.h"
46 #include "softbus_adapter_timer.h"
47 #include "softbus_common.h"
48 #include "softbus_error_code.h"
49 #include "softbus_utils.h"
50
51 typedef struct {
52 ListNode node;
53 TrustedInfo infoRecord;
54 } DeviceDbInfo;
55
56 static ListNode g_deviceInfoList = { &g_deviceInfoList, &g_deviceInfoList };
57 static SoftBusMutex g_deviceDbMutex;
58 static SoftBusMutex g_dbMutex;
59
60 static bool g_isDbListInit = false;
61
62 #define LNN_DB_KEY_LEN 1024
63 #define LNN_DB_KEY_AILAS "dsoftbus_decision_db_key_alias"
64 #define DEFAULT_USER_ID "0"
65
66 #define WAIT_ONE_HOUR_QUERY_INTERVAL (60 * 60 * 1000)
67 #define WAIT_SEVEN_DAYS_QUERY_INTERVAL (7 * 24 * 60 * 60 * 1000)
68
69 static struct HksBlob g_keyAlias = { sizeof(LNN_DB_KEY_AILAS), (uint8_t *)LNN_DB_KEY_AILAS };
70 static struct HksBlob g_ceKeyAlias = { sizeof(LNN_DB_KEY_AILAS), (uint8_t *)LNN_DB_KEY_AILAS };
71
72
DeviceDbRecoveryInit(void)73 static bool DeviceDbRecoveryInit(void)
74 {
75 if (SoftBusMutexInit(&g_deviceDbMutex, NULL) != SOFTBUS_OK) {
76 LNN_LOGE(LNN_LEDGER, "g_deviceDbMutex init fail");
77 return false;
78 }
79 if (SoftBusMutexInit(&g_dbMutex, NULL) != SOFTBUS_OK) {
80 SoftBusMutexDestroy(&g_deviceDbMutex);
81 LNN_LOGE(LNN_LEDGER, "g_isDbMutexInit init fail");
82 return false;
83 }
84 g_isDbListInit = true;
85 return true;
86 }
87
DeviceDbListLock(void)88 static int32_t DeviceDbListLock(void)
89 {
90 if (!g_isDbListInit) {
91 if (!DeviceDbRecoveryInit()) {
92 return SOFTBUS_NETWORK_DB_LOCK_INIT_FAILED;
93 }
94 }
95 return SoftBusMutexLock(&g_deviceDbMutex);
96 }
97
DeviceDbListUnlock(void)98 static void DeviceDbListUnlock(void)
99 {
100 if (!g_isDbListInit) {
101 (void)DeviceDbRecoveryInit();
102 return;
103 }
104 (void)SoftBusMutexUnlock(&g_deviceDbMutex);
105 }
106
EncryptStorageData(LnnEncryptDataLevel level,uint8_t * dbKey,uint32_t len)107 int32_t EncryptStorageData(LnnEncryptDataLevel level, uint8_t *dbKey, uint32_t len)
108 {
109 struct HksBlob plainData = { 0 };
110 struct HksBlob encryptData = { 0 };
111 if (level < LNN_ENCRYPT_LEVEL_DE || level > LNN_ENCRYPT_LEVEL_ECE) {
112 LNN_LOGE(LNN_LEDGER, "invalid param, level=%{public}u", level);
113 return SOFTBUS_MEM_ERR;
114 }
115 encryptData.data = (uint8_t *)SoftBusCalloc(len);
116 if (encryptData.data == NULL) {
117 LNN_LOGE(LNN_LEDGER, "calloc encrypt dbKey fail");
118 return SOFTBUS_MALLOC_ERR;
119 }
120 LNN_LOGI(LNN_LEDGER, "Encrypt data, level=%{public}u len=%{public}u", level, len);
121 plainData.size = len;
122 plainData.data = dbKey;
123 int32_t ret = SOFTBUS_OK;
124 if (level == LNN_ENCRYPT_LEVEL_CE) {
125 ret = LnnCeEncryptDataByHuks(&g_ceKeyAlias, &plainData, &encryptData);
126 } else {
127 ret = LnnEncryptDataByHuks(&g_keyAlias, &plainData, &encryptData);
128 }
129 if (ret != SOFTBUS_OK) {
130 LNN_LOGE(LNN_LEDGER, "encrypt dbKey by huks fail, ret=%{public}d", ret);
131 (void)memset_s(plainData.data, len, 0x0, len);
132 SoftBusFree(encryptData.data);
133 return ret;
134 }
135 LNN_LOGW(LNN_LEDGER, "encrypt dbKey log for audit");
136 (void)memset_s(plainData.data, len, 0x0, len);
137 if (memcpy_s(dbKey, len, encryptData.data, len) != SOFTBUS_OK) {
138 LNN_LOGE(LNN_LEDGER, "memcpy_s dbKey fail");
139 SoftBusFree(encryptData.data);
140 return SOFTBUS_MEM_ERR;
141 }
142 SoftBusFree(encryptData.data);
143 return SOFTBUS_OK;
144 }
145
DecryptStorageData(LnnEncryptDataLevel level,uint8_t * dbKey,uint32_t len)146 int32_t DecryptStorageData(LnnEncryptDataLevel level, uint8_t *dbKey, uint32_t len)
147 {
148 struct HksBlob encryptData = { 0 };
149 struct HksBlob decryptData = { 0 };
150 if (level < LNN_ENCRYPT_LEVEL_DE || level > LNN_ENCRYPT_LEVEL_ECE) {
151 LNN_LOGE(LNN_LEDGER, "invalid param, level=%{public}u", level);
152 return SOFTBUS_MEM_ERR;
153 }
154 decryptData.data = (uint8_t *)SoftBusCalloc(len);
155 if (decryptData.data == NULL) {
156 LNN_LOGE(LNN_LEDGER, "calloc decrypt dbKey fail");
157 return SOFTBUS_MEM_ERR;
158 }
159 encryptData.size = len;
160 encryptData.data = dbKey;
161 int32_t ret;
162 do {
163 if (level == LNN_ENCRYPT_LEVEL_CE) {
164 ret = LnnCeDecryptDataByHuks(&g_ceKeyAlias, &encryptData, &decryptData);
165 } else {
166 ret = LnnDecryptDataByHuks(&g_keyAlias, &encryptData, &decryptData);
167 }
168 if (ret != SOFTBUS_OK) {
169 LNN_LOGE(LNN_LEDGER, "decrypt dbKey by huks fail, ret=%{public}d", ret);
170 break;
171 }
172 if (memcpy_s(dbKey, len, decryptData.data, decryptData.size) != SOFTBUS_OK) {
173 LNN_LOGE(LNN_LEDGER, "memcpy_s dbKey fail");
174 ret = SOFTBUS_MEM_ERR;
175 break;
176 }
177 ret = SOFTBUS_OK;
178 } while (false);
179 (void)memset_s(decryptData.data, decryptData.size, 0x0, decryptData.size);
180 SoftBusFree(decryptData.data);
181 return ret;
182 }
183
GetDecisionDbKey(uint8_t * dbKey,uint32_t len,bool isUpdate)184 static int32_t GetDecisionDbKey(uint8_t *dbKey, uint32_t len, bool isUpdate)
185 {
186 char dbKeyFilePath[SOFTBUS_MAX_PATH_LEN] = {0};
187 int32_t ret = SOFTBUS_OK;
188 if (LnnGetFullStoragePath(LNN_FILE_ID_DB_KEY, dbKeyFilePath, SOFTBUS_MAX_PATH_LEN) != SOFTBUS_OK) {
189 LNN_LOGE(LNN_LEDGER, "get dbKey save path fail");
190 return SOFTBUS_NETWORK_GET_PATH_FAILED;
191 }
192 do {
193 if (!isUpdate && SoftBusAccessFile(dbKeyFilePath, SOFTBUS_F_OK) == SOFTBUS_OK) {
194 LNN_LOGD(LNN_LEDGER, "dbKey file is exist");
195 break;
196 }
197 ret = LnnGenerateRandomByHuks(dbKey, len);
198 if (ret != SOFTBUS_OK) {
199 LNN_LOGE(LNN_LEDGER, "generate random dbKey fail");
200 return ret;
201 }
202 ret = EncryptStorageData(LNN_ENCRYPT_LEVEL_DE, dbKey, len);
203 if (ret != SOFTBUS_OK) {
204 LNN_LOGE(LNN_LEDGER, "encrypt dbKey fail");
205 return ret;
206 }
207 if (SoftBusWriteFile(dbKeyFilePath, (char *)dbKey, len) != SOFTBUS_OK) {
208 LNN_LOGE(LNN_LEDGER, "write dbKey to file fail");
209 return SOFTBUS_FILE_ERR;
210 }
211 } while (false);
212 if (SoftBusReadFullFile(dbKeyFilePath, (char *)dbKey, len) != SOFTBUS_OK) {
213 LNN_LOGE(LNN_LEDGER, "read dbKey from file fail");
214 return SOFTBUS_FILE_ERR;
215 }
216 ret = DecryptStorageData(LNN_ENCRYPT_LEVEL_DE, dbKey, len);
217 if (ret != SOFTBUS_OK) {
218 LNN_LOGE(LNN_LEDGER, "decrypt dbKey fail");
219 return ret;
220 }
221 return SOFTBUS_OK;
222 }
223
EncryptDecisionDb(DbContext * ctx)224 static int32_t EncryptDecisionDb(DbContext *ctx)
225 {
226 uint8_t dbKey[LNN_DB_KEY_LEN] = {0};
227 int32_t ret = SOFTBUS_OK;
228
229 ret = GetDecisionDbKey(dbKey, sizeof(dbKey), false);
230 if (ret != SOFTBUS_OK) {
231 LNN_LOGE(LNN_LEDGER, "get decision dbKey fail");
232 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
233 return ret;
234 }
235 ret = EncryptedDb(ctx, dbKey, sizeof(dbKey));
236 if (ret != SOFTBUS_OK) {
237 LNN_LOGE(LNN_LEDGER, "encrypt decision db fail");
238 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
239 return ret;
240 }
241 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
242 return SOFTBUS_OK;
243 }
244
UpdateDecisionDbKey(DbContext * ctx)245 static int32_t UpdateDecisionDbKey(DbContext *ctx)
246 {
247 uint8_t dbKey[LNN_DB_KEY_LEN] = {0};
248
249 if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
250 LNN_LOGE(LNN_LEDGER, "update decision db de key fail");
251 return SOFTBUS_GENERATE_KEY_FAIL;
252 }
253 int32_t ret = GetDecisionDbKey(dbKey, sizeof(dbKey), true);
254 if (ret != SOFTBUS_OK) {
255 LNN_LOGE(LNN_LEDGER, "get decision dbKey fail");
256 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
257 return ret;
258 }
259 ret = UpdateDbPassword(ctx, dbKey, sizeof(dbKey));
260 if (ret != SOFTBUS_OK) {
261 LNN_LOGE(LNN_LEDGER, "encrypt decision db fail");
262 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
263 return ret;
264 }
265 LNN_LOGW(LNN_LEDGER, "update dbKey log for audit");
266 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
267 return SOFTBUS_OK;
268 }
269
CompleteUpdateTrustedDevInfo(void * para)270 static void CompleteUpdateTrustedDevInfo(void *para)
271 {
272 (void)para;
273
274 LNN_LOGD(LNN_LEDGER, "complete trusted dev info update enter");
275 LnnUpdateHeartbeatInfo(UPDATE_HB_NETWORK_INFO);
276 }
277
DeleteDeviceFromList(TrustedInfo * record)278 static int32_t DeleteDeviceFromList(TrustedInfo *record)
279 {
280 if (DeviceDbListLock() != SOFTBUS_OK) {
281 LNN_LOGE(LNN_LEDGER, "lock fail");
282 return SOFTBUS_LOCK_ERR;
283 }
284 DeviceDbInfo *item = NULL;
285 DeviceDbInfo *next = NULL;
286 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_deviceInfoList, DeviceDbInfo, node) {
287 if (strcmp(item->infoRecord.udid, record->udid) == 0 &&
288 item->infoRecord.userId == record->userId) {
289 char *anonyUdid = NULL;
290 Anonymize(record->udid, &anonyUdid);
291 LNN_LOGI(LNN_LEDGER, "delete device db from list. udid=%{public}s", AnonymizeWrapper(anonyUdid));
292 AnonymizeFree(anonyUdid);
293 ListDelete(&item->node);
294 SoftBusFree(item);
295 break;
296 }
297 }
298 DeviceDbListUnlock();
299 return SOFTBUS_OK;
300 }
301
InsertDeviceToList(TrustedInfo * record)302 static int32_t InsertDeviceToList(TrustedInfo *record)
303 {
304 if (DeviceDbListLock() != SOFTBUS_OK) {
305 LNN_LOGE(LNN_LEDGER, "lock fail");
306 return SOFTBUS_LOCK_ERR;
307 }
308 DeviceDbInfo *item = NULL;
309 LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
310 if (strcmp(item->infoRecord.udid, record->udid) == 0 &&
311 item->infoRecord.userId == record->userId) {
312 DeviceDbListUnlock();
313 return SOFTBUS_OK;
314 }
315 }
316 DeviceDbInfo *info = (DeviceDbInfo *)SoftBusCalloc(sizeof(DeviceDbInfo));
317 if (info == NULL) {
318 LNN_LOGE(LNN_BUILDER, "malloc info fail");
319 DeviceDbListUnlock();
320 return SOFTBUS_MALLOC_ERR;
321 }
322 info->infoRecord = *record;
323 ListNodeInsert(&g_deviceInfoList, &info->node);
324 DeviceDbListUnlock();
325 return SOFTBUS_OK;
326 }
327
LnnInsertSpecificTrustedDevInfo(const char * udid)328 int32_t LnnInsertSpecificTrustedDevInfo(const char *udid)
329 {
330 if (udid == NULL) {
331 LNN_LOGE(LNN_LEDGER, "invalid param");
332 return SOFTBUS_INVALID_PARAM;
333 }
334 TrustedInfo record;
335 record.userId = GetActiveOsAccountIds();
336 if (strcpy_s(record.udid, sizeof(record.udid), udid) != EOK) {
337 LNN_LOGE(LNN_LEDGER, "strcpy_s udid hash failed");
338 return SOFTBUS_STRCPY_ERR;
339 }
340 if (InsertDeviceToList(&record) == SOFTBUS_OK) {
341 (void)LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), CompleteUpdateTrustedDevInfo, NULL);
342 }
343 return SOFTBUS_OK;
344 }
345
LnnDeleteSpecificTrustedDevInfo(const char * udid,int32_t localUserId)346 int32_t LnnDeleteSpecificTrustedDevInfo(const char *udid, int32_t localUserId)
347 {
348 if (udid == NULL) {
349 LNN_LOGE(LNN_LEDGER, "invalid param");
350 return SOFTBUS_INVALID_PARAM;
351 }
352 TrustedInfo record;
353 record.userId = localUserId;
354 if (strcpy_s(record.udid, sizeof(record.udid), udid) != EOK) {
355 LNN_LOGE(LNN_LEDGER, "strcpy_s udid hash failed");
356 return SOFTBUS_STRCPY_ERR;
357 }
358 if (DeleteDeviceFromList(&record) == SOFTBUS_OK) {
359 (void)LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), CompleteUpdateTrustedDevInfo, NULL);
360 }
361 return SOFTBUS_OK;
362 }
363
GetAllDevNums(uint32_t * num,int32_t userId)364 static int32_t GetAllDevNums(uint32_t *num, int32_t userId)
365 {
366 DeviceDbInfo *item = NULL;
367 LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
368 if (item->infoRecord.userId == userId) {
369 (*num)++;
370 }
371 }
372 return SOFTBUS_OK;
373 }
374
LnnGetTrustedDevInfoFromDb(char ** udidArray,uint32_t * num)375 int32_t LnnGetTrustedDevInfoFromDb(char **udidArray, uint32_t *num)
376 {
377 LNN_CHECK_AND_RETURN_RET_LOGE((udidArray != NULL) && (num != NULL), SOFTBUS_INVALID_PARAM, LNN_LEDGER,
378 "invalid param");
379 int32_t userId = GetActiveOsAccountIds();
380 if (DeviceDbListLock() != SOFTBUS_OK) {
381 LNN_LOGE(LNN_LEDGER, "lock fail");
382 return SOFTBUS_LOCK_ERR;
383 }
384 GetAllDevNums(num, userId);
385 if (*num == 0) {
386 LNN_LOGD(LNN_LEDGER, "get none trusted dev info");
387 *udidArray = NULL;
388 DeviceDbListUnlock();
389 return SOFTBUS_OK;
390 }
391 *udidArray = (char *)SoftBusCalloc(*num * UDID_BUF_LEN);
392 if (*udidArray == NULL) {
393 LNN_LOGW(LNN_LEDGER, "malloc fail");
394 *num = 0;
395 DeviceDbListUnlock();
396 return SOFTBUS_MALLOC_ERR;
397 }
398 uint32_t cur = 0;
399 DeviceDbInfo *item = NULL;
400 LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
401 if (cur >= *num) {
402 break;
403 }
404 if (item->infoRecord.userId != userId) {
405 continue;
406 }
407 if (strcpy_s(*udidArray + cur * UDID_BUF_LEN, UDID_BUF_LEN, item->infoRecord.udid) != EOK) {
408 LNN_LOGE(LNN_LEDGER, "strcpy udid fail.");
409 continue;
410 }
411 cur++;
412 }
413 DeviceDbListUnlock();
414 return SOFTBUS_OK;
415 }
416
RecoveryTrustedDevInfoProcess(void)417 static int32_t RecoveryTrustedDevInfoProcess(void)
418 {
419 uint32_t num = 0;
420 TrustedInfo *trustedInfoArray = NULL;
421 if (SelectAllAcl(&trustedInfoArray, &num) != SOFTBUS_OK) {
422 LNN_LOGE(LNN_LEDGER, "get trusted dev info fail");
423 return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
424 }
425 LNN_LOGI(LNN_LEDGER, "get trusted relation num=%{public}u", num);
426 if (trustedInfoArray == NULL || num == 0) {
427 LNN_LOGE(LNN_LEDGER, "get none trusted dev info");
428 return SOFTBUS_OK;
429 }
430 if (DeviceDbListLock() != SOFTBUS_OK) {
431 LNN_LOGE(LNN_LEDGER, "db lock fail");
432 SoftBusFree(trustedInfoArray);
433 return SOFTBUS_LOCK_ERR;
434 }
435 for (uint32_t i = 0; i < num; i++) {
436 DeviceDbInfo *info = (DeviceDbInfo *)SoftBusCalloc(sizeof(DeviceDbInfo));
437 if (info == NULL) {
438 LNN_LOGE(LNN_BUILDER, "malloc info fail");
439 continue;
440 }
441 info->infoRecord = trustedInfoArray[i];
442 ListNodeInsert(&g_deviceInfoList, &info->node);
443 }
444 DeviceDbListUnlock();
445 SoftBusFree(trustedInfoArray);
446 return SOFTBUS_OK;
447 }
448
ClearRecoveryDeviceList(void)449 static void ClearRecoveryDeviceList(void)
450 {
451 if (DeviceDbListLock() != SOFTBUS_OK) {
452 LNN_LOGE(LNN_LEDGER, "db lock fail");
453 return;
454 }
455 DeviceDbInfo *item = NULL;
456 DeviceDbInfo *next = NULL;
457 LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_deviceInfoList, DeviceDbInfo, node) {
458 ListDelete(&item->node);
459 SoftBusFree(item);
460 }
461 DeviceDbListUnlock();
462 }
463
UpdateRecoveryDeviceInfoFromDb(void)464 int32_t UpdateRecoveryDeviceInfoFromDb(void)
465 {
466 if (!g_isDbListInit) {
467 return SOFTBUS_NETWORK_NOT_INIT;
468 }
469 ClearRecoveryDeviceList();
470 return RecoveryTrustedDevInfoProcess();
471 }
472
InitDbListDelay(void)473 int32_t InitDbListDelay(void)
474 {
475 if (!DeviceDbRecoveryInit()) {
476 LNN_LOGE(LNN_LEDGER, "init fail");
477 return SOFTBUS_NETWORK_DB_LOCK_INIT_FAILED;
478 }
479 ClearRecoveryDeviceList();
480 return RecoveryTrustedDevInfoProcess();
481 }
482
InitTrustedDevInfoTable(void)483 int32_t InitTrustedDevInfoTable(void)
484 {
485 bool isExist = false;
486 int32_t rc = SOFTBUS_NETWORK_INIT_TRUST_DEV_INFO_FAILED;
487 DbContext *ctx = NULL;
488
489 if (OpenDatabase(&ctx) != SOFTBUS_OK) {
490 LNN_LOGE(LNN_LEDGER, "open database failed");
491 return SOFTBUS_NETWORK_DATABASE_FAILED;
492 }
493 do {
494 if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
495 LNN_LOGE(LNN_LEDGER, "encrypt database failed");
496 break;
497 }
498 if (UpdateDecisionDbKey(ctx) != SOFTBUS_OK) {
499 LNN_LOGE(LNN_LEDGER, "update database dbKey failed");
500 break;
501 }
502 if (CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist) != SOFTBUS_OK) {
503 LNN_LOGE(LNN_LEDGER, "check table exist failed");
504 break;
505 }
506 if (!isExist && CreateTable(ctx, TABLE_TRUSTED_DEV_INFO) != SOFTBUS_OK) {
507 LNN_LOGE(LNN_LEDGER, "create trusted dev info table failed");
508 break;
509 }
510 rc = SOFTBUS_OK;
511 } while (false);
512 if (CloseDatabase(ctx) != SOFTBUS_OK) {
513 LNN_LOGE(LNN_LEDGER, "close database failed");
514 return SOFTBUS_NETWORK_DATABASE_FAILED;
515 }
516 return rc;
517 }
518
TryRecoveryTrustedDevInfoTable(void)519 static int32_t TryRecoveryTrustedDevInfoTable(void)
520 {
521 char dbKeyFilePath[SOFTBUS_MAX_PATH_LEN] = {0};
522
523 if (LnnGetFullStoragePath(LNN_FILE_ID_DB_KEY, dbKeyFilePath, SOFTBUS_MAX_PATH_LEN) != SOFTBUS_OK) {
524 LNN_LOGE(LNN_LEDGER, "get dbKey save path fail");
525 return SOFTBUS_NETWORK_GET_PATH_FAILED;
526 }
527 SoftBusRemoveFile(dbKeyFilePath);
528 SoftBusRemoveFile(DATABASE_NAME);
529 return InitTrustedDevInfoTable();
530 }
531
IsDeviceTrusted(const char * udid,int32_t userId)532 static bool IsDeviceTrusted(const char *udid, int32_t userId)
533 {
534 if (udid == NULL) {
535 return false;
536 }
537 DeviceDbInfo *item = NULL;
538 LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
539 if (strcmp(udid, item->infoRecord.udid) == 0 &&
540 item->infoRecord.userId == userId) {
541 return true;
542 }
543 }
544 return false;
545 }
546
LnnIsPotentialHomeGroup(const char * udid)547 bool LnnIsPotentialHomeGroup(const char *udid)
548 {
549 (void)udid;
550
551 LNN_LOGE(LNN_LEDGER, "check is potential home group not implemented");
552 return false;
553 }
554
LnnGenerateCeParams(bool isUnlocked)555 int32_t LnnGenerateCeParams(bool isUnlocked)
556 {
557 return LnnGenerateCeKeyByHuks(&g_ceKeyAlias, isUnlocked);
558 }
559
LnnCheckGenerateSoftBusKeyByHuks(void)560 int32_t LnnCheckGenerateSoftBusKeyByHuks(void)
561 {
562 if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
563 LNN_LOGE(LNN_LEDGER, "generate decision db huks de key fail");
564 return SOFTBUS_GENERATE_KEY_FAIL;
565 }
566 return SOFTBUS_OK;
567 }
568
LnnInitDecisionDbDelay(void)569 int32_t LnnInitDecisionDbDelay(void)
570 {
571 if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
572 LNN_LOGE(LNN_LEDGER, "generate decision db huks de key fail");
573 return SOFTBUS_GENERATE_KEY_FAIL;
574 }
575 if (InitTrustedDevInfoTable() != SOFTBUS_OK) {
576 LNN_LOGI(LNN_LEDGER, "try init trusted dev info table again");
577 return TryRecoveryTrustedDevInfoTable();
578 }
579 return SOFTBUS_OK;
580 }
581
LnnRemoveDb(void)582 void LnnRemoveDb(void)
583 {
584 SoftBusRemoveFile(DATABASE_NAME);
585 }
586
LnnFindDeviceUdidTrustedInfoFromDb(const char * deviceUdid)587 int32_t LnnFindDeviceUdidTrustedInfoFromDb(const char *deviceUdid)
588 {
589 if (deviceUdid == NULL) {
590 return SOFTBUS_INVALID_PARAM;
591 }
592 if (DeviceDbListLock() != SOFTBUS_OK) {
593 LNN_LOGE(LNN_LEDGER, "lock fail");
594 return SOFTBUS_LOCK_ERR;
595 }
596 int32_t userId = GetActiveOsAccountIds();
597 if (!IsDeviceTrusted(deviceUdid, userId)) {
598 LNN_LOGE(LNN_LEDGER, "not find trusted in db");
599 DeviceDbListUnlock();
600 return SOFTBUS_NOT_FIND;
601 }
602 DeviceDbListUnlock();
603 return SOFTBUS_OK;
604 }
605