1 /*
2 * Copyright (C) 2023 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 <memory>
17 #include "app_domain_verify_mgr_service_stub.h"
18 #include "sa_interface/app_domain_verify_mgr_interface_code.h"
19 #include "errors.h"
20 #include "app_domain_verify_parcel_util.h"
21 #include "iservice_registry.h"
22 #include "system_ability_definition.h"
23 #include "want.h"
24
25 namespace OHOS {
26 namespace AppDomainVerify {
27 namespace {
28 const std::string TASK_ID = "unload";
29 }
AppDomainVerifyMgrServiceStub()30 AppDomainVerifyMgrServiceStub::AppDomainVerifyMgrServiceStub()
31 {
32 }
~AppDomainVerifyMgrServiceStub()33 AppDomainVerifyMgrServiceStub::~AppDomainVerifyMgrServiceStub()
34 {
35 }
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)36 int32_t AppDomainVerifyMgrServiceStub::OnRemoteRequest(
37 uint32_t code, MessageParcel& data, MessageParcel& reply, MessageOption& option)
38 {
39 APP_DOMAIN_VERIFY_HILOGI(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "onRemoteRequest##code = %{public}u", code);
40 std::u16string myDescripter = AppDomainVerifyMgrServiceStub::GetDescriptor();
41 std::u16string remoteDescripter = data.ReadInterfaceToken();
42 if (myDescripter != remoteDescripter) {
43 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "end##descriptor checked fail");
44 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
45 }
46
47 switch (code) {
48 case static_cast<uint32_t>(static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_VERIFY_STATUS)):
49 return OnQueryDomainVerifyStatus(data, reply);
50 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::VERIFY_DOMAIN):
51 return OnVerifyDomain(data, reply);
52 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::CLEAR_DOMAIN_VERIFY_RESULT):
53 return OnClearDomainVerifyStatus(data, reply);
54 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::FILTER_ABILITIES):
55 return OnFilterAbilities(data, reply);
56 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ALL_VERIFY_STATUS):
57 return OnQueryAllDomainVerifyStatus(data, reply);
58 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::SAVE_VERIFY_STATUS):
59 return OnSaveDomainVerifyStatus(data, reply);
60 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::IS_ATOMIC_SERVICE_URL):
61 return OnIsAtomicServiceUrl(data, reply);
62 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::CONVERT_TO_EXPLICIT_WANT):
63 return OnConvertToExplicitWant(data, reply);
64 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::UPDATE_WHITE_LIST_URLS):
65 return OnUpdateWhiteListUrls(data, reply);
66 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_DOMAINS):
67 return OnQueryAssociatedDomains(data, reply);
68 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_BUNDLE_NAMES):
69 return OnQueryAssociatedBundleNames(data, reply);
70 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::GET_DEFERRED_LINK):
71 return OnGetDeferredLink(data, reply);
72 case static_cast<uint32_t>(AppDomainVerifyMgrInterfaceCode::QUERY_APP_DETAILS_WANT):
73 return OnQueryAppDetailsWant(data, reply);
74 default:
75 APP_DOMAIN_VERIFY_HILOGW(
76 APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "receive unknown code, code = %{public}d", code);
77 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
78 }
79 }
80
OnVerifyDomain(MessageParcel & data,MessageParcel & reply)81 int32_t AppDomainVerifyMgrServiceStub::OnVerifyDomain(MessageParcel& data, MessageParcel& reply)
82 {
83 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
84 std::string appIdentifier = data.ReadString();
85 std::string bundleName = data.ReadString();
86 std::string fingerprint = data.ReadString();
87 int32_t size = data.ReadInt32();
88 if (IsInvalidParcelArraySize(size)) {
89 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
90 return false;
91 }
92 std::vector<SkillUri> skillUris;
93 for (int32_t i = 0; i < size; i++) {
94 std::unique_ptr<SkillUri> info(data.ReadParcelable<SkillUri>());
95 if (!info) {
96 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable skillUri failed.");
97 return ERR_INVALID_VALUE;
98 }
99 skillUris.emplace_back(*info);
100 }
101
102 VerifyDomain(appIdentifier, bundleName, fingerprint, skillUris);
103 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
104 return ERR_OK;
105 }
106
OnClearDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)107 int32_t AppDomainVerifyMgrServiceStub::OnClearDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
108 {
109 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
110 std::string appIdentifier = data.ReadString();
111 std::string bundleName = data.ReadString();
112 bool status = ClearDomainVerifyStatus(appIdentifier, bundleName);
113
114 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
115 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
116 return ERR_OK;
117 }
118
OnFilterAbilities(MessageParcel & data,MessageParcel & reply)119 int32_t AppDomainVerifyMgrServiceStub::OnFilterAbilities(MessageParcel& data, MessageParcel& reply)
120 {
121 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
122 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
123 OHOS::AAFwk::Want want;
124 if (!w) {
125 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
126 return ERR_INVALID_VALUE;
127 }
128 want = *w;
129 std::vector<OHOS::AppExecFwk::AbilityInfo> originAbilityInfos;
130 int32_t size = data.ReadInt32();
131 if (IsInvalidParcelArraySize(size)) {
132 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
133 return false;
134 }
135 for (int32_t i = 0; i < size; i++) {
136 std::unique_ptr<OHOS::AppExecFwk::AbilityInfo> info(data.ReadParcelable<OHOS::AppExecFwk::AbilityInfo>());
137 if (!info) {
138 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable abilityInfo failed.");
139 return ERR_INVALID_VALUE;
140 }
141 originAbilityInfos.emplace_back(*info);
142 }
143 std::vector<OHOS::AppExecFwk::AbilityInfo> filtedAbilityInfos;
144 bool status = FilterAbilities(want, originAbilityInfos, filtedAbilityInfos);
145 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
146 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, filtedAbilityInfos.size());
147 for (auto& it : filtedAbilityInfos) {
148 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &it);
149 }
150 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
151 return ERR_OK;
152 }
153
OnQueryDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)154 int32_t AppDomainVerifyMgrServiceStub::OnQueryDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
155 {
156 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
157 std::string bundleName = data.ReadString();
158 DomainVerifyStatus domainVerificationState;
159 bool status = QueryDomainVerifyStatus(bundleName, domainVerificationState);
160 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
161 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, domainVerificationState);
162 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
163 return ERR_OK;
164 }
165
OnQueryAllDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)166 int32_t AppDomainVerifyMgrServiceStub::OnQueryAllDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
167 {
168 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
169 BundleVerifyStatusInfo bundleVerifyStatusInfo;
170 bool status = QueryAllDomainVerifyStatus(bundleVerifyStatusInfo);
171 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
172 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &bundleVerifyStatusInfo);
173 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
174 return ERR_OK;
175 }
176
OnSaveDomainVerifyStatus(MessageParcel & data,MessageParcel & reply)177 int32_t AppDomainVerifyMgrServiceStub::OnSaveDomainVerifyStatus(MessageParcel& data, MessageParcel& reply)
178 {
179 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
180 std::string bundleName = data.ReadString();
181 std::unique_ptr<VerifyResultInfo> verifyResultInfo(data.ReadParcelable<VerifyResultInfo>());
182 if (verifyResultInfo == nullptr) {
183 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "verifyResultInfo null");
184 return ERR_INVALID_VALUE;
185 }
186 bool status = SaveDomainVerifyStatus(bundleName, *verifyResultInfo);
187 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
188 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
189 return ERR_OK;
190 }
OnIsAtomicServiceUrl(MessageParcel & data,MessageParcel & reply)191 int32_t AppDomainVerifyMgrServiceStub::OnIsAtomicServiceUrl(MessageParcel& data, MessageParcel& reply)
192 {
193 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
194 std::string url = data.ReadString();
195 bool status = IsAtomicServiceUrl(url);
196 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Bool, reply, status);
197 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
198 return ERR_OK;
199 }
OnUpdateWhiteListUrls(MessageParcel & data,MessageParcel & reply)200 int32_t AppDomainVerifyMgrServiceStub::OnUpdateWhiteListUrls(MessageParcel& data, MessageParcel& reply)
201 {
202 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
203 uint32_t size = data.ReadUint32();
204 if (IsInvalidParcelArraySize(size)) {
205 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
206 return false;
207 }
208 std::vector<std::string> urls;
209 for (uint32_t i = 0; i < size; i++) {
210 auto url = data.ReadString();
211 urls.emplace_back(url);
212 }
213 UpdateWhiteListUrls(urls);
214 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
215 return 0;
216 }
OnConvertToExplicitWant(MessageParcel & data,MessageParcel & reply)217 int32_t AppDomainVerifyMgrServiceStub::OnConvertToExplicitWant(MessageParcel& data, MessageParcel& reply)
218 {
219 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
220 OHOS::AAFwk::Want want;
221 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
222 if (!w) {
223 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
224 return ERR_INVALID_VALUE;
225 }
226 want = *w;
227 sptr<IRemoteObject> object = data.ReadRemoteObject();
228 if (object == nullptr) {
229 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read failed");
230 return ERR_INVALID_VALUE;
231 }
232 sptr<IConvertCallback> cleanCacheCallback = iface_cast<IConvertCallback>(object);
233 ConvertToExplicitWant(want, cleanCacheCallback);
234 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
235 return ERR_OK;
236 }
OnQueryAssociatedDomains(MessageParcel & data,MessageParcel & reply)237 int32_t AppDomainVerifyMgrServiceStub::OnQueryAssociatedDomains(MessageParcel& data, MessageParcel& reply)
238 {
239 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
240 std::string bundleName;
241 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
242
243 std::vector<std::string> domains;
244 int ret = QueryAssociatedDomains(bundleName, domains);
245
246 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, ret);
247 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, domains.size());
248 for (const auto& i : domains) {
249 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, reply, i);
250 }
251 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
252 return ERR_OK;
253 }
OnQueryAssociatedBundleNames(MessageParcel & data,MessageParcel & reply)254 int32_t AppDomainVerifyMgrServiceStub::OnQueryAssociatedBundleNames(MessageParcel& data, MessageParcel& reply)
255 {
256 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
257 std::string domain;
258 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, domain);
259 std::vector<std::string> bundleNames;
260
261 int ret = QueryAssociatedBundleNames(domain, bundleNames);
262
263 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, ret);
264 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, bundleNames.size());
265 for (const auto& i : bundleNames) {
266 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, reply, i);
267 }
268 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
269 return ERR_OK;
270 }
OnGetDeferredLink(MessageParcel & data,MessageParcel & reply)271 int32_t AppDomainVerifyMgrServiceStub::OnGetDeferredLink(MessageParcel& data, MessageParcel& reply)
272 {
273 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
274 std::string link;
275 int ret = GetDeferredLink(link);
276
277 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Int32, reply, ret);
278 WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, reply, link);
279 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "call end");
280 return ERR_OK;
281 }
282
OnQueryAppDetailsWant(MessageParcel & data,MessageParcel & reply)283 int32_t AppDomainVerifyMgrServiceStub::OnQueryAppDetailsWant(MessageParcel& data, MessageParcel& reply)
284 {
285 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "called");
286 AAFwk::Want want;
287 std::string url;
288 READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url);
289 std::unique_ptr<OHOS::AAFwk::Want> w(data.ReadParcelable<OHOS::AAFwk::Want>());
290 if (!w) {
291 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable want failed.");
292 return ERR_INVALID_VALUE;
293 }
294 want = *w;
295 int ret = QueryAppDetailsWant(url, want);
296 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Int32, reply, ret);
297 WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(Parcelable, reply, &want);
298 return ERR_OK;
299 }
300
301 } // namespace AppDomainVerify
302 } // namespace OHOS