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 #include "app_domain_verify_mgr_service_proxy.h"
16 #include "app_domain_verify_mgr_interface_code.h"
17 #include "system_ability_definition.h"
18 #include "app_domain_verify_parcel_util.h"
19 
20 namespace OHOS {
21 namespace AppDomainVerify {
AppDomainVerifyMgrServiceProxy(const sptr<IRemoteObject> & object)22 AppDomainVerifyMgrServiceProxy::AppDomainVerifyMgrServiceProxy(const sptr<IRemoteObject>& object)
23     : IRemoteProxy<IAppDomainVerifyMgrService>(object)
24 {
25     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "new instance created.");
26 }
~AppDomainVerifyMgrServiceProxy()27 AppDomainVerifyMgrServiceProxy::~AppDomainVerifyMgrServiceProxy()
28 {
29     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "instance dead.");
30 }
VerifyDomain(const std::string & appIdentifier,const std::string & bundleName,const std::string & fingerprint,const std::vector<SkillUri> & skillUris)31 void AppDomainVerifyMgrServiceProxy::VerifyDomain(const std::string& appIdentifier, const std::string& bundleName,
32     const std::string& fingerprint, const std::vector<SkillUri>& skillUris)
33 {
34     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
35     MessageParcel data;
36     MessageParcel reply;
37     MessageOption option;
38     WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
39     WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, appIdentifier);
40     WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, bundleName);
41     WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, fingerprint);
42 
43     uint32_t size = static_cast<uint32_t>(skillUris.size());
44     WRITE_PARCEL_AND_RETURN_IF_FAIL(Uint32, data, size);
45     for (uint32_t i = 0; i < skillUris.size(); ++i) {
46         WRITE_PARCEL_AND_RETURN_IF_FAIL(Parcelable, data, &skillUris[i]);
47     }
48     int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::VERIFY_DOMAIN, data, reply, option);
49     if (error != ERR_NONE) {
50         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "VerifyDomain failed, error: %{public}d", error);
51     }
52     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
53 }
54 
ClearDomainVerifyStatus(const std::string & appIdentifier,const std::string & bundleName)55 bool AppDomainVerifyMgrServiceProxy::ClearDomainVerifyStatus(
56     const std::string& appIdentifier, const std::string& bundleName)
57 {
58     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
59     MessageParcel data;
60     MessageParcel reply;
61     MessageOption option;
62     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
63     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, appIdentifier);
64     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
65     int32_t error = Remote()->SendRequest(
66         AppDomainVerifyMgrInterfaceCode::CLEAR_DOMAIN_VERIFY_RESULT, data, reply, option);
67     if (error != ERR_NONE) {
68         APP_DOMAIN_VERIFY_HILOGE(
69             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "ClearDomainVerifyStatus failed, error: %d", error);
70         return false;
71     }
72     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
73     return reply.ReadBool();
74 }
75 
FilterAbilities(const OHOS::AAFwk::Want & want,const std::vector<OHOS::AppExecFwk::AbilityInfo> & originAbilityInfos,std::vector<OHOS::AppExecFwk::AbilityInfo> & filtedAbilityInfos)76 bool AppDomainVerifyMgrServiceProxy::FilterAbilities(const OHOS::AAFwk::Want& want,
77     const std::vector<OHOS::AppExecFwk::AbilityInfo>& originAbilityInfos,
78     std::vector<OHOS::AppExecFwk::AbilityInfo>& filtedAbilityInfos)
79 {
80     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
81     MessageParcel data;
82     MessageParcel reply;
83     MessageOption option;
84     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
85     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, data, &want);
86     uint32_t originAbilityInfoSize = static_cast<uint32_t>(originAbilityInfos.size());
87     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Uint32, data, originAbilityInfoSize);
88 
89     for (uint32_t i = 0; i < originAbilityInfos.size(); ++i) {
90         WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, data, &originAbilityInfos[i]);
91     }
92     int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::FILTER_ABILITIES, data, reply, option);
93     if (error != ERR_NONE) {
94         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "FilterAbilities failed, error: %d", error);
95         return false;
96     }
97     bool status = false;
98     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
99     if (!status) {
100         APP_DOMAIN_VERIFY_HILOGE(
101             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "FilterAbilities status failed, error: %d", error);
102         return false;
103     }
104     int32_t infoSize = reply.ReadInt32();
105     if (IsInvalidParcelArraySize(infoSize)) {
106         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
107         return false;
108     }
109     for (int32_t i = 0; i < infoSize; i++) {
110         std::unique_ptr<OHOS::AppExecFwk::AbilityInfo> info(reply.ReadParcelable<OHOS::AppExecFwk::AbilityInfo>());
111         if (info == nullptr) {
112             APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "Read Parcelable AbilityInfo failed");
113             return false;
114         }
115         filtedAbilityInfos.emplace_back(*info);
116     }
117     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
118     return true;
119 }
120 
QueryDomainVerifyStatus(const std::string & bundleName,DomainVerifyStatus & domainVerificationState)121 bool AppDomainVerifyMgrServiceProxy::QueryDomainVerifyStatus(
122     const std::string& bundleName, DomainVerifyStatus& domainVerificationState)
123 {
124     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
125     MessageParcel data;
126     MessageParcel reply;
127     MessageOption option;
128     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
129     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
130 
131     int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::QUERY_VERIFY_STATUS, data, reply, option);
132     if (error != ERR_NONE) {
133         APP_DOMAIN_VERIFY_HILOGE(
134             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryDomainVerifyStatus failed, error: %d", error);
135         return false;
136     }
137     bool status = false;
138     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
139     if (!status) {
140         APP_DOMAIN_VERIFY_HILOGE(
141             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryDomainVerifyStatus status failed, error: %d", error);
142         return false;
143     }
144     domainVerificationState = static_cast<DomainVerifyStatus>(reply.ReadInt32());
145     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
146     return true;
147 }
148 
QueryAllDomainVerifyStatus(BundleVerifyStatusInfo & bundleVerifyStatusInfo)149 bool AppDomainVerifyMgrServiceProxy::QueryAllDomainVerifyStatus(BundleVerifyStatusInfo& bundleVerifyStatusInfo)
150 {
151     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
152     MessageParcel data;
153     MessageParcel reply;
154     MessageOption option;
155     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
156     int32_t error = Remote()->SendRequest(
157         AppDomainVerifyMgrInterfaceCode::QUERY_ALL_VERIFY_STATUS, data, reply, option);
158     if (error != ERR_NONE) {
159         APP_DOMAIN_VERIFY_HILOGE(
160             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAllDomainVerifyStatus failed, error: %d", error);
161         return false;
162     }
163     bool status = false;
164     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
165     if (!status) {
166         APP_DOMAIN_VERIFY_HILOGE(
167             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAllDomainVerifyStatus status failed, error: %d", error);
168         return false;
169     }
170     std::unique_ptr<BundleVerifyStatusInfo> info(reply.ReadParcelable<BundleVerifyStatusInfo>());
171     if (info == nullptr) {
172         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "Read Parcelable BundleVerifyStatusInfo failed");
173         return false;
174     }
175     bundleVerifyStatusInfo.bundleVerifyStatusInfoMap_ = info->bundleVerifyStatusInfoMap_;
176 
177     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
178     return true;
179 }
180 
SaveDomainVerifyStatus(const std::string & bundleName,const VerifyResultInfo & verifyResultInfo)181 bool AppDomainVerifyMgrServiceProxy::SaveDomainVerifyStatus(
182     const std::string& bundleName, const VerifyResultInfo& verifyResultInfo)
183 {
184     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
185     MessageParcel data;
186     MessageParcel reply;
187     MessageOption option;
188     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
189     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, bundleName);
190     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(Parcelable, data, &verifyResultInfo);
191     int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::SAVE_VERIFY_STATUS, data, reply, option);
192     if (error != ERR_NONE) {
193         APP_DOMAIN_VERIFY_HILOGE(
194             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "SaveDomainVerifyStatus failed, error: %d", error);
195         return false;
196     }
197     bool status = false;
198     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
199     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
200     return status;
201 }
IsAtomicServiceUrl(const std::string & url)202 bool AppDomainVerifyMgrServiceProxy::IsAtomicServiceUrl(const std::string& url)
203 {
204     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
205     MessageParcel data;
206     MessageParcel reply;
207     MessageOption option;
208     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(InterfaceToken, data, GetDescriptor());
209     WRITE_PARCEL_AND_RETURN_FALSE_IF_FAIL(String, data, url);
210     int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::IS_ATOMIC_SERVICE_URL, data, reply, option);
211     if (error != ERR_NONE) {
212         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "IsAtomicServiceUrl failed, error: %d", error);
213         return false;
214     }
215     bool status = false;
216     READ_PARCEL_AND_RETURN_FALSE_IF_FAIL(Bool, reply, status);
217     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
218     return status;
219 }
UpdateWhiteListUrls(const std::vector<std::string> & urls)220 void AppDomainVerifyMgrServiceProxy::UpdateWhiteListUrls(const std::vector<std::string>& urls)
221 {
222     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
223     MessageParcel data;
224     MessageParcel reply;
225     MessageOption option;
226     WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
227     WRITE_PARCEL_AND_RETURN_IF_FAIL(Uint32, data, urls.size());
228     for (const auto& url : urls) {
229         WRITE_PARCEL_AND_RETURN_IF_FAIL(String, data, url);
230     }
231     int32_t error = Remote()->SendRequest(AppDomainVerifyMgrInterfaceCode::UPDATE_WHITE_LIST_URLS, data, reply, option);
232     if (error != ERR_NONE) {
233         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "IsAtomicServiceUrl failed, error: %d", error);
234         return;
235     }
236     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
237 }
ConvertToExplicitWant(OHOS::AAFwk::Want & implicitWant,sptr<IConvertCallback> & callback)238 void AppDomainVerifyMgrServiceProxy::ConvertToExplicitWant(
239     OHOS::AAFwk::Want& implicitWant, sptr<IConvertCallback>& callback)
240 {
241     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
242     MessageParcel data;
243     MessageParcel reply;
244     MessageOption option;
245     WRITE_PARCEL_AND_RETURN_IF_FAIL(InterfaceToken, data, GetDescriptor());
246     WRITE_PARCEL_AND_RETURN_IF_FAIL(Parcelable, data, &implicitWant);
247     WRITE_PARCEL_AND_RETURN_IF_FAIL(RemoteObject, data, callback->AsObject());
248 
249     int32_t error = Remote()->SendRequest(
250         AppDomainVerifyMgrInterfaceCode::CONVERT_TO_EXPLICIT_WANT, data, reply, option);
251     if (error != ERR_NONE) {
252         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "ConvertToExplicitWant failed, error: %d", error);
253     }
254     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
255 }
QueryAssociatedDomains(const std::string & bundleName,std::vector<std::string> & domains)256 int AppDomainVerifyMgrServiceProxy::QueryAssociatedDomains(
257     const std::string& bundleName, std::vector<std::string>& domains)
258 {
259     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
260     MessageParcel data;
261     MessageParcel reply;
262     MessageOption option;
263     WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor());
264     WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, bundleName);
265 
266     int32_t error = Remote()->SendRequest(
267         AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_DOMAINS, data, reply, option);
268     if (error != ERR_NONE) {
269         APP_DOMAIN_VERIFY_HILOGE(
270             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAssociatedDomains failed, error: %d", error);
271     }
272     int32_t result = reply.ReadInt32();
273     if (result != 0) {
274         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result);
275         return result;
276     }
277     int32_t size = reply.ReadInt32();
278     if (IsInvalidParcelArraySize(size)) {
279         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
280         return ERR_INVALID_VALUE;
281     }
282     domains.clear();
283     for (int32_t i = 0; i < size; i++) {
284         std::string domain;
285         READ_PARCEL_AND_RETURN_INT_IF_FAIL(String, reply, domain);
286         domains.emplace_back(domain);
287     }
288     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
289     return result;
290 }
QueryAssociatedBundleNames(const std::string & domain,std::vector<std::string> & bundleNames)291 int AppDomainVerifyMgrServiceProxy::QueryAssociatedBundleNames(
292     const std::string& domain, std::vector<std::string>& bundleNames)
293 {
294     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "called");
295     MessageParcel data;
296     MessageParcel reply;
297     MessageOption option;
298     WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(InterfaceToken, data, GetDescriptor());
299     WRITE_PARCEL_AND_RETURN_INT_IF_FAIL(String, data, domain);
300 
301     int32_t error = Remote()->SendRequest(
302         AppDomainVerifyMgrInterfaceCode::QUERY_ASSOCIATED_BUNDLE_NAMES, data, reply, option);
303     if (error != ERR_NONE) {
304         APP_DOMAIN_VERIFY_HILOGE(
305             APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "QueryAssociatedBundleNames failed, error: %d", error);
306     }
307     int32_t result = reply.ReadInt32();
308     if (result != 0) {
309         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "result failed, result: %d", result);
310         return result;
311     }
312     int32_t size = reply.ReadInt32();
313     if (IsInvalidParcelArraySize(size)) {
314         APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MGR_MODULE_SERVICE, "read parcelable size invalid.");
315         return E_INTERNAL_ERR;
316     }
317     bundleNames.clear();
318     for (int32_t i = 0; i < size; i++) {
319         std::string bundleName;
320         READ_PARCEL_AND_RETURN_INT_IF_FAIL(String, reply, bundleName);
321         bundleNames.emplace_back(bundleName);
322     }
323     APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MGR_MODULE_CLIENT, "call end");
324     return result;
325 }
326 }  // namespace AppDomainVerify
327 }  // namespace OHOS
328