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 "bms/bundle_info_query.h"
17 #include "os_account_manager.h"
18 #include "app_domain_verify_hilog.h"
19 #include "system_ability_definition.h"
20 #include "iservice_registry.h"
21 #include "app_domain_verify_hisysevent.h"
22 #include "ipc_skeleton.h"
23
24 namespace OHOS {
25 namespace AppDomainVerify {
GetBundleInfo(const std::string & bundleName,std::string & appIdentifier,std::string & fingerprint)26 bool BundleInfoQuery::GetBundleInfo(const std::string& bundleName, std::string& appIdentifier, std::string& fingerprint)
27 {
28 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "called");
29 sptr<AppExecFwk::IBundleMgr> bundleMgrProxy = GetBundleMgrProxy();
30
31 if (bundleMgrProxy == nullptr) {
32 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "bundleMgrProxy is nullptr.");
33 UNIVERSAL_ERROR_EVENT(CONNECT_OTHER_FAULT);
34 return false;
35 }
36 int32_t userId = GetCurrentAccountId();
37 if (userId < 0) {
38 return false;
39 }
40 OHOS::AppExecFwk::BundleInfo bundleInfo;
41 // use sa identity
42 std::string identity = IPCSkeleton::ResetCallingIdentity();
43 auto ret = bundleMgrProxy->GetBundleInfoV9(bundleName,
44 static_cast<int32_t>(AppExecFwk::GetBundleInfoFlag::GET_BUNDLE_INFO_WITH_SIGNATURE_INFO), bundleInfo, userId);
45 IPCSkeleton::SetCallingIdentity(identity);
46 if (ret != ERR_OK) {
47 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "GetBundleInfo failed, ret: %{public}d.", ret);
48 return false;
49 }
50 appIdentifier = bundleInfo.signatureInfo.appIdentifier;
51 fingerprint = bundleInfo.signatureInfo.fingerprint;
52 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "call end");
53 return true;
54 }
55
GetBundleMgrProxy()56 sptr<AppExecFwk::IBundleMgr> BundleInfoQuery::GetBundleMgrProxy()
57 {
58 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "called");
59 sptr<ISystemAbilityManager> systemAbilityManager =
60 SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
61 if (!systemAbilityManager) {
62 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "GetBundleMgrProxy, systemAbilityManager is null");
63 return nullptr;
64 }
65 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
66 if (!remoteObject) {
67 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "GetBundleMgrProxy, remoteObject is null");
68 return nullptr;
69 }
70 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "call end");
71 return iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
72 }
73
GetCurrentAccountId()74 int32_t BundleInfoQuery::GetCurrentAccountId()
75 {
76 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "called");
77 std::vector<int32_t> osAccountIds;
78 // use sa identity
79 std::string identity = IPCSkeleton::ResetCallingIdentity();
80 ErrCode ret = AccountSA::OsAccountManager::QueryActiveOsAccountIds(osAccountIds);
81 IPCSkeleton::SetCallingIdentity(identity);
82 if (ret != ERR_OK) {
83 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "QueryActiveOsAccountIds failed.");
84 return -1;
85 }
86
87 if (osAccountIds.empty()) {
88 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "osAccountInfos is empty, no accounts.");
89 return -1;
90 }
91
92 auto iter = std::find_if(
93 osAccountIds.cbegin(), osAccountIds.cend(), [](const int32_t& accountId) { return accountId >= 0; });
94 if (iter != osAccountIds.end()) {
95 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "call end");
96 return *iter;
97 }
98 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "GetCurrentAccountId failed, no osAccountIds now.");
99 return -1;
100 }
GetBundleNameForUid(const int uid,std::string & bundleName)101 bool BundleInfoQuery::GetBundleNameForUid(const int uid, std::string& bundleName)
102 {
103 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "called");
104 sptr<AppExecFwk::IBundleMgr> bundleMgrProxy = GetBundleMgrProxy();
105
106 if (bundleMgrProxy == nullptr) {
107 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "bundleMgrProxy is nullptr.");
108 UNIVERSAL_ERROR_EVENT(CONNECT_OTHER_FAULT);
109 return false;
110 }
111
112 // use sa identity
113 std::string identity = IPCSkeleton::ResetCallingIdentity();
114 auto ret = bundleMgrProxy->GetBundleNameForUid(uid, bundleName);
115 IPCSkeleton::SetCallingIdentity(identity);
116 if (!ret) {
117 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "GetBundleInfo failed, ret: %{public}d.", ret);
118 return false;
119 }
120 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "call end");
121 return true;
122 }
123
GetBundleAbilityInfos(const std::string & bundleName,std::vector<AbilityInfo> & abilityInfos)124 bool BundleInfoQuery::GetBundleAbilityInfos(const std::string& bundleName, std::vector<AbilityInfo>& abilityInfos)
125 {
126 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "called");
127 sptr<AppExecFwk::IBundleMgr> bundleMgrProxy = GetBundleMgrProxy();
128
129 if (bundleMgrProxy == nullptr) {
130 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "bundleMgrProxy is nullptr.");
131 UNIVERSAL_ERROR_EVENT(CONNECT_OTHER_FAULT);
132 return false;
133 }
134
135 AppExecFwk::BundleInfo bundleInfo;
136 // use sa identity
137 std::string identity = IPCSkeleton::ResetCallingIdentity();
138 auto ret = bundleMgrProxy->GetBundleInfo(bundleName,
139 AppExecFwk::BundleFlag::GET_BUNDLE_WITH_ABILITIES | AppExecFwk::BundleFlag::GET_BUNDLE_WITH_SKILL, bundleInfo,
140 AppExecFwk::Constants::ANY_USERID);
141 IPCSkeleton::SetCallingIdentity(identity);
142 if (!ret) {
143 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "GetBundleInfo failed, ret: %{public}d.", ret);
144 return false;
145 }
146 abilityInfos = bundleInfo.abilityInfos;
147 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "call end");
148 return true;
149 }
QueryAbilityInfos(const std::string & url,bool withDefault,std::vector<AbilityInfo> & abilityInfos,bool & findDefaultApp)150 bool BundleInfoQuery::QueryAbilityInfos(
151 const std::string& url, bool withDefault, std::vector<AbilityInfo>& abilityInfos, bool& findDefaultApp)
152 {
153 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON, "called");
154 sptr<AppExecFwk::IBundleMgr> bundleMgrProxy = GetBundleMgrProxy();
155
156 if (bundleMgrProxy == nullptr) {
157 APP_DOMAIN_VERIFY_HILOGE(APP_DOMAIN_VERIFY_MODULE_COMMON, "bundleMgrProxy is nullptr.");
158 UNIVERSAL_ERROR_EVENT(CONNECT_OTHER_FAULT);
159 return false;
160 }
161
162 Want uriWant;
163 uriWant.SetUri(url);
164 uriWant.SetAction(ACTION_VIEW_DATA);
165 uriWant.SetEntities({ ENTITY_BROWSER });
166
167 std::vector<AppExecFwk::ExtensionAbilityInfo> extensionAbilityInfo;
168 // use sa identity
169 std::string identity = IPCSkeleton::ResetCallingIdentity();
170 auto ret = bundleMgrProxy->ImplicitQueryInfos(uriWant, AppExecFwk::BundleFlag::GET_BUNDLE_WITH_ABILITIES,
171 AppExecFwk::Constants::ANY_USERID, withDefault, abilityInfos, extensionAbilityInfo, findDefaultApp);
172 IPCSkeleton::SetCallingIdentity(identity);
173 APP_DOMAIN_VERIFY_HILOGD(APP_DOMAIN_VERIFY_MODULE_COMMON,
174 "ImplicitQueryInfos withDefault:%{public}d, size:%{public}zu findDefaultApp:%{public}d", withDefault,
175 abilityInfos.size(), findDefaultApp);
176 return ret;
177 }
178 }
179 }