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 
20 #include "anonymizer.h"
21 #include "bus_center_info_key.h"
22 #include "bus_center_manager.h"
23 #include "lnn_async_callback_utils.h"
24 #include "lnn_file_utils.h"
25 #include "lnn_heartbeat_ctrl.h"
26 #include "lnn_huks_utils.h"
27 #include "lnn_log.h"
28 #include "sqlite3_utils.h"
29 
30 #include "softbus_adapter_crypto.h"
31 #include "softbus_adapter_file.h"
32 #include "softbus_adapter_mem.h"
33 #include "softbus_common.h"
34 #include "softbus_def.h"
35 #include "softbus_errcode.h"
36 #include "softbus_utils.h"
37 
38 typedef struct {
39     ListNode node;
40     TrustedDevInfoRecord infoRecord;
41 } DeviceDbInfo;
42 
43 static ListNode g_deviceInfoList = { &g_deviceInfoList, &g_deviceInfoList };
44 static SoftBusMutex g_deviceDbMutex;
45 static SoftBusMutex g_dbMutex;
46 
47 static bool g_isDbListInit = false;
48 
49 #define LNN_DB_KEY_LEN 1024
50 #define LNN_DB_KEY_AILAS "dsoftbus_decision_db_key_alias"
51 
52 static struct HksBlob g_keyAlias = { sizeof(LNN_DB_KEY_AILAS), (uint8_t *)LNN_DB_KEY_AILAS };
53 static struct HksBlob g_ceKeyAlias = { sizeof(LNN_DB_KEY_AILAS), (uint8_t *)LNN_DB_KEY_AILAS };
54 
DeviceDbRecoveryInit(void)55 static bool DeviceDbRecoveryInit(void)
56 {
57     if (SoftBusMutexInit(&g_deviceDbMutex, NULL) != SOFTBUS_OK) {
58         LNN_LOGE(LNN_LEDGER, "g_deviceDbMutex init fail");
59         return false;
60     }
61     if (SoftBusMutexInit(&g_dbMutex, NULL) != SOFTBUS_OK) {
62         SoftBusMutexDestroy(&g_deviceDbMutex);
63         LNN_LOGE(LNN_LEDGER, "g_isDbMutexInit init fail");
64         return false;
65     }
66     g_isDbListInit = true;
67     return true;
68 }
69 
DeviceDbListLock(void)70 static int32_t DeviceDbListLock(void)
71 {
72     if (!g_isDbListInit) {
73         if (!DeviceDbRecoveryInit()) {
74             return SOFTBUS_ERR;
75         }
76     }
77     return SoftBusMutexLock(&g_deviceDbMutex);
78 }
79 
DeviceDbListUnlock(void)80 static void DeviceDbListUnlock(void)
81 {
82     if (!g_isDbListInit) {
83         (void)DeviceDbRecoveryInit();
84         return;
85     }
86     (void)SoftBusMutexUnlock(&g_deviceDbMutex);
87 }
88 
DbLock(void)89 static int32_t DbLock(void)
90 {
91     if (!g_isDbListInit) {
92         if (!DeviceDbRecoveryInit()) {
93             LNN_LOGE(LNN_LEDGER, "g_isDbListInit init fail");
94             return SOFTBUS_ERR;
95         }
96     }
97     return SoftBusMutexLock(&g_dbMutex);
98 }
99 
DbUnlock(void)100 static void DbUnlock(void)
101 {
102     if (!g_isDbListInit) {
103         if (!DeviceDbRecoveryInit()) {
104             LNN_LOGE(LNN_LEDGER, "g_isDbListInit init fail");
105             return;
106         }
107     }
108     (void)SoftBusMutexUnlock(&g_dbMutex);
109 }
110 
EncryptStorageData(LnnEncryptDataLevel level,uint8_t * dbKey,uint32_t len)111 int32_t EncryptStorageData(LnnEncryptDataLevel level, uint8_t *dbKey, uint32_t len)
112 {
113     struct HksBlob plainData = { 0 };
114     struct HksBlob encryptData = { 0 };
115     if (level < LNN_ENCRYPT_LEVEL_DE || level > LNN_ENCRYPT_LEVEL_ECE) {
116         LNN_LOGE(LNN_LEDGER, "invalid param, level=%{public}u", level);
117         return SOFTBUS_MEM_ERR;
118     }
119     encryptData.data = (uint8_t *)SoftBusCalloc(len);
120     if (encryptData.data == NULL) {
121         LNN_LOGE(LNN_LEDGER, "calloc encrypt dbKey fail");
122         return SOFTBUS_MEM_ERR;
123     }
124     LNN_LOGI(LNN_LEDGER, "Encrypt data, level=%{public}u len=%{public}u", level, len);
125     plainData.size = len;
126     plainData.data = dbKey;
127     int32_t ret = SOFTBUS_OK;
128     if (level == LNN_ENCRYPT_LEVEL_CE) {
129         ret = LnnCeEncryptDataByHuks(&g_ceKeyAlias, &plainData, &encryptData);
130     } else {
131         ret = LnnEncryptDataByHuks(&g_keyAlias, &plainData, &encryptData);
132     }
133     if (ret != SOFTBUS_OK) {
134         LNN_LOGE(LNN_LEDGER, "encrypt dbKey by huks fail, ret=%{public}d", ret);
135         (void)memset_s(plainData.data, len, 0x0, len);
136         SoftBusFree(encryptData.data);
137         return SOFTBUS_ERR;
138     }
139     LNN_LOGW(LNN_LEDGER, "encrypt dbKey log for audit");
140     (void)memset_s(plainData.data, len, 0x0, len);
141     if (memcpy_s(dbKey, len, encryptData.data, len) != SOFTBUS_OK) {
142         LNN_LOGE(LNN_LEDGER, "memcpy_s dbKey fail");
143         SoftBusFree(encryptData.data);
144         return SOFTBUS_MEM_ERR;
145     }
146     SoftBusFree(encryptData.data);
147     return SOFTBUS_OK;
148 }
149 
DecryptStorageData(LnnEncryptDataLevel level,uint8_t * dbKey,uint32_t len)150 int32_t DecryptStorageData(LnnEncryptDataLevel level, uint8_t *dbKey, uint32_t len)
151 {
152     struct HksBlob encryptData = { 0 };
153     struct HksBlob decryptData = { 0 };
154     if (level < LNN_ENCRYPT_LEVEL_DE || level > LNN_ENCRYPT_LEVEL_ECE) {
155         LNN_LOGE(LNN_LEDGER, "invalid param, level=%{public}u", level);
156         return SOFTBUS_MEM_ERR;
157     }
158     decryptData.data = (uint8_t *)SoftBusCalloc(len);
159     if (decryptData.data == NULL) {
160         LNN_LOGE(LNN_LEDGER, "calloc decrypt dbKey fail");
161         return SOFTBUS_MEM_ERR;
162     }
163     encryptData.size = len;
164     encryptData.data = dbKey;
165     int32_t ret;
166     do {
167         if (level == LNN_ENCRYPT_LEVEL_CE) {
168             ret = LnnCeDecryptDataByHuks(&g_ceKeyAlias, &encryptData, &decryptData);
169         } else {
170             ret = LnnDecryptDataByHuks(&g_keyAlias, &encryptData, &decryptData);
171         }
172         if (ret != SOFTBUS_OK) {
173             LNN_LOGE(LNN_LEDGER, "decrypt dbKey by huks fail, ret=%{public}d", ret);
174             break;
175         }
176         if (memcpy_s(dbKey, len, decryptData.data, decryptData.size) != SOFTBUS_OK) {
177             LNN_LOGE(LNN_LEDGER, "memcpy_s dbKey fail");
178             ret = SOFTBUS_MEM_ERR;
179             break;
180         }
181         ret = SOFTBUS_OK;
182     } while (false);
183     (void)memset_s(decryptData.data, decryptData.size, 0x0, decryptData.size);
184     SoftBusFree(decryptData.data);
185     return ret;
186 }
187 
GetDecisionDbKey(uint8_t * dbKey,uint32_t len,bool isUpdate)188 static int32_t GetDecisionDbKey(uint8_t *dbKey, uint32_t len, bool isUpdate)
189 {
190     char dbKeyFilePath[SOFTBUS_MAX_PATH_LEN] = {0};
191 
192     if (LnnGetFullStoragePath(LNN_FILE_ID_DB_KEY, dbKeyFilePath, SOFTBUS_MAX_PATH_LEN) != SOFTBUS_OK) {
193         LNN_LOGE(LNN_LEDGER, "get dbKey save path fail");
194         return SOFTBUS_ERR;
195     }
196     do {
197         if (!isUpdate && SoftBusAccessFile(dbKeyFilePath, SOFTBUS_F_OK) == SOFTBUS_OK) {
198             LNN_LOGD(LNN_LEDGER, "dbKey file is exist");
199             break;
200         }
201         if (LnnGenerateRandomByHuks(dbKey, len) != SOFTBUS_OK) {
202             LNN_LOGE(LNN_LEDGER, "generate random dbKey fail");
203             return SOFTBUS_ERR;
204         }
205         if (EncryptStorageData(LNN_ENCRYPT_LEVEL_DE, dbKey, len) != SOFTBUS_OK) {
206             LNN_LOGE(LNN_LEDGER, "encrypt dbKey fail");
207             return SOFTBUS_ERR;
208         }
209         if (SoftBusWriteFile(dbKeyFilePath, (char *)dbKey, len) != SOFTBUS_OK) {
210             LNN_LOGE(LNN_LEDGER, "write dbKey to file fail");
211             return SOFTBUS_ERR;
212         }
213     } while (false);
214     if (SoftBusReadFullFile(dbKeyFilePath, (char *)dbKey, len) != SOFTBUS_OK) {
215         LNN_LOGE(LNN_LEDGER, "read dbKey from file fail");
216         return SOFTBUS_ERR;
217     }
218     if (DecryptStorageData(LNN_ENCRYPT_LEVEL_DE, dbKey, len) != SOFTBUS_OK) {
219         LNN_LOGE(LNN_LEDGER, "decrypt dbKey fail");
220         return SOFTBUS_ERR;
221     }
222     return SOFTBUS_OK;
223 }
224 
EncryptDecisionDb(DbContext * ctx)225 static int32_t EncryptDecisionDb(DbContext *ctx)
226 {
227     uint8_t dbKey[LNN_DB_KEY_LEN] = {0};
228 
229     if (GetDecisionDbKey(dbKey, sizeof(dbKey), false) != SOFTBUS_OK) {
230         LNN_LOGE(LNN_LEDGER, "get decision dbKey fail");
231         (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
232         return SOFTBUS_ERR;
233     }
234     if (EncryptedDb(ctx, dbKey, sizeof(dbKey)) != SOFTBUS_OK) {
235         LNN_LOGE(LNN_LEDGER, "encrypt decision db fail");
236         (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
237         return SOFTBUS_ERR;
238     }
239     (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
240     return SOFTBUS_OK;
241 }
242 
UpdateDecisionDbKey(DbContext * ctx)243 static int32_t UpdateDecisionDbKey(DbContext *ctx)
244 {
245     uint8_t dbKey[LNN_DB_KEY_LEN] = {0};
246 
247     if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
248         LNN_LOGE(LNN_LEDGER, "update decision db de key fail");
249         return SOFTBUS_ERR;
250     }
251     if (LnnGenerateCeKeyByHuks(&g_ceKeyAlias) != SOFTBUS_OK) {
252         LNN_LOGE(LNN_LEDGER, "update decision db ce key fail");
253         return SOFTBUS_ERR;
254     }
255     if (GetDecisionDbKey(dbKey, sizeof(dbKey), true) != SOFTBUS_OK) {
256         LNN_LOGE(LNN_LEDGER, "get decision dbKey fail");
257         (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
258         return SOFTBUS_ERR;
259     }
260     if (UpdateDbPassword(ctx, dbKey, sizeof(dbKey)) != SOFTBUS_OK) {
261         LNN_LOGE(LNN_LEDGER, "encrypt decision db fail");
262         (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
263         return SOFTBUS_ERR;
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 
BuildTrustedDevInfoRecord(const char * udid,TrustedDevInfoRecord * record)270 static int32_t BuildTrustedDevInfoRecord(const char *udid, TrustedDevInfoRecord *record)
271 {
272     uint8_t accountHash[SHA_256_HASH_LEN] = {0};
273     char accountHexHash[SHA_256_HEX_HASH_LEN] = {0};
274 
275     if (udid == NULL || record == NULL) {
276         LNN_LOGE(LNN_LEDGER, "invalid param");
277         return SOFTBUS_INVALID_PARAM;
278     }
279     if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
280         LNN_LOGE(LNN_LEDGER, "get local account hash failed");
281         return SOFTBUS_ERR;
282     }
283     if (memset_s(record, sizeof(TrustedDevInfoRecord), 0, sizeof(TrustedDevInfoRecord)) != EOK) {
284         LNN_LOGE(LNN_LEDGER, "memset_s record failed");
285         return SOFTBUS_MEM_ERR;
286     }
287     if (ConvertBytesToHexString(accountHexHash, SHA_256_HEX_HASH_LEN, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
288         LNN_LOGE(LNN_LEDGER, "convert accountHash failed");
289         return SOFTBUS_ERR;
290     }
291     if (strcpy_s(record->accountHexHash, sizeof(record->accountHexHash), accountHexHash) != EOK) {
292         LNN_LOGE(LNN_LEDGER, "memcpy_s account hash failed");
293         return SOFTBUS_MEM_ERR;
294     }
295     if (strcpy_s(record->udid, sizeof(record->udid), udid) != EOK) {
296         LNN_LOGE(LNN_LEDGER, "memcpy_s udid hash failed");
297         return SOFTBUS_MEM_ERR;
298     }
299     return SOFTBUS_OK;
300 }
301 
CompleteUpdateTrustedDevInfo(void * para)302 static void CompleteUpdateTrustedDevInfo(void *para)
303 {
304     (void)para;
305 
306     LNN_LOGD(LNN_LEDGER, "complete trusted dev info update enter");
307     LnnUpdateHeartbeatInfo(UPDATE_HB_NETWORK_INFO);
308 }
309 
InsertTrustedDevInfoRecord(void * param)310 static void InsertTrustedDevInfoRecord(void *param)
311 {
312     DbContext *ctx = NULL;
313     TrustedDevInfoRecord record;
314 
315     char *udid = (char *)param;
316     if (udid == NULL) {
317         LNN_LOGE(LNN_LEDGER, "invalid param");
318         return;
319     }
320     if (BuildTrustedDevInfoRecord(udid, &record) != SOFTBUS_OK) {
321         LNN_LOGE(LNN_LEDGER, "build insert trusted dev info record failed");
322         SoftBusFree(udid);
323         return;
324     }
325     if (DbLock() != SOFTBUS_OK) {
326         LNN_LOGE(LNN_LEDGER, "lock fail");
327         SoftBusFree(udid);
328         return;
329     }
330     if (OpenDatabase(&ctx) != SOFTBUS_OK) {
331         LNN_LOGE(LNN_LEDGER, "open database failed");
332         SoftBusFree(udid);
333         DbUnlock();
334         return;
335     }
336     do {
337         if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
338             LNN_LOGE(LNN_LEDGER, "encrypt database failed");
339             break;
340         }
341         char *anonyUdid = NULL;
342         Anonymize(udid, &anonyUdid);
343         LNN_LOGI(LNN_LEDGER, "insert udid to trusted dev info table. udid=%{public}s", anonyUdid);
344         AnonymizeFree(anonyUdid);
345         if (InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&record) == SOFTBUS_OK) {
346             (void)LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), CompleteUpdateTrustedDevInfo, NULL);
347         }
348     } while (false);
349     if (CloseDatabase(ctx) != SOFTBUS_OK) {
350         LNN_LOGE(LNN_LEDGER, "close database failed");
351         DbUnlock();
352         SoftBusFree(udid);
353         return;
354     }
355     DbUnlock();
356     SoftBusFree(udid);
357 }
358 
RemoveTrustedDevInfoRecord(void * param)359 static void RemoveTrustedDevInfoRecord(void *param)
360 {
361     DbContext *ctx = NULL;
362     TrustedDevInfoRecord record;
363 
364     char *udid = (char *)param;
365     if (udid == NULL) {
366         LNN_LOGE(LNN_LEDGER, "invalid param");
367         return;
368     }
369     if (BuildTrustedDevInfoRecord(udid, &record) != SOFTBUS_OK) {
370         LNN_LOGE(LNN_LEDGER, "build remove trusted dev info record failed");
371         SoftBusFree(udid);
372         return;
373     }
374     if (DbLock() != SOFTBUS_OK) {
375         LNN_LOGE(LNN_LEDGER, "lock fail");
376         SoftBusFree(udid);
377         return;
378     }
379     if (OpenDatabase(&ctx) != SOFTBUS_OK) {
380         LNN_LOGE(LNN_LEDGER, "open database failed");
381         SoftBusFree(udid);
382         DbUnlock();
383         return;
384     }
385     do {
386         if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
387             LNN_LOGE(LNN_LEDGER, "encrypt database failed");
388             break;
389         }
390         if (RemoveRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&record) == SOFTBUS_OK) {
391             (void)LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), CompleteUpdateTrustedDevInfo, NULL);
392         }
393     } while (false);
394     if (CloseDatabase(ctx) != SOFTBUS_OK) {
395         LNN_LOGE(LNN_LEDGER, "close database failed");
396     }
397     DbUnlock();
398     char *anonyUdid = NULL;
399     Anonymize(udid, &anonyUdid);
400     LNN_LOGI(LNN_LEDGER, "remove udid from trusted dev info table. udid=%{public}s", anonyUdid);
401     AnonymizeFree(anonyUdid);
402     SoftBusFree(udid);
403 }
404 
DeleteDeviceFromList(TrustedDevInfoRecord * record)405 static void DeleteDeviceFromList(TrustedDevInfoRecord *record)
406 {
407     if (DeviceDbListLock() != SOFTBUS_OK) {
408         LNN_LOGE(LNN_LEDGER, "lock fail");
409         return;
410     }
411     DeviceDbInfo *item = NULL;
412     DeviceDbInfo *next = NULL;
413     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_deviceInfoList, DeviceDbInfo, node) {
414         if (strcmp(item->infoRecord.accountHexHash, record->accountHexHash) == 0 &&
415             strcmp(item->infoRecord.udid, record->udid) == 0) {
416             char *anonyUdid = NULL;
417             Anonymize(record->udid, &anonyUdid);
418             LNN_LOGI(LNN_LEDGER, "delete device db from list. udid=%{public}s", anonyUdid);
419             AnonymizeFree(anonyUdid);
420             ListDelete(&item->node);
421             SoftBusFree(item);
422             break;
423         }
424     }
425     DeviceDbListUnlock();
426 }
427 
InsertDeviceToList(TrustedDevInfoRecord * record)428 static void InsertDeviceToList(TrustedDevInfoRecord *record)
429 {
430     if (DeviceDbListLock() != SOFTBUS_OK) {
431         LNN_LOGE(LNN_LEDGER, "lock fail");
432         return;
433     }
434     DeviceDbInfo *item = NULL;
435     LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
436         if (strcmp(item->infoRecord.accountHexHash, record->accountHexHash) == 0 &&
437             strcmp(item->infoRecord.udid, record->udid) == 0) {
438             DeviceDbListUnlock();
439             return;
440         }
441     }
442     DeviceDbInfo *info = (DeviceDbInfo *)SoftBusCalloc(sizeof(DeviceDbInfo));
443     if (info == NULL) {
444         LNN_LOGE(LNN_BUILDER, "malloc info fail");
445         DeviceDbListUnlock();
446         return;
447     }
448     info->infoRecord = *record;
449     ListNodeInsert(&g_deviceInfoList, &info->node);
450     DeviceDbListUnlock();
451 }
452 
LnnInsertSpecificTrustedDevInfo(const char * udid)453 int32_t LnnInsertSpecificTrustedDevInfo(const char *udid)
454 {
455     char *dupUdid = NULL;
456 
457     if (udid == NULL) {
458         LNN_LOGE(LNN_LEDGER, "invalid param");
459         return SOFTBUS_INVALID_PARAM;
460     }
461     TrustedDevInfoRecord record;
462     int32_t ret = BuildTrustedDevInfoRecord(udid, &record);
463     if (ret != SOFTBUS_OK) {
464         LNN_LOGE(LNN_LEDGER, "build insert trusted dev info record failed");
465         return ret;
466     }
467     InsertDeviceToList(&record);
468     dupUdid = (char *)SoftBusMalloc(UDID_BUF_LEN);
469     if (dupUdid == NULL) {
470         LNN_LOGE(LNN_LEDGER, "malloc dupUdid failed");
471         return SOFTBUS_MALLOC_ERR;
472     }
473     if (strcpy_s(dupUdid, UDID_BUF_LEN, udid) != EOK) {
474         LNN_LOGE(LNN_LEDGER, "strcpy_s dupUdid failed");
475         SoftBusFree(dupUdid);
476         return SOFTBUS_ERR;
477     }
478     if (LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), InsertTrustedDevInfoRecord,
479         (void *)dupUdid) != SOFTBUS_OK) {
480         LNN_LOGE(LNN_LEDGER, "async call insert trusted dev info failed");
481         SoftBusFree(dupUdid);
482         return SOFTBUS_ERR;
483     }
484     return SOFTBUS_OK;
485 }
486 
LnnDeleteSpecificTrustedDevInfo(const char * udid)487 int32_t LnnDeleteSpecificTrustedDevInfo(const char *udid)
488 {
489     char *dupUdid = NULL;
490 
491     if (udid == NULL) {
492         LNN_LOGE(LNN_LEDGER, "invalid param");
493         return SOFTBUS_INVALID_PARAM;
494     }
495     TrustedDevInfoRecord record;
496     int32_t ret = BuildTrustedDevInfoRecord(udid, &record);
497     if (ret != SOFTBUS_OK) {
498         LNN_LOGE(LNN_LEDGER, "build delete trusted dev info record failed");
499         return ret;
500     }
501     DeleteDeviceFromList(&record);
502     dupUdid = (char *)SoftBusMalloc(UDID_BUF_LEN);
503     if (dupUdid == NULL) {
504         LNN_LOGE(LNN_LEDGER, "malloc dupUdid failed");
505         return SOFTBUS_MALLOC_ERR;
506     }
507     if (strcpy_s(dupUdid, UDID_BUF_LEN, udid) != EOK) {
508         LNN_LOGE(LNN_LEDGER, "strcpy_s dupUdid failed");
509         SoftBusFree(dupUdid);
510         return SOFTBUS_ERR;
511     }
512     if (LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), RemoveTrustedDevInfoRecord,
513         (void *)dupUdid) != SOFTBUS_OK) {
514         LNN_LOGE(LNN_LEDGER, "async call remove trusted dev info failed");
515         SoftBusFree(dupUdid);
516         return SOFTBUS_ERR;
517     }
518     return SOFTBUS_OK;
519 }
520 
GetTrustedDevInfoRecord(DbContext * ctx,const char * accountHexHash,char ** udidArray,uint32_t * num)521 static int32_t GetTrustedDevInfoRecord(DbContext *ctx, const char *accountHexHash, char **udidArray, uint32_t *num)
522 {
523     if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
524         LNN_LOGE(LNN_LEDGER, "encrypt database failed");
525         *udidArray = NULL;
526         *num = 0;
527         return SOFTBUS_ERR;
528     }
529     *((int32_t *)num) = GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)accountHexHash);
530     if (*num == 0) {
531         LNN_LOGW(LNN_LEDGER, "get none trusted dev info");
532         *udidArray = NULL;
533         return SOFTBUS_OK;
534     }
535     *udidArray = (char *)SoftBusCalloc(*num * UDID_BUF_LEN);
536     if (*udidArray == NULL) {
537         *num = 0;
538         return SOFTBUS_MALLOC_ERR;
539     }
540     if (QueryRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)accountHexHash,
541         (uint8_t **)udidArray, *((int32_t *)num)) != SOFTBUS_OK) {
542         LNN_LOGE(LNN_LEDGER, "query udidArray failed");
543         SoftBusFree(*udidArray);
544         *udidArray = NULL;
545         *num = 0;
546         return SOFTBUS_ERR;
547     }
548     return SOFTBUS_OK;
549 }
550 
GetLocalAccountHexHash(char * accountHexHash)551 static int32_t GetLocalAccountHexHash(char *accountHexHash)
552 {
553     uint8_t accountHash[SHA_256_HASH_LEN] = {0};
554     if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
555         LNN_LOGE(LNN_LEDGER, "get local account hash failed");
556         return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
557     }
558     if (ConvertBytesToHexString(accountHexHash, SHA_256_HEX_HASH_LEN, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
559         LNN_LOGE(LNN_LEDGER, "convert accountHash failed");
560         return SOFTBUS_MEM_ERR;
561     }
562     return SOFTBUS_OK;
563 }
564 
GetAllDevNums(char * accountHexHash,uint32_t * num)565 static int32_t GetAllDevNums(char *accountHexHash, uint32_t *num)
566 {
567     DeviceDbInfo *item = NULL;
568     LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
569         if (strcmp(accountHexHash, item->infoRecord.accountHexHash) == 0) {
570             (*num)++;
571         }
572     }
573     return SOFTBUS_OK;
574 }
575 
LnnGetTrustedDevInfoFromDb(char ** udidArray,uint32_t * num)576 int32_t LnnGetTrustedDevInfoFromDb(char **udidArray, uint32_t *num)
577 {
578     char accountHexHash[SHA_256_HEX_HASH_LEN] = {0};
579     if (udidArray == NULL || num == NULL) {
580         return SOFTBUS_INVALID_PARAM;
581     }
582     if (GetLocalAccountHexHash(accountHexHash) != SOFTBUS_OK) {
583         LNN_LOGE(LNN_LEDGER, "get local account hash failed");
584         return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
585     }
586     if (DeviceDbListLock() != SOFTBUS_OK) {
587         LNN_LOGE(LNN_LEDGER, "lock fail");
588         return SOFTBUS_LOCK_ERR;
589     }
590     int32_t ret = GetAllDevNums(accountHexHash, num);
591     if (ret != SOFTBUS_OK) {
592         LNN_LOGE(LNN_LEDGER, "get all dev num fail");
593         DeviceDbListUnlock();
594         return ret;
595     }
596     if (*num == 0) {
597         LNN_LOGW(LNN_LEDGER, "get none trusted dev info");
598         *udidArray = NULL;
599         DeviceDbListUnlock();
600         return SOFTBUS_OK;
601     }
602     *udidArray = (char *)SoftBusCalloc(*num * UDID_BUF_LEN);
603     if (*udidArray == NULL) {
604         LNN_LOGW(LNN_LEDGER, "malloc fail");
605         *num = 0;
606         DeviceDbListUnlock();
607         return SOFTBUS_MALLOC_ERR;
608     }
609     uint32_t cur = 0;
610     DeviceDbInfo *item = NULL;
611     LIST_FOR_EACH_ENTRY(item, &g_deviceInfoList, DeviceDbInfo, node) {
612         if (cur >= *num) {
613             break;
614         }
615         if (strcmp(accountHexHash, item->infoRecord.accountHexHash) != 0) {
616             continue;
617         }
618         if (strcpy_s(*udidArray + cur * UDID_BUF_LEN, UDID_BUF_LEN, item->infoRecord.udid) != EOK) {
619             LNN_LOGE(LNN_LEDGER, "strcpy udid fail.");
620             continue;
621         }
622         cur++;
623     }
624     DeviceDbListUnlock();
625     return SOFTBUS_OK;
626 }
627 
GetTrustedDevInfoFromDb(char ** udidArray,uint32_t * num)628 static int32_t GetTrustedDevInfoFromDb(char **udidArray, uint32_t *num)
629 {
630     char accountHexHash[SHA_256_HEX_HASH_LEN] = {0};
631     DbContext *ctx = NULL;
632 
633     if (udidArray == NULL || num == NULL) {
634         return SOFTBUS_INVALID_PARAM;
635     }
636     if (GetLocalAccountHexHash(accountHexHash) != SOFTBUS_OK) {
637         LNN_LOGE(LNN_LEDGER, "get local account hash failed");
638         return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
639     }
640     if (DbLock() != SOFTBUS_OK) {
641         LNN_LOGE(LNN_LEDGER, "lock fail");
642         return SOFTBUS_LOCK_ERR;
643     }
644     if (OpenDatabase(&ctx) != SOFTBUS_OK) {
645         LNN_LOGE(LNN_LEDGER, "open database failed");
646         DbUnlock();
647         return SOFTBUS_ERR;
648     }
649     int32_t rc = GetTrustedDevInfoRecord(ctx, accountHexHash, udidArray, num);
650     if (rc != SOFTBUS_OK) {
651         LNN_LOGE(LNN_LEDGER, "get trusted dev info failed");
652     }
653     if (CloseDatabase(ctx) != SOFTBUS_OK) {
654         LNN_LOGE(LNN_LEDGER, "close database failed");
655         DbUnlock();
656         SoftBusFree(*udidArray);
657         *udidArray = NULL;
658         *num = 0;
659         return SOFTBUS_ERR;
660     }
661     DbUnlock();
662     return rc;
663 }
664 
RecoveryTrustedDevInfo(void)665 static int32_t RecoveryTrustedDevInfo(void)
666 {
667     uint32_t num = 0;
668     char *udidArray = NULL;
669     char accountHexHash[SHA_256_HEX_HASH_LEN] = {0};
670     if (GetTrustedDevInfoFromDb(&udidArray, &num) != SOFTBUS_OK) {
671         LNN_LOGE(LNN_LEDGER, "get trusted dev info fail");
672         return SOFTBUS_NETWORK_GET_DEVICE_INFO_ERR;
673     }
674     LNN_LOGI(LNN_LEDGER, "get trusted relation num=%{public}u", num);
675     if (udidArray == NULL || num == 0) {
676         LNN_LOGE(LNN_LEDGER, "get none trusted dev info");
677         return SOFTBUS_OK;
678     }
679     if (GetLocalAccountHexHash(accountHexHash) != SOFTBUS_OK) {
680         LNN_LOGE(LNN_LEDGER, "get local account hash failed");
681         SoftBusFree(udidArray);
682         return SOFTBUS_NETWORK_GET_NODE_INFO_ERR;
683     }
684     if (DeviceDbListLock() != SOFTBUS_OK) {
685         LNN_LOGE(LNN_LEDGER, "db lock fail");
686         SoftBusFree(udidArray);
687         return SOFTBUS_LOCK_ERR;
688     }
689     for (uint32_t i = 0; i < num; i++) {
690         char udidStr[UDID_BUF_LEN] = { 0 };
691         DeviceDbInfo *info = (DeviceDbInfo *)SoftBusCalloc(sizeof(DeviceDbInfo));
692         if (info == NULL) {
693             LNN_LOGE(LNN_BUILDER, "malloc info fail");
694             continue;
695         }
696         if (memcpy_s(udidStr, UDID_BUF_LEN, udidArray + i * UDID_BUF_LEN, UDID_BUF_LEN) != EOK ||
697             memcpy_s(info->infoRecord.udid, UDID_BUF_LEN, udidStr, UDID_BUF_LEN) != EOK ||
698             memcpy_s(info->infoRecord.accountHexHash, SHA_256_HEX_HASH_LEN, accountHexHash,
699                 SHA_256_HEX_HASH_LEN) != EOK) {
700             LNN_LOGE(LNN_LEDGER, "udid str cpy fail.");
701             DeviceDbListUnlock();
702             SoftBusFree(info);
703             SoftBusFree(udidArray);
704             return SOFTBUS_MEM_ERR;
705         }
706         ListNodeInsert(&g_deviceInfoList, &info->node);
707     }
708     DeviceDbListUnlock();
709     SoftBusFree(udidArray);
710     return SOFTBUS_OK;
711 }
712 
ClearRecoveryDeviceList(void)713 static void ClearRecoveryDeviceList(void)
714 {
715     if (DeviceDbListLock() != SOFTBUS_OK) {
716         LNN_LOGE(LNN_LEDGER, "db lock fail");
717         return;
718     }
719     DeviceDbInfo *item = NULL;
720     DeviceDbInfo *next = NULL;
721     LIST_FOR_EACH_ENTRY_SAFE(item, next, &g_deviceInfoList, DeviceDbInfo, node) {
722         ListDelete(&item->node);
723         SoftBusFree(item);
724     }
725     DeviceDbListUnlock();
726 }
727 
UpdateRecoveryDeviceInfoFromDb(void)728 int32_t UpdateRecoveryDeviceInfoFromDb(void)
729 {
730     if (!g_isDbListInit) {
731         return SOFTBUS_NETWORK_NOT_INIT;
732     }
733     ClearRecoveryDeviceList();
734     return RecoveryTrustedDevInfo();
735 }
736 
InitDbList(void)737 static int32_t InitDbList(void)
738 {
739     if (!DeviceDbRecoveryInit()) {
740         LNN_LOGE(LNN_LEDGER, "init fail");
741         return SOFTBUS_ERR;
742     }
743     ClearRecoveryDeviceList();
744     return RecoveryTrustedDevInfo();
745 }
746 
InitTrustedDevInfoTable(void)747 static int32_t InitTrustedDevInfoTable(void)
748 {
749     bool isExist = false;
750     int32_t rc = SOFTBUS_ERR;
751     DbContext *ctx = NULL;
752 
753     if (OpenDatabase(&ctx) != SOFTBUS_OK) {
754         LNN_LOGE(LNN_LEDGER, "open database failed");
755         return SOFTBUS_ERR;
756     }
757     do {
758         if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
759             LNN_LOGE(LNN_LEDGER, "encrypt database failed");
760             break;
761         }
762         if (UpdateDecisionDbKey(ctx) != SOFTBUS_OK) {
763             LNN_LOGE(LNN_LEDGER, "update database dbKey failed");
764             break;
765         }
766         if (CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist) != SOFTBUS_OK) {
767             LNN_LOGE(LNN_LEDGER, "check table exist failed");
768             break;
769         }
770         if (!isExist && CreateTable(ctx, TABLE_TRUSTED_DEV_INFO) != SOFTBUS_OK) {
771             LNN_LOGE(LNN_LEDGER, "create trusted dev info table failed");
772             break;
773         }
774         rc = SOFTBUS_OK;
775     } while (false);
776     if (CloseDatabase(ctx) != SOFTBUS_OK) {
777         LNN_LOGE(LNN_LEDGER, "close database failed");
778         return SOFTBUS_ERR;
779     }
780     if (rc == SOFTBUS_OK) {
781         rc = InitDbList();
782     }
783     return rc;
784 }
785 
TryRecoveryTrustedDevInfoTable(void)786 static int32_t TryRecoveryTrustedDevInfoTable(void)
787 {
788     char dbKeyFilePath[SOFTBUS_MAX_PATH_LEN] = {0};
789 
790     if (LnnGetFullStoragePath(LNN_FILE_ID_DB_KEY, dbKeyFilePath, SOFTBUS_MAX_PATH_LEN) != SOFTBUS_OK) {
791         LNN_LOGE(LNN_LEDGER, "get dbKey save path fail");
792         return SOFTBUS_ERR;
793     }
794     SoftBusRemoveFile(dbKeyFilePath);
795     SoftBusRemoveFile(DATABASE_NAME);
796     return InitTrustedDevInfoTable();
797 }
798 
LnnIsPotentialHomeGroup(const char * udid)799 bool LnnIsPotentialHomeGroup(const char *udid)
800 {
801     (void)udid;
802 
803     LNN_LOGE(LNN_LEDGER, "check is potential home group not implemented");
804     return false;
805 }
806 
LnnGenerateCeParams(void)807 int32_t LnnGenerateCeParams(void)
808 {
809     return LnnGenerateCeKeyByHuks(&g_ceKeyAlias);
810 }
811 
LnnCheckGenerateSoftBusKeyByHuks(void)812 int32_t LnnCheckGenerateSoftBusKeyByHuks(void)
813 {
814     if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
815         LNN_LOGE(LNN_LEDGER, "generate decision db huks de key fail");
816         return SOFTBUS_GENERATE_KEY_FAIL;
817     }
818     return SOFTBUS_OK;
819 }
820 
LnnInitDecisionDbDelay(void)821 int32_t LnnInitDecisionDbDelay(void)
822 {
823     if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
824         LNN_LOGE(LNN_LEDGER, "generate decision db huks de key fail");
825         return SOFTBUS_ERR;
826     }
827     if (LnnGenerateCeKeyByHuks(&g_ceKeyAlias) != SOFTBUS_OK) {
828         LNN_LOGE(LNN_LEDGER, "update decision db huks ce key fail");
829         return SOFTBUS_ERR;
830     }
831     if (InitTrustedDevInfoTable() != SOFTBUS_OK) {
832         LNN_LOGI(LNN_LEDGER, "try init trusted dev info table again");
833         return TryRecoveryTrustedDevInfoTable();
834     }
835     return SOFTBUS_OK;
836 }
837