1 /*
2 * Copyright (c) 2024 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 #define LOG_TAG "DataProviderConfig"
16
17 #include "data_provider_config.h"
18
19 #include <vector>
20
21 #include "accesstoken_kit.h"
22 #include "account/account_delegate.h"
23 #include "config_factory.h"
24 #include "datashare_errno.h"
25 #include "hap_token_info.h"
26 #include "ipc_skeleton.h"
27 #include "log_print.h"
28 #include "strategies/general/load_config_common_strategy.h"
29 #include "tokenid_kit.h"
30 #include "utils.h"
31 #include "utils/anonymous.h"
32
33 namespace OHOS::DataShare {
34 using namespace OHOS::DistributedData;
DataProviderConfig(const std::string & uri,uint32_t callerTokenId)35 DataProviderConfig::DataProviderConfig(const std::string &uri, uint32_t callerTokenId)
36 {
37 providerInfo_.uri = uri;
38 providerInfo_.currentUserId = AccountDelegate::GetInstance()->GetUserByToken(callerTokenId);
39 providerInfo_.visitedUserId = providerInfo_.currentUserId;
40 URIUtils::GetAppIndexFromProxyURI(providerInfo_.uri, providerInfo_.appIndex);
41 if (providerInfo_.currentUserId == 0) {
42 LoadConfigCommonStrategy::GetInfoFromProxyURI(providerInfo_.uri, providerInfo_.visitedUserId,
43 callerTokenId, providerInfo_.bundleName);
44 URIUtils::FormatUri(providerInfo_.uri);
45 // if visitedUserId is 0, set current foreground userId as visitedUserId
46 if (providerInfo_.visitedUserId == 0) {
47 if (!(AccountDelegate::GetInstance()->QueryForegroundUserId(providerInfo_.visitedUserId))) {
48 ZLOGE("Get foreground userId failed");
49 }
50 }
51 } else {
52 auto [success, data] = URIUtils::GetUserFromProxyURI(providerInfo_.uri);
53 if (success) {
54 // if data is -1, it means visiting provider's user
55 providerInfo_.visitedUserId = (data == -1 ? providerInfo_.currentUserId : data);
56 } else {
57 providerInfo_.visitedUserId = -1;
58 }
59 }
60 uriConfig_ = URIUtils::GetUriConfig(providerInfo_.uri);
61 }
62
GetBundleInfo()63 std::pair<int, BundleConfig> DataProviderConfig::GetBundleInfo()
64 {
65 BundleConfig bundleInfo;
66 providerInfo_.bundleName = uriConfig_.authority;
67 if (providerInfo_.bundleName.empty()) {
68 if (uriConfig_.pathSegments.empty()) {
69 return std::make_pair(E_URI_NOT_EXIST, bundleInfo);
70 }
71 providerInfo_.bundleName = uriConfig_.pathSegments[0];
72 }
73 auto ret = BundleMgrProxy::GetInstance()->GetBundleInfoFromBMSWithCheck(
74 providerInfo_.bundleName, providerInfo_.visitedUserId, bundleInfo, providerInfo_.appIndex);
75 return std::make_pair(ret, bundleInfo);
76 }
77
GetFromProxyData()78 int DataProviderConfig::GetFromProxyData()
79 {
80 auto [errCode, bundleInfo] = GetBundleInfo();
81 if (errCode != E_OK) {
82 ZLOGE("Get bundleInfo failed! bundleName:%{public}s, userId:%{public}d, visitedId:%{public}d, uri:%{public}s",
83 providerInfo_.bundleName.c_str(), providerInfo_.currentUserId, providerInfo_.visitedUserId,
84 URIUtils::Anonymous(providerInfo_.uri).c_str());
85 return errCode;
86 }
87 providerInfo_.singleton = bundleInfo.singleton;
88 for (auto &item : bundleInfo.extensionInfos) {
89 if (item.type != AppExecFwk::ExtensionAbilityType::DATASHARE) {
90 continue;
91 }
92 providerInfo_.hasExtension = true;
93 break;
94 }
95 for (auto &hapModuleInfo : bundleInfo.hapModuleInfos) {
96 auto &proxyDatas = hapModuleInfo.proxyDatas;
97 std::sort(proxyDatas.begin(), proxyDatas.end(), [](const ProxyData &curr,
98 const ProxyData &prev) {
99 return curr.uri.length() > prev.uri.length();
100 });
101 for (auto &data : proxyDatas) {
102 if (data.uri.length() > uriConfig_.formatUri.length() ||
103 uriConfig_.formatUri.compare(0, data.uri.length(), data.uri) != 0) {
104 continue;
105 }
106 providerInfo_.readPermission = std::move(data.requiredReadPermission);
107 providerInfo_.writePermission = std::move(data.requiredWritePermission);
108 providerInfo_.allowLists = std::move(data.profileInfo.profile.allowLists);
109 auto profileInfo = data.profileInfo;
110 if (profileInfo.resultCode == NOT_FOUND) {
111 return E_OK;
112 }
113 if (profileInfo.resultCode == ERROR) {
114 ZLOGE("Profile unmarshall error.uri: %{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
115 return E_ERROR;
116 }
117 return GetFromDataProperties(profileInfo.profile, hapModuleInfo.moduleName);
118 }
119 }
120 return E_URI_NOT_EXIST;
121 }
122
GetFromDataProperties(const ProfileInfo & profileInfo,const std::string & moduleName)123 int DataProviderConfig::GetFromDataProperties(const ProfileInfo &profileInfo,
124 const std::string &moduleName)
125 {
126 if (profileInfo.scope == MODULE_SCOPE) {
127 providerInfo_.moduleName = moduleName;
128 }
129 providerInfo_.storeName = profileInfo.storeName;
130 providerInfo_.tableName = profileInfo.tableName;
131 providerInfo_.type = profileInfo.type;
132 providerInfo_.storeMetaDataFromUri = profileInfo.storeMetaDataFromUri;
133 providerInfo_.backup = profileInfo.backup;
134 providerInfo_.extensionUri = profileInfo.extUri;
135 if (profileInfo.tableConfig.empty()) {
136 return E_OK;
137 }
138 return GetFromExtensionProperties(profileInfo, moduleName);
139 }
140
GetFromExtensionProperties(const ProfileInfo & profileInfo,const std::string & moduleName)141 int DataProviderConfig::GetFromExtensionProperties(const ProfileInfo &profileInfo,
142 const std::string &moduleName)
143 {
144 std::string storeUri = URIUtils::DATA_SHARE_SCHEMA + providerInfo_.bundleName + URIUtils::URI_SEPARATOR +
145 moduleName + URIUtils::URI_SEPARATOR + providerInfo_.storeName;
146 std::string tableUri = storeUri + URIUtils::URI_SEPARATOR + providerInfo_.tableName;
147 providerInfo_.accessCrossMode = DataShareProfileConfig::GetAccessCrossMode(profileInfo, tableUri, storeUri);
148 if (providerInfo_.singleton && providerInfo_.accessCrossMode == AccessCrossMode::USER_UNDEFINED) {
149 ZLOGE("Single app must config user cross mode,bundleName:%{public}s, uri:%{public}s",
150 providerInfo_.bundleName.c_str(), URIUtils::Anonymous(providerInfo_.uri).c_str());
151 return E_ERROR;
152 }
153 if (providerInfo_.singleton && providerInfo_.accessCrossMode == AccessCrossMode::USER_SINGLE) {
154 providerInfo_.tableName.append("_").append(std::to_string(providerInfo_.visitedUserId));
155 }
156 return E_OK;
157 }
158
GetFromExtension()159 int DataProviderConfig::GetFromExtension()
160 {
161 providerInfo_.isFromExtension = true;
162 if (!GetFromUriPath()) {
163 ZLOGE("Uri path failed! uri:%{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
164 return E_URI_NOT_EXIST;
165 }
166 BundleConfig bundleInfo;
167 auto ret = BundleMgrProxy::GetInstance()->GetBundleInfoFromBMSWithCheck(
168 providerInfo_.bundleName, providerInfo_.visitedUserId, bundleInfo, providerInfo_.appIndex);
169 if (ret != E_OK) {
170 ZLOGE("BundleInfo failed! bundleName: %{public}s", providerInfo_.bundleName.c_str());
171 return ret;
172 }
173 providerInfo_.singleton = bundleInfo.singleton;
174 providerInfo_.allowEmptyPermission = true;
175 for (auto &item : bundleInfo.extensionInfos) {
176 if (item.type != AppExecFwk::ExtensionAbilityType::DATASHARE) {
177 continue;
178 }
179 providerInfo_.hasExtension = true;
180 providerInfo_.readPermission = std::move(item.readPermission);
181 providerInfo_.writePermission = std::move(item.writePermission);
182 auto profileInfo = item.profileInfo;
183 if (profileInfo.resultCode == NOT_FOUND) {
184 return E_OK;
185 }
186 if (profileInfo.resultCode == ERROR) {
187 ZLOGE("Profile Unmarshall failed! uri:%{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
188 return E_ERROR;
189 }
190 return GetFromExtensionProperties(profileInfo.profile, providerInfo_.moduleName);
191 }
192 return E_URI_NOT_EXIST;
193 }
194
GetFromUriPath()195 bool DataProviderConfig::GetFromUriPath()
196 {
197 auto& pathSegments = uriConfig_.pathSegments;
198 if (pathSegments.size() < static_cast<std::size_t>(PATH_PARAM::PARAM_SIZE) ||
199 pathSegments[static_cast<std::size_t>(PATH_PARAM::BUNDLE_NAME)].empty() ||
200 pathSegments[static_cast<std::size_t>(PATH_PARAM::MODULE_NAME)].empty() ||
201 pathSegments[static_cast<std::size_t>(PATH_PARAM::STORE_NAME)].empty() ||
202 pathSegments[static_cast<std::size_t>(PATH_PARAM::TABLE_NAME)].empty()) {
203 ZLOGE("Invalid uri ! uri: %{public}s", URIUtils::Anonymous(providerInfo_.uri).c_str());
204 return false;
205 }
206 providerInfo_.bundleName = pathSegments[static_cast<std::size_t>(PATH_PARAM::BUNDLE_NAME)];
207 providerInfo_.moduleName = pathSegments[static_cast<std::size_t>(PATH_PARAM::MODULE_NAME)];
208 providerInfo_.storeName = pathSegments[static_cast<std::size_t>(PATH_PARAM::STORE_NAME)];
209 providerInfo_.tableName = pathSegments[static_cast<std::size_t>(PATH_PARAM::TABLE_NAME)];
210 return true;
211 }
212
GetMetaDataFromUri()213 void DataProviderConfig::GetMetaDataFromUri()
214 {
215 if (!providerInfo_.storeMetaDataFromUri) {
216 return;
217 }
218 if (!GetFromUriPath()) {
219 ZLOGE("Uri path failed, not change metaData from uri! uri:%{public}s",
220 URIUtils::Anonymous(providerInfo_.uri).c_str());
221 }
222 }
223
GetProviderInfo()224 std::pair<int, DataProviderConfig::ProviderInfo> DataProviderConfig::GetProviderInfo()
225 {
226 if (providerInfo_.appIndex == -1) {
227 return std::make_pair(E_APPINDEX_INVALID, providerInfo_);
228 }
229 if (providerInfo_.visitedUserId == -1) {
230 return std::make_pair(E_INVALID_USER_ID, providerInfo_);
231 }
232 auto ret = GetFromProxyData();
233 if (ret == E_OK) {
234 GetMetaDataFromUri();
235 return std::make_pair(ret, providerInfo_);
236 }
237 if (ret != E_URI_NOT_EXIST) {
238 return std::make_pair(ret, providerInfo_);
239 }
240 auto fullTokenId = IPCSkeleton::GetCallingFullTokenID();
241 Security::AccessToken::HapTokenInfo tokenInfo;
242 auto result = Security::AccessToken::AccessTokenKit::GetHapTokenInfo(IPCSkeleton::GetCallingTokenID(), tokenInfo);
243 if (!Security::AccessToken::TokenIdKit::IsSystemAppByFullTokenID(fullTokenId)
244 || (result == Security::AccessToken::RET_SUCCESS && !IsInExtList(tokenInfo.bundleName))) {
245 ZLOGE("The URI in the extension, is not allowed for silent access.! ret: %{public}d, bundleName: %{public}s,"
246 "uri: %{public}s", ret, tokenInfo.bundleName.c_str(), URIUtils::Anonymous(providerInfo_.uri).c_str());
247 }
248 ret = GetFromExtension();
249 if (ret != E_OK) {
250 ZLOGE("Get providerInfo failed! ret: %{public}d, uri: %{public}s",
251 ret, URIUtils::Anonymous(providerInfo_.uri).c_str());
252 }
253 return std::make_pair(ret, providerInfo_);
254 }
255
IsInExtList(const std::string & bundleName)256 bool DataProviderConfig::IsInExtList(const std::string &bundleName)
257 {
258 DataShareConfig *config = ConfigFactory::GetInstance().GetDataShareConfig();
259 if (config == nullptr) {
260 return true;
261 }
262 std::vector<std::string>& extNames = config->dataShareExtNames;
263 return std::find(extNames.begin(), extNames.end(), bundleName) != extNames.end();
264 }
265 } // namespace OHOS::DataShare
266