1 /*
2  * Copyright (c) 2022-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 
16 #ifndef OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_STUB_IMPL_H
17 #define OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_STUB_IMPL_H
18 
19 #include <functional>
20 #include <map>
21 #include <vector>
22 #include <unordered_set>
23 
24 #include "app_mgr_interface.h"
25 #include "istorage_manager.h"
26 #include "tokenid_permission.h"
27 #include "uri.h"
28 #include "uri_permission_manager_stub.h"
29 
30 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
31 #include "policy_info.h"
32 #include "sandbox_manager_kit.h"
33 #else
34 #include "upms_policy_info.h"
35 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
36 
37 namespace OHOS::AAFwk {
38 namespace {
39 using ClearProxyCallback = std::function<void(const wptr<IRemoteObject>&)>;
40 using TokenId = Security::AccessToken::AccessTokenID;
41 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
42 using namespace AccessControl::SandboxManager;
43 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
44 
45 constexpr int32_t DEFAULT_ABILITY_ID = -1;
46 }
47 
48 struct GrantInfo {
49     unsigned int flag;
50     const uint32_t fromTokenId;
51     const uint32_t targetTokenId;
52     bool autoRemove;
53     std::unordered_set<int32_t> abilityIds;
54 
AddAbilityIdGrantInfo55     void AddAbilityId(int32_t abilityId)
56     {
57         if (abilityId != DEFAULT_ABILITY_ID) {
58             abilityIds.insert(abilityId);
59         }
60     }
61 
RemoveAbilityIdGrantInfo62     bool RemoveAbilityId(int32_t abilityId)
63     {
64         return abilityIds.erase(abilityId) > 0;
65     }
66 
IsEmptyAbilityIdGrantInfo67     bool IsEmptyAbilityId()
68     {
69         return abilityIds.empty();
70     }
71 
ClearAbilityIdsGrantInfo72     void ClearAbilityIds()
73     {
74         abilityIds.clear();
75     }
76 };
77 
78 class UriPermissionManagerStubImpl : public UriPermissionManagerStub,
79                                      public std::enable_shared_from_this<UriPermissionManagerStubImpl> {
80 public:
81     UriPermissionManagerStubImpl() = default;
82     virtual ~UriPermissionManagerStubImpl() = default;
83 
84     int GrantUriPermission(const Uri &uri, unsigned int flag, const std::string targetBundleName,
85         int32_t appIndex = 0, uint32_t initiatorTokenId = 0, int32_t abilityId = -1) override;
86     int GrantUriPermission(const std::vector<Uri> &uriVec, unsigned int flag,
87         const std::string targetBundleName, int32_t appIndex = 0, uint32_t initiatorTokenId = 0,
88         int32_t abilityId = -1) override;
89     int32_t GrantUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
90         const std::string &targetBundleName, int32_t appIndex, uint32_t initiatorTokenId,
91         int32_t abilityId) override;
92 
93     std::vector<bool> CheckUriAuthorization(const std::vector<std::string> &uriVec, uint32_t flag,
94         uint32_t tokenId) override;
95 
96     // only for foundation calling
97     void RevokeUriPermission(const TokenId tokenId, int32_t abilityId = -1) override;
98     int RevokeAllUriPermissions(uint32_t tokenId) override;
99     int RevokeUriPermissionManually(const Uri &uri, const std::string bundleName,
100         int32_t appIndex = 0) override;
101 
102     bool VerifyUriPermission(const Uri &uri, uint32_t flag, uint32_t tokenId) override;
103 
104 private:
105     template<typename T>
106     void ConnectManager(sptr<T> &mgr, int32_t serviceId);
107     int GrantUriPermissionImpl(const Uri &uri, unsigned int flag,
108         TokenId fromTokenId, TokenId targetTokenId, int32_t abilityId);
109     int AddTempUriPermission(const std::string &uri, unsigned int flag, TokenId fromTokenId,
110         TokenId targetTokenId, int32_t abilityId);
111 
112     int GrantBatchUriPermissionImpl(const std::vector<std::string> &uriVec, unsigned int flag,
113         TokenId initiatorTokenId, TokenId targetTokenId, int32_t abilityId);
114     int GrantBatchUriPermission(const std::vector<Uri> &uriVec, unsigned int flag, uint32_t initiatorTokenId,
115         uint32_t targetTokenId, int32_t abilityId);
116 
117     int32_t GrantBatchUriPermissionPrivileged(const std::vector<Uri> &uriVec, uint32_t flag,
118         uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId = -1);
119 
120     int32_t GrantBatchUriPermissionFor2In1Privileged(const std::vector<Uri> &uriVec, uint32_t flag,
121         uint32_t callerTokenId, uint32_t targetTokenId, int32_t abilityId = -1);
122 
123     int GrantSingleUriPermission(const Uri &uri, unsigned int flag, uint32_t callerTokenId, uint32_t targetTokenId,
124         int32_t abilityId);
125 
126     int32_t CheckCalledBySandBox();
127 
128     std::vector<bool> CheckUriPermission(TokenIdPermission &tokenIdPermission, const std::vector<Uri> &uriVec,
129         uint32_t flag);
130 
131     bool CheckUriTypeIsValid(Uri uri);
132 
133     int GrantUriPermissionInner(const std::vector<Uri> &uriVec, unsigned int flag, const std::string targetBundleName,
134         int32_t appIndex, uint32_t initiatorTokenId, int32_t abilityId = -1);
135 
136     int GrantUriPermissionFor2In1Inner(const std::vector<Uri> &uriVec, unsigned int flag,
137         const std::string &targetBundleName, int32_t appIndex, bool isSystemAppCall, uint32_t initiatorTokenId = 0,
138         int32_t abilityId = -1);
139 
140     void HandleUriPermission(
141         uint64_t tokenId, unsigned int flag, std::vector<PolicyInfo> &docsVec, bool isSystemAppCall);
142 
143     void CheckProxyUriPermission(TokenIdPermission &tokenIdPermission, const std::vector<Uri> &uriVec, uint32_t flag,
144         std::vector<bool> &result);
145 
146     int32_t DeleteShareFile(uint32_t targetTokenId, const std::vector<std::string> &uriVec);
147 
148     void RemoveUriRecord(std::vector<std::string> &uriList, const TokenId tokenId, int32_t abilityId);
149 
150     bool VerifySubDirUriPermission(const std::string &uriStr, uint32_t newFlag, uint32_t tokenId);
151 
152     bool IsDistributedSubDirUri(const std::string &inputUri, const std::string &cachedUri);
153 
154     int32_t ClearPermissionTokenByMap(const uint32_t tokenId) override;
155 
156 #ifdef ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
157     int32_t Active(const std::vector<PolicyInfo> &policy, std::vector<uint32_t> &result) override;
158 #endif // ABILITY_RUNTIME_FEATURE_SANDBOXMANAGER
159 
160     class ProxyDeathRecipient : public IRemoteObject::DeathRecipient {
161     public:
ProxyDeathRecipient(ClearProxyCallback && proxy)162         explicit ProxyDeathRecipient(ClearProxyCallback&& proxy) : proxy_(proxy) {}
163         ~ProxyDeathRecipient() = default;
164         virtual void OnRemoteDied([[maybe_unused]] const wptr<IRemoteObject>& remote) override;
165 
166     private:
167         ClearProxyCallback proxy_;
168     };
169 
170 private:
171     std::map<std::string, std::list<GrantInfo>> uriMap_;
172     std::mutex mutex_;
173     std::mutex mgrMutex_;
174     sptr<AppExecFwk::IAppMgr> appMgr_ = nullptr;
175     sptr<StorageManager::IStorageManager> storageManager_ = nullptr;
176     std::set<uint32_t> permissionTokenMap_;
177     std::mutex ptMapMutex_;
178 };
179 }  // namespace OHOS::AAFwk
180 #endif  // OHOS_ABILITY_RUNTIME_URI_PERMISSION_MANAGER_STUB_IMPL_H
181