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 "devattest_service.h"
17
18 #include <securec.h>
19 #include "iservice_registry.h"
20 #include "devattest_errno.h"
21 #include "devattest_log.h"
22 #include "devattest_system_ability_listener.h"
23 #include "devattest_task.h"
24 #include "attest_entry.h"
25 #include "devattest_network_manager.h"
26
27 namespace OHOS {
28 namespace DevAttest {
29 using namespace std;
30
31 constexpr int32_t COMM_NET_CONN_MANAGER_SA_ID = 1151;
32 constexpr int32_t UNLOAD_IMMEDIATELY = 0;
33 constexpr int32_t DELAY_TIME = 600000;
34 const char* ATTEST_UNLOAD_TASK_ID = "attest_unload_task";
35 REGISTER_SYSTEM_ABILITY_BY_ID(DevAttestService, DevAttestInterface::SA_ID_DEVICE_ATTEST_SERVICE, false)
36
DevAttestService(int32_t systemAbilityId, bool runOnCreate)37 DevAttestService::DevAttestService(int32_t systemAbilityId, bool runOnCreate)
38 : SystemAbility(systemAbilityId, runOnCreate)
39 {
40 }
41
DevAttestService()42 DevAttestService::DevAttestService()
43 : SystemAbility(SA_ID_DEVICE_ATTEST_SERVICE, false)
44 {
45 }
46
~DevAttestService()47 DevAttestService::~DevAttestService()
48 {
49 }
50
OnStart(const SystemAbilityOnDemandReason& startReason)51 void DevAttestService::OnStart(const SystemAbilityOnDemandReason& startReason)
52 {
53 if (state_ == ServiceRunningState::STATE_RUNNING) {
54 HILOGE("[OnStart] DevAttest Service has already started.");
55 return;
56 }
57 if (!Init()) {
58 HILOGE("[OnStart] Failed to init DevAttestService.");
59 return;
60 }
61 state_ = ServiceRunningState::STATE_RUNNING;
62 HILOGI("[OnStart] DevAttestService start success");
63 if (startReason.GetId() != OHOS::OnDemandReasonId::INTERFACE_CALL) {
64 DevAttestTask devAttestTask;
65 if (!devAttestTask.CreateThread()) {
66 HILOGE("[OnStart] Failed to CreateThread");
67 }
68 } else {
69 std::unique_ptr<DevAttestSystemAbilityListener> pListener = std::make_unique<DevAttestSystemAbilityListener>();
70 if (!pListener->AddDevAttestSystemAbilityListener(COMM_NET_CONN_MANAGER_SA_ID)) {
71 HILOGE("[OnStart] AddDevAttestSystemAbilityListener failed.");
72 }
73 }
74 return;
75 }
76
Init()77 bool DevAttestService::Init()
78 {
79 shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(ATTEST_UNLOAD_TASK_ID);
80 if (unloadHandler_ == nullptr) {
81 unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
82 }
83 if (unloadHandler_ == nullptr) {
84 return false;
85 }
86
87 if (!registerToSa_) {
88 bool ret = Publish(this);
89 if (!ret) {
90 HILOGE("[Init] DevAttestService Init Publish failed");
91 return false;
92 }
93 registerToSa_ = true;
94 }
95 return true;
96 }
97
OnStop()98 void DevAttestService::OnStop()
99 {
100 HILOGI("[OnStop] DevAttestService OnStop");
101 state_ = ServiceRunningState::STATE_NOT_START;
102 registerToSa_ = false;
103 }
104
OnIdle(const SystemAbilityOnDemandReason& idleReason)105 int32_t DevAttestService::OnIdle(const SystemAbilityOnDemandReason& idleReason)
106 {
107 return UNLOAD_IMMEDIATELY;
108 }
109
DelayUnloadTask(void)110 void DevAttestService::DelayUnloadTask(void)
111 {
112 HILOGI("[DelayUnloadTask] Delay unload task begin");
113 if (unloadHandler_ == nullptr) {
114 shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(ATTEST_UNLOAD_TASK_ID);
115 unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
116 }
117 if (unloadHandler_ == nullptr) {
118 HILOGE("[DelayUnloadTask] UnloadHandler is null");
119 return;
120 }
121 auto task = []() {
122 sptr<ISystemAbilityManager> samgrProxy =
123 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
124 if (samgrProxy == nullptr) {
125 HILOGE("[DelayUnloadTask] SamgrProxy is null");
126 return;
127 }
128 DelayedSingleton<DevAttestNetworkManager>::GetInstance()->UnregisterNetConnCallback();
129 int32_t ret = AttestDestroyTimerTask();
130 if (ret != DEVATTEST_SUCCESS) {
131 // Don't return
132 HILOGW("[DelayUnloadTask] Stop timer failed");
133 }
134 ret = samgrProxy->UnloadSystemAbility(DevAttestInterface::SA_ID_DEVICE_ATTEST_SERVICE);
135 if (ret != DEVATTEST_SUCCESS) {
136 HILOGE("[DelayUnloadTask] System ability failed");
137 return;
138 }
139 };
140
141 unloadHandler_->RemoveTask(ATTEST_UNLOAD_TASK_ID);
142 unloadHandler_->PostTask(task, ATTEST_UNLOAD_TASK_ID, DELAY_TIME);
143 }
144
CopyAttestResult(int32_t *resultArray, AttestResultInfo &attestResultInfo)145 int32_t DevAttestService::CopyAttestResult(int32_t *resultArray, AttestResultInfo &attestResultInfo)
146 {
147 if (resultArray == NULL) {
148 return DEVATTEST_FAIL;
149 }
150 int32_t *head = resultArray;
151 attestResultInfo.authResult_ = *head;
152 head++;
153 attestResultInfo.softwareResult_ = *head;
154 for (int i = 0; i < SOFTWARE_RESULT_DETAIL_SIZE; i++) {
155 attestResultInfo.softwareResultDetail_[i] = *(++head);
156 }
157 return DEVATTEST_SUCCESS;
158 }
159
GetAttestStatus(AttestResultInfo &attestResultInfo)160 int32_t DevAttestService::GetAttestStatus(AttestResultInfo &attestResultInfo)
161 {
162 int32_t resultArraySize = MAX_ATTEST_RESULT_SIZE * sizeof(int32_t);
163 int32_t *resultArray = (int32_t *)malloc(resultArraySize);
164 if (resultArray == NULL) {
165 HILOGE("[GetAttestStatus] malloc resultArray failed");
166 return DEVATTEST_FAIL;
167 }
168 (void)memset_s(resultArray, resultArraySize, 0, resultArraySize);
169 int32_t ticketLength = 0;
170 char* ticketStr = NULL;
171 int32_t ret = DEVATTEST_SUCCESS;
172 do {
173 ret = QueryAttest(&resultArray, MAX_ATTEST_RESULT_SIZE, &ticketStr, &ticketLength);
174 if (ret != DEVATTEST_SUCCESS) {
175 HILOGE("[GetAttestStatus] QueryAttest failed");
176 break;
177 }
178
179 attestResultInfo.ticketLength_ = ticketLength;
180 attestResultInfo.ticket_ = (ticketStr == NULL) ? string("") : ticketStr;
181 ret = CopyAttestResult(resultArray, attestResultInfo);
182 if (ret != DEVATTEST_SUCCESS) {
183 HILOGE("[GetAttestStatus] copy attest result failed");
184 break;
185 }
186 } while (0);
187 if (ticketStr != NULL && ticketLength != 0) {
188 free(ticketStr);
189 ticketStr = NULL;
190 }
191 free(resultArray);
192 resultArray = NULL;
193 HILOGD("[GetAttestStatus] GetAttestStatus end");
194 return ret;
195 }
196 } // end of DevAttest
197 } // end of OHOS