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