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 = 300000;
34 const char* ATTEST_UNLOAD_TASK_ID = "attest_unload_task";
REGISTER_SYSTEM_ABILITY_BY_ID(DevAttestService,DevAttestInterface::SA_ID_DEVICE_ATTEST_SERVICE,false)35 REGISTER_SYSTEM_ABILITY_BY_ID(DevAttestService, DevAttestInterface::SA_ID_DEVICE_ATTEST_SERVICE, false)
36
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 sptr<DevAttestSystemAbilityListener> pListener =
70 (std::make_unique<DevAttestSystemAbilityListener>()).release();
71 if (!pListener->AddDevAttestSystemAbilityListener(COMM_NET_CONN_MANAGER_SA_ID)) {
72 HILOGE("[OnStart] AddDevAttestSystemAbilityListener failed.");
73 }
74 }
75 return;
76 }
77
Init()78 bool DevAttestService::Init()
79 {
80 shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(ATTEST_UNLOAD_TASK_ID);
81 if (unloadHandler_ == nullptr) {
82 unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
83 }
84 if (unloadHandler_ == nullptr) {
85 return false;
86 }
87
88 if (!registerToSa_) {
89 bool ret = Publish(this);
90 if (!ret) {
91 HILOGE("[Init] DevAttestService Init Publish failed");
92 return false;
93 }
94 registerToSa_ = true;
95 }
96 return true;
97 }
98
OnStop()99 void DevAttestService::OnStop()
100 {
101 HILOGI("[OnStop] DevAttestService OnStop");
102 state_ = ServiceRunningState::STATE_NOT_START;
103 registerToSa_ = false;
104 }
105
OnIdle(const SystemAbilityOnDemandReason & idleReason)106 int32_t DevAttestService::OnIdle(const SystemAbilityOnDemandReason& idleReason)
107 {
108 HILOGI("[OnIdle] reason %{public}d", idleReason.GetId());
109 (void)DelayedSingleton<DevAttestNetworkManager>::GetInstance()->UnregisterNetConnCallback();
110 (void)AttestDestroyTimerTask;
111 AttestWaitTaskOver();
112 return UNLOAD_IMMEDIATELY;
113 }
114
DelayUnloadTask(void)115 void DevAttestService::DelayUnloadTask(void)
116 {
117 HILOGI("delay unload task begin");
118 if (unloadHandler_ == nullptr) {
119 shared_ptr<AppExecFwk::EventRunner> runner = AppExecFwk::EventRunner::Create(ATTEST_UNLOAD_TASK_ID);
120 unloadHandler_ = std::make_shared<AppExecFwk::EventHandler>(runner);
121 }
122 if (unloadHandler_ == nullptr) {
123 HILOGE("unloadHandler is null");
124 return;
125 }
126 auto task = []() {
127 sptr<ISystemAbilityManager> samgrProxy =
128 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
129 if (samgrProxy == nullptr) {
130 HILOGE("[unload] samgrProxy is null");
131 return;
132 }
133 int32_t ret = samgrProxy->UnloadSystemAbility(DevAttestInterface::SA_ID_DEVICE_ATTEST_SERVICE);
134 if (ret != DEVATTEST_SUCCESS) {
135 HILOGE("[unload] system ability failed");
136 return;
137 }
138 };
139
140 unloadHandler_->RemoveTask(ATTEST_UNLOAD_TASK_ID);
141 unloadHandler_->PostTask(task, ATTEST_UNLOAD_TASK_ID, DELAY_TIME);
142 }
143
CopyAttestResult(int32_t * resultArray,AttestResultInfo & attestResultInfo)144 int32_t DevAttestService::CopyAttestResult(int32_t *resultArray, AttestResultInfo &attestResultInfo)
145 {
146 if (resultArray == NULL) {
147 return DEVATTEST_FAIL;
148 }
149 int32_t *head = resultArray;
150 attestResultInfo.authResult_ = *head;
151 head++;
152 attestResultInfo.softwareResult_ = *head;
153 for (int i = 0; i < SOFTWARE_RESULT_DETAIL_SIZE; i++) {
154 attestResultInfo.softwareResultDetail_[i] = *(++head);
155 }
156 return DEVATTEST_SUCCESS;
157 }
158
GetAttestStatus(AttestResultInfo & attestResultInfo)159 int32_t DevAttestService::GetAttestStatus(AttestResultInfo &attestResultInfo)
160 {
161 int32_t resultArraySize = MAX_ATTEST_RESULT_SIZE * sizeof(int32_t);
162 int32_t *resultArray = (int32_t *)malloc(resultArraySize);
163 if (resultArray == NULL) {
164 HILOGE("[GetAttestStatus] malloc resultArray failed");
165 return DEVATTEST_FAIL;
166 }
167 (void)memset_s(resultArray, resultArraySize, 0, resultArraySize);
168 int32_t ticketLength = 0;
169 char* ticketStr = NULL;
170 int32_t ret = DEVATTEST_SUCCESS;
171 do {
172 ret = QueryAttest(&resultArray, MAX_ATTEST_RESULT_SIZE, &ticketStr, &ticketLength);
173 if (ret != DEVATTEST_SUCCESS) {
174 HILOGE("[GetAttestStatus] QueryAttest failed");
175 break;
176 }
177
178 attestResultInfo.ticketLength_ = ticketLength;
179 attestResultInfo.ticket_ = (ticketStr == NULL) ? string("") : ticketStr;
180 ret = CopyAttestResult(resultArray, attestResultInfo);
181 if (ret != DEVATTEST_SUCCESS) {
182 HILOGE("[GetAttestStatus] copy attest result failed");
183 break;
184 }
185 } while (0);
186 if (ticketStr != NULL && ticketLength != 0) {
187 free(ticketStr);
188 ticketStr = NULL;
189 }
190 free(resultArray);
191 resultArray = NULL;
192 HILOGD("[GetAttestStatus] GetAttestStatus end");
193 return ret;
194 }
195 } // end of DevAttest
196 } // end of OHOS