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 "bus_center_manager.h"
21 #include "lnn_async_callback_utils.h"
22 #include "lnn_file_utils.h"
23 #include "lnn_heartbeat_ctrl.h"
24 #include "lnn_huks_utils.h"
25 #include "sqlite3_utils.h"
26
27 #include "softbus_adapter_crypto.h"
28 #include "softbus_adapter_file.h"
29 #include "softbus_adapter_mem.h"
30 #include "softbus_common.h"
31 #include "softbus_def.h"
32 #include "softbus_errcode.h"
33 #include "softbus_log.h"
34 #include "softbus_utils.h"
35
36 #define LNN_DB_KEY_LEN 1024
37 #define LNN_DB_KEY_AILAS "dsoftbus_decision_db_key_alias"
38
39 static struct HksBlob g_keyAlias = {sizeof(LNN_DB_KEY_AILAS), (uint8_t *)LNN_DB_KEY_AILAS};
40
EncryptStorageData(uint8_t * dbKey,uint32_t len)41 int32_t EncryptStorageData(uint8_t *dbKey, uint32_t len)
42 {
43 struct HksBlob plainData = {0};
44 struct HksBlob encryptData = {0};
45
46 encryptData.data = (uint8_t *)SoftBusCalloc(len);
47 if (encryptData.data == NULL) {
48 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "calloc encrypt dbKey fail");
49 return SOFTBUS_MEM_ERR;
50 }
51 LLOGI("Encrypt, data len = %d", len);
52 plainData.size = len;
53 plainData.data = dbKey;
54 if (LnnEncryptDataByHuks(&g_keyAlias, &plainData, &encryptData) != SOFTBUS_OK) {
55 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt dbKey by huks fail");
56 (void)memset_s(plainData.data, len, 0x0, len);
57 SoftBusFree(encryptData.data);
58 return SOFTBUS_ERR;
59 }
60 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "encrypt dbKey log for audit");
61 (void)memset_s(plainData.data, len, 0x0, len);
62 if (memcpy_s(dbKey, len, encryptData.data, len) != SOFTBUS_OK) {
63 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s dbKey fail");
64 SoftBusFree(encryptData.data);
65 return SOFTBUS_MEM_ERR;
66 }
67 SoftBusFree(encryptData.data);
68 return SOFTBUS_OK;
69 }
70
DecryptStorageData(uint8_t * dbKey,uint32_t len)71 int32_t DecryptStorageData(uint8_t *dbKey, uint32_t len)
72 {
73 struct HksBlob encryptData = {0};
74 struct HksBlob decryptData = {0};
75
76 decryptData.data = (uint8_t *)SoftBusCalloc(len);
77 if (decryptData.data == NULL) {
78 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "calloc decrypt dbKey fail");
79 return SOFTBUS_MEM_ERR;
80 }
81 LLOGI("Decrypt, data len = %d", len);
82 encryptData.size = len;
83 encryptData.data = dbKey;
84 int32_t ret;
85 do {
86 if (LnnDecryptDataByHuks(&g_keyAlias, &encryptData, &decryptData) != SOFTBUS_OK) {
87 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "decrypt dbKey by huks fail");
88 ret = SOFTBUS_ERR;
89 break;
90 }
91 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "decrypt dbKey log for audit");
92 if (memcpy_s(dbKey, len, decryptData.data, decryptData.size) != SOFTBUS_OK) {
93 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s dbKey fail");
94 ret = SOFTBUS_MEM_ERR;
95 break;
96 }
97 ret = SOFTBUS_OK;
98 } while (false);
99 (void)memset_s(decryptData.data, decryptData.size, 0x0, decryptData.size);
100 SoftBusFree(decryptData.data);
101 return ret;
102 }
103
GetDecisionDbKey(uint8_t * dbKey,uint32_t len,bool isUpdate)104 static int32_t GetDecisionDbKey(uint8_t *dbKey, uint32_t len, bool isUpdate)
105 {
106 char dbKeyFilePath[SOFTBUS_MAX_PATH_LEN];
107
108 if (LnnGetFullStoragePath(LNN_FILE_ID_DB_KEY, dbKeyFilePath, SOFTBUS_MAX_PATH_LEN) != SOFTBUS_OK) {
109 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get dbKey save path fail");
110 return SOFTBUS_ERR;
111 }
112 do {
113 if (!isUpdate && SoftBusAccessFile(dbKeyFilePath, SOFTBUS_F_OK) == SOFTBUS_OK) {
114 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "dbKey file is exist");
115 break;
116 }
117 if (LnnGenerateRandomByHuks(dbKey, len) != SOFTBUS_OK) {
118 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "generate random dbKey fail");
119 return SOFTBUS_ERR;
120 }
121 if (EncryptStorageData(dbKey, len) != SOFTBUS_OK) {
122 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt dbKey fail");
123 return SOFTBUS_ERR;
124 }
125 if (SoftBusWriteFile(dbKeyFilePath, (char *)dbKey, len) != SOFTBUS_OK) {
126 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "write dbKey to file fail");
127 return SOFTBUS_ERR;
128 }
129 } while (false);
130 if (SoftBusReadFullFile(dbKeyFilePath, (char *)dbKey, len) != SOFTBUS_OK) {
131 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "read dbKey from file fail");
132 return SOFTBUS_ERR;
133 }
134 if (DecryptStorageData(dbKey, len) != SOFTBUS_OK) {
135 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "decrypt dbKey fail");
136 return SOFTBUS_ERR;
137 }
138 return SOFTBUS_OK;
139 }
140
EncryptDecisionDb(DbContext * ctx)141 static int32_t EncryptDecisionDb(DbContext *ctx)
142 {
143 uint8_t dbKey[LNN_DB_KEY_LEN] = {0};
144
145 if (GetDecisionDbKey(dbKey, sizeof(dbKey), false) != SOFTBUS_OK) {
146 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get decision dbKey fail");
147 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
148 return SOFTBUS_ERR;
149 }
150 if (EncryptedDb(ctx, dbKey, sizeof(dbKey)) != SOFTBUS_OK) {
151 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt decision db fail");
152 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
153 return SOFTBUS_ERR;
154 }
155 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
156 return SOFTBUS_OK;
157 }
158
UpdateDecisionDbKey(DbContext * ctx)159 static int32_t UpdateDecisionDbKey(DbContext *ctx)
160 {
161 uint8_t dbKey[LNN_DB_KEY_LEN] = {0};
162
163 if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
164 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "update decision db root key fail");
165 return SOFTBUS_ERR;
166 }
167 if (GetDecisionDbKey(dbKey, sizeof(dbKey), true) != SOFTBUS_OK) {
168 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get decision dbKey fail");
169 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
170 return SOFTBUS_ERR;
171 }
172 if (UpdateDbPassword(ctx, dbKey, sizeof(dbKey)) != SOFTBUS_OK) {
173 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt decision db fail");
174 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
175 return SOFTBUS_ERR;
176 }
177 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "update dbKey log for audit");
178 (void)memset_s(dbKey, sizeof(dbKey), 0x0, sizeof(dbKey));
179 return SOFTBUS_OK;
180 }
181
BuildTrustedDevInfoRecord(const char * udid,TrustedDevInfoRecord * record)182 static int32_t BuildTrustedDevInfoRecord(const char *udid, TrustedDevInfoRecord *record)
183 {
184 uint8_t accountHash[SHA_256_HASH_LEN] = {0};
185 char accountHexHash[SHA_256_HEX_HASH_LEN] = {0};
186
187 if (udid == NULL || record == NULL) {
188 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid param.");
189 return SOFTBUS_INVALID_PARAM;
190 }
191 if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
192 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local account hash failed.");
193 return SOFTBUS_ERR;
194 }
195 if (memset_s(record, sizeof(TrustedDevInfoRecord), 0, sizeof(TrustedDevInfoRecord)) != EOK) {
196 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memset_s record failed.");
197 return SOFTBUS_MEM_ERR;
198 }
199 if (ConvertBytesToHexString(accountHexHash, SHA_256_HEX_HASH_LEN, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
200 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "convert accountHash failed.");
201 return SOFTBUS_ERR;
202 }
203 if (strcpy_s(record->accountHexHash, sizeof(record->accountHexHash), accountHexHash) != EOK) {
204 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s account hash failed.");
205 return SOFTBUS_MEM_ERR;
206 }
207 if (strcpy_s(record->udid, sizeof(record->udid), udid) != EOK) {
208 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "memcpy_s udid hash failed.");
209 return SOFTBUS_MEM_ERR;
210 }
211 return SOFTBUS_OK;
212 }
213
CompleteUpdateTrustedDevInfo(void * para)214 static void CompleteUpdateTrustedDevInfo(void *para)
215 {
216 (void)para;
217
218 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_DBG, "complete trusted dev info update enter.");
219 LnnUpdateHeartbeatInfo(UPDATE_HB_NETWORK_INFO);
220 }
221
InsertTrustedDevInfoRecord(void * param)222 NO_SANITIZE("cfi") static void InsertTrustedDevInfoRecord(void *param)
223 {
224 DbContext *ctx = NULL;
225 TrustedDevInfoRecord record;
226
227 char *udid = (char *)param;
228 if (udid == NULL) {
229 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid param.");
230 return;
231 }
232 if (BuildTrustedDevInfoRecord(udid, &record) != SOFTBUS_OK) {
233 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "build insert trusted dev info record failed.");
234 SoftBusFree(udid);
235 return;
236 }
237 if (OpenDatabase(&ctx) != SOFTBUS_OK) {
238 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open database failed.");
239 SoftBusFree(udid);
240 return;
241 }
242 do {
243 if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
244 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt database failed.");
245 break;
246 }
247 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO,
248 "insert udid:%s to trusted dev info table.", AnonymizesUDID(udid));
249 if (InsertRecord(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&record) == SOFTBUS_OK) {
250 (void)LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), CompleteUpdateTrustedDevInfo, NULL);
251 }
252 } while (false);
253 if (CloseDatabase(ctx) != SOFTBUS_OK) {
254 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "close database failed.");
255 SoftBusFree(udid);
256 return;
257 }
258 SoftBusFree(udid);
259 }
260
RemoveTrustedDevInfoRecord(void * param)261 static void RemoveTrustedDevInfoRecord(void *param)
262 {
263 DbContext *ctx = NULL;
264 TrustedDevInfoRecord record;
265
266 char *udid = (char *)param;
267 if (udid == NULL) {
268 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid param.");
269 return;
270 }
271 if (BuildTrustedDevInfoRecord(udid, &record) != SOFTBUS_OK) {
272 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "build remove trusted dev info record failed.");
273 SoftBusFree(udid);
274 return;
275 }
276 if (OpenDatabase(&ctx) != SOFTBUS_OK) {
277 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open database failed.");
278 SoftBusFree(udid);
279 return;
280 }
281 do {
282 if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
283 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt database failed.");
284 break;
285 }
286 if (RemoveRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)&record) == SOFTBUS_OK) {
287 (void)LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), CompleteUpdateTrustedDevInfo, NULL);
288 }
289 } while (false);
290 if (CloseDatabase(ctx) != SOFTBUS_OK) {
291 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "close database failed.");
292 }
293 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "remove udid:%s from trusted dev info table.", AnonymizesUDID(udid));
294 SoftBusFree(udid);
295 }
296
LnnInsertSpecificTrustedDevInfo(const char * udid)297 NO_SANITIZE("cfi") int32_t LnnInsertSpecificTrustedDevInfo(const char *udid)
298 {
299 char *dupUdid = NULL;
300
301 if (udid == NULL) {
302 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid param.");
303 return SOFTBUS_INVALID_PARAM;
304 }
305 dupUdid = (char *)SoftBusMalloc(UDID_BUF_LEN);
306 if (dupUdid == NULL) {
307 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "malloc dupUdid failed.");
308 return SOFTBUS_MALLOC_ERR;
309 }
310 if (strcpy_s(dupUdid, UDID_BUF_LEN, udid) != EOK) {
311 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s dupUdid failed.");
312 SoftBusFree(dupUdid);
313 return SOFTBUS_ERR;
314 }
315 if (LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), InsertTrustedDevInfoRecord,
316 (void *)dupUdid) != SOFTBUS_OK) {
317 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "async call insert trusted dev info failed.");
318 SoftBusFree(dupUdid);
319 return SOFTBUS_ERR;
320 }
321 return SOFTBUS_OK;
322 }
323
LnnDeleteSpecificTrustedDevInfo(const char * udid)324 NO_SANITIZE("cfi") int32_t LnnDeleteSpecificTrustedDevInfo(const char *udid)
325 {
326 char *dupUdid = NULL;
327
328 if (udid == NULL) {
329 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "invalid param.");
330 return SOFTBUS_INVALID_PARAM;
331 }
332 dupUdid = (char *)SoftBusMalloc(UDID_BUF_LEN);
333 if (dupUdid == NULL) {
334 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "malloc dupUdid failed.");
335 return SOFTBUS_MALLOC_ERR;
336 }
337 if (strcpy_s(dupUdid, UDID_BUF_LEN, udid) != EOK) {
338 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "strcpy_s dupUdid failed.");
339 SoftBusFree(dupUdid);
340 return SOFTBUS_ERR;
341 }
342 if (LnnAsyncCallbackHelper(GetLooper(LOOP_TYPE_DEFAULT), RemoveTrustedDevInfoRecord,
343 (void *)dupUdid) != SOFTBUS_OK) {
344 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "async call remove trusted dev info failed.");
345 SoftBusFree(dupUdid);
346 return SOFTBUS_ERR;
347 }
348 return SOFTBUS_OK;
349 }
350
GetTrustedDevInfoRecord(DbContext * ctx,const char * accountHexHash,char ** udidArray,uint32_t * num)351 static int32_t GetTrustedDevInfoRecord(DbContext *ctx, const char *accountHexHash,
352 char **udidArray, uint32_t *num)
353 {
354 if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
355 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt database failed.");
356 *udidArray = NULL;
357 *num = 0;
358 return SOFTBUS_ERR;
359 }
360 *num = GetRecordNumByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)accountHexHash);
361 if (*num == 0) {
362 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_WARN, "get none trusted dev info");
363 *udidArray = NULL;
364 return SOFTBUS_OK;
365 }
366 *udidArray = (char *)SoftBusCalloc(*num * UDID_BUF_LEN);
367 if (*udidArray == NULL) {
368 *num = 0;
369 return SOFTBUS_MALLOC_ERR;
370 }
371 if (QueryRecordByKey(ctx, TABLE_TRUSTED_DEV_INFO, (uint8_t *)accountHexHash,
372 (uint8_t **)udidArray, *num) != SOFTBUS_OK) {
373 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "query udidArray failed.");
374 SoftBusFree(*udidArray);
375 *udidArray = NULL;
376 *num = 0;
377 return SOFTBUS_ERR;
378 }
379 return SOFTBUS_OK;
380 }
381
LnnGetTrustedDevInfoFromDb(char ** udidArray,uint32_t * num)382 NO_SANITIZE("cfi") int32_t LnnGetTrustedDevInfoFromDb(char **udidArray, uint32_t *num)
383 {
384 uint8_t accountHash[SHA_256_HASH_LEN] = {0};
385 char accountHexHash[SHA_256_HEX_HASH_LEN] = {0};
386 DbContext *ctx = NULL;
387
388 if (udidArray == NULL || num == NULL) {
389 return SOFTBUS_INVALID_PARAM;
390 }
391 if (LnnGetLocalByteInfo(BYTE_KEY_ACCOUNT_HASH, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
392 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get local account hash failed.");
393 return SOFTBUS_ERR;
394 }
395 if (ConvertBytesToHexString(accountHexHash, SHA_256_HEX_HASH_LEN, accountHash, SHA_256_HASH_LEN) != SOFTBUS_OK) {
396 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "convert accountHash failed.");
397 return SOFTBUS_ERR;
398 }
399 if (OpenDatabase(&ctx) != SOFTBUS_OK) {
400 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open database failed.");
401 return SOFTBUS_ERR;
402 }
403 int32_t rc = GetTrustedDevInfoRecord(ctx, accountHexHash, udidArray, num);
404 if (rc != SOFTBUS_OK) {
405 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get trusted dev info failed.");
406 }
407 if (CloseDatabase(ctx) != SOFTBUS_OK) {
408 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "close database failed.");
409 SoftBusFree(*udidArray);
410 *udidArray = NULL;
411 *num = 0;
412 return SOFTBUS_ERR;
413 }
414 return rc;
415 }
416
InitTrustedDevInfoTable(void)417 static int32_t InitTrustedDevInfoTable(void)
418 {
419 bool isExist = false;
420 int32_t rc = SOFTBUS_ERR;
421 DbContext *ctx = NULL;
422
423 if (OpenDatabase(&ctx) != SOFTBUS_OK) {
424 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "open database failed.");
425 return SOFTBUS_ERR;
426 }
427 do {
428 if (EncryptDecisionDb(ctx) != SOFTBUS_OK) {
429 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "encrypt database failed.");
430 break;
431 }
432 if (UpdateDecisionDbKey(ctx) != SOFTBUS_OK) {
433 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "update database dbKey failed.");
434 break;
435 }
436 if (CheckTableExist(ctx, TABLE_TRUSTED_DEV_INFO, &isExist) != SOFTBUS_OK) {
437 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "check table exist failed.");
438 break;
439 }
440 if (!isExist && CreateTable(ctx, TABLE_TRUSTED_DEV_INFO) != SOFTBUS_OK) {
441 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "create trusted dev info table failed.");
442 break;
443 }
444 rc = SOFTBUS_OK;
445 } while (false);
446 if (CloseDatabase(ctx) != SOFTBUS_OK) {
447 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "close database failed.");
448 return SOFTBUS_ERR;
449 }
450 return rc;
451 }
452
TryRecoveryTrustedDevInfoTable(void)453 static int32_t TryRecoveryTrustedDevInfoTable(void)
454 {
455 char dbKeyFilePath[SOFTBUS_MAX_PATH_LEN];
456
457 if (LnnGetFullStoragePath(LNN_FILE_ID_DB_KEY, dbKeyFilePath, SOFTBUS_MAX_PATH_LEN) != SOFTBUS_OK) {
458 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "get dbKey save path fail");
459 return SOFTBUS_ERR;
460 }
461 SoftBusRemoveFile(dbKeyFilePath);
462 SoftBusRemoveFile(DATABASE_NAME);
463 return InitTrustedDevInfoTable();
464 }
465
LnnIsPotentialHomeGroup(const char * udid)466 bool LnnIsPotentialHomeGroup(const char *udid)
467 {
468 (void)udid;
469
470 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "check is potential home group not implemented.");
471 return false;
472 }
473
LnnInitDecisionDbDelay(void)474 NO_SANITIZE("cfi") int32_t LnnInitDecisionDbDelay(void)
475 {
476 if (LnnGenerateKeyByHuks(&g_keyAlias) != SOFTBUS_OK) {
477 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_ERROR, "generate decision db huks key fail");
478 return SOFTBUS_ERR;
479 }
480 if (InitTrustedDevInfoTable() != SOFTBUS_OK) {
481 SoftBusLog(SOFTBUS_LOG_LNN, SOFTBUS_LOG_INFO, "try init trusted dev info table again");
482 return TryRecoveryTrustedDevInfoTable();
483 }
484 return SOFTBUS_OK;
485 }
486