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