1 /*
2 * Copyright (c) 2024-2025 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 "crypto_delay_handler.h"
17
18 #include "storage_service_log.h"
19 #include "storage_service_errno.h"
20 #include "utils/storage_radar.h"
21
22 using namespace OHOS::StorageService;
23 namespace OHOS {
24 namespace StorageDaemon {
25 constexpr int32_t WAIT_THREAD_TIMEOUT_MS = 5;
26 constexpr int32_t DEFAULT_CHECK_INTERVAL = 10 * 1000; // 10s
27 constexpr const char *CLEAR_TASK_NAME = "clear_ece_sece_key";
28
DelayHandler(uint32_t userId)29 DelayHandler::DelayHandler(uint32_t userId) : userId_(userId) {}
~DelayHandler()30 DelayHandler::~DelayHandler()
31 {
32 LOGI("DelayHandler Destructor.");
33 std::unique_lock<std::mutex> lock(eventMutex_);
34 if ((eventHandler_ != nullptr) && (eventHandler_->GetEventRunner() != nullptr)) {
35 eventHandler_->RemoveAllEvents();
36 eventHandler_->GetEventRunner()->Stop();
37 }
38 if (eventThread_.joinable()) {
39 eventThread_.join();
40 }
41 eventHandler_ = nullptr;
42 LOGI("success");
43 }
44
StartDelayTask(std::shared_ptr<BaseKey> & el4Key)45 void DelayHandler::StartDelayTask(std::shared_ptr<BaseKey> &el4Key)
46 {
47 CancelDelayTask();
48 if (el4Key == nullptr) {
49 LOGI("elKey is nullptr do not clean.");
50 return;
51 }
52 el4Key_ = el4Key;
53
54 LOGI("StartDelayTask, start delay clear key task.");
55 std::unique_lock<std::mutex> lock(eventMutex_);
56 if (eventHandler_ == nullptr) {
57 eventThread_ = std::thread(&DelayHandler::StartDelayHandler, this);
58 eventCon_.wait_for(lock, std::chrono::seconds(WAIT_THREAD_TIMEOUT_MS), [this] {
59 return eventHandler_ != nullptr;
60 });
61 }
62
63 auto executeFunc = [this] { DeactiveEl3El4El5(); };
64 eventHandler_->PostTask(executeFunc, CLEAR_TASK_NAME, DEFAULT_CHECK_INTERVAL,
65 AppExecFwk::EventHandler::Priority::IMMEDIATE);
66 LOGI("success");
67 }
68
StartDelayHandler()69 void DelayHandler::StartDelayHandler()
70 {
71 pthread_setname_np(pthread_self(), "storage_monitor_task_event");
72 auto runner = AppExecFwk::EventRunner::Create(false);
73 if (runner == nullptr) {
74 LOGE("event runner is nullptr.");
75 return;
76 }
77 {
78 std::lock_guard<std::mutex> lock(eventMutex_);
79 eventHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
80 }
81 eventCon_.notify_one();
82 runner->Run();
83 LOGI("success");
84 }
85
CancelDelayTask()86 void DelayHandler::CancelDelayTask()
87 {
88 LOGI("enter");
89 if (eventHandler_ == nullptr) {
90 LOGE("eventHandler_ is nullptr !");
91 return;
92 }
93 eventHandler_->RemoveTask(CLEAR_TASK_NAME);
94 LOGI("success");
95 }
96
DeactiveEl3El4El5()97 void DelayHandler::DeactiveEl3El4El5()
98 {
99 LOGI("enter");
100 if (el4Key_ == nullptr) {
101 LOGI("elKey is nullptr do not clean.");
102 StorageRadar::ReportUpdateUserAuth("DeactiveEl3El4El5", userId_, E_PARAMS_INVALID, "EL4", "");
103 return;
104 }
105 int32_t ret = el4Key_->LockUserScreen(userId_, FSCRYPT_SDP_ECE_CLASS);
106 if (ret != E_OK) {
107 LOGE("Clear user %{public}u key failed", userId_);
108 StorageRadar::ReportUpdateUserAuth("DeactiveEl3El4El5::LockUserScreen", userId_, E_SYS_KERNEL_ERR, "EL4", "");
109 return;
110 }
111 LOGW("success");
112 }
113 } // StorageDaemon
114 } // OHOS